mlx4_en: Add driver for Mellanox ConnectX 10GbE NIC (c27a02cd) · Commits · e / devices / android_kernel_teracube_mt6765

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);

drivers/net/mlx4/en_netdev.c

0 → 100644

+1088 −0

File added.

Preview size limit exceeded, changes collapsed.