1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2019 Mellanox Technologies. All rights reserved */ 3 4 #include <linux/bitops.h> 5 #include <linux/kernel.h> 6 #include <linux/netlink.h> 7 #include <net/devlink.h> 8 #include <uapi/linux/devlink.h> 9 10 #include "core.h" 11 #include "reg.h" 12 #include "spectrum.h" 13 #include "spectrum_trap.h" 14 15 struct mlxsw_sp_trap_policer_item { 16 struct devlink_trap_policer policer; 17 u16 hw_id; 18 }; 19 20 struct mlxsw_sp_trap_group_item { 21 struct devlink_trap_group group; 22 u16 hw_group_id; 23 u8 priority; 24 u8 fixed_policer:1; /* Whether policer binding can change */ 25 }; 26 27 #define MLXSW_SP_TRAP_LISTENERS_MAX 3 28 29 struct mlxsw_sp_trap_item { 30 struct devlink_trap trap; 31 struct mlxsw_listener listeners_arr[MLXSW_SP_TRAP_LISTENERS_MAX]; 32 u8 is_source:1; 33 }; 34 35 /* All driver-specific traps must be documented in 36 * Documentation/networking/devlink/mlxsw.rst 37 */ 38 enum { 39 DEVLINK_MLXSW_TRAP_ID_BASE = DEVLINK_TRAP_GENERIC_ID_MAX, 40 DEVLINK_MLXSW_TRAP_ID_IRIF_DISABLED, 41 DEVLINK_MLXSW_TRAP_ID_ERIF_DISABLED, 42 }; 43 44 #define DEVLINK_MLXSW_TRAP_NAME_IRIF_DISABLED \ 45 "irif_disabled" 46 #define DEVLINK_MLXSW_TRAP_NAME_ERIF_DISABLED \ 47 "erif_disabled" 48 49 #define MLXSW_SP_TRAP_METADATA DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT 50 51 enum { 52 /* Packet was mirrored from ingress. */ 53 MLXSW_SP_MIRROR_REASON_INGRESS = 1, 54 /* Packet was mirrored from policy engine. */ 55 MLXSW_SP_MIRROR_REASON_POLICY_ENGINE = 2, 56 /* Packet was early dropped. */ 57 MLXSW_SP_MIRROR_REASON_INGRESS_WRED = 9, 58 /* Packet was mirrored from egress. */ 59 MLXSW_SP_MIRROR_REASON_EGRESS = 14, 60 }; 61 62 static int mlxsw_sp_rx_listener(struct mlxsw_sp *mlxsw_sp, struct sk_buff *skb, 63 u16 local_port, 64 struct mlxsw_sp_port *mlxsw_sp_port) 65 { 66 struct mlxsw_sp_port_pcpu_stats *pcpu_stats; 67 68 if (unlikely(!mlxsw_sp_port)) { 69 dev_warn_ratelimited(mlxsw_sp->bus_info->dev, "Port %d: skb received for non-existent port\n", 70 local_port); 71 kfree_skb(skb); 72 return -EINVAL; 73 } 74 75 skb->dev = mlxsw_sp_port->dev; 76 77 pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats); 78 u64_stats_update_begin(&pcpu_stats->syncp); 79 pcpu_stats->rx_packets++; 80 pcpu_stats->rx_bytes += skb->len; 81 u64_stats_update_end(&pcpu_stats->syncp); 82 83 skb->protocol = eth_type_trans(skb, skb->dev); 84 85 return 0; 86 } 87 88 static void mlxsw_sp_rx_drop_listener(struct sk_buff *skb, u16 local_port, 89 void *trap_ctx) 90 { 91 struct devlink_port *in_devlink_port; 92 struct mlxsw_sp_port *mlxsw_sp_port; 93 struct mlxsw_sp *mlxsw_sp; 94 struct devlink *devlink; 95 int err; 96 97 mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 98 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 99 100 err = mlxsw_sp_rx_listener(mlxsw_sp, skb, local_port, mlxsw_sp_port); 101 if (err) 102 return; 103 104 devlink = priv_to_devlink(mlxsw_sp->core); 105 in_devlink_port = mlxsw_core_port_devlink_port_get(mlxsw_sp->core, 106 local_port); 107 skb_push(skb, ETH_HLEN); 108 devlink_trap_report(devlink, skb, trap_ctx, in_devlink_port, NULL); 109 consume_skb(skb); 110 } 111 112 static void mlxsw_sp_rx_acl_drop_listener(struct sk_buff *skb, u16 local_port, 113 void *trap_ctx) 114 { 115 u32 cookie_index = mlxsw_skb_cb(skb)->rx_md_info.cookie_index; 116 const struct flow_action_cookie *fa_cookie; 117 struct devlink_port *in_devlink_port; 118 struct mlxsw_sp_port *mlxsw_sp_port; 119 struct mlxsw_sp *mlxsw_sp; 120 struct devlink *devlink; 121 int err; 122 123 mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 124 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 125 126 err = mlxsw_sp_rx_listener(mlxsw_sp, skb, local_port, mlxsw_sp_port); 127 if (err) 128 return; 129 130 devlink = priv_to_devlink(mlxsw_sp->core); 131 in_devlink_port = mlxsw_core_port_devlink_port_get(mlxsw_sp->core, 132 local_port); 133 skb_push(skb, ETH_HLEN); 134 rcu_read_lock(); 135 fa_cookie = mlxsw_sp_acl_act_cookie_lookup(mlxsw_sp, cookie_index); 136 devlink_trap_report(devlink, skb, trap_ctx, in_devlink_port, fa_cookie); 137 rcu_read_unlock(); 138 consume_skb(skb); 139 } 140 141 static int __mlxsw_sp_rx_no_mark_listener(struct sk_buff *skb, u16 local_port, 142 void *trap_ctx) 143 { 144 struct devlink_port *in_devlink_port; 145 struct mlxsw_sp_port *mlxsw_sp_port; 146 struct mlxsw_sp *mlxsw_sp; 147 struct devlink *devlink; 148 int err; 149 150 mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 151 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 152 153 err = mlxsw_sp_rx_listener(mlxsw_sp, skb, local_port, mlxsw_sp_port); 154 if (err) 155 return err; 156 157 devlink = priv_to_devlink(mlxsw_sp->core); 158 in_devlink_port = mlxsw_core_port_devlink_port_get(mlxsw_sp->core, 159 local_port); 160 skb_push(skb, ETH_HLEN); 161 devlink_trap_report(devlink, skb, trap_ctx, in_devlink_port, NULL); 162 skb_pull(skb, ETH_HLEN); 163 164 return 0; 165 } 166 167 static void mlxsw_sp_rx_no_mark_listener(struct sk_buff *skb, u16 local_port, 168 void *trap_ctx) 169 { 170 int err; 171 172 err = __mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 173 if (err) 174 return; 175 176 netif_receive_skb(skb); 177 } 178 179 static void mlxsw_sp_rx_mark_listener(struct sk_buff *skb, u16 local_port, 180 void *trap_ctx) 181 { 182 skb->offload_fwd_mark = 1; 183 mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 184 } 185 186 static void mlxsw_sp_rx_l3_mark_listener(struct sk_buff *skb, u16 local_port, 187 void *trap_ctx) 188 { 189 skb->offload_l3_fwd_mark = 1; 190 skb->offload_fwd_mark = 1; 191 mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 192 } 193 194 static void mlxsw_sp_rx_ptp_listener(struct sk_buff *skb, u16 local_port, 195 void *trap_ctx) 196 { 197 struct mlxsw_sp *mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 198 int err; 199 200 err = __mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 201 if (err) 202 return; 203 204 /* The PTP handler expects skb->data to point to the start of the 205 * Ethernet header. 206 */ 207 skb_push(skb, ETH_HLEN); 208 mlxsw_sp_ptp_receive(mlxsw_sp, skb, local_port); 209 } 210 211 static struct mlxsw_sp_port * 212 mlxsw_sp_sample_tx_port_get(struct mlxsw_sp *mlxsw_sp, 213 const struct mlxsw_rx_md_info *rx_md_info) 214 { 215 u16 local_port; 216 217 if (!rx_md_info->tx_port_valid) 218 return NULL; 219 220 if (rx_md_info->tx_port_is_lag) 221 local_port = mlxsw_core_lag_mapping_get(mlxsw_sp->core, 222 rx_md_info->tx_lag_id, 223 rx_md_info->tx_lag_port_index); 224 else 225 local_port = rx_md_info->tx_sys_port; 226 227 if (local_port >= mlxsw_core_max_ports(mlxsw_sp->core)) 228 return NULL; 229 230 return mlxsw_sp->ports[local_port]; 231 } 232 233 /* The latency units are determined according to MOGCR.mirror_latency_units. It 234 * defaults to 64 nanoseconds. 235 */ 236 #define MLXSW_SP_MIRROR_LATENCY_SHIFT 6 237 238 static void mlxsw_sp_psample_md_init(struct mlxsw_sp *mlxsw_sp, 239 struct psample_metadata *md, 240 struct sk_buff *skb, int in_ifindex, 241 bool truncate, u32 trunc_size) 242 { 243 struct mlxsw_rx_md_info *rx_md_info = &mlxsw_skb_cb(skb)->rx_md_info; 244 struct mlxsw_sp_port *mlxsw_sp_port; 245 246 md->trunc_size = truncate ? trunc_size : skb->len; 247 md->in_ifindex = in_ifindex; 248 mlxsw_sp_port = mlxsw_sp_sample_tx_port_get(mlxsw_sp, rx_md_info); 249 md->out_ifindex = mlxsw_sp_port && mlxsw_sp_port->dev ? 250 mlxsw_sp_port->dev->ifindex : 0; 251 md->out_tc_valid = rx_md_info->tx_tc_valid; 252 md->out_tc = rx_md_info->tx_tc; 253 md->out_tc_occ_valid = rx_md_info->tx_congestion_valid; 254 md->out_tc_occ = rx_md_info->tx_congestion; 255 md->latency_valid = rx_md_info->latency_valid; 256 md->latency = rx_md_info->latency; 257 md->latency <<= MLXSW_SP_MIRROR_LATENCY_SHIFT; 258 } 259 260 static void mlxsw_sp_rx_sample_listener(struct sk_buff *skb, u16 local_port, 261 void *trap_ctx) 262 { 263 struct mlxsw_sp *mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 264 struct mlxsw_sp_sample_trigger trigger; 265 struct mlxsw_sp_sample_params *params; 266 struct mlxsw_sp_port *mlxsw_sp_port; 267 struct psample_metadata md = {}; 268 int err; 269 270 err = __mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 271 if (err) 272 return; 273 274 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 275 if (!mlxsw_sp_port) 276 goto out; 277 278 trigger.type = MLXSW_SP_SAMPLE_TRIGGER_TYPE_INGRESS; 279 trigger.local_port = local_port; 280 params = mlxsw_sp_sample_trigger_params_lookup(mlxsw_sp, &trigger); 281 if (!params) 282 goto out; 283 284 /* The psample module expects skb->data to point to the start of the 285 * Ethernet header. 286 */ 287 skb_push(skb, ETH_HLEN); 288 mlxsw_sp_psample_md_init(mlxsw_sp, &md, skb, 289 mlxsw_sp_port->dev->ifindex, params->truncate, 290 params->trunc_size); 291 psample_sample_packet(params->psample_group, skb, params->rate, &md); 292 out: 293 consume_skb(skb); 294 } 295 296 static void mlxsw_sp_rx_sample_tx_listener(struct sk_buff *skb, u16 local_port, 297 void *trap_ctx) 298 { 299 struct mlxsw_rx_md_info *rx_md_info = &mlxsw_skb_cb(skb)->rx_md_info; 300 struct mlxsw_sp *mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 301 struct mlxsw_sp_port *mlxsw_sp_port, *mlxsw_sp_port_tx; 302 struct mlxsw_sp_sample_trigger trigger; 303 struct mlxsw_sp_sample_params *params; 304 struct psample_metadata md = {}; 305 int err; 306 307 /* Locally generated packets are not reported from the policy engine 308 * trigger, so do not report them from the egress trigger as well. 309 */ 310 if (local_port == MLXSW_PORT_CPU_PORT) 311 goto out; 312 313 err = __mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 314 if (err) 315 return; 316 317 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 318 if (!mlxsw_sp_port) 319 goto out; 320 321 /* Packet was sampled from Tx, so we need to retrieve the sample 322 * parameters based on the Tx port and not the Rx port. 323 */ 324 mlxsw_sp_port_tx = mlxsw_sp_sample_tx_port_get(mlxsw_sp, rx_md_info); 325 if (!mlxsw_sp_port_tx) 326 goto out; 327 328 trigger.type = MLXSW_SP_SAMPLE_TRIGGER_TYPE_EGRESS; 329 trigger.local_port = mlxsw_sp_port_tx->local_port; 330 params = mlxsw_sp_sample_trigger_params_lookup(mlxsw_sp, &trigger); 331 if (!params) 332 goto out; 333 334 /* The psample module expects skb->data to point to the start of the 335 * Ethernet header. 336 */ 337 skb_push(skb, ETH_HLEN); 338 mlxsw_sp_psample_md_init(mlxsw_sp, &md, skb, 339 mlxsw_sp_port->dev->ifindex, params->truncate, 340 params->trunc_size); 341 psample_sample_packet(params->psample_group, skb, params->rate, &md); 342 out: 343 consume_skb(skb); 344 } 345 346 static void mlxsw_sp_rx_sample_acl_listener(struct sk_buff *skb, u16 local_port, 347 void *trap_ctx) 348 { 349 struct mlxsw_sp *mlxsw_sp = devlink_trap_ctx_priv(trap_ctx); 350 struct mlxsw_sp_sample_trigger trigger = { 351 .type = MLXSW_SP_SAMPLE_TRIGGER_TYPE_POLICY_ENGINE, 352 }; 353 struct mlxsw_sp_sample_params *params; 354 struct mlxsw_sp_port *mlxsw_sp_port; 355 struct psample_metadata md = {}; 356 int err; 357 358 err = __mlxsw_sp_rx_no_mark_listener(skb, local_port, trap_ctx); 359 if (err) 360 return; 361 362 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 363 if (!mlxsw_sp_port) 364 goto out; 365 366 params = mlxsw_sp_sample_trigger_params_lookup(mlxsw_sp, &trigger); 367 if (!params) 368 goto out; 369 370 /* The psample module expects skb->data to point to the start of the 371 * Ethernet header. 372 */ 373 skb_push(skb, ETH_HLEN); 374 mlxsw_sp_psample_md_init(mlxsw_sp, &md, skb, 375 mlxsw_sp_port->dev->ifindex, params->truncate, 376 params->trunc_size); 377 psample_sample_packet(params->psample_group, skb, params->rate, &md); 378 out: 379 consume_skb(skb); 380 } 381 382 #define MLXSW_SP_TRAP_DROP(_id, _group_id) \ 383 DEVLINK_TRAP_GENERIC(DROP, DROP, _id, \ 384 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 385 MLXSW_SP_TRAP_METADATA) 386 387 #define MLXSW_SP_TRAP_DROP_EXT(_id, _group_id, _metadata) \ 388 DEVLINK_TRAP_GENERIC(DROP, DROP, _id, \ 389 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 390 MLXSW_SP_TRAP_METADATA | (_metadata)) 391 392 #define MLXSW_SP_TRAP_BUFFER_DROP(_id) \ 393 DEVLINK_TRAP_GENERIC(DROP, TRAP, _id, \ 394 DEVLINK_TRAP_GROUP_GENERIC_ID_BUFFER_DROPS, \ 395 MLXSW_SP_TRAP_METADATA) 396 397 #define MLXSW_SP_TRAP_DRIVER_DROP(_id, _group_id) \ 398 DEVLINK_TRAP_DRIVER(DROP, DROP, DEVLINK_MLXSW_TRAP_ID_##_id, \ 399 DEVLINK_MLXSW_TRAP_NAME_##_id, \ 400 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 401 MLXSW_SP_TRAP_METADATA) 402 403 #define MLXSW_SP_TRAP_EXCEPTION(_id, _group_id) \ 404 DEVLINK_TRAP_GENERIC(EXCEPTION, TRAP, _id, \ 405 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 406 MLXSW_SP_TRAP_METADATA) 407 408 #define MLXSW_SP_TRAP_CONTROL(_id, _group_id, _action) \ 409 DEVLINK_TRAP_GENERIC(CONTROL, _action, _id, \ 410 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \ 411 MLXSW_SP_TRAP_METADATA) 412 413 #define MLXSW_SP_RXL_DISCARD(_id, _group_id) \ 414 MLXSW_RXL_DIS(mlxsw_sp_rx_drop_listener, DISCARD_##_id, \ 415 TRAP_EXCEPTION_TO_CPU, false, SP_##_group_id, \ 416 SET_FW_DEFAULT, SP_##_group_id) 417 418 #define MLXSW_SP_RXL_ACL_DISCARD(_id, _en_group_id, _dis_group_id) \ 419 MLXSW_RXL_DIS(mlxsw_sp_rx_acl_drop_listener, DISCARD_##_id, \ 420 TRAP_EXCEPTION_TO_CPU, false, SP_##_en_group_id, \ 421 SET_FW_DEFAULT, SP_##_dis_group_id) 422 423 #define MLXSW_SP_RXL_BUFFER_DISCARD(_mirror_reason) \ 424 MLXSW_RXL_MIRROR(mlxsw_sp_rx_drop_listener, 0, SP_BUFFER_DISCARDS, \ 425 MLXSW_SP_MIRROR_REASON_##_mirror_reason) 426 427 #define MLXSW_SP_RXL_EXCEPTION(_id, _group_id, _action) \ 428 MLXSW_RXL(mlxsw_sp_rx_mark_listener, _id, \ 429 _action, false, SP_##_group_id, SET_FW_DEFAULT) 430 431 #define MLXSW_SP_RXL_NO_MARK(_id, _group_id, _action, _is_ctrl) \ 432 MLXSW_RXL(mlxsw_sp_rx_no_mark_listener, _id, _action, \ 433 _is_ctrl, SP_##_group_id, DISCARD) 434 435 #define MLXSW_SP_RXL_MARK(_id, _group_id, _action, _is_ctrl) \ 436 MLXSW_RXL(mlxsw_sp_rx_mark_listener, _id, _action, _is_ctrl, \ 437 SP_##_group_id, DISCARD) 438 439 #define MLXSW_SP_RXL_L3_MARK(_id, _group_id, _action, _is_ctrl) \ 440 MLXSW_RXL(mlxsw_sp_rx_l3_mark_listener, _id, _action, _is_ctrl, \ 441 SP_##_group_id, DISCARD) 442 443 #define MLXSW_SP_TRAP_POLICER(_id, _rate, _burst) \ 444 DEVLINK_TRAP_POLICER(_id, _rate, _burst, \ 445 MLXSW_REG_QPCR_HIGHEST_CIR, \ 446 MLXSW_REG_QPCR_LOWEST_CIR, \ 447 1 << MLXSW_REG_QPCR_HIGHEST_CBS, \ 448 1 << MLXSW_REG_QPCR_LOWEST_CBS) 449 450 /* Ordered by policer identifier */ 451 static const struct mlxsw_sp_trap_policer_item 452 mlxsw_sp_trap_policer_items_arr[] = { 453 { 454 .policer = MLXSW_SP_TRAP_POLICER(1, 10 * 1024, 4096), 455 }, 456 { 457 .policer = MLXSW_SP_TRAP_POLICER(2, 128, 128), 458 }, 459 { 460 .policer = MLXSW_SP_TRAP_POLICER(3, 128, 128), 461 }, 462 { 463 .policer = MLXSW_SP_TRAP_POLICER(4, 128, 128), 464 }, 465 { 466 .policer = MLXSW_SP_TRAP_POLICER(5, 16 * 1024, 8192), 467 }, 468 { 469 .policer = MLXSW_SP_TRAP_POLICER(6, 128, 128), 470 }, 471 { 472 .policer = MLXSW_SP_TRAP_POLICER(7, 1024, 512), 473 }, 474 { 475 .policer = MLXSW_SP_TRAP_POLICER(8, 20 * 1024, 8192), 476 }, 477 { 478 .policer = MLXSW_SP_TRAP_POLICER(9, 128, 128), 479 }, 480 { 481 .policer = MLXSW_SP_TRAP_POLICER(10, 1024, 512), 482 }, 483 { 484 .policer = MLXSW_SP_TRAP_POLICER(11, 256, 128), 485 }, 486 { 487 .policer = MLXSW_SP_TRAP_POLICER(12, 128, 128), 488 }, 489 { 490 .policer = MLXSW_SP_TRAP_POLICER(13, 128, 128), 491 }, 492 { 493 .policer = MLXSW_SP_TRAP_POLICER(14, 1024, 512), 494 }, 495 { 496 .policer = MLXSW_SP_TRAP_POLICER(15, 1024, 512), 497 }, 498 { 499 .policer = MLXSW_SP_TRAP_POLICER(16, 24 * 1024, 16384), 500 }, 501 { 502 .policer = MLXSW_SP_TRAP_POLICER(17, 19 * 1024, 8192), 503 }, 504 { 505 .policer = MLXSW_SP_TRAP_POLICER(18, 1024, 512), 506 }, 507 { 508 .policer = MLXSW_SP_TRAP_POLICER(19, 1024, 512), 509 }, 510 { 511 .policer = MLXSW_SP_TRAP_POLICER(20, 10240, 4096), 512 }, 513 }; 514 515 static const struct mlxsw_sp_trap_group_item mlxsw_sp_trap_group_items_arr[] = { 516 { 517 .group = DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 1), 518 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_L2_DISCARDS, 519 .priority = 0, 520 }, 521 { 522 .group = DEVLINK_TRAP_GROUP_GENERIC(L3_DROPS, 1), 523 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_L3_DISCARDS, 524 .priority = 0, 525 }, 526 { 527 .group = DEVLINK_TRAP_GROUP_GENERIC(L3_EXCEPTIONS, 1), 528 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_L3_EXCEPTIONS, 529 .priority = 2, 530 }, 531 { 532 .group = DEVLINK_TRAP_GROUP_GENERIC(TUNNEL_DROPS, 1), 533 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_TUNNEL_DISCARDS, 534 .priority = 0, 535 }, 536 { 537 .group = DEVLINK_TRAP_GROUP_GENERIC(ACL_DROPS, 1), 538 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_ACL_DISCARDS, 539 .priority = 0, 540 }, 541 { 542 .group = DEVLINK_TRAP_GROUP_GENERIC(STP, 2), 543 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_STP, 544 .priority = 5, 545 }, 546 { 547 .group = DEVLINK_TRAP_GROUP_GENERIC(LACP, 3), 548 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_LACP, 549 .priority = 5, 550 }, 551 { 552 .group = DEVLINK_TRAP_GROUP_GENERIC(LLDP, 4), 553 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_LLDP, 554 .priority = 5, 555 }, 556 { 557 .group = DEVLINK_TRAP_GROUP_GENERIC(MC_SNOOPING, 5), 558 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_MC_SNOOPING, 559 .priority = 3, 560 }, 561 { 562 .group = DEVLINK_TRAP_GROUP_GENERIC(DHCP, 6), 563 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_DHCP, 564 .priority = 2, 565 }, 566 { 567 .group = DEVLINK_TRAP_GROUP_GENERIC(NEIGH_DISCOVERY, 7), 568 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_NEIGH_DISCOVERY, 569 .priority = 2, 570 }, 571 { 572 .group = DEVLINK_TRAP_GROUP_GENERIC(BFD, 8), 573 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_BFD, 574 .priority = 5, 575 }, 576 { 577 .group = DEVLINK_TRAP_GROUP_GENERIC(OSPF, 9), 578 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_OSPF, 579 .priority = 5, 580 }, 581 { 582 .group = DEVLINK_TRAP_GROUP_GENERIC(BGP, 10), 583 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_BGP, 584 .priority = 4, 585 }, 586 { 587 .group = DEVLINK_TRAP_GROUP_GENERIC(VRRP, 11), 588 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_VRRP, 589 .priority = 5, 590 }, 591 { 592 .group = DEVLINK_TRAP_GROUP_GENERIC(PIM, 12), 593 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_PIM, 594 .priority = 5, 595 }, 596 { 597 .group = DEVLINK_TRAP_GROUP_GENERIC(UC_LB, 13), 598 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_LBERROR, 599 .priority = 0, 600 }, 601 { 602 .group = DEVLINK_TRAP_GROUP_GENERIC(LOCAL_DELIVERY, 14), 603 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_IP2ME, 604 .priority = 2, 605 }, 606 { 607 .group = DEVLINK_TRAP_GROUP_GENERIC(EXTERNAL_DELIVERY, 19), 608 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_EXTERNAL_ROUTE, 609 .priority = 1, 610 }, 611 { 612 .group = DEVLINK_TRAP_GROUP_GENERIC(IPV6, 15), 613 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_IPV6, 614 .priority = 2, 615 }, 616 { 617 .group = DEVLINK_TRAP_GROUP_GENERIC(PTP_EVENT, 16), 618 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP0, 619 .priority = 5, 620 }, 621 { 622 .group = DEVLINK_TRAP_GROUP_GENERIC(PTP_GENERAL, 17), 623 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_PTP1, 624 .priority = 2, 625 }, 626 { 627 .group = DEVLINK_TRAP_GROUP_GENERIC(ACL_TRAP, 18), 628 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_FLOW_LOGGING, 629 .priority = 4, 630 }, 631 }; 632 633 static const struct mlxsw_sp_trap_item mlxsw_sp_trap_items_arr[] = { 634 { 635 .trap = MLXSW_SP_TRAP_DROP(SMAC_MC, L2_DROPS), 636 .listeners_arr = { 637 MLXSW_SP_RXL_DISCARD(ING_PACKET_SMAC_MC, L2_DISCARDS), 638 }, 639 }, 640 { 641 .trap = MLXSW_SP_TRAP_DROP(VLAN_TAG_MISMATCH, L2_DROPS), 642 .listeners_arr = { 643 MLXSW_SP_RXL_DISCARD(ING_SWITCH_VTAG_ALLOW, 644 L2_DISCARDS), 645 }, 646 }, 647 { 648 .trap = MLXSW_SP_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS), 649 .listeners_arr = { 650 MLXSW_SP_RXL_DISCARD(ING_SWITCH_VLAN, L2_DISCARDS), 651 }, 652 }, 653 { 654 .trap = MLXSW_SP_TRAP_DROP(INGRESS_STP_FILTER, L2_DROPS), 655 .listeners_arr = { 656 MLXSW_SP_RXL_DISCARD(ING_SWITCH_STP, L2_DISCARDS), 657 }, 658 }, 659 { 660 .trap = MLXSW_SP_TRAP_DROP(EMPTY_TX_LIST, L2_DROPS), 661 .listeners_arr = { 662 MLXSW_SP_RXL_DISCARD(LOOKUP_SWITCH_UC, L2_DISCARDS), 663 MLXSW_SP_RXL_DISCARD(LOOKUP_SWITCH_MC_NULL, L2_DISCARDS), 664 }, 665 }, 666 { 667 .trap = MLXSW_SP_TRAP_DROP(PORT_LOOPBACK_FILTER, L2_DROPS), 668 .listeners_arr = { 669 MLXSW_SP_RXL_DISCARD(LOOKUP_SWITCH_LB, L2_DISCARDS), 670 }, 671 }, 672 { 673 .trap = MLXSW_SP_TRAP_DROP(BLACKHOLE_ROUTE, L3_DROPS), 674 .listeners_arr = { 675 MLXSW_SP_RXL_DISCARD(ROUTER2, L3_DISCARDS), 676 }, 677 }, 678 { 679 .trap = MLXSW_SP_TRAP_DROP(NON_IP_PACKET, L3_DROPS), 680 .listeners_arr = { 681 MLXSW_SP_RXL_DISCARD(ING_ROUTER_NON_IP_PACKET, 682 L3_DISCARDS), 683 }, 684 }, 685 { 686 .trap = MLXSW_SP_TRAP_DROP(UC_DIP_MC_DMAC, L3_DROPS), 687 .listeners_arr = { 688 MLXSW_SP_RXL_DISCARD(ING_ROUTER_UC_DIP_MC_DMAC, 689 L3_DISCARDS), 690 }, 691 }, 692 { 693 .trap = MLXSW_SP_TRAP_DROP(DIP_LB, L3_DROPS), 694 .listeners_arr = { 695 MLXSW_SP_RXL_DISCARD(ING_ROUTER_DIP_LB, L3_DISCARDS), 696 }, 697 }, 698 { 699 .trap = MLXSW_SP_TRAP_DROP(SIP_MC, L3_DROPS), 700 .listeners_arr = { 701 MLXSW_SP_RXL_DISCARD(ING_ROUTER_SIP_MC, L3_DISCARDS), 702 }, 703 }, 704 { 705 .trap = MLXSW_SP_TRAP_DROP(SIP_LB, L3_DROPS), 706 .listeners_arr = { 707 MLXSW_SP_RXL_DISCARD(ING_ROUTER_SIP_LB, L3_DISCARDS), 708 }, 709 }, 710 { 711 .trap = MLXSW_SP_TRAP_DROP(CORRUPTED_IP_HDR, L3_DROPS), 712 .listeners_arr = { 713 MLXSW_SP_RXL_DISCARD(ING_ROUTER_CORRUPTED_IP_HDR, 714 L3_DISCARDS), 715 }, 716 }, 717 { 718 .trap = MLXSW_SP_TRAP_DROP(IPV4_SIP_BC, L3_DROPS), 719 .listeners_arr = { 720 MLXSW_SP_RXL_DISCARD(ING_ROUTER_IPV4_SIP_BC, 721 L3_DISCARDS), 722 }, 723 }, 724 { 725 .trap = MLXSW_SP_TRAP_DROP(IPV6_MC_DIP_RESERVED_SCOPE, 726 L3_DROPS), 727 .listeners_arr = { 728 MLXSW_SP_RXL_DISCARD(IPV6_MC_DIP_RESERVED_SCOPE, 729 L3_DISCARDS), 730 }, 731 }, 732 { 733 .trap = MLXSW_SP_TRAP_DROP(IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE, 734 L3_DROPS), 735 .listeners_arr = { 736 MLXSW_SP_RXL_DISCARD(IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE, 737 L3_DISCARDS), 738 }, 739 }, 740 { 741 .trap = MLXSW_SP_TRAP_EXCEPTION(MTU_ERROR, L3_EXCEPTIONS), 742 .listeners_arr = { 743 MLXSW_SP_RXL_EXCEPTION(MTUERROR, L3_EXCEPTIONS, 744 TRAP_TO_CPU), 745 }, 746 }, 747 { 748 .trap = MLXSW_SP_TRAP_EXCEPTION(TTL_ERROR, L3_EXCEPTIONS), 749 .listeners_arr = { 750 MLXSW_SP_RXL_EXCEPTION(TTLERROR, L3_EXCEPTIONS, 751 TRAP_TO_CPU), 752 }, 753 }, 754 { 755 .trap = MLXSW_SP_TRAP_EXCEPTION(RPF, L3_EXCEPTIONS), 756 .listeners_arr = { 757 MLXSW_SP_RXL_EXCEPTION(RPF, L3_EXCEPTIONS, TRAP_TO_CPU), 758 }, 759 }, 760 { 761 .trap = MLXSW_SP_TRAP_EXCEPTION(REJECT_ROUTE, L3_EXCEPTIONS), 762 .listeners_arr = { 763 MLXSW_SP_RXL_EXCEPTION(RTR_INGRESS1, L3_EXCEPTIONS, 764 TRAP_TO_CPU), 765 }, 766 }, 767 { 768 .trap = MLXSW_SP_TRAP_EXCEPTION(UNRESOLVED_NEIGH, 769 L3_EXCEPTIONS), 770 .listeners_arr = { 771 MLXSW_SP_RXL_EXCEPTION(HOST_MISS_IPV4, L3_EXCEPTIONS, 772 TRAP_TO_CPU), 773 MLXSW_SP_RXL_EXCEPTION(HOST_MISS_IPV6, L3_EXCEPTIONS, 774 TRAP_TO_CPU), 775 MLXSW_SP_RXL_EXCEPTION(RTR_EGRESS0, L3_EXCEPTIONS, 776 TRAP_EXCEPTION_TO_CPU), 777 }, 778 }, 779 { 780 .trap = MLXSW_SP_TRAP_EXCEPTION(IPV4_LPM_UNICAST_MISS, 781 L3_EXCEPTIONS), 782 .listeners_arr = { 783 MLXSW_SP_RXL_EXCEPTION(DISCARD_ROUTER_LPM4, 784 L3_EXCEPTIONS, 785 TRAP_EXCEPTION_TO_CPU), 786 }, 787 }, 788 { 789 .trap = MLXSW_SP_TRAP_EXCEPTION(IPV6_LPM_UNICAST_MISS, 790 L3_EXCEPTIONS), 791 .listeners_arr = { 792 MLXSW_SP_RXL_EXCEPTION(DISCARD_ROUTER_LPM6, 793 L3_EXCEPTIONS, 794 TRAP_EXCEPTION_TO_CPU), 795 }, 796 }, 797 { 798 .trap = MLXSW_SP_TRAP_DRIVER_DROP(IRIF_DISABLED, L3_DROPS), 799 .listeners_arr = { 800 MLXSW_SP_RXL_DISCARD(ROUTER_IRIF_EN, L3_DISCARDS), 801 }, 802 }, 803 { 804 .trap = MLXSW_SP_TRAP_DRIVER_DROP(ERIF_DISABLED, L3_DROPS), 805 .listeners_arr = { 806 MLXSW_SP_RXL_DISCARD(ROUTER_ERIF_EN, L3_DISCARDS), 807 }, 808 }, 809 { 810 .trap = MLXSW_SP_TRAP_DROP(NON_ROUTABLE, L3_DROPS), 811 .listeners_arr = { 812 MLXSW_SP_RXL_DISCARD(NON_ROUTABLE, L3_DISCARDS), 813 }, 814 }, 815 { 816 .trap = MLXSW_SP_TRAP_EXCEPTION(DECAP_ERROR, TUNNEL_DROPS), 817 .listeners_arr = { 818 MLXSW_SP_RXL_EXCEPTION(DECAP_ECN0, TUNNEL_DISCARDS, 819 TRAP_EXCEPTION_TO_CPU), 820 MLXSW_SP_RXL_EXCEPTION(IPIP_DECAP_ERROR, 821 TUNNEL_DISCARDS, 822 TRAP_EXCEPTION_TO_CPU), 823 MLXSW_SP_RXL_EXCEPTION(DISCARD_DEC_PKT, TUNNEL_DISCARDS, 824 TRAP_EXCEPTION_TO_CPU), 825 }, 826 }, 827 { 828 .trap = MLXSW_SP_TRAP_DROP(OVERLAY_SMAC_MC, TUNNEL_DROPS), 829 .listeners_arr = { 830 MLXSW_SP_RXL_DISCARD(OVERLAY_SMAC_MC, TUNNEL_DISCARDS), 831 }, 832 }, 833 { 834 .trap = MLXSW_SP_TRAP_DROP_EXT(INGRESS_FLOW_ACTION_DROP, 835 ACL_DROPS, 836 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE), 837 .listeners_arr = { 838 MLXSW_SP_RXL_ACL_DISCARD(INGRESS_ACL, ACL_DISCARDS, 839 DUMMY), 840 }, 841 }, 842 { 843 .trap = MLXSW_SP_TRAP_DROP_EXT(EGRESS_FLOW_ACTION_DROP, 844 ACL_DROPS, 845 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE), 846 .listeners_arr = { 847 MLXSW_SP_RXL_ACL_DISCARD(EGRESS_ACL, ACL_DISCARDS, 848 DUMMY), 849 }, 850 }, 851 { 852 .trap = MLXSW_SP_TRAP_CONTROL(STP, STP, TRAP), 853 .listeners_arr = { 854 MLXSW_SP_RXL_NO_MARK(STP, STP, TRAP_TO_CPU, true), 855 }, 856 }, 857 { 858 .trap = MLXSW_SP_TRAP_CONTROL(LACP, LACP, TRAP), 859 .listeners_arr = { 860 MLXSW_SP_RXL_NO_MARK(LACP, LACP, TRAP_TO_CPU, true), 861 }, 862 }, 863 { 864 .trap = MLXSW_SP_TRAP_CONTROL(LLDP, LLDP, TRAP), 865 .listeners_arr = { 866 MLXSW_RXL(mlxsw_sp_rx_ptp_listener, LLDP, TRAP_TO_CPU, 867 false, SP_LLDP, DISCARD), 868 }, 869 }, 870 { 871 .trap = MLXSW_SP_TRAP_CONTROL(IGMP_QUERY, MC_SNOOPING, MIRROR), 872 .listeners_arr = { 873 MLXSW_SP_RXL_MARK(IGMP_QUERY, MC_SNOOPING, 874 MIRROR_TO_CPU, false), 875 }, 876 }, 877 { 878 .trap = MLXSW_SP_TRAP_CONTROL(IGMP_V1_REPORT, MC_SNOOPING, 879 TRAP), 880 .listeners_arr = { 881 MLXSW_SP_RXL_NO_MARK(IGMP_V1_REPORT, MC_SNOOPING, 882 TRAP_TO_CPU, false), 883 }, 884 }, 885 { 886 .trap = MLXSW_SP_TRAP_CONTROL(IGMP_V2_REPORT, MC_SNOOPING, 887 TRAP), 888 .listeners_arr = { 889 MLXSW_SP_RXL_NO_MARK(IGMP_V2_REPORT, MC_SNOOPING, 890 TRAP_TO_CPU, false), 891 }, 892 }, 893 { 894 .trap = MLXSW_SP_TRAP_CONTROL(IGMP_V3_REPORT, MC_SNOOPING, 895 TRAP), 896 .listeners_arr = { 897 MLXSW_SP_RXL_NO_MARK(IGMP_V3_REPORT, MC_SNOOPING, 898 TRAP_TO_CPU, false), 899 }, 900 }, 901 { 902 .trap = MLXSW_SP_TRAP_CONTROL(IGMP_V2_LEAVE, MC_SNOOPING, 903 TRAP), 904 .listeners_arr = { 905 MLXSW_SP_RXL_NO_MARK(IGMP_V2_LEAVE, MC_SNOOPING, 906 TRAP_TO_CPU, false), 907 }, 908 }, 909 { 910 .trap = MLXSW_SP_TRAP_CONTROL(MLD_QUERY, MC_SNOOPING, MIRROR), 911 .listeners_arr = { 912 MLXSW_SP_RXL_MARK(IPV6_MLDV12_LISTENER_QUERY, 913 MC_SNOOPING, MIRROR_TO_CPU, false), 914 }, 915 }, 916 { 917 .trap = MLXSW_SP_TRAP_CONTROL(MLD_V1_REPORT, MC_SNOOPING, 918 TRAP), 919 .listeners_arr = { 920 MLXSW_SP_RXL_NO_MARK(IPV6_MLDV1_LISTENER_REPORT, 921 MC_SNOOPING, TRAP_TO_CPU, false), 922 }, 923 }, 924 { 925 .trap = MLXSW_SP_TRAP_CONTROL(MLD_V2_REPORT, MC_SNOOPING, 926 TRAP), 927 .listeners_arr = { 928 MLXSW_SP_RXL_NO_MARK(IPV6_MLDV2_LISTENER_REPORT, 929 MC_SNOOPING, TRAP_TO_CPU, false), 930 }, 931 }, 932 { 933 .trap = MLXSW_SP_TRAP_CONTROL(MLD_V1_DONE, MC_SNOOPING, 934 TRAP), 935 .listeners_arr = { 936 MLXSW_SP_RXL_NO_MARK(IPV6_MLDV1_LISTENER_DONE, 937 MC_SNOOPING, TRAP_TO_CPU, false), 938 }, 939 }, 940 { 941 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_DHCP, DHCP, TRAP), 942 .listeners_arr = { 943 MLXSW_SP_RXL_MARK(IPV4_DHCP, DHCP, TRAP_TO_CPU, false), 944 }, 945 }, 946 { 947 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_DHCP, DHCP, TRAP), 948 .listeners_arr = { 949 MLXSW_SP_RXL_MARK(IPV6_DHCP, DHCP, TRAP_TO_CPU, false), 950 }, 951 }, 952 { 953 .trap = MLXSW_SP_TRAP_CONTROL(ARP_REQUEST, NEIGH_DISCOVERY, 954 MIRROR), 955 .listeners_arr = { 956 MLXSW_SP_RXL_MARK(ARPBC, NEIGH_DISCOVERY, MIRROR_TO_CPU, 957 false), 958 }, 959 }, 960 { 961 .trap = MLXSW_SP_TRAP_CONTROL(ARP_RESPONSE, NEIGH_DISCOVERY, 962 MIRROR), 963 .listeners_arr = { 964 MLXSW_SP_RXL_MARK(ARPUC, NEIGH_DISCOVERY, MIRROR_TO_CPU, 965 false), 966 }, 967 }, 968 { 969 .trap = MLXSW_SP_TRAP_CONTROL(ARP_OVERLAY, NEIGH_DISCOVERY, 970 TRAP), 971 .listeners_arr = { 972 MLXSW_SP_RXL_NO_MARK(NVE_DECAP_ARP, NEIGH_DISCOVERY, 973 TRAP_TO_CPU, false), 974 }, 975 }, 976 { 977 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_NEIGH_SOLICIT, 978 NEIGH_DISCOVERY, TRAP), 979 .listeners_arr = { 980 MLXSW_SP_RXL_MARK(L3_IPV6_NEIGHBOR_SOLICITATION, 981 NEIGH_DISCOVERY, TRAP_TO_CPU, false), 982 }, 983 }, 984 { 985 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_NEIGH_ADVERT, 986 NEIGH_DISCOVERY, TRAP), 987 .listeners_arr = { 988 MLXSW_SP_RXL_MARK(L3_IPV6_NEIGHBOR_ADVERTISEMENT, 989 NEIGH_DISCOVERY, TRAP_TO_CPU, false), 990 }, 991 }, 992 { 993 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_BFD, BFD, TRAP), 994 .listeners_arr = { 995 MLXSW_SP_RXL_MARK(IPV4_BFD, BFD, TRAP_TO_CPU, false), 996 }, 997 }, 998 { 999 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_BFD, BFD, TRAP), 1000 .listeners_arr = { 1001 MLXSW_SP_RXL_MARK(IPV6_BFD, BFD, TRAP_TO_CPU, false), 1002 }, 1003 }, 1004 { 1005 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_OSPF, OSPF, TRAP), 1006 .listeners_arr = { 1007 MLXSW_SP_RXL_MARK(IPV4_OSPF, OSPF, TRAP_TO_CPU, false), 1008 }, 1009 }, 1010 { 1011 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_OSPF, OSPF, TRAP), 1012 .listeners_arr = { 1013 MLXSW_SP_RXL_MARK(IPV6_OSPF, OSPF, TRAP_TO_CPU, false), 1014 }, 1015 }, 1016 { 1017 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_BGP, BGP, TRAP), 1018 .listeners_arr = { 1019 MLXSW_SP_RXL_MARK(IPV4_BGP, BGP, TRAP_TO_CPU, false), 1020 }, 1021 }, 1022 { 1023 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_BGP, BGP, TRAP), 1024 .listeners_arr = { 1025 MLXSW_SP_RXL_MARK(IPV6_BGP, BGP, TRAP_TO_CPU, false), 1026 }, 1027 }, 1028 { 1029 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_VRRP, VRRP, TRAP), 1030 .listeners_arr = { 1031 MLXSW_SP_RXL_MARK(IPV4_VRRP, VRRP, TRAP_TO_CPU, false), 1032 }, 1033 }, 1034 { 1035 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_VRRP, VRRP, TRAP), 1036 .listeners_arr = { 1037 MLXSW_SP_RXL_MARK(IPV6_VRRP, VRRP, TRAP_TO_CPU, false), 1038 }, 1039 }, 1040 { 1041 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_PIM, PIM, TRAP), 1042 .listeners_arr = { 1043 MLXSW_SP_RXL_MARK(IPV4_PIM, PIM, TRAP_TO_CPU, false), 1044 }, 1045 }, 1046 { 1047 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_PIM, PIM, TRAP), 1048 .listeners_arr = { 1049 MLXSW_SP_RXL_MARK(IPV6_PIM, PIM, TRAP_TO_CPU, false), 1050 }, 1051 }, 1052 { 1053 .trap = MLXSW_SP_TRAP_CONTROL(UC_LB, UC_LB, MIRROR), 1054 .listeners_arr = { 1055 MLXSW_SP_RXL_L3_MARK(LBERROR, LBERROR, MIRROR_TO_CPU, 1056 false), 1057 }, 1058 }, 1059 { 1060 .trap = MLXSW_SP_TRAP_CONTROL(LOCAL_ROUTE, LOCAL_DELIVERY, 1061 TRAP), 1062 .listeners_arr = { 1063 MLXSW_SP_RXL_MARK(IP2ME, IP2ME, TRAP_TO_CPU, false), 1064 }, 1065 }, 1066 { 1067 .trap = MLXSW_SP_TRAP_CONTROL(EXTERNAL_ROUTE, EXTERNAL_DELIVERY, 1068 TRAP), 1069 .listeners_arr = { 1070 MLXSW_SP_RXL_MARK(RTR_INGRESS0, EXTERNAL_ROUTE, 1071 TRAP_TO_CPU, false), 1072 }, 1073 }, 1074 { 1075 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_UC_DIP_LINK_LOCAL_SCOPE, 1076 LOCAL_DELIVERY, TRAP), 1077 .listeners_arr = { 1078 MLXSW_SP_RXL_MARK(IPV6_LINK_LOCAL_DEST, IP2ME, 1079 TRAP_TO_CPU, false), 1080 }, 1081 }, 1082 { 1083 .trap = MLXSW_SP_TRAP_CONTROL(IPV4_ROUTER_ALERT, LOCAL_DELIVERY, 1084 TRAP), 1085 .listeners_arr = { 1086 MLXSW_SP_RXL_MARK(ROUTER_ALERT_IPV4, IP2ME, TRAP_TO_CPU, 1087 false), 1088 }, 1089 }, 1090 { 1091 /* IPV6_ROUTER_ALERT is defined in uAPI as 22, but it is not 1092 * used in this file, so undefine it. 1093 */ 1094 #undef IPV6_ROUTER_ALERT 1095 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_ROUTER_ALERT, LOCAL_DELIVERY, 1096 TRAP), 1097 .listeners_arr = { 1098 MLXSW_SP_RXL_MARK(ROUTER_ALERT_IPV6, IP2ME, TRAP_TO_CPU, 1099 false), 1100 }, 1101 }, 1102 { 1103 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_DIP_ALL_NODES, IPV6, TRAP), 1104 .listeners_arr = { 1105 MLXSW_SP_RXL_MARK(IPV6_ALL_NODES_LINK, IPV6, 1106 TRAP_TO_CPU, false), 1107 }, 1108 }, 1109 { 1110 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_DIP_ALL_ROUTERS, IPV6, TRAP), 1111 .listeners_arr = { 1112 MLXSW_SP_RXL_MARK(IPV6_ALL_ROUTERS_LINK, IPV6, 1113 TRAP_TO_CPU, false), 1114 }, 1115 }, 1116 { 1117 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_ROUTER_SOLICIT, IPV6, TRAP), 1118 .listeners_arr = { 1119 MLXSW_SP_RXL_MARK(L3_IPV6_ROUTER_SOLICITATION, IPV6, 1120 TRAP_TO_CPU, false), 1121 }, 1122 }, 1123 { 1124 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_ROUTER_ADVERT, IPV6, TRAP), 1125 .listeners_arr = { 1126 MLXSW_SP_RXL_MARK(L3_IPV6_ROUTER_ADVERTISEMENT, IPV6, 1127 TRAP_TO_CPU, false), 1128 }, 1129 }, 1130 { 1131 .trap = MLXSW_SP_TRAP_CONTROL(IPV6_REDIRECT, IPV6, TRAP), 1132 .listeners_arr = { 1133 MLXSW_SP_RXL_MARK(L3_IPV6_REDIRECTION, IPV6, 1134 TRAP_TO_CPU, false), 1135 }, 1136 }, 1137 { 1138 .trap = MLXSW_SP_TRAP_CONTROL(PTP_EVENT, PTP_EVENT, TRAP), 1139 .listeners_arr = { 1140 MLXSW_RXL(mlxsw_sp_rx_ptp_listener, PTP0, TRAP_TO_CPU, 1141 false, SP_PTP0, DISCARD), 1142 }, 1143 }, 1144 { 1145 .trap = MLXSW_SP_TRAP_CONTROL(PTP_GENERAL, PTP_GENERAL, TRAP), 1146 .listeners_arr = { 1147 MLXSW_SP_RXL_NO_MARK(PTP1, PTP1, TRAP_TO_CPU, false), 1148 }, 1149 }, 1150 { 1151 .trap = MLXSW_SP_TRAP_CONTROL(FLOW_ACTION_TRAP, ACL_TRAP, TRAP), 1152 .listeners_arr = { 1153 MLXSW_SP_RXL_NO_MARK(ACL0, FLOW_LOGGING, TRAP_TO_CPU, 1154 false), 1155 }, 1156 }, 1157 { 1158 .trap = MLXSW_SP_TRAP_DROP(BLACKHOLE_NEXTHOP, L3_DROPS), 1159 .listeners_arr = { 1160 MLXSW_SP_RXL_DISCARD(ROUTER3, L3_DISCARDS), 1161 }, 1162 }, 1163 }; 1164 1165 static struct mlxsw_sp_trap_policer_item * 1166 mlxsw_sp_trap_policer_item_lookup(struct mlxsw_sp *mlxsw_sp, u32 id) 1167 { 1168 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1169 int i; 1170 1171 for (i = 0; i < trap->policers_count; i++) { 1172 if (trap->policer_items_arr[i].policer.id == id) 1173 return &trap->policer_items_arr[i]; 1174 } 1175 1176 return NULL; 1177 } 1178 1179 static struct mlxsw_sp_trap_group_item * 1180 mlxsw_sp_trap_group_item_lookup(struct mlxsw_sp *mlxsw_sp, u16 id) 1181 { 1182 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1183 int i; 1184 1185 for (i = 0; i < trap->groups_count; i++) { 1186 if (trap->group_items_arr[i].group.id == id) 1187 return &trap->group_items_arr[i]; 1188 } 1189 1190 return NULL; 1191 } 1192 1193 static struct mlxsw_sp_trap_item * 1194 mlxsw_sp_trap_item_lookup(struct mlxsw_sp *mlxsw_sp, u16 id) 1195 { 1196 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1197 int i; 1198 1199 for (i = 0; i < trap->traps_count; i++) { 1200 if (trap->trap_items_arr[i].trap.id == id) 1201 return &trap->trap_items_arr[i]; 1202 } 1203 1204 return NULL; 1205 } 1206 1207 static int mlxsw_sp_trap_cpu_policers_set(struct mlxsw_sp *mlxsw_sp) 1208 { 1209 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1210 char qpcr_pl[MLXSW_REG_QPCR_LEN]; 1211 u16 hw_id; 1212 1213 /* The purpose of "thin" policer is to drop as many packets 1214 * as possible. The dummy group is using it. 1215 */ 1216 hw_id = find_first_zero_bit(trap->policers_usage, trap->max_policers); 1217 if (WARN_ON(hw_id == trap->max_policers)) 1218 return -ENOBUFS; 1219 1220 __set_bit(hw_id, trap->policers_usage); 1221 trap->thin_policer_hw_id = hw_id; 1222 mlxsw_reg_qpcr_pack(qpcr_pl, hw_id, MLXSW_REG_QPCR_IR_UNITS_M, 1223 false, 1, 4); 1224 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(qpcr), qpcr_pl); 1225 } 1226 1227 static int mlxsw_sp_trap_dummy_group_init(struct mlxsw_sp *mlxsw_sp) 1228 { 1229 char htgt_pl[MLXSW_REG_HTGT_LEN]; 1230 1231 mlxsw_reg_htgt_pack(htgt_pl, MLXSW_REG_HTGT_TRAP_GROUP_SP_DUMMY, 1232 mlxsw_sp->trap->thin_policer_hw_id, 0, 1); 1233 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(htgt), htgt_pl); 1234 } 1235 1236 static int mlxsw_sp_trap_policer_items_arr_init(struct mlxsw_sp *mlxsw_sp) 1237 { 1238 size_t arr_size = ARRAY_SIZE(mlxsw_sp_trap_policer_items_arr); 1239 size_t elem_size = sizeof(struct mlxsw_sp_trap_policer_item); 1240 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1241 size_t free_policers = 0; 1242 u32 last_id; 1243 int i; 1244 1245 for_each_clear_bit(i, trap->policers_usage, trap->max_policers) 1246 free_policers++; 1247 1248 if (arr_size > free_policers) { 1249 dev_err(mlxsw_sp->bus_info->dev, "Exceeded number of supported packet trap policers\n"); 1250 return -ENOBUFS; 1251 } 1252 1253 trap->policer_items_arr = kcalloc(free_policers, elem_size, GFP_KERNEL); 1254 if (!trap->policer_items_arr) 1255 return -ENOMEM; 1256 1257 trap->policers_count = free_policers; 1258 1259 /* Initialize policer items array with pre-defined policers. */ 1260 memcpy(trap->policer_items_arr, mlxsw_sp_trap_policer_items_arr, 1261 elem_size * arr_size); 1262 1263 /* Initialize policer items array with the rest of the available 1264 * policers. 1265 */ 1266 last_id = mlxsw_sp_trap_policer_items_arr[arr_size - 1].policer.id; 1267 for (i = arr_size; i < trap->policers_count; i++) { 1268 const struct mlxsw_sp_trap_policer_item *policer_item; 1269 1270 /* Use parameters set for first policer and override 1271 * relevant ones. 1272 */ 1273 policer_item = &mlxsw_sp_trap_policer_items_arr[0]; 1274 trap->policer_items_arr[i] = *policer_item; 1275 trap->policer_items_arr[i].policer.id = ++last_id; 1276 trap->policer_items_arr[i].policer.init_rate = 1; 1277 trap->policer_items_arr[i].policer.init_burst = 16; 1278 } 1279 1280 return 0; 1281 } 1282 1283 static void mlxsw_sp_trap_policer_items_arr_fini(struct mlxsw_sp *mlxsw_sp) 1284 { 1285 kfree(mlxsw_sp->trap->policer_items_arr); 1286 } 1287 1288 static int mlxsw_sp_trap_policers_init(struct mlxsw_sp *mlxsw_sp) 1289 { 1290 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1291 const struct mlxsw_sp_trap_policer_item *policer_item; 1292 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1293 int err, i; 1294 1295 err = mlxsw_sp_trap_policer_items_arr_init(mlxsw_sp); 1296 if (err) 1297 return err; 1298 1299 for (i = 0; i < trap->policers_count; i++) { 1300 policer_item = &trap->policer_items_arr[i]; 1301 err = devlink_trap_policers_register(devlink, 1302 &policer_item->policer, 1); 1303 if (err) 1304 goto err_trap_policer_register; 1305 } 1306 1307 return 0; 1308 1309 err_trap_policer_register: 1310 for (i--; i >= 0; i--) { 1311 policer_item = &trap->policer_items_arr[i]; 1312 devlink_trap_policers_unregister(devlink, 1313 &policer_item->policer, 1); 1314 } 1315 mlxsw_sp_trap_policer_items_arr_fini(mlxsw_sp); 1316 return err; 1317 } 1318 1319 static void mlxsw_sp_trap_policers_fini(struct mlxsw_sp *mlxsw_sp) 1320 { 1321 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1322 const struct mlxsw_sp_trap_policer_item *policer_item; 1323 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1324 int i; 1325 1326 for (i = trap->policers_count - 1; i >= 0; i--) { 1327 policer_item = &trap->policer_items_arr[i]; 1328 devlink_trap_policers_unregister(devlink, 1329 &policer_item->policer, 1); 1330 } 1331 mlxsw_sp_trap_policer_items_arr_fini(mlxsw_sp); 1332 } 1333 1334 static int mlxsw_sp_trap_group_items_arr_init(struct mlxsw_sp *mlxsw_sp) 1335 { 1336 size_t common_groups_count = ARRAY_SIZE(mlxsw_sp_trap_group_items_arr); 1337 const struct mlxsw_sp_trap_group_item *spec_group_items_arr; 1338 size_t elem_size = sizeof(struct mlxsw_sp_trap_group_item); 1339 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1340 size_t groups_count, spec_groups_count; 1341 int err; 1342 1343 err = mlxsw_sp->trap_ops->groups_init(mlxsw_sp, &spec_group_items_arr, 1344 &spec_groups_count); 1345 if (err) 1346 return err; 1347 1348 /* The group items array is created by concatenating the common trap 1349 * group items and the ASIC-specific trap group items. 1350 */ 1351 groups_count = common_groups_count + spec_groups_count; 1352 trap->group_items_arr = kcalloc(groups_count, elem_size, GFP_KERNEL); 1353 if (!trap->group_items_arr) 1354 return -ENOMEM; 1355 1356 memcpy(trap->group_items_arr, mlxsw_sp_trap_group_items_arr, 1357 elem_size * common_groups_count); 1358 memcpy(trap->group_items_arr + common_groups_count, 1359 spec_group_items_arr, elem_size * spec_groups_count); 1360 1361 trap->groups_count = groups_count; 1362 1363 return 0; 1364 } 1365 1366 static void mlxsw_sp_trap_group_items_arr_fini(struct mlxsw_sp *mlxsw_sp) 1367 { 1368 kfree(mlxsw_sp->trap->group_items_arr); 1369 } 1370 1371 static int mlxsw_sp_trap_groups_init(struct mlxsw_sp *mlxsw_sp) 1372 { 1373 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1374 const struct mlxsw_sp_trap_group_item *group_item; 1375 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1376 int err, i; 1377 1378 err = mlxsw_sp_trap_group_items_arr_init(mlxsw_sp); 1379 if (err) 1380 return err; 1381 1382 for (i = 0; i < trap->groups_count; i++) { 1383 group_item = &trap->group_items_arr[i]; 1384 err = devlink_trap_groups_register(devlink, &group_item->group, 1385 1); 1386 if (err) 1387 goto err_trap_group_register; 1388 } 1389 1390 return 0; 1391 1392 err_trap_group_register: 1393 for (i--; i >= 0; i--) { 1394 group_item = &trap->group_items_arr[i]; 1395 devlink_trap_groups_unregister(devlink, &group_item->group, 1); 1396 } 1397 mlxsw_sp_trap_group_items_arr_fini(mlxsw_sp); 1398 return err; 1399 } 1400 1401 static void mlxsw_sp_trap_groups_fini(struct mlxsw_sp *mlxsw_sp) 1402 { 1403 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1404 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1405 int i; 1406 1407 for (i = trap->groups_count - 1; i >= 0; i--) { 1408 const struct mlxsw_sp_trap_group_item *group_item; 1409 1410 group_item = &trap->group_items_arr[i]; 1411 devlink_trap_groups_unregister(devlink, &group_item->group, 1); 1412 } 1413 mlxsw_sp_trap_group_items_arr_fini(mlxsw_sp); 1414 } 1415 1416 static bool 1417 mlxsw_sp_trap_listener_is_valid(const struct mlxsw_listener *listener) 1418 { 1419 return listener->trap_id != 0; 1420 } 1421 1422 static int mlxsw_sp_trap_items_arr_init(struct mlxsw_sp *mlxsw_sp) 1423 { 1424 size_t common_traps_count = ARRAY_SIZE(mlxsw_sp_trap_items_arr); 1425 const struct mlxsw_sp_trap_item *spec_trap_items_arr; 1426 size_t elem_size = sizeof(struct mlxsw_sp_trap_item); 1427 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1428 size_t traps_count, spec_traps_count; 1429 int err; 1430 1431 err = mlxsw_sp->trap_ops->traps_init(mlxsw_sp, &spec_trap_items_arr, 1432 &spec_traps_count); 1433 if (err) 1434 return err; 1435 1436 /* The trap items array is created by concatenating the common trap 1437 * items and the ASIC-specific trap items. 1438 */ 1439 traps_count = common_traps_count + spec_traps_count; 1440 trap->trap_items_arr = kcalloc(traps_count, elem_size, GFP_KERNEL); 1441 if (!trap->trap_items_arr) 1442 return -ENOMEM; 1443 1444 memcpy(trap->trap_items_arr, mlxsw_sp_trap_items_arr, 1445 elem_size * common_traps_count); 1446 memcpy(trap->trap_items_arr + common_traps_count, 1447 spec_trap_items_arr, elem_size * spec_traps_count); 1448 1449 trap->traps_count = traps_count; 1450 1451 return 0; 1452 } 1453 1454 static void mlxsw_sp_trap_items_arr_fini(struct mlxsw_sp *mlxsw_sp) 1455 { 1456 kfree(mlxsw_sp->trap->trap_items_arr); 1457 } 1458 1459 static int mlxsw_sp_traps_init(struct mlxsw_sp *mlxsw_sp) 1460 { 1461 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1462 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1463 const struct mlxsw_sp_trap_item *trap_item; 1464 int err, i; 1465 1466 err = mlxsw_sp_trap_items_arr_init(mlxsw_sp); 1467 if (err) 1468 return err; 1469 1470 for (i = 0; i < trap->traps_count; i++) { 1471 trap_item = &trap->trap_items_arr[i]; 1472 err = devlink_traps_register(devlink, &trap_item->trap, 1, 1473 mlxsw_sp); 1474 if (err) 1475 goto err_trap_register; 1476 } 1477 1478 return 0; 1479 1480 err_trap_register: 1481 for (i--; i >= 0; i--) { 1482 trap_item = &trap->trap_items_arr[i]; 1483 devlink_traps_unregister(devlink, &trap_item->trap, 1); 1484 } 1485 mlxsw_sp_trap_items_arr_fini(mlxsw_sp); 1486 return err; 1487 } 1488 1489 static void mlxsw_sp_traps_fini(struct mlxsw_sp *mlxsw_sp) 1490 { 1491 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 1492 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1493 int i; 1494 1495 for (i = trap->traps_count - 1; i >= 0; i--) { 1496 const struct mlxsw_sp_trap_item *trap_item; 1497 1498 trap_item = &trap->trap_items_arr[i]; 1499 devlink_traps_unregister(devlink, &trap_item->trap, 1); 1500 } 1501 mlxsw_sp_trap_items_arr_fini(mlxsw_sp); 1502 } 1503 1504 int mlxsw_sp_devlink_traps_init(struct mlxsw_sp *mlxsw_sp) 1505 { 1506 int err; 1507 1508 err = mlxsw_sp_trap_cpu_policers_set(mlxsw_sp); 1509 if (err) 1510 return err; 1511 1512 err = mlxsw_sp_trap_dummy_group_init(mlxsw_sp); 1513 if (err) 1514 return err; 1515 1516 err = mlxsw_sp_trap_policers_init(mlxsw_sp); 1517 if (err) 1518 return err; 1519 1520 err = mlxsw_sp_trap_groups_init(mlxsw_sp); 1521 if (err) 1522 goto err_trap_groups_init; 1523 1524 err = mlxsw_sp_traps_init(mlxsw_sp); 1525 if (err) 1526 goto err_traps_init; 1527 1528 return 0; 1529 1530 err_traps_init: 1531 mlxsw_sp_trap_groups_fini(mlxsw_sp); 1532 err_trap_groups_init: 1533 mlxsw_sp_trap_policers_fini(mlxsw_sp); 1534 return err; 1535 } 1536 1537 void mlxsw_sp_devlink_traps_fini(struct mlxsw_sp *mlxsw_sp) 1538 { 1539 mlxsw_sp_traps_fini(mlxsw_sp); 1540 mlxsw_sp_trap_groups_fini(mlxsw_sp); 1541 mlxsw_sp_trap_policers_fini(mlxsw_sp); 1542 } 1543 1544 int mlxsw_sp_trap_init(struct mlxsw_core *mlxsw_core, 1545 const struct devlink_trap *trap, void *trap_ctx) 1546 { 1547 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1548 const struct mlxsw_sp_trap_item *trap_item; 1549 int i; 1550 1551 trap_item = mlxsw_sp_trap_item_lookup(mlxsw_sp, trap->id); 1552 if (WARN_ON(!trap_item)) 1553 return -EINVAL; 1554 1555 for (i = 0; i < MLXSW_SP_TRAP_LISTENERS_MAX; i++) { 1556 const struct mlxsw_listener *listener; 1557 int err; 1558 1559 listener = &trap_item->listeners_arr[i]; 1560 if (!mlxsw_sp_trap_listener_is_valid(listener)) 1561 continue; 1562 err = mlxsw_core_trap_register(mlxsw_core, listener, trap_ctx); 1563 if (err) 1564 return err; 1565 } 1566 1567 return 0; 1568 } 1569 1570 void mlxsw_sp_trap_fini(struct mlxsw_core *mlxsw_core, 1571 const struct devlink_trap *trap, void *trap_ctx) 1572 { 1573 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1574 const struct mlxsw_sp_trap_item *trap_item; 1575 int i; 1576 1577 trap_item = mlxsw_sp_trap_item_lookup(mlxsw_sp, trap->id); 1578 if (WARN_ON(!trap_item)) 1579 return; 1580 1581 for (i = MLXSW_SP_TRAP_LISTENERS_MAX - 1; i >= 0; i--) { 1582 const struct mlxsw_listener *listener; 1583 1584 listener = &trap_item->listeners_arr[i]; 1585 if (!mlxsw_sp_trap_listener_is_valid(listener)) 1586 continue; 1587 mlxsw_core_trap_unregister(mlxsw_core, listener, trap_ctx); 1588 } 1589 } 1590 1591 int mlxsw_sp_trap_action_set(struct mlxsw_core *mlxsw_core, 1592 const struct devlink_trap *trap, 1593 enum devlink_trap_action action, 1594 struct netlink_ext_ack *extack) 1595 { 1596 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1597 const struct mlxsw_sp_trap_item *trap_item; 1598 int i; 1599 1600 trap_item = mlxsw_sp_trap_item_lookup(mlxsw_sp, trap->id); 1601 if (WARN_ON(!trap_item)) 1602 return -EINVAL; 1603 1604 if (trap_item->is_source) { 1605 NL_SET_ERR_MSG_MOD(extack, "Changing the action of source traps is not supported"); 1606 return -EOPNOTSUPP; 1607 } 1608 1609 for (i = 0; i < MLXSW_SP_TRAP_LISTENERS_MAX; i++) { 1610 const struct mlxsw_listener *listener; 1611 bool enabled; 1612 int err; 1613 1614 listener = &trap_item->listeners_arr[i]; 1615 if (!mlxsw_sp_trap_listener_is_valid(listener)) 1616 continue; 1617 1618 switch (action) { 1619 case DEVLINK_TRAP_ACTION_DROP: 1620 enabled = false; 1621 break; 1622 case DEVLINK_TRAP_ACTION_TRAP: 1623 enabled = true; 1624 break; 1625 default: 1626 return -EINVAL; 1627 } 1628 err = mlxsw_core_trap_state_set(mlxsw_core, listener, enabled); 1629 if (err) 1630 return err; 1631 } 1632 1633 return 0; 1634 } 1635 1636 static int 1637 __mlxsw_sp_trap_group_init(struct mlxsw_core *mlxsw_core, 1638 const struct devlink_trap_group *group, 1639 u32 policer_id, struct netlink_ext_ack *extack) 1640 { 1641 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1642 u16 hw_policer_id = MLXSW_REG_HTGT_INVALID_POLICER; 1643 const struct mlxsw_sp_trap_group_item *group_item; 1644 char htgt_pl[MLXSW_REG_HTGT_LEN]; 1645 1646 group_item = mlxsw_sp_trap_group_item_lookup(mlxsw_sp, group->id); 1647 if (WARN_ON(!group_item)) 1648 return -EINVAL; 1649 1650 if (group_item->fixed_policer && policer_id != group->init_policer_id) { 1651 NL_SET_ERR_MSG_MOD(extack, "Changing the policer binding of this group is not supported"); 1652 return -EOPNOTSUPP; 1653 } 1654 1655 if (policer_id) { 1656 struct mlxsw_sp_trap_policer_item *policer_item; 1657 1658 policer_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, 1659 policer_id); 1660 if (WARN_ON(!policer_item)) 1661 return -EINVAL; 1662 hw_policer_id = policer_item->hw_id; 1663 } 1664 1665 mlxsw_reg_htgt_pack(htgt_pl, group_item->hw_group_id, hw_policer_id, 1666 group_item->priority, group_item->priority); 1667 return mlxsw_reg_write(mlxsw_core, MLXSW_REG(htgt), htgt_pl); 1668 } 1669 1670 int mlxsw_sp_trap_group_init(struct mlxsw_core *mlxsw_core, 1671 const struct devlink_trap_group *group) 1672 { 1673 return __mlxsw_sp_trap_group_init(mlxsw_core, group, 1674 group->init_policer_id, NULL); 1675 } 1676 1677 int mlxsw_sp_trap_group_set(struct mlxsw_core *mlxsw_core, 1678 const struct devlink_trap_group *group, 1679 const struct devlink_trap_policer *policer, 1680 struct netlink_ext_ack *extack) 1681 { 1682 u32 policer_id = policer ? policer->id : 0; 1683 1684 return __mlxsw_sp_trap_group_init(mlxsw_core, group, policer_id, 1685 extack); 1686 } 1687 1688 static int 1689 mlxsw_sp_trap_policer_item_init(struct mlxsw_sp *mlxsw_sp, 1690 struct mlxsw_sp_trap_policer_item *policer_item) 1691 { 1692 struct mlxsw_sp_trap *trap = mlxsw_sp->trap; 1693 u16 hw_id; 1694 1695 /* We should be able to allocate a policer because the number of 1696 * policers we registered with devlink is in according with the number 1697 * of available policers. 1698 */ 1699 hw_id = find_first_zero_bit(trap->policers_usage, trap->max_policers); 1700 if (WARN_ON(hw_id == trap->max_policers)) 1701 return -ENOBUFS; 1702 1703 __set_bit(hw_id, trap->policers_usage); 1704 policer_item->hw_id = hw_id; 1705 1706 return 0; 1707 } 1708 1709 static void 1710 mlxsw_sp_trap_policer_item_fini(struct mlxsw_sp *mlxsw_sp, 1711 struct mlxsw_sp_trap_policer_item *policer_item) 1712 { 1713 __clear_bit(policer_item->hw_id, mlxsw_sp->trap->policers_usage); 1714 } 1715 1716 static int mlxsw_sp_trap_policer_bs(u64 burst, u8 *p_burst_size, 1717 struct netlink_ext_ack *extack) 1718 { 1719 int bs = fls64(burst) - 1; 1720 1721 if (burst != (BIT_ULL(bs))) { 1722 NL_SET_ERR_MSG_MOD(extack, "Policer burst size is not power of two"); 1723 return -EINVAL; 1724 } 1725 1726 *p_burst_size = bs; 1727 1728 return 0; 1729 } 1730 1731 static int __mlxsw_sp_trap_policer_set(struct mlxsw_sp *mlxsw_sp, u16 hw_id, 1732 u64 rate, u64 burst, bool clear_counter, 1733 struct netlink_ext_ack *extack) 1734 { 1735 char qpcr_pl[MLXSW_REG_QPCR_LEN]; 1736 u8 burst_size; 1737 int err; 1738 1739 err = mlxsw_sp_trap_policer_bs(burst, &burst_size, extack); 1740 if (err) 1741 return err; 1742 1743 mlxsw_reg_qpcr_pack(qpcr_pl, hw_id, MLXSW_REG_QPCR_IR_UNITS_M, false, 1744 rate, burst_size); 1745 mlxsw_reg_qpcr_clear_counter_set(qpcr_pl, clear_counter); 1746 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(qpcr), qpcr_pl); 1747 } 1748 1749 int mlxsw_sp_trap_policer_init(struct mlxsw_core *mlxsw_core, 1750 const struct devlink_trap_policer *policer) 1751 { 1752 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1753 struct mlxsw_sp_trap_policer_item *policer_item; 1754 int err; 1755 1756 policer_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, policer->id); 1757 if (WARN_ON(!policer_item)) 1758 return -EINVAL; 1759 1760 err = mlxsw_sp_trap_policer_item_init(mlxsw_sp, policer_item); 1761 if (err) 1762 return err; 1763 1764 err = __mlxsw_sp_trap_policer_set(mlxsw_sp, policer_item->hw_id, 1765 policer->init_rate, 1766 policer->init_burst, true, NULL); 1767 if (err) 1768 goto err_trap_policer_set; 1769 1770 return 0; 1771 1772 err_trap_policer_set: 1773 mlxsw_sp_trap_policer_item_fini(mlxsw_sp, policer_item); 1774 return err; 1775 } 1776 1777 void mlxsw_sp_trap_policer_fini(struct mlxsw_core *mlxsw_core, 1778 const struct devlink_trap_policer *policer) 1779 { 1780 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1781 struct mlxsw_sp_trap_policer_item *policer_item; 1782 1783 policer_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, policer->id); 1784 if (WARN_ON(!policer_item)) 1785 return; 1786 1787 mlxsw_sp_trap_policer_item_fini(mlxsw_sp, policer_item); 1788 } 1789 1790 int mlxsw_sp_trap_policer_set(struct mlxsw_core *mlxsw_core, 1791 const struct devlink_trap_policer *policer, 1792 u64 rate, u64 burst, 1793 struct netlink_ext_ack *extack) 1794 { 1795 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1796 struct mlxsw_sp_trap_policer_item *policer_item; 1797 1798 policer_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, policer->id); 1799 if (WARN_ON(!policer_item)) 1800 return -EINVAL; 1801 1802 return __mlxsw_sp_trap_policer_set(mlxsw_sp, policer_item->hw_id, 1803 rate, burst, false, extack); 1804 } 1805 1806 int 1807 mlxsw_sp_trap_policer_counter_get(struct mlxsw_core *mlxsw_core, 1808 const struct devlink_trap_policer *policer, 1809 u64 *p_drops) 1810 { 1811 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 1812 struct mlxsw_sp_trap_policer_item *policer_item; 1813 char qpcr_pl[MLXSW_REG_QPCR_LEN]; 1814 int err; 1815 1816 policer_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, policer->id); 1817 if (WARN_ON(!policer_item)) 1818 return -EINVAL; 1819 1820 mlxsw_reg_qpcr_pack(qpcr_pl, policer_item->hw_id, 1821 MLXSW_REG_QPCR_IR_UNITS_M, false, 0, 0); 1822 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(qpcr), qpcr_pl); 1823 if (err) 1824 return err; 1825 1826 *p_drops = mlxsw_reg_qpcr_violate_count_get(qpcr_pl); 1827 1828 return 0; 1829 } 1830 1831 int mlxsw_sp_trap_group_policer_hw_id_get(struct mlxsw_sp *mlxsw_sp, u16 id, 1832 bool *p_enabled, u16 *p_hw_id) 1833 { 1834 struct mlxsw_sp_trap_policer_item *pol_item; 1835 struct mlxsw_sp_trap_group_item *gr_item; 1836 u32 pol_id; 1837 1838 gr_item = mlxsw_sp_trap_group_item_lookup(mlxsw_sp, id); 1839 if (!gr_item) 1840 return -ENOENT; 1841 1842 pol_id = gr_item->group.init_policer_id; 1843 if (!pol_id) { 1844 *p_enabled = false; 1845 return 0; 1846 } 1847 1848 pol_item = mlxsw_sp_trap_policer_item_lookup(mlxsw_sp, pol_id); 1849 if (WARN_ON(!pol_item)) 1850 return -ENOENT; 1851 1852 *p_enabled = true; 1853 *p_hw_id = pol_item->hw_id; 1854 return 0; 1855 } 1856 1857 static const struct mlxsw_sp_trap_group_item 1858 mlxsw_sp1_trap_group_items_arr[] = { 1859 { 1860 .group = DEVLINK_TRAP_GROUP_GENERIC(ACL_SAMPLE, 0), 1861 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_PKT_SAMPLE, 1862 .priority = 0, 1863 }, 1864 }; 1865 1866 static const struct mlxsw_sp_trap_item 1867 mlxsw_sp1_trap_items_arr[] = { 1868 { 1869 .trap = MLXSW_SP_TRAP_CONTROL(FLOW_ACTION_SAMPLE, ACL_SAMPLE, 1870 MIRROR), 1871 .listeners_arr = { 1872 MLXSW_RXL(mlxsw_sp_rx_sample_listener, PKT_SAMPLE, 1873 MIRROR_TO_CPU, false, SP_PKT_SAMPLE, DISCARD), 1874 }, 1875 }, 1876 }; 1877 1878 static int 1879 mlxsw_sp1_trap_groups_init(struct mlxsw_sp *mlxsw_sp, 1880 const struct mlxsw_sp_trap_group_item **arr, 1881 size_t *p_groups_count) 1882 { 1883 *arr = mlxsw_sp1_trap_group_items_arr; 1884 *p_groups_count = ARRAY_SIZE(mlxsw_sp1_trap_group_items_arr); 1885 1886 return 0; 1887 } 1888 1889 static int mlxsw_sp1_traps_init(struct mlxsw_sp *mlxsw_sp, 1890 const struct mlxsw_sp_trap_item **arr, 1891 size_t *p_traps_count) 1892 { 1893 *arr = mlxsw_sp1_trap_items_arr; 1894 *p_traps_count = ARRAY_SIZE(mlxsw_sp1_trap_items_arr); 1895 1896 return 0; 1897 } 1898 1899 const struct mlxsw_sp_trap_ops mlxsw_sp1_trap_ops = { 1900 .groups_init = mlxsw_sp1_trap_groups_init, 1901 .traps_init = mlxsw_sp1_traps_init, 1902 }; 1903 1904 static const struct mlxsw_sp_trap_group_item 1905 mlxsw_sp2_trap_group_items_arr[] = { 1906 { 1907 .group = DEVLINK_TRAP_GROUP_GENERIC(BUFFER_DROPS, 20), 1908 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_BUFFER_DISCARDS, 1909 .priority = 0, 1910 .fixed_policer = true, 1911 }, 1912 { 1913 .group = DEVLINK_TRAP_GROUP_GENERIC(ACL_SAMPLE, 0), 1914 .hw_group_id = MLXSW_REG_HTGT_TRAP_GROUP_SP_PKT_SAMPLE, 1915 .priority = 0, 1916 .fixed_policer = true, 1917 }, 1918 }; 1919 1920 static const struct mlxsw_sp_trap_item 1921 mlxsw_sp2_trap_items_arr[] = { 1922 { 1923 .trap = MLXSW_SP_TRAP_BUFFER_DROP(EARLY_DROP), 1924 .listeners_arr = { 1925 MLXSW_SP_RXL_BUFFER_DISCARD(INGRESS_WRED), 1926 }, 1927 .is_source = true, 1928 }, 1929 { 1930 .trap = MLXSW_SP_TRAP_CONTROL(FLOW_ACTION_SAMPLE, ACL_SAMPLE, 1931 MIRROR), 1932 .listeners_arr = { 1933 MLXSW_RXL_MIRROR(mlxsw_sp_rx_sample_listener, 1, 1934 SP_PKT_SAMPLE, 1935 MLXSW_SP_MIRROR_REASON_INGRESS), 1936 MLXSW_RXL_MIRROR(mlxsw_sp_rx_sample_tx_listener, 1, 1937 SP_PKT_SAMPLE, 1938 MLXSW_SP_MIRROR_REASON_EGRESS), 1939 MLXSW_RXL_MIRROR(mlxsw_sp_rx_sample_acl_listener, 1, 1940 SP_PKT_SAMPLE, 1941 MLXSW_SP_MIRROR_REASON_POLICY_ENGINE), 1942 }, 1943 }, 1944 }; 1945 1946 static int 1947 mlxsw_sp2_trap_groups_init(struct mlxsw_sp *mlxsw_sp, 1948 const struct mlxsw_sp_trap_group_item **arr, 1949 size_t *p_groups_count) 1950 { 1951 *arr = mlxsw_sp2_trap_group_items_arr; 1952 *p_groups_count = ARRAY_SIZE(mlxsw_sp2_trap_group_items_arr); 1953 1954 return 0; 1955 } 1956 1957 static int mlxsw_sp2_traps_init(struct mlxsw_sp *mlxsw_sp, 1958 const struct mlxsw_sp_trap_item **arr, 1959 size_t *p_traps_count) 1960 { 1961 *arr = mlxsw_sp2_trap_items_arr; 1962 *p_traps_count = ARRAY_SIZE(mlxsw_sp2_trap_items_arr); 1963 1964 return 0; 1965 } 1966 1967 const struct mlxsw_sp_trap_ops mlxsw_sp2_trap_ops = { 1968 .groups_init = mlxsw_sp2_trap_groups_init, 1969 .traps_init = mlxsw_sp2_traps_init, 1970 }; 1971