drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * RSS and Classifier helpers for Marvell PPv2 Network Controller
   4  *
   5  * Copyright (C) 2014 Marvell
   6  *
   7  * Marcin Wojtas <mw@semihalf.com>
   8  */
   9
  10 #include "mvpp2.h"
  11 #include "mvpp2_cls.h"
  12 #include "mvpp2_prs.h"
  13
  14 #define MVPP2_DEF_FLOW(_type, _id, _opts, _ri, _ri_mask)        \
  15 {                                                               \
  16         .flow_type = _type,                                     \
  17         .flow_id = _id,                                         \
  18         .supported_hash_opts = _opts,                           \
  19         .prs_ri = {                                             \
  20                 .ri = _ri,                                      \
  21                 .ri_mask = _ri_mask                             \
  22         }                                                       \
  23 }
  24
  25 static struct mvpp2_cls_flow cls_flows[MVPP2_N_FLOWS] = {
  26         /* TCP over IPv4 flows, Not fragmented, no vlan tag */
  27         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_UNTAG,
  28                        MVPP22_CLS_HEK_IP4_5T,
  29                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4 |
  30                        MVPP2_PRS_RI_L4_TCP,
  31                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  32
  33         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_UNTAG,
  34                        MVPP22_CLS_HEK_IP4_5T,
  35                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OPT |
  36                        MVPP2_PRS_RI_L4_TCP,
  37                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  38
  39         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_UNTAG,
  40                        MVPP22_CLS_HEK_IP4_5T,
  41                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OTHER |
  42                        MVPP2_PRS_RI_L4_TCP,
  43                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  44
  45         /* TCP over IPv4 flows, Not fragmented, with vlan tag */
  46         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_TAG,
  47                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
  48                        MVPP2_PRS_RI_L3_IP4 | MVPP2_PRS_RI_L4_TCP,
  49                        MVPP2_PRS_IP_MASK),
  50
  51         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_TAG,
  52                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
  53                        MVPP2_PRS_RI_L3_IP4_OPT | MVPP2_PRS_RI_L4_TCP,
  54                        MVPP2_PRS_IP_MASK),
  55
  56         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_NF_TAG,
  57                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
  58                        MVPP2_PRS_RI_L3_IP4_OTHER | MVPP2_PRS_RI_L4_TCP,
  59                        MVPP2_PRS_IP_MASK),
  60
  61         /* TCP over IPv4 flows, fragmented, no vlan tag */
  62         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_UNTAG,
  63                        MVPP22_CLS_HEK_IP4_2T,
  64                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4 |
  65                        MVPP2_PRS_RI_L4_TCP,
  66                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  67
  68         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_UNTAG,
  69                        MVPP22_CLS_HEK_IP4_2T,
  70                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OPT |
  71                        MVPP2_PRS_RI_L4_TCP,
  72                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  73
  74         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_UNTAG,
  75                        MVPP22_CLS_HEK_IP4_2T,
  76                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OTHER |
  77                        MVPP2_PRS_RI_L4_TCP,
  78                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
  79
  80         /* TCP over IPv4 flows, fragmented, with vlan tag */
  81         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_TAG,
  82                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
  83                        MVPP2_PRS_RI_L3_IP4 | MVPP2_PRS_RI_L4_TCP,
  84                        MVPP2_PRS_IP_MASK),
  85
  86         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_TAG,
  87                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
  88                        MVPP2_PRS_RI_L3_IP4_OPT | MVPP2_PRS_RI_L4_TCP,
  89                        MVPP2_PRS_IP_MASK),
  90
  91         MVPP2_DEF_FLOW(TCP_V4_FLOW, MVPP2_FL_IP4_TCP_FRAG_TAG,
  92                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
  93                        MVPP2_PRS_RI_L3_IP4_OTHER | MVPP2_PRS_RI_L4_TCP,
  94                        MVPP2_PRS_IP_MASK),
  95
  96         /* UDP over IPv4 flows, Not fragmented, no vlan tag */
  97         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_UNTAG,
  98                        MVPP22_CLS_HEK_IP4_5T,
  99                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4 |
 100                        MVPP2_PRS_RI_L4_UDP,
 101                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 102
 103         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_UNTAG,
 104                        MVPP22_CLS_HEK_IP4_5T,
 105                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OPT |
 106                        MVPP2_PRS_RI_L4_UDP,
 107                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 108
 109         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_UNTAG,
 110                        MVPP22_CLS_HEK_IP4_5T,
 111                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OTHER |
 112                        MVPP2_PRS_RI_L4_UDP,
 113                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 114
 115         /* UDP over IPv4 flows, Not fragmented, with vlan tag */
 116         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_TAG,
 117                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
 118                        MVPP2_PRS_RI_L3_IP4 | MVPP2_PRS_RI_L4_UDP,
 119                        MVPP2_PRS_IP_MASK),
 120
 121         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_TAG,
 122                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
 123                        MVPP2_PRS_RI_L3_IP4_OPT | MVPP2_PRS_RI_L4_UDP,
 124                        MVPP2_PRS_IP_MASK),
 125
 126         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_NF_TAG,
 127                        MVPP22_CLS_HEK_IP4_5T | MVPP22_CLS_HEK_OPT_VLAN,
 128                        MVPP2_PRS_RI_L3_IP4_OTHER | MVPP2_PRS_RI_L4_UDP,
 129                        MVPP2_PRS_IP_MASK),
 130
 131         /* UDP over IPv4 flows, fragmented, no vlan tag */
 132         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_UNTAG,
 133                        MVPP22_CLS_HEK_IP4_2T,
 134                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4 |
 135                        MVPP2_PRS_RI_L4_UDP,
 136                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 137
 138         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_UNTAG,
 139                        MVPP22_CLS_HEK_IP4_2T,
 140                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OPT |
 141                        MVPP2_PRS_RI_L4_UDP,
 142                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 143
 144         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_UNTAG,
 145                        MVPP22_CLS_HEK_IP4_2T,
 146                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OTHER |
 147                        MVPP2_PRS_RI_L4_UDP,
 148                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 149
 150         /* UDP over IPv4 flows, fragmented, with vlan tag */
 151         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_TAG,
 152                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 153                        MVPP2_PRS_RI_L3_IP4 | MVPP2_PRS_RI_L4_UDP,
 154                        MVPP2_PRS_IP_MASK),
 155
 156         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_TAG,
 157                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 158                        MVPP2_PRS_RI_L3_IP4_OPT | MVPP2_PRS_RI_L4_UDP,
 159                        MVPP2_PRS_IP_MASK),
 160
 161         MVPP2_DEF_FLOW(UDP_V4_FLOW, MVPP2_FL_IP4_UDP_FRAG_TAG,
 162                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 163                        MVPP2_PRS_RI_L3_IP4_OTHER | MVPP2_PRS_RI_L4_UDP,
 164                        MVPP2_PRS_IP_MASK),
 165
 166         /* TCP over IPv6 flows, not fragmented, no vlan tag */
 167         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_NF_UNTAG,
 168                        MVPP22_CLS_HEK_IP6_5T,
 169                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6 |
 170                        MVPP2_PRS_RI_L4_TCP,
 171                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 172
 173         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_NF_UNTAG,
 174                        MVPP22_CLS_HEK_IP6_5T,
 175                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6_EXT |
 176                        MVPP2_PRS_RI_L4_TCP,
 177                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 178
 179         /* TCP over IPv6 flows, not fragmented, with vlan tag */
 180         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_NF_TAG,
 181                        MVPP22_CLS_HEK_IP6_5T | MVPP22_CLS_HEK_OPT_VLAN,
 182                        MVPP2_PRS_RI_L3_IP6 | MVPP2_PRS_RI_L4_TCP,
 183                        MVPP2_PRS_IP_MASK),
 184
 185         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_NF_TAG,
 186                        MVPP22_CLS_HEK_IP6_5T | MVPP22_CLS_HEK_OPT_VLAN,
 187                        MVPP2_PRS_RI_L3_IP6_EXT | MVPP2_PRS_RI_L4_TCP,
 188                        MVPP2_PRS_IP_MASK),
 189
 190         /* TCP over IPv6 flows, fragmented, no vlan tag */
 191         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_FRAG_UNTAG,
 192                        MVPP22_CLS_HEK_IP6_2T,
 193                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6 |
 194                        MVPP2_PRS_RI_IP_FRAG_TRUE | MVPP2_PRS_RI_L4_TCP,
 195                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 196
 197         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_FRAG_UNTAG,
 198                        MVPP22_CLS_HEK_IP6_2T,
 199                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6_EXT |
 200                        MVPP2_PRS_RI_IP_FRAG_TRUE | MVPP2_PRS_RI_L4_TCP,
 201                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 202
 203         /* TCP over IPv6 flows, fragmented, with vlan tag */
 204         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_FRAG_TAG,
 205                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 206                        MVPP2_PRS_RI_L3_IP6 | MVPP2_PRS_RI_IP_FRAG_TRUE |
 207                        MVPP2_PRS_RI_L4_TCP,
 208                        MVPP2_PRS_IP_MASK),
 209
 210         MVPP2_DEF_FLOW(TCP_V6_FLOW, MVPP2_FL_IP6_TCP_FRAG_TAG,
 211                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 212                        MVPP2_PRS_RI_L3_IP6_EXT | MVPP2_PRS_RI_IP_FRAG_TRUE |
 213                        MVPP2_PRS_RI_L4_TCP,
 214                        MVPP2_PRS_IP_MASK),
 215
 216         /* UDP over IPv6 flows, not fragmented, no vlan tag */
 217         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_NF_UNTAG,
 218                        MVPP22_CLS_HEK_IP6_5T,
 219                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6 |
 220                        MVPP2_PRS_RI_L4_UDP,
 221                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 222
 223         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_NF_UNTAG,
 224                        MVPP22_CLS_HEK_IP6_5T,
 225                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6_EXT |
 226                        MVPP2_PRS_RI_L4_UDP,
 227                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 228
 229         /* UDP over IPv6 flows, not fragmented, with vlan tag */
 230         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_NF_TAG,
 231                        MVPP22_CLS_HEK_IP6_5T | MVPP22_CLS_HEK_OPT_VLAN,
 232                        MVPP2_PRS_RI_L3_IP6 | MVPP2_PRS_RI_L4_UDP,
 233                        MVPP2_PRS_IP_MASK),
 234
 235         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_NF_TAG,
 236                        MVPP22_CLS_HEK_IP6_5T | MVPP22_CLS_HEK_OPT_VLAN,
 237                        MVPP2_PRS_RI_L3_IP6_EXT | MVPP2_PRS_RI_L4_UDP,
 238                        MVPP2_PRS_IP_MASK),
 239
 240         /* UDP over IPv6 flows, fragmented, no vlan tag */
 241         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_FRAG_UNTAG,
 242                        MVPP22_CLS_HEK_IP6_2T,
 243                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6 |
 244                        MVPP2_PRS_RI_IP_FRAG_TRUE | MVPP2_PRS_RI_L4_UDP,
 245                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 246
 247         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_FRAG_UNTAG,
 248                        MVPP22_CLS_HEK_IP6_2T,
 249                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6_EXT |
 250                        MVPP2_PRS_RI_IP_FRAG_TRUE | MVPP2_PRS_RI_L4_UDP,
 251                        MVPP2_PRS_IP_MASK | MVPP2_PRS_RI_VLAN_MASK),
 252
 253         /* UDP over IPv6 flows, fragmented, with vlan tag */
 254         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_FRAG_TAG,
 255                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 256                        MVPP2_PRS_RI_L3_IP6 | MVPP2_PRS_RI_IP_FRAG_TRUE |
 257                        MVPP2_PRS_RI_L4_UDP,
 258                        MVPP2_PRS_IP_MASK),
 259
 260         MVPP2_DEF_FLOW(UDP_V6_FLOW, MVPP2_FL_IP6_UDP_FRAG_TAG,
 261                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 262                        MVPP2_PRS_RI_L3_IP6_EXT | MVPP2_PRS_RI_IP_FRAG_TRUE |
 263                        MVPP2_PRS_RI_L4_UDP,
 264                        MVPP2_PRS_IP_MASK),
 265
 266         /* IPv4 flows, no vlan tag */
 267         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_UNTAG,
 268                        MVPP22_CLS_HEK_IP4_2T,
 269                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4,
 270                        MVPP2_PRS_RI_VLAN_MASK | MVPP2_PRS_RI_L3_PROTO_MASK),
 271         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_UNTAG,
 272                        MVPP22_CLS_HEK_IP4_2T,
 273                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OPT,
 274                        MVPP2_PRS_RI_VLAN_MASK | MVPP2_PRS_RI_L3_PROTO_MASK),
 275         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_UNTAG,
 276                        MVPP22_CLS_HEK_IP4_2T,
 277                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP4_OTHER,
 278                        MVPP2_PRS_RI_VLAN_MASK | MVPP2_PRS_RI_L3_PROTO_MASK),
 279
 280         /* IPv4 flows, with vlan tag */
 281         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_TAG,
 282                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 283                        MVPP2_PRS_RI_L3_IP4,
 284                        MVPP2_PRS_RI_L3_PROTO_MASK),
 285         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_TAG,
 286                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 287                        MVPP2_PRS_RI_L3_IP4_OPT,
 288                        MVPP2_PRS_RI_L3_PROTO_MASK),
 289         MVPP2_DEF_FLOW(IPV4_FLOW, MVPP2_FL_IP4_TAG,
 290                        MVPP22_CLS_HEK_IP4_2T | MVPP22_CLS_HEK_OPT_VLAN,
 291                        MVPP2_PRS_RI_L3_IP4_OTHER,
 292                        MVPP2_PRS_RI_L3_PROTO_MASK),
 293
 294         /* IPv6 flows, no vlan tag */
 295         MVPP2_DEF_FLOW(IPV6_FLOW, MVPP2_FL_IP6_UNTAG,
 296                        MVPP22_CLS_HEK_IP6_2T,
 297                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6,
 298                        MVPP2_PRS_RI_VLAN_MASK | MVPP2_PRS_RI_L3_PROTO_MASK),
 299         MVPP2_DEF_FLOW(IPV6_FLOW, MVPP2_FL_IP6_UNTAG,
 300                        MVPP22_CLS_HEK_IP6_2T,
 301                        MVPP2_PRS_RI_VLAN_NONE | MVPP2_PRS_RI_L3_IP6,
 302                        MVPP2_PRS_RI_VLAN_MASK | MVPP2_PRS_RI_L3_PROTO_MASK),
 303
 304         /* IPv6 flows, with vlan tag */
 305         MVPP2_DEF_FLOW(IPV6_FLOW, MVPP2_FL_IP6_TAG,
 306                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 307                        MVPP2_PRS_RI_L3_IP6,
 308                        MVPP2_PRS_RI_L3_PROTO_MASK),
 309         MVPP2_DEF_FLOW(IPV6_FLOW, MVPP2_FL_IP6_TAG,
 310                        MVPP22_CLS_HEK_IP6_2T | MVPP22_CLS_HEK_OPT_VLAN,
 311                        MVPP2_PRS_RI_L3_IP6,
 312                        MVPP2_PRS_RI_L3_PROTO_MASK),
 313
 314         /* Non IP flow, no vlan tag */
 315         MVPP2_DEF_FLOW(ETHER_FLOW, MVPP2_FL_NON_IP_UNTAG,
 316                        0,
 317                        MVPP2_PRS_RI_VLAN_NONE,
 318                        MVPP2_PRS_RI_VLAN_MASK),
 319         /* Non IP flow, with vlan tag */
 320         MVPP2_DEF_FLOW(ETHER_FLOW, MVPP2_FL_NON_IP_TAG,
 321                        MVPP22_CLS_HEK_OPT_VLAN,
 322                        0, 0),
 323 };
 324
 325 static void mvpp2_cls_flow_read(struct mvpp2 *priv, int index,
 326                                 struct mvpp2_cls_flow_entry *fe)
 327 {
 328         fe->index = index;
 329         mvpp2_write(priv, MVPP2_CLS_FLOW_INDEX_REG, index);
 330         fe->data[0] = mvpp2_read(priv, MVPP2_CLS_FLOW_TBL0_REG);
 331         fe->data[1] = mvpp2_read(priv, MVPP2_CLS_FLOW_TBL1_REG);
 332         fe->data[2] = mvpp2_read(priv, MVPP2_CLS_FLOW_TBL2_REG);
 333 }
 334
 335 /* Update classification flow table registers */
 336 static void mvpp2_cls_flow_write(struct mvpp2 *priv,
 337                                  struct mvpp2_cls_flow_entry *fe)
 338 {
 339         mvpp2_write(priv, MVPP2_CLS_FLOW_INDEX_REG, fe->index);
 340         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL0_REG,  fe->data[0]);
 341         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL1_REG,  fe->data[1]);
 342         mvpp2_write(priv, MVPP2_CLS_FLOW_TBL2_REG,  fe->data[2]);
 343 }
 344
 345 /* Update classification lookup table register */
 346 static void mvpp2_cls_lookup_write(struct mvpp2 *priv,
 347                                    struct mvpp2_cls_lookup_entry *le)
 348 {
 349         u32 val;
 350
 351         val = (le->way << MVPP2_CLS_LKP_INDEX_WAY_OFFS) | le->lkpid;
 352         mvpp2_write(priv, MVPP2_CLS_LKP_INDEX_REG, val);
 353         mvpp2_write(priv, MVPP2_CLS_LKP_TBL_REG, le->data);
 354 }
 355
 356 /* Operations on flow entry */
 357 static int mvpp2_cls_flow_hek_num_get(struct mvpp2_cls_flow_entry *fe)
 358 {
 359         return fe->data[1] & MVPP2_CLS_FLOW_TBL1_N_FIELDS_MASK;
 360 }
 361
 362 static void mvpp2_cls_flow_hek_num_set(struct mvpp2_cls_flow_entry *fe,
 363                                        int num_of_fields)
 364 {
 365         fe->data[1] &= ~MVPP2_CLS_FLOW_TBL1_N_FIELDS_MASK;
 366         fe->data[1] |= MVPP2_CLS_FLOW_TBL1_N_FIELDS(num_of_fields);
 367 }
 368
 369 static int mvpp2_cls_flow_hek_get(struct mvpp2_cls_flow_entry *fe,
 370                                   int field_index)
 371 {
 372         return (fe->data[2] >> MVPP2_CLS_FLOW_TBL2_FLD_OFFS(field_index)) &
 373                 MVPP2_CLS_FLOW_TBL2_FLD_MASK;
 374 }
 375
 376 static void mvpp2_cls_flow_hek_set(struct mvpp2_cls_flow_entry *fe,
 377                                    int field_index, int field_id)
 378 {
 379         fe->data[2] &= ~MVPP2_CLS_FLOW_TBL2_FLD(field_index,
 380                                                 MVPP2_CLS_FLOW_TBL2_FLD_MASK);
 381         fe->data[2] |= MVPP2_CLS_FLOW_TBL2_FLD(field_index, field_id);
 382 }
 383
 384 static void mvpp2_cls_flow_eng_set(struct mvpp2_cls_flow_entry *fe,
 385                                    int engine)
 386 {
 387         fe->data[0] &= ~MVPP2_CLS_FLOW_TBL0_ENG(MVPP2_CLS_FLOW_TBL0_ENG_MASK);
 388         fe->data[0] |= MVPP2_CLS_FLOW_TBL0_ENG(engine);
 389 }
 390
 391 static void mvpp2_cls_flow_port_id_sel(struct mvpp2_cls_flow_entry *fe,
 392                                        bool from_packet)
 393 {
 394         if (from_packet)
 395                 fe->data[0] |= MVPP2_CLS_FLOW_TBL0_PORT_ID_SEL;
 396         else
 397                 fe->data[0] &= ~MVPP2_CLS_FLOW_TBL0_PORT_ID_SEL;
 398 }
 399
 400 static void mvpp2_cls_flow_seq_set(struct mvpp2_cls_flow_entry *fe, u32 seq)
 401 {
 402         fe->data[1] &= ~MVPP2_CLS_FLOW_TBL1_SEQ(MVPP2_CLS_FLOW_TBL1_SEQ_MASK);
 403         fe->data[1] |= MVPP2_CLS_FLOW_TBL1_SEQ(seq);
 404 }
 405
 406 static void mvpp2_cls_flow_last_set(struct mvpp2_cls_flow_entry *fe,
 407                                     bool is_last)
 408 {
 409         fe->data[0] &= ~MVPP2_CLS_FLOW_TBL0_LAST;
 410         fe->data[0] |= !!is_last;
 411 }
 412
 413 static void mvpp2_cls_flow_pri_set(struct mvpp2_cls_flow_entry *fe, int prio)
 414 {
 415         fe->data[1] &= ~MVPP2_CLS_FLOW_TBL1_PRIO(MVPP2_CLS_FLOW_TBL1_PRIO_MASK);
 416         fe->data[1] |= MVPP2_CLS_FLOW_TBL1_PRIO(prio);
 417 }
 418
 419 static void mvpp2_cls_flow_port_add(struct mvpp2_cls_flow_entry *fe,
 420                                     u32 port)
 421 {
 422         fe->data[0] |= MVPP2_CLS_FLOW_TBL0_PORT_ID(port);
 423 }
 424
 425 /* Initialize the parser entry for the given flow */
 426 static void mvpp2_cls_flow_prs_init(struct mvpp2 *priv,
 427                                     struct mvpp2_cls_flow *flow)
 428 {
 429         mvpp2_prs_add_flow(priv, flow->flow_id, flow->prs_ri.ri,
 430                            flow->prs_ri.ri_mask);
 431 }
 432
 433 /* Initialize the Lookup Id table entry for the given flow */
 434 static void mvpp2_cls_flow_lkp_init(struct mvpp2 *priv,
 435                                     struct mvpp2_cls_flow *flow)
 436 {
 437         struct mvpp2_cls_lookup_entry le;
 438
 439         le.way = 0;
 440         le.lkpid = flow->flow_id;
 441
 442         /* The default RxQ for this port is set in the C2 lookup */
 443         le.data = 0;
 444
 445         /* We point on the first lookup in the sequence for the flow, that is
 446          * the C2 lookup.
 447          */
 448         le.data |= MVPP2_CLS_LKP_FLOW_PTR(MVPP2_FLOW_C2_ENTRY(flow->flow_id));
 449
 450         /* CLS is always enabled, RSS is enabled/disabled in C2 lookup */
 451         le.data |= MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK;
 452
 453         mvpp2_cls_lookup_write(priv, &le);
 454 }
 455
 456 /* Initialize the flow table entries for the given flow */
 457 static void mvpp2_cls_flow_init(struct mvpp2 *priv, struct mvpp2_cls_flow *flow)
 458 {
 459         struct mvpp2_cls_flow_entry fe;
 460         int i;
 461
 462         /* C2 lookup */
 463         memset(&fe, 0, sizeof(fe));
 464         fe.index = MVPP2_FLOW_C2_ENTRY(flow->flow_id);
 465
 466         mvpp2_cls_flow_eng_set(&fe, MVPP22_CLS_ENGINE_C2);
 467         mvpp2_cls_flow_port_id_sel(&fe, true);
 468         mvpp2_cls_flow_last_set(&fe, 0);
 469         mvpp2_cls_flow_pri_set(&fe, 0);
 470         mvpp2_cls_flow_seq_set(&fe, MVPP2_CLS_FLOW_SEQ_FIRST1);
 471
 472         /* Add all ports */
 473         for (i = 0; i < MVPP2_MAX_PORTS; i++)
 474                 mvpp2_cls_flow_port_add(&fe, BIT(i));
 475
 476         mvpp2_cls_flow_write(priv, &fe);
 477
 478         /* C3Hx lookups */
 479         for (i = 0; i < MVPP2_MAX_PORTS; i++) {
 480                 memset(&fe, 0, sizeof(fe));
 481                 fe.index = MVPP2_PORT_FLOW_HASH_ENTRY(i, flow->flow_id);
 482
 483                 mvpp2_cls_flow_port_id_sel(&fe, true);
 484                 mvpp2_cls_flow_pri_set(&fe, i + 1);
 485                 mvpp2_cls_flow_seq_set(&fe, MVPP2_CLS_FLOW_SEQ_MIDDLE);
 486                 mvpp2_cls_flow_port_add(&fe, BIT(i));
 487
 488                 mvpp2_cls_flow_write(priv, &fe);
 489         }
 490
 491         /* Update the last entry */
 492         mvpp2_cls_flow_last_set(&fe, 1);
 493         mvpp2_cls_flow_seq_set(&fe, MVPP2_CLS_FLOW_SEQ_LAST);
 494
 495         mvpp2_cls_flow_write(priv, &fe);
 496 }
 497
 498 /* Adds a field to the Header Extracted Key generation parameters*/
 499 static int mvpp2_flow_add_hek_field(struct mvpp2_cls_flow_entry *fe,
 500                                     u32 field_id)
 501 {
 502         int nb_fields = mvpp2_cls_flow_hek_num_get(fe);
 503
 504         if (nb_fields == MVPP2_FLOW_N_FIELDS)
 505                 return -EINVAL;
 506
 507         mvpp2_cls_flow_hek_set(fe, nb_fields, field_id);
 508
 509         mvpp2_cls_flow_hek_num_set(fe, nb_fields + 1);
 510
 511         return 0;
 512 }
 513
 514 static int mvpp2_flow_set_hek_fields(struct mvpp2_cls_flow_entry *fe,
 515                                      unsigned long hash_opts)
 516 {
 517         u32 field_id;
 518         int i;
 519
 520         /* Clear old fields */
 521         mvpp2_cls_flow_hek_num_set(fe, 0);
 522         fe->data[2] = 0;
 523
 524         for_each_set_bit(i, &hash_opts, MVPP22_CLS_HEK_N_FIELDS) {
 525                 switch (BIT(i)) {
 526                 case MVPP22_CLS_HEK_OPT_VLAN:
 527                         field_id = MVPP22_CLS_FIELD_VLAN;
 528                         break;
 529                 case MVPP22_CLS_HEK_OPT_IP4SA:
 530                         field_id = MVPP22_CLS_FIELD_IP4SA;
 531                         break;
 532                 case MVPP22_CLS_HEK_OPT_IP4DA:
 533                         field_id = MVPP22_CLS_FIELD_IP4DA;
 534                         break;
 535                 case MVPP22_CLS_HEK_OPT_IP6SA:
 536                         field_id = MVPP22_CLS_FIELD_IP6SA;
 537                         break;
 538                 case MVPP22_CLS_HEK_OPT_IP6DA:
 539                         field_id = MVPP22_CLS_FIELD_IP6DA;
 540                         break;
 541                 case MVPP22_CLS_HEK_OPT_L4SIP:
 542                         field_id = MVPP22_CLS_FIELD_L4SIP;
 543                         break;
 544                 case MVPP22_CLS_HEK_OPT_L4DIP:
 545                         field_id = MVPP22_CLS_FIELD_L4DIP;
 546                         break;
 547                 default:
 548                         return -EINVAL;
 549                 }
 550                 if (mvpp2_flow_add_hek_field(fe, field_id))
 551                         return -EINVAL;
 552         }
 553
 554         return 0;
 555 }
 556
 557 static struct mvpp2_cls_flow *mvpp2_cls_flow_get(int flow)
 558 {
 559         if (flow >= MVPP2_N_FLOWS)
 560                 return NULL;
 561
 562         return &cls_flows[flow];
 563 }
 564
 565 /* Set the hash generation options for the given traffic flow.
 566  * One traffic flow (in the ethtool sense) has multiple classification flows,
 567  * to handle specific cases such as fragmentation, or the presence of a
 568  * VLAN / DSA Tag.
 569  *
 570  * Each of these individual flows has different constraints, for example we
 571  * can't hash fragmented packets on L4 data (else we would risk having packet
 572  * re-ordering), so each classification flows masks the options with their
 573  * supported ones.
 574  *
 575  */
 576 static int mvpp2_port_rss_hash_opts_set(struct mvpp2_port *port, int flow_type,
 577                                         u16 requested_opts)
 578 {
 579         struct mvpp2_cls_flow_entry fe;
 580         struct mvpp2_cls_flow *flow;
 581         int i, engine, flow_index;
 582         u16 hash_opts;
 583
 584         for (i = 0; i < MVPP2_N_FLOWS; i++) {
 585                 flow = mvpp2_cls_flow_get(i);
 586                 if (!flow)
 587                         return -EINVAL;
 588
 589                 if (flow->flow_type != flow_type)
 590                         continue;
 591
 592                 flow_index = MVPP2_PORT_FLOW_HASH_ENTRY(port->id,
 593                                                         flow->flow_id);
 594
 595                 mvpp2_cls_flow_read(port->priv, flow_index, &fe);
 596
 597                 hash_opts = flow->supported_hash_opts & requested_opts;
 598
 599                 /* Use C3HB engine to access L4 infos. This adds L4 infos to the
 600                  * hash parameters
 601                  */
 602                 if (hash_opts & MVPP22_CLS_HEK_L4_OPTS)
 603                         engine = MVPP22_CLS_ENGINE_C3HB;
 604                 else
 605                         engine = MVPP22_CLS_ENGINE_C3HA;
 606
 607                 if (mvpp2_flow_set_hek_fields(&fe, hash_opts))
 608                         return -EINVAL;
 609
 610                 mvpp2_cls_flow_eng_set(&fe, engine);
 611
 612                 mvpp2_cls_flow_write(port->priv, &fe);
 613         }
 614
 615         return 0;
 616 }
 617
 618 u16 mvpp2_flow_get_hek_fields(struct mvpp2_cls_flow_entry *fe)
 619 {
 620         u16 hash_opts = 0;
 621         int n_fields, i, field;
 622
 623         n_fields = mvpp2_cls_flow_hek_num_get(fe);
 624
 625         for (i = 0; i < n_fields; i++) {
 626                 field = mvpp2_cls_flow_hek_get(fe, i);
 627
 628                 switch (field) {
 629                 case MVPP22_CLS_FIELD_MAC_DA:
 630                         hash_opts |= MVPP22_CLS_HEK_OPT_MAC_DA;
 631                         break;
 632                 case MVPP22_CLS_FIELD_VLAN:
 633                         hash_opts |= MVPP22_CLS_HEK_OPT_VLAN;
 634                         break;
 635                 case MVPP22_CLS_FIELD_L3_PROTO:
 636                         hash_opts |= MVPP22_CLS_HEK_OPT_L3_PROTO;
 637                         break;
 638                 case MVPP22_CLS_FIELD_IP4SA:
 639                         hash_opts |= MVPP22_CLS_HEK_OPT_IP4SA;
 640                         break;
 641                 case MVPP22_CLS_FIELD_IP4DA:
 642                         hash_opts |= MVPP22_CLS_HEK_OPT_IP4DA;
 643                         break;
 644                 case MVPP22_CLS_FIELD_IP6SA:
 645                         hash_opts |= MVPP22_CLS_HEK_OPT_IP6SA;
 646                         break;
 647                 case MVPP22_CLS_FIELD_IP6DA:
 648                         hash_opts |= MVPP22_CLS_HEK_OPT_IP6DA;
 649                         break;
 650                 case MVPP22_CLS_FIELD_L4SIP:
 651                         hash_opts |= MVPP22_CLS_HEK_OPT_L4SIP;
 652                         break;
 653                 case MVPP22_CLS_FIELD_L4DIP:
 654                         hash_opts |= MVPP22_CLS_HEK_OPT_L4DIP;
 655                         break;
 656                 default:
 657                         break;
 658                 }
 659         }
 660         return hash_opts;
 661 }
 662
 663 /* Returns the hash opts for this flow. There are several classifier flows
 664  * for one traffic flow, this returns an aggregation of all configurations.
 665  */
 666 static u16 mvpp2_port_rss_hash_opts_get(struct mvpp2_port *port, int flow_type)
 667 {
 668         struct mvpp2_cls_flow_entry fe;
 669         struct mvpp2_cls_flow *flow;
 670         int i, flow_index;
 671         u16 hash_opts = 0;
 672
 673         for (i = 0; i < MVPP2_N_FLOWS; i++) {
 674                 flow = mvpp2_cls_flow_get(i);
 675                 if (!flow)
 676                         return 0;
 677
 678                 if (flow->flow_type != flow_type)
 679                         continue;
 680
 681                 flow_index = MVPP2_PORT_FLOW_HASH_ENTRY(port->id,
 682                                                         flow->flow_id);
 683
 684                 mvpp2_cls_flow_read(port->priv, flow_index, &fe);
 685
 686                 hash_opts |= mvpp2_flow_get_hek_fields(&fe);
 687         }
 688
 689         return hash_opts;
 690 }
 691
 692 static void mvpp2_cls_port_init_flows(struct mvpp2 *priv)
 693 {
 694         struct mvpp2_cls_flow *flow;
 695         int i;
 696
 697         for (i = 0; i < MVPP2_N_FLOWS; i++) {
 698                 flow = mvpp2_cls_flow_get(i);
 699                 if (!flow)
 700                         break;
 701
 702                 mvpp2_cls_flow_prs_init(priv, flow);
 703                 mvpp2_cls_flow_lkp_init(priv, flow);
 704                 mvpp2_cls_flow_init(priv, flow);
 705         }
 706 }
 707
 708 static void mvpp2_cls_c2_write(struct mvpp2 *priv,
 709                                struct mvpp2_cls_c2_entry *c2)
 710 {
 711         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_IDX, c2->index);
 712
 713         /* Write TCAM */
 714         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_DATA0, c2->tcam[0]);
 715         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_DATA1, c2->tcam[1]);
 716         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_DATA2, c2->tcam[2]);
 717         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_DATA3, c2->tcam[3]);
 718         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_DATA4, c2->tcam[4]);
 719
 720         mvpp2_write(priv, MVPP22_CLS_C2_ACT, c2->act);
 721
 722         mvpp2_write(priv, MVPP22_CLS_C2_ATTR0, c2->attr[0]);
 723         mvpp2_write(priv, MVPP22_CLS_C2_ATTR1, c2->attr[1]);
 724         mvpp2_write(priv, MVPP22_CLS_C2_ATTR2, c2->attr[2]);
 725         mvpp2_write(priv, MVPP22_CLS_C2_ATTR3, c2->attr[3]);
 726 }
 727
 728 static void mvpp2_cls_c2_read(struct mvpp2 *priv, int index,
 729                               struct mvpp2_cls_c2_entry *c2)
 730 {
 731         mvpp2_write(priv, MVPP22_CLS_C2_TCAM_IDX, index);
 732
 733         c2->index = index;
 734
 735         c2->tcam[0] = mvpp2_read(priv, MVPP22_CLS_C2_TCAM_DATA0);
 736         c2->tcam[1] = mvpp2_read(priv, MVPP22_CLS_C2_TCAM_DATA1);
 737         c2->tcam[2] = mvpp2_read(priv, MVPP22_CLS_C2_TCAM_DATA2);
 738         c2->tcam[3] = mvpp2_read(priv, MVPP22_CLS_C2_TCAM_DATA3);
 739         c2->tcam[4] = mvpp2_read(priv, MVPP22_CLS_C2_TCAM_DATA4);
 740
 741         c2->act = mvpp2_read(priv, MVPP22_CLS_C2_ACT);
 742
 743         c2->attr[0] = mvpp2_read(priv, MVPP22_CLS_C2_ATTR0);
 744         c2->attr[1] = mvpp2_read(priv, MVPP22_CLS_C2_ATTR1);
 745         c2->attr[2] = mvpp2_read(priv, MVPP22_CLS_C2_ATTR2);
 746         c2->attr[3] = mvpp2_read(priv, MVPP22_CLS_C2_ATTR3);
 747 }
 748
 749 static void mvpp2_port_c2_cls_init(struct mvpp2_port *port)
 750 {
 751         struct mvpp2_cls_c2_entry c2;
 752         u8 qh, ql, pmap;
 753
 754         memset(&c2, 0, sizeof(c2));
 755
 756         c2.index = MVPP22_CLS_C2_RSS_ENTRY(port->id);
 757
 758         pmap = BIT(port->id);
 759         c2.tcam[4] = MVPP22_CLS_C2_PORT_ID(pmap);
 760         c2.tcam[4] |= MVPP22_CLS_C2_TCAM_EN(MVPP22_CLS_C2_PORT_ID(pmap));
 761
 762         /* Update RSS status after matching this entry */
 763         c2.act = MVPP22_CLS_C2_ACT_RSS_EN(MVPP22_C2_UPD_LOCK);
 764
 765         /* Mark packet as "forwarded to software", needed for RSS */
 766         c2.act |= MVPP22_CLS_C2_ACT_FWD(MVPP22_C2_FWD_SW_LOCK);
 767
 768         /* Configure the default rx queue : Update Queue Low and Queue High, but
 769          * don't lock, since the rx queue selection might be overridden by RSS
 770          */
 771         c2.act |= MVPP22_CLS_C2_ACT_QHIGH(MVPP22_C2_UPD) |
 772                    MVPP22_CLS_C2_ACT_QLOW(MVPP22_C2_UPD);
 773
 774         qh = (port->first_rxq >> 3) & MVPP22_CLS_C2_ATTR0_QHIGH_MASK;
 775         ql = port->first_rxq & MVPP22_CLS_C2_ATTR0_QLOW_MASK;
 776
 777         c2.attr[0] = MVPP22_CLS_C2_ATTR0_QHIGH(qh) |
 778                       MVPP22_CLS_C2_ATTR0_QLOW(ql);
 779
 780         mvpp2_cls_c2_write(port->priv, &c2);
 781 }
 782
 783 /* Classifier default initialization */
 784 void mvpp2_cls_init(struct mvpp2 *priv)
 785 {
 786         struct mvpp2_cls_lookup_entry le;
 787         struct mvpp2_cls_flow_entry fe;
 788         int index;
 789
 790         /* Enable classifier */
 791         mvpp2_write(priv, MVPP2_CLS_MODE_REG, MVPP2_CLS_MODE_ACTIVE_MASK);
 792
 793         /* Clear classifier flow table */
 794         memset(&fe.data, 0, sizeof(fe.data));
 795         for (index = 0; index < MVPP2_CLS_FLOWS_TBL_SIZE; index++) {
 796                 fe.index = index;
 797                 mvpp2_cls_flow_write(priv, &fe);
 798         }
 799
 800         /* Clear classifier lookup table */
 801         le.data = 0;
 802         for (index = 0; index < MVPP2_CLS_LKP_TBL_SIZE; index++) {
 803                 le.lkpid = index;
 804                 le.way = 0;
 805                 mvpp2_cls_lookup_write(priv, &le);
 806
 807                 le.way = 1;
 808                 mvpp2_cls_lookup_write(priv, &le);
 809         }
 810
 811         mvpp2_cls_port_init_flows(priv);
 812 }
 813
 814 void mvpp2_cls_port_config(struct mvpp2_port *port)
 815 {
 816         struct mvpp2_cls_lookup_entry le;
 817         u32 val;
 818
 819         /* Set way for the port */
 820         val = mvpp2_read(port->priv, MVPP2_CLS_PORT_WAY_REG);
 821         val &= ~MVPP2_CLS_PORT_WAY_MASK(port->id);
 822         mvpp2_write(port->priv, MVPP2_CLS_PORT_WAY_REG, val);
 823
 824         /* Pick the entry to be accessed in lookup ID decoding table
 825          * according to the way and lkpid.
 826          */
 827         le.lkpid = port->id;
 828         le.way = 0;
 829         le.data = 0;
 830
 831         /* Set initial CPU queue for receiving packets */
 832         le.data &= ~MVPP2_CLS_LKP_TBL_RXQ_MASK;
 833         le.data |= port->first_rxq;
 834
 835         /* Disable classification engines */
 836         le.data &= ~MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK;
 837
 838         /* Update lookup ID table entry */
 839         mvpp2_cls_lookup_write(port->priv, &le);
 840
 841         mvpp2_port_c2_cls_init(port);
 842 }
 843
 844 static void mvpp2_rss_port_c2_enable(struct mvpp2_port *port)
 845 {
 846         struct mvpp2_cls_c2_entry c2;
 847
 848         mvpp2_cls_c2_read(port->priv, MVPP22_CLS_C2_RSS_ENTRY(port->id), &c2);
 849
 850         c2.attr[2] |= MVPP22_CLS_C2_ATTR2_RSS_EN;
 851
 852         mvpp2_cls_c2_write(port->priv, &c2);
 853 }
 854
 855 static void mvpp2_rss_port_c2_disable(struct mvpp2_port *port)
 856 {
 857         struct mvpp2_cls_c2_entry c2;
 858
 859         mvpp2_cls_c2_read(port->priv, MVPP22_CLS_C2_RSS_ENTRY(port->id), &c2);
 860
 861         c2.attr[2] &= ~MVPP22_CLS_C2_ATTR2_RSS_EN;
 862
 863         mvpp2_cls_c2_write(port->priv, &c2);
 864 }
 865
 866 void mvpp22_rss_enable(struct mvpp2_port *port)
 867 {
 868         mvpp2_rss_port_c2_enable(port);
 869 }
 870
 871 void mvpp22_rss_disable(struct mvpp2_port *port)
 872 {
 873         mvpp2_rss_port_c2_disable(port);
 874 }
 875
 876 /* Set CPU queue number for oversize packets */
 877 void mvpp2_cls_oversize_rxq_set(struct mvpp2_port *port)
 878 {
 879         u32 val;
 880
 881         mvpp2_write(port->priv, MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port->id),
 882                     port->first_rxq & MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK);
 883
 884         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_P2HQ_REG(port->id),
 885                     (port->first_rxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS));
 886
 887         val = mvpp2_read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG);
 888         val |= MVPP2_CLS_SWFWD_PCTRL_MASK(port->id);
 889         mvpp2_write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val);
 890 }
 891
 892 static inline u32 mvpp22_rxfh_indir(struct mvpp2_port *port, u32 rxq)
 893 {
 894         int nrxqs, cpu, cpus = num_possible_cpus();
 895
 896         /* Number of RXQs per CPU */
 897         nrxqs = port->nrxqs / cpus;
 898
 899         /* CPU that will handle this rx queue */
 900         cpu = rxq / nrxqs;
 901
 902         if (!cpu_online(cpu))
 903                 return port->first_rxq;
 904
 905         /* Indirection to better distribute the paquets on the CPUs when
 906          * configuring the RSS queues.
 907          */
 908         return port->first_rxq + ((rxq * nrxqs + rxq / cpus) % port->nrxqs);
 909 }
 910
 911 void mvpp22_rss_fill_table(struct mvpp2_port *port, u32 table)
 912 {
 913         struct mvpp2 *priv = port->priv;
 914         int i;
 915
 916         for (i = 0; i < MVPP22_RSS_TABLE_ENTRIES; i++) {
 917                 u32 sel = MVPP22_RSS_INDEX_TABLE(table) |
 918                           MVPP22_RSS_INDEX_TABLE_ENTRY(i);
 919                 mvpp2_write(priv, MVPP22_RSS_INDEX, sel);
 920
 921                 mvpp2_write(priv, MVPP22_RSS_TABLE_ENTRY,
 922                             mvpp22_rxfh_indir(port, port->indir[i]));
 923         }
 924 }
 925
 926 int mvpp2_ethtool_rxfh_set(struct mvpp2_port *port, struct ethtool_rxnfc *info)
 927 {
 928         u16 hash_opts = 0;
 929
 930         switch (info->flow_type) {
 931         case TCP_V4_FLOW:
 932         case UDP_V4_FLOW:
 933         case TCP_V6_FLOW:
 934         case UDP_V6_FLOW:
 935                 if (info->data & RXH_L4_B_0_1)
 936                         hash_opts |= MVPP22_CLS_HEK_OPT_L4SIP;
 937                 if (info->data & RXH_L4_B_2_3)
 938                         hash_opts |= MVPP22_CLS_HEK_OPT_L4DIP;
 939                 /* Fallthrough */
 940         case IPV4_FLOW:
 941         case IPV6_FLOW:
 942                 if (info->data & RXH_L2DA)
 943                         hash_opts |= MVPP22_CLS_HEK_OPT_MAC_DA;
 944                 if (info->data & RXH_VLAN)
 945                         hash_opts |= MVPP22_CLS_HEK_OPT_VLAN;
 946                 if (info->data & RXH_L3_PROTO)
 947                         hash_opts |= MVPP22_CLS_HEK_OPT_L3_PROTO;
 948                 if (info->data & RXH_IP_SRC)
 949                         hash_opts |= (MVPP22_CLS_HEK_OPT_IP4SA |
 950                                      MVPP22_CLS_HEK_OPT_IP6SA);
 951                 if (info->data & RXH_IP_DST)
 952                         hash_opts |= (MVPP22_CLS_HEK_OPT_IP4DA |
 953                                      MVPP22_CLS_HEK_OPT_IP6DA);
 954                 break;
 955         default: return -EOPNOTSUPP;
 956         }
 957
 958         return mvpp2_port_rss_hash_opts_set(port, info->flow_type, hash_opts);
 959 }
 960
 961 int mvpp2_ethtool_rxfh_get(struct mvpp2_port *port, struct ethtool_rxnfc *info)
 962 {
 963         unsigned long hash_opts;
 964         int i;
 965
 966         hash_opts = mvpp2_port_rss_hash_opts_get(port, info->flow_type);
 967         info->data = 0;
 968
 969         for_each_set_bit(i, &hash_opts, MVPP22_CLS_HEK_N_FIELDS) {
 970                 switch (BIT(i)) {
 971                 case MVPP22_CLS_HEK_OPT_MAC_DA:
 972                         info->data |= RXH_L2DA;
 973                         break;
 974                 case MVPP22_CLS_HEK_OPT_VLAN:
 975                         info->data |= RXH_VLAN;
 976                         break;
 977                 case MVPP22_CLS_HEK_OPT_L3_PROTO:
 978                         info->data |= RXH_L3_PROTO;
 979                         break;
 980                 case MVPP22_CLS_HEK_OPT_IP4SA:
 981                 case MVPP22_CLS_HEK_OPT_IP6SA:
 982                         info->data |= RXH_IP_SRC;
 983                         break;
 984                 case MVPP22_CLS_HEK_OPT_IP4DA:
 985                 case MVPP22_CLS_HEK_OPT_IP6DA:
 986                         info->data |= RXH_IP_DST;
 987                         break;
 988                 case MVPP22_CLS_HEK_OPT_L4SIP:
 989                         info->data |= RXH_L4_B_0_1;
 990                         break;
 991                 case MVPP22_CLS_HEK_OPT_L4DIP:
 992                         info->data |= RXH_L4_B_2_3;
 993                         break;
 994                 default:
 995                         return -EINVAL;
 996                 }
 997         }
 998         return 0;
 999 }
1000
1001 void mvpp22_rss_port_init(struct mvpp2_port *port)
1002 {
1003         struct mvpp2 *priv = port->priv;
1004         int i;
1005
1006         /* Set the table width: replace the whole classifier Rx queue number
1007          * with the ones configured in RSS table entries.
1008          */
1009         mvpp2_write(priv, MVPP22_RSS_INDEX, MVPP22_RSS_INDEX_TABLE(port->id));
1010         mvpp2_write(priv, MVPP22_RSS_WIDTH, 8);
1011
1012         /* The default RxQ is used as a key to select the RSS table to use.
1013          * We use one RSS table per port.
1014          */
1015         mvpp2_write(priv, MVPP22_RSS_INDEX,
1016                     MVPP22_RSS_INDEX_QUEUE(port->first_rxq));
1017         mvpp2_write(priv, MVPP22_RXQ2RSS_TABLE,
1018                     MVPP22_RSS_TABLE_POINTER(port->id));
1019
1020         /* Configure the first table to evenly distribute the packets across
1021          * real Rx Queues. The table entries map a hash to a port Rx Queue.
1022          */
1023         for (i = 0; i < MVPP22_RSS_TABLE_ENTRIES; i++)
1024                 port->indir[i] = ethtool_rxfh_indir_default(i, port->nrxqs);
1025
1026         mvpp22_rss_fill_table(port, port->id);
1027
1028         /* Configure default flows */
1029         mvpp2_port_rss_hash_opts_set(port, IPV4_FLOW, MVPP22_CLS_HEK_IP4_2T);
1030         mvpp2_port_rss_hash_opts_set(port, IPV6_FLOW, MVPP22_CLS_HEK_IP6_2T);
1031         mvpp2_port_rss_hash_opts_set(port, TCP_V4_FLOW, MVPP22_CLS_HEK_IP4_5T);
1032         mvpp2_port_rss_hash_opts_set(port, TCP_V6_FLOW, MVPP22_CLS_HEK_IP6_5T);
1033         mvpp2_port_rss_hash_opts_set(port, UDP_V4_FLOW, MVPP22_CLS_HEK_IP4_5T);
1034         mvpp2_port_rss_hash_opts_set(port, UDP_V6_FLOW, MVPP22_CLS_HEK_IP6_5T);
1035 }