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

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4 #include <linux/lockdep.h>
   5 #include <linux/netdevice.h>
   6
   7 #include "nfpcore/nfp_cpp.h"
   8 #include "nfpcore/nfp_nsp.h"
   9 #include "nfp_app.h"
  10 #include "nfp_main.h"
  11 #include "nfp_net.h"
  12 #include "nfp_port.h"
  13
  14 struct nfp_port *nfp_port_from_netdev(struct net_device *netdev)
  15 {
  16         if (nfp_netdev_is_nfp_net(netdev)) {
  17                 struct nfp_net *nn = netdev_priv(netdev);
  18
  19                 return nn->port;
  20         }
  21
  22         if (nfp_netdev_is_nfp_repr(netdev)) {
  23                 struct nfp_repr *repr = netdev_priv(netdev);
  24
  25                 return repr->port;
  26         }
  27
  28         WARN(1, "Unknown netdev type for nfp_port\n");
  29
  30         return NULL;
  31 }
  32
  33 int nfp_port_get_port_parent_id(struct net_device *netdev,
  34                                 struct netdev_phys_item_id *ppid)
  35 {
  36         struct nfp_port *port;
  37         const u8 *serial;
  38
  39         port = nfp_port_from_netdev(netdev);
  40         if (!port)
  41                 return -EOPNOTSUPP;
  42
  43         ppid->id_len = nfp_cpp_serial(port->app->cpp, &serial);
  44         memcpy(&ppid->id, serial, ppid->id_len);
  45
  46         return 0;
  47 }
  48
  49 int nfp_port_setup_tc(struct net_device *netdev, enum tc_setup_type type,
  50                       void *type_data)
  51 {
  52         struct nfp_port *port;
  53
  54         port = nfp_port_from_netdev(netdev);
  55         if (!port)
  56                 return -EOPNOTSUPP;
  57
  58         return nfp_app_setup_tc(port->app, netdev, type, type_data);
  59 }
  60
  61 int nfp_port_set_features(struct net_device *netdev, netdev_features_t features)
  62 {
  63         struct nfp_port *port;
  64
  65         port = nfp_port_from_netdev(netdev);
  66         if (!port)
  67                 return 0;
  68
  69         if ((netdev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&
  70             port->tc_offload_cnt) {
  71                 netdev_err(netdev, "Cannot disable HW TC offload while offloads active\n");
  72                 return -EBUSY;
  73         }
  74
  75         return 0;
  76 }
  77
  78 struct nfp_port *
  79 nfp_port_from_id(struct nfp_pf *pf, enum nfp_port_type type, unsigned int id)
  80 {
  81         struct devlink *devlink = priv_to_devlink(pf);
  82         struct nfp_port *port;
  83
  84         devl_assert_locked(devlink);
  85
  86         if (type != NFP_PORT_PHYS_PORT)
  87                 return NULL;
  88
  89         list_for_each_entry(port, &pf->ports, port_list)
  90                 if (port->eth_id == id)
  91                         return port;
  92
  93         return NULL;
  94 }
  95
  96 struct nfp_eth_table_port *__nfp_port_get_eth_port(struct nfp_port *port)
  97 {
  98         if (!port)
  99                 return NULL;
 100         if (port->type != NFP_PORT_PHYS_PORT)
 101                 return NULL;
 102
 103         return port->eth_port;
 104 }
 105
 106 struct nfp_eth_table_port *nfp_port_get_eth_port(struct nfp_port *port)
 107 {
 108         if (!__nfp_port_get_eth_port(port))
 109                 return NULL;
 110
 111         if (test_bit(NFP_PORT_CHANGED, &port->flags))
 112                 if (nfp_net_refresh_eth_port(port))
 113                         return NULL;
 114
 115         return __nfp_port_get_eth_port(port);
 116 }
 117
 118 int
 119 nfp_port_get_phys_port_name(struct net_device *netdev, char *name, size_t len)
 120 {
 121         struct nfp_eth_table_port *eth_port;
 122         struct nfp_port *port;
 123         int n;
 124
 125         port = nfp_port_from_netdev(netdev);
 126         if (!port)
 127                 return -EOPNOTSUPP;
 128
 129         switch (port->type) {
 130         case NFP_PORT_PHYS_PORT:
 131                 eth_port = __nfp_port_get_eth_port(port);
 132                 if (!eth_port)
 133                         return -EOPNOTSUPP;
 134
 135                 if (!eth_port->is_split)
 136                         n = snprintf(name, len, "p%d", eth_port->label_port);
 137                 else
 138                         n = snprintf(name, len, "p%ds%d", eth_port->label_port,
 139                                      eth_port->label_subport);
 140                 break;
 141         case NFP_PORT_PF_PORT:
 142                 if (!port->pf_split)
 143                         n = snprintf(name, len, "pf%d", port->pf_id);
 144                 else
 145                         n = snprintf(name, len, "pf%ds%d", port->pf_id,
 146                                      port->pf_split_id);
 147                 break;
 148         case NFP_PORT_VF_PORT:
 149                 n = snprintf(name, len, "pf%dvf%d", port->pf_id, port->vf_id);
 150                 break;
 151         default:
 152                 return -EOPNOTSUPP;
 153         }
 154
 155         if (n >= len)
 156                 return -EINVAL;
 157
 158         return 0;
 159 }
 160
 161 /**
 162  * nfp_port_configure() - helper to set the interface configured bit
 163  * @netdev:     net_device instance
 164  * @configed:   Desired state
 165  *
 166  * Helper to set the ifup/ifdown state on the PHY only if there is a physical
 167  * interface associated with the netdev.
 168  *
 169  * Return:
 170  * 0 - configuration successful (or no change);
 171  * -ERRNO - configuration failed.
 172  */
 173 int nfp_port_configure(struct net_device *netdev, bool configed)
 174 {
 175         struct nfp_eth_table_port *eth_port;
 176         struct nfp_port *port;
 177         int err;
 178
 179         port = nfp_port_from_netdev(netdev);
 180         eth_port = __nfp_port_get_eth_port(port);
 181         if (!eth_port)
 182                 return 0;
 183         if (port->eth_forced)
 184                 return 0;
 185
 186         err = nfp_eth_set_configured(port->app->cpp, eth_port->index, configed);
 187         return err < 0 && err != -EOPNOTSUPP ? err : 0;
 188 }
 189
 190 int nfp_port_init_phy_port(struct nfp_pf *pf, struct nfp_app *app,
 191                            struct nfp_port *port, unsigned int id)
 192 {
 193         /* Check if vNIC has external port associated and cfg is OK */
 194         if (!pf->eth_tbl || id >= pf->eth_tbl->count) {
 195                 nfp_err(app->cpp,
 196                         "NSP port entries don't match vNICs (no entry %d)\n",
 197                         id);
 198                 return -EINVAL;
 199         }
 200         if (pf->eth_tbl->ports[id].override_changed) {
 201                 nfp_warn(app->cpp,
 202                          "Config changed for port #%d, reboot required before port will be operational\n",
 203                          pf->eth_tbl->ports[id].index);
 204                 port->type = NFP_PORT_INVALID;
 205                 return 0;
 206         }
 207
 208         port->eth_port = &pf->eth_tbl->ports[id];
 209         port->eth_id = pf->eth_tbl->ports[id].index;
 210         if (pf->mac_stats_mem)
 211                 port->eth_stats =
 212                         pf->mac_stats_mem + port->eth_id * NFP_MAC_STATS_SIZE;
 213
 214         return 0;
 215 }
 216
 217 struct nfp_port *
 218 nfp_port_alloc(struct nfp_app *app, enum nfp_port_type type,
 219                struct net_device *netdev)
 220 {
 221         struct nfp_port *port;
 222
 223         port = kzalloc(sizeof(*port), GFP_KERNEL);
 224         if (!port)
 225                 return ERR_PTR(-ENOMEM);
 226
 227         port->netdev = netdev;
 228         port->type = type;
 229         port->app = app;
 230
 231         list_add_tail(&port->port_list, &app->pf->ports);
 232
 233         return port;
 234 }
 235
 236 void nfp_port_free(struct nfp_port *port)
 237 {
 238         if (!port)
 239                 return;
 240         list_del(&port->port_list);
 241         kfree(port);
 242 }