drivers/net/ethernet/marvell/prestera/prestera_flow.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2020 Marvell International Ltd. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/list.h>
   6
   7 #include "prestera.h"
   8 #include "prestera_acl.h"
   9 #include "prestera_flow.h"
  10 #include "prestera_span.h"
  11 #include "prestera_flower.h"
  12
  13 static LIST_HEAD(prestera_block_cb_list);
  14
  15 static int prestera_flow_block_mall_cb(struct prestera_flow_block *block,
  16                                        struct tc_cls_matchall_offload *f)
  17 {
  18         switch (f->command) {
  19         case TC_CLSMATCHALL_REPLACE:
  20                 return prestera_span_replace(block, f);
  21         case TC_CLSMATCHALL_DESTROY:
  22                 prestera_span_destroy(block);
  23                 return 0;
  24         default:
  25                 return -EOPNOTSUPP;
  26         }
  27 }
  28
  29 static int prestera_flow_block_flower_cb(struct prestera_flow_block *block,
  30                                          struct flow_cls_offload *f)
  31 {
  32         if (f->common.chain_index != 0)
  33                 return -EOPNOTSUPP;
  34
  35         switch (f->command) {
  36         case FLOW_CLS_REPLACE:
  37                 return prestera_flower_replace(block, f);
  38         case FLOW_CLS_DESTROY:
  39                 prestera_flower_destroy(block, f);
  40                 return 0;
  41         case FLOW_CLS_STATS:
  42                 return prestera_flower_stats(block, f);
  43         default:
  44                 return -EOPNOTSUPP;
  45         }
  46 }
  47
  48 static int prestera_flow_block_cb(enum tc_setup_type type,
  49                                   void *type_data, void *cb_priv)
  50 {
  51         struct prestera_flow_block *block = cb_priv;
  52
  53         switch (type) {
  54         case TC_SETUP_CLSFLOWER:
  55                 return prestera_flow_block_flower_cb(block, type_data);
  56         case TC_SETUP_CLSMATCHALL:
  57                 return prestera_flow_block_mall_cb(block, type_data);
  58         default:
  59                 return -EOPNOTSUPP;
  60         }
  61 }
  62
  63 static void prestera_flow_block_release(void *cb_priv)
  64 {
  65         struct prestera_flow_block *block = cb_priv;
  66
  67         prestera_acl_block_destroy(block);
  68 }
  69
  70 static struct prestera_flow_block *
  71 prestera_flow_block_get(struct prestera_switch *sw,
  72                         struct flow_block_offload *f,
  73                         bool *register_block)
  74 {
  75         struct prestera_flow_block *block;
  76         struct flow_block_cb *block_cb;
  77
  78         block_cb = flow_block_cb_lookup(f->block,
  79                                         prestera_flow_block_cb, sw);
  80         if (!block_cb) {
  81                 block = prestera_acl_block_create(sw, f->net);
  82                 if (!block)
  83                         return ERR_PTR(-ENOMEM);
  84
  85                 block_cb = flow_block_cb_alloc(prestera_flow_block_cb,
  86                                                sw, block,
  87                                                prestera_flow_block_release);
  88                 if (IS_ERR(block_cb)) {
  89                         prestera_acl_block_destroy(block);
  90                         return ERR_CAST(block_cb);
  91                 }
  92
  93                 block->block_cb = block_cb;
  94                 *register_block = true;
  95         } else {
  96                 block = flow_block_cb_priv(block_cb);
  97                 *register_block = false;
  98         }
  99
 100         flow_block_cb_incref(block_cb);
 101
 102         return block;
 103 }
 104
 105 static void prestera_flow_block_put(struct prestera_flow_block *block)
 106 {
 107         struct flow_block_cb *block_cb = block->block_cb;
 108
 109         if (flow_block_cb_decref(block_cb))
 110                 return;
 111
 112         flow_block_cb_free(block_cb);
 113         prestera_acl_block_destroy(block);
 114 }
 115
 116 static int prestera_setup_flow_block_bind(struct prestera_port *port,
 117                                           struct flow_block_offload *f)
 118 {
 119         struct prestera_switch *sw = port->sw;
 120         struct prestera_flow_block *block;
 121         struct flow_block_cb *block_cb;
 122         bool register_block;
 123         int err;
 124
 125         block = prestera_flow_block_get(sw, f, &register_block);
 126         if (IS_ERR(block))
 127                 return PTR_ERR(block);
 128
 129         block_cb = block->block_cb;
 130
 131         err = prestera_acl_block_bind(block, port);
 132         if (err)
 133                 goto err_block_bind;
 134
 135         if (register_block) {
 136                 flow_block_cb_add(block_cb, f);
 137                 list_add_tail(&block_cb->driver_list, &prestera_block_cb_list);
 138         }
 139
 140         port->flow_block = block;
 141         return 0;
 142
 143 err_block_bind:
 144         prestera_flow_block_put(block);
 145
 146         return err;
 147 }
 148
 149 static void prestera_setup_flow_block_unbind(struct prestera_port *port,
 150                                              struct flow_block_offload *f)
 151 {
 152         struct prestera_switch *sw = port->sw;
 153         struct prestera_flow_block *block;
 154         struct flow_block_cb *block_cb;
 155         int err;
 156
 157         block_cb = flow_block_cb_lookup(f->block, prestera_flow_block_cb, sw);
 158         if (!block_cb)
 159                 return;
 160
 161         block = flow_block_cb_priv(block_cb);
 162
 163         prestera_span_destroy(block);
 164
 165         err = prestera_acl_block_unbind(block, port);
 166         if (err)
 167                 goto error;
 168
 169         if (!flow_block_cb_decref(block_cb)) {
 170                 flow_block_cb_remove(block_cb, f);
 171                 list_del(&block_cb->driver_list);
 172         }
 173 error:
 174         port->flow_block = NULL;
 175 }
 176
 177 int prestera_flow_block_setup(struct prestera_port *port,
 178                               struct flow_block_offload *f)
 179 {
 180         if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
 181                 return -EOPNOTSUPP;
 182
 183         f->driver_block_list = &prestera_block_cb_list;
 184
 185         switch (f->command) {
 186         case FLOW_BLOCK_BIND:
 187                 return prestera_setup_flow_block_bind(port, f);
 188         case FLOW_BLOCK_UNBIND:
 189                 prestera_setup_flow_block_unbind(port, f);
 190                 return 0;
 191         default:
 192                 return -EOPNOTSUPP;
 193         }
 194 }