Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c27a02cd authored by Yevgeny Petrilin's avatar Yevgeny Petrilin Committed by Roland Dreier
Browse files

mlx4_en: Add driver for Mellanox ConnectX 10GbE NIC 



The Mellanox ConnectX can operate as an InfiniBand adapter, as an
Ethernet NIC, or as a Fibre Channel (FC) HBA.  The kernel has a
low-level driver, mlx4_core, which handles multiplexing access to the
device, and there is also already an InfiniBad driver, mlx4_ib.

This patch adds a new driver, mlx4_en, which implements a standard
Ethernet NIC driver.

Signed-off-by: default avatarLiran Liss <liranl@mellanox.co.il>
Signed-off-by: default avatarYevgeny Petrilin <yevgenyp@mellanox.co.il>
Signed-off-by: default avatarRoland Dreier <rolandd@cisco.com>
parent 7ff93f8b

drivers/net/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -2465,6 +2465,15 @@ config PASEMI_MAC 
	  This driver supports the on-chip 1/10Gbit Ethernet controller on

	  PA Semi's PWRficient line of chips.



config MLX4_EN

	tristate "Mellanox Technologies 10Gbit Ethernet support"

	depends on PCI && INET

	select MLX4_CORE

	select INET_LRO

	help

	  This driver supports Mellanox Technologies ConnectX Ethernet

	  devices.



config MLX4_CORE

	tristate

	depends on PCI

drivers/net/mlx4/Makefile

+5 −0
Original line number Diff line number Diff line
@@ -2,3 +2,8 @@ obj-$(CONFIG_MLX4_CORE) += mlx4_core.o 


mlx4_core-y :=	alloc.o catas.o cmd.o cq.o eq.o fw.o icm.o intf.o main.o mcg.o \

		mr.o pd.o port.o profile.o qp.o reset.o srq.o



obj-$(CONFIG_MLX4_EN)               += mlx4_en.o



mlx4_en-y := 	en_main.o en_tx.o en_rx.o en_params.o en_port.o en_cq.o \

		en_resources.o en_netdev.o

drivers/net/mlx4/en_cq.c

0 → 100644
+146 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2007 Mellanox Technologies. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 */



#include <linux/mlx4/cq.h>

#include <linux/mlx4/qp.h>

#include <linux/mlx4/cmd.h>



#include "mlx4_en.h"



static void mlx4_en_cq_event(struct mlx4_cq *cq, enum mlx4_event event)

{

	return;

}





int mlx4_en_create_cq(struct mlx4_en_priv *priv,

		      struct mlx4_en_cq *cq,

		      int entries, int ring, enum cq_type mode)

{

	struct mlx4_en_dev *mdev = priv->mdev;

	int err;



	cq->size = entries;

	if (mode == RX)

		cq->buf_size = cq->size * sizeof(struct mlx4_cqe);

	else

		cq->buf_size = sizeof(struct mlx4_cqe);



	cq->ring = ring;

	cq->is_tx = mode;

	spin_lock_init(&cq->lock);



	err = mlx4_alloc_hwq_res(mdev->dev, &cq->wqres,

				cq->buf_size, 2 * PAGE_SIZE);

	if (err)

		return err;



	err = mlx4_en_map_buffer(&cq->wqres.buf);

	if (err)

		mlx4_free_hwq_res(mdev->dev, &cq->wqres, cq->buf_size);



	return err;

}



int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)

{

	struct mlx4_en_dev *mdev = priv->mdev;

	int err;



	cq->dev = mdev->pndev[priv->port];

	cq->mcq.set_ci_db  = cq->wqres.db.db;

	cq->mcq.arm_db     = cq->wqres.db.db + 1;

	*cq->mcq.set_ci_db = 0;

	*cq->mcq.arm_db    = 0;

	cq->buf = (struct mlx4_cqe *) cq->wqres.buf.direct.buf;

	memset(cq->buf, 0, cq->buf_size);



	err = mlx4_cq_alloc(mdev->dev, cq->size, &cq->wqres.mtt, &mdev->priv_uar,

			    cq->wqres.db.dma, &cq->mcq, cq->is_tx);

	if (err)

		return err;



	cq->mcq.comp  = cq->is_tx ? mlx4_en_tx_irq : mlx4_en_rx_irq;

	cq->mcq.event = mlx4_en_cq_event;



	if (cq->is_tx) {

		init_timer(&cq->timer);

		cq->timer.function = mlx4_en_poll_tx_cq;

		cq->timer.data = (unsigned long) cq;

	} else {

		netif_napi_add(cq->dev, &cq->napi, mlx4_en_poll_rx_cq, 64);

		napi_enable(&cq->napi);

	}



	return 0;

}



void mlx4_en_destroy_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)

{

	struct mlx4_en_dev *mdev = priv->mdev;



	mlx4_en_unmap_buffer(&cq->wqres.buf);

	mlx4_free_hwq_res(mdev->dev, &cq->wqres, cq->buf_size);

	cq->buf_size = 0;

	cq->buf = NULL;

}



void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)

{

	struct mlx4_en_dev *mdev = priv->mdev;



	if (cq->is_tx)

		del_timer(&cq->timer);

	else

		napi_disable(&cq->napi);



	mlx4_cq_free(mdev->dev, &cq->mcq);

}



/* Set rx cq moderation parameters */

int mlx4_en_set_cq_moder(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)

{

	return mlx4_cq_modify(priv->mdev->dev, &cq->mcq,

			      cq->moder_cnt, cq->moder_time);

}



int mlx4_en_arm_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)

{

	cq->armed = 1;

	mlx4_cq_arm(&cq->mcq, MLX4_CQ_DB_REQ_NOT, priv->mdev->uar_map,

		    &priv->mdev->uar_lock);



	return 0;

}

drivers/net/mlx4/en_main.c

0 → 100644
+254 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2007 Mellanox Technologies. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 */



#include <linux/cpumask.h>

#include <linux/module.h>

#include <linux/delay.h>

#include <linux/netdevice.h>

#include <linux/cpumask.h>



#include <linux/mlx4/driver.h>

#include <linux/mlx4/device.h>

#include <linux/mlx4/cmd.h>



#include "mlx4_en.h"



MODULE_AUTHOR("Liran Liss, Yevgeny Petrilin");

MODULE_DESCRIPTION("Mellanox ConnectX HCA Ethernet driver");

MODULE_LICENSE("Dual BSD/GPL");

MODULE_VERSION(DRV_VERSION " ("DRV_RELDATE")");



static const char mlx4_en_version[] =

	DRV_NAME ": Mellanox ConnectX HCA Ethernet driver v"

	DRV_VERSION " (" DRV_RELDATE ")\n";



static void mlx4_en_event(struct mlx4_dev *dev, void *endev_ptr,

			  enum mlx4_dev_event event, int port)

{

	struct mlx4_en_dev *mdev = (struct mlx4_en_dev *) endev_ptr;

	struct mlx4_en_priv *priv;



	if (!mdev->pndev[port])

		return;



	priv = netdev_priv(mdev->pndev[port]);

	switch (event) {

	case MLX4_DEV_EVENT_PORT_UP:

	case MLX4_DEV_EVENT_PORT_DOWN:

		/* To prevent races, we poll the link state in a separate

		  task rather than changing it here */

		priv->link_state = event;

		queue_work(mdev->workqueue, &priv->linkstate_task);

		break;



	case MLX4_DEV_EVENT_CATASTROPHIC_ERROR:

		mlx4_err(mdev, "Internal error detected, restarting device\n");

		break;



	default:

		mlx4_warn(mdev, "Unhandled event: %d\n", event);

	}

}



static void mlx4_en_remove(struct mlx4_dev *dev, void *endev_ptr)

{

	struct mlx4_en_dev *mdev = endev_ptr;

	int i;



	mutex_lock(&mdev->state_lock);

	mdev->device_up = false;

	mutex_unlock(&mdev->state_lock);



	mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH)

		if (mdev->pndev[i])

			mlx4_en_destroy_netdev(mdev->pndev[i]);



	flush_workqueue(mdev->workqueue);

	destroy_workqueue(mdev->workqueue);

	mlx4_mr_free(dev, &mdev->mr);

	mlx4_uar_free(dev, &mdev->priv_uar);

	mlx4_pd_free(dev, mdev->priv_pdn);

	kfree(mdev);

}



static void *mlx4_en_add(struct mlx4_dev *dev)

{

	static int mlx4_en_version_printed;

	struct mlx4_en_dev *mdev;

	int i;

	int err;



	if (!mlx4_en_version_printed) {

		printk(KERN_INFO "%s", mlx4_en_version);

		mlx4_en_version_printed++;

	}



	mdev = kzalloc(sizeof *mdev, GFP_KERNEL);

	if (!mdev) {

		dev_err(&dev->pdev->dev, "Device struct alloc failed, "

			"aborting.\n");

		err = -ENOMEM;

		goto err_free_res;

	}



	if (mlx4_pd_alloc(dev, &mdev->priv_pdn))

		goto err_free_dev;



	if (mlx4_uar_alloc(dev, &mdev->priv_uar))

		goto err_pd;



	mdev->uar_map = ioremap(mdev->priv_uar.pfn << PAGE_SHIFT, PAGE_SIZE);

	if (!mdev->uar_map)

		goto err_uar;

	spin_lock_init(&mdev->uar_lock);



	mdev->dev = dev;

	mdev->dma_device = &(dev->pdev->dev);

	mdev->pdev = dev->pdev;

	mdev->device_up = false;



	mdev->LSO_support = !!(dev->caps.flags & (1 << 15));

	if (!mdev->LSO_support)

		mlx4_warn(mdev, "LSO not supported, please upgrade to later "

				"FW version to enable LSO\n");



	if (mlx4_mr_alloc(mdev->dev, mdev->priv_pdn, 0, ~0ull,

			 MLX4_PERM_LOCAL_WRITE |  MLX4_PERM_LOCAL_READ,

			 0, 0, &mdev->mr)) {

		mlx4_err(mdev, "Failed allocating memory region\n");

		goto err_uar;

	}

	if (mlx4_mr_enable(mdev->dev, &mdev->mr)) {

		mlx4_err(mdev, "Failed enabling memory region\n");

		goto err_mr;

	}



	/* Build device profile according to supplied module parameters */

	err = mlx4_en_get_profile(mdev);

	if (err) {

		mlx4_err(mdev, "Bad module parameters, aborting.\n");

		goto err_mr;

	}



	/* Configure wich ports to start according to module parameters */

	mdev->port_cnt = 0;

	mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH)

		mdev->port_cnt++;



	/* If we did not receive an explicit number of Rx rings, default to

	 * the number of completion vectors populated by the mlx4_core */

	mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {

		mlx4_info(mdev, "Using %d tx rings for port:%d\n",

			  mdev->profile.prof[i].tx_ring_num, i);

		if (!mdev->profile.prof[i].rx_ring_num) {

			mdev->profile.prof[i].rx_ring_num = 1;

			mlx4_info(mdev, "Defaulting to %d rx rings for port:%d\n",

				  1, i);

		} else

			mlx4_info(mdev, "Using %d rx rings for port:%d\n",

				  mdev->profile.prof[i].rx_ring_num, i);

	}



	/* Create our own workqueue for reset/multicast tasks

	 * Note: we cannot use the shared workqueue because of deadlocks caused

	 *       by the rtnl lock */

	mdev->workqueue = create_singlethread_workqueue("mlx4_en");

	if (!mdev->workqueue) {

		err = -ENOMEM;

		goto err_close_nic;

	}



	/* At this stage all non-port specific tasks are complete:

	 * mark the card state as up */

	mutex_init(&mdev->state_lock);

	mdev->device_up = true;



	/* Setup ports */



	/* Create a netdev for each port */

	mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {

		mlx4_info(mdev, "Activating port:%d\n", i);

		if (mlx4_en_init_netdev(mdev, i, &mdev->profile.prof[i])) {

			mdev->pndev[i] = NULL;

			goto err_free_netdev;

		}

	}

	return mdev;





err_free_netdev:

	mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {

		if (mdev->pndev[i])

			mlx4_en_destroy_netdev(mdev->pndev[i]);

	}



	mutex_lock(&mdev->state_lock);

	mdev->device_up = false;

	mutex_unlock(&mdev->state_lock);

	flush_workqueue(mdev->workqueue);



	/* Stop event queue before we drop down to release shared SW state */



err_close_nic:

	destroy_workqueue(mdev->workqueue);

err_mr:

	mlx4_mr_free(dev, &mdev->mr);

err_uar:

	mlx4_uar_free(dev, &mdev->priv_uar);

err_pd:

	mlx4_pd_free(dev, mdev->priv_pdn);

err_free_dev:

	kfree(mdev);

err_free_res:

	return NULL;

}



static struct mlx4_interface mlx4_en_interface = {

	.add	= mlx4_en_add,

	.remove	= mlx4_en_remove,

	.event	= mlx4_en_event,

};



static int __init mlx4_en_init(void)

{

	return mlx4_register_interface(&mlx4_en_interface);

}



static void __exit mlx4_en_cleanup(void)

{

	mlx4_unregister_interface(&mlx4_en_interface);

}



module_init(mlx4_en_init);

module_exit(mlx4_en_cleanup);