aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/ethernet/rocker/rocker.c
diff options
context:
space:
mode:
authorJiri Pirko <jiri@mellanox.com>2015-09-24 04:02:40 -0400
committerDavid S. Miller <davem@davemloft.net>2015-09-25 01:59:21 -0400
commit69f5df491e0becb75d2d795add7481a35218d657 (patch)
tree3ed228b4acf8401be9203be33cc2448152d9267c /drivers/net/ethernet/rocker/rocker.c
parentaee2f545f0a12399cc6bbe134d69b8994582b694 (diff)
switchdev: rename "trans" to "trans_ph".
This is temporary, name "trans" will be used for something else and "trans_ph" will eventually disappear. Signed-off-by: Jiri Pirko <jiri@mellanox.com> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/net/ethernet/rocker/rocker.c')
-rw-r--r--drivers/net/ethernet/rocker/rocker.c382
1 files changed, 191 insertions, 191 deletions
diff --git a/drivers/net/ethernet/rocker/rocker.c b/drivers/net/ethernet/rocker/rocker.c
index 32c5429ea5fe..cf03b077311e 100644
--- a/drivers/net/ethernet/rocker/rocker.c
+++ b/drivers/net/ethernet/rocker/rocker.c
@@ -343,7 +343,7 @@ static bool rocker_port_is_ovsed(const struct rocker_port *rocker_port)
343#define ROCKER_OP_FLAG_REFRESH BIT(3) 343#define ROCKER_OP_FLAG_REFRESH BIT(3)
344 344
345static void *__rocker_port_mem_alloc(struct rocker_port *rocker_port, 345static void *__rocker_port_mem_alloc(struct rocker_port *rocker_port,
346 enum switchdev_trans trans, int flags, 346 enum switchdev_trans_ph trans_ph, int flags,
347 size_t size) 347 size_t size)
348{ 348{
349 struct list_head *elem = NULL; 349 struct list_head *elem = NULL;
@@ -359,7 +359,7 @@ static void *__rocker_port_mem_alloc(struct rocker_port *rocker_port,
359 * memory used in the commit phase. 359 * memory used in the commit phase.
360 */ 360 */
361 361
362 switch (trans) { 362 switch (trans_ph) {
363 case SWITCHDEV_TRANS_PREPARE: 363 case SWITCHDEV_TRANS_PREPARE:
364 elem = kzalloc(size + sizeof(*elem), gfp_flags); 364 elem = kzalloc(size + sizeof(*elem), gfp_flags);
365 if (!elem) 365 if (!elem)
@@ -384,20 +384,20 @@ static void *__rocker_port_mem_alloc(struct rocker_port *rocker_port,
384} 384}
385 385
386static void *rocker_port_kzalloc(struct rocker_port *rocker_port, 386static void *rocker_port_kzalloc(struct rocker_port *rocker_port,
387 enum switchdev_trans trans, int flags, 387 enum switchdev_trans_ph trans_ph, int flags,
388 size_t size) 388 size_t size)
389{ 389{
390 return __rocker_port_mem_alloc(rocker_port, trans, flags, size); 390 return __rocker_port_mem_alloc(rocker_port, trans_ph, flags, size);
391} 391}
392 392
393static void *rocker_port_kcalloc(struct rocker_port *rocker_port, 393static void *rocker_port_kcalloc(struct rocker_port *rocker_port,
394 enum switchdev_trans trans, int flags, 394 enum switchdev_trans_ph trans_ph, int flags,
395 size_t n, size_t size) 395 size_t n, size_t size)
396{ 396{
397 return __rocker_port_mem_alloc(rocker_port, trans, flags, n * size); 397 return __rocker_port_mem_alloc(rocker_port, trans_ph, flags, n * size);
398} 398}
399 399
400static void rocker_port_kfree(enum switchdev_trans trans, const void *mem) 400static void rocker_port_kfree(enum switchdev_trans_ph trans_ph, const void *mem)
401{ 401{
402 struct list_head *elem; 402 struct list_head *elem;
403 403
@@ -406,7 +406,7 @@ static void rocker_port_kfree(enum switchdev_trans trans, const void *mem)
406 * commit phase. 406 * commit phase.
407 */ 407 */
408 408
409 if (trans == SWITCHDEV_TRANS_PREPARE) 409 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
410 return; 410 return;
411 411
412 elem = (struct list_head *)mem - 1; 412 elem = (struct list_head *)mem - 1;
@@ -433,22 +433,22 @@ static void rocker_wait_init(struct rocker_wait *wait)
433} 433}
434 434
435static struct rocker_wait *rocker_wait_create(struct rocker_port *rocker_port, 435static struct rocker_wait *rocker_wait_create(struct rocker_port *rocker_port,
436 enum switchdev_trans trans, 436 enum switchdev_trans_ph trans_ph,
437 int flags) 437 int flags)
438{ 438{
439 struct rocker_wait *wait; 439 struct rocker_wait *wait;
440 440
441 wait = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*wait)); 441 wait = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*wait));
442 if (!wait) 442 if (!wait)
443 return NULL; 443 return NULL;
444 rocker_wait_init(wait); 444 rocker_wait_init(wait);
445 return wait; 445 return wait;
446} 446}
447 447
448static void rocker_wait_destroy(enum switchdev_trans trans, 448static void rocker_wait_destroy(enum switchdev_trans_ph trans_ph,
449 struct rocker_wait *wait) 449 struct rocker_wait *wait)
450{ 450{
451 rocker_port_kfree(trans, wait); 451 rocker_port_kfree(trans_ph, wait);
452} 452}
453 453
454static bool rocker_wait_event_timeout(struct rocker_wait *wait, 454static bool rocker_wait_event_timeout(struct rocker_wait *wait,
@@ -1466,7 +1466,7 @@ static int rocker_event_link_change(const struct rocker *rocker,
1466} 1466}
1467 1467
1468static int rocker_port_fdb(struct rocker_port *rocker_port, 1468static int rocker_port_fdb(struct rocker_port *rocker_port,
1469 enum switchdev_trans trans, 1469 enum switchdev_trans_ph trans_ph,
1470 const unsigned char *addr, 1470 const unsigned char *addr,
1471 __be16 vlan_id, int flags); 1471 __be16 vlan_id, int flags);
1472 1472
@@ -1585,7 +1585,7 @@ typedef int (*rocker_cmd_proc_cb_t)(const struct rocker_port *rocker_port,
1585 void *priv); 1585 void *priv);
1586 1586
1587static int rocker_cmd_exec(struct rocker_port *rocker_port, 1587static int rocker_cmd_exec(struct rocker_port *rocker_port,
1588 enum switchdev_trans trans, int flags, 1588 enum switchdev_trans_ph trans_ph, int flags,
1589 rocker_cmd_prep_cb_t prepare, void *prepare_priv, 1589 rocker_cmd_prep_cb_t prepare, void *prepare_priv,
1590 rocker_cmd_proc_cb_t process, void *process_priv) 1590 rocker_cmd_proc_cb_t process, void *process_priv)
1591{ 1591{
@@ -1596,7 +1596,7 @@ static int rocker_cmd_exec(struct rocker_port *rocker_port,
1596 unsigned long lock_flags; 1596 unsigned long lock_flags;
1597 int err; 1597 int err;
1598 1598
1599 wait = rocker_wait_create(rocker_port, trans, flags); 1599 wait = rocker_wait_create(rocker_port, trans_ph, flags);
1600 if (!wait) 1600 if (!wait)
1601 return -ENOMEM; 1601 return -ENOMEM;
1602 wait->nowait = nowait; 1602 wait->nowait = nowait;
@@ -1618,7 +1618,7 @@ static int rocker_cmd_exec(struct rocker_port *rocker_port,
1618 1618
1619 rocker_desc_cookie_ptr_set(desc_info, wait); 1619 rocker_desc_cookie_ptr_set(desc_info, wait);
1620 1620
1621 if (trans != SWITCHDEV_TRANS_PREPARE) 1621 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
1622 rocker_desc_head_set(rocker, &rocker->cmd_ring, desc_info); 1622 rocker_desc_head_set(rocker, &rocker->cmd_ring, desc_info);
1623 1623
1624 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags); 1624 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags);
@@ -1626,7 +1626,7 @@ static int rocker_cmd_exec(struct rocker_port *rocker_port,
1626 if (nowait) 1626 if (nowait)
1627 return 0; 1627 return 0;
1628 1628
1629 if (trans != SWITCHDEV_TRANS_PREPARE) 1629 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
1630 if (!rocker_wait_event_timeout(wait, HZ / 10)) 1630 if (!rocker_wait_event_timeout(wait, HZ / 10))
1631 return -EIO; 1631 return -EIO;
1632 1632
@@ -1639,7 +1639,7 @@ static int rocker_cmd_exec(struct rocker_port *rocker_port,
1639 1639
1640 rocker_desc_gen_clear(desc_info); 1640 rocker_desc_gen_clear(desc_info);
1641out: 1641out:
1642 rocker_wait_destroy(trans, wait); 1642 rocker_wait_destroy(trans_ph, wait);
1643 return err; 1643 return err;
1644} 1644}
1645 1645
@@ -1918,9 +1918,9 @@ static int rocker_cmd_set_port_settings_mtu(struct rocker_port *rocker_port,
1918} 1918}
1919 1919
1920static int rocker_port_set_learning(struct rocker_port *rocker_port, 1920static int rocker_port_set_learning(struct rocker_port *rocker_port,
1921 enum switchdev_trans trans) 1921 enum switchdev_trans_ph trans_ph)
1922{ 1922{
1923 return rocker_cmd_exec(rocker_port, trans, 0, 1923 return rocker_cmd_exec(rocker_port, trans_ph, 0,
1924 rocker_cmd_set_port_learning_prep, 1924 rocker_cmd_set_port_learning_prep,
1925 NULL, NULL, NULL); 1925 NULL, NULL, NULL);
1926} 1926}
@@ -2436,7 +2436,7 @@ rocker_flow_tbl_find(const struct rocker *rocker,
2436} 2436}
2437 2437
2438static int rocker_flow_tbl_add(struct rocker_port *rocker_port, 2438static int rocker_flow_tbl_add(struct rocker_port *rocker_port,
2439 enum switchdev_trans trans, int flags, 2439 enum switchdev_trans_ph trans_ph, int flags,
2440 struct rocker_flow_tbl_entry *match) 2440 struct rocker_flow_tbl_entry *match)
2441{ 2441{
2442 struct rocker *rocker = rocker_port->rocker; 2442 struct rocker *rocker = rocker_port->rocker;
@@ -2452,9 +2452,9 @@ static int rocker_flow_tbl_add(struct rocker_port *rocker_port,
2452 2452
2453 if (found) { 2453 if (found) {
2454 match->cookie = found->cookie; 2454 match->cookie = found->cookie;
2455 if (trans != SWITCHDEV_TRANS_PREPARE) 2455 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2456 hash_del(&found->entry); 2456 hash_del(&found->entry);
2457 rocker_port_kfree(trans, found); 2457 rocker_port_kfree(trans_ph, found);
2458 found = match; 2458 found = match;
2459 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD; 2459 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD;
2460 } else { 2460 } else {
@@ -2463,17 +2463,17 @@ static int rocker_flow_tbl_add(struct rocker_port *rocker_port,
2463 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD; 2463 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD;
2464 } 2464 }
2465 2465
2466 if (trans != SWITCHDEV_TRANS_PREPARE) 2466 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2467 hash_add(rocker->flow_tbl, &found->entry, found->key_crc32); 2467 hash_add(rocker->flow_tbl, &found->entry, found->key_crc32);
2468 2468
2469 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags); 2469 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags);
2470 2470
2471 return rocker_cmd_exec(rocker_port, trans, flags, 2471 return rocker_cmd_exec(rocker_port, trans_ph, flags,
2472 rocker_cmd_flow_tbl_add, found, NULL, NULL); 2472 rocker_cmd_flow_tbl_add, found, NULL, NULL);
2473} 2473}
2474 2474
2475static int rocker_flow_tbl_del(struct rocker_port *rocker_port, 2475static int rocker_flow_tbl_del(struct rocker_port *rocker_port,
2476 enum switchdev_trans trans, int flags, 2476 enum switchdev_trans_ph trans_ph, int flags,
2477 struct rocker_flow_tbl_entry *match) 2477 struct rocker_flow_tbl_entry *match)
2478{ 2478{
2479 struct rocker *rocker = rocker_port->rocker; 2479 struct rocker *rocker = rocker_port->rocker;
@@ -2489,43 +2489,43 @@ static int rocker_flow_tbl_del(struct rocker_port *rocker_port,
2489 found = rocker_flow_tbl_find(rocker, match); 2489 found = rocker_flow_tbl_find(rocker, match);
2490 2490
2491 if (found) { 2491 if (found) {
2492 if (trans != SWITCHDEV_TRANS_PREPARE) 2492 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2493 hash_del(&found->entry); 2493 hash_del(&found->entry);
2494 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL; 2494 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL;
2495 } 2495 }
2496 2496
2497 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags); 2497 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags);
2498 2498
2499 rocker_port_kfree(trans, match); 2499 rocker_port_kfree(trans_ph, match);
2500 2500
2501 if (found) { 2501 if (found) {
2502 err = rocker_cmd_exec(rocker_port, trans, flags, 2502 err = rocker_cmd_exec(rocker_port, trans_ph, flags,
2503 rocker_cmd_flow_tbl_del, 2503 rocker_cmd_flow_tbl_del,
2504 found, NULL, NULL); 2504 found, NULL, NULL);
2505 rocker_port_kfree(trans, found); 2505 rocker_port_kfree(trans_ph, found);
2506 } 2506 }
2507 2507
2508 return err; 2508 return err;
2509} 2509}
2510 2510
2511static int rocker_flow_tbl_do(struct rocker_port *rocker_port, 2511static int rocker_flow_tbl_do(struct rocker_port *rocker_port,
2512 enum switchdev_trans trans, int flags, 2512 enum switchdev_trans_ph trans_ph, int flags,
2513 struct rocker_flow_tbl_entry *entry) 2513 struct rocker_flow_tbl_entry *entry)
2514{ 2514{
2515 if (flags & ROCKER_OP_FLAG_REMOVE) 2515 if (flags & ROCKER_OP_FLAG_REMOVE)
2516 return rocker_flow_tbl_del(rocker_port, trans, flags, entry); 2516 return rocker_flow_tbl_del(rocker_port, trans_ph, flags, entry);
2517 else 2517 else
2518 return rocker_flow_tbl_add(rocker_port, trans, flags, entry); 2518 return rocker_flow_tbl_add(rocker_port, trans_ph, flags, entry);
2519} 2519}
2520 2520
2521static int rocker_flow_tbl_ig_port(struct rocker_port *rocker_port, 2521static int rocker_flow_tbl_ig_port(struct rocker_port *rocker_port,
2522 enum switchdev_trans trans, int flags, 2522 enum switchdev_trans_ph trans_ph, int flags,
2523 u32 in_pport, u32 in_pport_mask, 2523 u32 in_pport, u32 in_pport_mask,
2524 enum rocker_of_dpa_table_id goto_tbl) 2524 enum rocker_of_dpa_table_id goto_tbl)
2525{ 2525{
2526 struct rocker_flow_tbl_entry *entry; 2526 struct rocker_flow_tbl_entry *entry;
2527 2527
2528 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2528 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2529 if (!entry) 2529 if (!entry)
2530 return -ENOMEM; 2530 return -ENOMEM;
2531 2531
@@ -2535,11 +2535,11 @@ static int rocker_flow_tbl_ig_port(struct rocker_port *rocker_port,
2535 entry->key.ig_port.in_pport_mask = in_pport_mask; 2535 entry->key.ig_port.in_pport_mask = in_pport_mask;
2536 entry->key.ig_port.goto_tbl = goto_tbl; 2536 entry->key.ig_port.goto_tbl = goto_tbl;
2537 2537
2538 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2538 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2539} 2539}
2540 2540
2541static int rocker_flow_tbl_vlan(struct rocker_port *rocker_port, 2541static int rocker_flow_tbl_vlan(struct rocker_port *rocker_port,
2542 enum switchdev_trans trans, int flags, 2542 enum switchdev_trans_ph trans_ph, int flags,
2543 u32 in_pport, __be16 vlan_id, 2543 u32 in_pport, __be16 vlan_id,
2544 __be16 vlan_id_mask, 2544 __be16 vlan_id_mask,
2545 enum rocker_of_dpa_table_id goto_tbl, 2545 enum rocker_of_dpa_table_id goto_tbl,
@@ -2547,7 +2547,7 @@ static int rocker_flow_tbl_vlan(struct rocker_port *rocker_port,
2547{ 2547{
2548 struct rocker_flow_tbl_entry *entry; 2548 struct rocker_flow_tbl_entry *entry;
2549 2549
2550 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2550 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2551 if (!entry) 2551 if (!entry)
2552 return -ENOMEM; 2552 return -ENOMEM;
2553 2553
@@ -2561,11 +2561,11 @@ static int rocker_flow_tbl_vlan(struct rocker_port *rocker_port,
2561 entry->key.vlan.untagged = untagged; 2561 entry->key.vlan.untagged = untagged;
2562 entry->key.vlan.new_vlan_id = new_vlan_id; 2562 entry->key.vlan.new_vlan_id = new_vlan_id;
2563 2563
2564 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2564 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2565} 2565}
2566 2566
2567static int rocker_flow_tbl_term_mac(struct rocker_port *rocker_port, 2567static int rocker_flow_tbl_term_mac(struct rocker_port *rocker_port,
2568 enum switchdev_trans trans, 2568 enum switchdev_trans_ph trans_ph,
2569 u32 in_pport, u32 in_pport_mask, 2569 u32 in_pport, u32 in_pport_mask,
2570 __be16 eth_type, const u8 *eth_dst, 2570 __be16 eth_type, const u8 *eth_dst,
2571 const u8 *eth_dst_mask, __be16 vlan_id, 2571 const u8 *eth_dst_mask, __be16 vlan_id,
@@ -2574,7 +2574,7 @@ static int rocker_flow_tbl_term_mac(struct rocker_port *rocker_port,
2574{ 2574{
2575 struct rocker_flow_tbl_entry *entry; 2575 struct rocker_flow_tbl_entry *entry;
2576 2576
2577 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2577 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2578 if (!entry) 2578 if (!entry)
2579 return -ENOMEM; 2579 return -ENOMEM;
2580 2580
@@ -2598,11 +2598,11 @@ static int rocker_flow_tbl_term_mac(struct rocker_port *rocker_port,
2598 entry->key.term_mac.vlan_id_mask = vlan_id_mask; 2598 entry->key.term_mac.vlan_id_mask = vlan_id_mask;
2599 entry->key.term_mac.copy_to_cpu = copy_to_cpu; 2599 entry->key.term_mac.copy_to_cpu = copy_to_cpu;
2600 2600
2601 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2601 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2602} 2602}
2603 2603
2604static int rocker_flow_tbl_bridge(struct rocker_port *rocker_port, 2604static int rocker_flow_tbl_bridge(struct rocker_port *rocker_port,
2605 enum switchdev_trans trans, int flags, 2605 enum switchdev_trans_ph trans_ph, int flags,
2606 const u8 *eth_dst, const u8 *eth_dst_mask, 2606 const u8 *eth_dst, const u8 *eth_dst_mask,
2607 __be16 vlan_id, u32 tunnel_id, 2607 __be16 vlan_id, u32 tunnel_id,
2608 enum rocker_of_dpa_table_id goto_tbl, 2608 enum rocker_of_dpa_table_id goto_tbl,
@@ -2614,7 +2614,7 @@ static int rocker_flow_tbl_bridge(struct rocker_port *rocker_port,
2614 bool dflt = !eth_dst || (eth_dst && eth_dst_mask); 2614 bool dflt = !eth_dst || (eth_dst && eth_dst_mask);
2615 bool wild = false; 2615 bool wild = false;
2616 2616
2617 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2617 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2618 if (!entry) 2618 if (!entry)
2619 return -ENOMEM; 2619 return -ENOMEM;
2620 2620
@@ -2652,11 +2652,11 @@ static int rocker_flow_tbl_bridge(struct rocker_port *rocker_port,
2652 entry->key.bridge.group_id = group_id; 2652 entry->key.bridge.group_id = group_id;
2653 entry->key.bridge.copy_to_cpu = copy_to_cpu; 2653 entry->key.bridge.copy_to_cpu = copy_to_cpu;
2654 2654
2655 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2655 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2656} 2656}
2657 2657
2658static int rocker_flow_tbl_ucast4_routing(struct rocker_port *rocker_port, 2658static int rocker_flow_tbl_ucast4_routing(struct rocker_port *rocker_port,
2659 enum switchdev_trans trans, 2659 enum switchdev_trans_ph trans_ph,
2660 __be16 eth_type, __be32 dst, 2660 __be16 eth_type, __be32 dst,
2661 __be32 dst_mask, u32 priority, 2661 __be32 dst_mask, u32 priority,
2662 enum rocker_of_dpa_table_id goto_tbl, 2662 enum rocker_of_dpa_table_id goto_tbl,
@@ -2664,7 +2664,7 @@ static int rocker_flow_tbl_ucast4_routing(struct rocker_port *rocker_port,
2664{ 2664{
2665 struct rocker_flow_tbl_entry *entry; 2665 struct rocker_flow_tbl_entry *entry;
2666 2666
2667 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2667 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2668 if (!entry) 2668 if (!entry)
2669 return -ENOMEM; 2669 return -ENOMEM;
2670 2670
@@ -2678,11 +2678,11 @@ static int rocker_flow_tbl_ucast4_routing(struct rocker_port *rocker_port,
2678 entry->key_len = offsetof(struct rocker_flow_tbl_key, 2678 entry->key_len = offsetof(struct rocker_flow_tbl_key,
2679 ucast_routing.group_id); 2679 ucast_routing.group_id);
2680 2680
2681 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2681 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2682} 2682}
2683 2683
2684static int rocker_flow_tbl_acl(struct rocker_port *rocker_port, 2684static int rocker_flow_tbl_acl(struct rocker_port *rocker_port,
2685 enum switchdev_trans trans, int flags, 2685 enum switchdev_trans_ph trans_ph, int flags,
2686 u32 in_pport, u32 in_pport_mask, 2686 u32 in_pport, u32 in_pport_mask,
2687 const u8 *eth_src, const u8 *eth_src_mask, 2687 const u8 *eth_src, const u8 *eth_src_mask,
2688 const u8 *eth_dst, const u8 *eth_dst_mask, 2688 const u8 *eth_dst, const u8 *eth_dst_mask,
@@ -2694,7 +2694,7 @@ static int rocker_flow_tbl_acl(struct rocker_port *rocker_port,
2694 u32 priority; 2694 u32 priority;
2695 struct rocker_flow_tbl_entry *entry; 2695 struct rocker_flow_tbl_entry *entry;
2696 2696
2697 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2697 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2698 if (!entry) 2698 if (!entry)
2699 return -ENOMEM; 2699 return -ENOMEM;
2700 2700
@@ -2729,7 +2729,7 @@ static int rocker_flow_tbl_acl(struct rocker_port *rocker_port,
2729 entry->key.acl.ip_tos_mask = ip_tos_mask; 2729 entry->key.acl.ip_tos_mask = ip_tos_mask;
2730 entry->key.acl.group_id = group_id; 2730 entry->key.acl.group_id = group_id;
2731 2731
2732 return rocker_flow_tbl_do(rocker_port, trans, flags, entry); 2732 return rocker_flow_tbl_do(rocker_port, trans_ph, flags, entry);
2733} 2733}
2734 2734
2735static struct rocker_group_tbl_entry * 2735static struct rocker_group_tbl_entry *
@@ -2747,22 +2747,22 @@ rocker_group_tbl_find(const struct rocker *rocker,
2747 return NULL; 2747 return NULL;
2748} 2748}
2749 2749
2750static void rocker_group_tbl_entry_free(enum switchdev_trans trans, 2750static void rocker_group_tbl_entry_free(enum switchdev_trans_ph trans_ph,
2751 struct rocker_group_tbl_entry *entry) 2751 struct rocker_group_tbl_entry *entry)
2752{ 2752{
2753 switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) { 2753 switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) {
2754 case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD: 2754 case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
2755 case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST: 2755 case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
2756 rocker_port_kfree(trans, entry->group_ids); 2756 rocker_port_kfree(trans_ph, entry->group_ids);
2757 break; 2757 break;
2758 default: 2758 default:
2759 break; 2759 break;
2760 } 2760 }
2761 rocker_port_kfree(trans, entry); 2761 rocker_port_kfree(trans_ph, entry);
2762} 2762}
2763 2763
2764static int rocker_group_tbl_add(struct rocker_port *rocker_port, 2764static int rocker_group_tbl_add(struct rocker_port *rocker_port,
2765 enum switchdev_trans trans, int flags, 2765 enum switchdev_trans_ph trans_ph, int flags,
2766 struct rocker_group_tbl_entry *match) 2766 struct rocker_group_tbl_entry *match)
2767{ 2767{
2768 struct rocker *rocker = rocker_port->rocker; 2768 struct rocker *rocker = rocker_port->rocker;
@@ -2774,9 +2774,9 @@ static int rocker_group_tbl_add(struct rocker_port *rocker_port,
2774 found = rocker_group_tbl_find(rocker, match); 2774 found = rocker_group_tbl_find(rocker, match);
2775 2775
2776 if (found) { 2776 if (found) {
2777 if (trans != SWITCHDEV_TRANS_PREPARE) 2777 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2778 hash_del(&found->entry); 2778 hash_del(&found->entry);
2779 rocker_group_tbl_entry_free(trans, found); 2779 rocker_group_tbl_entry_free(trans_ph, found);
2780 found = match; 2780 found = match;
2781 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD; 2781 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD;
2782 } else { 2782 } else {
@@ -2784,17 +2784,17 @@ static int rocker_group_tbl_add(struct rocker_port *rocker_port,
2784 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD; 2784 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD;
2785 } 2785 }
2786 2786
2787 if (trans != SWITCHDEV_TRANS_PREPARE) 2787 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2788 hash_add(rocker->group_tbl, &found->entry, found->group_id); 2788 hash_add(rocker->group_tbl, &found->entry, found->group_id);
2789 2789
2790 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags); 2790 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags);
2791 2791
2792 return rocker_cmd_exec(rocker_port, trans, flags, 2792 return rocker_cmd_exec(rocker_port, trans_ph, flags,
2793 rocker_cmd_group_tbl_add, found, NULL, NULL); 2793 rocker_cmd_group_tbl_add, found, NULL, NULL);
2794} 2794}
2795 2795
2796static int rocker_group_tbl_del(struct rocker_port *rocker_port, 2796static int rocker_group_tbl_del(struct rocker_port *rocker_port,
2797 enum switchdev_trans trans, int flags, 2797 enum switchdev_trans_ph trans_ph, int flags,
2798 struct rocker_group_tbl_entry *match) 2798 struct rocker_group_tbl_entry *match)
2799{ 2799{
2800 struct rocker *rocker = rocker_port->rocker; 2800 struct rocker *rocker = rocker_port->rocker;
@@ -2807,95 +2807,95 @@ static int rocker_group_tbl_del(struct rocker_port *rocker_port,
2807 found = rocker_group_tbl_find(rocker, match); 2807 found = rocker_group_tbl_find(rocker, match);
2808 2808
2809 if (found) { 2809 if (found) {
2810 if (trans != SWITCHDEV_TRANS_PREPARE) 2810 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
2811 hash_del(&found->entry); 2811 hash_del(&found->entry);
2812 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL; 2812 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL;
2813 } 2813 }
2814 2814
2815 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags); 2815 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags);
2816 2816
2817 rocker_group_tbl_entry_free(trans, match); 2817 rocker_group_tbl_entry_free(trans_ph, match);
2818 2818
2819 if (found) { 2819 if (found) {
2820 err = rocker_cmd_exec(rocker_port, trans, flags, 2820 err = rocker_cmd_exec(rocker_port, trans_ph, flags,
2821 rocker_cmd_group_tbl_del, 2821 rocker_cmd_group_tbl_del,
2822 found, NULL, NULL); 2822 found, NULL, NULL);
2823 rocker_group_tbl_entry_free(trans, found); 2823 rocker_group_tbl_entry_free(trans_ph, found);
2824 } 2824 }
2825 2825
2826 return err; 2826 return err;
2827} 2827}
2828 2828
2829static int rocker_group_tbl_do(struct rocker_port *rocker_port, 2829static int rocker_group_tbl_do(struct rocker_port *rocker_port,
2830 enum switchdev_trans trans, int flags, 2830 enum switchdev_trans_ph trans_ph, int flags,
2831 struct rocker_group_tbl_entry *entry) 2831 struct rocker_group_tbl_entry *entry)
2832{ 2832{
2833 if (flags & ROCKER_OP_FLAG_REMOVE) 2833 if (flags & ROCKER_OP_FLAG_REMOVE)
2834 return rocker_group_tbl_del(rocker_port, trans, flags, entry); 2834 return rocker_group_tbl_del(rocker_port, trans_ph, flags, entry);
2835 else 2835 else
2836 return rocker_group_tbl_add(rocker_port, trans, flags, entry); 2836 return rocker_group_tbl_add(rocker_port, trans_ph, flags, entry);
2837} 2837}
2838 2838
2839static int rocker_group_l2_interface(struct rocker_port *rocker_port, 2839static int rocker_group_l2_interface(struct rocker_port *rocker_port,
2840 enum switchdev_trans trans, int flags, 2840 enum switchdev_trans_ph trans_ph, int flags,
2841 __be16 vlan_id, u32 out_pport, 2841 __be16 vlan_id, u32 out_pport,
2842 int pop_vlan) 2842 int pop_vlan)
2843{ 2843{
2844 struct rocker_group_tbl_entry *entry; 2844 struct rocker_group_tbl_entry *entry;
2845 2845
2846 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2846 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2847 if (!entry) 2847 if (!entry)
2848 return -ENOMEM; 2848 return -ENOMEM;
2849 2849
2850 entry->group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport); 2850 entry->group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
2851 entry->l2_interface.pop_vlan = pop_vlan; 2851 entry->l2_interface.pop_vlan = pop_vlan;
2852 2852
2853 return rocker_group_tbl_do(rocker_port, trans, flags, entry); 2853 return rocker_group_tbl_do(rocker_port, trans_ph, flags, entry);
2854} 2854}
2855 2855
2856static int rocker_group_l2_fan_out(struct rocker_port *rocker_port, 2856static int rocker_group_l2_fan_out(struct rocker_port *rocker_port,
2857 enum switchdev_trans trans, 2857 enum switchdev_trans_ph trans_ph,
2858 int flags, u8 group_count, 2858 int flags, u8 group_count,
2859 const u32 *group_ids, u32 group_id) 2859 const u32 *group_ids, u32 group_id)
2860{ 2860{
2861 struct rocker_group_tbl_entry *entry; 2861 struct rocker_group_tbl_entry *entry;
2862 2862
2863 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2863 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2864 if (!entry) 2864 if (!entry)
2865 return -ENOMEM; 2865 return -ENOMEM;
2866 2866
2867 entry->group_id = group_id; 2867 entry->group_id = group_id;
2868 entry->group_count = group_count; 2868 entry->group_count = group_count;
2869 2869
2870 entry->group_ids = rocker_port_kcalloc(rocker_port, trans, flags, 2870 entry->group_ids = rocker_port_kcalloc(rocker_port, trans_ph, flags,
2871 group_count, sizeof(u32)); 2871 group_count, sizeof(u32));
2872 if (!entry->group_ids) { 2872 if (!entry->group_ids) {
2873 rocker_port_kfree(trans, entry); 2873 rocker_port_kfree(trans_ph, entry);
2874 return -ENOMEM; 2874 return -ENOMEM;
2875 } 2875 }
2876 memcpy(entry->group_ids, group_ids, group_count * sizeof(u32)); 2876 memcpy(entry->group_ids, group_ids, group_count * sizeof(u32));
2877 2877
2878 return rocker_group_tbl_do(rocker_port, trans, flags, entry); 2878 return rocker_group_tbl_do(rocker_port, trans_ph, flags, entry);
2879} 2879}
2880 2880
2881static int rocker_group_l2_flood(struct rocker_port *rocker_port, 2881static int rocker_group_l2_flood(struct rocker_port *rocker_port,
2882 enum switchdev_trans trans, int flags, 2882 enum switchdev_trans_ph trans_ph, int flags,
2883 __be16 vlan_id, u8 group_count, 2883 __be16 vlan_id, u8 group_count,
2884 const u32 *group_ids, u32 group_id) 2884 const u32 *group_ids, u32 group_id)
2885{ 2885{
2886 return rocker_group_l2_fan_out(rocker_port, trans, flags, 2886 return rocker_group_l2_fan_out(rocker_port, trans_ph, flags,
2887 group_count, group_ids, 2887 group_count, group_ids,
2888 group_id); 2888 group_id);
2889} 2889}
2890 2890
2891static int rocker_group_l3_unicast(struct rocker_port *rocker_port, 2891static int rocker_group_l3_unicast(struct rocker_port *rocker_port,
2892 enum switchdev_trans trans, int flags, 2892 enum switchdev_trans_ph trans_ph, int flags,
2893 u32 index, const u8 *src_mac, const u8 *dst_mac, 2893 u32 index, const u8 *src_mac, const u8 *dst_mac,
2894 __be16 vlan_id, bool ttl_check, u32 pport) 2894 __be16 vlan_id, bool ttl_check, u32 pport)
2895{ 2895{
2896 struct rocker_group_tbl_entry *entry; 2896 struct rocker_group_tbl_entry *entry;
2897 2897
2898 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2898 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2899 if (!entry) 2899 if (!entry)
2900 return -ENOMEM; 2900 return -ENOMEM;
2901 2901
@@ -2908,7 +2908,7 @@ static int rocker_group_l3_unicast(struct rocker_port *rocker_port,
2908 entry->l3_unicast.ttl_check = ttl_check; 2908 entry->l3_unicast.ttl_check = ttl_check;
2909 entry->l3_unicast.group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, pport); 2909 entry->l3_unicast.group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, pport);
2910 2910
2911 return rocker_group_tbl_do(rocker_port, trans, flags, entry); 2911 return rocker_group_tbl_do(rocker_port, trans_ph, flags, entry);
2912} 2912}
2913 2913
2914static struct rocker_neigh_tbl_entry * 2914static struct rocker_neigh_tbl_entry *
@@ -2925,43 +2925,43 @@ rocker_neigh_tbl_find(const struct rocker *rocker, __be32 ip_addr)
2925} 2925}
2926 2926
2927static void _rocker_neigh_add(struct rocker *rocker, 2927static void _rocker_neigh_add(struct rocker *rocker,
2928 enum switchdev_trans trans, 2928 enum switchdev_trans_ph trans_ph,
2929 struct rocker_neigh_tbl_entry *entry) 2929 struct rocker_neigh_tbl_entry *entry)
2930{ 2930{
2931 if (trans != SWITCHDEV_TRANS_COMMIT) 2931 if (trans_ph != SWITCHDEV_TRANS_COMMIT)
2932 entry->index = rocker->neigh_tbl_next_index++; 2932 entry->index = rocker->neigh_tbl_next_index++;
2933 if (trans == SWITCHDEV_TRANS_PREPARE) 2933 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
2934 return; 2934 return;
2935 entry->ref_count++; 2935 entry->ref_count++;
2936 hash_add(rocker->neigh_tbl, &entry->entry, 2936 hash_add(rocker->neigh_tbl, &entry->entry,
2937 be32_to_cpu(entry->ip_addr)); 2937 be32_to_cpu(entry->ip_addr));
2938} 2938}
2939 2939
2940static void _rocker_neigh_del(enum switchdev_trans trans, 2940static void _rocker_neigh_del(enum switchdev_trans_ph trans_ph,
2941 struct rocker_neigh_tbl_entry *entry) 2941 struct rocker_neigh_tbl_entry *entry)
2942{ 2942{
2943 if (trans == SWITCHDEV_TRANS_PREPARE) 2943 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
2944 return; 2944 return;
2945 if (--entry->ref_count == 0) { 2945 if (--entry->ref_count == 0) {
2946 hash_del(&entry->entry); 2946 hash_del(&entry->entry);
2947 rocker_port_kfree(trans, entry); 2947 rocker_port_kfree(trans_ph, entry);
2948 } 2948 }
2949} 2949}
2950 2950
2951static void _rocker_neigh_update(struct rocker_neigh_tbl_entry *entry, 2951static void _rocker_neigh_update(struct rocker_neigh_tbl_entry *entry,
2952 enum switchdev_trans trans, 2952 enum switchdev_trans_ph trans_ph,
2953 const u8 *eth_dst, bool ttl_check) 2953 const u8 *eth_dst, bool ttl_check)
2954{ 2954{
2955 if (eth_dst) { 2955 if (eth_dst) {
2956 ether_addr_copy(entry->eth_dst, eth_dst); 2956 ether_addr_copy(entry->eth_dst, eth_dst);
2957 entry->ttl_check = ttl_check; 2957 entry->ttl_check = ttl_check;
2958 } else if (trans != SWITCHDEV_TRANS_PREPARE) { 2958 } else if (trans_ph != SWITCHDEV_TRANS_PREPARE) {
2959 entry->ref_count++; 2959 entry->ref_count++;
2960 } 2960 }
2961} 2961}
2962 2962
2963static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port, 2963static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
2964 enum switchdev_trans trans, 2964 enum switchdev_trans_ph trans_ph,
2965 int flags, __be32 ip_addr, const u8 *eth_dst) 2965 int flags, __be32 ip_addr, const u8 *eth_dst)
2966{ 2966{
2967 struct rocker *rocker = rocker_port->rocker; 2967 struct rocker *rocker = rocker_port->rocker;
@@ -2978,7 +2978,7 @@ static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
2978 bool removing; 2978 bool removing;
2979 int err = 0; 2979 int err = 0;
2980 2980
2981 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 2981 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
2982 if (!entry) 2982 if (!entry)
2983 return -ENOMEM; 2983 return -ENOMEM;
2984 2984
@@ -2995,12 +2995,12 @@ static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
2995 entry->dev = rocker_port->dev; 2995 entry->dev = rocker_port->dev;
2996 ether_addr_copy(entry->eth_dst, eth_dst); 2996 ether_addr_copy(entry->eth_dst, eth_dst);
2997 entry->ttl_check = true; 2997 entry->ttl_check = true;
2998 _rocker_neigh_add(rocker, trans, entry); 2998 _rocker_neigh_add(rocker, trans_ph, entry);
2999 } else if (removing) { 2999 } else if (removing) {
3000 memcpy(entry, found, sizeof(*entry)); 3000 memcpy(entry, found, sizeof(*entry));
3001 _rocker_neigh_del(trans, found); 3001 _rocker_neigh_del(trans_ph, found);
3002 } else if (updating) { 3002 } else if (updating) {
3003 _rocker_neigh_update(found, trans, eth_dst, true); 3003 _rocker_neigh_update(found, trans_ph, eth_dst, true);
3004 memcpy(entry, found, sizeof(*entry)); 3004 memcpy(entry, found, sizeof(*entry));
3005 } else { 3005 } else {
3006 err = -ENOENT; 3006 err = -ENOENT;
@@ -3017,7 +3017,7 @@ static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
3017 * other routes' nexthops. 3017 * other routes' nexthops.
3018 */ 3018 */
3019 3019
3020 err = rocker_group_l3_unicast(rocker_port, trans, flags, 3020 err = rocker_group_l3_unicast(rocker_port, trans_ph, flags,
3021 entry->index, 3021 entry->index,
3022 rocker_port->dev->dev_addr, 3022 rocker_port->dev->dev_addr,
3023 entry->eth_dst, 3023 entry->eth_dst,
@@ -3033,7 +3033,7 @@ static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
3033 3033
3034 if (adding || removing) { 3034 if (adding || removing) {
3035 group_id = ROCKER_GROUP_L3_UNICAST(entry->index); 3035 group_id = ROCKER_GROUP_L3_UNICAST(entry->index);
3036 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans, 3036 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans_ph,
3037 eth_type, ip_addr, 3037 eth_type, ip_addr,
3038 inet_make_mask(32), 3038 inet_make_mask(32),
3039 priority, goto_tbl, 3039 priority, goto_tbl,
@@ -3047,13 +3047,13 @@ static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
3047 3047
3048err_out: 3048err_out:
3049 if (!adding) 3049 if (!adding)
3050 rocker_port_kfree(trans, entry); 3050 rocker_port_kfree(trans_ph, entry);
3051 3051
3052 return err; 3052 return err;
3053} 3053}
3054 3054
3055static int rocker_port_ipv4_resolve(struct rocker_port *rocker_port, 3055static int rocker_port_ipv4_resolve(struct rocker_port *rocker_port,
3056 enum switchdev_trans trans, __be32 ip_addr) 3056 enum switchdev_trans_ph trans_ph, __be32 ip_addr)
3057{ 3057{
3058 struct net_device *dev = rocker_port->dev; 3058 struct net_device *dev = rocker_port->dev;
3059 struct neighbour *n = __ipv4_neigh_lookup(dev, (__force u32)ip_addr); 3059 struct neighbour *n = __ipv4_neigh_lookup(dev, (__force u32)ip_addr);
@@ -3071,7 +3071,7 @@ static int rocker_port_ipv4_resolve(struct rocker_port *rocker_port,
3071 */ 3071 */
3072 3072
3073 if (n->nud_state & NUD_VALID) 3073 if (n->nud_state & NUD_VALID)
3074 err = rocker_port_ipv4_neigh(rocker_port, trans, 0, 3074 err = rocker_port_ipv4_neigh(rocker_port, trans_ph, 0,
3075 ip_addr, n->ha); 3075 ip_addr, n->ha);
3076 else 3076 else
3077 neigh_event_send(n, NULL); 3077 neigh_event_send(n, NULL);
@@ -3081,7 +3081,7 @@ static int rocker_port_ipv4_resolve(struct rocker_port *rocker_port,
3081} 3081}
3082 3082
3083static int rocker_port_ipv4_nh(struct rocker_port *rocker_port, 3083static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3084 enum switchdev_trans trans, int flags, 3084 enum switchdev_trans_ph trans_ph, int flags,
3085 __be32 ip_addr, u32 *index) 3085 __be32 ip_addr, u32 *index)
3086{ 3086{
3087 struct rocker *rocker = rocker_port->rocker; 3087 struct rocker *rocker = rocker_port->rocker;
@@ -3094,7 +3094,7 @@ static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3094 bool resolved = true; 3094 bool resolved = true;
3095 int err = 0; 3095 int err = 0;
3096 3096
3097 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry)); 3097 entry = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*entry));
3098 if (!entry) 3098 if (!entry)
3099 return -ENOMEM; 3099 return -ENOMEM;
3100 3100
@@ -3111,13 +3111,13 @@ static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3111 if (adding) { 3111 if (adding) {
3112 entry->ip_addr = ip_addr; 3112 entry->ip_addr = ip_addr;
3113 entry->dev = rocker_port->dev; 3113 entry->dev = rocker_port->dev;
3114 _rocker_neigh_add(rocker, trans, entry); 3114 _rocker_neigh_add(rocker, trans_ph, entry);
3115 *index = entry->index; 3115 *index = entry->index;
3116 resolved = false; 3116 resolved = false;
3117 } else if (removing) { 3117 } else if (removing) {
3118 _rocker_neigh_del(trans, found); 3118 _rocker_neigh_del(trans_ph, found);
3119 } else if (updating) { 3119 } else if (updating) {
3120 _rocker_neigh_update(found, trans, NULL, false); 3120 _rocker_neigh_update(found, trans_ph, NULL, false);
3121 resolved = !is_zero_ether_addr(found->eth_dst); 3121 resolved = !is_zero_ether_addr(found->eth_dst);
3122 } else { 3122 } else {
3123 err = -ENOENT; 3123 err = -ENOENT;
@@ -3126,7 +3126,7 @@ static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3126 spin_unlock_irqrestore(&rocker->neigh_tbl_lock, lock_flags); 3126 spin_unlock_irqrestore(&rocker->neigh_tbl_lock, lock_flags);
3127 3127
3128 if (!adding) 3128 if (!adding)
3129 rocker_port_kfree(trans, entry); 3129 rocker_port_kfree(trans_ph, entry);
3130 3130
3131 if (err) 3131 if (err)
3132 return err; 3132 return err;
@@ -3134,13 +3134,13 @@ static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3134 /* Resolved means neigh ip_addr is resolved to neigh mac. */ 3134 /* Resolved means neigh ip_addr is resolved to neigh mac. */
3135 3135
3136 if (!resolved) 3136 if (!resolved)
3137 err = rocker_port_ipv4_resolve(rocker_port, trans, ip_addr); 3137 err = rocker_port_ipv4_resolve(rocker_port, trans_ph, ip_addr);
3138 3138
3139 return err; 3139 return err;
3140} 3140}
3141 3141
3142static int rocker_port_vlan_flood_group(struct rocker_port *rocker_port, 3142static int rocker_port_vlan_flood_group(struct rocker_port *rocker_port,
3143 enum switchdev_trans trans, 3143 enum switchdev_trans_ph trans_ph,
3144 int flags, __be16 vlan_id) 3144 int flags, __be16 vlan_id)
3145{ 3145{
3146 struct rocker_port *p; 3146 struct rocker_port *p;
@@ -3151,7 +3151,7 @@ static int rocker_port_vlan_flood_group(struct rocker_port *rocker_port,
3151 int err = 0; 3151 int err = 0;
3152 int i; 3152 int i;
3153 3153
3154 group_ids = rocker_port_kcalloc(rocker_port, trans, flags, 3154 group_ids = rocker_port_kcalloc(rocker_port, trans_ph, flags,
3155 rocker->port_count, sizeof(u32)); 3155 rocker->port_count, sizeof(u32));
3156 if (!group_ids) 3156 if (!group_ids)
3157 return -ENOMEM; 3157 return -ENOMEM;
@@ -3177,19 +3177,19 @@ static int rocker_port_vlan_flood_group(struct rocker_port *rocker_port,
3177 if (group_count == 0) 3177 if (group_count == 0)
3178 goto no_ports_in_vlan; 3178 goto no_ports_in_vlan;
3179 3179
3180 err = rocker_group_l2_flood(rocker_port, trans, flags, vlan_id, 3180 err = rocker_group_l2_flood(rocker_port, trans_ph, flags, vlan_id,
3181 group_count, group_ids, group_id); 3181 group_count, group_ids, group_id);
3182 if (err) 3182 if (err)
3183 netdev_err(rocker_port->dev, 3183 netdev_err(rocker_port->dev,
3184 "Error (%d) port VLAN l2 flood group\n", err); 3184 "Error (%d) port VLAN l2 flood group\n", err);
3185 3185
3186no_ports_in_vlan: 3186no_ports_in_vlan:
3187 rocker_port_kfree(trans, group_ids); 3187 rocker_port_kfree(trans_ph, group_ids);
3188 return err; 3188 return err;
3189} 3189}
3190 3190
3191static int rocker_port_vlan_l2_groups(struct rocker_port *rocker_port, 3191static int rocker_port_vlan_l2_groups(struct rocker_port *rocker_port,
3192 enum switchdev_trans trans, int flags, 3192 enum switchdev_trans_ph trans_ph, int flags,
3193 __be16 vlan_id, bool pop_vlan) 3193 __be16 vlan_id, bool pop_vlan)
3194{ 3194{
3195 const struct rocker *rocker = rocker_port->rocker; 3195 const struct rocker *rocker = rocker_port->rocker;
@@ -3207,7 +3207,7 @@ static int rocker_port_vlan_l2_groups(struct rocker_port *rocker_port,
3207 if (rocker_port->stp_state == BR_STATE_LEARNING || 3207 if (rocker_port->stp_state == BR_STATE_LEARNING ||
3208 rocker_port->stp_state == BR_STATE_FORWARDING) { 3208 rocker_port->stp_state == BR_STATE_FORWARDING) {
3209 out_pport = rocker_port->pport; 3209 out_pport = rocker_port->pport;
3210 err = rocker_group_l2_interface(rocker_port, trans, flags, 3210 err = rocker_group_l2_interface(rocker_port, trans_ph, flags,
3211 vlan_id, out_pport, pop_vlan); 3211 vlan_id, out_pport, pop_vlan);
3212 if (err) { 3212 if (err) {
3213 netdev_err(rocker_port->dev, 3213 netdev_err(rocker_port->dev,
@@ -3232,7 +3232,7 @@ static int rocker_port_vlan_l2_groups(struct rocker_port *rocker_port,
3232 return 0; 3232 return 0;
3233 3233
3234 out_pport = 0; 3234 out_pport = 0;
3235 err = rocker_group_l2_interface(rocker_port, trans, flags, 3235 err = rocker_group_l2_interface(rocker_port, trans_ph, flags,
3236 vlan_id, out_pport, pop_vlan); 3236 vlan_id, out_pport, pop_vlan);
3237 if (err) { 3237 if (err) {
3238 netdev_err(rocker_port->dev, 3238 netdev_err(rocker_port->dev,
@@ -3295,7 +3295,7 @@ static struct rocker_ctrl {
3295}; 3295};
3296 3296
3297static int rocker_port_ctrl_vlan_acl(struct rocker_port *rocker_port, 3297static int rocker_port_ctrl_vlan_acl(struct rocker_port *rocker_port,
3298 enum switchdev_trans trans, int flags, 3298 enum switchdev_trans_ph trans_ph, int flags,
3299 const struct rocker_ctrl *ctrl, __be16 vlan_id) 3299 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3300{ 3300{
3301 u32 in_pport = rocker_port->pport; 3301 u32 in_pport = rocker_port->pport;
@@ -3311,7 +3311,7 @@ static int rocker_port_ctrl_vlan_acl(struct rocker_port *rocker_port,
3311 u32 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport); 3311 u32 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
3312 int err; 3312 int err;
3313 3313
3314 err = rocker_flow_tbl_acl(rocker_port, trans, flags, 3314 err = rocker_flow_tbl_acl(rocker_port, trans_ph, flags,
3315 in_pport, in_pport_mask, 3315 in_pport, in_pport_mask,
3316 eth_src, eth_src_mask, 3316 eth_src, eth_src_mask,
3317 ctrl->eth_dst, ctrl->eth_dst_mask, 3317 ctrl->eth_dst, ctrl->eth_dst_mask,
@@ -3328,7 +3328,7 @@ static int rocker_port_ctrl_vlan_acl(struct rocker_port *rocker_port,
3328} 3328}
3329 3329
3330static int rocker_port_ctrl_vlan_bridge(struct rocker_port *rocker_port, 3330static int rocker_port_ctrl_vlan_bridge(struct rocker_port *rocker_port,
3331 enum switchdev_trans trans, int flags, 3331 enum switchdev_trans_ph trans_ph, int flags,
3332 const struct rocker_ctrl *ctrl, 3332 const struct rocker_ctrl *ctrl,
3333 __be16 vlan_id) 3333 __be16 vlan_id)
3334{ 3334{
@@ -3341,7 +3341,7 @@ static int rocker_port_ctrl_vlan_bridge(struct rocker_port *rocker_port,
3341 if (!rocker_port_is_bridged(rocker_port)) 3341 if (!rocker_port_is_bridged(rocker_port))
3342 return 0; 3342 return 0;
3343 3343
3344 err = rocker_flow_tbl_bridge(rocker_port, trans, flags, 3344 err = rocker_flow_tbl_bridge(rocker_port, trans_ph, flags,
3345 ctrl->eth_dst, ctrl->eth_dst_mask, 3345 ctrl->eth_dst, ctrl->eth_dst_mask,
3346 vlan_id, tunnel_id, 3346 vlan_id, tunnel_id,
3347 goto_tbl, group_id, ctrl->copy_to_cpu); 3347 goto_tbl, group_id, ctrl->copy_to_cpu);
@@ -3353,7 +3353,7 @@ static int rocker_port_ctrl_vlan_bridge(struct rocker_port *rocker_port,
3353} 3353}
3354 3354
3355static int rocker_port_ctrl_vlan_term(struct rocker_port *rocker_port, 3355static int rocker_port_ctrl_vlan_term(struct rocker_port *rocker_port,
3356 enum switchdev_trans trans, int flags, 3356 enum switchdev_trans_ph trans_ph, int flags,
3357 const struct rocker_ctrl *ctrl, __be16 vlan_id) 3357 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3358{ 3358{
3359 u32 in_pport_mask = 0xffffffff; 3359 u32 in_pport_mask = 0xffffffff;
@@ -3363,7 +3363,7 @@ static int rocker_port_ctrl_vlan_term(struct rocker_port *rocker_port,
3363 if (ntohs(vlan_id) == 0) 3363 if (ntohs(vlan_id) == 0)
3364 vlan_id = rocker_port->internal_vlan_id; 3364 vlan_id = rocker_port->internal_vlan_id;
3365 3365
3366 err = rocker_flow_tbl_term_mac(rocker_port, trans, 3366 err = rocker_flow_tbl_term_mac(rocker_port, trans_ph,
3367 rocker_port->pport, in_pport_mask, 3367 rocker_port->pport, in_pport_mask,
3368 ctrl->eth_type, ctrl->eth_dst, 3368 ctrl->eth_type, ctrl->eth_dst,
3369 ctrl->eth_dst_mask, vlan_id, 3369 ctrl->eth_dst_mask, vlan_id,
@@ -3377,25 +3377,25 @@ static int rocker_port_ctrl_vlan_term(struct rocker_port *rocker_port,
3377} 3377}
3378 3378
3379static int rocker_port_ctrl_vlan(struct rocker_port *rocker_port, 3379static int rocker_port_ctrl_vlan(struct rocker_port *rocker_port,
3380 enum switchdev_trans trans, int flags, 3380 enum switchdev_trans_ph trans_ph, int flags,
3381 const struct rocker_ctrl *ctrl, __be16 vlan_id) 3381 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3382{ 3382{
3383 if (ctrl->acl) 3383 if (ctrl->acl)
3384 return rocker_port_ctrl_vlan_acl(rocker_port, trans, flags, 3384 return rocker_port_ctrl_vlan_acl(rocker_port, trans_ph, flags,
3385 ctrl, vlan_id); 3385 ctrl, vlan_id);
3386 if (ctrl->bridge) 3386 if (ctrl->bridge)
3387 return rocker_port_ctrl_vlan_bridge(rocker_port, trans, flags, 3387 return rocker_port_ctrl_vlan_bridge(rocker_port, trans_ph, flags,
3388 ctrl, vlan_id); 3388 ctrl, vlan_id);
3389 3389
3390 if (ctrl->term) 3390 if (ctrl->term)
3391 return rocker_port_ctrl_vlan_term(rocker_port, trans, flags, 3391 return rocker_port_ctrl_vlan_term(rocker_port, trans_ph, flags,
3392 ctrl, vlan_id); 3392 ctrl, vlan_id);
3393 3393
3394 return -EOPNOTSUPP; 3394 return -EOPNOTSUPP;
3395} 3395}
3396 3396
3397static int rocker_port_ctrl_vlan_add(struct rocker_port *rocker_port, 3397static int rocker_port_ctrl_vlan_add(struct rocker_port *rocker_port,
3398 enum switchdev_trans trans, int flags, 3398 enum switchdev_trans_ph trans_ph, int flags,
3399 __be16 vlan_id) 3399 __be16 vlan_id)
3400{ 3400{
3401 int err = 0; 3401 int err = 0;
@@ -3403,7 +3403,7 @@ static int rocker_port_ctrl_vlan_add(struct rocker_port *rocker_port,
3403 3403
3404 for (i = 0; i < ROCKER_CTRL_MAX; i++) { 3404 for (i = 0; i < ROCKER_CTRL_MAX; i++) {
3405 if (rocker_port->ctrls[i]) { 3405 if (rocker_port->ctrls[i]) {
3406 err = rocker_port_ctrl_vlan(rocker_port, trans, flags, 3406 err = rocker_port_ctrl_vlan(rocker_port, trans_ph, flags,
3407 &rocker_ctrls[i], vlan_id); 3407 &rocker_ctrls[i], vlan_id);
3408 if (err) 3408 if (err)
3409 return err; 3409 return err;
@@ -3414,7 +3414,7 @@ static int rocker_port_ctrl_vlan_add(struct rocker_port *rocker_port,
3414} 3414}
3415 3415
3416static int rocker_port_ctrl(struct rocker_port *rocker_port, 3416static int rocker_port_ctrl(struct rocker_port *rocker_port,
3417 enum switchdev_trans trans, int flags, 3417 enum switchdev_trans_ph trans_ph, int flags,
3418 const struct rocker_ctrl *ctrl) 3418 const struct rocker_ctrl *ctrl)
3419{ 3419{
3420 u16 vid; 3420 u16 vid;
@@ -3423,7 +3423,7 @@ static int rocker_port_ctrl(struct rocker_port *rocker_port,
3423 for (vid = 1; vid < VLAN_N_VID; vid++) { 3423 for (vid = 1; vid < VLAN_N_VID; vid++) {
3424 if (!test_bit(vid, rocker_port->vlan_bitmap)) 3424 if (!test_bit(vid, rocker_port->vlan_bitmap))
3425 continue; 3425 continue;
3426 err = rocker_port_ctrl_vlan(rocker_port, trans, flags, 3426 err = rocker_port_ctrl_vlan(rocker_port, trans_ph, flags,
3427 ctrl, htons(vid)); 3427 ctrl, htons(vid));
3428 if (err) 3428 if (err)
3429 break; 3429 break;
@@ -3433,7 +3433,7 @@ static int rocker_port_ctrl(struct rocker_port *rocker_port,
3433} 3433}
3434 3434
3435static int rocker_port_vlan(struct rocker_port *rocker_port, 3435static int rocker_port_vlan(struct rocker_port *rocker_port,
3436 enum switchdev_trans trans, int flags, u16 vid) 3436 enum switchdev_trans_ph trans_ph, int flags, u16 vid)
3437{ 3437{
3438 enum rocker_of_dpa_table_id goto_tbl = 3438 enum rocker_of_dpa_table_id goto_tbl =
3439 ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC; 3439 ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
@@ -3457,7 +3457,7 @@ static int rocker_port_vlan(struct rocker_port *rocker_port,
3457 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap); 3457 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap);
3458 3458
3459 if (adding) { 3459 if (adding) {
3460 err = rocker_port_ctrl_vlan_add(rocker_port, trans, flags, 3460 err = rocker_port_ctrl_vlan_add(rocker_port, trans_ph, flags,
3461 internal_vlan_id); 3461 internal_vlan_id);
3462 if (err) { 3462 if (err) {
3463 netdev_err(rocker_port->dev, 3463 netdev_err(rocker_port->dev,
@@ -3466,7 +3466,7 @@ static int rocker_port_vlan(struct rocker_port *rocker_port,
3466 } 3466 }
3467 } 3467 }
3468 3468
3469 err = rocker_port_vlan_l2_groups(rocker_port, trans, flags, 3469 err = rocker_port_vlan_l2_groups(rocker_port, trans_ph, flags,
3470 internal_vlan_id, untagged); 3470 internal_vlan_id, untagged);
3471 if (err) { 3471 if (err) {
3472 netdev_err(rocker_port->dev, 3472 netdev_err(rocker_port->dev,
@@ -3474,7 +3474,7 @@ static int rocker_port_vlan(struct rocker_port *rocker_port,
3474 goto err_out; 3474 goto err_out;
3475 } 3475 }
3476 3476
3477 err = rocker_port_vlan_flood_group(rocker_port, trans, flags, 3477 err = rocker_port_vlan_flood_group(rocker_port, trans_ph, flags,
3478 internal_vlan_id); 3478 internal_vlan_id);
3479 if (err) { 3479 if (err) {
3480 netdev_err(rocker_port->dev, 3480 netdev_err(rocker_port->dev,
@@ -3482,7 +3482,7 @@ static int rocker_port_vlan(struct rocker_port *rocker_port,
3482 goto err_out; 3482 goto err_out;
3483 } 3483 }
3484 3484
3485 err = rocker_flow_tbl_vlan(rocker_port, trans, flags, 3485 err = rocker_flow_tbl_vlan(rocker_port, trans_ph, flags,
3486 in_pport, vlan_id, vlan_id_mask, 3486 in_pport, vlan_id, vlan_id_mask,
3487 goto_tbl, untagged, internal_vlan_id); 3487 goto_tbl, untagged, internal_vlan_id);
3488 if (err) 3488 if (err)
@@ -3490,14 +3490,14 @@ static int rocker_port_vlan(struct rocker_port *rocker_port,
3490 "Error (%d) port VLAN table\n", err); 3490 "Error (%d) port VLAN table\n", err);
3491 3491
3492err_out: 3492err_out:
3493 if (trans == SWITCHDEV_TRANS_PREPARE) 3493 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
3494 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap); 3494 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap);
3495 3495
3496 return err; 3496 return err;
3497} 3497}
3498 3498
3499static int rocker_port_ig_tbl(struct rocker_port *rocker_port, 3499static int rocker_port_ig_tbl(struct rocker_port *rocker_port,
3500 enum switchdev_trans trans, int flags) 3500 enum switchdev_trans_ph trans_ph, int flags)
3501{ 3501{
3502 enum rocker_of_dpa_table_id goto_tbl; 3502 enum rocker_of_dpa_table_id goto_tbl;
3503 u32 in_pport; 3503 u32 in_pport;
@@ -3512,7 +3512,7 @@ static int rocker_port_ig_tbl(struct rocker_port *rocker_port,
3512 in_pport_mask = 0xffff0000; 3512 in_pport_mask = 0xffff0000;
3513 goto_tbl = ROCKER_OF_DPA_TABLE_ID_VLAN; 3513 goto_tbl = ROCKER_OF_DPA_TABLE_ID_VLAN;
3514 3514
3515 err = rocker_flow_tbl_ig_port(rocker_port, trans, flags, 3515 err = rocker_flow_tbl_ig_port(rocker_port, trans_ph, flags,
3516 in_pport, in_pport_mask, 3516 in_pport, in_pport_mask,
3517 goto_tbl); 3517 goto_tbl);
3518 if (err) 3518 if (err)
@@ -3525,7 +3525,7 @@ static int rocker_port_ig_tbl(struct rocker_port *rocker_port,
3525struct rocker_fdb_learn_work { 3525struct rocker_fdb_learn_work {
3526 struct work_struct work; 3526 struct work_struct work;
3527 struct rocker_port *rocker_port; 3527 struct rocker_port *rocker_port;
3528 enum switchdev_trans trans; 3528 enum switchdev_trans_ph trans_ph;
3529 int flags; 3529 int flags;
3530 u8 addr[ETH_ALEN]; 3530 u8 addr[ETH_ALEN];
3531 u16 vid; 3531 u16 vid;
@@ -3549,11 +3549,11 @@ static void rocker_port_fdb_learn_work(struct work_struct *work)
3549 call_switchdev_notifiers(SWITCHDEV_FDB_ADD, 3549 call_switchdev_notifiers(SWITCHDEV_FDB_ADD,
3550 lw->rocker_port->dev, &info.info); 3550 lw->rocker_port->dev, &info.info);
3551 3551
3552 rocker_port_kfree(lw->trans, work); 3552 rocker_port_kfree(lw->trans_ph, work);
3553} 3553}
3554 3554
3555static int rocker_port_fdb_learn(struct rocker_port *rocker_port, 3555static int rocker_port_fdb_learn(struct rocker_port *rocker_port,
3556 enum switchdev_trans trans, int flags, 3556 enum switchdev_trans_ph trans_ph, int flags,
3557 const u8 *addr, __be16 vlan_id) 3557 const u8 *addr, __be16 vlan_id)
3558{ 3558{
3559 struct rocker_fdb_learn_work *lw; 3559 struct rocker_fdb_learn_work *lw;
@@ -3570,7 +3570,7 @@ static int rocker_port_fdb_learn(struct rocker_port *rocker_port,
3570 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport); 3570 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
3571 3571
3572 if (!(flags & ROCKER_OP_FLAG_REFRESH)) { 3572 if (!(flags & ROCKER_OP_FLAG_REFRESH)) {
3573 err = rocker_flow_tbl_bridge(rocker_port, trans, flags, addr, 3573 err = rocker_flow_tbl_bridge(rocker_port, trans_ph, flags, addr,
3574 NULL, vlan_id, tunnel_id, goto_tbl, 3574 NULL, vlan_id, tunnel_id, goto_tbl,
3575 group_id, copy_to_cpu); 3575 group_id, copy_to_cpu);
3576 if (err) 3576 if (err)
@@ -3583,20 +3583,20 @@ static int rocker_port_fdb_learn(struct rocker_port *rocker_port,
3583 if (!rocker_port_is_bridged(rocker_port)) 3583 if (!rocker_port_is_bridged(rocker_port))
3584 return 0; 3584 return 0;
3585 3585
3586 lw = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*lw)); 3586 lw = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*lw));
3587 if (!lw) 3587 if (!lw)
3588 return -ENOMEM; 3588 return -ENOMEM;
3589 3589
3590 INIT_WORK(&lw->work, rocker_port_fdb_learn_work); 3590 INIT_WORK(&lw->work, rocker_port_fdb_learn_work);
3591 3591
3592 lw->rocker_port = rocker_port; 3592 lw->rocker_port = rocker_port;
3593 lw->trans = trans; 3593 lw->trans_ph = trans_ph;
3594 lw->flags = flags; 3594 lw->flags = flags;
3595 ether_addr_copy(lw->addr, addr); 3595 ether_addr_copy(lw->addr, addr);
3596 lw->vid = rocker_port_vlan_to_vid(rocker_port, vlan_id); 3596 lw->vid = rocker_port_vlan_to_vid(rocker_port, vlan_id);
3597 3597
3598 if (trans == SWITCHDEV_TRANS_PREPARE) 3598 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
3599 rocker_port_kfree(trans, lw); 3599 rocker_port_kfree(trans_ph, lw);
3600 else 3600 else
3601 schedule_work(&lw->work); 3601 schedule_work(&lw->work);
3602 3602
@@ -3617,7 +3617,7 @@ rocker_fdb_tbl_find(const struct rocker *rocker,
3617} 3617}
3618 3618
3619static int rocker_port_fdb(struct rocker_port *rocker_port, 3619static int rocker_port_fdb(struct rocker_port *rocker_port,
3620 enum switchdev_trans trans, 3620 enum switchdev_trans_ph trans_ph,
3621 const unsigned char *addr, 3621 const unsigned char *addr,
3622 __be16 vlan_id, int flags) 3622 __be16 vlan_id, int flags)
3623{ 3623{
@@ -3627,7 +3627,7 @@ static int rocker_port_fdb(struct rocker_port *rocker_port,
3627 bool removing = (flags & ROCKER_OP_FLAG_REMOVE); 3627 bool removing = (flags & ROCKER_OP_FLAG_REMOVE);
3628 unsigned long lock_flags; 3628 unsigned long lock_flags;
3629 3629
3630 fdb = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*fdb)); 3630 fdb = rocker_port_kzalloc(rocker_port, trans_ph, flags, sizeof(*fdb));
3631 if (!fdb) 3631 if (!fdb)
3632 return -ENOMEM; 3632 return -ENOMEM;
3633 3633
@@ -3645,12 +3645,12 @@ static int rocker_port_fdb(struct rocker_port *rocker_port,
3645 if (found) { 3645 if (found) {
3646 found->touched = jiffies; 3646 found->touched = jiffies;
3647 if (removing) { 3647 if (removing) {
3648 rocker_port_kfree(trans, fdb); 3648 rocker_port_kfree(trans_ph, fdb);
3649 if (trans != SWITCHDEV_TRANS_PREPARE) 3649 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
3650 hash_del(&found->entry); 3650 hash_del(&found->entry);
3651 } 3651 }
3652 } else if (!removing) { 3652 } else if (!removing) {
3653 if (trans != SWITCHDEV_TRANS_PREPARE) 3653 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
3654 hash_add(rocker->fdb_tbl, &fdb->entry, 3654 hash_add(rocker->fdb_tbl, &fdb->entry,
3655 fdb->key_crc32); 3655 fdb->key_crc32);
3656 } 3656 }
@@ -3659,18 +3659,18 @@ static int rocker_port_fdb(struct rocker_port *rocker_port,
3659 3659
3660 /* Check if adding and already exists, or removing and can't find */ 3660 /* Check if adding and already exists, or removing and can't find */
3661 if (!found != !removing) { 3661 if (!found != !removing) {
3662 rocker_port_kfree(trans, fdb); 3662 rocker_port_kfree(trans_ph, fdb);
3663 if (!found && removing) 3663 if (!found && removing)
3664 return 0; 3664 return 0;
3665 /* Refreshing existing to update aging timers */ 3665 /* Refreshing existing to update aging timers */
3666 flags |= ROCKER_OP_FLAG_REFRESH; 3666 flags |= ROCKER_OP_FLAG_REFRESH;
3667 } 3667 }
3668 3668
3669 return rocker_port_fdb_learn(rocker_port, trans, flags, addr, vlan_id); 3669 return rocker_port_fdb_learn(rocker_port, trans_ph, flags, addr, vlan_id);
3670} 3670}
3671 3671
3672static int rocker_port_fdb_flush(struct rocker_port *rocker_port, 3672static int rocker_port_fdb_flush(struct rocker_port *rocker_port,
3673 enum switchdev_trans trans, int flags) 3673 enum switchdev_trans_ph trans_ph, int flags)
3674{ 3674{
3675 struct rocker *rocker = rocker_port->rocker; 3675 struct rocker *rocker = rocker_port->rocker;
3676 struct rocker_fdb_tbl_entry *found; 3676 struct rocker_fdb_tbl_entry *found;
@@ -3692,12 +3692,12 @@ static int rocker_port_fdb_flush(struct rocker_port *rocker_port,
3692 continue; 3692 continue;
3693 if (!found->learned) 3693 if (!found->learned)
3694 continue; 3694 continue;
3695 err = rocker_port_fdb_learn(rocker_port, trans, flags, 3695 err = rocker_port_fdb_learn(rocker_port, trans_ph, flags,
3696 found->key.addr, 3696 found->key.addr,
3697 found->key.vlan_id); 3697 found->key.vlan_id);
3698 if (err) 3698 if (err)
3699 goto err_out; 3699 goto err_out;
3700 if (trans != SWITCHDEV_TRANS_PREPARE) 3700 if (trans_ph != SWITCHDEV_TRANS_PREPARE)
3701 hash_del(&found->entry); 3701 hash_del(&found->entry);
3702 } 3702 }
3703 3703
@@ -3743,7 +3743,7 @@ static void rocker_fdb_cleanup(unsigned long data)
3743} 3743}
3744 3744
3745static int rocker_port_router_mac(struct rocker_port *rocker_port, 3745static int rocker_port_router_mac(struct rocker_port *rocker_port,
3746 enum switchdev_trans trans, int flags, 3746 enum switchdev_trans_ph trans_ph, int flags,
3747 __be16 vlan_id) 3747 __be16 vlan_id)
3748{ 3748{
3749 u32 in_pport_mask = 0xffffffff; 3749 u32 in_pport_mask = 0xffffffff;
@@ -3757,7 +3757,7 @@ static int rocker_port_router_mac(struct rocker_port *rocker_port,
3757 vlan_id = rocker_port->internal_vlan_id; 3757 vlan_id = rocker_port->internal_vlan_id;
3758 3758
3759 eth_type = htons(ETH_P_IP); 3759 eth_type = htons(ETH_P_IP);
3760 err = rocker_flow_tbl_term_mac(rocker_port, trans, 3760 err = rocker_flow_tbl_term_mac(rocker_port, trans_ph,
3761 rocker_port->pport, in_pport_mask, 3761 rocker_port->pport, in_pport_mask,
3762 eth_type, rocker_port->dev->dev_addr, 3762 eth_type, rocker_port->dev->dev_addr,
3763 dst_mac_mask, vlan_id, vlan_id_mask, 3763 dst_mac_mask, vlan_id, vlan_id_mask,
@@ -3766,7 +3766,7 @@ static int rocker_port_router_mac(struct rocker_port *rocker_port,
3766 return err; 3766 return err;
3767 3767
3768 eth_type = htons(ETH_P_IPV6); 3768 eth_type = htons(ETH_P_IPV6);
3769 err = rocker_flow_tbl_term_mac(rocker_port, trans, 3769 err = rocker_flow_tbl_term_mac(rocker_port, trans_ph,
3770 rocker_port->pport, in_pport_mask, 3770 rocker_port->pport, in_pport_mask,
3771 eth_type, rocker_port->dev->dev_addr, 3771 eth_type, rocker_port->dev->dev_addr,
3772 dst_mac_mask, vlan_id, vlan_id_mask, 3772 dst_mac_mask, vlan_id, vlan_id_mask,
@@ -3776,7 +3776,7 @@ static int rocker_port_router_mac(struct rocker_port *rocker_port,
3776} 3776}
3777 3777
3778static int rocker_port_fwding(struct rocker_port *rocker_port, 3778static int rocker_port_fwding(struct rocker_port *rocker_port,
3779 enum switchdev_trans trans, int flags) 3779 enum switchdev_trans_ph trans_ph, int flags)
3780{ 3780{
3781 bool pop_vlan; 3781 bool pop_vlan;
3782 u32 out_pport; 3782 u32 out_pport;
@@ -3801,7 +3801,7 @@ static int rocker_port_fwding(struct rocker_port *rocker_port,
3801 continue; 3801 continue;
3802 vlan_id = htons(vid); 3802 vlan_id = htons(vid);
3803 pop_vlan = rocker_vlan_id_is_internal(vlan_id); 3803 pop_vlan = rocker_vlan_id_is_internal(vlan_id);
3804 err = rocker_group_l2_interface(rocker_port, trans, flags, 3804 err = rocker_group_l2_interface(rocker_port, trans_ph, flags,
3805 vlan_id, out_pport, pop_vlan); 3805 vlan_id, out_pport, pop_vlan);
3806 if (err) { 3806 if (err) {
3807 netdev_err(rocker_port->dev, 3807 netdev_err(rocker_port->dev,
@@ -3815,7 +3815,7 @@ static int rocker_port_fwding(struct rocker_port *rocker_port,
3815} 3815}
3816 3816
3817static int rocker_port_stp_update(struct rocker_port *rocker_port, 3817static int rocker_port_stp_update(struct rocker_port *rocker_port,
3818 enum switchdev_trans trans, int flags, 3818 enum switchdev_trans_ph trans_ph, int flags,
3819 u8 state) 3819 u8 state)
3820{ 3820{
3821 bool want[ROCKER_CTRL_MAX] = { 0, }; 3821 bool want[ROCKER_CTRL_MAX] = { 0, };
@@ -3824,7 +3824,7 @@ static int rocker_port_stp_update(struct rocker_port *rocker_port,
3824 int err; 3824 int err;
3825 int i; 3825 int i;
3826 3826
3827 if (trans == SWITCHDEV_TRANS_PREPARE) { 3827 if (trans_ph == SWITCHDEV_TRANS_PREPARE) {
3828 memcpy(prev_ctrls, rocker_port->ctrls, sizeof(prev_ctrls)); 3828 memcpy(prev_ctrls, rocker_port->ctrls, sizeof(prev_ctrls));
3829 prev_state = rocker_port->stp_state; 3829 prev_state = rocker_port->stp_state;
3830 } 3830 }
@@ -3861,7 +3861,7 @@ static int rocker_port_stp_update(struct rocker_port *rocker_port,
3861 if (want[i] != rocker_port->ctrls[i]) { 3861 if (want[i] != rocker_port->ctrls[i]) {
3862 int ctrl_flags = flags | 3862 int ctrl_flags = flags |
3863 (want[i] ? 0 : ROCKER_OP_FLAG_REMOVE); 3863 (want[i] ? 0 : ROCKER_OP_FLAG_REMOVE);
3864 err = rocker_port_ctrl(rocker_port, trans, ctrl_flags, 3864 err = rocker_port_ctrl(rocker_port, trans_ph, ctrl_flags,
3865 &rocker_ctrls[i]); 3865 &rocker_ctrls[i]);
3866 if (err) 3866 if (err)
3867 goto err_out; 3867 goto err_out;
@@ -3869,14 +3869,14 @@ static int rocker_port_stp_update(struct rocker_port *rocker_port,
3869 } 3869 }
3870 } 3870 }
3871 3871
3872 err = rocker_port_fdb_flush(rocker_port, trans, flags); 3872 err = rocker_port_fdb_flush(rocker_port, trans_ph, flags);
3873 if (err) 3873 if (err)
3874 goto err_out; 3874 goto err_out;
3875 3875
3876 err = rocker_port_fwding(rocker_port, trans, flags); 3876 err = rocker_port_fwding(rocker_port, trans_ph, flags);
3877 3877
3878err_out: 3878err_out:
3879 if (trans == SWITCHDEV_TRANS_PREPARE) { 3879 if (trans_ph == SWITCHDEV_TRANS_PREPARE) {
3880 memcpy(rocker_port->ctrls, prev_ctrls, sizeof(prev_ctrls)); 3880 memcpy(rocker_port->ctrls, prev_ctrls, sizeof(prev_ctrls));
3881 rocker_port->stp_state = prev_state; 3881 rocker_port->stp_state = prev_state;
3882 } 3882 }
@@ -3885,26 +3885,26 @@ err_out:
3885} 3885}
3886 3886
3887static int rocker_port_fwd_enable(struct rocker_port *rocker_port, 3887static int rocker_port_fwd_enable(struct rocker_port *rocker_port,
3888 enum switchdev_trans trans, int flags) 3888 enum switchdev_trans_ph trans_ph, int flags)
3889{ 3889{
3890 if (rocker_port_is_bridged(rocker_port)) 3890 if (rocker_port_is_bridged(rocker_port))
3891 /* bridge STP will enable port */ 3891 /* bridge STP will enable port */
3892 return 0; 3892 return 0;
3893 3893
3894 /* port is not bridged, so simulate going to FORWARDING state */ 3894 /* port is not bridged, so simulate going to FORWARDING state */
3895 return rocker_port_stp_update(rocker_port, trans, flags, 3895 return rocker_port_stp_update(rocker_port, trans_ph, flags,
3896 BR_STATE_FORWARDING); 3896 BR_STATE_FORWARDING);
3897} 3897}
3898 3898
3899static int rocker_port_fwd_disable(struct rocker_port *rocker_port, 3899static int rocker_port_fwd_disable(struct rocker_port *rocker_port,
3900 enum switchdev_trans trans, int flags) 3900 enum switchdev_trans_ph trans_ph, int flags)
3901{ 3901{
3902 if (rocker_port_is_bridged(rocker_port)) 3902 if (rocker_port_is_bridged(rocker_port))
3903 /* bridge STP will disable port */ 3903 /* bridge STP will disable port */
3904 return 0; 3904 return 0;
3905 3905
3906 /* port is not bridged, so simulate going to DISABLED state */ 3906 /* port is not bridged, so simulate going to DISABLED state */
3907 return rocker_port_stp_update(rocker_port, trans, flags, 3907 return rocker_port_stp_update(rocker_port, trans_ph, flags,
3908 BR_STATE_DISABLED); 3908 BR_STATE_DISABLED);
3909} 3909}
3910 3910
@@ -3995,7 +3995,7 @@ not_found:
3995} 3995}
3996 3996
3997static int rocker_port_fib_ipv4(struct rocker_port *rocker_port, 3997static int rocker_port_fib_ipv4(struct rocker_port *rocker_port,
3998 enum switchdev_trans trans, __be32 dst, 3998 enum switchdev_trans_ph trans_ph, __be32 dst,
3999 int dst_len, const struct fib_info *fi, 3999 int dst_len, const struct fib_info *fi,
4000 u32 tb_id, int flags) 4000 u32 tb_id, int flags)
4001{ 4001{
@@ -4019,7 +4019,7 @@ static int rocker_port_fib_ipv4(struct rocker_port *rocker_port,
4019 has_gw = !!nh->nh_gw; 4019 has_gw = !!nh->nh_gw;
4020 4020
4021 if (has_gw && nh_on_port) { 4021 if (has_gw && nh_on_port) {
4022 err = rocker_port_ipv4_nh(rocker_port, trans, flags, 4022 err = rocker_port_ipv4_nh(rocker_port, trans_ph, flags,
4023 nh->nh_gw, &index); 4023 nh->nh_gw, &index);
4024 if (err) 4024 if (err)
4025 return err; 4025 return err;
@@ -4030,7 +4030,7 @@ static int rocker_port_fib_ipv4(struct rocker_port *rocker_port,
4030 group_id = ROCKER_GROUP_L2_INTERFACE(internal_vlan_id, 0); 4030 group_id = ROCKER_GROUP_L2_INTERFACE(internal_vlan_id, 0);
4031 } 4031 }
4032 4032
4033 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans, eth_type, dst, 4033 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans_ph, eth_type, dst,
4034 dst_mask, priority, goto_tbl, 4034 dst_mask, priority, goto_tbl,
4035 group_id, flags); 4035 group_id, flags);
4036 if (err) 4036 if (err)
@@ -4365,7 +4365,7 @@ static void rocker_port_trans_abort(const struct rocker_port *rocker_port)
4365} 4365}
4366 4366
4367static int rocker_port_brport_flags_set(struct rocker_port *rocker_port, 4367static int rocker_port_brport_flags_set(struct rocker_port *rocker_port,
4368 enum switchdev_trans trans, 4368 enum switchdev_trans_ph trans_ph,
4369 unsigned long brport_flags) 4369 unsigned long brport_flags)
4370{ 4370{
4371 unsigned long orig_flags; 4371 unsigned long orig_flags;
@@ -4374,9 +4374,9 @@ static int rocker_port_brport_flags_set(struct rocker_port *rocker_port,
4374 orig_flags = rocker_port->brport_flags; 4374 orig_flags = rocker_port->brport_flags;
4375 rocker_port->brport_flags = brport_flags; 4375 rocker_port->brport_flags = brport_flags;
4376 if ((orig_flags ^ rocker_port->brport_flags) & BR_LEARNING) 4376 if ((orig_flags ^ rocker_port->brport_flags) & BR_LEARNING)
4377 err = rocker_port_set_learning(rocker_port, trans); 4377 err = rocker_port_set_learning(rocker_port, trans_ph);
4378 4378
4379 if (trans == SWITCHDEV_TRANS_PREPARE) 4379 if (trans_ph == SWITCHDEV_TRANS_PREPARE)
4380 rocker_port->brport_flags = orig_flags; 4380 rocker_port->brport_flags = orig_flags;
4381 4381
4382 return err; 4382 return err;
@@ -4388,7 +4388,7 @@ static int rocker_port_attr_set(struct net_device *dev,
4388 struct rocker_port *rocker_port = netdev_priv(dev); 4388 struct rocker_port *rocker_port = netdev_priv(dev);
4389 int err = 0; 4389 int err = 0;
4390 4390
4391 switch (attr->trans) { 4391 switch (attr->trans_ph) {
4392 case SWITCHDEV_TRANS_PREPARE: 4392 case SWITCHDEV_TRANS_PREPARE:
4393 BUG_ON(!list_empty(&rocker_port->trans_mem)); 4393 BUG_ON(!list_empty(&rocker_port->trans_mem));
4394 break; 4394 break;
@@ -4401,12 +4401,12 @@ static int rocker_port_attr_set(struct net_device *dev,
4401 4401
4402 switch (attr->id) { 4402 switch (attr->id) {
4403 case SWITCHDEV_ATTR_PORT_STP_STATE: 4403 case SWITCHDEV_ATTR_PORT_STP_STATE:
4404 err = rocker_port_stp_update(rocker_port, attr->trans, 4404 err = rocker_port_stp_update(rocker_port, attr->trans_ph,
4405 ROCKER_OP_FLAG_NOWAIT, 4405 ROCKER_OP_FLAG_NOWAIT,
4406 attr->u.stp_state); 4406 attr->u.stp_state);
4407 break; 4407 break;
4408 case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS: 4408 case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS:
4409 err = rocker_port_brport_flags_set(rocker_port, attr->trans, 4409 err = rocker_port_brport_flags_set(rocker_port, attr->trans_ph,
4410 attr->u.brport_flags); 4410 attr->u.brport_flags);
4411 break; 4411 break;
4412 default: 4412 default:
@@ -4418,33 +4418,33 @@ static int rocker_port_attr_set(struct net_device *dev,
4418} 4418}
4419 4419
4420static int rocker_port_vlan_add(struct rocker_port *rocker_port, 4420static int rocker_port_vlan_add(struct rocker_port *rocker_port,
4421 enum switchdev_trans trans, u16 vid, u16 flags) 4421 enum switchdev_trans_ph trans_ph, u16 vid, u16 flags)
4422{ 4422{
4423 int err; 4423 int err;
4424 4424
4425 /* XXX deal with flags for PVID and untagged */ 4425 /* XXX deal with flags for PVID and untagged */
4426 4426
4427 err = rocker_port_vlan(rocker_port, trans, 0, vid); 4427 err = rocker_port_vlan(rocker_port, trans_ph, 0, vid);
4428 if (err) 4428 if (err)
4429 return err; 4429 return err;
4430 4430
4431 err = rocker_port_router_mac(rocker_port, trans, 0, htons(vid)); 4431 err = rocker_port_router_mac(rocker_port, trans_ph, 0, htons(vid));
4432 if (err) 4432 if (err)
4433 rocker_port_vlan(rocker_port, trans, 4433 rocker_port_vlan(rocker_port, trans_ph,
4434 ROCKER_OP_FLAG_REMOVE, vid); 4434 ROCKER_OP_FLAG_REMOVE, vid);
4435 4435
4436 return err; 4436 return err;
4437} 4437}
4438 4438
4439static int rocker_port_vlans_add(struct rocker_port *rocker_port, 4439static int rocker_port_vlans_add(struct rocker_port *rocker_port,
4440 enum switchdev_trans trans, 4440 enum switchdev_trans_ph trans_ph,
4441 const struct switchdev_obj_vlan *vlan) 4441 const struct switchdev_obj_vlan *vlan)
4442{ 4442{
4443 u16 vid; 4443 u16 vid;
4444 int err; 4444 int err;
4445 4445
4446 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { 4446 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
4447 err = rocker_port_vlan_add(rocker_port, trans, 4447 err = rocker_port_vlan_add(rocker_port, trans_ph,
4448 vid, vlan->flags); 4448 vid, vlan->flags);
4449 if (err) 4449 if (err)
4450 return err; 4450 return err;
@@ -4454,7 +4454,7 @@ static int rocker_port_vlans_add(struct rocker_port *rocker_port,
4454} 4454}
4455 4455
4456static int rocker_port_fdb_add(struct rocker_port *rocker_port, 4456static int rocker_port_fdb_add(struct rocker_port *rocker_port,
4457 enum switchdev_trans trans, 4457 enum switchdev_trans_ph trans_ph,
4458 const struct switchdev_obj_fdb *fdb) 4458 const struct switchdev_obj_fdb *fdb)
4459{ 4459{
4460 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL); 4460 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL);
@@ -4463,7 +4463,7 @@ static int rocker_port_fdb_add(struct rocker_port *rocker_port,
4463 if (!rocker_port_is_bridged(rocker_port)) 4463 if (!rocker_port_is_bridged(rocker_port))
4464 return -EINVAL; 4464 return -EINVAL;
4465 4465
4466 return rocker_port_fdb(rocker_port, trans, fdb->addr, vlan_id, flags); 4466 return rocker_port_fdb(rocker_port, trans_ph, fdb->addr, vlan_id, flags);
4467} 4467}
4468 4468
4469static int rocker_port_obj_add(struct net_device *dev, 4469static int rocker_port_obj_add(struct net_device *dev,
@@ -4473,7 +4473,7 @@ static int rocker_port_obj_add(struct net_device *dev,
4473 const struct switchdev_obj_ipv4_fib *fib4; 4473 const struct switchdev_obj_ipv4_fib *fib4;
4474 int err = 0; 4474 int err = 0;
4475 4475
4476 switch (obj->trans) { 4476 switch (obj->trans_ph) {
4477 case SWITCHDEV_TRANS_PREPARE: 4477 case SWITCHDEV_TRANS_PREPARE:
4478 BUG_ON(!list_empty(&rocker_port->trans_mem)); 4478 BUG_ON(!list_empty(&rocker_port->trans_mem));
4479 break; 4479 break;
@@ -4486,17 +4486,17 @@ static int rocker_port_obj_add(struct net_device *dev,
4486 4486
4487 switch (obj->id) { 4487 switch (obj->id) {
4488 case SWITCHDEV_OBJ_PORT_VLAN: 4488 case SWITCHDEV_OBJ_PORT_VLAN:
4489 err = rocker_port_vlans_add(rocker_port, obj->trans, 4489 err = rocker_port_vlans_add(rocker_port, obj->trans_ph,
4490 &obj->u.vlan); 4490 &obj->u.vlan);
4491 break; 4491 break;
4492 case SWITCHDEV_OBJ_IPV4_FIB: 4492 case SWITCHDEV_OBJ_IPV4_FIB:
4493 fib4 = &obj->u.ipv4_fib; 4493 fib4 = &obj->u.ipv4_fib;
4494 err = rocker_port_fib_ipv4(rocker_port, obj->trans, 4494 err = rocker_port_fib_ipv4(rocker_port, obj->trans_ph,
4495 htonl(fib4->dst), fib4->dst_len, 4495 htonl(fib4->dst), fib4->dst_len,
4496 fib4->fi, fib4->tb_id, 0); 4496 fib4->fi, fib4->tb_id, 0);
4497 break; 4497 break;
4498 case SWITCHDEV_OBJ_PORT_FDB: 4498 case SWITCHDEV_OBJ_PORT_FDB:
4499 err = rocker_port_fdb_add(rocker_port, obj->trans, &obj->u.fdb); 4499 err = rocker_port_fdb_add(rocker_port, obj->trans_ph, &obj->u.fdb);
4500 break; 4500 break;
4501 default: 4501 default:
4502 err = -EOPNOTSUPP; 4502 err = -EOPNOTSUPP;
@@ -4536,7 +4536,7 @@ static int rocker_port_vlans_del(struct rocker_port *rocker_port,
4536} 4536}
4537 4537
4538static int rocker_port_fdb_del(struct rocker_port *rocker_port, 4538static int rocker_port_fdb_del(struct rocker_port *rocker_port,
4539 enum switchdev_trans trans, 4539 enum switchdev_trans_ph trans_ph,
4540 const struct switchdev_obj_fdb *fdb) 4540 const struct switchdev_obj_fdb *fdb)
4541{ 4541{
4542 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL); 4542 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL);
@@ -4545,7 +4545,7 @@ static int rocker_port_fdb_del(struct rocker_port *rocker_port,
4545 if (!rocker_port_is_bridged(rocker_port)) 4545 if (!rocker_port_is_bridged(rocker_port))
4546 return -EINVAL; 4546 return -EINVAL;
4547 4547
4548 return rocker_port_fdb(rocker_port, trans, fdb->addr, vlan_id, flags); 4548 return rocker_port_fdb(rocker_port, trans_ph, fdb->addr, vlan_id, flags);
4549} 4549}
4550 4550
4551static int rocker_port_obj_del(struct net_device *dev, 4551static int rocker_port_obj_del(struct net_device *dev,
@@ -4567,7 +4567,7 @@ static int rocker_port_obj_del(struct net_device *dev,
4567 ROCKER_OP_FLAG_REMOVE); 4567 ROCKER_OP_FLAG_REMOVE);
4568 break; 4568 break;
4569 case SWITCHDEV_OBJ_PORT_FDB: 4569 case SWITCHDEV_OBJ_PORT_FDB:
4570 err = rocker_port_fdb_del(rocker_port, obj->trans, &obj->u.fdb); 4570 err = rocker_port_fdb_del(rocker_port, obj->trans_ph, &obj->u.fdb);
4571 break; 4571 break;
4572 default: 4572 default:
4573 err = -EOPNOTSUPP; 4573 err = -EOPNOTSUPP;