drivers/net/ethernet/freescale/dpaa2/dpaa2-eth-devlink.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 #include "dpaa2-eth.h"
   3 /* Copyright 2020 NXP
   4  */
   5
   6 #define DPAA2_ETH_TRAP_DROP(_id, _group_id)                                     \
   7         DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                                   \
   8                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, 0)
   9
  10 static const struct devlink_trap_group dpaa2_eth_trap_groups_arr[] = {
  11         DEVLINK_TRAP_GROUP_GENERIC(PARSER_ERROR_DROPS, 0),
  12 };
  13
  14 static const struct devlink_trap dpaa2_eth_traps_arr[] = {
  15         DPAA2_ETH_TRAP_DROP(VXLAN_PARSING, PARSER_ERROR_DROPS),
  16         DPAA2_ETH_TRAP_DROP(LLC_SNAP_PARSING, PARSER_ERROR_DROPS),
  17         DPAA2_ETH_TRAP_DROP(VLAN_PARSING, PARSER_ERROR_DROPS),
  18         DPAA2_ETH_TRAP_DROP(PPPOE_PPP_PARSING, PARSER_ERROR_DROPS),
  19         DPAA2_ETH_TRAP_DROP(MPLS_PARSING, PARSER_ERROR_DROPS),
  20         DPAA2_ETH_TRAP_DROP(ARP_PARSING, PARSER_ERROR_DROPS),
  21         DPAA2_ETH_TRAP_DROP(IP_1_PARSING, PARSER_ERROR_DROPS),
  22         DPAA2_ETH_TRAP_DROP(IP_N_PARSING, PARSER_ERROR_DROPS),
  23         DPAA2_ETH_TRAP_DROP(GRE_PARSING, PARSER_ERROR_DROPS),
  24         DPAA2_ETH_TRAP_DROP(UDP_PARSING, PARSER_ERROR_DROPS),
  25         DPAA2_ETH_TRAP_DROP(TCP_PARSING, PARSER_ERROR_DROPS),
  26         DPAA2_ETH_TRAP_DROP(IPSEC_PARSING, PARSER_ERROR_DROPS),
  27         DPAA2_ETH_TRAP_DROP(SCTP_PARSING, PARSER_ERROR_DROPS),
  28         DPAA2_ETH_TRAP_DROP(DCCP_PARSING, PARSER_ERROR_DROPS),
  29         DPAA2_ETH_TRAP_DROP(GTP_PARSING, PARSER_ERROR_DROPS),
  30         DPAA2_ETH_TRAP_DROP(ESP_PARSING, PARSER_ERROR_DROPS),
  31 };
  32
  33 static int dpaa2_eth_dl_info_get(struct devlink *devlink,
  34                                  struct devlink_info_req *req,
  35                                  struct netlink_ext_ack *extack)
  36 {
  37         struct dpaa2_eth_devlink_priv *dl_priv = devlink_priv(devlink);
  38         struct dpaa2_eth_priv *priv = dl_priv->dpaa2_priv;
  39         char buf[10];
  40         int err;
  41
  42         err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
  43         if (err)
  44                 return err;
  45
  46         scnprintf(buf, 10, "%d.%d", priv->dpni_ver_major, priv->dpni_ver_minor);
  47         err = devlink_info_version_running_put(req, "dpni", buf);
  48         if (err)
  49                 return err;
  50
  51         return 0;
  52 }
  53
  54 static struct dpaa2_eth_trap_item *
  55 dpaa2_eth_dl_trap_item_lookup(struct dpaa2_eth_priv *priv, u16 trap_id)
  56 {
  57         struct dpaa2_eth_trap_data *dpaa2_eth_trap_data = priv->trap_data;
  58         int i;
  59
  60         for (i = 0; i < ARRAY_SIZE(dpaa2_eth_traps_arr); i++) {
  61                 if (dpaa2_eth_traps_arr[i].id == trap_id)
  62                         return &dpaa2_eth_trap_data->trap_items_arr[i];
  63         }
  64
  65         return NULL;
  66 }
  67
  68 struct dpaa2_eth_trap_item *dpaa2_eth_dl_get_trap(struct dpaa2_eth_priv *priv,
  69                                                   struct dpaa2_fapr *fapr)
  70 {
  71         static const struct dpaa2_faf_error_bit {
  72                 int position;
  73                 enum devlink_trap_generic_id trap_id;
  74         } faf_bits[] = {
  75                 { .position = 5,  .trap_id = DEVLINK_TRAP_GENERIC_ID_VXLAN_PARSING },
  76                 { .position = 20, .trap_id = DEVLINK_TRAP_GENERIC_ID_LLC_SNAP_PARSING },
  77                 { .position = 24, .trap_id = DEVLINK_TRAP_GENERIC_ID_VLAN_PARSING },
  78                 { .position = 26, .trap_id = DEVLINK_TRAP_GENERIC_ID_PPPOE_PPP_PARSING },
  79                 { .position = 29, .trap_id = DEVLINK_TRAP_GENERIC_ID_MPLS_PARSING },
  80                 { .position = 31, .trap_id = DEVLINK_TRAP_GENERIC_ID_ARP_PARSING },
  81                 { .position = 52, .trap_id = DEVLINK_TRAP_GENERIC_ID_IP_1_PARSING },
  82                 { .position = 61, .trap_id = DEVLINK_TRAP_GENERIC_ID_IP_N_PARSING },
  83                 { .position = 67, .trap_id = DEVLINK_TRAP_GENERIC_ID_GRE_PARSING },
  84                 { .position = 71, .trap_id = DEVLINK_TRAP_GENERIC_ID_UDP_PARSING },
  85                 { .position = 76, .trap_id = DEVLINK_TRAP_GENERIC_ID_TCP_PARSING },
  86                 { .position = 80, .trap_id = DEVLINK_TRAP_GENERIC_ID_IPSEC_PARSING },
  87                 { .position = 82, .trap_id = DEVLINK_TRAP_GENERIC_ID_SCTP_PARSING },
  88                 { .position = 84, .trap_id = DEVLINK_TRAP_GENERIC_ID_DCCP_PARSING },
  89                 { .position = 88, .trap_id = DEVLINK_TRAP_GENERIC_ID_GTP_PARSING },
  90                 { .position = 90, .trap_id = DEVLINK_TRAP_GENERIC_ID_ESP_PARSING },
  91         };
  92         u64 faf_word;
  93         u64 mask;
  94         int i;
  95
  96         for (i = 0; i < ARRAY_SIZE(faf_bits); i++) {
  97                 if (faf_bits[i].position < 32) {
  98                         /* Low part of FAF.
  99                          * position ranges from 31 to 0, mask from 0 to 31.
 100                          */
 101                         mask = 1ull << (31 - faf_bits[i].position);
 102                         faf_word = __le32_to_cpu(fapr->faf_lo);
 103                 } else {
 104                         /* High part of FAF.
 105                          * position ranges from 95 to 32, mask from 0 to 63.
 106                          */
 107                         mask = 1ull << (63 - (faf_bits[i].position - 32));
 108                         faf_word = __le64_to_cpu(fapr->faf_hi);
 109                 }
 110                 if (faf_word & mask)
 111                         return dpaa2_eth_dl_trap_item_lookup(priv, faf_bits[i].trap_id);
 112         }
 113         return NULL;
 114 }
 115
 116 static int dpaa2_eth_dl_trap_init(struct devlink *devlink,
 117                                   const struct devlink_trap *trap,
 118                                   void *trap_ctx)
 119 {
 120         struct dpaa2_eth_devlink_priv *dl_priv = devlink_priv(devlink);
 121         struct dpaa2_eth_priv *priv = dl_priv->dpaa2_priv;
 122         struct dpaa2_eth_trap_item *dpaa2_eth_trap_item;
 123
 124         dpaa2_eth_trap_item = dpaa2_eth_dl_trap_item_lookup(priv, trap->id);
 125         if (WARN_ON(!dpaa2_eth_trap_item))
 126                 return -ENOENT;
 127
 128         dpaa2_eth_trap_item->trap_ctx = trap_ctx;
 129
 130         return 0;
 131 }
 132
 133 static int dpaa2_eth_dl_trap_action_set(struct devlink *devlink,
 134                                         const struct devlink_trap *trap,
 135                                         enum devlink_trap_action action,
 136                                         struct netlink_ext_ack *extack)
 137 {
 138         /* No support for changing the action of an independent packet trap,
 139          * only per trap group - parser error drops
 140          */
 141         NL_SET_ERR_MSG_MOD(extack,
 142                            "Cannot change trap action independently of group");
 143         return -EOPNOTSUPP;
 144 }
 145
 146 static int dpaa2_eth_dl_trap_group_action_set(struct devlink *devlink,
 147                                               const struct devlink_trap_group *group,
 148                                               enum devlink_trap_action action,
 149                                               struct netlink_ext_ack *extack)
 150 {
 151         struct dpaa2_eth_devlink_priv *dl_priv = devlink_priv(devlink);
 152         struct dpaa2_eth_priv *priv = dl_priv->dpaa2_priv;
 153         struct net_device *net_dev = priv->net_dev;
 154         struct device *dev = net_dev->dev.parent;
 155         struct dpni_error_cfg err_cfg = {0};
 156         int err;
 157
 158         if (group->id != DEVLINK_TRAP_GROUP_GENERIC_ID_PARSER_ERROR_DROPS)
 159                 return -EOPNOTSUPP;
 160
 161         /* Configure handling of frames marked as errors from the parser */
 162         err_cfg.errors = DPAA2_FAS_RX_ERR_MASK;
 163         err_cfg.set_frame_annotation = 1;
 164
 165         switch (action) {
 166         case DEVLINK_TRAP_ACTION_DROP:
 167                 err_cfg.error_action = DPNI_ERROR_ACTION_DISCARD;
 168                 break;
 169         case DEVLINK_TRAP_ACTION_TRAP:
 170                 err_cfg.error_action = DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE;
 171                 break;
 172         default:
 173                 return -EOPNOTSUPP;
 174         }
 175
 176         err = dpni_set_errors_behavior(priv->mc_io, 0, priv->mc_token, &err_cfg);
 177         if (err) {
 178                 dev_err(dev, "dpni_set_errors_behavior failed\n");
 179                 return err;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static const struct devlink_ops dpaa2_eth_devlink_ops = {
 186         .info_get = dpaa2_eth_dl_info_get,
 187         .trap_init = dpaa2_eth_dl_trap_init,
 188         .trap_action_set = dpaa2_eth_dl_trap_action_set,
 189         .trap_group_action_set = dpaa2_eth_dl_trap_group_action_set,
 190 };
 191
 192 int dpaa2_eth_dl_register(struct dpaa2_eth_priv *priv)
 193 {
 194         struct net_device *net_dev = priv->net_dev;
 195         struct device *dev = net_dev->dev.parent;
 196         struct dpaa2_eth_devlink_priv *dl_priv;
 197         int err;
 198
 199         priv->devlink = devlink_alloc(&dpaa2_eth_devlink_ops, sizeof(*dl_priv));
 200         if (!priv->devlink) {
 201                 dev_err(dev, "devlink_alloc failed\n");
 202                 return -ENOMEM;
 203         }
 204         dl_priv = devlink_priv(priv->devlink);
 205         dl_priv->dpaa2_priv = priv;
 206
 207         err = devlink_register(priv->devlink, dev);
 208         if (err) {
 209                 dev_err(dev, "devlink_register() = %d\n", err);
 210                 goto devlink_free;
 211         }
 212
 213         return 0;
 214
 215 devlink_free:
 216         devlink_free(priv->devlink);
 217
 218         return err;
 219 }
 220
 221 void dpaa2_eth_dl_unregister(struct dpaa2_eth_priv *priv)
 222 {
 223         devlink_unregister(priv->devlink);
 224         devlink_free(priv->devlink);
 225 }
 226
 227 int dpaa2_eth_dl_port_add(struct dpaa2_eth_priv *priv)
 228 {
 229         struct devlink_port *devlink_port = &priv->devlink_port;
 230         struct devlink_port_attrs attrs = {};
 231         int err;
 232
 233         attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
 234         devlink_port_attrs_set(devlink_port, &attrs);
 235
 236         err = devlink_port_register(priv->devlink, devlink_port, 0);
 237         if (err)
 238                 return err;
 239
 240         devlink_port_type_eth_set(devlink_port, priv->net_dev);
 241
 242         return 0;
 243 }
 244
 245 void dpaa2_eth_dl_port_del(struct dpaa2_eth_priv *priv)
 246 {
 247         struct devlink_port *devlink_port = &priv->devlink_port;
 248
 249         devlink_port_type_clear(devlink_port);
 250         devlink_port_unregister(devlink_port);
 251 }
 252
 253 int dpaa2_eth_dl_traps_register(struct dpaa2_eth_priv *priv)
 254 {
 255         struct dpaa2_eth_trap_data *dpaa2_eth_trap_data;
 256         struct net_device *net_dev = priv->net_dev;
 257         struct device *dev = net_dev->dev.parent;
 258         int err;
 259
 260         dpaa2_eth_trap_data = kzalloc(sizeof(*dpaa2_eth_trap_data), GFP_KERNEL);
 261         if (!dpaa2_eth_trap_data)
 262                 return -ENOMEM;
 263         priv->trap_data = dpaa2_eth_trap_data;
 264
 265         dpaa2_eth_trap_data->trap_items_arr = kcalloc(ARRAY_SIZE(dpaa2_eth_traps_arr),
 266                                                       sizeof(struct dpaa2_eth_trap_item),
 267                                                       GFP_KERNEL);
 268         if (!dpaa2_eth_trap_data->trap_items_arr) {
 269                 err = -ENOMEM;
 270                 goto trap_data_free;
 271         }
 272
 273         err = devlink_trap_groups_register(priv->devlink, dpaa2_eth_trap_groups_arr,
 274                                            ARRAY_SIZE(dpaa2_eth_trap_groups_arr));
 275         if (err) {
 276                 dev_err(dev, "devlink_trap_groups_register() = %d\n", err);
 277                 goto trap_items_arr_free;
 278         }
 279
 280         err = devlink_traps_register(priv->devlink, dpaa2_eth_traps_arr,
 281                                      ARRAY_SIZE(dpaa2_eth_traps_arr), priv);
 282         if (err) {
 283                 dev_err(dev, "devlink_traps_register() = %d\n", err);
 284                 goto trap_groups_unregiser;
 285         }
 286
 287         return 0;
 288
 289 trap_groups_unregiser:
 290         devlink_trap_groups_unregister(priv->devlink, dpaa2_eth_trap_groups_arr,
 291                                        ARRAY_SIZE(dpaa2_eth_trap_groups_arr));
 292 trap_items_arr_free:
 293         kfree(dpaa2_eth_trap_data->trap_items_arr);
 294 trap_data_free:
 295         kfree(dpaa2_eth_trap_data);
 296         priv->trap_data = NULL;
 297
 298         return err;
 299 }
 300
 301 void dpaa2_eth_dl_traps_unregister(struct dpaa2_eth_priv *priv)
 302 {
 303         devlink_traps_unregister(priv->devlink, dpaa2_eth_traps_arr,
 304                                  ARRAY_SIZE(dpaa2_eth_traps_arr));
 305         devlink_trap_groups_unregister(priv->devlink, dpaa2_eth_trap_groups_arr,
 306                                        ARRAY_SIZE(dpaa2_eth_trap_groups_arr));
 307         kfree(priv->trap_data->trap_items_arr);
 308         kfree(priv->trap_data);
 309 }