Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlx4 / main.c

diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index f8674ae62752d53bc768c16ac9b2de3053e183eb..503ec23e84cce68e6e47613ea9dc495dae9942cd 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -42,6 +42,7 @@
 #include <linux/io-mapping.h>
 #include <linux/delay.h>
 #include <linux/kmod.h>
+#include <net/devlink.h>
 
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/doorbell.h>
@@ -1081,36 +1082,20 @@ static ssize_t show_port_type(struct device *dev,
        return strlen(buf);
 }
 
-static ssize_t set_port_type(struct device *dev,
-                            struct device_attribute *attr,
-                            const char *buf, size_t count)
+static int __set_port_type(struct mlx4_port_info *info,
+                          enum mlx4_port_type port_type)
 {
-       struct mlx4_port_info *info = container_of(attr, struct mlx4_port_info,
-                                                  port_attr);
        struct mlx4_dev *mdev = info->dev;
        struct mlx4_priv *priv = mlx4_priv(mdev);
        enum mlx4_port_type types[MLX4_MAX_PORTS];
        enum mlx4_port_type new_types[MLX4_MAX_PORTS];
-       static DEFINE_MUTEX(set_port_type_mutex);
        int i;
        int err = 0;
 
-       mutex_lock(&set_port_type_mutex);
-
-       if (!strcmp(buf, "ib\n"))
-               info->tmp_type = MLX4_PORT_TYPE_IB;
-       else if (!strcmp(buf, "eth\n"))
-               info->tmp_type = MLX4_PORT_TYPE_ETH;
-       else if (!strcmp(buf, "auto\n"))
-               info->tmp_type = MLX4_PORT_TYPE_AUTO;
-       else {
-               mlx4_err(mdev, "%s is not supported port type\n", buf);
-               err = -EINVAL;
-               goto err_out;
-       }
-
        mlx4_stop_sense(mdev);
        mutex_lock(&priv->port_mutex);
+       info->tmp_type = port_type;
+
        /* Possible type is always the one that was delivered */
        mdev->caps.possible_type[info->port] = info->tmp_type;
 
@@ -1152,6 +1137,37 @@ static ssize_t set_port_type(struct device *dev,
 out:
        mlx4_start_sense(mdev);
        mutex_unlock(&priv->port_mutex);
+
+       return err;
+}
+
+static ssize_t set_port_type(struct device *dev,
+                            struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+       struct mlx4_port_info *info = container_of(attr, struct mlx4_port_info,
+                                                  port_attr);
+       struct mlx4_dev *mdev = info->dev;
+       enum mlx4_port_type port_type;
+       static DEFINE_MUTEX(set_port_type_mutex);
+       int err;
+
+       mutex_lock(&set_port_type_mutex);
+
+       if (!strcmp(buf, "ib\n")) {
+               port_type = MLX4_PORT_TYPE_IB;
+       } else if (!strcmp(buf, "eth\n")) {
+               port_type = MLX4_PORT_TYPE_ETH;
+       } else if (!strcmp(buf, "auto\n")) {
+               port_type = MLX4_PORT_TYPE_AUTO;
+       } else {
+               mlx4_err(mdev, "%s is not supported port type\n", buf);
+               err = -EINVAL;
+               goto err_out;
+       }
+
+       err = __set_port_type(info, port_type);
+
 err_out:
        mutex_unlock(&set_port_type_mutex);
 
@@ -2889,8 +2905,13 @@ no_msi:
 
 static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
 {
+       struct devlink *devlink = priv_to_devlink(mlx4_priv(dev));
        struct mlx4_port_info *info = &mlx4_priv(dev)->port[port];
-       int err = 0;
+       int err;
+
+       err = devlink_port_register(devlink, &info->devlink_port, port);
+       if (err)
+               return err;
 
        info->dev = dev;
        info->port = port;
@@ -2915,6 +2936,7 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
        err = device_create_file(&dev->persist->pdev->dev, &info->port_attr);
        if (err) {
                mlx4_err(dev, "Failed to create file for port %d\n", port);
+               devlink_port_unregister(&info->devlink_port);
                info->port = -1;
        }
 
@@ -3686,23 +3708,54 @@ err_disable_pdev:
        return err;
 }
 
+static int mlx4_devlink_port_type_set(struct devlink_port *devlink_port,
+                                     enum devlink_port_type port_type)
+{
+       struct mlx4_port_info *info = container_of(devlink_port,
+                                                  struct mlx4_port_info,
+                                                  devlink_port);
+       enum mlx4_port_type mlx4_port_type;
+
+       switch (port_type) {
+       case DEVLINK_PORT_TYPE_AUTO:
+               mlx4_port_type = MLX4_PORT_TYPE_AUTO;
+               break;
+       case DEVLINK_PORT_TYPE_ETH:
+               mlx4_port_type = MLX4_PORT_TYPE_ETH;
+               break;
+       case DEVLINK_PORT_TYPE_IB:
+               mlx4_port_type = MLX4_PORT_TYPE_IB;
+               break;
+       default:
+               return -EOPNOTSUPP;
+       }
+
+       return __set_port_type(info, mlx4_port_type);
+}
+
+static const struct devlink_ops mlx4_devlink_ops = {
+       .port_type_set  = mlx4_devlink_port_type_set,
+};
+
 static int mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
+       struct devlink *devlink;
        struct mlx4_priv *priv;
        struct mlx4_dev *dev;
        int ret;
 
        printk_once(KERN_INFO "%s", mlx4_version);
 
-       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-       if (!priv)
+       devlink = devlink_alloc(&mlx4_devlink_ops, sizeof(*priv));
+       if (!devlink)
                return -ENOMEM;
+       priv = devlink_priv(devlink);
 
        dev       = &priv->dev;
        dev->persist = kzalloc(sizeof(*dev->persist), GFP_KERNEL);
        if (!dev->persist) {
-               kfree(priv);
-               return -ENOMEM;
+               ret = -ENOMEM;
+               goto err_devlink_free;
        }
        dev->persist->pdev = pdev;
        dev->persist->dev = dev;
@@ -3711,14 +3764,23 @@ static int mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        mutex_init(&dev->persist->device_state_mutex);
        mutex_init(&dev->persist->interface_state_mutex);
 
+       ret = devlink_register(devlink, &pdev->dev);
+       if (ret)
+               goto err_persist_free;
+
        ret =  __mlx4_init_one(pdev, id->driver_data, priv);
-       if (ret) {
-               kfree(dev->persist);
-               kfree(priv);
-       } else {
-               pci_save_state(pdev);
-       }
+       if (ret)
+               goto err_devlink_unregister;
 
+       pci_save_state(pdev);
+       return 0;
+
+err_devlink_unregister:
+       devlink_unregister(devlink);
+err_persist_free:
+       kfree(dev->persist);
+err_devlink_free:
+       devlink_free(devlink);
        return ret;
 }
 
@@ -3819,6 +3881,7 @@ static void mlx4_remove_one(struct pci_dev *pdev)
        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
        struct mlx4_dev  *dev  = persist->dev;
        struct mlx4_priv *priv = mlx4_priv(dev);
+       struct devlink *devlink = priv_to_devlink(priv);
        int active_vfs = 0;
 
        mutex_lock(&persist->interface_state_mutex);
@@ -3849,8 +3912,9 @@ static void mlx4_remove_one(struct pci_dev *pdev)
 
        pci_release_regions(pdev);
        pci_disable_device(pdev);
+       devlink_unregister(devlink);
        kfree(dev->persist);
-       kfree(priv);
+       devlink_free(devlink);
        pci_set_drvdata(pdev, NULL);
 }