gianfar: various coding style and whitespace cleanups (bc4598bc) · Commits · 戴 / test

drivers/net/ethernet/freescale/gianfar.c

+154 −144

Original line number	Diff line number	Diff line
		@@ -283,7 +283,8 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
		for (i = 0; i < priv->num_tx_queues; i++) {
		tx_queue = priv->tx_queue[i];
		tx_queue->tx_skbuff = kmalloc(sizeof(tx_queue->tx_skbuff)
		tx_queue->tx_ring_size, GFP_KERNEL);
		tx_queue->tx_ring_size,
		GFP_KERNEL);
		if (!tx_queue->tx_skbuff) {
		netif_err(priv, ifup, ndev,
		"Could not allocate tx_skbuff\n");
		@@ -297,7 +298,8 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
		for (i = 0; i < priv->num_rx_queues; i++) {
		rx_queue = priv->rx_queue[i];
		rx_queue->rx_skbuff = kmalloc(sizeof(rx_queue->rx_skbuff)
		rx_queue->rx_ring_size, GFP_KERNEL);
		rx_queue->rx_ring_size,
		GFP_KERNEL);

		if (!rx_queue->rx_skbuff) {
		netif_err(priv, ifup, ndev,
		@@ -581,14 +583,12 @@ static int gfar_parse_group(struct device_node *np,
		priv->gfargrp[priv->num_grps].priv = priv;
		spin_lock_init(&priv->gfargrp[priv->num_grps].grplock);
		if (priv->mode == MQ_MG_MODE) {
		queue_mask = (u32 *)of_get_property(np,
		"fsl,rx-bit-map", NULL);
		priv->gfargrp[priv->num_grps].rx_bit_map =
		queue_mask ? *queue_mask :(DEFAULT_MAPPING >> priv->num_grps);
		queue_mask = (u32 *)of_get_property(np,
		"fsl,tx-bit-map", NULL);
		priv->gfargrp[priv->num_grps].tx_bit_map =
		queue_mask ? *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
		queue_mask = (u32 *)of_get_property(np, "fsl,rx-bit-map", NULL);
		priv->gfargrp[priv->num_grps].rx_bit_map = queue_mask ?
		*queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
		queue_mask = (u32 *)of_get_property(np, "fsl,tx-bit-map", NULL);
		priv->gfargrp[priv->num_grps].tx_bit_map = queue_mask ?
		*queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
		} else {
		priv->gfargrp[priv->num_grps].rx_bit_map = 0xFF;
		priv->gfargrp[priv->num_grps].tx_bit_map = 0xFF;
		@@ -730,18 +730,18 @@ static int gfar_of_init(struct platform_device ofdev, struct net_device *pdev)
		priv->device_flags \|= FSL_GIANFAR_DEV_HAS_BUF_STASHING;

		mac_addr = of_get_mac_address(np);

		if (mac_addr)
		memcpy(dev->dev_addr, mac_addr, ETH_ALEN);

		if (model && !strcasecmp(model, "TSEC"))
		priv->device_flags =
		FSL_GIANFAR_DEV_HAS_GIGABIT \|
		priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT \|
		FSL_GIANFAR_DEV_HAS_COALESCE \|
		FSL_GIANFAR_DEV_HAS_RMON \|
		FSL_GIANFAR_DEV_HAS_MULTI_INTR;

		if (model && !strcasecmp(model, "eTSEC"))
		priv->device_flags =
		FSL_GIANFAR_DEV_HAS_GIGABIT \|
		priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT \|
		FSL_GIANFAR_DEV_HAS_COALESCE \|
		FSL_GIANFAR_DEV_HAS_RMON \|
		FSL_GIANFAR_DEV_HAS_MULTI_INTR \|
		@@ -851,6 +851,7 @@ static unsigned int reverse_bitmap(unsigned int bit_map, unsigned int max_qs)
		{
		unsigned int new_bit_map = 0x0;
		int mask = 0x1 << (max_qs - 1), i;

		for (i = 0; i < max_qs; i++) {
		if (bit_map & mask)
		new_bit_map = new_bit_map + (1 << i);
		@@ -1028,7 +1029,8 @@ static int gfar_probe(struct platform_device *ofdev)

		/* Register for napi ...We are registering NAPI for each grp */
		for (i = 0; i < priv->num_grps; i++)
		netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll, GFAR_DEV_WEIGHT);
		netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll,
		GFAR_DEV_WEIGHT);

		if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
		dev->hw_features = NETIF_F_IP_CSUM \| NETIF_F_SG \|
		@@ -1103,10 +1105,10 @@ static int gfar_probe(struct platform_device *ofdev)
		* 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);
		priv->gfargrp[i].rx_bit_map = reverse_bitmap(
		priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
		priv->gfargrp[i].tx_bit_map =
		reverse_bitmap(priv->gfargrp[i].tx_bit_map, MAX_TX_QS);
		priv->gfargrp[i].rx_bit_map =
		reverse_bitmap(priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
		}

		/* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values,
		@@ -1114,6 +1116,7 @@ static int gfar_probe(struct platform_device *ofdev)
		*/
		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,
		priv->num_rx_queues) {
		priv->gfargrp[grp_idx].num_rx_queues++;
		@@ -1122,6 +1125,7 @@ static int gfar_probe(struct platform_device *ofdev)
		rqueue = rqueue \| ((RQUEUE_EN0 \| RQUEUE_EX0) >> i);
		}
		priv->gfargrp[grp_idx].num_tx_queues = 0x0;

		for_each_set_bit(i, &priv->gfargrp[grp_idx].tx_bit_map,
		priv->num_tx_queues) {
		priv->gfargrp[grp_idx].num_tx_queues++;
		@@ -1169,7 +1173,8 @@ static int gfar_probe(struct platform_device *ofdev)
		}

		device_init_wakeup(&dev->dev,
		priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
		priv->device_flags &
		FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);

		/* fill out IRQ number and name fields */
		for (i = 0; i < priv->num_grps; i++) {
		@@ -1247,7 +1252,8 @@ static int gfar_suspend(struct device *dev)
		u32 tempval;

		int magic_packet = priv->wol_en &&
		(priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
		(priv->device_flags &
		FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);

		netif_device_detach(ndev);

		@@ -1299,7 +1305,8 @@ static int gfar_resume(struct device *dev)
		unsigned long flags;
		u32 tempval;
		int magic_packet = priv->wol_en &&
		(priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
		(priv->device_flags &
		FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);

		if (!netif_running(ndev)) {
		netif_device_attach(ndev);
		@@ -1398,8 +1405,9 @@ static phy_interface_t gfar_get_interface(struct net_device *dev)
		}

		if (ecntrl & ECNTRL_REDUCED_MODE) {
		if (ecntrl & ECNTRL_REDUCED_MII_MODE)
		if (ecntrl & ECNTRL_REDUCED_MII_MODE) {
		return PHY_INTERFACE_MODE_RMII;
		}
		else {
		phy_interface_t interface = priv->interface;

		@@ -1497,8 +1505,9 @@ static void gfar_configure_serdes(struct net_device *dev)
		ADVERTISE_1000XFULL \| ADVERTISE_1000XPAUSE \|
		ADVERTISE_1000XPSE_ASYM);

		phy_write(tbiphy, MII_BMCR, BMCR_ANENABLE \|
		BMCR_ANRESTART \| BMCR_FULLDPLX \| BMCR_SPEED1000);
		phy_write(tbiphy, MII_BMCR,
		BMCR_ANENABLE \| BMCR_ANRESTART \| BMCR_FULLDPLX \|
		BMCR_SPEED1000);
		}

		static void init_registers(struct net_device *dev)
		@@ -1594,8 +1603,8 @@ static void gfar_halt_nodisable(struct net_device *dev)
		regs = priv->gfargrp[0].regs;
		/* Stop the DMA, and wait for it to stop */
		tempval = gfar_read(&regs->dmactrl);
		if ((tempval & (DMACTRL_GRS \| DMACTRL_GTS))
		!= (DMACTRL_GRS \| DMACTRL_GTS)) {
		if ((tempval & (DMACTRL_GRS \| DMACTRL_GTS)) !=
		(DMACTRL_GRS \| DMACTRL_GTS)) {
		int ret;

		tempval \|= (DMACTRL_GRS \| DMACTRL_GTS);
		@@ -1729,6 +1738,7 @@ static void free_skb_resources(struct gfar_private *priv)
		/* Go through all the buffer descriptors and free their data buffers */
		for (i = 0; i < priv->num_tx_queues; i++) {
		struct netdev_queue *txq;

		tx_queue = priv->tx_queue[i];
		txq = netdev_get_tx_queue(tx_queue->dev, tx_queue->qindex);
		if (tx_queue->tx_skbuff)
		@@ -1834,8 +1844,8 @@ static int register_grp_irqs(struct gfar_priv_grp *grp)
		/* Install our interrupt handlers for Error,
		* Transmit, and Receive
		*/
		if ((err = request_irq(grp->interruptError, gfar_error, 0,
		grp->int_name_er,grp)) < 0) {
		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",
		grp->interruptError);

		@@ -1849,15 +1859,15 @@ static int register_grp_irqs(struct gfar_priv_grp *grp)
		goto tx_irq_fail;
		}

		if ((err = request_irq(grp->interruptReceive, gfar_receive, 0,
		grp->int_name_rx, grp)) < 0) {
		if ((err = request_irq(grp->interruptReceive, gfar_receive,
		0, grp->int_name_rx, grp)) < 0) {
		netif_err(priv, intr, dev, "Can't get IRQ %d\n",
		grp->interruptReceive);
		goto rx_irq_fail;
		}
		} else {
		if ((err = request_irq(grp->interruptTransmit, gfar_interrupt, 0,
		grp->int_name_tx, grp)) < 0) {
		if ((err = request_irq(grp->interruptTransmit, gfar_interrupt,
		0, grp->int_name_tx, grp)) < 0) {
		netif_err(priv, intr, dev, "Can't get IRQ %d\n",
		grp->interruptTransmit);
		goto err_irq_fail;
		@@ -2152,8 +2162,8 @@ static int gfar_start_xmit(struct sk_buff skb, struct net_device dev)
		if (CHECKSUM_PARTIAL == skb->ip_summed) {
		fcb = gfar_add_fcb(skb);
		/* as specified by errata */
		if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12)
		&& ((unsigned long)fcb % 0x20) > 0x18)) {
		if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12) &&
		((unsigned long)fcb % 0x20) > 0x18)) {
		__skb_pull(skb, GMAC_FCB_LEN);
		skb_checksum_help(skb);
		} else {
		@@ -2365,8 +2375,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)

		frame_size += priv->padding;

		tempsize =
		(frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
		tempsize = (frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
		INCREMENTAL_BUFFER_SIZE;

		/* Only stop and start the controller if it isn't already
		@@ -2500,6 +2509,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
		if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
		struct skb_shared_hwtstamps shhwtstamps;
		u64 ns = (u64) (((u32)skb->data + 0x10) & ~0x7);

		memset(&shhwtstamps, 0, sizeof(shhwtstamps));
		shhwtstamps.hwtstamp = ns_to_ktime(*ns);
		skb_pull(skb, GMAC_FCB_LEN + GMAC_TXPAL_LEN);
		@@ -2512,10 +2522,8 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
		bdp = next_txbd(bdp, base, tx_ring_size);

		for (i = 0; i < frags; i++) {
		dma_unmap_page(&priv->ofdev->dev,
		bdp->bufPtr,
		bdp->length,
		DMA_TO_DEVICE);
		dma_unmap_page(&priv->ofdev->dev, bdp->bufPtr,
		bdp->length, DMA_TO_DEVICE);
		bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
		bdp = next_txbd(bdp, base, tx_ring_size);
		}
		@@ -2700,6 +2708,7 @@ static int gfar_process_frame(struct net_device dev, struct sk_buff skb,
		if (priv->hwts_rx_en) {
		struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
		u64 ns = (u64 ) skb->data;

		memset(shhwtstamps, 0, sizeof(*shhwtstamps));
		shhwtstamps->hwtstamp = ns_to_ktime(*ns);
		}
		@@ -2752,6 +2761,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)

		while (!((bdp->status & RXBD_EMPTY) \|\| (--rx_work_limit < 0))) {
		struct sk_buff *newskb;

		rmb();

		/* Add another skb for the future */
		@@ -2806,8 +2816,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
		bdp = next_bd(bdp, base, rx_queue->rx_ring_size);

		/* update to point at the next skb */
		rx_queue->skb_currx =
		(rx_queue->skb_currx + 1) &
		rx_queue->skb_currx = (rx_queue->skb_currx + 1) &
		RX_RING_MOD_MASK(rx_queue->rx_ring_size);
		}

		@@ -2819,8 +2828,8 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)

		static int gfar_poll(struct napi_struct *napi, int budget)
		{
		struct gfar_priv_grp *gfargrp = container_of(napi,
		struct gfar_priv_grp, napi);
		struct gfar_priv_grp *gfargrp =
		container_of(napi, struct gfar_priv_grp, napi);
		struct gfar_private *priv = gfargrp->priv;
		struct gfar __iomem *regs = gfargrp->regs;
		struct gfar_priv_tx_q *tx_queue = NULL;
		@@ -2839,7 +2848,6 @@ static int gfar_poll(struct napi_struct *napi, int budget)
		gfar_write(&regs->ievent, IEVENT_RTX_MASK);

		while (num_queues && left_over_budget) {

		budget_per_queue = left_over_budget/num_queues;
		left_over_budget = 0;

		@@ -2850,12 +2858,13 @@ static int gfar_poll(struct napi_struct *napi, int budget)
		tx_queue = priv->tx_queue[rx_queue->qindex];

		tx_cleaned += gfar_clean_tx_ring(tx_queue);
		rx_cleaned_per_queue = gfar_clean_rx_ring(rx_queue,
		budget_per_queue);
		rx_cleaned_per_queue =
		gfar_clean_rx_ring(rx_queue, budget_per_queue);
		rx_cleaned += rx_cleaned_per_queue;
		if (rx_cleaned_per_queue < budget_per_queue) {
		left_over_budget = left_over_budget +
		(budget_per_queue - rx_cleaned_per_queue);
		(budget_per_queue -
		rx_cleaned_per_queue);
		set_bit(i, &serviced_queues);
		num_queues--;
		}
		@@ -2876,8 +2885,8 @@ static int gfar_poll(struct napi_struct *napi, int budget)
		/* If we are coalescing interrupts, update the timer
		* Otherwise, clear it
		*/
		gfar_configure_coalescing(priv,
		gfargrp->rx_bit_map, gfargrp->tx_bit_map);
		gfar_configure_coalescing(priv, gfargrp->rx_bit_map,
		gfargrp->tx_bit_map);
		}

		return rx_cleaned;
		@@ -3208,7 +3217,8 @@ static irqreturn_t gfar_error(int irq, void *grp_id)

		/* Hmm... */
		if (netif_msg_rx_err(priv) \|\| netif_msg_tx_err(priv))
		netdev_dbg(dev, "error interrupt (ievent=0x%08x imask=0x%08x)\n",
		netdev_dbg(dev,
		"error interrupt (ievent=0x%08x imask=0x%08x)\n",
		events, gfar_read(&regs->imask));

		/* Update the error counters */

Admin message