igb: misc whitespace/formatting cleanups

 *

 * Return 0 on success, negative on failure

 **/

int igb_setup_tx_resources(struct igb_adapter *adapter,

			   struct igb_ring *tx_ring)

{

	int i, j;

	for (i = 0; i < adapter->num_tx_queues; i++) {

		struct igb_ring *ring = &(adapter->tx_ring[i]);

		struct igb_ring *ring = &adapter->tx_ring[i];

		j = ring->reg_idx;

		wr32(E1000_TDLEN(j),

		     ring->count * sizeof(struct e1000_tx_desc));

		wr32(E1000_DCA_TXCTRL(j), txctrl);

	}

	/* Use the default values for the Tx Inter Packet Gap (IPG) timer */

	/* Program the Transmit Control Register */

 *

 * Returns 0 on success, negative on failure

 **/

int igb_setup_rx_resources(struct igb_adapter *adapter,

			   struct igb_ring *rx_ring)

{

	/* Setup the HW Rx Head and Tail Descriptor Pointers and

	 * the Base and Length of the Rx Descriptor Ring */

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

		struct igb_ring *ring = &(adapter->rx_ring[i]);

		struct igb_ring *ring = &adapter->rx_ring[i];

		j = ring->reg_idx;

		rdba = ring->dma;

		wr32(E1000_RDBAL(j),

		buffer_info->skb = NULL;

	}

	buffer_info->time_stamp = 0;

	buffer_info->next_to_watch = 0;

	/* buffer_info must be completely set up in the transmit path */

}

					    adapter->tx_itr,

					    adapter->tx_ring->total_packets,

					    adapter->tx_ring->total_bytes);

		current_itr = max(adapter->rx_itr, adapter->tx_itr);

	} else {

		current_itr = adapter->rx_itr;

	}

	/* conservative mode (itr 3) eliminates the lowest_latency setting */

	if (adapter->itr_setting == 3 &&

	    current_itr == lowest_latency)

	if (adapter->itr_setting == 3 && current_itr == lowest_latency)

		current_itr = low_latency;

	switch (current_itr) {

	mss_l4len_idx = (skb_shinfo(skb)->gso_size << E1000_ADVTXD_MSS_SHIFT);

	mss_l4len_idx |= (l4len << E1000_ADVTXD_L4LEN_SHIFT);

	/* Context index must be unique per ring. */

	/* For 82575, context index must be unique per ring. */

	if (adapter->flags & IGB_FLAG_NEED_CTX_IDX)

		mss_l4len_idx |= tx_ring->queue_index << 4;

		return true;

	}

	return false;

}

		tx_flags |= IGB_TX_FLAGS_IPV4;

	first = tx_ring->next_to_use;

	tso = skb_is_gso(skb) ? igb_tso_adv(adapter, tx_ring, skb, tx_flags,

					      &hdr_len) : 0;

 * Returns the address of the device statistics structure.

 * The statistics are actually updated from the timer callback.

 **/

static struct net_device_stats *

igb_get_stats(struct net_device *netdev)

static struct net_device_stats *igb_get_stats(struct net_device *netdev)

{

	struct igb_adapter *adapter = netdev_priv(netdev);

	while (test_and_set_bit(__IGB_RESETTING, &adapter->state))

		msleep(1);

	/* igb_down has a dependency on max_frame_size */

	adapter->max_frame_size = max_frame;

	if (netif_running(netdev))

	/* Phy Stats */

	if (hw->phy.media_type == e1000_media_type_copper) {

		if ((adapter->link_speed == SPEED_1000) &&

		   (!igb_read_phy_reg(hw, PHY_1000T_STATUS,

					      &phy_tmp))) {

		   (!igb_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {

			phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;

			adapter->phy_stats.idle_errors += phy_tmp;

		}

	adapter->stats.mgpdc += rd32(E1000_MGTPDC);

}

static irqreturn_t igb_msix_other(int irq, void *data)

{

	struct net_device *netdev = data;

	if (adapter->flags & IGB_FLAG_DCA_ENABLED)

		igb_update_tx_dca(tx_ring);

#endif

	tx_ring->total_bytes = 0;

	tx_ring->total_packets = 0;

	if ((ring->adapter->itr_setting & 3) && ring->set_itr) {

		switch (hw->mac.type) {

		case e1000_82576:

			wr32(ring->itr_register,

			     ring->itr_val |

			wr32(ring->itr_register, ring->itr_val |

			     0x80000000);

			break;

		default:

			wr32(ring->itr_register,

			     ring->itr_val |

			wr32(ring->itr_register, ring->itr_val |

			     (ring->itr_val << 16));

			break;

		}

#endif

	igb_clean_rx_irq_adv(rx_ring, &work_done, budget);

	/* If not enough Rx work done, exit the polling mode */

	if ((work_done == 0) || !netif_running(netdev)) {

		napi_complete(napi);

			else

				igb_update_ring_itr(rx_ring);

		}

		if (!test_bit(__IGB_DOWN, &adapter->state))

			wr32(E1000_EIMS, rx_ring->eims_value);

			if (i == tx_ring->count)

				i = 0;

		}

		eop = tx_ring->buffer_info[i].next_to_watch;

		eop_desc = E1000_TX_DESC_ADV(*tx_ring, eop);

	}

 * igb_receive_skb - helper function to handle rx indications

 * @ring: pointer to receive ring receving this packet

 * @status: descriptor status field as written by hardware

 * @vlan: descriptor vlan field as written by hardware (no le/be conversion)

 * @rx_desc: receive descriptor containing vlan and type information.

 * @skb: pointer to sk_buff to be indicated to stack

 **/

static void igb_receive_skb(struct igb_ring *ring, u8 status,

	}

}

static inline void igb_rx_checksum_adv(struct igb_adapter *adapter,

				       u32 status_err, struct sk_buff *skb)

{

	union e1000_adv_rx_desc *rx_desc , *next_rxd;

	struct igb_buffer *buffer_info , *next_buffer;

	struct sk_buff *skb;

	unsigned int i;

	u32 length, hlen, staterr;

	bool cleaned = false;

	int cleaned_count = 0;

	unsigned int total_bytes = 0, total_packets = 0;

	unsigned int i;

	u32 length, hlen, staterr;

	i = rx_ring->next_to_clean;

	buffer_info = &rx_ring->buffer_info[i];

		if (!skb_shinfo(skb)->nr_frags) {

			pci_unmap_single(pdev, buffer_info->dma,

					 adapter->rx_ps_hdr_size +

					   NET_IP_ALIGN,

					 adapter->rx_ps_hdr_size + NET_IP_ALIGN,

					 PCI_DMA_FROMDEVICE);

			skb_put(skb, hlen);

		}

	return cleaned;

}

/**

 * igb_alloc_rx_buffers_adv - Replace used receive buffers; packet split

 * @adapter: address of board private structure

	return 0;

}

static int igb_suspend(struct pci_dev *pdev, pm_message_t state)

{

	struct net_device *netdev = pci_get_drvdata(pdev);