1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Header Parser helpers for Marvell PPv2 Network Controller 4 * 5 * Copyright (C) 2014 Marvell 6 * 7 * Marcin Wojtas <mw@semihalf.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/netdevice.h> 12 #include <linux/etherdevice.h> 13 #include <linux/platform_device.h> 14 #include <uapi/linux/ppp_defs.h> 15 #include <net/ip.h> 16 #include <net/ipv6.h> 17 18 #include "mvpp2.h" 19 #include "mvpp2_prs.h" 20 21 /* Update parser tcam and sram hw entries */ 22 static int mvpp2_prs_hw_write(struct mvpp2 *priv, struct mvpp2_prs_entry *pe) 23 { 24 int i; 25 26 if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1) 27 return -EINVAL; 28 29 /* Clear entry invalidation bit */ 30 pe->tcam[MVPP2_PRS_TCAM_INV_WORD] &= ~MVPP2_PRS_TCAM_INV_MASK; 31 32 /* Write sram index - indirect access */ 33 mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index); 34 for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) 35 mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), pe->sram[i]); 36 37 /* Write tcam index - indirect access */ 38 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index); 39 for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) 40 mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), pe->tcam[i]); 41 42 return 0; 43 } 44 45 /* Initialize tcam entry from hw */ 46 int mvpp2_prs_init_from_hw(struct mvpp2 *priv, struct mvpp2_prs_entry *pe, 47 int tid) 48 { 49 int i; 50 51 if (tid > MVPP2_PRS_TCAM_SRAM_SIZE - 1) 52 return -EINVAL; 53 54 memset(pe, 0, sizeof(*pe)); 55 pe->index = tid; 56 57 /* Write tcam index - indirect access */ 58 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index); 59 60 pe->tcam[MVPP2_PRS_TCAM_INV_WORD] = mvpp2_read(priv, 61 MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD)); 62 if (pe->tcam[MVPP2_PRS_TCAM_INV_WORD] & MVPP2_PRS_TCAM_INV_MASK) 63 return MVPP2_PRS_TCAM_ENTRY_INVALID; 64 65 for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) 66 pe->tcam[i] = mvpp2_read(priv, MVPP2_PRS_TCAM_DATA_REG(i)); 67 68 /* Write sram index - indirect access */ 69 mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index); 70 for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) 71 pe->sram[i] = mvpp2_read(priv, MVPP2_PRS_SRAM_DATA_REG(i)); 72 73 return 0; 74 } 75 76 /* Invalidate tcam hw entry */ 77 static void mvpp2_prs_hw_inv(struct mvpp2 *priv, int index) 78 { 79 /* Write index - indirect access */ 80 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index); 81 mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD), 82 MVPP2_PRS_TCAM_INV_MASK); 83 } 84 85 /* Enable shadow table entry and set its lookup ID */ 86 static void mvpp2_prs_shadow_set(struct mvpp2 *priv, int index, int lu) 87 { 88 priv->prs_shadow[index].valid = true; 89 priv->prs_shadow[index].lu = lu; 90 } 91 92 /* Update ri fields in shadow table entry */ 93 static void mvpp2_prs_shadow_ri_set(struct mvpp2 *priv, int index, 94 unsigned int ri, unsigned int ri_mask) 95 { 96 priv->prs_shadow[index].ri_mask = ri_mask; 97 priv->prs_shadow[index].ri = ri; 98 } 99 100 /* Update lookup field in tcam sw entry */ 101 static void mvpp2_prs_tcam_lu_set(struct mvpp2_prs_entry *pe, unsigned int lu) 102 { 103 pe->tcam[MVPP2_PRS_TCAM_LU_WORD] &= ~MVPP2_PRS_TCAM_LU(MVPP2_PRS_LU_MASK); 104 pe->tcam[MVPP2_PRS_TCAM_LU_WORD] &= ~MVPP2_PRS_TCAM_LU_EN(MVPP2_PRS_LU_MASK); 105 pe->tcam[MVPP2_PRS_TCAM_LU_WORD] |= MVPP2_PRS_TCAM_LU(lu & MVPP2_PRS_LU_MASK); 106 pe->tcam[MVPP2_PRS_TCAM_LU_WORD] |= MVPP2_PRS_TCAM_LU_EN(MVPP2_PRS_LU_MASK); 107 } 108 109 /* Update mask for single port in tcam sw entry */ 110 static void mvpp2_prs_tcam_port_set(struct mvpp2_prs_entry *pe, 111 unsigned int port, bool add) 112 { 113 if (add) 114 pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] &= ~MVPP2_PRS_TCAM_PORT_EN(BIT(port)); 115 else 116 pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] |= MVPP2_PRS_TCAM_PORT_EN(BIT(port)); 117 } 118 119 /* Update port map in tcam sw entry */ 120 static void mvpp2_prs_tcam_port_map_set(struct mvpp2_prs_entry *pe, 121 unsigned int ports) 122 { 123 pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] &= ~MVPP2_PRS_TCAM_PORT(MVPP2_PRS_PORT_MASK); 124 pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] &= ~MVPP2_PRS_TCAM_PORT_EN(MVPP2_PRS_PORT_MASK); 125 pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] |= MVPP2_PRS_TCAM_PORT_EN(~ports & MVPP2_PRS_PORT_MASK); 126 } 127 128 /* Obtain port map from tcam sw entry */ 129 unsigned int mvpp2_prs_tcam_port_map_get(struct mvpp2_prs_entry *pe) 130 { 131 return (~pe->tcam[MVPP2_PRS_TCAM_PORT_WORD] >> 24) & MVPP2_PRS_PORT_MASK; 132 } 133 134 /* Set byte of data and its enable bits in tcam sw entry */ 135 static void mvpp2_prs_tcam_data_byte_set(struct mvpp2_prs_entry *pe, 136 unsigned int offs, unsigned char byte, 137 unsigned char enable) 138 { 139 int pos = MVPP2_PRS_BYTE_IN_WORD(offs) * BITS_PER_BYTE; 140 141 pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] &= ~(0xff << pos); 142 pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] &= ~(MVPP2_PRS_TCAM_EN(0xff) << pos); 143 pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] |= byte << pos; 144 pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] |= MVPP2_PRS_TCAM_EN(enable << pos); 145 } 146 147 /* Get byte of data and its enable bits from tcam sw entry */ 148 void mvpp2_prs_tcam_data_byte_get(struct mvpp2_prs_entry *pe, 149 unsigned int offs, unsigned char *byte, 150 unsigned char *enable) 151 { 152 int pos = MVPP2_PRS_BYTE_IN_WORD(offs) * BITS_PER_BYTE; 153 154 *byte = (pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] >> pos) & 0xff; 155 *enable = (pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] >> (pos + 16)) & 0xff; 156 } 157 158 /* Compare tcam data bytes with a pattern */ 159 static bool mvpp2_prs_tcam_data_cmp(struct mvpp2_prs_entry *pe, int offs, 160 u16 data) 161 { 162 u16 tcam_data; 163 164 tcam_data = pe->tcam[MVPP2_PRS_BYTE_TO_WORD(offs)] & 0xffff; 165 return tcam_data == data; 166 } 167 168 /* Update ai bits in tcam sw entry */ 169 static void mvpp2_prs_tcam_ai_update(struct mvpp2_prs_entry *pe, 170 unsigned int bits, unsigned int enable) 171 { 172 int i; 173 174 for (i = 0; i < MVPP2_PRS_AI_BITS; i++) { 175 if (!(enable & BIT(i))) 176 continue; 177 178 if (bits & BIT(i)) 179 pe->tcam[MVPP2_PRS_TCAM_AI_WORD] |= BIT(i); 180 else 181 pe->tcam[MVPP2_PRS_TCAM_AI_WORD] &= ~BIT(i); 182 } 183 184 pe->tcam[MVPP2_PRS_TCAM_AI_WORD] |= MVPP2_PRS_TCAM_AI_EN(enable); 185 } 186 187 /* Get ai bits from tcam sw entry */ 188 static int mvpp2_prs_tcam_ai_get(struct mvpp2_prs_entry *pe) 189 { 190 return pe->tcam[MVPP2_PRS_TCAM_AI_WORD] & MVPP2_PRS_AI_MASK; 191 } 192 193 /* Set ethertype in tcam sw entry */ 194 static void mvpp2_prs_match_etype(struct mvpp2_prs_entry *pe, int offset, 195 unsigned short ethertype) 196 { 197 mvpp2_prs_tcam_data_byte_set(pe, offset + 0, ethertype >> 8, 0xff); 198 mvpp2_prs_tcam_data_byte_set(pe, offset + 1, ethertype & 0xff, 0xff); 199 } 200 201 /* Set vid in tcam sw entry */ 202 static void mvpp2_prs_match_vid(struct mvpp2_prs_entry *pe, int offset, 203 unsigned short vid) 204 { 205 mvpp2_prs_tcam_data_byte_set(pe, offset + 0, (vid & 0xf00) >> 8, 0xf); 206 mvpp2_prs_tcam_data_byte_set(pe, offset + 1, vid & 0xff, 0xff); 207 } 208 209 /* Set bits in sram sw entry */ 210 static void mvpp2_prs_sram_bits_set(struct mvpp2_prs_entry *pe, int bit_num, 211 u32 val) 212 { 213 pe->sram[MVPP2_BIT_TO_WORD(bit_num)] |= (val << (MVPP2_BIT_IN_WORD(bit_num))); 214 } 215 216 /* Clear bits in sram sw entry */ 217 static void mvpp2_prs_sram_bits_clear(struct mvpp2_prs_entry *pe, int bit_num, 218 u32 val) 219 { 220 pe->sram[MVPP2_BIT_TO_WORD(bit_num)] &= ~(val << (MVPP2_BIT_IN_WORD(bit_num))); 221 } 222 223 /* Update ri bits in sram sw entry */ 224 static void mvpp2_prs_sram_ri_update(struct mvpp2_prs_entry *pe, 225 unsigned int bits, unsigned int mask) 226 { 227 unsigned int i; 228 229 for (i = 0; i < MVPP2_PRS_SRAM_RI_CTRL_BITS; i++) { 230 if (!(mask & BIT(i))) 231 continue; 232 233 if (bits & BIT(i)) 234 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_RI_OFFS + i, 235 1); 236 else 237 mvpp2_prs_sram_bits_clear(pe, 238 MVPP2_PRS_SRAM_RI_OFFS + i, 239 1); 240 241 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_RI_CTRL_OFFS + i, 1); 242 } 243 } 244 245 /* Obtain ri bits from sram sw entry */ 246 static int mvpp2_prs_sram_ri_get(struct mvpp2_prs_entry *pe) 247 { 248 return pe->sram[MVPP2_PRS_SRAM_RI_WORD]; 249 } 250 251 /* Update ai bits in sram sw entry */ 252 static void mvpp2_prs_sram_ai_update(struct mvpp2_prs_entry *pe, 253 unsigned int bits, unsigned int mask) 254 { 255 unsigned int i; 256 257 for (i = 0; i < MVPP2_PRS_SRAM_AI_CTRL_BITS; i++) { 258 if (!(mask & BIT(i))) 259 continue; 260 261 if (bits & BIT(i)) 262 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_AI_OFFS + i, 263 1); 264 else 265 mvpp2_prs_sram_bits_clear(pe, 266 MVPP2_PRS_SRAM_AI_OFFS + i, 267 1); 268 269 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_AI_CTRL_OFFS + i, 1); 270 } 271 } 272 273 /* Read ai bits from sram sw entry */ 274 static int mvpp2_prs_sram_ai_get(struct mvpp2_prs_entry *pe) 275 { 276 u8 bits; 277 /* ai is stored on bits 90->97; so it spreads across two u32 */ 278 int ai_off = MVPP2_BIT_TO_WORD(MVPP2_PRS_SRAM_AI_OFFS); 279 int ai_shift = MVPP2_BIT_IN_WORD(MVPP2_PRS_SRAM_AI_OFFS); 280 281 bits = (pe->sram[ai_off] >> ai_shift) | 282 (pe->sram[ai_off + 1] << (32 - ai_shift)); 283 284 return bits; 285 } 286 287 /* In sram sw entry set lookup ID field of the tcam key to be used in the next 288 * lookup interation 289 */ 290 static void mvpp2_prs_sram_next_lu_set(struct mvpp2_prs_entry *pe, 291 unsigned int lu) 292 { 293 int sram_next_off = MVPP2_PRS_SRAM_NEXT_LU_OFFS; 294 295 mvpp2_prs_sram_bits_clear(pe, sram_next_off, 296 MVPP2_PRS_SRAM_NEXT_LU_MASK); 297 mvpp2_prs_sram_bits_set(pe, sram_next_off, lu); 298 } 299 300 /* In the sram sw entry set sign and value of the next lookup offset 301 * and the offset value generated to the classifier 302 */ 303 static void mvpp2_prs_sram_shift_set(struct mvpp2_prs_entry *pe, int shift, 304 unsigned int op) 305 { 306 /* Set sign */ 307 if (shift < 0) { 308 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1); 309 shift = 0 - shift; 310 } else { 311 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1); 312 } 313 314 /* Set value */ 315 pe->sram[MVPP2_BIT_TO_WORD(MVPP2_PRS_SRAM_SHIFT_OFFS)] |= 316 shift & MVPP2_PRS_SRAM_SHIFT_MASK; 317 318 /* Reset and set operation */ 319 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, 320 MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK); 321 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, op); 322 323 /* Set base offset as current */ 324 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1); 325 } 326 327 /* In the sram sw entry set sign and value of the user defined offset 328 * generated to the classifier 329 */ 330 static void mvpp2_prs_sram_offset_set(struct mvpp2_prs_entry *pe, 331 unsigned int type, int offset, 332 unsigned int op) 333 { 334 /* Set sign */ 335 if (offset < 0) { 336 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1); 337 offset = 0 - offset; 338 } else { 339 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1); 340 } 341 342 /* Set value */ 343 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_OFFS, 344 MVPP2_PRS_SRAM_UDF_MASK); 345 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_OFFS, 346 offset & MVPP2_PRS_SRAM_UDF_MASK); 347 348 /* Set offset type */ 349 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, 350 MVPP2_PRS_SRAM_UDF_TYPE_MASK); 351 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, type); 352 353 /* Set offset operation */ 354 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, 355 MVPP2_PRS_SRAM_OP_SEL_UDF_MASK); 356 mvpp2_prs_sram_bits_set(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, 357 op & MVPP2_PRS_SRAM_OP_SEL_UDF_MASK); 358 359 /* Set base offset as current */ 360 mvpp2_prs_sram_bits_clear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1); 361 } 362 363 /* Find parser flow entry */ 364 static int mvpp2_prs_flow_find(struct mvpp2 *priv, int flow) 365 { 366 struct mvpp2_prs_entry pe; 367 int tid; 368 369 /* Go through the all entires with MVPP2_PRS_LU_FLOWS */ 370 for (tid = MVPP2_PRS_TCAM_SRAM_SIZE - 1; tid >= 0; tid--) { 371 u8 bits; 372 373 if (!priv->prs_shadow[tid].valid || 374 priv->prs_shadow[tid].lu != MVPP2_PRS_LU_FLOWS) 375 continue; 376 377 mvpp2_prs_init_from_hw(priv, &pe, tid); 378 bits = mvpp2_prs_sram_ai_get(&pe); 379 380 /* Sram store classification lookup ID in AI bits [5:0] */ 381 if ((bits & MVPP2_PRS_FLOW_ID_MASK) == flow) 382 return tid; 383 } 384 385 return -ENOENT; 386 } 387 388 /* Return first free tcam index, seeking from start to end */ 389 static int mvpp2_prs_tcam_first_free(struct mvpp2 *priv, unsigned char start, 390 unsigned char end) 391 { 392 int tid; 393 394 if (start > end) 395 swap(start, end); 396 397 for (tid = start; tid <= end; tid++) { 398 if (!priv->prs_shadow[tid].valid) 399 return tid; 400 } 401 402 return -EINVAL; 403 } 404 405 /* Drop flow control pause frames */ 406 static void mvpp2_prs_drop_fc(struct mvpp2 *priv) 407 { 408 unsigned char da[ETH_ALEN] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x01 }; 409 struct mvpp2_prs_entry pe; 410 unsigned int len; 411 412 memset(&pe, 0, sizeof(pe)); 413 414 /* For all ports - drop flow control frames */ 415 pe.index = MVPP2_PE_FC_DROP; 416 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC); 417 418 /* Set match on DA */ 419 len = ETH_ALEN; 420 while (len--) 421 mvpp2_prs_tcam_data_byte_set(&pe, len, da[len], 0xff); 422 423 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK, 424 MVPP2_PRS_RI_DROP_MASK); 425 426 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 427 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 428 429 /* Mask all ports */ 430 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 431 432 /* Update shadow table and hw entry */ 433 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 434 mvpp2_prs_hw_write(priv, &pe); 435 } 436 437 /* Enable/disable dropping all mac da's */ 438 static void mvpp2_prs_mac_drop_all_set(struct mvpp2 *priv, int port, bool add) 439 { 440 struct mvpp2_prs_entry pe; 441 442 if (priv->prs_shadow[MVPP2_PE_DROP_ALL].valid) { 443 /* Entry exist - update port only */ 444 mvpp2_prs_init_from_hw(priv, &pe, MVPP2_PE_DROP_ALL); 445 } else { 446 /* Entry doesn't exist - create new */ 447 memset(&pe, 0, sizeof(pe)); 448 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC); 449 pe.index = MVPP2_PE_DROP_ALL; 450 451 /* Non-promiscuous mode for all ports - DROP unknown packets */ 452 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK, 453 MVPP2_PRS_RI_DROP_MASK); 454 455 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 456 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 457 458 /* Update shadow table */ 459 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 460 461 /* Mask all ports */ 462 mvpp2_prs_tcam_port_map_set(&pe, 0); 463 } 464 465 /* Update port mask */ 466 mvpp2_prs_tcam_port_set(&pe, port, add); 467 468 mvpp2_prs_hw_write(priv, &pe); 469 } 470 471 /* Set port to unicast or multicast promiscuous mode */ 472 void mvpp2_prs_mac_promisc_set(struct mvpp2 *priv, int port, 473 enum mvpp2_prs_l2_cast l2_cast, bool add) 474 { 475 struct mvpp2_prs_entry pe; 476 unsigned char cast_match; 477 unsigned int ri; 478 int tid; 479 480 if (l2_cast == MVPP2_PRS_L2_UNI_CAST) { 481 cast_match = MVPP2_PRS_UCAST_VAL; 482 tid = MVPP2_PE_MAC_UC_PROMISCUOUS; 483 ri = MVPP2_PRS_RI_L2_UCAST; 484 } else { 485 cast_match = MVPP2_PRS_MCAST_VAL; 486 tid = MVPP2_PE_MAC_MC_PROMISCUOUS; 487 ri = MVPP2_PRS_RI_L2_MCAST; 488 } 489 490 /* promiscuous mode - Accept unknown unicast or multicast packets */ 491 if (priv->prs_shadow[tid].valid) { 492 mvpp2_prs_init_from_hw(priv, &pe, tid); 493 } else { 494 memset(&pe, 0, sizeof(pe)); 495 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC); 496 pe.index = tid; 497 498 /* Continue - set next lookup */ 499 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA); 500 501 /* Set result info bits */ 502 mvpp2_prs_sram_ri_update(&pe, ri, MVPP2_PRS_RI_L2_CAST_MASK); 503 504 /* Match UC or MC addresses */ 505 mvpp2_prs_tcam_data_byte_set(&pe, 0, cast_match, 506 MVPP2_PRS_CAST_MASK); 507 508 /* Shift to ethertype */ 509 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN, 510 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 511 512 /* Mask all ports */ 513 mvpp2_prs_tcam_port_map_set(&pe, 0); 514 515 /* Update shadow table */ 516 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 517 } 518 519 /* Update port mask */ 520 mvpp2_prs_tcam_port_set(&pe, port, add); 521 522 mvpp2_prs_hw_write(priv, &pe); 523 } 524 525 /* Set entry for dsa packets */ 526 static void mvpp2_prs_dsa_tag_set(struct mvpp2 *priv, int port, bool add, 527 bool tagged, bool extend) 528 { 529 struct mvpp2_prs_entry pe; 530 int tid, shift; 531 532 if (extend) { 533 tid = tagged ? MVPP2_PE_EDSA_TAGGED : MVPP2_PE_EDSA_UNTAGGED; 534 shift = 8; 535 } else { 536 tid = tagged ? MVPP2_PE_DSA_TAGGED : MVPP2_PE_DSA_UNTAGGED; 537 shift = 4; 538 } 539 540 if (priv->prs_shadow[tid].valid) { 541 /* Entry exist - update port only */ 542 mvpp2_prs_init_from_hw(priv, &pe, tid); 543 } else { 544 /* Entry doesn't exist - create new */ 545 memset(&pe, 0, sizeof(pe)); 546 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_DSA); 547 pe.index = tid; 548 549 /* Update shadow table */ 550 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_DSA); 551 552 if (tagged) { 553 /* Set tagged bit in DSA tag */ 554 mvpp2_prs_tcam_data_byte_set(&pe, 0, 555 MVPP2_PRS_TCAM_DSA_TAGGED_BIT, 556 MVPP2_PRS_TCAM_DSA_TAGGED_BIT); 557 558 /* Set ai bits for next iteration */ 559 if (extend) 560 mvpp2_prs_sram_ai_update(&pe, 1, 561 MVPP2_PRS_SRAM_AI_MASK); 562 else 563 mvpp2_prs_sram_ai_update(&pe, 0, 564 MVPP2_PRS_SRAM_AI_MASK); 565 566 /* Set result info bits to 'single vlan' */ 567 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_SINGLE, 568 MVPP2_PRS_RI_VLAN_MASK); 569 /* If packet is tagged continue check vid filtering */ 570 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VID); 571 } else { 572 /* Shift 4 bytes for DSA tag or 8 bytes for EDSA tag*/ 573 mvpp2_prs_sram_shift_set(&pe, shift, 574 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 575 576 /* Set result info bits to 'no vlans' */ 577 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_NONE, 578 MVPP2_PRS_RI_VLAN_MASK); 579 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 580 } 581 582 /* Mask all ports */ 583 mvpp2_prs_tcam_port_map_set(&pe, 0); 584 } 585 586 /* Update port mask */ 587 mvpp2_prs_tcam_port_set(&pe, port, add); 588 589 mvpp2_prs_hw_write(priv, &pe); 590 } 591 592 /* Set entry for dsa ethertype */ 593 static void mvpp2_prs_dsa_tag_ethertype_set(struct mvpp2 *priv, int port, 594 bool add, bool tagged, bool extend) 595 { 596 struct mvpp2_prs_entry pe; 597 int tid, shift, port_mask; 598 599 if (extend) { 600 tid = tagged ? MVPP2_PE_ETYPE_EDSA_TAGGED : 601 MVPP2_PE_ETYPE_EDSA_UNTAGGED; 602 port_mask = 0; 603 shift = 8; 604 } else { 605 tid = tagged ? MVPP2_PE_ETYPE_DSA_TAGGED : 606 MVPP2_PE_ETYPE_DSA_UNTAGGED; 607 port_mask = MVPP2_PRS_PORT_MASK; 608 shift = 4; 609 } 610 611 if (priv->prs_shadow[tid].valid) { 612 /* Entry exist - update port only */ 613 mvpp2_prs_init_from_hw(priv, &pe, tid); 614 } else { 615 /* Entry doesn't exist - create new */ 616 memset(&pe, 0, sizeof(pe)); 617 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_DSA); 618 pe.index = tid; 619 620 /* Set ethertype */ 621 mvpp2_prs_match_etype(&pe, 0, ETH_P_EDSA); 622 mvpp2_prs_match_etype(&pe, 2, 0); 623 624 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DSA_MASK, 625 MVPP2_PRS_RI_DSA_MASK); 626 /* Shift ethertype + 2 byte reserved + tag*/ 627 mvpp2_prs_sram_shift_set(&pe, 2 + MVPP2_ETH_TYPE_LEN + shift, 628 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 629 630 /* Update shadow table */ 631 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_DSA); 632 633 if (tagged) { 634 /* Set tagged bit in DSA tag */ 635 mvpp2_prs_tcam_data_byte_set(&pe, 636 MVPP2_ETH_TYPE_LEN + 2 + 3, 637 MVPP2_PRS_TCAM_DSA_TAGGED_BIT, 638 MVPP2_PRS_TCAM_DSA_TAGGED_BIT); 639 /* Clear all ai bits for next iteration */ 640 mvpp2_prs_sram_ai_update(&pe, 0, 641 MVPP2_PRS_SRAM_AI_MASK); 642 /* If packet is tagged continue check vlans */ 643 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VLAN); 644 } else { 645 /* Set result info bits to 'no vlans' */ 646 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_NONE, 647 MVPP2_PRS_RI_VLAN_MASK); 648 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 649 } 650 /* Mask/unmask all ports, depending on dsa type */ 651 mvpp2_prs_tcam_port_map_set(&pe, port_mask); 652 } 653 654 /* Update port mask */ 655 mvpp2_prs_tcam_port_set(&pe, port, add); 656 657 mvpp2_prs_hw_write(priv, &pe); 658 } 659 660 /* Search for existing single/triple vlan entry */ 661 static int mvpp2_prs_vlan_find(struct mvpp2 *priv, unsigned short tpid, int ai) 662 { 663 struct mvpp2_prs_entry pe; 664 int tid; 665 666 /* Go through the all entries with MVPP2_PRS_LU_VLAN */ 667 for (tid = MVPP2_PE_FIRST_FREE_TID; 668 tid <= MVPP2_PE_LAST_FREE_TID; tid++) { 669 unsigned int ri_bits, ai_bits; 670 bool match; 671 672 if (!priv->prs_shadow[tid].valid || 673 priv->prs_shadow[tid].lu != MVPP2_PRS_LU_VLAN) 674 continue; 675 676 mvpp2_prs_init_from_hw(priv, &pe, tid); 677 match = mvpp2_prs_tcam_data_cmp(&pe, 0, tpid); 678 if (!match) 679 continue; 680 681 /* Get vlan type */ 682 ri_bits = mvpp2_prs_sram_ri_get(&pe); 683 ri_bits &= MVPP2_PRS_RI_VLAN_MASK; 684 685 /* Get current ai value from tcam */ 686 ai_bits = mvpp2_prs_tcam_ai_get(&pe); 687 /* Clear double vlan bit */ 688 ai_bits &= ~MVPP2_PRS_DBL_VLAN_AI_BIT; 689 690 if (ai != ai_bits) 691 continue; 692 693 if (ri_bits == MVPP2_PRS_RI_VLAN_SINGLE || 694 ri_bits == MVPP2_PRS_RI_VLAN_TRIPLE) 695 return tid; 696 } 697 698 return -ENOENT; 699 } 700 701 /* Add/update single/triple vlan entry */ 702 static int mvpp2_prs_vlan_add(struct mvpp2 *priv, unsigned short tpid, int ai, 703 unsigned int port_map) 704 { 705 struct mvpp2_prs_entry pe; 706 int tid_aux, tid; 707 int ret = 0; 708 709 memset(&pe, 0, sizeof(pe)); 710 711 tid = mvpp2_prs_vlan_find(priv, tpid, ai); 712 713 if (tid < 0) { 714 /* Create new tcam entry */ 715 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_LAST_FREE_TID, 716 MVPP2_PE_FIRST_FREE_TID); 717 if (tid < 0) 718 return tid; 719 720 /* Get last double vlan tid */ 721 for (tid_aux = MVPP2_PE_LAST_FREE_TID; 722 tid_aux >= MVPP2_PE_FIRST_FREE_TID; tid_aux--) { 723 unsigned int ri_bits; 724 725 if (!priv->prs_shadow[tid_aux].valid || 726 priv->prs_shadow[tid_aux].lu != MVPP2_PRS_LU_VLAN) 727 continue; 728 729 mvpp2_prs_init_from_hw(priv, &pe, tid_aux); 730 ri_bits = mvpp2_prs_sram_ri_get(&pe); 731 if ((ri_bits & MVPP2_PRS_RI_VLAN_MASK) == 732 MVPP2_PRS_RI_VLAN_DOUBLE) 733 break; 734 } 735 736 if (tid <= tid_aux) 737 return -EINVAL; 738 739 memset(&pe, 0, sizeof(pe)); 740 pe.index = tid; 741 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VLAN); 742 743 mvpp2_prs_match_etype(&pe, 0, tpid); 744 745 /* VLAN tag detected, proceed with VID filtering */ 746 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VID); 747 748 /* Clear all ai bits for next iteration */ 749 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 750 751 if (ai == MVPP2_PRS_SINGLE_VLAN_AI) { 752 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_SINGLE, 753 MVPP2_PRS_RI_VLAN_MASK); 754 } else { 755 ai |= MVPP2_PRS_DBL_VLAN_AI_BIT; 756 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_TRIPLE, 757 MVPP2_PRS_RI_VLAN_MASK); 758 } 759 mvpp2_prs_tcam_ai_update(&pe, ai, MVPP2_PRS_SRAM_AI_MASK); 760 761 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VLAN); 762 } else { 763 mvpp2_prs_init_from_hw(priv, &pe, tid); 764 } 765 /* Update ports' mask */ 766 mvpp2_prs_tcam_port_map_set(&pe, port_map); 767 768 mvpp2_prs_hw_write(priv, &pe); 769 770 return ret; 771 } 772 773 /* Get first free double vlan ai number */ 774 static int mvpp2_prs_double_vlan_ai_free_get(struct mvpp2 *priv) 775 { 776 int i; 777 778 for (i = 1; i < MVPP2_PRS_DBL_VLANS_MAX; i++) { 779 if (!priv->prs_double_vlans[i]) 780 return i; 781 } 782 783 return -EINVAL; 784 } 785 786 /* Search for existing double vlan entry */ 787 static int mvpp2_prs_double_vlan_find(struct mvpp2 *priv, unsigned short tpid1, 788 unsigned short tpid2) 789 { 790 struct mvpp2_prs_entry pe; 791 int tid; 792 793 /* Go through the all entries with MVPP2_PRS_LU_VLAN */ 794 for (tid = MVPP2_PE_FIRST_FREE_TID; 795 tid <= MVPP2_PE_LAST_FREE_TID; tid++) { 796 unsigned int ri_mask; 797 bool match; 798 799 if (!priv->prs_shadow[tid].valid || 800 priv->prs_shadow[tid].lu != MVPP2_PRS_LU_VLAN) 801 continue; 802 803 mvpp2_prs_init_from_hw(priv, &pe, tid); 804 805 match = mvpp2_prs_tcam_data_cmp(&pe, 0, tpid1) && 806 mvpp2_prs_tcam_data_cmp(&pe, 4, tpid2); 807 808 if (!match) 809 continue; 810 811 ri_mask = mvpp2_prs_sram_ri_get(&pe) & MVPP2_PRS_RI_VLAN_MASK; 812 if (ri_mask == MVPP2_PRS_RI_VLAN_DOUBLE) 813 return tid; 814 } 815 816 return -ENOENT; 817 } 818 819 /* Add or update double vlan entry */ 820 static int mvpp2_prs_double_vlan_add(struct mvpp2 *priv, unsigned short tpid1, 821 unsigned short tpid2, 822 unsigned int port_map) 823 { 824 int tid_aux, tid, ai, ret = 0; 825 struct mvpp2_prs_entry pe; 826 827 memset(&pe, 0, sizeof(pe)); 828 829 tid = mvpp2_prs_double_vlan_find(priv, tpid1, tpid2); 830 831 if (tid < 0) { 832 /* Create new tcam entry */ 833 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 834 MVPP2_PE_LAST_FREE_TID); 835 if (tid < 0) 836 return tid; 837 838 /* Set ai value for new double vlan entry */ 839 ai = mvpp2_prs_double_vlan_ai_free_get(priv); 840 if (ai < 0) 841 return ai; 842 843 /* Get first single/triple vlan tid */ 844 for (tid_aux = MVPP2_PE_FIRST_FREE_TID; 845 tid_aux <= MVPP2_PE_LAST_FREE_TID; tid_aux++) { 846 unsigned int ri_bits; 847 848 if (!priv->prs_shadow[tid_aux].valid || 849 priv->prs_shadow[tid_aux].lu != MVPP2_PRS_LU_VLAN) 850 continue; 851 852 mvpp2_prs_init_from_hw(priv, &pe, tid_aux); 853 ri_bits = mvpp2_prs_sram_ri_get(&pe); 854 ri_bits &= MVPP2_PRS_RI_VLAN_MASK; 855 if (ri_bits == MVPP2_PRS_RI_VLAN_SINGLE || 856 ri_bits == MVPP2_PRS_RI_VLAN_TRIPLE) 857 break; 858 } 859 860 if (tid >= tid_aux) 861 return -ERANGE; 862 863 memset(&pe, 0, sizeof(pe)); 864 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VLAN); 865 pe.index = tid; 866 867 priv->prs_double_vlans[ai] = true; 868 869 mvpp2_prs_match_etype(&pe, 0, tpid1); 870 mvpp2_prs_match_etype(&pe, 4, tpid2); 871 872 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VLAN); 873 /* Shift 4 bytes - skip outer vlan tag */ 874 mvpp2_prs_sram_shift_set(&pe, MVPP2_VLAN_TAG_LEN, 875 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 876 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_DOUBLE, 877 MVPP2_PRS_RI_VLAN_MASK); 878 mvpp2_prs_sram_ai_update(&pe, ai | MVPP2_PRS_DBL_VLAN_AI_BIT, 879 MVPP2_PRS_SRAM_AI_MASK); 880 881 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VLAN); 882 } else { 883 mvpp2_prs_init_from_hw(priv, &pe, tid); 884 } 885 886 /* Update ports' mask */ 887 mvpp2_prs_tcam_port_map_set(&pe, port_map); 888 mvpp2_prs_hw_write(priv, &pe); 889 890 return ret; 891 } 892 893 /* IPv4 header parsing for fragmentation and L4 offset */ 894 static int mvpp2_prs_ip4_proto(struct mvpp2 *priv, unsigned short proto, 895 unsigned int ri, unsigned int ri_mask) 896 { 897 struct mvpp2_prs_entry pe; 898 int tid; 899 900 if ((proto != IPPROTO_TCP) && (proto != IPPROTO_UDP) && 901 (proto != IPPROTO_IGMP)) 902 return -EINVAL; 903 904 /* Not fragmented packet */ 905 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 906 MVPP2_PE_LAST_FREE_TID); 907 if (tid < 0) 908 return tid; 909 910 memset(&pe, 0, sizeof(pe)); 911 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP4); 912 pe.index = tid; 913 914 /* Finished: go to flowid generation */ 915 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 916 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 917 918 /* Set L3 offset */ 919 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, -4, 920 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 921 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); 922 mvpp2_prs_sram_ri_update(&pe, ri, ri_mask | MVPP2_PRS_RI_IP_FRAG_MASK); 923 924 mvpp2_prs_tcam_data_byte_set(&pe, 2, 0x00, 925 MVPP2_PRS_TCAM_PROTO_MASK_L); 926 mvpp2_prs_tcam_data_byte_set(&pe, 3, 0x00, 927 MVPP2_PRS_TCAM_PROTO_MASK); 928 929 mvpp2_prs_tcam_data_byte_set(&pe, 5, proto, MVPP2_PRS_TCAM_PROTO_MASK); 930 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, 931 MVPP2_PRS_IPV4_DIP_AI_BIT); 932 /* Unmask all ports */ 933 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 934 935 /* Update shadow table and hw entry */ 936 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 937 mvpp2_prs_hw_write(priv, &pe); 938 939 /* Fragmented packet */ 940 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 941 MVPP2_PE_LAST_FREE_TID); 942 if (tid < 0) 943 return tid; 944 945 pe.index = tid; 946 /* Clear ri before updating */ 947 pe.sram[MVPP2_PRS_SRAM_RI_WORD] = 0x0; 948 pe.sram[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0; 949 mvpp2_prs_sram_ri_update(&pe, ri, ri_mask); 950 951 mvpp2_prs_sram_ri_update(&pe, ri | MVPP2_PRS_RI_IP_FRAG_TRUE, 952 ri_mask | MVPP2_PRS_RI_IP_FRAG_MASK); 953 954 mvpp2_prs_tcam_data_byte_set(&pe, 2, 0x00, 0x0); 955 mvpp2_prs_tcam_data_byte_set(&pe, 3, 0x00, 0x0); 956 957 /* Update shadow table and hw entry */ 958 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 959 mvpp2_prs_hw_write(priv, &pe); 960 961 return 0; 962 } 963 964 /* IPv4 L3 multicast or broadcast */ 965 static int mvpp2_prs_ip4_cast(struct mvpp2 *priv, unsigned short l3_cast) 966 { 967 struct mvpp2_prs_entry pe; 968 int mask, tid; 969 970 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 971 MVPP2_PE_LAST_FREE_TID); 972 if (tid < 0) 973 return tid; 974 975 memset(&pe, 0, sizeof(pe)); 976 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP4); 977 pe.index = tid; 978 979 switch (l3_cast) { 980 case MVPP2_PRS_L3_MULTI_CAST: 981 mvpp2_prs_tcam_data_byte_set(&pe, 0, MVPP2_PRS_IPV4_MC, 982 MVPP2_PRS_IPV4_MC_MASK); 983 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_MCAST, 984 MVPP2_PRS_RI_L3_ADDR_MASK); 985 break; 986 case MVPP2_PRS_L3_BROAD_CAST: 987 mask = MVPP2_PRS_IPV4_BC_MASK; 988 mvpp2_prs_tcam_data_byte_set(&pe, 0, mask, mask); 989 mvpp2_prs_tcam_data_byte_set(&pe, 1, mask, mask); 990 mvpp2_prs_tcam_data_byte_set(&pe, 2, mask, mask); 991 mvpp2_prs_tcam_data_byte_set(&pe, 3, mask, mask); 992 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_BCAST, 993 MVPP2_PRS_RI_L3_ADDR_MASK); 994 break; 995 default: 996 return -EINVAL; 997 } 998 999 /* Go again to ipv4 */ 1000 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4); 1001 1002 mvpp2_prs_sram_ai_update(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, 1003 MVPP2_PRS_IPV4_DIP_AI_BIT); 1004 1005 /* Shift back to IPv4 proto */ 1006 mvpp2_prs_sram_shift_set(&pe, -12, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1007 1008 mvpp2_prs_tcam_ai_update(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); 1009 1010 /* Unmask all ports */ 1011 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1012 1013 /* Update shadow table and hw entry */ 1014 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1015 mvpp2_prs_hw_write(priv, &pe); 1016 1017 return 0; 1018 } 1019 1020 /* Set entries for protocols over IPv6 */ 1021 static int mvpp2_prs_ip6_proto(struct mvpp2 *priv, unsigned short proto, 1022 unsigned int ri, unsigned int ri_mask) 1023 { 1024 struct mvpp2_prs_entry pe; 1025 int tid; 1026 1027 if ((proto != IPPROTO_TCP) && (proto != IPPROTO_UDP) && 1028 (proto != IPPROTO_ICMPV6) && (proto != IPPROTO_IPIP)) 1029 return -EINVAL; 1030 1031 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1032 MVPP2_PE_LAST_FREE_TID); 1033 if (tid < 0) 1034 return tid; 1035 1036 memset(&pe, 0, sizeof(pe)); 1037 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1038 pe.index = tid; 1039 1040 /* Finished: go to flowid generation */ 1041 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1042 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1043 mvpp2_prs_sram_ri_update(&pe, ri, ri_mask); 1044 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, 1045 sizeof(struct ipv6hdr) - 6, 1046 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1047 1048 mvpp2_prs_tcam_data_byte_set(&pe, 0, proto, MVPP2_PRS_TCAM_PROTO_MASK); 1049 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, 1050 MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1051 /* Unmask all ports */ 1052 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1053 1054 /* Write HW */ 1055 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP6); 1056 mvpp2_prs_hw_write(priv, &pe); 1057 1058 return 0; 1059 } 1060 1061 /* IPv6 L3 multicast entry */ 1062 static int mvpp2_prs_ip6_cast(struct mvpp2 *priv, unsigned short l3_cast) 1063 { 1064 struct mvpp2_prs_entry pe; 1065 int tid; 1066 1067 if (l3_cast != MVPP2_PRS_L3_MULTI_CAST) 1068 return -EINVAL; 1069 1070 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1071 MVPP2_PE_LAST_FREE_TID); 1072 if (tid < 0) 1073 return tid; 1074 1075 memset(&pe, 0, sizeof(pe)); 1076 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1077 pe.index = tid; 1078 1079 /* Finished: go to flowid generation */ 1080 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6); 1081 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_MCAST, 1082 MVPP2_PRS_RI_L3_ADDR_MASK); 1083 mvpp2_prs_sram_ai_update(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, 1084 MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1085 /* Shift back to IPv6 NH */ 1086 mvpp2_prs_sram_shift_set(&pe, -18, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1087 1088 mvpp2_prs_tcam_data_byte_set(&pe, 0, MVPP2_PRS_IPV6_MC, 1089 MVPP2_PRS_IPV6_MC_MASK); 1090 mvpp2_prs_tcam_ai_update(&pe, 0, MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1091 /* Unmask all ports */ 1092 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1093 1094 /* Update shadow table and hw entry */ 1095 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP6); 1096 mvpp2_prs_hw_write(priv, &pe); 1097 1098 return 0; 1099 } 1100 1101 /* Parser per-port initialization */ 1102 static void mvpp2_prs_hw_port_init(struct mvpp2 *priv, int port, int lu_first, 1103 int lu_max, int offset) 1104 { 1105 u32 val; 1106 1107 /* Set lookup ID */ 1108 val = mvpp2_read(priv, MVPP2_PRS_INIT_LOOKUP_REG); 1109 val &= ~MVPP2_PRS_PORT_LU_MASK(port); 1110 val |= MVPP2_PRS_PORT_LU_VAL(port, lu_first); 1111 mvpp2_write(priv, MVPP2_PRS_INIT_LOOKUP_REG, val); 1112 1113 /* Set maximum number of loops for packet received from port */ 1114 val = mvpp2_read(priv, MVPP2_PRS_MAX_LOOP_REG(port)); 1115 val &= ~MVPP2_PRS_MAX_LOOP_MASK(port); 1116 val |= MVPP2_PRS_MAX_LOOP_VAL(port, lu_max); 1117 mvpp2_write(priv, MVPP2_PRS_MAX_LOOP_REG(port), val); 1118 1119 /* Set initial offset for packet header extraction for the first 1120 * searching loop 1121 */ 1122 val = mvpp2_read(priv, MVPP2_PRS_INIT_OFFS_REG(port)); 1123 val &= ~MVPP2_PRS_INIT_OFF_MASK(port); 1124 val |= MVPP2_PRS_INIT_OFF_VAL(port, offset); 1125 mvpp2_write(priv, MVPP2_PRS_INIT_OFFS_REG(port), val); 1126 } 1127 1128 /* Default flow entries initialization for all ports */ 1129 static void mvpp2_prs_def_flow_init(struct mvpp2 *priv) 1130 { 1131 struct mvpp2_prs_entry pe; 1132 int port; 1133 1134 for (port = 0; port < MVPP2_MAX_PORTS; port++) { 1135 memset(&pe, 0, sizeof(pe)); 1136 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1137 pe.index = MVPP2_PE_FIRST_DEFAULT_FLOW - port; 1138 1139 /* Mask all ports */ 1140 mvpp2_prs_tcam_port_map_set(&pe, 0); 1141 1142 /* Set flow ID*/ 1143 mvpp2_prs_sram_ai_update(&pe, port, MVPP2_PRS_FLOW_ID_MASK); 1144 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1); 1145 1146 /* Update shadow table and hw entry */ 1147 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_FLOWS); 1148 mvpp2_prs_hw_write(priv, &pe); 1149 } 1150 } 1151 1152 /* Set default entry for Marvell Header field */ 1153 static void mvpp2_prs_mh_init(struct mvpp2 *priv) 1154 { 1155 struct mvpp2_prs_entry pe; 1156 1157 memset(&pe, 0, sizeof(pe)); 1158 1159 pe.index = MVPP2_PE_MH_DEFAULT; 1160 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MH); 1161 mvpp2_prs_sram_shift_set(&pe, MVPP2_MH_SIZE, 1162 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1163 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_MAC); 1164 1165 /* Unmask all ports */ 1166 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1167 1168 /* Update shadow table and hw entry */ 1169 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MH); 1170 mvpp2_prs_hw_write(priv, &pe); 1171 1172 /* Set MH entry that skip parser */ 1173 pe.index = MVPP2_PE_MH_SKIP_PRS; 1174 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MH); 1175 mvpp2_prs_sram_shift_set(&pe, MVPP2_MH_SIZE, 1176 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1177 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1178 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1179 1180 /* Mask all ports */ 1181 mvpp2_prs_tcam_port_map_set(&pe, 0); 1182 1183 /* Update shadow table and hw entry */ 1184 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MH); 1185 mvpp2_prs_hw_write(priv, &pe); 1186 } 1187 1188 /* Set default entires (place holder) for promiscuous, non-promiscuous and 1189 * multicast MAC addresses 1190 */ 1191 static void mvpp2_prs_mac_init(struct mvpp2 *priv) 1192 { 1193 struct mvpp2_prs_entry pe; 1194 1195 memset(&pe, 0, sizeof(pe)); 1196 1197 /* Non-promiscuous mode for all ports - DROP unknown packets */ 1198 pe.index = MVPP2_PE_MAC_NON_PROMISCUOUS; 1199 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC); 1200 1201 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK, 1202 MVPP2_PRS_RI_DROP_MASK); 1203 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1204 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1205 1206 /* Unmask all ports */ 1207 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1208 1209 /* Update shadow table and hw entry */ 1210 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 1211 mvpp2_prs_hw_write(priv, &pe); 1212 1213 /* Create dummy entries for drop all and promiscuous modes */ 1214 mvpp2_prs_drop_fc(priv); 1215 mvpp2_prs_mac_drop_all_set(priv, 0, false); 1216 mvpp2_prs_mac_promisc_set(priv, 0, MVPP2_PRS_L2_UNI_CAST, false); 1217 mvpp2_prs_mac_promisc_set(priv, 0, MVPP2_PRS_L2_MULTI_CAST, false); 1218 } 1219 1220 /* Set default entries for various types of dsa packets */ 1221 static void mvpp2_prs_dsa_init(struct mvpp2 *priv) 1222 { 1223 struct mvpp2_prs_entry pe; 1224 1225 /* None tagged EDSA entry - place holder */ 1226 mvpp2_prs_dsa_tag_set(priv, 0, false, MVPP2_PRS_UNTAGGED, 1227 MVPP2_PRS_EDSA); 1228 1229 /* Tagged EDSA entry - place holder */ 1230 mvpp2_prs_dsa_tag_set(priv, 0, false, MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); 1231 1232 /* None tagged DSA entry - place holder */ 1233 mvpp2_prs_dsa_tag_set(priv, 0, false, MVPP2_PRS_UNTAGGED, 1234 MVPP2_PRS_DSA); 1235 1236 /* Tagged DSA entry - place holder */ 1237 mvpp2_prs_dsa_tag_set(priv, 0, false, MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); 1238 1239 /* None tagged EDSA ethertype entry - place holder*/ 1240 mvpp2_prs_dsa_tag_ethertype_set(priv, 0, false, 1241 MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); 1242 1243 /* Tagged EDSA ethertype entry - place holder*/ 1244 mvpp2_prs_dsa_tag_ethertype_set(priv, 0, false, 1245 MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); 1246 1247 /* None tagged DSA ethertype entry */ 1248 mvpp2_prs_dsa_tag_ethertype_set(priv, 0, true, 1249 MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); 1250 1251 /* Tagged DSA ethertype entry */ 1252 mvpp2_prs_dsa_tag_ethertype_set(priv, 0, true, 1253 MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); 1254 1255 /* Set default entry, in case DSA or EDSA tag not found */ 1256 memset(&pe, 0, sizeof(pe)); 1257 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_DSA); 1258 pe.index = MVPP2_PE_DSA_DEFAULT; 1259 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VLAN); 1260 1261 /* Shift 0 bytes */ 1262 mvpp2_prs_sram_shift_set(&pe, 0, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1263 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 1264 1265 /* Clear all sram ai bits for next iteration */ 1266 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 1267 1268 /* Unmask all ports */ 1269 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1270 1271 mvpp2_prs_hw_write(priv, &pe); 1272 } 1273 1274 /* Initialize parser entries for VID filtering */ 1275 static void mvpp2_prs_vid_init(struct mvpp2 *priv) 1276 { 1277 struct mvpp2_prs_entry pe; 1278 1279 memset(&pe, 0, sizeof(pe)); 1280 1281 /* Set default vid entry */ 1282 pe.index = MVPP2_PE_VID_FLTR_DEFAULT; 1283 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VID); 1284 1285 mvpp2_prs_tcam_ai_update(&pe, 0, MVPP2_PRS_EDSA_VID_AI_BIT); 1286 1287 /* Skip VLAN header - Set offset to 4 bytes */ 1288 mvpp2_prs_sram_shift_set(&pe, MVPP2_VLAN_TAG_LEN, 1289 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1290 1291 /* Clear all ai bits for next iteration */ 1292 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 1293 1294 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 1295 1296 /* Unmask all ports */ 1297 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1298 1299 /* Update shadow table and hw entry */ 1300 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VID); 1301 mvpp2_prs_hw_write(priv, &pe); 1302 1303 /* Set default vid entry for extended DSA*/ 1304 memset(&pe, 0, sizeof(pe)); 1305 1306 /* Set default vid entry */ 1307 pe.index = MVPP2_PE_VID_EDSA_FLTR_DEFAULT; 1308 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VID); 1309 1310 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_EDSA_VID_AI_BIT, 1311 MVPP2_PRS_EDSA_VID_AI_BIT); 1312 1313 /* Skip VLAN header - Set offset to 8 bytes */ 1314 mvpp2_prs_sram_shift_set(&pe, MVPP2_VLAN_TAG_EDSA_LEN, 1315 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1316 1317 /* Clear all ai bits for next iteration */ 1318 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 1319 1320 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 1321 1322 /* Unmask all ports */ 1323 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1324 1325 /* Update shadow table and hw entry */ 1326 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VID); 1327 mvpp2_prs_hw_write(priv, &pe); 1328 } 1329 1330 /* Match basic ethertypes */ 1331 static int mvpp2_prs_etype_init(struct mvpp2 *priv) 1332 { 1333 struct mvpp2_prs_entry pe; 1334 int tid, ihl; 1335 1336 /* Ethertype: PPPoE */ 1337 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1338 MVPP2_PE_LAST_FREE_TID); 1339 if (tid < 0) 1340 return tid; 1341 1342 memset(&pe, 0, sizeof(pe)); 1343 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1344 pe.index = tid; 1345 1346 mvpp2_prs_match_etype(&pe, 0, ETH_P_PPP_SES); 1347 1348 mvpp2_prs_sram_shift_set(&pe, MVPP2_PPPOE_HDR_SIZE, 1349 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1350 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_PPPOE); 1351 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_PPPOE_MASK, 1352 MVPP2_PRS_RI_PPPOE_MASK); 1353 1354 /* Update shadow table and hw entry */ 1355 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1356 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1357 priv->prs_shadow[pe.index].finish = false; 1358 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_PPPOE_MASK, 1359 MVPP2_PRS_RI_PPPOE_MASK); 1360 mvpp2_prs_hw_write(priv, &pe); 1361 1362 /* Ethertype: ARP */ 1363 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1364 MVPP2_PE_LAST_FREE_TID); 1365 if (tid < 0) 1366 return tid; 1367 1368 memset(&pe, 0, sizeof(pe)); 1369 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1370 pe.index = tid; 1371 1372 mvpp2_prs_match_etype(&pe, 0, ETH_P_ARP); 1373 1374 /* Generate flow in the next iteration*/ 1375 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1376 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1377 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_ARP, 1378 MVPP2_PRS_RI_L3_PROTO_MASK); 1379 /* Set L3 offset */ 1380 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1381 MVPP2_ETH_TYPE_LEN, 1382 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1383 1384 /* Update shadow table and hw entry */ 1385 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1386 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1387 priv->prs_shadow[pe.index].finish = true; 1388 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_ARP, 1389 MVPP2_PRS_RI_L3_PROTO_MASK); 1390 mvpp2_prs_hw_write(priv, &pe); 1391 1392 /* Ethertype: LBTD */ 1393 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1394 MVPP2_PE_LAST_FREE_TID); 1395 if (tid < 0) 1396 return tid; 1397 1398 memset(&pe, 0, sizeof(pe)); 1399 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1400 pe.index = tid; 1401 1402 mvpp2_prs_match_etype(&pe, 0, MVPP2_IP_LBDT_TYPE); 1403 1404 /* Generate flow in the next iteration*/ 1405 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1406 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1407 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_CPU_CODE_RX_SPEC | 1408 MVPP2_PRS_RI_UDF3_RX_SPECIAL, 1409 MVPP2_PRS_RI_CPU_CODE_MASK | 1410 MVPP2_PRS_RI_UDF3_MASK); 1411 /* Set L3 offset */ 1412 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1413 MVPP2_ETH_TYPE_LEN, 1414 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1415 1416 /* Update shadow table and hw entry */ 1417 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1418 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1419 priv->prs_shadow[pe.index].finish = true; 1420 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_CPU_CODE_RX_SPEC | 1421 MVPP2_PRS_RI_UDF3_RX_SPECIAL, 1422 MVPP2_PRS_RI_CPU_CODE_MASK | 1423 MVPP2_PRS_RI_UDF3_MASK); 1424 mvpp2_prs_hw_write(priv, &pe); 1425 1426 /* Ethertype: IPv4 with header length >= 5 */ 1427 for (ihl = MVPP2_PRS_IPV4_IHL_MIN; ihl <= MVPP2_PRS_IPV4_IHL_MAX; ihl++) { 1428 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1429 MVPP2_PE_LAST_FREE_TID); 1430 if (tid < 0) 1431 return tid; 1432 1433 memset(&pe, 0, sizeof(pe)); 1434 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1435 pe.index = tid; 1436 1437 mvpp2_prs_match_etype(&pe, 0, ETH_P_IP); 1438 mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN, 1439 MVPP2_PRS_IPV4_HEAD | ihl, 1440 MVPP2_PRS_IPV4_HEAD_MASK | 1441 MVPP2_PRS_IPV4_IHL_MASK); 1442 1443 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4); 1444 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4, 1445 MVPP2_PRS_RI_L3_PROTO_MASK); 1446 /* goto ipv4 dst-address (skip eth_type + IP-header-size - 4) */ 1447 mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 1448 sizeof(struct iphdr) - 4, 1449 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1450 /* Set L4 offset */ 1451 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, 1452 MVPP2_ETH_TYPE_LEN + (ihl * 4), 1453 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1454 1455 /* Update shadow table and hw entry */ 1456 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1457 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1458 priv->prs_shadow[pe.index].finish = false; 1459 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP4, 1460 MVPP2_PRS_RI_L3_PROTO_MASK); 1461 mvpp2_prs_hw_write(priv, &pe); 1462 } 1463 1464 /* Ethertype: IPv6 without options */ 1465 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1466 MVPP2_PE_LAST_FREE_TID); 1467 if (tid < 0) 1468 return tid; 1469 1470 memset(&pe, 0, sizeof(pe)); 1471 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1472 pe.index = tid; 1473 1474 mvpp2_prs_match_etype(&pe, 0, ETH_P_IPV6); 1475 1476 /* Skip DIP of IPV6 header */ 1477 mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 8 + 1478 MVPP2_MAX_L3_ADDR_SIZE, 1479 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1480 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6); 1481 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP6, 1482 MVPP2_PRS_RI_L3_PROTO_MASK); 1483 /* Set L3 offset */ 1484 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1485 MVPP2_ETH_TYPE_LEN, 1486 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1487 1488 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1489 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1490 priv->prs_shadow[pe.index].finish = false; 1491 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_IP6, 1492 MVPP2_PRS_RI_L3_PROTO_MASK); 1493 mvpp2_prs_hw_write(priv, &pe); 1494 1495 /* Default entry for MVPP2_PRS_LU_L2 - Unknown ethtype */ 1496 memset(&pe, 0, sizeof(struct mvpp2_prs_entry)); 1497 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_L2); 1498 pe.index = MVPP2_PE_ETH_TYPE_UN; 1499 1500 /* Unmask all ports */ 1501 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1502 1503 /* Generate flow in the next iteration*/ 1504 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1505 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1506 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UN, 1507 MVPP2_PRS_RI_L3_PROTO_MASK); 1508 /* Set L3 offset even it's unknown L3 */ 1509 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1510 MVPP2_ETH_TYPE_LEN, 1511 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1512 1513 /* Update shadow table and hw entry */ 1514 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_L2); 1515 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; 1516 priv->prs_shadow[pe.index].finish = true; 1517 mvpp2_prs_shadow_ri_set(priv, pe.index, MVPP2_PRS_RI_L3_UN, 1518 MVPP2_PRS_RI_L3_PROTO_MASK); 1519 mvpp2_prs_hw_write(priv, &pe); 1520 1521 return 0; 1522 } 1523 1524 /* Configure vlan entries and detect up to 2 successive VLAN tags. 1525 * Possible options: 1526 * 0x8100, 0x88A8 1527 * 0x8100, 0x8100 1528 * 0x8100 1529 * 0x88A8 1530 */ 1531 static int mvpp2_prs_vlan_init(struct platform_device *pdev, struct mvpp2 *priv) 1532 { 1533 struct mvpp2_prs_entry pe; 1534 int err; 1535 1536 priv->prs_double_vlans = devm_kcalloc(&pdev->dev, sizeof(bool), 1537 MVPP2_PRS_DBL_VLANS_MAX, 1538 GFP_KERNEL); 1539 if (!priv->prs_double_vlans) 1540 return -ENOMEM; 1541 1542 /* Double VLAN: 0x8100, 0x88A8 */ 1543 err = mvpp2_prs_double_vlan_add(priv, ETH_P_8021Q, ETH_P_8021AD, 1544 MVPP2_PRS_PORT_MASK); 1545 if (err) 1546 return err; 1547 1548 /* Double VLAN: 0x8100, 0x8100 */ 1549 err = mvpp2_prs_double_vlan_add(priv, ETH_P_8021Q, ETH_P_8021Q, 1550 MVPP2_PRS_PORT_MASK); 1551 if (err) 1552 return err; 1553 1554 /* Single VLAN: 0x88a8 */ 1555 err = mvpp2_prs_vlan_add(priv, ETH_P_8021AD, MVPP2_PRS_SINGLE_VLAN_AI, 1556 MVPP2_PRS_PORT_MASK); 1557 if (err) 1558 return err; 1559 1560 /* Single VLAN: 0x8100 */ 1561 err = mvpp2_prs_vlan_add(priv, ETH_P_8021Q, MVPP2_PRS_SINGLE_VLAN_AI, 1562 MVPP2_PRS_PORT_MASK); 1563 if (err) 1564 return err; 1565 1566 /* Set default double vlan entry */ 1567 memset(&pe, 0, sizeof(pe)); 1568 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VLAN); 1569 pe.index = MVPP2_PE_VLAN_DBL; 1570 1571 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_VID); 1572 1573 /* Clear ai for next iterations */ 1574 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 1575 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_DOUBLE, 1576 MVPP2_PRS_RI_VLAN_MASK); 1577 1578 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_DBL_VLAN_AI_BIT, 1579 MVPP2_PRS_DBL_VLAN_AI_BIT); 1580 /* Unmask all ports */ 1581 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1582 1583 /* Update shadow table and hw entry */ 1584 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VLAN); 1585 mvpp2_prs_hw_write(priv, &pe); 1586 1587 /* Set default vlan none entry */ 1588 memset(&pe, 0, sizeof(pe)); 1589 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VLAN); 1590 pe.index = MVPP2_PE_VLAN_NONE; 1591 1592 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 1593 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_VLAN_NONE, 1594 MVPP2_PRS_RI_VLAN_MASK); 1595 1596 /* Unmask all ports */ 1597 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1598 1599 /* Update shadow table and hw entry */ 1600 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VLAN); 1601 mvpp2_prs_hw_write(priv, &pe); 1602 1603 return 0; 1604 } 1605 1606 /* Set entries for PPPoE ethertype */ 1607 static int mvpp2_prs_pppoe_init(struct mvpp2 *priv) 1608 { 1609 struct mvpp2_prs_entry pe; 1610 int tid; 1611 1612 /* IPv4 over PPPoE with options */ 1613 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1614 MVPP2_PE_LAST_FREE_TID); 1615 if (tid < 0) 1616 return tid; 1617 1618 memset(&pe, 0, sizeof(pe)); 1619 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_PPPOE); 1620 pe.index = tid; 1621 1622 mvpp2_prs_match_etype(&pe, 0, PPP_IP); 1623 1624 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4); 1625 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4_OPT, 1626 MVPP2_PRS_RI_L3_PROTO_MASK); 1627 /* goto ipv4 dest-address (skip eth_type + IP-header-size - 4) */ 1628 mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 1629 sizeof(struct iphdr) - 4, 1630 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1631 /* Set L3 offset */ 1632 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1633 MVPP2_ETH_TYPE_LEN, 1634 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1635 1636 /* Update shadow table and hw entry */ 1637 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_PPPOE); 1638 mvpp2_prs_hw_write(priv, &pe); 1639 1640 /* IPv4 over PPPoE without options */ 1641 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1642 MVPP2_PE_LAST_FREE_TID); 1643 if (tid < 0) 1644 return tid; 1645 1646 pe.index = tid; 1647 1648 mvpp2_prs_tcam_data_byte_set(&pe, MVPP2_ETH_TYPE_LEN, 1649 MVPP2_PRS_IPV4_HEAD | 1650 MVPP2_PRS_IPV4_IHL_MIN, 1651 MVPP2_PRS_IPV4_HEAD_MASK | 1652 MVPP2_PRS_IPV4_IHL_MASK); 1653 1654 /* Clear ri before updating */ 1655 pe.sram[MVPP2_PRS_SRAM_RI_WORD] = 0x0; 1656 pe.sram[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0; 1657 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP4, 1658 MVPP2_PRS_RI_L3_PROTO_MASK); 1659 1660 /* Update shadow table and hw entry */ 1661 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_PPPOE); 1662 mvpp2_prs_hw_write(priv, &pe); 1663 1664 /* IPv6 over PPPoE */ 1665 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1666 MVPP2_PE_LAST_FREE_TID); 1667 if (tid < 0) 1668 return tid; 1669 1670 memset(&pe, 0, sizeof(pe)); 1671 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_PPPOE); 1672 pe.index = tid; 1673 1674 mvpp2_prs_match_etype(&pe, 0, PPP_IPV6); 1675 1676 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6); 1677 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_IP6, 1678 MVPP2_PRS_RI_L3_PROTO_MASK); 1679 /* Jump to DIP of IPV6 header */ 1680 mvpp2_prs_sram_shift_set(&pe, MVPP2_ETH_TYPE_LEN + 8 + 1681 MVPP2_MAX_L3_ADDR_SIZE, 1682 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1683 /* Set L3 offset */ 1684 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1685 MVPP2_ETH_TYPE_LEN, 1686 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1687 1688 /* Update shadow table and hw entry */ 1689 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_PPPOE); 1690 mvpp2_prs_hw_write(priv, &pe); 1691 1692 /* Non-IP over PPPoE */ 1693 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1694 MVPP2_PE_LAST_FREE_TID); 1695 if (tid < 0) 1696 return tid; 1697 1698 memset(&pe, 0, sizeof(pe)); 1699 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_PPPOE); 1700 pe.index = tid; 1701 1702 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UN, 1703 MVPP2_PRS_RI_L3_PROTO_MASK); 1704 1705 /* Finished: go to flowid generation */ 1706 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1707 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1708 /* Set L3 offset even if it's unknown L3 */ 1709 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, 1710 MVPP2_ETH_TYPE_LEN, 1711 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1712 1713 /* Update shadow table and hw entry */ 1714 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_PPPOE); 1715 mvpp2_prs_hw_write(priv, &pe); 1716 1717 return 0; 1718 } 1719 1720 /* Initialize entries for IPv4 */ 1721 static int mvpp2_prs_ip4_init(struct mvpp2 *priv) 1722 { 1723 struct mvpp2_prs_entry pe; 1724 int err; 1725 1726 /* Set entries for TCP, UDP and IGMP over IPv4 */ 1727 err = mvpp2_prs_ip4_proto(priv, IPPROTO_TCP, MVPP2_PRS_RI_L4_TCP, 1728 MVPP2_PRS_RI_L4_PROTO_MASK); 1729 if (err) 1730 return err; 1731 1732 err = mvpp2_prs_ip4_proto(priv, IPPROTO_UDP, MVPP2_PRS_RI_L4_UDP, 1733 MVPP2_PRS_RI_L4_PROTO_MASK); 1734 if (err) 1735 return err; 1736 1737 err = mvpp2_prs_ip4_proto(priv, IPPROTO_IGMP, 1738 MVPP2_PRS_RI_CPU_CODE_RX_SPEC | 1739 MVPP2_PRS_RI_UDF3_RX_SPECIAL, 1740 MVPP2_PRS_RI_CPU_CODE_MASK | 1741 MVPP2_PRS_RI_UDF3_MASK); 1742 if (err) 1743 return err; 1744 1745 /* IPv4 Broadcast */ 1746 err = mvpp2_prs_ip4_cast(priv, MVPP2_PRS_L3_BROAD_CAST); 1747 if (err) 1748 return err; 1749 1750 /* IPv4 Multicast */ 1751 err = mvpp2_prs_ip4_cast(priv, MVPP2_PRS_L3_MULTI_CAST); 1752 if (err) 1753 return err; 1754 1755 /* Default IPv4 entry for unknown protocols */ 1756 memset(&pe, 0, sizeof(pe)); 1757 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP4); 1758 pe.index = MVPP2_PE_IP4_PROTO_UN; 1759 1760 /* Finished: go to flowid generation */ 1761 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1762 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1763 1764 /* Set L3 offset */ 1765 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, -4, 1766 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1767 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); 1768 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L4_OTHER, 1769 MVPP2_PRS_RI_L4_PROTO_MASK); 1770 1771 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, 1772 MVPP2_PRS_IPV4_DIP_AI_BIT); 1773 /* Unmask all ports */ 1774 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1775 1776 /* Update shadow table and hw entry */ 1777 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1778 mvpp2_prs_hw_write(priv, &pe); 1779 1780 /* Default IPv4 entry for unicast address */ 1781 memset(&pe, 0, sizeof(pe)); 1782 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP4); 1783 pe.index = MVPP2_PE_IP4_ADDR_UN; 1784 1785 /* Go again to ipv4 */ 1786 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP4); 1787 1788 mvpp2_prs_sram_ai_update(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, 1789 MVPP2_PRS_IPV4_DIP_AI_BIT); 1790 1791 /* Shift back to IPv4 proto */ 1792 mvpp2_prs_sram_shift_set(&pe, -12, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1793 1794 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UCAST, 1795 MVPP2_PRS_RI_L3_ADDR_MASK); 1796 mvpp2_prs_tcam_ai_update(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); 1797 1798 /* Unmask all ports */ 1799 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1800 1801 /* Update shadow table and hw entry */ 1802 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1803 mvpp2_prs_hw_write(priv, &pe); 1804 1805 return 0; 1806 } 1807 1808 /* Initialize entries for IPv6 */ 1809 static int mvpp2_prs_ip6_init(struct mvpp2 *priv) 1810 { 1811 struct mvpp2_prs_entry pe; 1812 int tid, err; 1813 1814 /* Set entries for TCP, UDP and ICMP over IPv6 */ 1815 err = mvpp2_prs_ip6_proto(priv, IPPROTO_TCP, 1816 MVPP2_PRS_RI_L4_TCP, 1817 MVPP2_PRS_RI_L4_PROTO_MASK); 1818 if (err) 1819 return err; 1820 1821 err = mvpp2_prs_ip6_proto(priv, IPPROTO_UDP, 1822 MVPP2_PRS_RI_L4_UDP, 1823 MVPP2_PRS_RI_L4_PROTO_MASK); 1824 if (err) 1825 return err; 1826 1827 err = mvpp2_prs_ip6_proto(priv, IPPROTO_ICMPV6, 1828 MVPP2_PRS_RI_CPU_CODE_RX_SPEC | 1829 MVPP2_PRS_RI_UDF3_RX_SPECIAL, 1830 MVPP2_PRS_RI_CPU_CODE_MASK | 1831 MVPP2_PRS_RI_UDF3_MASK); 1832 if (err) 1833 return err; 1834 1835 /* IPv4 is the last header. This is similar case as 6-TCP or 17-UDP */ 1836 /* Result Info: UDF7=1, DS lite */ 1837 err = mvpp2_prs_ip6_proto(priv, IPPROTO_IPIP, 1838 MVPP2_PRS_RI_UDF7_IP6_LITE, 1839 MVPP2_PRS_RI_UDF7_MASK); 1840 if (err) 1841 return err; 1842 1843 /* IPv6 multicast */ 1844 err = mvpp2_prs_ip6_cast(priv, MVPP2_PRS_L3_MULTI_CAST); 1845 if (err) 1846 return err; 1847 1848 /* Entry for checking hop limit */ 1849 tid = mvpp2_prs_tcam_first_free(priv, MVPP2_PE_FIRST_FREE_TID, 1850 MVPP2_PE_LAST_FREE_TID); 1851 if (tid < 0) 1852 return tid; 1853 1854 memset(&pe, 0, sizeof(pe)); 1855 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1856 pe.index = tid; 1857 1858 /* Finished: go to flowid generation */ 1859 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1860 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1861 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UN | 1862 MVPP2_PRS_RI_DROP_MASK, 1863 MVPP2_PRS_RI_L3_PROTO_MASK | 1864 MVPP2_PRS_RI_DROP_MASK); 1865 1866 mvpp2_prs_tcam_data_byte_set(&pe, 1, 0x00, MVPP2_PRS_IPV6_HOP_MASK); 1867 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, 1868 MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1869 1870 /* Update shadow table and hw entry */ 1871 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1872 mvpp2_prs_hw_write(priv, &pe); 1873 1874 /* Default IPv6 entry for unknown protocols */ 1875 memset(&pe, 0, sizeof(pe)); 1876 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1877 pe.index = MVPP2_PE_IP6_PROTO_UN; 1878 1879 /* Finished: go to flowid generation */ 1880 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1881 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1882 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L4_OTHER, 1883 MVPP2_PRS_RI_L4_PROTO_MASK); 1884 /* Set L4 offset relatively to our current place */ 1885 mvpp2_prs_sram_offset_set(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, 1886 sizeof(struct ipv6hdr) - 4, 1887 MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); 1888 1889 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, 1890 MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1891 /* Unmask all ports */ 1892 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1893 1894 /* Update shadow table and hw entry */ 1895 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1896 mvpp2_prs_hw_write(priv, &pe); 1897 1898 /* Default IPv6 entry for unknown ext protocols */ 1899 memset(&pe, 0, sizeof(struct mvpp2_prs_entry)); 1900 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1901 pe.index = MVPP2_PE_IP6_EXT_PROTO_UN; 1902 1903 /* Finished: go to flowid generation */ 1904 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 1905 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); 1906 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L4_OTHER, 1907 MVPP2_PRS_RI_L4_PROTO_MASK); 1908 1909 mvpp2_prs_tcam_ai_update(&pe, MVPP2_PRS_IPV6_EXT_AI_BIT, 1910 MVPP2_PRS_IPV6_EXT_AI_BIT); 1911 /* Unmask all ports */ 1912 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1913 1914 /* Update shadow table and hw entry */ 1915 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP4); 1916 mvpp2_prs_hw_write(priv, &pe); 1917 1918 /* Default IPv6 entry for unicast address */ 1919 memset(&pe, 0, sizeof(struct mvpp2_prs_entry)); 1920 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_IP6); 1921 pe.index = MVPP2_PE_IP6_ADDR_UN; 1922 1923 /* Finished: go to IPv6 again */ 1924 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_IP6); 1925 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_L3_UCAST, 1926 MVPP2_PRS_RI_L3_ADDR_MASK); 1927 mvpp2_prs_sram_ai_update(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, 1928 MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1929 /* Shift back to IPV6 NH */ 1930 mvpp2_prs_sram_shift_set(&pe, -18, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 1931 1932 mvpp2_prs_tcam_ai_update(&pe, 0, MVPP2_PRS_IPV6_NO_EXT_AI_BIT); 1933 /* Unmask all ports */ 1934 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 1935 1936 /* Update shadow table and hw entry */ 1937 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_IP6); 1938 mvpp2_prs_hw_write(priv, &pe); 1939 1940 return 0; 1941 } 1942 1943 /* Find tcam entry with matched pair <vid,port> */ 1944 static int mvpp2_prs_vid_range_find(struct mvpp2_port *port, u16 vid, u16 mask) 1945 { 1946 unsigned char byte[2], enable[2]; 1947 struct mvpp2_prs_entry pe; 1948 u16 rvid, rmask; 1949 int tid; 1950 1951 /* Go through the all entries with MVPP2_PRS_LU_VID */ 1952 for (tid = MVPP2_PRS_VID_PORT_FIRST(port->id); 1953 tid <= MVPP2_PRS_VID_PORT_LAST(port->id); tid++) { 1954 if (!port->priv->prs_shadow[tid].valid || 1955 port->priv->prs_shadow[tid].lu != MVPP2_PRS_LU_VID) 1956 continue; 1957 1958 mvpp2_prs_init_from_hw(port->priv, &pe, tid); 1959 1960 mvpp2_prs_tcam_data_byte_get(&pe, 2, &byte[0], &enable[0]); 1961 mvpp2_prs_tcam_data_byte_get(&pe, 3, &byte[1], &enable[1]); 1962 1963 rvid = ((byte[0] & 0xf) << 8) + byte[1]; 1964 rmask = ((enable[0] & 0xf) << 8) + enable[1]; 1965 1966 if (rvid != vid || rmask != mask) 1967 continue; 1968 1969 return tid; 1970 } 1971 1972 return -ENOENT; 1973 } 1974 1975 /* Write parser entry for VID filtering */ 1976 int mvpp2_prs_vid_entry_add(struct mvpp2_port *port, u16 vid) 1977 { 1978 unsigned int vid_start = MVPP2_PE_VID_FILT_RANGE_START + 1979 port->id * MVPP2_PRS_VLAN_FILT_MAX; 1980 unsigned int mask = 0xfff, reg_val, shift; 1981 struct mvpp2 *priv = port->priv; 1982 struct mvpp2_prs_entry pe; 1983 int tid; 1984 1985 memset(&pe, 0, sizeof(pe)); 1986 1987 /* Scan TCAM and see if entry with this <vid,port> already exist */ 1988 tid = mvpp2_prs_vid_range_find(port, vid, mask); 1989 1990 reg_val = mvpp2_read(priv, MVPP2_MH_REG(port->id)); 1991 if (reg_val & MVPP2_DSA_EXTENDED) 1992 shift = MVPP2_VLAN_TAG_EDSA_LEN; 1993 else 1994 shift = MVPP2_VLAN_TAG_LEN; 1995 1996 /* No such entry */ 1997 if (tid < 0) { 1998 1999 /* Go through all entries from first to last in vlan range */ 2000 tid = mvpp2_prs_tcam_first_free(priv, vid_start, 2001 vid_start + 2002 MVPP2_PRS_VLAN_FILT_MAX_ENTRY); 2003 2004 /* There isn't room for a new VID filter */ 2005 if (tid < 0) 2006 return tid; 2007 2008 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VID); 2009 pe.index = tid; 2010 2011 /* Mask all ports */ 2012 mvpp2_prs_tcam_port_map_set(&pe, 0); 2013 } else { 2014 mvpp2_prs_init_from_hw(priv, &pe, tid); 2015 } 2016 2017 /* Enable the current port */ 2018 mvpp2_prs_tcam_port_set(&pe, port->id, true); 2019 2020 /* Continue - set next lookup */ 2021 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 2022 2023 /* Skip VLAN header - Set offset to 4 or 8 bytes */ 2024 mvpp2_prs_sram_shift_set(&pe, shift, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 2025 2026 /* Set match on VID */ 2027 mvpp2_prs_match_vid(&pe, MVPP2_PRS_VID_TCAM_BYTE, vid); 2028 2029 /* Clear all ai bits for next iteration */ 2030 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 2031 2032 /* Update shadow table */ 2033 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VID); 2034 mvpp2_prs_hw_write(priv, &pe); 2035 2036 return 0; 2037 } 2038 2039 /* Write parser entry for VID filtering */ 2040 void mvpp2_prs_vid_entry_remove(struct mvpp2_port *port, u16 vid) 2041 { 2042 struct mvpp2 *priv = port->priv; 2043 int tid; 2044 2045 /* Scan TCAM and see if entry with this <vid,port> already exist */ 2046 tid = mvpp2_prs_vid_range_find(port, vid, 0xfff); 2047 2048 /* No such entry */ 2049 if (tid < 0) 2050 return; 2051 2052 mvpp2_prs_hw_inv(priv, tid); 2053 priv->prs_shadow[tid].valid = false; 2054 } 2055 2056 /* Remove all existing VID filters on this port */ 2057 void mvpp2_prs_vid_remove_all(struct mvpp2_port *port) 2058 { 2059 struct mvpp2 *priv = port->priv; 2060 int tid; 2061 2062 for (tid = MVPP2_PRS_VID_PORT_FIRST(port->id); 2063 tid <= MVPP2_PRS_VID_PORT_LAST(port->id); tid++) { 2064 if (priv->prs_shadow[tid].valid) { 2065 mvpp2_prs_hw_inv(priv, tid); 2066 priv->prs_shadow[tid].valid = false; 2067 } 2068 } 2069 } 2070 2071 /* Remove VID filering entry for this port */ 2072 void mvpp2_prs_vid_disable_filtering(struct mvpp2_port *port) 2073 { 2074 unsigned int tid = MVPP2_PRS_VID_PORT_DFLT(port->id); 2075 struct mvpp2 *priv = port->priv; 2076 2077 /* Invalidate the guard entry */ 2078 mvpp2_prs_hw_inv(priv, tid); 2079 2080 priv->prs_shadow[tid].valid = false; 2081 } 2082 2083 /* Add guard entry that drops packets when no VID is matched on this port */ 2084 void mvpp2_prs_vid_enable_filtering(struct mvpp2_port *port) 2085 { 2086 unsigned int tid = MVPP2_PRS_VID_PORT_DFLT(port->id); 2087 struct mvpp2 *priv = port->priv; 2088 unsigned int reg_val, shift; 2089 struct mvpp2_prs_entry pe; 2090 2091 if (priv->prs_shadow[tid].valid) 2092 return; 2093 2094 memset(&pe, 0, sizeof(pe)); 2095 2096 pe.index = tid; 2097 2098 reg_val = mvpp2_read(priv, MVPP2_MH_REG(port->id)); 2099 if (reg_val & MVPP2_DSA_EXTENDED) 2100 shift = MVPP2_VLAN_TAG_EDSA_LEN; 2101 else 2102 shift = MVPP2_VLAN_TAG_LEN; 2103 2104 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_VID); 2105 2106 /* Mask all ports */ 2107 mvpp2_prs_tcam_port_map_set(&pe, 0); 2108 2109 /* Update port mask */ 2110 mvpp2_prs_tcam_port_set(&pe, port->id, true); 2111 2112 /* Continue - set next lookup */ 2113 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_L2); 2114 2115 /* Skip VLAN header - Set offset to 4 or 8 bytes */ 2116 mvpp2_prs_sram_shift_set(&pe, shift, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 2117 2118 /* Drop VLAN packets that don't belong to any VIDs on this port */ 2119 mvpp2_prs_sram_ri_update(&pe, MVPP2_PRS_RI_DROP_MASK, 2120 MVPP2_PRS_RI_DROP_MASK); 2121 2122 /* Clear all ai bits for next iteration */ 2123 mvpp2_prs_sram_ai_update(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); 2124 2125 /* Update shadow table */ 2126 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_VID); 2127 mvpp2_prs_hw_write(priv, &pe); 2128 } 2129 2130 /* Parser default initialization */ 2131 int mvpp2_prs_default_init(struct platform_device *pdev, struct mvpp2 *priv) 2132 { 2133 int err, index, i; 2134 2135 /* Enable tcam table */ 2136 mvpp2_write(priv, MVPP2_PRS_TCAM_CTRL_REG, MVPP2_PRS_TCAM_EN_MASK); 2137 2138 /* Clear all tcam and sram entries */ 2139 for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) { 2140 mvpp2_write(priv, MVPP2_PRS_TCAM_IDX_REG, index); 2141 for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) 2142 mvpp2_write(priv, MVPP2_PRS_TCAM_DATA_REG(i), 0); 2143 2144 mvpp2_write(priv, MVPP2_PRS_SRAM_IDX_REG, index); 2145 for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) 2146 mvpp2_write(priv, MVPP2_PRS_SRAM_DATA_REG(i), 0); 2147 } 2148 2149 /* Invalidate all tcam entries */ 2150 for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) 2151 mvpp2_prs_hw_inv(priv, index); 2152 2153 priv->prs_shadow = devm_kcalloc(&pdev->dev, MVPP2_PRS_TCAM_SRAM_SIZE, 2154 sizeof(*priv->prs_shadow), 2155 GFP_KERNEL); 2156 if (!priv->prs_shadow) 2157 return -ENOMEM; 2158 2159 /* Always start from lookup = 0 */ 2160 for (index = 0; index < MVPP2_MAX_PORTS; index++) 2161 mvpp2_prs_hw_port_init(priv, index, MVPP2_PRS_LU_MH, 2162 MVPP2_PRS_PORT_LU_MAX, 0); 2163 2164 mvpp2_prs_def_flow_init(priv); 2165 2166 mvpp2_prs_mh_init(priv); 2167 2168 mvpp2_prs_mac_init(priv); 2169 2170 mvpp2_prs_dsa_init(priv); 2171 2172 mvpp2_prs_vid_init(priv); 2173 2174 err = mvpp2_prs_etype_init(priv); 2175 if (err) 2176 return err; 2177 2178 err = mvpp2_prs_vlan_init(pdev, priv); 2179 if (err) 2180 return err; 2181 2182 err = mvpp2_prs_pppoe_init(priv); 2183 if (err) 2184 return err; 2185 2186 err = mvpp2_prs_ip6_init(priv); 2187 if (err) 2188 return err; 2189 2190 err = mvpp2_prs_ip4_init(priv); 2191 if (err) 2192 return err; 2193 2194 return 0; 2195 } 2196 2197 /* Compare MAC DA with tcam entry data */ 2198 static bool mvpp2_prs_mac_range_equals(struct mvpp2_prs_entry *pe, 2199 const u8 *da, unsigned char *mask) 2200 { 2201 unsigned char tcam_byte, tcam_mask; 2202 int index; 2203 2204 for (index = 0; index < ETH_ALEN; index++) { 2205 mvpp2_prs_tcam_data_byte_get(pe, index, &tcam_byte, &tcam_mask); 2206 if (tcam_mask != mask[index]) 2207 return false; 2208 2209 if ((tcam_mask & tcam_byte) != (da[index] & mask[index])) 2210 return false; 2211 } 2212 2213 return true; 2214 } 2215 2216 /* Find tcam entry with matched pair <MAC DA, port> */ 2217 static int 2218 mvpp2_prs_mac_da_range_find(struct mvpp2 *priv, int pmap, const u8 *da, 2219 unsigned char *mask, int udf_type) 2220 { 2221 struct mvpp2_prs_entry pe; 2222 int tid; 2223 2224 /* Go through the all entires with MVPP2_PRS_LU_MAC */ 2225 for (tid = MVPP2_PE_MAC_RANGE_START; 2226 tid <= MVPP2_PE_MAC_RANGE_END; tid++) { 2227 unsigned int entry_pmap; 2228 2229 if (!priv->prs_shadow[tid].valid || 2230 (priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC) || 2231 (priv->prs_shadow[tid].udf != udf_type)) 2232 continue; 2233 2234 mvpp2_prs_init_from_hw(priv, &pe, tid); 2235 entry_pmap = mvpp2_prs_tcam_port_map_get(&pe); 2236 2237 if (mvpp2_prs_mac_range_equals(&pe, da, mask) && 2238 entry_pmap == pmap) 2239 return tid; 2240 } 2241 2242 return -ENOENT; 2243 } 2244 2245 /* Update parser's mac da entry */ 2246 int mvpp2_prs_mac_da_accept(struct mvpp2_port *port, const u8 *da, bool add) 2247 { 2248 unsigned char mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 2249 struct mvpp2 *priv = port->priv; 2250 unsigned int pmap, len, ri; 2251 struct mvpp2_prs_entry pe; 2252 int tid; 2253 2254 memset(&pe, 0, sizeof(pe)); 2255 2256 /* Scan TCAM and see if entry with this <MAC DA, port> already exist */ 2257 tid = mvpp2_prs_mac_da_range_find(priv, BIT(port->id), da, mask, 2258 MVPP2_PRS_UDF_MAC_DEF); 2259 2260 /* No such entry */ 2261 if (tid < 0) { 2262 if (!add) 2263 return 0; 2264 2265 /* Create new TCAM entry */ 2266 /* Go through the all entries from first to last */ 2267 tid = mvpp2_prs_tcam_first_free(priv, 2268 MVPP2_PE_MAC_RANGE_START, 2269 MVPP2_PE_MAC_RANGE_END); 2270 if (tid < 0) 2271 return tid; 2272 2273 pe.index = tid; 2274 2275 /* Mask all ports */ 2276 mvpp2_prs_tcam_port_map_set(&pe, 0); 2277 } else { 2278 mvpp2_prs_init_from_hw(priv, &pe, tid); 2279 } 2280 2281 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_MAC); 2282 2283 /* Update port mask */ 2284 mvpp2_prs_tcam_port_set(&pe, port->id, add); 2285 2286 /* Invalidate the entry if no ports are left enabled */ 2287 pmap = mvpp2_prs_tcam_port_map_get(&pe); 2288 if (pmap == 0) { 2289 if (add) 2290 return -EINVAL; 2291 2292 mvpp2_prs_hw_inv(priv, pe.index); 2293 priv->prs_shadow[pe.index].valid = false; 2294 return 0; 2295 } 2296 2297 /* Continue - set next lookup */ 2298 mvpp2_prs_sram_next_lu_set(&pe, MVPP2_PRS_LU_DSA); 2299 2300 /* Set match on DA */ 2301 len = ETH_ALEN; 2302 while (len--) 2303 mvpp2_prs_tcam_data_byte_set(&pe, len, da[len], 0xff); 2304 2305 /* Set result info bits */ 2306 if (is_broadcast_ether_addr(da)) { 2307 ri = MVPP2_PRS_RI_L2_BCAST; 2308 } else if (is_multicast_ether_addr(da)) { 2309 ri = MVPP2_PRS_RI_L2_MCAST; 2310 } else { 2311 ri = MVPP2_PRS_RI_L2_UCAST; 2312 2313 if (ether_addr_equal(da, port->dev->dev_addr)) 2314 ri |= MVPP2_PRS_RI_MAC_ME_MASK; 2315 } 2316 2317 mvpp2_prs_sram_ri_update(&pe, ri, MVPP2_PRS_RI_L2_CAST_MASK | 2318 MVPP2_PRS_RI_MAC_ME_MASK); 2319 mvpp2_prs_shadow_ri_set(priv, pe.index, ri, MVPP2_PRS_RI_L2_CAST_MASK | 2320 MVPP2_PRS_RI_MAC_ME_MASK); 2321 2322 /* Shift to ethertype */ 2323 mvpp2_prs_sram_shift_set(&pe, 2 * ETH_ALEN, 2324 MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); 2325 2326 /* Update shadow table and hw entry */ 2327 priv->prs_shadow[pe.index].udf = MVPP2_PRS_UDF_MAC_DEF; 2328 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_MAC); 2329 mvpp2_prs_hw_write(priv, &pe); 2330 2331 return 0; 2332 } 2333 2334 int mvpp2_prs_update_mac_da(struct net_device *dev, const u8 *da) 2335 { 2336 struct mvpp2_port *port = netdev_priv(dev); 2337 int err; 2338 2339 /* Remove old parser entry */ 2340 err = mvpp2_prs_mac_da_accept(port, dev->dev_addr, false); 2341 if (err) 2342 return err; 2343 2344 /* Add new parser entry */ 2345 err = mvpp2_prs_mac_da_accept(port, da, true); 2346 if (err) 2347 return err; 2348 2349 /* Set addr in the device */ 2350 eth_hw_addr_set(dev, da); 2351 2352 return 0; 2353 } 2354 2355 void mvpp2_prs_mac_del_all(struct mvpp2_port *port) 2356 { 2357 struct mvpp2 *priv = port->priv; 2358 struct mvpp2_prs_entry pe; 2359 unsigned long pmap; 2360 int index, tid; 2361 2362 for (tid = MVPP2_PE_MAC_RANGE_START; 2363 tid <= MVPP2_PE_MAC_RANGE_END; tid++) { 2364 unsigned char da[ETH_ALEN], da_mask[ETH_ALEN]; 2365 2366 if (!priv->prs_shadow[tid].valid || 2367 (priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC) || 2368 (priv->prs_shadow[tid].udf != MVPP2_PRS_UDF_MAC_DEF)) 2369 continue; 2370 2371 mvpp2_prs_init_from_hw(priv, &pe, tid); 2372 2373 pmap = mvpp2_prs_tcam_port_map_get(&pe); 2374 2375 /* We only want entries active on this port */ 2376 if (!test_bit(port->id, &pmap)) 2377 continue; 2378 2379 /* Read mac addr from entry */ 2380 for (index = 0; index < ETH_ALEN; index++) 2381 mvpp2_prs_tcam_data_byte_get(&pe, index, &da[index], 2382 &da_mask[index]); 2383 2384 /* Special cases : Don't remove broadcast and port's own 2385 * address 2386 */ 2387 if (is_broadcast_ether_addr(da) || 2388 ether_addr_equal(da, port->dev->dev_addr)) 2389 continue; 2390 2391 /* Remove entry from TCAM */ 2392 mvpp2_prs_mac_da_accept(port, da, false); 2393 } 2394 } 2395 2396 int mvpp2_prs_tag_mode_set(struct mvpp2 *priv, int port, int type) 2397 { 2398 switch (type) { 2399 case MVPP2_TAG_TYPE_EDSA: 2400 /* Add port to EDSA entries */ 2401 mvpp2_prs_dsa_tag_set(priv, port, true, 2402 MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); 2403 mvpp2_prs_dsa_tag_set(priv, port, true, 2404 MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); 2405 /* Remove port from DSA entries */ 2406 mvpp2_prs_dsa_tag_set(priv, port, false, 2407 MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); 2408 mvpp2_prs_dsa_tag_set(priv, port, false, 2409 MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); 2410 break; 2411 2412 case MVPP2_TAG_TYPE_DSA: 2413 /* Add port to DSA entries */ 2414 mvpp2_prs_dsa_tag_set(priv, port, true, 2415 MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); 2416 mvpp2_prs_dsa_tag_set(priv, port, true, 2417 MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); 2418 /* Remove port from EDSA entries */ 2419 mvpp2_prs_dsa_tag_set(priv, port, false, 2420 MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); 2421 mvpp2_prs_dsa_tag_set(priv, port, false, 2422 MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); 2423 break; 2424 2425 case MVPP2_TAG_TYPE_MH: 2426 case MVPP2_TAG_TYPE_NONE: 2427 /* Remove port form EDSA and DSA entries */ 2428 mvpp2_prs_dsa_tag_set(priv, port, false, 2429 MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); 2430 mvpp2_prs_dsa_tag_set(priv, port, false, 2431 MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); 2432 mvpp2_prs_dsa_tag_set(priv, port, false, 2433 MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); 2434 mvpp2_prs_dsa_tag_set(priv, port, false, 2435 MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); 2436 break; 2437 2438 default: 2439 if ((type < 0) || (type > MVPP2_TAG_TYPE_EDSA)) 2440 return -EINVAL; 2441 } 2442 2443 return 0; 2444 } 2445 2446 int mvpp2_prs_add_flow(struct mvpp2 *priv, int flow, u32 ri, u32 ri_mask) 2447 { 2448 struct mvpp2_prs_entry pe; 2449 u8 *ri_byte, *ri_byte_mask; 2450 int tid, i; 2451 2452 memset(&pe, 0, sizeof(pe)); 2453 2454 tid = mvpp2_prs_tcam_first_free(priv, 2455 MVPP2_PE_LAST_FREE_TID, 2456 MVPP2_PE_FIRST_FREE_TID); 2457 if (tid < 0) 2458 return tid; 2459 2460 pe.index = tid; 2461 2462 ri_byte = (u8 *)&ri; 2463 ri_byte_mask = (u8 *)&ri_mask; 2464 2465 mvpp2_prs_sram_ai_update(&pe, flow, MVPP2_PRS_FLOW_ID_MASK); 2466 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1); 2467 2468 for (i = 0; i < 4; i++) { 2469 mvpp2_prs_tcam_data_byte_set(&pe, i, ri_byte[i], 2470 ri_byte_mask[i]); 2471 } 2472 2473 mvpp2_prs_shadow_set(priv, pe.index, MVPP2_PRS_LU_FLOWS); 2474 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 2475 mvpp2_prs_tcam_port_map_set(&pe, MVPP2_PRS_PORT_MASK); 2476 mvpp2_prs_hw_write(priv, &pe); 2477 2478 return 0; 2479 } 2480 2481 /* Set prs flow for the port */ 2482 int mvpp2_prs_def_flow(struct mvpp2_port *port) 2483 { 2484 struct mvpp2_prs_entry pe; 2485 int tid; 2486 2487 memset(&pe, 0, sizeof(pe)); 2488 2489 tid = mvpp2_prs_flow_find(port->priv, port->id); 2490 2491 /* Such entry not exist */ 2492 if (tid < 0) { 2493 /* Go through the all entires from last to first */ 2494 tid = mvpp2_prs_tcam_first_free(port->priv, 2495 MVPP2_PE_LAST_FREE_TID, 2496 MVPP2_PE_FIRST_FREE_TID); 2497 if (tid < 0) 2498 return tid; 2499 2500 pe.index = tid; 2501 2502 /* Set flow ID*/ 2503 mvpp2_prs_sram_ai_update(&pe, port->id, MVPP2_PRS_FLOW_ID_MASK); 2504 mvpp2_prs_sram_bits_set(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1); 2505 2506 /* Update shadow table */ 2507 mvpp2_prs_shadow_set(port->priv, pe.index, MVPP2_PRS_LU_FLOWS); 2508 } else { 2509 mvpp2_prs_init_from_hw(port->priv, &pe, tid); 2510 } 2511 2512 mvpp2_prs_tcam_lu_set(&pe, MVPP2_PRS_LU_FLOWS); 2513 mvpp2_prs_tcam_port_map_set(&pe, (1 << port->id)); 2514 mvpp2_prs_hw_write(port->priv, &pe); 2515 2516 return 0; 2517 } 2518 2519 int mvpp2_prs_hits(struct mvpp2 *priv, int index) 2520 { 2521 u32 val; 2522 2523 if (index > MVPP2_PRS_TCAM_SRAM_SIZE) 2524 return -EINVAL; 2525 2526 mvpp2_write(priv, MVPP2_PRS_TCAM_HIT_IDX_REG, index); 2527 2528 val = mvpp2_read(priv, MVPP2_PRS_TCAM_HIT_CNT_REG); 2529 2530 val &= MVPP2_PRS_TCAM_HIT_CNT_MASK; 2531 2532 return val; 2533 } 2534