Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 7a2eaf9358250706672783eb8511835706b0922b

Authored by Christian Dietrich 2011-06-04 23:35:58 +0800

Committed by Greg Kroah-Hartman 2011-06-29 05:29:19 +0800

Exists in master and in 6 other branches

staging: octeon: use printk_ratelimited instead of printk_ratelimit

As per printk_ratelimit comment, it should not be used

Signed-off-by: Christian Dietrich <christian.dietrich@informatik.uni-erlangen.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 7 changed files with 70 additions and 65 deletions Inline Diff

drivers/staging/octeon/ethernet-mdio.c
drivers/staging/octeon/ethernet-rgmii.c
drivers/staging/octeon/ethernet-rx.c
drivers/staging/octeon/ethernet-sgmii.c
drivers/staging/octeon/ethernet-tx.c
drivers/staging/octeon/ethernet-util.h
drivers/staging/octeon/ethernet-xaui.c

drivers/staging/octeon/ethernet-mdio.c

Diff comments View file @ 7a2eaf9

 /**********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2007 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/ethtool.h>
 #include <linux/phy.h>
+#include <linux/ratelimit.h>
 #include <net/dst.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-mdio.h"
 #include "ethernet-util.h"
 #include "cvmx-helper-board.h"
 #include "cvmx-smix-defs.h"
 static void cvm_oct_get_drvinfo(struct net_device *dev,
 				struct ethtool_drvinfo *info)
 {
 	strcpy(info->driver, "cavium-ethernet");
 	strcpy(info->version, OCTEON_ETHERNET_VERSION);
 	strcpy(info->bus_info, "Builtin");
 }
 static int cvm_oct_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	if (priv->phydev)
 		return phy_ethtool_gset(priv->phydev, cmd);
 	return -EINVAL;
 }
 static int cvm_oct_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	if (priv->phydev)
 		return phy_ethtool_sset(priv->phydev, cmd);
 	return -EINVAL;
 }
 static int cvm_oct_nway_reset(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	if (priv->phydev)
 		return phy_start_aneg(priv->phydev);
 	return -EINVAL;
 }
 const struct ethtool_ops cvm_oct_ethtool_ops = {
 	.get_drvinfo = cvm_oct_get_drvinfo,
 	.get_settings = cvm_oct_get_settings,
 	.set_settings = cvm_oct_set_settings,
 	.nway_reset = cvm_oct_nway_reset,
 	.get_link = ethtool_op_get_link,
 };
 /**
  * cvm_oct_ioctl - IOCTL support for PHY control
  * @dev:    Device to change
  * @rq:     the request
  * @cmd:    the command
  *
  * Returns Zero on success
  */
 int cvm_oct_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	if (!netif_running(dev))
 		return -EINVAL;
 	if (!priv->phydev)
 		return -EINVAL;
 	return phy_mii_ioctl(priv->phydev, rq, cmd);
 }
 static void cvm_oct_adjust_link(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvmx_helper_link_info_t link_info;
 	if (priv->last_link != priv->phydev->link) {
 		priv->last_link = priv->phydev->link;
 		link_info.u64 = 0;
 		link_info.s.link_up = priv->last_link ? 1 : 0;
 		link_info.s.full_duplex = priv->phydev->duplex ? 1 : 0;
 		link_info.s.speed = priv->phydev->speed;
 		cvmx_helper_link_set( priv->port, link_info);
 		if (priv->last_link) {
 			netif_carrier_on(dev);
 			if (priv->queue != -1)
-				DEBUGPRINT("%s: %u Mbps %s duplex, "
+				printk_ratelimited("%s: %u Mbps %s duplex, "
-					   "port %2d, queue %2d\n",
+						   "port %2d, queue %2d\n",
-					   dev->name, priv->phydev->speed,
+						   dev->name, priv->phydev->speed,
-					   priv->phydev->duplex ?
+						   priv->phydev->duplex ?
-						"Full" : "Half",
+						   "Full" : "Half",
-					   priv->port, priv->queue);
+						   priv->port, priv->queue);
 			else
-				DEBUGPRINT("%s: %u Mbps %s duplex, "
+				printk_ratelimited("%s: %u Mbps %s duplex, "
-					   "port %2d, POW\n",
+						   "port %2d, POW\n",
-					   dev->name, priv->phydev->speed,
+						   dev->name, priv->phydev->speed,
-					   priv->phydev->duplex ?
+						   priv->phydev->duplex ?
-						"Full" : "Half",
+						   "Full" : "Half",
-					   priv->port);
+						   priv->port);
 		} else {
 			netif_carrier_off(dev);
-			DEBUGPRINT("%s: Link down\n", dev->name);
+			printk_ratelimited("%s: Link down\n", dev->name);
 		}
 	}
 }
 /**
  * cvm_oct_phy_setup_device - setup the PHY
  *
  * @dev:    Device to setup
  *
  * Returns Zero on success, negative on failure
  */
 int cvm_oct_phy_setup_device(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int phy_addr = cvmx_helper_board_get_mii_address(priv->port);
 	if (phy_addr != -1) {
 		char phy_id[20];
 		snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, "0", phy_addr);
 		priv->phydev = phy_connect(dev, phy_id, cvm_oct_adjust_link, 0,
 					PHY_INTERFACE_MODE_GMII);
 		if (IS_ERR(priv->phydev)) {
 			priv->phydev = NULL;
 			return -1;
 		}
 		priv->last_link = 0;
 		phy_start_aneg(priv->phydev);
 	}
 	return 0;
 }

drivers/staging/octeon/ethernet-rgmii.c

Diff comments View file @ 7a2eaf9

 /*********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2007 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/phy.h>
+#include <linux/ratelimit.h>
 #include <net/dst.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-util.h"
 #include "cvmx-helper.h"
 #include <asm/octeon/cvmx-ipd-defs.h>
 #include <asm/octeon/cvmx-npi-defs.h>
 #include "cvmx-gmxx-defs.h"
 DEFINE_SPINLOCK(global_register_lock);
 static int number_rgmii_ports;
 static void cvm_oct_rgmii_poll(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	unsigned long flags = 0;
 	cvmx_helper_link_info_t link_info;
 	int use_global_register_lock = (priv->phydev == NULL);
 	BUG_ON(in_interrupt());
 	if (use_global_register_lock) {
 		/*
 		 * Take the global register lock since we are going to
 		 * touch registers that affect more than one port.
 		 */
 		spin_lock_irqsave(&global_register_lock, flags);
 	} else {
 		mutex_lock(&priv->phydev->bus->mdio_lock);
 	}
 	link_info = cvmx_helper_link_get(priv->port);
 	if (link_info.u64 == priv->link_info) {
 		/*
 		 * If the 10Mbps preamble workaround is supported and we're
 		 * at 10Mbps we may need to do some special checking.
 		 */
 		if (USE_10MBPS_PREAMBLE_WORKAROUND && (link_info.s.speed == 10)) {
 			/*
 			 * Read the GMXX_RXX_INT_REG[PCTERR] bit and
 			 * see if we are getting preamble errors.
 			 */
 			int interface = INTERFACE(priv->port);
 			int index = INDEX(priv->port);
 			union cvmx_gmxx_rxx_int_reg gmxx_rxx_int_reg;
 			gmxx_rxx_int_reg.u64 =
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_REG
 					  (index, interface));
 			if (gmxx_rxx_int_reg.s.pcterr) {
 				/*
 				 * We are getting preamble errors at
 				 * 10Mbps.  Most likely the PHY is
 				 * giving us packets with mis aligned
 				 * preambles. In order to get these
 				 * packets we need to disable preamble
 				 * checking and do it in software.
 				 */
 				union cvmx_gmxx_rxx_frm_ctl gmxx_rxx_frm_ctl;
 				union cvmx_ipd_sub_port_fcs ipd_sub_port_fcs;
 				/* Disable preamble checking */
 				gmxx_rxx_frm_ctl.u64 =
 				    cvmx_read_csr(CVMX_GMXX_RXX_FRM_CTL
 						  (index, interface));
 				gmxx_rxx_frm_ctl.s.pre_chk = 0;
 				cvmx_write_csr(CVMX_GMXX_RXX_FRM_CTL
 					       (index, interface),
 					       gmxx_rxx_frm_ctl.u64);
 				/* Disable FCS stripping */
 				ipd_sub_port_fcs.u64 =
 				    cvmx_read_csr(CVMX_IPD_SUB_PORT_FCS);
 				ipd_sub_port_fcs.s.port_bit &=
 				    0xffffffffull ^ (1ull << priv->port);
 				cvmx_write_csr(CVMX_IPD_SUB_PORT_FCS,
 					       ipd_sub_port_fcs.u64);
 				/* Clear any error bits */
 				cvmx_write_csr(CVMX_GMXX_RXX_INT_REG
 					       (index, interface),
 					       gmxx_rxx_int_reg.u64);
-				DEBUGPRINT("%s: Using 10Mbps with software "
+				printk_ratelimited("%s: Using 10Mbps with software "
-					   "preamble removal\n",
+						   "preamble removal\n",
-				     dev->name);
+						   dev->name);
 			}
 		}
 		if (use_global_register_lock)
 			spin_unlock_irqrestore(&global_register_lock, flags);
 		else
 			mutex_unlock(&priv->phydev->bus->mdio_lock);
 		return;
 	}
 	/* If the 10Mbps preamble workaround is allowed we need to on
 	   preamble checking, FCS stripping, and clear error bits on
 	   every speed change. If errors occur during 10Mbps operation
 	   the above code will change this stuff */
 	if (USE_10MBPS_PREAMBLE_WORKAROUND) {
 		union cvmx_gmxx_rxx_frm_ctl gmxx_rxx_frm_ctl;
 		union cvmx_ipd_sub_port_fcs ipd_sub_port_fcs;
 		union cvmx_gmxx_rxx_int_reg gmxx_rxx_int_reg;
 		int interface = INTERFACE(priv->port);
 		int index = INDEX(priv->port);
 		/* Enable preamble checking */
 		gmxx_rxx_frm_ctl.u64 =
 		    cvmx_read_csr(CVMX_GMXX_RXX_FRM_CTL(index, interface));
 		gmxx_rxx_frm_ctl.s.pre_chk = 1;
 		cvmx_write_csr(CVMX_GMXX_RXX_FRM_CTL(index, interface),
 			       gmxx_rxx_frm_ctl.u64);
 		/* Enable FCS stripping */
 		ipd_sub_port_fcs.u64 = cvmx_read_csr(CVMX_IPD_SUB_PORT_FCS);
 		ipd_sub_port_fcs.s.port_bit |= 1ull << priv->port;
 		cvmx_write_csr(CVMX_IPD_SUB_PORT_FCS, ipd_sub_port_fcs.u64);
 		/* Clear any error bits */
 		gmxx_rxx_int_reg.u64 =
 		    cvmx_read_csr(CVMX_GMXX_RXX_INT_REG(index, interface));
 		cvmx_write_csr(CVMX_GMXX_RXX_INT_REG(index, interface),
 			       gmxx_rxx_int_reg.u64);
 	}
 	if (priv->phydev == NULL) {
 		link_info = cvmx_helper_link_autoconf(priv->port);
 		priv->link_info = link_info.u64;
 	}
 	if (use_global_register_lock)
 		spin_unlock_irqrestore(&global_register_lock, flags);
 	else {
 		mutex_unlock(&priv->phydev->bus->mdio_lock);
 	}
 	if (priv->phydev == NULL) {
 		/* Tell core. */
 		if (link_info.s.link_up) {
 			if (!netif_carrier_ok(dev))
 				netif_carrier_on(dev);
 			if (priv->queue != -1)
-				DEBUGPRINT("%s: %u Mbps %s duplex, "
+				printk_ratelimited("%s: %u Mbps %s duplex, "
-					   "port %2d, queue %2d\n",
+						   "port %2d, queue %2d\n",
-					   dev->name, link_info.s.speed,
+						   dev->name, link_info.s.speed,
-					   (link_info.s.full_duplex) ?
+						   (link_info.s.full_duplex) ?
-						"Full" : "Half",
+						   "Full" : "Half",
-					   priv->port, priv->queue);
+						   priv->port, priv->queue);
 			else
-				DEBUGPRINT("%s: %u Mbps %s duplex, "
+				printk_ratelimited("%s: %u Mbps %s duplex, "
-					   "port %2d, POW\n",
+						   "port %2d, POW\n",
-					   dev->name, link_info.s.speed,
+						   dev->name, link_info.s.speed,
-					   (link_info.s.full_duplex) ?
+						   (link_info.s.full_duplex) ?
-						"Full" : "Half",
+						   "Full" : "Half",
-					   priv->port);
+						   priv->port);
 		} else {
 			if (netif_carrier_ok(dev))
 				netif_carrier_off(dev);
-			DEBUGPRINT("%s: Link down\n", dev->name);
+			printk_ratelimited("%s: Link down\n", dev->name);
 		}
 	}
 }
 static irqreturn_t cvm_oct_rgmii_rml_interrupt(int cpl, void *dev_id)
 {
 	union cvmx_npi_rsl_int_blocks rsl_int_blocks;
 	int index;
 	irqreturn_t return_status = IRQ_NONE;
 	rsl_int_blocks.u64 = cvmx_read_csr(CVMX_NPI_RSL_INT_BLOCKS);
 	/* Check and see if this interrupt was caused by the GMX0 block */
 	if (rsl_int_blocks.s.gmx0) {
 		int interface = 0;
 		/* Loop through every port of this interface */
 		for (index = 0;
 		     index < cvmx_helper_ports_on_interface(interface);
 		     index++) {
 			/* Read the GMX interrupt status bits */
 			union cvmx_gmxx_rxx_int_reg gmx_rx_int_reg;
 			gmx_rx_int_reg.u64 =
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_REG
 					  (index, interface));
 			gmx_rx_int_reg.u64 &=
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_EN
 					  (index, interface));
 			/* Poll the port if inband status changed */
 			if (gmx_rx_int_reg.s.phy_dupx
 			    || gmx_rx_int_reg.s.phy_link
 			    || gmx_rx_int_reg.s.phy_spd) {
 				struct net_device *dev =
 				    cvm_oct_device[cvmx_helper_get_ipd_port
 						   (interface, index)];
 				struct octeon_ethernet *priv = netdev_priv(dev);
 				if (dev && !atomic_read(&cvm_oct_poll_queue_stopping))
 					queue_work(cvm_oct_poll_queue, &priv->port_work);
 				gmx_rx_int_reg.u64 = 0;
 				gmx_rx_int_reg.s.phy_dupx = 1;
 				gmx_rx_int_reg.s.phy_link = 1;
 				gmx_rx_int_reg.s.phy_spd = 1;
 				cvmx_write_csr(CVMX_GMXX_RXX_INT_REG
 					       (index, interface),
 					       gmx_rx_int_reg.u64);
 				return_status = IRQ_HANDLED;
 			}
 		}
 	}
 	/* Check and see if this interrupt was caused by the GMX1 block */
 	if (rsl_int_blocks.s.gmx1) {
 		int interface = 1;
 		/* Loop through every port of this interface */
 		for (index = 0;
 		     index < cvmx_helper_ports_on_interface(interface);
 		     index++) {
 			/* Read the GMX interrupt status bits */
 			union cvmx_gmxx_rxx_int_reg gmx_rx_int_reg;
 			gmx_rx_int_reg.u64 =
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_REG
 					  (index, interface));
 			gmx_rx_int_reg.u64 &=
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_EN
 					  (index, interface));
 			/* Poll the port if inband status changed */
 			if (gmx_rx_int_reg.s.phy_dupx
 			    || gmx_rx_int_reg.s.phy_link
 			    || gmx_rx_int_reg.s.phy_spd) {
 				struct net_device *dev =
 				    cvm_oct_device[cvmx_helper_get_ipd_port
 						   (interface, index)];
 				struct octeon_ethernet *priv = netdev_priv(dev);
 				if (dev && !atomic_read(&cvm_oct_poll_queue_stopping))
 					queue_work(cvm_oct_poll_queue, &priv->port_work);
 				gmx_rx_int_reg.u64 = 0;
 				gmx_rx_int_reg.s.phy_dupx = 1;
 				gmx_rx_int_reg.s.phy_link = 1;
 				gmx_rx_int_reg.s.phy_spd = 1;
 				cvmx_write_csr(CVMX_GMXX_RXX_INT_REG
 					       (index, interface),
 					       gmx_rx_int_reg.u64);
 				return_status = IRQ_HANDLED;
 			}
 		}
 	}
 	return return_status;
 }
 int cvm_oct_rgmii_open(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	cvmx_helper_link_info_t link_info;
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 1;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	if (!octeon_is_simulation()) {
 		link_info = cvmx_helper_link_get(priv->port);
 		if (!link_info.s.link_up)
 			netif_carrier_off(dev);
 	}
 	return 0;
 }
 int cvm_oct_rgmii_stop(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 0;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	return 0;
 }
 static void cvm_oct_rgmii_immediate_poll(struct work_struct *work)
 {
 	struct octeon_ethernet *priv = container_of(work, struct octeon_ethernet, port_work);
 	cvm_oct_rgmii_poll(cvm_oct_device[priv->port]);
 }
 int cvm_oct_rgmii_init(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int r;
 	cvm_oct_common_init(dev);
 	dev->netdev_ops->ndo_stop(dev);
 	INIT_WORK(&priv->port_work, cvm_oct_rgmii_immediate_poll);
 	/*
 	 * Due to GMX errata in CN3XXX series chips, it is necessary
 	 * to take the link down immediately when the PHY changes
 	 * state. In order to do this we call the poll function every
 	 * time the RGMII inband status changes.  This may cause
 	 * problems if the PHY doesn't implement inband status
 	 * properly.
 	 */
 	if (number_rgmii_ports == 0) {
 		r = request_irq(OCTEON_IRQ_RML, cvm_oct_rgmii_rml_interrupt,
 				IRQF_SHARED, "RGMII", &number_rgmii_ports);
 		if (r != 0)
 			return r;
 	}
 	number_rgmii_ports++;
 	/*
 	 * Only true RGMII ports need to be polled. In GMII mode, port
 	 * 0 is really a RGMII port.
 	 */
 	if (((priv->imode == CVMX_HELPER_INTERFACE_MODE_GMII)
 	     && (priv->port == 0))
 	    || (priv->imode == CVMX_HELPER_INTERFACE_MODE_RGMII)) {
 		if (!octeon_is_simulation()) {
 			union cvmx_gmxx_rxx_int_en gmx_rx_int_en;
 			int interface = INTERFACE(priv->port);
 			int index = INDEX(priv->port);
 			/*
 			 * Enable interrupts on inband status changes
 			 * for this port.
 			 */
 			gmx_rx_int_en.u64 =
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_EN
 					  (index, interface));
 			gmx_rx_int_en.s.phy_dupx = 1;
 			gmx_rx_int_en.s.phy_link = 1;
 			gmx_rx_int_en.s.phy_spd = 1;
 			cvmx_write_csr(CVMX_GMXX_RXX_INT_EN(index, interface),
 				       gmx_rx_int_en.u64);
 			priv->poll = cvm_oct_rgmii_poll;
 		}
 	}
 	return 0;
 }
 void cvm_oct_rgmii_uninit(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvm_oct_common_uninit(dev);
 	/*
 	 * Only true RGMII ports need to be polled. In GMII mode, port
 	 * 0 is really a RGMII port.
 	 */
 	if (((priv->imode == CVMX_HELPER_INTERFACE_MODE_GMII)
 	     && (priv->port == 0))
 	    || (priv->imode == CVMX_HELPER_INTERFACE_MODE_RGMII)) {
 		if (!octeon_is_simulation()) {
 			union cvmx_gmxx_rxx_int_en gmx_rx_int_en;
 			int interface = INTERFACE(priv->port);
 			int index = INDEX(priv->port);
 			/*
 			 * Disable interrupts on inband status changes
 			 * for this port.
 			 */
 			gmx_rx_int_en.u64 =
 			    cvmx_read_csr(CVMX_GMXX_RXX_INT_EN
 					  (index, interface));
 			gmx_rx_int_en.s.phy_dupx = 0;
 			gmx_rx_int_en.s.phy_link = 0;
 			gmx_rx_int_en.s.phy_spd = 0;
 			cvmx_write_csr(CVMX_GMXX_RXX_INT_EN(index, interface),
 				       gmx_rx_int_en.u64);
 		}
 	}
 	/* Remove the interrupt handler when the last port is removed. */
 	number_rgmii_ports--;
 	if (number_rgmii_ports == 0)
 		free_irq(OCTEON_IRQ_RML, &number_rgmii_ports);
 	cancel_work_sync(&priv->port_work);
 }

drivers/staging/octeon/ethernet-rx.c

Diff comments View file @ 7a2eaf9

 /**********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2010 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 **********************************************************************/
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/cache.h>
 #include <linux/cpumask.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
 #include <linux/etherdevice.h>
 #include <linux/ip.h>
 #include <linux/string.h>
 #include <linux/prefetch.h>
+#include <linux/ratelimit.h>
 #include <linux/smp.h>
 #include <net/dst.h>
 #ifdef CONFIG_XFRM
 #include <linux/xfrm.h>
 #include <net/xfrm.h>
 #endif /* CONFIG_XFRM */
 #include <asm/atomic.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "ethernet-mem.h"
 #include "ethernet-rx.h"
 #include "octeon-ethernet.h"
 #include "ethernet-util.h"
 #include "cvmx-helper.h"
 #include "cvmx-wqe.h"
 #include "cvmx-fau.h"
 #include "cvmx-pow.h"
 #include "cvmx-pip.h"
 #include "cvmx-scratch.h"
 #include "cvmx-gmxx-defs.h"
 struct cvm_napi_wrapper {
 	struct napi_struct napi;
 } ____cacheline_aligned_in_smp;
 static struct cvm_napi_wrapper cvm_oct_napi[NR_CPUS] __cacheline_aligned_in_smp;
 struct cvm_oct_core_state {
 	int baseline_cores;
 	/*
 	 * The number of additional cores that could be processing
 	 * input packtes.
 	 */
 	atomic_t available_cores;
 	cpumask_t cpu_state;
 } ____cacheline_aligned_in_smp;
 static struct cvm_oct_core_state core_state __cacheline_aligned_in_smp;
 static void cvm_oct_enable_napi(void *_)
 {
 	int cpu = smp_processor_id();
 	napi_schedule(&cvm_oct_napi[cpu].napi);
 }
 static void cvm_oct_enable_one_cpu(void)
 {
 	int v;
 	int cpu;
 	/* Check to see if more CPUs are available for receive processing... */
 	v = atomic_sub_if_positive(1, &core_state.available_cores);
 	if (v < 0)
 		return;
 	/* ... if a CPU is available, Turn on NAPI polling for that CPU.  */
 	for_each_online_cpu(cpu) {
 		if (!cpu_test_and_set(cpu, core_state.cpu_state)) {
 			v = smp_call_function_single(cpu, cvm_oct_enable_napi,
 						     NULL, 0);
 			if (v)
 				panic("Can't enable NAPI.");
 			break;
 		}
 	}
 }
 static void cvm_oct_no_more_work(void)
 {
 	int cpu = smp_processor_id();
 	/*
 	 * CPU zero is special.  It always has the irq enabled when
 	 * waiting for incoming packets.
 	 */
 	if (cpu == 0) {
 		enable_irq(OCTEON_IRQ_WORKQ0 + pow_receive_group);
 		return;
 	}
 	cpu_clear(cpu, core_state.cpu_state);
 	atomic_add(1, &core_state.available_cores);
 }
 /**
  * cvm_oct_do_interrupt - interrupt handler.
  *
  * The interrupt occurs whenever the POW has packets in our group.
  *
  */
 static irqreturn_t cvm_oct_do_interrupt(int cpl, void *dev_id)
 {
 	/* Disable the IRQ and start napi_poll. */
 	disable_irq_nosync(OCTEON_IRQ_WORKQ0 + pow_receive_group);
 	cvm_oct_enable_napi(NULL);
 	return IRQ_HANDLED;
 }
 /**
  * cvm_oct_check_rcv_error - process receive errors
  * @work: Work queue entry pointing to the packet.
  *
  * Returns Non-zero if the packet can be dropped, zero otherwise.
  */
 static inline int cvm_oct_check_rcv_error(cvmx_wqe_t *work)
 {
 	if ((work->word2.snoip.err_code == 10) && (work->len <= 64)) {
 		/*
 		 * Ignore length errors on min size packets. Some
 		 * equipment incorrectly pads packets to 64+4FCS
 		 * instead of 60+4FCS.  Note these packets still get
 		 * counted as frame errors.
 		 */
 	} else
 	    if (USE_10MBPS_PREAMBLE_WORKAROUND
 		&& ((work->word2.snoip.err_code == 5)
 		    || (work->word2.snoip.err_code == 7))) {
 		/*
 		 * We received a packet with either an alignment error
 		 * or a FCS error. This may be signalling that we are
 		 * running 10Mbps with GMXX_RXX_FRM_CTL[PRE_CHK}
 		 * off. If this is the case we need to parse the
 		 * packet to determine if we can remove a non spec
 		 * preamble and generate a correct packet.
 		 */
 		int interface = cvmx_helper_get_interface_num(work->ipprt);
 		int index = cvmx_helper_get_interface_index_num(work->ipprt);
 		union cvmx_gmxx_rxx_frm_ctl gmxx_rxx_frm_ctl;
 		gmxx_rxx_frm_ctl.u64 =
 		    cvmx_read_csr(CVMX_GMXX_RXX_FRM_CTL(index, interface));
 		if (gmxx_rxx_frm_ctl.s.pre_chk == 0) {
 			uint8_t *ptr =
 			    cvmx_phys_to_ptr(work->packet_ptr.s.addr);
 			int i = 0;
 			while (i < work->len - 1) {
 				if (*ptr != 0x55)
 					break;
 				ptr++;
 				i++;
 			}
 			if (*ptr == 0xd5) {
 				/*
-				   DEBUGPRINT("Port %d received 0xd5 preamble\n", work->ipprt);
+				  printk_ratelimited("Port %d received 0xd5 preamble\n", work->ipprt);
 				 */
 				work->packet_ptr.s.addr += i + 1;
 				work->len -= i + 5;
 			} else if ((*ptr & 0xf) == 0xd) {
 				/*
-				   DEBUGPRINT("Port %d received 0x?d preamble\n", work->ipprt);
+				  printk_ratelimited("Port %d received 0x?d preamble\n", work->ipprt);
 				 */
 				work->packet_ptr.s.addr += i;
 				work->len -= i + 4;
 				for (i = 0; i < work->len; i++) {
 					*ptr =
 					    ((*ptr & 0xf0) >> 4) |
 					    ((*(ptr + 1) & 0xf) << 4);
 					ptr++;
 				}
 			} else {
-				DEBUGPRINT("Port %d unknown preamble, packet "
+				printk_ratelimited("Port %d unknown preamble, packet "
-					   "dropped\n",
+						   "dropped\n",
-				     work->ipprt);
+						   work->ipprt);
 				/*
 				   cvmx_helper_dump_packet(work);
 				 */
 				cvm_oct_free_work(work);
 				return 1;
 			}
 		}
 	} else {
-		DEBUGPRINT("Port %d receive error code %d, packet dropped\n",
+		printk_ratelimited("Port %d receive error code %d, packet dropped\n",
-			   work->ipprt, work->word2.snoip.err_code);
+				   work->ipprt, work->word2.snoip.err_code);
 		cvm_oct_free_work(work);
 		return 1;
 	}
 	return 0;
 }
 /**
  * cvm_oct_napi_poll - the NAPI poll function.
  * @napi: The NAPI instance, or null if called from cvm_oct_poll_controller
  * @budget: Maximum number of packets to receive.
  *
  * Returns the number of packets processed.
  */
 static int cvm_oct_napi_poll(struct napi_struct *napi, int budget)
 {
 	const int	coreid = cvmx_get_core_num();
 	uint64_t	old_group_mask;
 	uint64_t	old_scratch;
 	int		rx_count = 0;
 	int		did_work_request = 0;
 	int		packet_not_copied;
 	/* Prefetch cvm_oct_device since we know we need it soon */
 	prefetch(cvm_oct_device);
 	if (USE_ASYNC_IOBDMA) {
 		/* Save scratch in case userspace is using it */
 		CVMX_SYNCIOBDMA;
 		old_scratch = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
 	}
 	/* Only allow work for our group (and preserve priorities) */
 	old_group_mask = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(coreid));
 	cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(coreid),
 		       (old_group_mask & ~0xFFFFull) | 1 << pow_receive_group);
 	if (USE_ASYNC_IOBDMA) {
 		cvmx_pow_work_request_async(CVMX_SCR_SCRATCH, CVMX_POW_NO_WAIT);
 		did_work_request = 1;
 	}
 	while (rx_count < budget) {
 		struct sk_buff *skb = NULL;
 		struct sk_buff **pskb = NULL;
 		int skb_in_hw;
 		cvmx_wqe_t *work;
 		if (USE_ASYNC_IOBDMA && did_work_request)
 			work = cvmx_pow_work_response_async(CVMX_SCR_SCRATCH);
 		else
 			work = cvmx_pow_work_request_sync(CVMX_POW_NO_WAIT);
 		prefetch(work);
 		did_work_request = 0;
 		if (work == NULL) {
 			union cvmx_pow_wq_int wq_int;
 			wq_int.u64 = 0;
 			wq_int.s.iq_dis = 1 << pow_receive_group;
 			wq_int.s.wq_int = 1 << pow_receive_group;
 			cvmx_write_csr(CVMX_POW_WQ_INT, wq_int.u64);
 			break;
 		}
 		pskb = (struct sk_buff **)(cvm_oct_get_buffer_ptr(work->packet_ptr) - sizeof(void *));
 		prefetch(pskb);
 		if (USE_ASYNC_IOBDMA && rx_count < (budget - 1)) {
 			cvmx_pow_work_request_async_nocheck(CVMX_SCR_SCRATCH, CVMX_POW_NO_WAIT);
 			did_work_request = 1;
 		}
 		if (rx_count == 0) {
 			/*
 			 * First time through, see if there is enough
 			 * work waiting to merit waking another
 			 * CPU.
 			 */
 			union cvmx_pow_wq_int_cntx counts;
 			int backlog;
 			int cores_in_use = core_state.baseline_cores - atomic_read(&core_state.available_cores);
 			counts.u64 = cvmx_read_csr(CVMX_POW_WQ_INT_CNTX(pow_receive_group));
 			backlog = counts.s.iq_cnt + counts.s.ds_cnt;
 			if (backlog > budget * cores_in_use && napi != NULL)
 				cvm_oct_enable_one_cpu();
 		}
 		skb_in_hw = USE_SKBUFFS_IN_HW && work->word2.s.bufs == 1;
 		if (likely(skb_in_hw)) {
 			skb = *pskb;
 			prefetch(&skb->head);
 			prefetch(&skb->len);
 		}
 		prefetch(cvm_oct_device[work->ipprt]);
 		/* Immediately throw away all packets with receive errors */
 		if (unlikely(work->word2.snoip.rcv_error)) {
 			if (cvm_oct_check_rcv_error(work))
 				continue;
 		}
 		/*
 		 * We can only use the zero copy path if skbuffs are
 		 * in the FPA pool and the packet fits in a single
 		 * buffer.
 		 */
 		if (likely(skb_in_hw)) {
 			skb->data = skb->head + work->packet_ptr.s.addr - cvmx_ptr_to_phys(skb->head);
 			prefetch(skb->data);
 			skb->len = work->len;
 			skb_set_tail_pointer(skb, skb->len);
 			packet_not_copied = 1;
 		} else {
 			/*
 			 * We have to copy the packet. First allocate
 			 * an skbuff for it.
 			 */
 			skb = dev_alloc_skb(work->len);
 			if (!skb) {
-				DEBUGPRINT("Port %d failed to allocate skbuff, packet dropped\n",
+				printk_ratelimited("Port %d failed to allocate "
-					   work->ipprt);
+						   "skbuff, packet dropped\n",
+						   work->ipprt);
 				cvm_oct_free_work(work);
 				continue;
 			}
 			/*
 			 * Check if we've received a packet that was
 			 * entirely stored in the work entry.
 			 */
 			if (unlikely(work->word2.s.bufs == 0)) {
 				uint8_t *ptr = work->packet_data;
 				if (likely(!work->word2.s.not_IP)) {
 					/*
 					 * The beginning of the packet
 					 * moves for IP packets.
 					 */
 					if (work->word2.s.is_v6)
 						ptr += 2;
 					else
 						ptr += 6;
 				}
 				memcpy(skb_put(skb, work->len), ptr, work->len);
 				/* No packet buffers to free */
 			} else {
 				int segments = work->word2.s.bufs;
 				union cvmx_buf_ptr segment_ptr = work->packet_ptr;
 				int len = work->len;
 				while (segments--) {
 					union cvmx_buf_ptr next_ptr =
 					    *(union cvmx_buf_ptr *)cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
 			/*
 			 * Octeon Errata PKI-100: The segment size is
 			 * wrong. Until it is fixed, calculate the
 			 * segment size based on the packet pool
 			 * buffer size. When it is fixed, the
 			 * following line should be replaced with this
 			 * one: int segment_size =
 			 * segment_ptr.s.size;
 			 */
 					int segment_size = CVMX_FPA_PACKET_POOL_SIZE -
 						(segment_ptr.s.addr - (((segment_ptr.s.addr >> 7) - segment_ptr.s.back) << 7));
 					/*
 					 * Don't copy more than what
 					 * is left in the packet.
 					 */
 					if (segment_size > len)
 						segment_size = len;
 					/* Copy the data into the packet */
 					memcpy(skb_put(skb, segment_size),
 					       cvmx_phys_to_ptr(segment_ptr.s.addr),
 					       segment_size);
 					len -= segment_size;
 					segment_ptr = next_ptr;
 				}
 			}
 			packet_not_copied = 0;
 		}
 		if (likely((work->ipprt < TOTAL_NUMBER_OF_PORTS) &&
 			   cvm_oct_device[work->ipprt])) {
 			struct net_device *dev = cvm_oct_device[work->ipprt];
 			struct octeon_ethernet *priv = netdev_priv(dev);
 			/*
 			 * Only accept packets for devices that are
 			 * currently up.
 			 */
 			if (likely(dev->flags & IFF_UP)) {
 				skb->protocol = eth_type_trans(skb, dev);
 				skb->dev = dev;
 				if (unlikely(work->word2.s.not_IP || work->word2.s.IP_exc || work->word2.s.L4_error))
 					skb->ip_summed = CHECKSUM_NONE;
 				else
 					skb->ip_summed = CHECKSUM_UNNECESSARY;
 				/* Increment RX stats for virtual ports */
 				if (work->ipprt >= CVMX_PIP_NUM_INPUT_PORTS) {
 #ifdef CONFIG_64BIT
 					atomic64_add(1, (atomic64_t *)&priv->stats.rx_packets);
 					atomic64_add(skb->len, (atomic64_t *)&priv->stats.rx_bytes);
 #else
 					atomic_add(1, (atomic_t *)&priv->stats.rx_packets);
 					atomic_add(skb->len, (atomic_t *)&priv->stats.rx_bytes);
 #endif
 				}
 				netif_receive_skb(skb);
 				rx_count++;
 			} else {
 				/* Drop any packet received for a device that isn't up */
 				/*
-				DEBUGPRINT("%s: Device not up, packet dropped\n",
+				  printk_ratelimited("%s: Device not up, packet dropped\n",
 					   dev->name);
 				*/
 #ifdef CONFIG_64BIT
 				atomic64_add(1, (atomic64_t *)&priv->stats.rx_dropped);
 #else
 				atomic_add(1, (atomic_t *)&priv->stats.rx_dropped);
 #endif
 				dev_kfree_skb_irq(skb);
 			}
 		} else {
 			/*
 			 * Drop any packet received for a device that
 			 * doesn't exist.
 			 */
-			DEBUGPRINT("Port %d not controlled by Linux, packet dropped\n",
+			printk_ratelimited("Port %d not controlled by Linux, packet dropped\n",
 				   work->ipprt);
 			dev_kfree_skb_irq(skb);
 		}
 		/*
 		 * Check to see if the skbuff and work share the same
 		 * packet buffer.
 		 */
 		if (USE_SKBUFFS_IN_HW && likely(packet_not_copied)) {
 			/*
 			 * This buffer needs to be replaced, increment
 			 * the number of buffers we need to free by
 			 * one.
 			 */
 			cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE,
 					      1);
 			cvmx_fpa_free(work, CVMX_FPA_WQE_POOL,
 				      DONT_WRITEBACK(1));
 		} else {
 			cvm_oct_free_work(work);
 		}
 	}
 	/* Restore the original POW group mask */
 	cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(coreid), old_group_mask);
 	if (USE_ASYNC_IOBDMA) {
 		/* Restore the scratch area */
 		cvmx_scratch_write64(CVMX_SCR_SCRATCH, old_scratch);
 	}
 	cvm_oct_rx_refill_pool(0);
 	if (rx_count < budget && napi != NULL) {
 		/* No more work */
 		napi_complete(napi);
 		cvm_oct_no_more_work();
 	}
 	return rx_count;
 }
 #ifdef CONFIG_NET_POLL_CONTROLLER
 /**
  * cvm_oct_poll_controller - poll for receive packets
  * device.
  *
  * @dev:    Device to poll. Unused
  */
 void cvm_oct_poll_controller(struct net_device *dev)
 {
 	cvm_oct_napi_poll(NULL, 16);
 }
 #endif
 void cvm_oct_rx_initialize(void)
 {
 	int i;
 	struct net_device *dev_for_napi = NULL;
 	union cvmx_pow_wq_int_thrx int_thr;
 	union cvmx_pow_wq_int_pc int_pc;
 	for (i = 0; i < TOTAL_NUMBER_OF_PORTS; i++) {
 		if (cvm_oct_device[i]) {
 			dev_for_napi = cvm_oct_device[i];
 			break;
 		}
 	}
 	if (NULL == dev_for_napi)
 		panic("No net_devices were allocated.");
 	if (max_rx_cpus > 1  && max_rx_cpus < num_online_cpus())
 		atomic_set(&core_state.available_cores, max_rx_cpus);
 	else
 		atomic_set(&core_state.available_cores, num_online_cpus());
 	core_state.baseline_cores = atomic_read(&core_state.available_cores);
 	core_state.cpu_state = CPU_MASK_NONE;
 	for_each_possible_cpu(i) {
 		netif_napi_add(dev_for_napi, &cvm_oct_napi[i].napi,
 			       cvm_oct_napi_poll, rx_napi_weight);
 		napi_enable(&cvm_oct_napi[i].napi);
 	}
 	/* Register an IRQ hander for to receive POW interrupts */
 	i = request_irq(OCTEON_IRQ_WORKQ0 + pow_receive_group,
 			cvm_oct_do_interrupt, 0, "Ethernet", cvm_oct_device);
 	if (i)
 		panic("Could not acquire Ethernet IRQ %d\n",
 		      OCTEON_IRQ_WORKQ0 + pow_receive_group);
 	disable_irq_nosync(OCTEON_IRQ_WORKQ0 + pow_receive_group);
 	int_thr.u64 = 0;
 	int_thr.s.tc_en = 1;
 	int_thr.s.tc_thr = 1;
 	/* Enable POW interrupt when our port has at least one packet */
 	cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), int_thr.u64);
 	int_pc.u64 = 0;
 	int_pc.s.pc_thr = 5;
 	cvmx_write_csr(CVMX_POW_WQ_INT_PC, int_pc.u64);
 	/* Scheduld NAPI now.  This will indirectly enable interrupts. */
 	cvm_oct_enable_one_cpu();
 }
 void cvm_oct_rx_shutdown(void)
 {
 	int i;
 	/* Shutdown all of the NAPIs */
 	for_each_possible_cpu(i)
 		netif_napi_del(&cvm_oct_napi[i].napi);
 }

drivers/staging/octeon/ethernet-sgmii.c

Diff comments View file @ 7a2eaf9

 /**********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2007 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/ratelimit.h>
 #include <net/dst.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-util.h"
 #include "cvmx-helper.h"
 #include "cvmx-gmxx-defs.h"
 int cvm_oct_sgmii_open(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	cvmx_helper_link_info_t link_info;
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 1;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	if (!octeon_is_simulation()) {
 		link_info = cvmx_helper_link_get(priv->port);
 		if (!link_info.s.link_up)
 			netif_carrier_off(dev);
 	}
 	return 0;
 }
 int cvm_oct_sgmii_stop(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 0;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	return 0;
 }
 static void cvm_oct_sgmii_poll(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvmx_helper_link_info_t link_info;
 	link_info = cvmx_helper_link_get(priv->port);
 	if (link_info.u64 == priv->link_info)
 		return;
 	link_info = cvmx_helper_link_autoconf(priv->port);
 	priv->link_info = link_info.u64;
 	/* Tell Linux */
 	if (link_info.s.link_up) {
 		if (!netif_carrier_ok(dev))
 			netif_carrier_on(dev);
 		if (priv->queue != -1)
-			DEBUGPRINT
+			printk_ratelimited
 			    ("%s: %u Mbps %s duplex, port %2d, queue %2d\n",
 			     dev->name, link_info.s.speed,
 			     (link_info.s.full_duplex) ? "Full" : "Half",
 			     priv->port, priv->queue);
 		else
-			DEBUGPRINT("%s: %u Mbps %s duplex, port %2d, POW\n",
+			printk_ratelimited
-				   dev->name, link_info.s.speed,
+				("%s: %u Mbps %s duplex, port %2d, POW\n",
-				   (link_info.s.full_duplex) ? "Full" : "Half",
+				 dev->name, link_info.s.speed,
-				   priv->port);
+				 (link_info.s.full_duplex) ? "Full" : "Half",
+				 priv->port);
 	} else {
 		if (netif_carrier_ok(dev))
 			netif_carrier_off(dev);
-		DEBUGPRINT("%s: Link down\n", dev->name);
+		printk_ratelimited("%s: Link down\n", dev->name);
 	}
 }
 int cvm_oct_sgmii_init(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvm_oct_common_init(dev);
 	dev->netdev_ops->ndo_stop(dev);
 	if (!octeon_is_simulation() && priv->phydev == NULL)
 		priv->poll = cvm_oct_sgmii_poll;
 	/* FIXME: Need autoneg logic */
 	return 0;
 }
 void cvm_oct_sgmii_uninit(struct net_device *dev)
 {
 	cvm_oct_common_uninit(dev);
 }

drivers/staging/octeon/ethernet-tx.c

Diff comments View file @ 7a2eaf9

 /*********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2010 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 *********************************************************************/
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
 #include <linux/etherdevice.h>
 #include <linux/ip.h>
+#include <linux/ratelimit.h>
 #include <linux/string.h>
 #include <net/dst.h>
 #ifdef CONFIG_XFRM
 #include <linux/xfrm.h>
 #include <net/xfrm.h>
 #endif /* CONFIG_XFRM */
 #include <asm/atomic.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-tx.h"
 #include "ethernet-util.h"
 #include "cvmx-wqe.h"
 #include "cvmx-fau.h"
 #include "cvmx-pip.h"
 #include "cvmx-pko.h"
 #include "cvmx-helper.h"
 #include "cvmx-gmxx-defs.h"
 #define CVM_OCT_SKB_CB(skb)	((u64 *)((skb)->cb))
 /*
  * You can define GET_SKBUFF_QOS() to override how the skbuff output
  * function determines which output queue is used. The default
  * implementation always uses the base queue for the port. If, for
  * example, you wanted to use the skb->priority fieid, define
  * GET_SKBUFF_QOS as: #define GET_SKBUFF_QOS(skb) ((skb)->priority)
  */
 #ifndef GET_SKBUFF_QOS
 #define GET_SKBUFF_QOS(skb) 0
 #endif
 static void cvm_oct_tx_do_cleanup(unsigned long arg);
 static DECLARE_TASKLET(cvm_oct_tx_cleanup_tasklet, cvm_oct_tx_do_cleanup, 0);
 /* Maximum number of SKBs to try to free per xmit packet. */
 #define MAX_SKB_TO_FREE (MAX_OUT_QUEUE_DEPTH * 2)
 static inline int32_t cvm_oct_adjust_skb_to_free(int32_t skb_to_free, int fau)
 {
 	int32_t undo;
 	undo = skb_to_free > 0 ? MAX_SKB_TO_FREE : skb_to_free + MAX_SKB_TO_FREE;
 	if (undo > 0)
 		cvmx_fau_atomic_add32(fau, -undo);
 	skb_to_free = -skb_to_free > MAX_SKB_TO_FREE ? MAX_SKB_TO_FREE : -skb_to_free;
 	return skb_to_free;
 }
 static void cvm_oct_kick_tx_poll_watchdog(void)
 {
 	union cvmx_ciu_timx ciu_timx;
 	ciu_timx.u64 = 0;
 	ciu_timx.s.one_shot = 1;
 	ciu_timx.s.len = cvm_oct_tx_poll_interval;
 	cvmx_write_csr(CVMX_CIU_TIMX(1), ciu_timx.u64);
 }
 void cvm_oct_free_tx_skbs(struct net_device *dev)
 {
 	int32_t skb_to_free;
 	int qos, queues_per_port;
 	int total_freed = 0;
 	int total_remaining = 0;
 	unsigned long flags;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	queues_per_port = cvmx_pko_get_num_queues(priv->port);
 	/* Drain any pending packets in the free list */
 	for (qos = 0; qos < queues_per_port; qos++) {
 		if (skb_queue_len(&priv->tx_free_list[qos]) == 0)
 			continue;
 		skb_to_free = cvmx_fau_fetch_and_add32(priv->fau+qos*4, MAX_SKB_TO_FREE);
 		skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free, priv->fau+qos*4);
 		total_freed += skb_to_free;
 		if (skb_to_free > 0) {
 			struct sk_buff *to_free_list = NULL;
 			spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
 			while (skb_to_free > 0) {
 				struct sk_buff *t = __skb_dequeue(&priv->tx_free_list[qos]);
 				t->next = to_free_list;
 				to_free_list = t;
 				skb_to_free--;
 			}
 			spin_unlock_irqrestore(&priv->tx_free_list[qos].lock, flags);
 			/* Do the actual freeing outside of the lock. */
 			while (to_free_list) {
 				struct sk_buff *t = to_free_list;
 				to_free_list = to_free_list->next;
 				dev_kfree_skb_any(t);
 			}
 		}
 		total_remaining += skb_queue_len(&priv->tx_free_list[qos]);
 	}
 	if (total_freed >= 0 && netif_queue_stopped(dev))
 		netif_wake_queue(dev);
 	if (total_remaining)
 		cvm_oct_kick_tx_poll_watchdog();
 }
 /**
  * cvm_oct_xmit - transmit a packet
  * @skb:    Packet to send
  * @dev:    Device info structure
  *
  * Returns Always returns NETDEV_TX_OK
  */
 int cvm_oct_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	cvmx_pko_command_word0_t pko_command;
 	union cvmx_buf_ptr hw_buffer;
 	uint64_t old_scratch;
 	uint64_t old_scratch2;
 	int qos;
 	int i;
 	enum {QUEUE_CORE, QUEUE_HW, QUEUE_DROP} queue_type;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	struct sk_buff *to_free_list;
 	int32_t skb_to_free;
 	int32_t buffers_to_free;
 	u32 total_to_clean;
 	unsigned long flags;
 #if REUSE_SKBUFFS_WITHOUT_FREE
 	unsigned char *fpa_head;
 #endif
 	/*
 	 * Prefetch the private data structure.  It is larger that one
 	 * cache line.
 	 */
 	prefetch(priv);
 	/*
 	 * The check on CVMX_PKO_QUEUES_PER_PORT_* is designed to
 	 * completely remove "qos" in the event neither interface
 	 * supports multiple queues per port.
 	 */
 	if ((CVMX_PKO_QUEUES_PER_PORT_INTERFACE0 > 1) ||
 	    (CVMX_PKO_QUEUES_PER_PORT_INTERFACE1 > 1)) {
 		qos = GET_SKBUFF_QOS(skb);
 		if (qos <= 0)
 			qos = 0;
 		else if (qos >= cvmx_pko_get_num_queues(priv->port))
 			qos = 0;
 	} else
 		qos = 0;
 	if (USE_ASYNC_IOBDMA) {
 		/* Save scratch in case userspace is using it */
 		CVMX_SYNCIOBDMA;
 		old_scratch = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
 		old_scratch2 = cvmx_scratch_read64(CVMX_SCR_SCRATCH + 8);
 		/*
 		 * Fetch and increment the number of packets to be
 		 * freed.
 		 */
 		cvmx_fau_async_fetch_and_add32(CVMX_SCR_SCRATCH + 8,
 					       FAU_NUM_PACKET_BUFFERS_TO_FREE,
 					       0);
 		cvmx_fau_async_fetch_and_add32(CVMX_SCR_SCRATCH,
 					       priv->fau + qos * 4,
 					       MAX_SKB_TO_FREE);
 	}
 	/*
 	 * We have space for 6 segment pointers, If there will be more
 	 * than that, we must linearize.
 	 */
 	if (unlikely(skb_shinfo(skb)->nr_frags > 5)) {
 		if (unlikely(__skb_linearize(skb))) {
 			queue_type = QUEUE_DROP;
 			if (USE_ASYNC_IOBDMA) {
 				/* Get the number of skbuffs in use by the hardware */
 				CVMX_SYNCIOBDMA;
 				skb_to_free = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
 			} else {
 				/* Get the number of skbuffs in use by the hardware */
 				skb_to_free = cvmx_fau_fetch_and_add32(priv->fau + qos * 4,
 								       MAX_SKB_TO_FREE);
 			}
 			skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free, priv->fau + qos * 4);
 			spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
 			goto skip_xmit;
 		}
 	}
 	/*
 	 * The CN3XXX series of parts has an errata (GMX-401) which
 	 * causes the GMX block to hang if a collision occurs towards
 	 * the end of a <68 byte packet. As a workaround for this, we
 	 * pad packets to be 68 bytes whenever we are in half duplex
 	 * mode. We don't handle the case of having a small packet but
 	 * no room to add the padding.  The kernel should always give
 	 * us at least a cache line
 	 */
 	if ((skb->len < 64) && OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
 		union cvmx_gmxx_prtx_cfg gmx_prt_cfg;
 		int interface = INTERFACE(priv->port);
 		int index = INDEX(priv->port);
 		if (interface < 2) {
 			/* We only need to pad packet in half duplex mode */
 			gmx_prt_cfg.u64 =
 			    cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 			if (gmx_prt_cfg.s.duplex == 0) {
 				int add_bytes = 64 - skb->len;
 				if ((skb_tail_pointer(skb) + add_bytes) <=
 				    skb_end_pointer(skb))
 					memset(__skb_put(skb, add_bytes), 0,
 					       add_bytes);
 			}
 		}
 	}
 	/* Build the PKO command */
 	pko_command.u64 = 0;
 	pko_command.s.n2 = 1;	/* Don't pollute L2 with the outgoing packet */
 	pko_command.s.segs = 1;
 	pko_command.s.total_bytes = skb->len;
 	pko_command.s.size0 = CVMX_FAU_OP_SIZE_32;
 	pko_command.s.subone0 = 1;
 	pko_command.s.dontfree = 1;
 	/* Build the PKO buffer pointer */
 	hw_buffer.u64 = 0;
 	if (skb_shinfo(skb)->nr_frags == 0) {
 		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)skb->data);
 		hw_buffer.s.pool = 0;
 		hw_buffer.s.size = skb->len;
 	} else {
 		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)skb->data);
 		hw_buffer.s.pool = 0;
 		hw_buffer.s.size = skb_headlen(skb);
 		CVM_OCT_SKB_CB(skb)[0] = hw_buffer.u64;
 		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 			struct skb_frag_struct *fs = skb_shinfo(skb)->frags + i;
 			hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)(page_address(fs->page) + fs->page_offset));
 			hw_buffer.s.size = fs->size;
 			CVM_OCT_SKB_CB(skb)[i + 1] = hw_buffer.u64;
 		}
 		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)CVM_OCT_SKB_CB(skb));
 		hw_buffer.s.size = skb_shinfo(skb)->nr_frags + 1;
 		pko_command.s.segs = skb_shinfo(skb)->nr_frags + 1;
 		pko_command.s.gather = 1;
 		goto dont_put_skbuff_in_hw;
 	}
 	/*
 	 * See if we can put this skb in the FPA pool. Any strange
 	 * behavior from the Linux networking stack will most likely
 	 * be caused by a bug in the following code. If some field is
 	 * in use by the network stack and get carried over when a
 	 * buffer is reused, bad thing may happen.  If in doubt and
 	 * you dont need the absolute best performance, disable the
 	 * define REUSE_SKBUFFS_WITHOUT_FREE. The reuse of buffers has
 	 * shown a 25% increase in performance under some loads.
 	 */
 #if REUSE_SKBUFFS_WITHOUT_FREE
 	fpa_head = skb->head + 256 - ((unsigned long)skb->head & 0x7f);
 	if (unlikely(skb->data < fpa_head)) {
 		/*
 		 * printk("TX buffer beginning can't meet FPA
 		 * alignment constraints\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely
 	    ((skb_end_pointer(skb) - fpa_head) < CVMX_FPA_PACKET_POOL_SIZE)) {
 		/*
 		   printk("TX buffer isn't large enough for the FPA\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely(skb_shared(skb))) {
 		/*
 		   printk("TX buffer sharing data with someone else\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely(skb_cloned(skb))) {
 		/*
 		   printk("TX buffer has been cloned\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely(skb_header_cloned(skb))) {
 		/*
 		   printk("TX buffer header has been cloned\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely(skb->destructor)) {
 		/*
 		   printk("TX buffer has a destructor\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely(skb_shinfo(skb)->nr_frags)) {
 		/*
 		   printk("TX buffer has fragments\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	if (unlikely
 	    (skb->truesize !=
 	     sizeof(*skb) + skb_end_pointer(skb) - skb->head)) {
 		/*
 		   printk("TX buffer truesize has been changed\n");
 		 */
 		goto dont_put_skbuff_in_hw;
 	}
 	/*
 	 * We can use this buffer in the FPA.  We don't need the FAU
 	 * update anymore
 	 */
 	pko_command.s.dontfree = 0;
 	hw_buffer.s.back = ((unsigned long)skb->data >> 7) - ((unsigned long)fpa_head >> 7);
 	*(struct sk_buff **)(fpa_head - sizeof(void *)) = skb;
 	/*
 	 * The skbuff will be reused without ever being freed. We must
 	 * cleanup a bunch of core things.
 	 */
 	dst_release(skb_dst(skb));
 	skb_dst_set(skb, NULL);
 #ifdef CONFIG_XFRM
 	secpath_put(skb->sp);
 	skb->sp = NULL;
 #endif
 	nf_reset(skb);
 #ifdef CONFIG_NET_SCHED
 	skb->tc_index = 0;
 #ifdef CONFIG_NET_CLS_ACT
 	skb->tc_verd = 0;
 #endif /* CONFIG_NET_CLS_ACT */
 #endif /* CONFIG_NET_SCHED */
 #endif /* REUSE_SKBUFFS_WITHOUT_FREE */
 dont_put_skbuff_in_hw:
 	/* Check if we can use the hardware checksumming */
 	if (USE_HW_TCPUDP_CHECKSUM && (skb->protocol == htons(ETH_P_IP)) &&
 	    (ip_hdr(skb)->version == 4) && (ip_hdr(skb)->ihl == 5) &&
 	    ((ip_hdr(skb)->frag_off == 0) || (ip_hdr(skb)->frag_off == 1 << 14))
 	    && ((ip_hdr(skb)->protocol == IPPROTO_TCP)
 		|| (ip_hdr(skb)->protocol == IPPROTO_UDP))) {
 		/* Use hardware checksum calc */
 		pko_command.s.ipoffp1 = sizeof(struct ethhdr) + 1;
 	}
 	if (USE_ASYNC_IOBDMA) {
 		/* Get the number of skbuffs in use by the hardware */
 		CVMX_SYNCIOBDMA;
 		skb_to_free = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
 		buffers_to_free = cvmx_scratch_read64(CVMX_SCR_SCRATCH + 8);
 	} else {
 		/* Get the number of skbuffs in use by the hardware */
 		skb_to_free = cvmx_fau_fetch_and_add32(priv->fau + qos * 4,
 						       MAX_SKB_TO_FREE);
 		buffers_to_free =
 		    cvmx_fau_fetch_and_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
 	}
 	skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free, priv->fau+qos*4);
 	/*
 	 * If we're sending faster than the receive can free them then
 	 * don't do the HW free.
 	 */
 	if ((buffers_to_free < -100) && !pko_command.s.dontfree)
 		pko_command.s.dontfree = 1;
 	if (pko_command.s.dontfree) {
 		queue_type = QUEUE_CORE;
 		pko_command.s.reg0 = priv->fau+qos*4;
 	} else {
 		queue_type = QUEUE_HW;
 	}
 	if (USE_ASYNC_IOBDMA)
 		cvmx_fau_async_fetch_and_add32(CVMX_SCR_SCRATCH, FAU_TOTAL_TX_TO_CLEAN, 1);
 	spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
 	/* Drop this packet if we have too many already queued to the HW */
 	if (unlikely(skb_queue_len(&priv->tx_free_list[qos]) >= MAX_OUT_QUEUE_DEPTH)) {
 		if (dev->tx_queue_len != 0) {
 			/* Drop the lock when notifying the core.  */
 			spin_unlock_irqrestore(&priv->tx_free_list[qos].lock, flags);
 			netif_stop_queue(dev);
 			spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
 		} else {
 			/* If not using normal queueing.  */
 			queue_type = QUEUE_DROP;
 			goto skip_xmit;
 		}
 	}
 	cvmx_pko_send_packet_prepare(priv->port, priv->queue + qos,
 				     CVMX_PKO_LOCK_NONE);
 	/* Send the packet to the output queue */
 	if (unlikely(cvmx_pko_send_packet_finish(priv->port,
 						 priv->queue + qos,
 						 pko_command, hw_buffer,
 						 CVMX_PKO_LOCK_NONE))) {
-		DEBUGPRINT("%s: Failed to send the packet\n", dev->name);
+		printk_ratelimited("%s: Failed to send the packet\n", dev->name);
 		queue_type = QUEUE_DROP;
 	}
 skip_xmit:
 	to_free_list = NULL;
 	switch (queue_type) {
 	case QUEUE_DROP:
 		skb->next = to_free_list;
 		to_free_list = skb;
 		priv->stats.tx_dropped++;
 		break;
 	case QUEUE_HW:
 		cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE, -1);
 		break;
 	case QUEUE_CORE:
 		__skb_queue_tail(&priv->tx_free_list[qos], skb);
 		break;
 	default:
 		BUG();
 	}
 	while (skb_to_free > 0) {
 		struct sk_buff *t = __skb_dequeue(&priv->tx_free_list[qos]);
 		t->next = to_free_list;
 		to_free_list = t;
 		skb_to_free--;
 	}
 	spin_unlock_irqrestore(&priv->tx_free_list[qos].lock, flags);
 	/* Do the actual freeing outside of the lock. */
 	while (to_free_list) {
 		struct sk_buff *t = to_free_list;
 		to_free_list = to_free_list->next;
 		dev_kfree_skb_any(t);
 	}
 	if (USE_ASYNC_IOBDMA) {
 		CVMX_SYNCIOBDMA;
 		total_to_clean = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
 		/* Restore the scratch area */
 		cvmx_scratch_write64(CVMX_SCR_SCRATCH, old_scratch);
 		cvmx_scratch_write64(CVMX_SCR_SCRATCH + 8, old_scratch2);
 	} else {
 		total_to_clean = cvmx_fau_fetch_and_add32(FAU_TOTAL_TX_TO_CLEAN, 1);
 	}
 	if (total_to_clean & 0x3ff) {
 		/*
 		 * Schedule the cleanup tasklet every 1024 packets for
 		 * the pathological case of high traffic on one port
 		 * delaying clean up of packets on a different port
 		 * that is blocked waiting for the cleanup.
 		 */
 		tasklet_schedule(&cvm_oct_tx_cleanup_tasklet);
 	}
 	cvm_oct_kick_tx_poll_watchdog();
 	return NETDEV_TX_OK;
 }
 /**
  * cvm_oct_xmit_pow - transmit a packet to the POW
  * @skb:    Packet to send
  * @dev:    Device info structure
  * Returns Always returns zero
  */
 int cvm_oct_xmit_pow(struct sk_buff *skb, struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	void *packet_buffer;
 	void *copy_location;
 	/* Get a work queue entry */
 	cvmx_wqe_t *work = cvmx_fpa_alloc(CVMX_FPA_WQE_POOL);
 	if (unlikely(work == NULL)) {
-		DEBUGPRINT("%s: Failed to allocate a work queue entry\n",
+		printk_ratelimited("%s: Failed to allocate a work "
-			   dev->name);
+				   "queue entry\n", dev->name);
 		priv->stats.tx_dropped++;
 		dev_kfree_skb(skb);
 		return 0;
 	}
 	/* Get a packet buffer */
 	packet_buffer = cvmx_fpa_alloc(CVMX_FPA_PACKET_POOL);
 	if (unlikely(packet_buffer == NULL)) {
-		DEBUGPRINT("%s: Failed to allocate a packet buffer\n",
+		printk_ratelimited("%s: Failed to allocate a packet buffer\n",
-			   dev->name);
+				   dev->name);
 		cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, DONT_WRITEBACK(1));
 		priv->stats.tx_dropped++;
 		dev_kfree_skb(skb);
 		return 0;
 	}
 	/*
 	 * Calculate where we need to copy the data to. We need to
 	 * leave 8 bytes for a next pointer (unused). We also need to
 	 * include any configure skip. Then we need to align the IP
 	 * packet src and dest into the same 64bit word. The below
 	 * calculation may add a little extra, but that doesn't
 	 * hurt.
 	 */
 	copy_location = packet_buffer + sizeof(uint64_t);
 	copy_location += ((CVMX_HELPER_FIRST_MBUFF_SKIP + 7) & 0xfff8) + 6;
 	/*
 	 * We have to copy the packet since whoever processes this
 	 * packet will free it to a hardware pool. We can't use the
 	 * trick of counting outstanding packets like in
 	 * cvm_oct_xmit.
 	 */
 	memcpy(copy_location, skb->data, skb->len);
 	/*
 	 * Fill in some of the work queue fields. We may need to add
 	 * more if the software at the other end needs them.
 	 */
 	work->hw_chksum = skb->csum;
 	work->len = skb->len;
 	work->ipprt = priv->port;
 	work->qos = priv->port & 0x7;
 	work->grp = pow_send_group;
 	work->tag_type = CVMX_HELPER_INPUT_TAG_TYPE;
 	work->tag = pow_send_group;	/* FIXME */
 	/* Default to zero. Sets of zero later are commented out */
 	work->word2.u64 = 0;
 	work->word2.s.bufs = 1;
 	work->packet_ptr.u64 = 0;
 	work->packet_ptr.s.addr = cvmx_ptr_to_phys(copy_location);
 	work->packet_ptr.s.pool = CVMX_FPA_PACKET_POOL;
 	work->packet_ptr.s.size = CVMX_FPA_PACKET_POOL_SIZE;
 	work->packet_ptr.s.back = (copy_location - packet_buffer) >> 7;
 	if (skb->protocol == htons(ETH_P_IP)) {
 		work->word2.s.ip_offset = 14;
 #if 0
 		work->word2.s.vlan_valid = 0;	/* FIXME */
 		work->word2.s.vlan_cfi = 0;	/* FIXME */
 		work->word2.s.vlan_id = 0;	/* FIXME */
 		work->word2.s.dec_ipcomp = 0;	/* FIXME */
 #endif
 		work->word2.s.tcp_or_udp =
 		    (ip_hdr(skb)->protocol == IPPROTO_TCP)
 		    || (ip_hdr(skb)->protocol == IPPROTO_UDP);
 #if 0
 		/* FIXME */
 		work->word2.s.dec_ipsec = 0;
 		/* We only support IPv4 right now */
 		work->word2.s.is_v6 = 0;
 		/* Hardware would set to zero */
 		work->word2.s.software = 0;
 		/* No error, packet is internal */
 		work->word2.s.L4_error = 0;
 #endif
 		work->word2.s.is_frag = !((ip_hdr(skb)->frag_off == 0)
 					  || (ip_hdr(skb)->frag_off ==
 					      1 << 14));
 #if 0
 		/* Assume Linux is sending a good packet */
 		work->word2.s.IP_exc = 0;
 #endif
 		work->word2.s.is_bcast = (skb->pkt_type == PACKET_BROADCAST);
 		work->word2.s.is_mcast = (skb->pkt_type == PACKET_MULTICAST);
 #if 0
 		/* This is an IP packet */
 		work->word2.s.not_IP = 0;
 		/* No error, packet is internal */
 		work->word2.s.rcv_error = 0;
 		/* No error, packet is internal */
 		work->word2.s.err_code = 0;
 #endif
 		/*
 		 * When copying the data, include 4 bytes of the
 		 * ethernet header to align the same way hardware
 		 * does.
 		 */
 		memcpy(work->packet_data, skb->data + 10,
 		       sizeof(work->packet_data));
 	} else {
 #if 0
 		work->word2.snoip.vlan_valid = 0;	/* FIXME */
 		work->word2.snoip.vlan_cfi = 0;	/* FIXME */
 		work->word2.snoip.vlan_id = 0;	/* FIXME */
 		work->word2.snoip.software = 0;	/* Hardware would set to zero */
 #endif
 		work->word2.snoip.is_rarp = skb->protocol == htons(ETH_P_RARP);
 		work->word2.snoip.is_arp = skb->protocol == htons(ETH_P_ARP);
 		work->word2.snoip.is_bcast =
 		    (skb->pkt_type == PACKET_BROADCAST);
 		work->word2.snoip.is_mcast =
 		    (skb->pkt_type == PACKET_MULTICAST);
 		work->word2.snoip.not_IP = 1;	/* IP was done up above */
 #if 0
 		/* No error, packet is internal */
 		work->word2.snoip.rcv_error = 0;
 		/* No error, packet is internal */
 		work->word2.snoip.err_code = 0;
 #endif
 		memcpy(work->packet_data, skb->data, sizeof(work->packet_data));
 	}
 	/* Submit the packet to the POW */
 	cvmx_pow_work_submit(work, work->tag, work->tag_type, work->qos,
 			     work->grp);
 	priv->stats.tx_packets++;
 	priv->stats.tx_bytes += skb->len;
 	dev_kfree_skb(skb);
 	return 0;
 }
 /**
  * cvm_oct_tx_shutdown_dev - free all skb that are currently queued for TX.
  * @dev:    Device being shutdown
  *
  */
 void cvm_oct_tx_shutdown_dev(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	unsigned long flags;
 	int qos;
 	for (qos = 0; qos < 16; qos++) {
 		spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
 		while (skb_queue_len(&priv->tx_free_list[qos]))
 			dev_kfree_skb_any(__skb_dequeue
 					  (&priv->tx_free_list[qos]));
 		spin_unlock_irqrestore(&priv->tx_free_list[qos].lock, flags);
 	}
 }
 static void cvm_oct_tx_do_cleanup(unsigned long arg)
 {
 	int port;
 	for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) {
 		if (cvm_oct_device[port]) {
 			struct net_device *dev = cvm_oct_device[port];
 			cvm_oct_free_tx_skbs(dev);
 		}
 	}
 }
 static irqreturn_t cvm_oct_tx_cleanup_watchdog(int cpl, void *dev_id)
 {
 	/* Disable the interrupt.  */
 	cvmx_write_csr(CVMX_CIU_TIMX(1), 0);
 	/* Do the work in the tasklet.  */
 	tasklet_schedule(&cvm_oct_tx_cleanup_tasklet);
 	return IRQ_HANDLED;
 }
 void cvm_oct_tx_initialize(void)
 {
 	int i;
 	/* Disable the interrupt.  */
 	cvmx_write_csr(CVMX_CIU_TIMX(1), 0);
 	/* Register an IRQ hander for to receive CIU_TIMX(1) interrupts */
 	i = request_irq(OCTEON_IRQ_TIMER1,
 			cvm_oct_tx_cleanup_watchdog, 0,
 			"Ethernet", cvm_oct_device);
 	if (i)
 		panic("Could not acquire Ethernet IRQ %d\n", OCTEON_IRQ_TIMER1);
 }
 void cvm_oct_tx_shutdown(void)
 {
 	/* Free the interrupt handler */
 	free_irq(OCTEON_IRQ_TIMER1, cvm_oct_device);
 }

drivers/staging/octeon/ethernet-util.h

Diff comments View file @ 7a2eaf9

 /**********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2007 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 *********************************************************************/
-#define DEBUGPRINT(format, ...) do { if (printk_ratelimit()) 		\
-					printk(format, ##__VA_ARGS__);	\
-				} while (0)
 /**
  * cvm_oct_get_buffer_ptr - convert packet data address to pointer
  * @packet_ptr: Packet data hardware address
  *
  * Returns Packet buffer pointer
  */
 static inline void *cvm_oct_get_buffer_ptr(union cvmx_buf_ptr packet_ptr)
 {
 	return cvmx_phys_to_ptr(((packet_ptr.s.addr >> 7) - packet_ptr.s.back)
 				<< 7);
 }
 /**
  * INTERFACE - convert IPD port to locgical interface
  * @ipd_port: Port to check
  *
  * Returns Logical interface
  */
 static inline int INTERFACE(int ipd_port)
 {
 	if (ipd_port < 32)	/* Interface 0 or 1 for RGMII,GMII,SPI, etc */
 		return ipd_port >> 4;
 	else if (ipd_port < 36)	/* Interface 2 for NPI */
 		return 2;
 	else if (ipd_port < 40)	/* Interface 3 for loopback */
 		return 3;
 	else if (ipd_port == 40)	/* Non existent interface for POW0 */
 		return 4;
 	else
 		panic("Illegal ipd_port %d passed to INTERFACE\n", ipd_port);
 }
 /**
  * INDEX - convert IPD/PKO port number to the port's interface index
  * @ipd_port: Port to check
  *
  * Returns Index into interface port list
  */
 static inline int INDEX(int ipd_port)
 {
 	if (ipd_port < 32)
 		return ipd_port & 15;
 	else
 		return ipd_port & 3;
 }

drivers/staging/octeon/ethernet-xaui.c

Diff comments View file @ 7a2eaf9

 /**********************************************************************
  * Author: Cavium Networks
  *
  * Contact: support@caviumnetworks.com
  * This file is part of the OCTEON SDK
  *
  * Copyright (c) 2003-2007 Cavium Networks
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, Version 2, as
  * published by the Free Software Foundation.
  *
  * This file is distributed in the hope that it will be useful, but
  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  * NONINFRINGEMENT.  See the GNU General Public License for more
  * details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this file; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  * or visit http://www.gnu.org/licenses/.
  *
  * This file may also be available under a different license from Cavium.
  * Contact Cavium Networks for more information
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/ratelimit.h>
 #include <net/dst.h>
 #include <asm/octeon/octeon.h>
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-util.h"
 #include "cvmx-helper.h"
 #include "cvmx-gmxx-defs.h"
 int cvm_oct_xaui_open(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	cvmx_helper_link_info_t link_info;
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 1;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	if (!octeon_is_simulation()) {
 		link_info = cvmx_helper_link_get(priv->port);
 		if (!link_info.s.link_up)
 			netif_carrier_off(dev);
 	}
 	return 0;
 }
 int cvm_oct_xaui_stop(struct net_device *dev)
 {
 	union cvmx_gmxx_prtx_cfg gmx_cfg;
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	int interface = INTERFACE(priv->port);
 	int index = INDEX(priv->port);
 	gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
 	gmx_cfg.s.en = 0;
 	cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
 	return 0;
 }
 static void cvm_oct_xaui_poll(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvmx_helper_link_info_t link_info;
 	link_info = cvmx_helper_link_get(priv->port);
 	if (link_info.u64 == priv->link_info)
 		return;
 	link_info = cvmx_helper_link_autoconf(priv->port);
 	priv->link_info = link_info.u64;
 	/* Tell Linux */
 	if (link_info.s.link_up) {
 		if (!netif_carrier_ok(dev))
 			netif_carrier_on(dev);
 		if (priv->queue != -1)
-			DEBUGPRINT
+			printk_ratelimited
-			    ("%s: %u Mbps %s duplex, port %2d, queue %2d\n",
+				("%s: %u Mbps %s duplex, port %2d, queue %2d\n",
-			     dev->name, link_info.s.speed,
+				 dev->name, link_info.s.speed,
-			     (link_info.s.full_duplex) ? "Full" : "Half",
+				 (link_info.s.full_duplex) ? "Full" : "Half",
-			     priv->port, priv->queue);
+				 priv->port, priv->queue);
 		else
-			DEBUGPRINT("%s: %u Mbps %s duplex, port %2d, POW\n",
+			printk_ratelimited
-				   dev->name, link_info.s.speed,
+				("%s: %u Mbps %s duplex, port %2d, POW\n",
-				   (link_info.s.full_duplex) ? "Full" : "Half",
+				 dev->name, link_info.s.speed,
-				   priv->port);
+				 (link_info.s.full_duplex) ? "Full" : "Half",
+				 priv->port);
 	} else {
 		if (netif_carrier_ok(dev))
 			netif_carrier_off(dev);
-		DEBUGPRINT("%s: Link down\n", dev->name);
+		printk_ratelimited("%s: Link down\n", dev->name);
 	}
 }
 int cvm_oct_xaui_init(struct net_device *dev)
 {
 	struct octeon_ethernet *priv = netdev_priv(dev);
 	cvm_oct_common_init(dev);
 	dev->netdev_ops->ndo_stop(dev);
 	if (!octeon_is_simulation() && priv->phydev == NULL)
 		priv->poll = cvm_oct_xaui_poll;
 	return 0;
 }
 void cvm_oct_xaui_uninit(struct net_device *dev)
 {
 	cvm_oct_common_uninit(dev);
 }