1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */ 3 4 #include <linux/kernel.h> 5 #include <linux/list.h> 6 #include <linux/netdevice.h> 7 8 #include "spectrum_mr_tcam.h" 9 #include "reg.h" 10 #include "spectrum.h" 11 #include "core_acl_flex_actions.h" 12 #include "spectrum_mr.h" 13 14 struct mlxsw_sp_mr_tcam { 15 void *priv; 16 }; 17 18 /* This struct maps to one RIGR2 register entry */ 19 struct mlxsw_sp_mr_erif_sublist { 20 struct list_head list; 21 u32 rigr2_kvdl_index; 22 int num_erifs; 23 u16 erif_indices[MLXSW_REG_RIGR2_MAX_ERIFS]; 24 bool synced; 25 }; 26 27 struct mlxsw_sp_mr_tcam_erif_list { 28 struct list_head erif_sublists; 29 u32 kvdl_index; 30 }; 31 32 static bool 33 mlxsw_sp_mr_erif_sublist_full(struct mlxsw_sp *mlxsw_sp, 34 struct mlxsw_sp_mr_erif_sublist *erif_sublist) 35 { 36 int erif_list_entries = MLXSW_CORE_RES_GET(mlxsw_sp->core, 37 MC_ERIF_LIST_ENTRIES); 38 39 return erif_sublist->num_erifs == erif_list_entries; 40 } 41 42 static void 43 mlxsw_sp_mr_erif_list_init(struct mlxsw_sp_mr_tcam_erif_list *erif_list) 44 { 45 INIT_LIST_HEAD(&erif_list->erif_sublists); 46 } 47 48 static struct mlxsw_sp_mr_erif_sublist * 49 mlxsw_sp_mr_erif_sublist_create(struct mlxsw_sp *mlxsw_sp, 50 struct mlxsw_sp_mr_tcam_erif_list *erif_list) 51 { 52 struct mlxsw_sp_mr_erif_sublist *erif_sublist; 53 int err; 54 55 erif_sublist = kzalloc(sizeof(*erif_sublist), GFP_KERNEL); 56 if (!erif_sublist) 57 return ERR_PTR(-ENOMEM); 58 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_MCRIGR, 59 1, &erif_sublist->rigr2_kvdl_index); 60 if (err) { 61 kfree(erif_sublist); 62 return ERR_PTR(err); 63 } 64 65 list_add_tail(&erif_sublist->list, &erif_list->erif_sublists); 66 return erif_sublist; 67 } 68 69 static void 70 mlxsw_sp_mr_erif_sublist_destroy(struct mlxsw_sp *mlxsw_sp, 71 struct mlxsw_sp_mr_erif_sublist *erif_sublist) 72 { 73 list_del(&erif_sublist->list); 74 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_MCRIGR, 75 1, erif_sublist->rigr2_kvdl_index); 76 kfree(erif_sublist); 77 } 78 79 static int 80 mlxsw_sp_mr_erif_list_add(struct mlxsw_sp *mlxsw_sp, 81 struct mlxsw_sp_mr_tcam_erif_list *erif_list, 82 u16 erif_index) 83 { 84 struct mlxsw_sp_mr_erif_sublist *sublist; 85 86 /* If either there is no erif_entry or the last one is full, allocate a 87 * new one. 88 */ 89 if (list_empty(&erif_list->erif_sublists)) { 90 sublist = mlxsw_sp_mr_erif_sublist_create(mlxsw_sp, erif_list); 91 if (IS_ERR(sublist)) 92 return PTR_ERR(sublist); 93 erif_list->kvdl_index = sublist->rigr2_kvdl_index; 94 } else { 95 sublist = list_last_entry(&erif_list->erif_sublists, 96 struct mlxsw_sp_mr_erif_sublist, 97 list); 98 sublist->synced = false; 99 if (mlxsw_sp_mr_erif_sublist_full(mlxsw_sp, sublist)) { 100 sublist = mlxsw_sp_mr_erif_sublist_create(mlxsw_sp, 101 erif_list); 102 if (IS_ERR(sublist)) 103 return PTR_ERR(sublist); 104 } 105 } 106 107 /* Add the eRIF to the last entry's last index */ 108 sublist->erif_indices[sublist->num_erifs++] = erif_index; 109 return 0; 110 } 111 112 static void 113 mlxsw_sp_mr_erif_list_flush(struct mlxsw_sp *mlxsw_sp, 114 struct mlxsw_sp_mr_tcam_erif_list *erif_list) 115 { 116 struct mlxsw_sp_mr_erif_sublist *erif_sublist, *tmp; 117 118 list_for_each_entry_safe(erif_sublist, tmp, &erif_list->erif_sublists, 119 list) 120 mlxsw_sp_mr_erif_sublist_destroy(mlxsw_sp, erif_sublist); 121 } 122 123 static int 124 mlxsw_sp_mr_erif_list_commit(struct mlxsw_sp *mlxsw_sp, 125 struct mlxsw_sp_mr_tcam_erif_list *erif_list) 126 { 127 struct mlxsw_sp_mr_erif_sublist *curr_sublist; 128 char rigr2_pl[MLXSW_REG_RIGR2_LEN]; 129 int err; 130 int i; 131 132 list_for_each_entry(curr_sublist, &erif_list->erif_sublists, list) { 133 if (curr_sublist->synced) 134 continue; 135 136 /* If the sublist is not the last one, pack the next index */ 137 if (list_is_last(&curr_sublist->list, 138 &erif_list->erif_sublists)) { 139 mlxsw_reg_rigr2_pack(rigr2_pl, 140 curr_sublist->rigr2_kvdl_index, 141 false, 0); 142 } else { 143 struct mlxsw_sp_mr_erif_sublist *next_sublist; 144 145 next_sublist = list_next_entry(curr_sublist, list); 146 mlxsw_reg_rigr2_pack(rigr2_pl, 147 curr_sublist->rigr2_kvdl_index, 148 true, 149 next_sublist->rigr2_kvdl_index); 150 } 151 152 /* Pack all the erifs */ 153 for (i = 0; i < curr_sublist->num_erifs; i++) { 154 u16 erif_index = curr_sublist->erif_indices[i]; 155 156 mlxsw_reg_rigr2_erif_entry_pack(rigr2_pl, i, true, 157 erif_index); 158 } 159 160 /* Write the entry */ 161 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rigr2), 162 rigr2_pl); 163 if (err) 164 /* No need of a rollback here because this 165 * hardware entry should not be pointed yet. 166 */ 167 return err; 168 curr_sublist->synced = true; 169 } 170 return 0; 171 } 172 173 static void mlxsw_sp_mr_erif_list_move(struct mlxsw_sp_mr_tcam_erif_list *to, 174 struct mlxsw_sp_mr_tcam_erif_list *from) 175 { 176 list_splice(&from->erif_sublists, &to->erif_sublists); 177 to->kvdl_index = from->kvdl_index; 178 } 179 180 struct mlxsw_sp_mr_tcam_route { 181 struct mlxsw_sp_mr_tcam_erif_list erif_list; 182 struct mlxsw_afa_block *afa_block; 183 u32 counter_index; 184 enum mlxsw_sp_mr_route_action action; 185 struct mlxsw_sp_mr_route_key key; 186 u16 irif_index; 187 u16 min_mtu; 188 void *priv; 189 }; 190 191 static struct mlxsw_afa_block * 192 mlxsw_sp_mr_tcam_afa_block_create(struct mlxsw_sp *mlxsw_sp, 193 enum mlxsw_sp_mr_route_action route_action, 194 u16 irif_index, u32 counter_index, 195 u16 min_mtu, 196 struct mlxsw_sp_mr_tcam_erif_list *erif_list) 197 { 198 struct mlxsw_afa_block *afa_block; 199 int err; 200 201 afa_block = mlxsw_afa_block_create(mlxsw_sp->afa); 202 if (IS_ERR(afa_block)) 203 return afa_block; 204 205 err = mlxsw_afa_block_append_allocated_counter(afa_block, 206 counter_index); 207 if (err) 208 goto err; 209 210 switch (route_action) { 211 case MLXSW_SP_MR_ROUTE_ACTION_TRAP: 212 err = mlxsw_afa_block_append_trap(afa_block, 213 MLXSW_TRAP_ID_ACL1); 214 if (err) 215 goto err; 216 break; 217 case MLXSW_SP_MR_ROUTE_ACTION_TRAP_AND_FORWARD: 218 case MLXSW_SP_MR_ROUTE_ACTION_FORWARD: 219 /* If we are about to append a multicast router action, commit 220 * the erif_list. 221 */ 222 err = mlxsw_sp_mr_erif_list_commit(mlxsw_sp, erif_list); 223 if (err) 224 goto err; 225 226 err = mlxsw_afa_block_append_mcrouter(afa_block, irif_index, 227 min_mtu, false, 228 erif_list->kvdl_index); 229 if (err) 230 goto err; 231 232 if (route_action == MLXSW_SP_MR_ROUTE_ACTION_TRAP_AND_FORWARD) { 233 err = mlxsw_afa_block_append_trap_and_forward(afa_block, 234 MLXSW_TRAP_ID_ACL2); 235 if (err) 236 goto err; 237 } 238 break; 239 default: 240 err = -EINVAL; 241 goto err; 242 } 243 244 err = mlxsw_afa_block_commit(afa_block); 245 if (err) 246 goto err; 247 return afa_block; 248 err: 249 mlxsw_afa_block_destroy(afa_block); 250 return ERR_PTR(err); 251 } 252 253 static void 254 mlxsw_sp_mr_tcam_afa_block_destroy(struct mlxsw_afa_block *afa_block) 255 { 256 mlxsw_afa_block_destroy(afa_block); 257 } 258 259 static int 260 mlxsw_sp_mr_tcam_erif_populate(struct mlxsw_sp *mlxsw_sp, 261 struct mlxsw_sp_mr_tcam_erif_list *erif_list, 262 struct mlxsw_sp_mr_route_info *route_info) 263 { 264 int err; 265 int i; 266 267 for (i = 0; i < route_info->erif_num; i++) { 268 u16 erif_index = route_info->erif_indices[i]; 269 270 err = mlxsw_sp_mr_erif_list_add(mlxsw_sp, erif_list, 271 erif_index); 272 if (err) 273 return err; 274 } 275 return 0; 276 } 277 278 static int 279 mlxsw_sp_mr_tcam_route_create(struct mlxsw_sp *mlxsw_sp, void *priv, 280 void *route_priv, 281 struct mlxsw_sp_mr_route_params *route_params) 282 { 283 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 284 struct mlxsw_sp_mr_tcam_route *route = route_priv; 285 struct mlxsw_sp_mr_tcam *mr_tcam = priv; 286 int err; 287 288 route->key = route_params->key; 289 route->irif_index = route_params->value.irif_index; 290 route->min_mtu = route_params->value.min_mtu; 291 route->action = route_params->value.route_action; 292 293 /* Create the egress RIFs list */ 294 mlxsw_sp_mr_erif_list_init(&route->erif_list); 295 err = mlxsw_sp_mr_tcam_erif_populate(mlxsw_sp, &route->erif_list, 296 &route_params->value); 297 if (err) 298 goto err_erif_populate; 299 300 /* Create the flow counter */ 301 err = mlxsw_sp_flow_counter_alloc(mlxsw_sp, &route->counter_index); 302 if (err) 303 goto err_counter_alloc; 304 305 /* Create the flexible action block */ 306 route->afa_block = mlxsw_sp_mr_tcam_afa_block_create(mlxsw_sp, 307 route->action, 308 route->irif_index, 309 route->counter_index, 310 route->min_mtu, 311 &route->erif_list); 312 if (IS_ERR(route->afa_block)) { 313 err = PTR_ERR(route->afa_block); 314 goto err_afa_block_create; 315 } 316 317 route->priv = kzalloc(ops->route_priv_size, GFP_KERNEL); 318 if (!route->priv) { 319 err = -ENOMEM; 320 goto err_route_priv_alloc; 321 } 322 323 /* Write the route to the TCAM */ 324 err = ops->route_create(mlxsw_sp, mr_tcam->priv, route->priv, 325 &route->key, route->afa_block, 326 route_params->prio); 327 if (err) 328 goto err_route_create; 329 return 0; 330 331 err_route_create: 332 kfree(route->priv); 333 err_route_priv_alloc: 334 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 335 err_afa_block_create: 336 mlxsw_sp_flow_counter_free(mlxsw_sp, route->counter_index); 337 err_erif_populate: 338 err_counter_alloc: 339 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &route->erif_list); 340 return err; 341 } 342 343 static void mlxsw_sp_mr_tcam_route_destroy(struct mlxsw_sp *mlxsw_sp, 344 void *priv, void *route_priv) 345 { 346 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 347 struct mlxsw_sp_mr_tcam_route *route = route_priv; 348 struct mlxsw_sp_mr_tcam *mr_tcam = priv; 349 350 ops->route_destroy(mlxsw_sp, mr_tcam->priv, route->priv, &route->key); 351 kfree(route->priv); 352 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 353 mlxsw_sp_flow_counter_free(mlxsw_sp, route->counter_index); 354 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &route->erif_list); 355 } 356 357 static int mlxsw_sp_mr_tcam_route_stats(struct mlxsw_sp *mlxsw_sp, 358 void *route_priv, u64 *packets, 359 u64 *bytes) 360 { 361 struct mlxsw_sp_mr_tcam_route *route = route_priv; 362 363 return mlxsw_sp_flow_counter_get(mlxsw_sp, route->counter_index, 364 packets, bytes); 365 } 366 367 static int 368 mlxsw_sp_mr_tcam_route_action_update(struct mlxsw_sp *mlxsw_sp, 369 void *route_priv, 370 enum mlxsw_sp_mr_route_action route_action) 371 { 372 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 373 struct mlxsw_sp_mr_tcam_route *route = route_priv; 374 struct mlxsw_afa_block *afa_block; 375 int err; 376 377 /* Create a new flexible action block */ 378 afa_block = mlxsw_sp_mr_tcam_afa_block_create(mlxsw_sp, route_action, 379 route->irif_index, 380 route->counter_index, 381 route->min_mtu, 382 &route->erif_list); 383 if (IS_ERR(afa_block)) 384 return PTR_ERR(afa_block); 385 386 /* Update the TCAM route entry */ 387 err = ops->route_update(mlxsw_sp, route->priv, &route->key, afa_block); 388 if (err) 389 goto err; 390 391 /* Delete the old one */ 392 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 393 route->afa_block = afa_block; 394 route->action = route_action; 395 return 0; 396 err: 397 mlxsw_sp_mr_tcam_afa_block_destroy(afa_block); 398 return err; 399 } 400 401 static int mlxsw_sp_mr_tcam_route_min_mtu_update(struct mlxsw_sp *mlxsw_sp, 402 void *route_priv, u16 min_mtu) 403 { 404 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 405 struct mlxsw_sp_mr_tcam_route *route = route_priv; 406 struct mlxsw_afa_block *afa_block; 407 int err; 408 409 /* Create a new flexible action block */ 410 afa_block = mlxsw_sp_mr_tcam_afa_block_create(mlxsw_sp, 411 route->action, 412 route->irif_index, 413 route->counter_index, 414 min_mtu, 415 &route->erif_list); 416 if (IS_ERR(afa_block)) 417 return PTR_ERR(afa_block); 418 419 /* Update the TCAM route entry */ 420 err = ops->route_update(mlxsw_sp, route->priv, &route->key, afa_block); 421 if (err) 422 goto err; 423 424 /* Delete the old one */ 425 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 426 route->afa_block = afa_block; 427 route->min_mtu = min_mtu; 428 return 0; 429 err: 430 mlxsw_sp_mr_tcam_afa_block_destroy(afa_block); 431 return err; 432 } 433 434 static int mlxsw_sp_mr_tcam_route_irif_update(struct mlxsw_sp *mlxsw_sp, 435 void *route_priv, u16 irif_index) 436 { 437 struct mlxsw_sp_mr_tcam_route *route = route_priv; 438 439 if (route->action != MLXSW_SP_MR_ROUTE_ACTION_TRAP) 440 return -EINVAL; 441 route->irif_index = irif_index; 442 return 0; 443 } 444 445 static int mlxsw_sp_mr_tcam_route_erif_add(struct mlxsw_sp *mlxsw_sp, 446 void *route_priv, u16 erif_index) 447 { 448 struct mlxsw_sp_mr_tcam_route *route = route_priv; 449 int err; 450 451 err = mlxsw_sp_mr_erif_list_add(mlxsw_sp, &route->erif_list, 452 erif_index); 453 if (err) 454 return err; 455 456 /* Commit the action only if the route action is not TRAP */ 457 if (route->action != MLXSW_SP_MR_ROUTE_ACTION_TRAP) 458 return mlxsw_sp_mr_erif_list_commit(mlxsw_sp, 459 &route->erif_list); 460 return 0; 461 } 462 463 static int mlxsw_sp_mr_tcam_route_erif_del(struct mlxsw_sp *mlxsw_sp, 464 void *route_priv, u16 erif_index) 465 { 466 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 467 struct mlxsw_sp_mr_tcam_route *route = route_priv; 468 struct mlxsw_sp_mr_erif_sublist *erif_sublist; 469 struct mlxsw_sp_mr_tcam_erif_list erif_list; 470 struct mlxsw_afa_block *afa_block; 471 int err; 472 int i; 473 474 /* Create a copy of the original erif_list without the deleted entry */ 475 mlxsw_sp_mr_erif_list_init(&erif_list); 476 list_for_each_entry(erif_sublist, &route->erif_list.erif_sublists, list) { 477 for (i = 0; i < erif_sublist->num_erifs; i++) { 478 u16 curr_erif = erif_sublist->erif_indices[i]; 479 480 if (curr_erif == erif_index) 481 continue; 482 err = mlxsw_sp_mr_erif_list_add(mlxsw_sp, &erif_list, 483 curr_erif); 484 if (err) 485 goto err_erif_list_add; 486 } 487 } 488 489 /* Create the flexible action block pointing to the new erif_list */ 490 afa_block = mlxsw_sp_mr_tcam_afa_block_create(mlxsw_sp, route->action, 491 route->irif_index, 492 route->counter_index, 493 route->min_mtu, 494 &erif_list); 495 if (IS_ERR(afa_block)) { 496 err = PTR_ERR(afa_block); 497 goto err_afa_block_create; 498 } 499 500 /* Update the TCAM route entry */ 501 err = ops->route_update(mlxsw_sp, route->priv, &route->key, afa_block); 502 if (err) 503 goto err_route_write; 504 505 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 506 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &route->erif_list); 507 route->afa_block = afa_block; 508 mlxsw_sp_mr_erif_list_move(&route->erif_list, &erif_list); 509 return 0; 510 511 err_route_write: 512 mlxsw_sp_mr_tcam_afa_block_destroy(afa_block); 513 err_afa_block_create: 514 err_erif_list_add: 515 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &erif_list); 516 return err; 517 } 518 519 static int 520 mlxsw_sp_mr_tcam_route_update(struct mlxsw_sp *mlxsw_sp, void *route_priv, 521 struct mlxsw_sp_mr_route_info *route_info) 522 { 523 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 524 struct mlxsw_sp_mr_tcam_route *route = route_priv; 525 struct mlxsw_sp_mr_tcam_erif_list erif_list; 526 struct mlxsw_afa_block *afa_block; 527 int err; 528 529 /* Create a new erif_list */ 530 mlxsw_sp_mr_erif_list_init(&erif_list); 531 err = mlxsw_sp_mr_tcam_erif_populate(mlxsw_sp, &erif_list, route_info); 532 if (err) 533 goto err_erif_populate; 534 535 /* Create the flexible action block pointing to the new erif_list */ 536 afa_block = mlxsw_sp_mr_tcam_afa_block_create(mlxsw_sp, 537 route_info->route_action, 538 route_info->irif_index, 539 route->counter_index, 540 route_info->min_mtu, 541 &erif_list); 542 if (IS_ERR(afa_block)) { 543 err = PTR_ERR(afa_block); 544 goto err_afa_block_create; 545 } 546 547 /* Update the TCAM route entry */ 548 err = ops->route_update(mlxsw_sp, route->priv, &route->key, afa_block); 549 if (err) 550 goto err_route_write; 551 552 mlxsw_sp_mr_tcam_afa_block_destroy(route->afa_block); 553 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &route->erif_list); 554 route->afa_block = afa_block; 555 mlxsw_sp_mr_erif_list_move(&route->erif_list, &erif_list); 556 route->action = route_info->route_action; 557 route->irif_index = route_info->irif_index; 558 route->min_mtu = route_info->min_mtu; 559 return 0; 560 561 err_route_write: 562 mlxsw_sp_mr_tcam_afa_block_destroy(afa_block); 563 err_afa_block_create: 564 err_erif_populate: 565 mlxsw_sp_mr_erif_list_flush(mlxsw_sp, &erif_list); 566 return err; 567 } 568 569 static int mlxsw_sp_mr_tcam_init(struct mlxsw_sp *mlxsw_sp, void *priv) 570 { 571 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 572 struct mlxsw_sp_mr_tcam *mr_tcam = priv; 573 int err; 574 575 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MC_ERIF_LIST_ENTRIES)) 576 return -EIO; 577 578 mr_tcam->priv = kzalloc(ops->priv_size, GFP_KERNEL); 579 if (!mr_tcam->priv) 580 return -ENOMEM; 581 582 err = ops->init(mlxsw_sp, mr_tcam->priv); 583 if (err) 584 goto err_init; 585 return 0; 586 587 err_init: 588 kfree(mr_tcam->priv); 589 return err; 590 } 591 592 static void mlxsw_sp_mr_tcam_fini(struct mlxsw_sp *mlxsw_sp, void *priv) 593 { 594 const struct mlxsw_sp_mr_tcam_ops *ops = mlxsw_sp->mr_tcam_ops; 595 struct mlxsw_sp_mr_tcam *mr_tcam = priv; 596 597 ops->fini(mr_tcam->priv); 598 kfree(mr_tcam->priv); 599 } 600 601 const struct mlxsw_sp_mr_ops mlxsw_sp_mr_tcam_ops = { 602 .priv_size = sizeof(struct mlxsw_sp_mr_tcam), 603 .route_priv_size = sizeof(struct mlxsw_sp_mr_tcam_route), 604 .init = mlxsw_sp_mr_tcam_init, 605 .route_create = mlxsw_sp_mr_tcam_route_create, 606 .route_update = mlxsw_sp_mr_tcam_route_update, 607 .route_stats = mlxsw_sp_mr_tcam_route_stats, 608 .route_action_update = mlxsw_sp_mr_tcam_route_action_update, 609 .route_min_mtu_update = mlxsw_sp_mr_tcam_route_min_mtu_update, 610 .route_irif_update = mlxsw_sp_mr_tcam_route_irif_update, 611 .route_erif_add = mlxsw_sp_mr_tcam_route_erif_add, 612 .route_erif_del = mlxsw_sp_mr_tcam_route_erif_del, 613 .route_destroy = mlxsw_sp_mr_tcam_route_destroy, 614 .fini = mlxsw_sp_mr_tcam_fini, 615 }; 616