drivers/net/ethernet/netronome/nfp/nfp_devlink.c

   1 /*
   2  * Copyright (C) 2017 Netronome Systems, Inc.
   3  *
   4  * This software is dual licensed under the GNU General License Version 2,
   5  * June 1991 as shown in the file COPYING in the top-level directory of this
   6  * source tree or the BSD 2-Clause License provided below.  You have the
   7  * option to license this software under the complete terms of either license.
   8  *
   9  * The BSD 2-Clause License:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      1. Redistributions of source code must retain the above
  16  *         copyright notice, this list of conditions and the following
  17  *         disclaimer.
  18  *
  19  *      2. Redistributions in binary form must reproduce the above
  20  *         copyright notice, this list of conditions and the following
  21  *         disclaimer in the documentation and/or other materials
  22  *         provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include <linux/rtnetlink.h>
  35 #include <net/devlink.h>
  36
  37 #include "nfpcore/nfp_nsp.h"
  38 #include "nfp_app.h"
  39 #include "nfp_main.h"
  40 #include "nfp_port.h"
  41
  42 static int
  43 nfp_devlink_fill_eth_port(struct nfp_port *port,
  44                           struct nfp_eth_table_port *copy)
  45 {
  46         struct nfp_eth_table_port *eth_port;
  47
  48         eth_port = __nfp_port_get_eth_port(port);
  49         if (!eth_port)
  50                 return -EINVAL;
  51
  52         memcpy(copy, eth_port, sizeof(*eth_port));
  53
  54         return 0;
  55 }
  56
  57 static int
  58 nfp_devlink_fill_eth_port_from_id(struct nfp_pf *pf, unsigned int port_index,
  59                                   struct nfp_eth_table_port *copy)
  60 {
  61         struct nfp_port *port;
  62
  63         port = nfp_port_from_id(pf, NFP_PORT_PHYS_PORT, port_index);
  64
  65         return nfp_devlink_fill_eth_port(port, copy);
  66 }
  67
  68 static int
  69 nfp_devlink_set_lanes(struct nfp_pf *pf, unsigned int idx, unsigned int lanes)
  70 {
  71         struct nfp_nsp *nsp;
  72         int ret;
  73
  74         nsp = nfp_eth_config_start(pf->cpp, idx);
  75         if (IS_ERR(nsp))
  76                 return PTR_ERR(nsp);
  77
  78         ret = __nfp_eth_set_split(nsp, lanes);
  79         if (ret) {
  80                 nfp_eth_config_cleanup_end(nsp);
  81                 return ret;
  82         }
  83
  84         ret = nfp_eth_config_commit_end(nsp);
  85         if (ret < 0)
  86                 return ret;
  87         if (ret) /* no change */
  88                 return 0;
  89
  90         return nfp_net_refresh_port_table_sync(pf);
  91 }
  92
  93 static int
  94 nfp_devlink_port_split(struct devlink *devlink, unsigned int port_index,
  95                        unsigned int count)
  96 {
  97         struct nfp_pf *pf = devlink_priv(devlink);
  98         struct nfp_eth_table_port eth_port;
  99         int ret;
 100
 101         if (count < 2)
 102                 return -EINVAL;
 103
 104         mutex_lock(&pf->lock);
 105
 106         rtnl_lock();
 107         ret = nfp_devlink_fill_eth_port_from_id(pf, port_index, &eth_port);
 108         rtnl_unlock();
 109         if (ret)
 110                 goto out;
 111
 112         if (eth_port.is_split || eth_port.port_lanes % count) {
 113                 ret = -EINVAL;
 114                 goto out;
 115         }
 116
 117         ret = nfp_devlink_set_lanes(pf, eth_port.index,
 118                                     eth_port.port_lanes / count);
 119 out:
 120         mutex_unlock(&pf->lock);
 121
 122         return ret;
 123 }
 124
 125 static int
 126 nfp_devlink_port_unsplit(struct devlink *devlink, unsigned int port_index)
 127 {
 128         struct nfp_pf *pf = devlink_priv(devlink);
 129         struct nfp_eth_table_port eth_port;
 130         int ret;
 131
 132         mutex_lock(&pf->lock);
 133
 134         rtnl_lock();
 135         ret = nfp_devlink_fill_eth_port_from_id(pf, port_index, &eth_port);
 136         rtnl_unlock();
 137         if (ret)
 138                 goto out;
 139
 140         if (!eth_port.is_split) {
 141                 ret = -EINVAL;
 142                 goto out;
 143         }
 144
 145         ret = nfp_devlink_set_lanes(pf, eth_port.index, eth_port.port_lanes);
 146 out:
 147         mutex_unlock(&pf->lock);
 148
 149         return ret;
 150 }
 151
 152 static int nfp_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 153 {
 154         struct nfp_pf *pf = devlink_priv(devlink);
 155         int ret;
 156
 157         mutex_lock(&pf->lock);
 158         if (!pf->app) {
 159                 ret = -EBUSY;
 160                 goto out;
 161         }
 162         ret = nfp_app_eswitch_mode_get(pf->app, mode);
 163 out:
 164         mutex_unlock(&pf->lock);
 165
 166         return ret;
 167 }
 168
 169 const struct devlink_ops nfp_devlink_ops = {
 170         .port_split             = nfp_devlink_port_split,
 171         .port_unsplit           = nfp_devlink_port_unsplit,
 172         .eswitch_mode_get       = nfp_devlink_eswitch_mode_get,
 173 };
 174
 175 int nfp_devlink_port_register(struct nfp_app *app, struct nfp_port *port)
 176 {
 177         struct nfp_eth_table_port eth_port;
 178         struct devlink *devlink;
 179         int ret;
 180
 181         rtnl_lock();
 182         ret = nfp_devlink_fill_eth_port(port, &eth_port);
 183         rtnl_unlock();
 184         if (ret)
 185                 return ret;
 186
 187         devlink_port_type_eth_set(&port->dl_port, port->netdev);
 188         if (eth_port.is_split)
 189                 devlink_port_split_set(&port->dl_port, eth_port.label_port);
 190
 191         devlink = priv_to_devlink(app->pf);
 192
 193         return devlink_port_register(devlink, &port->dl_port, port->eth_id);
 194 }
 195
 196 void nfp_devlink_port_unregister(struct nfp_port *port)
 197 {
 198         devlink_port_unregister(&port->dl_port);
 199 }