2 * drivers/net/ethernet/rocker/rocker.c - Rocker switch device driver
3 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
4 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/pci.h>
15 #include <linux/interrupt.h>
16 #include <linux/sched.h>
17 #include <linux/wait.h>
18 #include <linux/spinlock.h>
19 #include <linux/hashtable.h>
20 #include <linux/crc32.h>
21 #include <linux/sort.h>
22 #include <linux/random.h>
23 #include <linux/netdevice.h>
24 #include <linux/inetdevice.h>
25 #include <linux/skbuff.h>
26 #include <linux/socket.h>
27 #include <linux/etherdevice.h>
28 #include <linux/ethtool.h>
29 #include <linux/if_ether.h>
30 #include <linux/if_vlan.h>
31 #include <linux/if_bridge.h>
32 #include <linux/bitops.h>
33 #include <linux/ctype.h>
34 #include <net/switchdev.h>
35 #include <net/rtnetlink.h>
36 #include <net/ip_fib.h>
37 #include <net/netevent.h>
39 #include <asm-generic/io-64-nonatomic-lo-hi.h>
40 #include <generated/utsrelease.h>
44 static const char rocker_driver_name[] = "rocker";
46 static const struct pci_device_id rocker_pci_id_table[] = {
47 {PCI_VDEVICE(REDHAT, PCI_DEVICE_ID_REDHAT_ROCKER), 0},
51 struct rocker_flow_tbl_key {
53 enum rocker_of_dpa_table_id tbl_id;
58 enum rocker_of_dpa_table_id goto_tbl;
64 enum rocker_of_dpa_table_id goto_tbl;
73 u8 eth_dst_mask[ETH_ALEN];
76 enum rocker_of_dpa_table_id goto_tbl;
83 enum rocker_of_dpa_table_id goto_tbl;
88 u8 eth_dst_mask[ETH_ALEN];
93 enum rocker_of_dpa_table_id goto_tbl;
100 u8 eth_src[ETH_ALEN];
101 u8 eth_src_mask[ETH_ALEN];
102 u8 eth_dst[ETH_ALEN];
103 u8 eth_dst_mask[ETH_ALEN];
116 struct rocker_flow_tbl_entry {
117 struct hlist_node entry;
120 struct rocker_flow_tbl_key key;
122 u32 key_crc32; /* key */
125 struct rocker_group_tbl_entry {
126 struct hlist_node entry;
128 u32 group_id; /* key */
136 u8 eth_src[ETH_ALEN];
137 u8 eth_dst[ETH_ALEN];
142 u8 eth_src[ETH_ALEN];
143 u8 eth_dst[ETH_ALEN];
151 struct rocker_fdb_tbl_entry {
152 struct hlist_node entry;
153 u32 key_crc32; /* key */
155 unsigned long touched;
156 struct rocker_fdb_tbl_key {
157 struct rocker_port *rocker_port;
163 struct rocker_internal_vlan_tbl_entry {
164 struct hlist_node entry;
165 int ifindex; /* key */
170 struct rocker_neigh_tbl_entry {
171 struct hlist_node entry;
172 __be32 ip_addr; /* key */
173 struct net_device *dev;
176 u8 eth_dst[ETH_ALEN];
180 struct rocker_desc_info {
181 char *data; /* mapped */
184 struct rocker_desc *desc;
188 struct rocker_dma_ring_info {
192 struct rocker_desc *desc; /* mapped */
194 struct rocker_desc_info *desc_info;
201 ROCKER_CTRL_LINK_LOCAL_MCAST,
202 ROCKER_CTRL_LOCAL_ARP,
203 ROCKER_CTRL_IPV4_MCAST,
204 ROCKER_CTRL_IPV6_MCAST,
205 ROCKER_CTRL_DFLT_BRIDGING,
206 ROCKER_CTRL_DFLT_OVS,
210 #define ROCKER_INTERNAL_VLAN_ID_BASE 0x0f00
211 #define ROCKER_N_INTERNAL_VLANS 255
212 #define ROCKER_VLAN_BITMAP_LEN BITS_TO_LONGS(VLAN_N_VID)
213 #define ROCKER_INTERNAL_VLAN_BITMAP_LEN BITS_TO_LONGS(ROCKER_N_INTERNAL_VLANS)
216 struct net_device *dev;
217 struct net_device *bridge_dev;
218 struct rocker *rocker;
219 unsigned int port_number;
221 __be16 internal_vlan_id;
224 unsigned long ageing_time;
225 bool ctrls[ROCKER_CTRL_MAX];
226 unsigned long vlan_bitmap[ROCKER_VLAN_BITMAP_LEN];
227 struct napi_struct napi_tx;
228 struct napi_struct napi_rx;
229 struct rocker_dma_ring_info tx_ring;
230 struct rocker_dma_ring_info rx_ring;
231 struct list_head trans_mem;
235 struct pci_dev *pdev;
237 struct msix_entry *msix_entries;
238 unsigned int port_count;
239 struct rocker_port **ports;
243 spinlock_t cmd_ring_lock; /* for cmd ring accesses */
244 struct rocker_dma_ring_info cmd_ring;
245 struct rocker_dma_ring_info event_ring;
246 DECLARE_HASHTABLE(flow_tbl, 16);
247 spinlock_t flow_tbl_lock; /* for flow tbl accesses */
248 u64 flow_tbl_next_cookie;
249 DECLARE_HASHTABLE(group_tbl, 16);
250 spinlock_t group_tbl_lock; /* for group tbl accesses */
251 struct timer_list fdb_cleanup_timer;
252 DECLARE_HASHTABLE(fdb_tbl, 16);
253 spinlock_t fdb_tbl_lock; /* for fdb tbl accesses */
254 unsigned long internal_vlan_bitmap[ROCKER_INTERNAL_VLAN_BITMAP_LEN];
255 DECLARE_HASHTABLE(internal_vlan_tbl, 8);
256 spinlock_t internal_vlan_tbl_lock; /* for vlan tbl accesses */
257 DECLARE_HASHTABLE(neigh_tbl, 16);
258 spinlock_t neigh_tbl_lock; /* for neigh tbl accesses */
259 u32 neigh_tbl_next_index;
262 static const u8 zero_mac[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
263 static const u8 ff_mac[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
264 static const u8 ll_mac[ETH_ALEN] = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
265 static const u8 ll_mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0 };
266 static const u8 mcast_mac[ETH_ALEN] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
267 static const u8 ipv4_mcast[ETH_ALEN] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
268 static const u8 ipv4_mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0x80, 0x00, 0x00 };
269 static const u8 ipv6_mcast[ETH_ALEN] = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
270 static const u8 ipv6_mask[ETH_ALEN] = { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 };
272 /* Rocker priority levels for flow table entries. Higher
273 * priority match takes precedence over lower priority match.
277 ROCKER_PRIORITY_UNKNOWN = 0,
278 ROCKER_PRIORITY_IG_PORT = 1,
279 ROCKER_PRIORITY_VLAN = 1,
280 ROCKER_PRIORITY_TERM_MAC_UCAST = 0,
281 ROCKER_PRIORITY_TERM_MAC_MCAST = 1,
282 ROCKER_PRIORITY_BRIDGING_VLAN_DFLT_EXACT = 1,
283 ROCKER_PRIORITY_BRIDGING_VLAN_DFLT_WILD = 2,
284 ROCKER_PRIORITY_BRIDGING_VLAN = 3,
285 ROCKER_PRIORITY_BRIDGING_TENANT_DFLT_EXACT = 1,
286 ROCKER_PRIORITY_BRIDGING_TENANT_DFLT_WILD = 2,
287 ROCKER_PRIORITY_BRIDGING_TENANT = 3,
288 ROCKER_PRIORITY_ACL_CTRL = 3,
289 ROCKER_PRIORITY_ACL_NORMAL = 2,
290 ROCKER_PRIORITY_ACL_DFLT = 1,
293 static bool rocker_vlan_id_is_internal(__be16 vlan_id)
295 u16 start = ROCKER_INTERNAL_VLAN_ID_BASE;
297 u16 _vlan_id = ntohs(vlan_id);
299 return (_vlan_id >= start && _vlan_id <= end);
302 static __be16 rocker_port_vid_to_vlan(const struct rocker_port *rocker_port,
303 u16 vid, bool *pop_vlan)
309 vlan_id = htons(vid);
311 vlan_id = rocker_port->internal_vlan_id;
319 static u16 rocker_port_vlan_to_vid(const struct rocker_port *rocker_port,
322 if (rocker_vlan_id_is_internal(vlan_id))
325 return ntohs(vlan_id);
328 static bool rocker_port_is_bridged(const struct rocker_port *rocker_port)
330 return rocker_port->bridge_dev &&
331 netif_is_bridge_master(rocker_port->bridge_dev);
334 static bool rocker_port_is_ovsed(const struct rocker_port *rocker_port)
336 return rocker_port->bridge_dev &&
337 netif_is_ovs_master(rocker_port->bridge_dev);
340 #define ROCKER_OP_FLAG_REMOVE BIT(0)
341 #define ROCKER_OP_FLAG_NOWAIT BIT(1)
342 #define ROCKER_OP_FLAG_LEARNED BIT(2)
343 #define ROCKER_OP_FLAG_REFRESH BIT(3)
345 static void *__rocker_port_mem_alloc(struct rocker_port *rocker_port,
346 struct switchdev_trans *trans, int flags,
349 struct list_head *elem = NULL;
350 gfp_t gfp_flags = (flags & ROCKER_OP_FLAG_NOWAIT) ?
351 GFP_ATOMIC : GFP_KERNEL;
353 /* If in transaction prepare phase, allocate the memory
354 * and enqueue it on a per-port list. If in transaction
355 * commit phase, dequeue the memory from the per-port list
356 * rather than re-allocating the memory. The idea is the
357 * driver code paths for prepare and commit are identical
358 * so the memory allocated in the prepare phase is the
359 * memory used in the commit phase.
363 elem = kzalloc(size + sizeof(*elem), gfp_flags);
365 INIT_LIST_HEAD(elem);
366 } else if (switchdev_trans_ph_prepare(trans)) {
367 elem = kzalloc(size + sizeof(*elem), gfp_flags);
370 list_add_tail(elem, &rocker_port->trans_mem);
372 BUG_ON(list_empty(&rocker_port->trans_mem));
373 elem = rocker_port->trans_mem.next;
377 return elem ? elem + 1 : NULL;
380 static void *rocker_port_kzalloc(struct rocker_port *rocker_port,
381 struct switchdev_trans *trans, int flags,
384 return __rocker_port_mem_alloc(rocker_port, trans, flags, size);
387 static void *rocker_port_kcalloc(struct rocker_port *rocker_port,
388 struct switchdev_trans *trans, int flags,
389 size_t n, size_t size)
391 return __rocker_port_mem_alloc(rocker_port, trans, flags, n * size);
394 static void rocker_port_kfree(struct switchdev_trans *trans, const void *mem)
396 struct list_head *elem;
398 /* Frees are ignored if in transaction prepare phase. The
399 * memory remains on the per-port list until freed in the
403 if (switchdev_trans_ph_prepare(trans))
406 elem = (struct list_head *)mem - 1;
407 BUG_ON(!list_empty(elem));
412 wait_queue_head_t wait;
417 static void rocker_wait_reset(struct rocker_wait *wait)
420 wait->nowait = false;
423 static void rocker_wait_init(struct rocker_wait *wait)
425 init_waitqueue_head(&wait->wait);
426 rocker_wait_reset(wait);
429 static struct rocker_wait *rocker_wait_create(struct rocker_port *rocker_port,
430 struct switchdev_trans *trans,
433 struct rocker_wait *wait;
435 wait = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*wait));
438 rocker_wait_init(wait);
442 static void rocker_wait_destroy(struct switchdev_trans *trans,
443 struct rocker_wait *wait)
445 rocker_port_kfree(trans, wait);
448 static bool rocker_wait_event_timeout(struct rocker_wait *wait,
449 unsigned long timeout)
451 wait_event_timeout(wait->wait, wait->done, HZ / 10);
457 static void rocker_wait_wake_up(struct rocker_wait *wait)
460 wake_up(&wait->wait);
463 static u32 rocker_msix_vector(const struct rocker *rocker, unsigned int vector)
465 return rocker->msix_entries[vector].vector;
468 static u32 rocker_msix_tx_vector(const struct rocker_port *rocker_port)
470 return rocker_msix_vector(rocker_port->rocker,
471 ROCKER_MSIX_VEC_TX(rocker_port->port_number));
474 static u32 rocker_msix_rx_vector(const struct rocker_port *rocker_port)
476 return rocker_msix_vector(rocker_port->rocker,
477 ROCKER_MSIX_VEC_RX(rocker_port->port_number));
480 #define rocker_write32(rocker, reg, val) \
481 writel((val), (rocker)->hw_addr + (ROCKER_ ## reg))
482 #define rocker_read32(rocker, reg) \
483 readl((rocker)->hw_addr + (ROCKER_ ## reg))
484 #define rocker_write64(rocker, reg, val) \
485 writeq((val), (rocker)->hw_addr + (ROCKER_ ## reg))
486 #define rocker_read64(rocker, reg) \
487 readq((rocker)->hw_addr + (ROCKER_ ## reg))
489 /*****************************
490 * HW basic testing functions
491 *****************************/
493 static int rocker_reg_test(const struct rocker *rocker)
495 const struct pci_dev *pdev = rocker->pdev;
501 rocker_write32(rocker, TEST_REG, rnd);
502 test_reg = rocker_read32(rocker, TEST_REG);
503 if (test_reg != rnd * 2) {
504 dev_err(&pdev->dev, "unexpected 32bit register value %08llx, expected %08llx\n",
511 rnd |= prandom_u32();
512 rocker_write64(rocker, TEST_REG64, rnd);
513 test_reg = rocker_read64(rocker, TEST_REG64);
514 if (test_reg != rnd * 2) {
515 dev_err(&pdev->dev, "unexpected 64bit register value %16llx, expected %16llx\n",
523 static int rocker_dma_test_one(const struct rocker *rocker,
524 struct rocker_wait *wait, u32 test_type,
525 dma_addr_t dma_handle, const unsigned char *buf,
526 const unsigned char *expect, size_t size)
528 const struct pci_dev *pdev = rocker->pdev;
531 rocker_wait_reset(wait);
532 rocker_write32(rocker, TEST_DMA_CTRL, test_type);
534 if (!rocker_wait_event_timeout(wait, HZ / 10)) {
535 dev_err(&pdev->dev, "no interrupt received within a timeout\n");
539 for (i = 0; i < size; i++) {
540 if (buf[i] != expect[i]) {
541 dev_err(&pdev->dev, "unexpected memory content %02x at byte %x\n, %02x expected",
542 buf[i], i, expect[i]);
549 #define ROCKER_TEST_DMA_BUF_SIZE (PAGE_SIZE * 4)
550 #define ROCKER_TEST_DMA_FILL_PATTERN 0x96
552 static int rocker_dma_test_offset(const struct rocker *rocker,
553 struct rocker_wait *wait, int offset)
555 struct pci_dev *pdev = rocker->pdev;
556 unsigned char *alloc;
558 unsigned char *expect;
559 dma_addr_t dma_handle;
563 alloc = kzalloc(ROCKER_TEST_DMA_BUF_SIZE * 2 + offset,
564 GFP_KERNEL | GFP_DMA);
567 buf = alloc + offset;
568 expect = buf + ROCKER_TEST_DMA_BUF_SIZE;
570 dma_handle = pci_map_single(pdev, buf, ROCKER_TEST_DMA_BUF_SIZE,
571 PCI_DMA_BIDIRECTIONAL);
572 if (pci_dma_mapping_error(pdev, dma_handle)) {
577 rocker_write64(rocker, TEST_DMA_ADDR, dma_handle);
578 rocker_write32(rocker, TEST_DMA_SIZE, ROCKER_TEST_DMA_BUF_SIZE);
580 memset(expect, ROCKER_TEST_DMA_FILL_PATTERN, ROCKER_TEST_DMA_BUF_SIZE);
581 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_FILL,
582 dma_handle, buf, expect,
583 ROCKER_TEST_DMA_BUF_SIZE);
587 memset(expect, 0, ROCKER_TEST_DMA_BUF_SIZE);
588 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_CLEAR,
589 dma_handle, buf, expect,
590 ROCKER_TEST_DMA_BUF_SIZE);
594 prandom_bytes(buf, ROCKER_TEST_DMA_BUF_SIZE);
595 for (i = 0; i < ROCKER_TEST_DMA_BUF_SIZE; i++)
597 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_INVERT,
598 dma_handle, buf, expect,
599 ROCKER_TEST_DMA_BUF_SIZE);
604 pci_unmap_single(pdev, dma_handle, ROCKER_TEST_DMA_BUF_SIZE,
605 PCI_DMA_BIDIRECTIONAL);
612 static int rocker_dma_test(const struct rocker *rocker,
613 struct rocker_wait *wait)
618 for (i = 0; i < 8; i++) {
619 err = rocker_dma_test_offset(rocker, wait, i);
626 static irqreturn_t rocker_test_irq_handler(int irq, void *dev_id)
628 struct rocker_wait *wait = dev_id;
630 rocker_wait_wake_up(wait);
635 static int rocker_basic_hw_test(const struct rocker *rocker)
637 const struct pci_dev *pdev = rocker->pdev;
638 struct rocker_wait wait;
641 err = rocker_reg_test(rocker);
643 dev_err(&pdev->dev, "reg test failed\n");
647 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_TEST),
648 rocker_test_irq_handler, 0,
649 rocker_driver_name, &wait);
651 dev_err(&pdev->dev, "cannot assign test irq\n");
655 rocker_wait_init(&wait);
656 rocker_write32(rocker, TEST_IRQ, ROCKER_MSIX_VEC_TEST);
658 if (!rocker_wait_event_timeout(&wait, HZ / 10)) {
659 dev_err(&pdev->dev, "no interrupt received within a timeout\n");
664 err = rocker_dma_test(rocker, &wait);
666 dev_err(&pdev->dev, "dma test failed\n");
669 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_TEST), &wait);
677 #define ROCKER_TLV_ALIGNTO 8U
678 #define ROCKER_TLV_ALIGN(len) \
679 (((len) + ROCKER_TLV_ALIGNTO - 1) & ~(ROCKER_TLV_ALIGNTO - 1))
680 #define ROCKER_TLV_HDRLEN ROCKER_TLV_ALIGN(sizeof(struct rocker_tlv))
682 /* <------- ROCKER_TLV_HDRLEN -------> <--- ROCKER_TLV_ALIGN(payload) --->
683 * +-----------------------------+- - -+- - - - - - - - - - - - - - -+- - -+
684 * | Header | Pad | Payload | Pad |
685 * | (struct rocker_tlv) | ing | | ing |
686 * +-----------------------------+- - -+- - - - - - - - - - - - - - -+- - -+
687 * <--------------------------- tlv->len -------------------------->
690 static struct rocker_tlv *rocker_tlv_next(const struct rocker_tlv *tlv,
693 int totlen = ROCKER_TLV_ALIGN(tlv->len);
695 *remaining -= totlen;
696 return (struct rocker_tlv *) ((char *) tlv + totlen);
699 static int rocker_tlv_ok(const struct rocker_tlv *tlv, int remaining)
701 return remaining >= (int) ROCKER_TLV_HDRLEN &&
702 tlv->len >= ROCKER_TLV_HDRLEN &&
703 tlv->len <= remaining;
706 #define rocker_tlv_for_each(pos, head, len, rem) \
707 for (pos = head, rem = len; \
708 rocker_tlv_ok(pos, rem); \
709 pos = rocker_tlv_next(pos, &(rem)))
711 #define rocker_tlv_for_each_nested(pos, tlv, rem) \
712 rocker_tlv_for_each(pos, rocker_tlv_data(tlv), \
713 rocker_tlv_len(tlv), rem)
715 static int rocker_tlv_attr_size(int payload)
717 return ROCKER_TLV_HDRLEN + payload;
720 static int rocker_tlv_total_size(int payload)
722 return ROCKER_TLV_ALIGN(rocker_tlv_attr_size(payload));
725 static int rocker_tlv_padlen(int payload)
727 return rocker_tlv_total_size(payload) - rocker_tlv_attr_size(payload);
730 static int rocker_tlv_type(const struct rocker_tlv *tlv)
735 static void *rocker_tlv_data(const struct rocker_tlv *tlv)
737 return (char *) tlv + ROCKER_TLV_HDRLEN;
740 static int rocker_tlv_len(const struct rocker_tlv *tlv)
742 return tlv->len - ROCKER_TLV_HDRLEN;
745 static u8 rocker_tlv_get_u8(const struct rocker_tlv *tlv)
747 return *(u8 *) rocker_tlv_data(tlv);
750 static u16 rocker_tlv_get_u16(const struct rocker_tlv *tlv)
752 return *(u16 *) rocker_tlv_data(tlv);
755 static __be16 rocker_tlv_get_be16(const struct rocker_tlv *tlv)
757 return *(__be16 *) rocker_tlv_data(tlv);
760 static u32 rocker_tlv_get_u32(const struct rocker_tlv *tlv)
762 return *(u32 *) rocker_tlv_data(tlv);
765 static u64 rocker_tlv_get_u64(const struct rocker_tlv *tlv)
767 return *(u64 *) rocker_tlv_data(tlv);
770 static void rocker_tlv_parse(const struct rocker_tlv **tb, int maxtype,
771 const char *buf, int buf_len)
773 const struct rocker_tlv *tlv;
774 const struct rocker_tlv *head = (const struct rocker_tlv *) buf;
777 memset(tb, 0, sizeof(struct rocker_tlv *) * (maxtype + 1));
779 rocker_tlv_for_each(tlv, head, buf_len, rem) {
780 u32 type = rocker_tlv_type(tlv);
782 if (type > 0 && type <= maxtype)
787 static void rocker_tlv_parse_nested(const struct rocker_tlv **tb, int maxtype,
788 const struct rocker_tlv *tlv)
790 rocker_tlv_parse(tb, maxtype, rocker_tlv_data(tlv),
791 rocker_tlv_len(tlv));
794 static void rocker_tlv_parse_desc(const struct rocker_tlv **tb, int maxtype,
795 const struct rocker_desc_info *desc_info)
797 rocker_tlv_parse(tb, maxtype, desc_info->data,
798 desc_info->desc->tlv_size);
801 static struct rocker_tlv *rocker_tlv_start(struct rocker_desc_info *desc_info)
803 return (struct rocker_tlv *) ((char *) desc_info->data +
804 desc_info->tlv_size);
807 static int rocker_tlv_put(struct rocker_desc_info *desc_info,
808 int attrtype, int attrlen, const void *data)
810 int tail_room = desc_info->data_size - desc_info->tlv_size;
811 int total_size = rocker_tlv_total_size(attrlen);
812 struct rocker_tlv *tlv;
814 if (unlikely(tail_room < total_size))
817 tlv = rocker_tlv_start(desc_info);
818 desc_info->tlv_size += total_size;
819 tlv->type = attrtype;
820 tlv->len = rocker_tlv_attr_size(attrlen);
821 memcpy(rocker_tlv_data(tlv), data, attrlen);
822 memset((char *) tlv + tlv->len, 0, rocker_tlv_padlen(attrlen));
826 static int rocker_tlv_put_u8(struct rocker_desc_info *desc_info,
827 int attrtype, u8 value)
829 return rocker_tlv_put(desc_info, attrtype, sizeof(u8), &value);
832 static int rocker_tlv_put_u16(struct rocker_desc_info *desc_info,
833 int attrtype, u16 value)
835 return rocker_tlv_put(desc_info, attrtype, sizeof(u16), &value);
838 static int rocker_tlv_put_be16(struct rocker_desc_info *desc_info,
839 int attrtype, __be16 value)
841 return rocker_tlv_put(desc_info, attrtype, sizeof(__be16), &value);
844 static int rocker_tlv_put_u32(struct rocker_desc_info *desc_info,
845 int attrtype, u32 value)
847 return rocker_tlv_put(desc_info, attrtype, sizeof(u32), &value);
850 static int rocker_tlv_put_be32(struct rocker_desc_info *desc_info,
851 int attrtype, __be32 value)
853 return rocker_tlv_put(desc_info, attrtype, sizeof(__be32), &value);
856 static int rocker_tlv_put_u64(struct rocker_desc_info *desc_info,
857 int attrtype, u64 value)
859 return rocker_tlv_put(desc_info, attrtype, sizeof(u64), &value);
862 static struct rocker_tlv *
863 rocker_tlv_nest_start(struct rocker_desc_info *desc_info, int attrtype)
865 struct rocker_tlv *start = rocker_tlv_start(desc_info);
867 if (rocker_tlv_put(desc_info, attrtype, 0, NULL) < 0)
873 static void rocker_tlv_nest_end(struct rocker_desc_info *desc_info,
874 struct rocker_tlv *start)
876 start->len = (char *) rocker_tlv_start(desc_info) - (char *) start;
879 static void rocker_tlv_nest_cancel(struct rocker_desc_info *desc_info,
880 const struct rocker_tlv *start)
882 desc_info->tlv_size = (const char *) start - desc_info->data;
885 /******************************************
886 * DMA rings and descriptors manipulations
887 ******************************************/
889 static u32 __pos_inc(u32 pos, size_t limit)
891 return ++pos == limit ? 0 : pos;
894 static int rocker_desc_err(const struct rocker_desc_info *desc_info)
896 int err = desc_info->desc->comp_err & ~ROCKER_DMA_DESC_COMP_ERR_GEN;
911 case -ROCKER_EMSGSIZE:
913 case -ROCKER_ENOTSUP:
915 case -ROCKER_ENOBUFS:
922 static void rocker_desc_gen_clear(const struct rocker_desc_info *desc_info)
924 desc_info->desc->comp_err &= ~ROCKER_DMA_DESC_COMP_ERR_GEN;
927 static bool rocker_desc_gen(const struct rocker_desc_info *desc_info)
929 u32 comp_err = desc_info->desc->comp_err;
931 return comp_err & ROCKER_DMA_DESC_COMP_ERR_GEN ? true : false;
934 static void *rocker_desc_cookie_ptr_get(const struct rocker_desc_info *desc_info)
936 return (void *)(uintptr_t)desc_info->desc->cookie;
939 static void rocker_desc_cookie_ptr_set(const struct rocker_desc_info *desc_info,
942 desc_info->desc->cookie = (uintptr_t) ptr;
945 static struct rocker_desc_info *
946 rocker_desc_head_get(const struct rocker_dma_ring_info *info)
948 static struct rocker_desc_info *desc_info;
949 u32 head = __pos_inc(info->head, info->size);
951 desc_info = &info->desc_info[info->head];
952 if (head == info->tail)
953 return NULL; /* ring full */
954 desc_info->tlv_size = 0;
958 static void rocker_desc_commit(const struct rocker_desc_info *desc_info)
960 desc_info->desc->buf_size = desc_info->data_size;
961 desc_info->desc->tlv_size = desc_info->tlv_size;
964 static void rocker_desc_head_set(const struct rocker *rocker,
965 struct rocker_dma_ring_info *info,
966 const struct rocker_desc_info *desc_info)
968 u32 head = __pos_inc(info->head, info->size);
970 BUG_ON(head == info->tail);
971 rocker_desc_commit(desc_info);
973 rocker_write32(rocker, DMA_DESC_HEAD(info->type), head);
976 static struct rocker_desc_info *
977 rocker_desc_tail_get(struct rocker_dma_ring_info *info)
979 static struct rocker_desc_info *desc_info;
981 if (info->tail == info->head)
982 return NULL; /* nothing to be done between head and tail */
983 desc_info = &info->desc_info[info->tail];
984 if (!rocker_desc_gen(desc_info))
985 return NULL; /* gen bit not set, desc is not ready yet */
986 info->tail = __pos_inc(info->tail, info->size);
987 desc_info->tlv_size = desc_info->desc->tlv_size;
991 static void rocker_dma_ring_credits_set(const struct rocker *rocker,
992 const struct rocker_dma_ring_info *info,
996 rocker_write32(rocker, DMA_DESC_CREDITS(info->type), credits);
999 static unsigned long rocker_dma_ring_size_fix(size_t size)
1001 return max(ROCKER_DMA_SIZE_MIN,
1002 min(roundup_pow_of_two(size), ROCKER_DMA_SIZE_MAX));
1005 static int rocker_dma_ring_create(const struct rocker *rocker,
1008 struct rocker_dma_ring_info *info)
1012 BUG_ON(size != rocker_dma_ring_size_fix(size));
1017 info->desc_info = kcalloc(info->size, sizeof(*info->desc_info),
1019 if (!info->desc_info)
1022 info->desc = pci_alloc_consistent(rocker->pdev,
1023 info->size * sizeof(*info->desc),
1026 kfree(info->desc_info);
1030 for (i = 0; i < info->size; i++)
1031 info->desc_info[i].desc = &info->desc[i];
1033 rocker_write32(rocker, DMA_DESC_CTRL(info->type),
1034 ROCKER_DMA_DESC_CTRL_RESET);
1035 rocker_write64(rocker, DMA_DESC_ADDR(info->type), info->mapaddr);
1036 rocker_write32(rocker, DMA_DESC_SIZE(info->type), info->size);
1041 static void rocker_dma_ring_destroy(const struct rocker *rocker,
1042 const struct rocker_dma_ring_info *info)
1044 rocker_write64(rocker, DMA_DESC_ADDR(info->type), 0);
1046 pci_free_consistent(rocker->pdev,
1047 info->size * sizeof(struct rocker_desc),
1048 info->desc, info->mapaddr);
1049 kfree(info->desc_info);
1052 static void rocker_dma_ring_pass_to_producer(const struct rocker *rocker,
1053 struct rocker_dma_ring_info *info)
1057 BUG_ON(info->head || info->tail);
1059 /* When ring is consumer, we need to advance head for each desc.
1060 * That tells hw that the desc is ready to be used by it.
1062 for (i = 0; i < info->size - 1; i++)
1063 rocker_desc_head_set(rocker, info, &info->desc_info[i]);
1064 rocker_desc_commit(&info->desc_info[i]);
1067 static int rocker_dma_ring_bufs_alloc(const struct rocker *rocker,
1068 const struct rocker_dma_ring_info *info,
1069 int direction, size_t buf_size)
1071 struct pci_dev *pdev = rocker->pdev;
1075 for (i = 0; i < info->size; i++) {
1076 struct rocker_desc_info *desc_info = &info->desc_info[i];
1077 struct rocker_desc *desc = &info->desc[i];
1078 dma_addr_t dma_handle;
1081 buf = kzalloc(buf_size, GFP_KERNEL | GFP_DMA);
1087 dma_handle = pci_map_single(pdev, buf, buf_size, direction);
1088 if (pci_dma_mapping_error(pdev, dma_handle)) {
1094 desc_info->data = buf;
1095 desc_info->data_size = buf_size;
1096 dma_unmap_addr_set(desc_info, mapaddr, dma_handle);
1098 desc->buf_addr = dma_handle;
1099 desc->buf_size = buf_size;
1104 for (i--; i >= 0; i--) {
1105 const struct rocker_desc_info *desc_info = &info->desc_info[i];
1107 pci_unmap_single(pdev, dma_unmap_addr(desc_info, mapaddr),
1108 desc_info->data_size, direction);
1109 kfree(desc_info->data);
1114 static void rocker_dma_ring_bufs_free(const struct rocker *rocker,
1115 const struct rocker_dma_ring_info *info,
1118 struct pci_dev *pdev = rocker->pdev;
1121 for (i = 0; i < info->size; i++) {
1122 const struct rocker_desc_info *desc_info = &info->desc_info[i];
1123 struct rocker_desc *desc = &info->desc[i];
1127 pci_unmap_single(pdev, dma_unmap_addr(desc_info, mapaddr),
1128 desc_info->data_size, direction);
1129 kfree(desc_info->data);
1133 static int rocker_dma_rings_init(struct rocker *rocker)
1135 const struct pci_dev *pdev = rocker->pdev;
1138 err = rocker_dma_ring_create(rocker, ROCKER_DMA_CMD,
1139 ROCKER_DMA_CMD_DEFAULT_SIZE,
1142 dev_err(&pdev->dev, "failed to create command dma ring\n");
1146 spin_lock_init(&rocker->cmd_ring_lock);
1148 err = rocker_dma_ring_bufs_alloc(rocker, &rocker->cmd_ring,
1149 PCI_DMA_BIDIRECTIONAL, PAGE_SIZE);
1151 dev_err(&pdev->dev, "failed to alloc command dma ring buffers\n");
1152 goto err_dma_cmd_ring_bufs_alloc;
1155 err = rocker_dma_ring_create(rocker, ROCKER_DMA_EVENT,
1156 ROCKER_DMA_EVENT_DEFAULT_SIZE,
1157 &rocker->event_ring);
1159 dev_err(&pdev->dev, "failed to create event dma ring\n");
1160 goto err_dma_event_ring_create;
1163 err = rocker_dma_ring_bufs_alloc(rocker, &rocker->event_ring,
1164 PCI_DMA_FROMDEVICE, PAGE_SIZE);
1166 dev_err(&pdev->dev, "failed to alloc event dma ring buffers\n");
1167 goto err_dma_event_ring_bufs_alloc;
1169 rocker_dma_ring_pass_to_producer(rocker, &rocker->event_ring);
1172 err_dma_event_ring_bufs_alloc:
1173 rocker_dma_ring_destroy(rocker, &rocker->event_ring);
1174 err_dma_event_ring_create:
1175 rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring,
1176 PCI_DMA_BIDIRECTIONAL);
1177 err_dma_cmd_ring_bufs_alloc:
1178 rocker_dma_ring_destroy(rocker, &rocker->cmd_ring);
1182 static void rocker_dma_rings_fini(struct rocker *rocker)
1184 rocker_dma_ring_bufs_free(rocker, &rocker->event_ring,
1185 PCI_DMA_BIDIRECTIONAL);
1186 rocker_dma_ring_destroy(rocker, &rocker->event_ring);
1187 rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring,
1188 PCI_DMA_BIDIRECTIONAL);
1189 rocker_dma_ring_destroy(rocker, &rocker->cmd_ring);
1192 static int rocker_dma_rx_ring_skb_map(const struct rocker_port *rocker_port,
1193 struct rocker_desc_info *desc_info,
1194 struct sk_buff *skb, size_t buf_len)
1196 const struct rocker *rocker = rocker_port->rocker;
1197 struct pci_dev *pdev = rocker->pdev;
1198 dma_addr_t dma_handle;
1200 dma_handle = pci_map_single(pdev, skb->data, buf_len,
1201 PCI_DMA_FROMDEVICE);
1202 if (pci_dma_mapping_error(pdev, dma_handle))
1204 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_RX_FRAG_ADDR, dma_handle))
1205 goto tlv_put_failure;
1206 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_RX_FRAG_MAX_LEN, buf_len))
1207 goto tlv_put_failure;
1211 pci_unmap_single(pdev, dma_handle, buf_len, PCI_DMA_FROMDEVICE);
1212 desc_info->tlv_size = 0;
1216 static size_t rocker_port_rx_buf_len(const struct rocker_port *rocker_port)
1218 return rocker_port->dev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;
1221 static int rocker_dma_rx_ring_skb_alloc(const struct rocker_port *rocker_port,
1222 struct rocker_desc_info *desc_info)
1224 struct net_device *dev = rocker_port->dev;
1225 struct sk_buff *skb;
1226 size_t buf_len = rocker_port_rx_buf_len(rocker_port);
1229 /* Ensure that hw will see tlv_size zero in case of an error.
1230 * That tells hw to use another descriptor.
1232 rocker_desc_cookie_ptr_set(desc_info, NULL);
1233 desc_info->tlv_size = 0;
1235 skb = netdev_alloc_skb_ip_align(dev, buf_len);
1238 err = rocker_dma_rx_ring_skb_map(rocker_port, desc_info, skb, buf_len);
1240 dev_kfree_skb_any(skb);
1243 rocker_desc_cookie_ptr_set(desc_info, skb);
1247 static void rocker_dma_rx_ring_skb_unmap(const struct rocker *rocker,
1248 const struct rocker_tlv **attrs)
1250 struct pci_dev *pdev = rocker->pdev;
1251 dma_addr_t dma_handle;
1254 if (!attrs[ROCKER_TLV_RX_FRAG_ADDR] ||
1255 !attrs[ROCKER_TLV_RX_FRAG_MAX_LEN])
1257 dma_handle = rocker_tlv_get_u64(attrs[ROCKER_TLV_RX_FRAG_ADDR]);
1258 len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_MAX_LEN]);
1259 pci_unmap_single(pdev, dma_handle, len, PCI_DMA_FROMDEVICE);
1262 static void rocker_dma_rx_ring_skb_free(const struct rocker *rocker,
1263 const struct rocker_desc_info *desc_info)
1265 const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1];
1266 struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info);
1270 rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info);
1271 rocker_dma_rx_ring_skb_unmap(rocker, attrs);
1272 dev_kfree_skb_any(skb);
1275 static int rocker_dma_rx_ring_skbs_alloc(const struct rocker_port *rocker_port)
1277 const struct rocker_dma_ring_info *rx_ring = &rocker_port->rx_ring;
1278 const struct rocker *rocker = rocker_port->rocker;
1282 for (i = 0; i < rx_ring->size; i++) {
1283 err = rocker_dma_rx_ring_skb_alloc(rocker_port,
1284 &rx_ring->desc_info[i]);
1291 for (i--; i >= 0; i--)
1292 rocker_dma_rx_ring_skb_free(rocker, &rx_ring->desc_info[i]);
1296 static void rocker_dma_rx_ring_skbs_free(const struct rocker_port *rocker_port)
1298 const struct rocker_dma_ring_info *rx_ring = &rocker_port->rx_ring;
1299 const struct rocker *rocker = rocker_port->rocker;
1302 for (i = 0; i < rx_ring->size; i++)
1303 rocker_dma_rx_ring_skb_free(rocker, &rx_ring->desc_info[i]);
1306 static int rocker_port_dma_rings_init(struct rocker_port *rocker_port)
1308 struct rocker *rocker = rocker_port->rocker;
1311 err = rocker_dma_ring_create(rocker,
1312 ROCKER_DMA_TX(rocker_port->port_number),
1313 ROCKER_DMA_TX_DEFAULT_SIZE,
1314 &rocker_port->tx_ring);
1316 netdev_err(rocker_port->dev, "failed to create tx dma ring\n");
1320 err = rocker_dma_ring_bufs_alloc(rocker, &rocker_port->tx_ring,
1322 ROCKER_DMA_TX_DESC_SIZE);
1324 netdev_err(rocker_port->dev, "failed to alloc tx dma ring buffers\n");
1325 goto err_dma_tx_ring_bufs_alloc;
1328 err = rocker_dma_ring_create(rocker,
1329 ROCKER_DMA_RX(rocker_port->port_number),
1330 ROCKER_DMA_RX_DEFAULT_SIZE,
1331 &rocker_port->rx_ring);
1333 netdev_err(rocker_port->dev, "failed to create rx dma ring\n");
1334 goto err_dma_rx_ring_create;
1337 err = rocker_dma_ring_bufs_alloc(rocker, &rocker_port->rx_ring,
1338 PCI_DMA_BIDIRECTIONAL,
1339 ROCKER_DMA_RX_DESC_SIZE);
1341 netdev_err(rocker_port->dev, "failed to alloc rx dma ring buffers\n");
1342 goto err_dma_rx_ring_bufs_alloc;
1345 err = rocker_dma_rx_ring_skbs_alloc(rocker_port);
1347 netdev_err(rocker_port->dev, "failed to alloc rx dma ring skbs\n");
1348 goto err_dma_rx_ring_skbs_alloc;
1350 rocker_dma_ring_pass_to_producer(rocker, &rocker_port->rx_ring);
1354 err_dma_rx_ring_skbs_alloc:
1355 rocker_dma_ring_bufs_free(rocker, &rocker_port->rx_ring,
1356 PCI_DMA_BIDIRECTIONAL);
1357 err_dma_rx_ring_bufs_alloc:
1358 rocker_dma_ring_destroy(rocker, &rocker_port->rx_ring);
1359 err_dma_rx_ring_create:
1360 rocker_dma_ring_bufs_free(rocker, &rocker_port->tx_ring,
1362 err_dma_tx_ring_bufs_alloc:
1363 rocker_dma_ring_destroy(rocker, &rocker_port->tx_ring);
1367 static void rocker_port_dma_rings_fini(struct rocker_port *rocker_port)
1369 struct rocker *rocker = rocker_port->rocker;
1371 rocker_dma_rx_ring_skbs_free(rocker_port);
1372 rocker_dma_ring_bufs_free(rocker, &rocker_port->rx_ring,
1373 PCI_DMA_BIDIRECTIONAL);
1374 rocker_dma_ring_destroy(rocker, &rocker_port->rx_ring);
1375 rocker_dma_ring_bufs_free(rocker, &rocker_port->tx_ring,
1377 rocker_dma_ring_destroy(rocker, &rocker_port->tx_ring);
1380 static void rocker_port_set_enable(const struct rocker_port *rocker_port,
1383 u64 val = rocker_read64(rocker_port->rocker, PORT_PHYS_ENABLE);
1386 val |= 1ULL << rocker_port->pport;
1388 val &= ~(1ULL << rocker_port->pport);
1389 rocker_write64(rocker_port->rocker, PORT_PHYS_ENABLE, val);
1392 /********************************
1393 * Interrupt handler and helpers
1394 ********************************/
1396 static irqreturn_t rocker_cmd_irq_handler(int irq, void *dev_id)
1398 struct rocker *rocker = dev_id;
1399 const struct rocker_desc_info *desc_info;
1400 struct rocker_wait *wait;
1403 spin_lock(&rocker->cmd_ring_lock);
1404 while ((desc_info = rocker_desc_tail_get(&rocker->cmd_ring))) {
1405 wait = rocker_desc_cookie_ptr_get(desc_info);
1407 rocker_desc_gen_clear(desc_info);
1408 rocker_wait_destroy(NULL, wait);
1410 rocker_wait_wake_up(wait);
1414 spin_unlock(&rocker->cmd_ring_lock);
1415 rocker_dma_ring_credits_set(rocker, &rocker->cmd_ring, credits);
1420 static void rocker_port_link_up(const struct rocker_port *rocker_port)
1422 netif_carrier_on(rocker_port->dev);
1423 netdev_info(rocker_port->dev, "Link is up\n");
1426 static void rocker_port_link_down(const struct rocker_port *rocker_port)
1428 netif_carrier_off(rocker_port->dev);
1429 netdev_info(rocker_port->dev, "Link is down\n");
1432 static int rocker_event_link_change(const struct rocker *rocker,
1433 const struct rocker_tlv *info)
1435 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_LINK_CHANGED_MAX + 1];
1436 unsigned int port_number;
1438 struct rocker_port *rocker_port;
1440 rocker_tlv_parse_nested(attrs, ROCKER_TLV_EVENT_LINK_CHANGED_MAX, info);
1441 if (!attrs[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT] ||
1442 !attrs[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP])
1445 rocker_tlv_get_u32(attrs[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT]) - 1;
1446 link_up = rocker_tlv_get_u8(attrs[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP]);
1448 if (port_number >= rocker->port_count)
1451 rocker_port = rocker->ports[port_number];
1452 if (netif_carrier_ok(rocker_port->dev) != link_up) {
1454 rocker_port_link_up(rocker_port);
1456 rocker_port_link_down(rocker_port);
1462 static int rocker_port_fdb(struct rocker_port *rocker_port,
1463 struct switchdev_trans *trans,
1464 const unsigned char *addr,
1465 __be16 vlan_id, int flags);
1467 static int rocker_event_mac_vlan_seen(const struct rocker *rocker,
1468 const struct rocker_tlv *info)
1470 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAX + 1];
1471 unsigned int port_number;
1472 struct rocker_port *rocker_port;
1473 const unsigned char *addr;
1474 int flags = ROCKER_OP_FLAG_NOWAIT | ROCKER_OP_FLAG_LEARNED;
1477 rocker_tlv_parse_nested(attrs, ROCKER_TLV_EVENT_MAC_VLAN_MAX, info);
1478 if (!attrs[ROCKER_TLV_EVENT_MAC_VLAN_PPORT] ||
1479 !attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAC] ||
1480 !attrs[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID])
1483 rocker_tlv_get_u32(attrs[ROCKER_TLV_EVENT_MAC_VLAN_PPORT]) - 1;
1484 addr = rocker_tlv_data(attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAC]);
1485 vlan_id = rocker_tlv_get_be16(attrs[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID]);
1487 if (port_number >= rocker->port_count)
1490 rocker_port = rocker->ports[port_number];
1492 if (rocker_port->stp_state != BR_STATE_LEARNING &&
1493 rocker_port->stp_state != BR_STATE_FORWARDING)
1496 return rocker_port_fdb(rocker_port, NULL, addr, vlan_id, flags);
1499 static int rocker_event_process(const struct rocker *rocker,
1500 const struct rocker_desc_info *desc_info)
1502 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_MAX + 1];
1503 const struct rocker_tlv *info;
1506 rocker_tlv_parse_desc(attrs, ROCKER_TLV_EVENT_MAX, desc_info);
1507 if (!attrs[ROCKER_TLV_EVENT_TYPE] ||
1508 !attrs[ROCKER_TLV_EVENT_INFO])
1511 type = rocker_tlv_get_u16(attrs[ROCKER_TLV_EVENT_TYPE]);
1512 info = attrs[ROCKER_TLV_EVENT_INFO];
1515 case ROCKER_TLV_EVENT_TYPE_LINK_CHANGED:
1516 return rocker_event_link_change(rocker, info);
1517 case ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN:
1518 return rocker_event_mac_vlan_seen(rocker, info);
1524 static irqreturn_t rocker_event_irq_handler(int irq, void *dev_id)
1526 struct rocker *rocker = dev_id;
1527 const struct pci_dev *pdev = rocker->pdev;
1528 const struct rocker_desc_info *desc_info;
1532 while ((desc_info = rocker_desc_tail_get(&rocker->event_ring))) {
1533 err = rocker_desc_err(desc_info);
1535 dev_err(&pdev->dev, "event desc received with err %d\n",
1538 err = rocker_event_process(rocker, desc_info);
1540 dev_err(&pdev->dev, "event processing failed with err %d\n",
1543 rocker_desc_gen_clear(desc_info);
1544 rocker_desc_head_set(rocker, &rocker->event_ring, desc_info);
1547 rocker_dma_ring_credits_set(rocker, &rocker->event_ring, credits);
1552 static irqreturn_t rocker_tx_irq_handler(int irq, void *dev_id)
1554 struct rocker_port *rocker_port = dev_id;
1556 napi_schedule(&rocker_port->napi_tx);
1560 static irqreturn_t rocker_rx_irq_handler(int irq, void *dev_id)
1562 struct rocker_port *rocker_port = dev_id;
1564 napi_schedule(&rocker_port->napi_rx);
1568 /********************
1570 ********************/
1572 typedef int (*rocker_cmd_prep_cb_t)(const struct rocker_port *rocker_port,
1573 struct rocker_desc_info *desc_info,
1576 typedef int (*rocker_cmd_proc_cb_t)(const struct rocker_port *rocker_port,
1577 const struct rocker_desc_info *desc_info,
1580 static int rocker_cmd_exec(struct rocker_port *rocker_port,
1581 struct switchdev_trans *trans, int flags,
1582 rocker_cmd_prep_cb_t prepare, void *prepare_priv,
1583 rocker_cmd_proc_cb_t process, void *process_priv)
1585 struct rocker *rocker = rocker_port->rocker;
1586 struct rocker_desc_info *desc_info;
1587 struct rocker_wait *wait;
1588 bool nowait = !!(flags & ROCKER_OP_FLAG_NOWAIT);
1589 unsigned long lock_flags;
1592 wait = rocker_wait_create(rocker_port, trans, flags);
1595 wait->nowait = nowait;
1597 spin_lock_irqsave(&rocker->cmd_ring_lock, lock_flags);
1599 desc_info = rocker_desc_head_get(&rocker->cmd_ring);
1601 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags);
1606 err = prepare(rocker_port, desc_info, prepare_priv);
1608 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags);
1612 rocker_desc_cookie_ptr_set(desc_info, wait);
1614 if (!switchdev_trans_ph_prepare(trans))
1615 rocker_desc_head_set(rocker, &rocker->cmd_ring, desc_info);
1617 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags);
1622 if (!switchdev_trans_ph_prepare(trans))
1623 if (!rocker_wait_event_timeout(wait, HZ / 10))
1626 err = rocker_desc_err(desc_info);
1631 err = process(rocker_port, desc_info, process_priv);
1633 rocker_desc_gen_clear(desc_info);
1635 rocker_wait_destroy(trans, wait);
1640 rocker_cmd_get_port_settings_prep(const struct rocker_port *rocker_port,
1641 struct rocker_desc_info *desc_info,
1644 struct rocker_tlv *cmd_info;
1646 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
1647 ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS))
1649 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
1652 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT,
1653 rocker_port->pport))
1655 rocker_tlv_nest_end(desc_info, cmd_info);
1660 rocker_cmd_get_port_settings_ethtool_proc(const struct rocker_port *rocker_port,
1661 const struct rocker_desc_info *desc_info,
1664 struct ethtool_cmd *ecmd = priv;
1665 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
1666 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1];
1671 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
1672 if (!attrs[ROCKER_TLV_CMD_INFO])
1675 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX,
1676 attrs[ROCKER_TLV_CMD_INFO]);
1677 if (!info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED] ||
1678 !info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX] ||
1679 !info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG])
1682 speed = rocker_tlv_get_u32(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED]);
1683 duplex = rocker_tlv_get_u8(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX]);
1684 autoneg = rocker_tlv_get_u8(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]);
1686 ecmd->transceiver = XCVR_INTERNAL;
1687 ecmd->supported = SUPPORTED_TP;
1688 ecmd->phy_address = 0xff;
1689 ecmd->port = PORT_TP;
1690 ethtool_cmd_speed_set(ecmd, speed);
1691 ecmd->duplex = duplex ? DUPLEX_FULL : DUPLEX_HALF;
1692 ecmd->autoneg = autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
1698 rocker_cmd_get_port_settings_macaddr_proc(const struct rocker_port *rocker_port,
1699 const struct rocker_desc_info *desc_info,
1702 unsigned char *macaddr = priv;
1703 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
1704 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1];
1705 const struct rocker_tlv *attr;
1707 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
1708 if (!attrs[ROCKER_TLV_CMD_INFO])
1711 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX,
1712 attrs[ROCKER_TLV_CMD_INFO]);
1713 attr = info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR];
1717 if (rocker_tlv_len(attr) != ETH_ALEN)
1720 ether_addr_copy(macaddr, rocker_tlv_data(attr));
1730 rocker_cmd_get_port_settings_phys_name_proc(const struct rocker_port *rocker_port,
1731 const struct rocker_desc_info *desc_info,
1734 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1];
1735 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
1736 struct port_name *name = priv;
1737 const struct rocker_tlv *attr;
1741 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
1742 if (!attrs[ROCKER_TLV_CMD_INFO])
1745 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX,
1746 attrs[ROCKER_TLV_CMD_INFO]);
1747 attr = info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME];
1751 len = min_t(size_t, rocker_tlv_len(attr), name->len);
1752 str = rocker_tlv_data(attr);
1754 /* make sure name only contains alphanumeric characters */
1755 for (i = j = 0; i < len; ++i) {
1756 if (isalnum(str[i])) {
1757 name->buf[j] = str[i];
1765 name->buf[j] = '\0';
1771 rocker_cmd_set_port_settings_ethtool_prep(const struct rocker_port *rocker_port,
1772 struct rocker_desc_info *desc_info,
1775 struct ethtool_cmd *ecmd = priv;
1776 struct rocker_tlv *cmd_info;
1778 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
1779 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS))
1781 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
1784 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT,
1785 rocker_port->pport))
1787 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED,
1788 ethtool_cmd_speed(ecmd)))
1790 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX,
1793 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG,
1796 rocker_tlv_nest_end(desc_info, cmd_info);
1801 rocker_cmd_set_port_settings_macaddr_prep(const struct rocker_port *rocker_port,
1802 struct rocker_desc_info *desc_info,
1805 const unsigned char *macaddr = priv;
1806 struct rocker_tlv *cmd_info;
1808 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
1809 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS))
1811 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
1814 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT,
1815 rocker_port->pport))
1817 if (rocker_tlv_put(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR,
1820 rocker_tlv_nest_end(desc_info, cmd_info);
1825 rocker_cmd_set_port_settings_mtu_prep(const struct rocker_port *rocker_port,
1826 struct rocker_desc_info *desc_info,
1829 int mtu = *(int *)priv;
1830 struct rocker_tlv *cmd_info;
1832 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
1833 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS))
1835 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
1838 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT,
1839 rocker_port->pport))
1841 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_MTU,
1844 rocker_tlv_nest_end(desc_info, cmd_info);
1849 rocker_cmd_set_port_learning_prep(const struct rocker_port *rocker_port,
1850 struct rocker_desc_info *desc_info,
1853 struct rocker_tlv *cmd_info;
1855 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
1856 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS))
1858 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
1861 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT,
1862 rocker_port->pport))
1864 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING,
1865 !!(rocker_port->brport_flags & BR_LEARNING)))
1867 rocker_tlv_nest_end(desc_info, cmd_info);
1871 static int rocker_cmd_get_port_settings_ethtool(struct rocker_port *rocker_port,
1872 struct ethtool_cmd *ecmd)
1874 return rocker_cmd_exec(rocker_port, NULL, 0,
1875 rocker_cmd_get_port_settings_prep, NULL,
1876 rocker_cmd_get_port_settings_ethtool_proc,
1880 static int rocker_cmd_get_port_settings_macaddr(struct rocker_port *rocker_port,
1881 unsigned char *macaddr)
1883 return rocker_cmd_exec(rocker_port, NULL, 0,
1884 rocker_cmd_get_port_settings_prep, NULL,
1885 rocker_cmd_get_port_settings_macaddr_proc,
1889 static int rocker_cmd_set_port_settings_ethtool(struct rocker_port *rocker_port,
1890 struct ethtool_cmd *ecmd)
1892 return rocker_cmd_exec(rocker_port, NULL, 0,
1893 rocker_cmd_set_port_settings_ethtool_prep,
1897 static int rocker_cmd_set_port_settings_macaddr(struct rocker_port *rocker_port,
1898 unsigned char *macaddr)
1900 return rocker_cmd_exec(rocker_port, NULL, 0,
1901 rocker_cmd_set_port_settings_macaddr_prep,
1902 macaddr, NULL, NULL);
1905 static int rocker_cmd_set_port_settings_mtu(struct rocker_port *rocker_port,
1908 return rocker_cmd_exec(rocker_port, NULL, 0,
1909 rocker_cmd_set_port_settings_mtu_prep,
1913 static int rocker_port_set_learning(struct rocker_port *rocker_port,
1914 struct switchdev_trans *trans)
1916 return rocker_cmd_exec(rocker_port, trans, 0,
1917 rocker_cmd_set_port_learning_prep,
1922 rocker_cmd_flow_tbl_add_ig_port(struct rocker_desc_info *desc_info,
1923 const struct rocker_flow_tbl_entry *entry)
1925 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
1926 entry->key.ig_port.in_pport))
1928 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
1929 entry->key.ig_port.in_pport_mask))
1931 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
1932 entry->key.ig_port.goto_tbl))
1939 rocker_cmd_flow_tbl_add_vlan(struct rocker_desc_info *desc_info,
1940 const struct rocker_flow_tbl_entry *entry)
1942 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
1943 entry->key.vlan.in_pport))
1945 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
1946 entry->key.vlan.vlan_id))
1948 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
1949 entry->key.vlan.vlan_id_mask))
1951 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
1952 entry->key.vlan.goto_tbl))
1954 if (entry->key.vlan.untagged &&
1955 rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_NEW_VLAN_ID,
1956 entry->key.vlan.new_vlan_id))
1963 rocker_cmd_flow_tbl_add_term_mac(struct rocker_desc_info *desc_info,
1964 const struct rocker_flow_tbl_entry *entry)
1966 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
1967 entry->key.term_mac.in_pport))
1969 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
1970 entry->key.term_mac.in_pport_mask))
1972 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
1973 entry->key.term_mac.eth_type))
1975 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
1976 ETH_ALEN, entry->key.term_mac.eth_dst))
1978 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
1979 ETH_ALEN, entry->key.term_mac.eth_dst_mask))
1981 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
1982 entry->key.term_mac.vlan_id))
1984 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
1985 entry->key.term_mac.vlan_id_mask))
1987 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
1988 entry->key.term_mac.goto_tbl))
1990 if (entry->key.term_mac.copy_to_cpu &&
1991 rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_COPY_CPU_ACTION,
1992 entry->key.term_mac.copy_to_cpu))
1999 rocker_cmd_flow_tbl_add_ucast_routing(struct rocker_desc_info *desc_info,
2000 const struct rocker_flow_tbl_entry *entry)
2002 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
2003 entry->key.ucast_routing.eth_type))
2005 if (rocker_tlv_put_be32(desc_info, ROCKER_TLV_OF_DPA_DST_IP,
2006 entry->key.ucast_routing.dst4))
2008 if (rocker_tlv_put_be32(desc_info, ROCKER_TLV_OF_DPA_DST_IP_MASK,
2009 entry->key.ucast_routing.dst4_mask))
2011 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
2012 entry->key.ucast_routing.goto_tbl))
2014 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
2015 entry->key.ucast_routing.group_id))
2022 rocker_cmd_flow_tbl_add_bridge(struct rocker_desc_info *desc_info,
2023 const struct rocker_flow_tbl_entry *entry)
2025 if (entry->key.bridge.has_eth_dst &&
2026 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
2027 ETH_ALEN, entry->key.bridge.eth_dst))
2029 if (entry->key.bridge.has_eth_dst_mask &&
2030 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
2031 ETH_ALEN, entry->key.bridge.eth_dst_mask))
2033 if (entry->key.bridge.vlan_id &&
2034 rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
2035 entry->key.bridge.vlan_id))
2037 if (entry->key.bridge.tunnel_id &&
2038 rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_TUNNEL_ID,
2039 entry->key.bridge.tunnel_id))
2041 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
2042 entry->key.bridge.goto_tbl))
2044 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
2045 entry->key.bridge.group_id))
2047 if (entry->key.bridge.copy_to_cpu &&
2048 rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_COPY_CPU_ACTION,
2049 entry->key.bridge.copy_to_cpu))
2056 rocker_cmd_flow_tbl_add_acl(struct rocker_desc_info *desc_info,
2057 const struct rocker_flow_tbl_entry *entry)
2059 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
2060 entry->key.acl.in_pport))
2062 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
2063 entry->key.acl.in_pport_mask))
2065 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
2066 ETH_ALEN, entry->key.acl.eth_src))
2068 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC_MASK,
2069 ETH_ALEN, entry->key.acl.eth_src_mask))
2071 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
2072 ETH_ALEN, entry->key.acl.eth_dst))
2074 if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
2075 ETH_ALEN, entry->key.acl.eth_dst_mask))
2077 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
2078 entry->key.acl.eth_type))
2080 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
2081 entry->key.acl.vlan_id))
2083 if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
2084 entry->key.acl.vlan_id_mask))
2087 switch (ntohs(entry->key.acl.eth_type)) {
2090 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_PROTO,
2091 entry->key.acl.ip_proto))
2093 if (rocker_tlv_put_u8(desc_info,
2094 ROCKER_TLV_OF_DPA_IP_PROTO_MASK,
2095 entry->key.acl.ip_proto_mask))
2097 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_DSCP,
2098 entry->key.acl.ip_tos & 0x3f))
2100 if (rocker_tlv_put_u8(desc_info,
2101 ROCKER_TLV_OF_DPA_IP_DSCP_MASK,
2102 entry->key.acl.ip_tos_mask & 0x3f))
2104 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_ECN,
2105 (entry->key.acl.ip_tos & 0xc0) >> 6))
2107 if (rocker_tlv_put_u8(desc_info,
2108 ROCKER_TLV_OF_DPA_IP_ECN_MASK,
2109 (entry->key.acl.ip_tos_mask & 0xc0) >> 6))
2114 if (entry->key.acl.group_id != ROCKER_GROUP_NONE &&
2115 rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
2116 entry->key.acl.group_id))
2122 static int rocker_cmd_flow_tbl_add(const struct rocker_port *rocker_port,
2123 struct rocker_desc_info *desc_info,
2126 const struct rocker_flow_tbl_entry *entry = priv;
2127 struct rocker_tlv *cmd_info;
2130 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
2132 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2135 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_TABLE_ID,
2138 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_PRIORITY,
2139 entry->key.priority))
2141 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_HARDTIME, 0))
2143 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_OF_DPA_COOKIE,
2147 switch (entry->key.tbl_id) {
2148 case ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT:
2149 err = rocker_cmd_flow_tbl_add_ig_port(desc_info, entry);
2151 case ROCKER_OF_DPA_TABLE_ID_VLAN:
2152 err = rocker_cmd_flow_tbl_add_vlan(desc_info, entry);
2154 case ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC:
2155 err = rocker_cmd_flow_tbl_add_term_mac(desc_info, entry);
2157 case ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING:
2158 err = rocker_cmd_flow_tbl_add_ucast_routing(desc_info, entry);
2160 case ROCKER_OF_DPA_TABLE_ID_BRIDGING:
2161 err = rocker_cmd_flow_tbl_add_bridge(desc_info, entry);
2163 case ROCKER_OF_DPA_TABLE_ID_ACL_POLICY:
2164 err = rocker_cmd_flow_tbl_add_acl(desc_info, entry);
2174 rocker_tlv_nest_end(desc_info, cmd_info);
2179 static int rocker_cmd_flow_tbl_del(const struct rocker_port *rocker_port,
2180 struct rocker_desc_info *desc_info,
2183 const struct rocker_flow_tbl_entry *entry = priv;
2184 struct rocker_tlv *cmd_info;
2186 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
2188 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2191 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_OF_DPA_COOKIE,
2194 rocker_tlv_nest_end(desc_info, cmd_info);
2200 rocker_cmd_group_tbl_add_l2_interface(struct rocker_desc_info *desc_info,
2201 struct rocker_group_tbl_entry *entry)
2203 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_OUT_PPORT,
2204 ROCKER_GROUP_PORT_GET(entry->group_id)))
2206 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_POP_VLAN,
2207 entry->l2_interface.pop_vlan))
2214 rocker_cmd_group_tbl_add_l2_rewrite(struct rocker_desc_info *desc_info,
2215 const struct rocker_group_tbl_entry *entry)
2217 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID_LOWER,
2218 entry->l2_rewrite.group_id))
2220 if (!is_zero_ether_addr(entry->l2_rewrite.eth_src) &&
2221 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
2222 ETH_ALEN, entry->l2_rewrite.eth_src))
2224 if (!is_zero_ether_addr(entry->l2_rewrite.eth_dst) &&
2225 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
2226 ETH_ALEN, entry->l2_rewrite.eth_dst))
2228 if (entry->l2_rewrite.vlan_id &&
2229 rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
2230 entry->l2_rewrite.vlan_id))
2237 rocker_cmd_group_tbl_add_group_ids(struct rocker_desc_info *desc_info,
2238 const struct rocker_group_tbl_entry *entry)
2241 struct rocker_tlv *group_ids;
2243 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GROUP_COUNT,
2244 entry->group_count))
2247 group_ids = rocker_tlv_nest_start(desc_info,
2248 ROCKER_TLV_OF_DPA_GROUP_IDS);
2252 for (i = 0; i < entry->group_count; i++)
2253 /* Note TLV array is 1-based */
2254 if (rocker_tlv_put_u32(desc_info, i + 1, entry->group_ids[i]))
2257 rocker_tlv_nest_end(desc_info, group_ids);
2263 rocker_cmd_group_tbl_add_l3_unicast(struct rocker_desc_info *desc_info,
2264 const struct rocker_group_tbl_entry *entry)
2266 if (!is_zero_ether_addr(entry->l3_unicast.eth_src) &&
2267 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
2268 ETH_ALEN, entry->l3_unicast.eth_src))
2270 if (!is_zero_ether_addr(entry->l3_unicast.eth_dst) &&
2271 rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
2272 ETH_ALEN, entry->l3_unicast.eth_dst))
2274 if (entry->l3_unicast.vlan_id &&
2275 rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
2276 entry->l3_unicast.vlan_id))
2278 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_TTL_CHECK,
2279 entry->l3_unicast.ttl_check))
2281 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID_LOWER,
2282 entry->l3_unicast.group_id))
2288 static int rocker_cmd_group_tbl_add(const struct rocker_port *rocker_port,
2289 struct rocker_desc_info *desc_info,
2292 struct rocker_group_tbl_entry *entry = priv;
2293 struct rocker_tlv *cmd_info;
2296 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
2298 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2302 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
2306 switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) {
2307 case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
2308 err = rocker_cmd_group_tbl_add_l2_interface(desc_info, entry);
2310 case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
2311 err = rocker_cmd_group_tbl_add_l2_rewrite(desc_info, entry);
2313 case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
2314 case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
2315 err = rocker_cmd_group_tbl_add_group_ids(desc_info, entry);
2317 case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST:
2318 err = rocker_cmd_group_tbl_add_l3_unicast(desc_info, entry);
2328 rocker_tlv_nest_end(desc_info, cmd_info);
2333 static int rocker_cmd_group_tbl_del(const struct rocker_port *rocker_port,
2334 struct rocker_desc_info *desc_info,
2337 const struct rocker_group_tbl_entry *entry = priv;
2338 struct rocker_tlv *cmd_info;
2340 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
2342 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2345 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
2348 rocker_tlv_nest_end(desc_info, cmd_info);
2353 /***************************************************
2354 * Flow, group, FDB, internal VLAN and neigh tables
2355 ***************************************************/
2357 static int rocker_init_tbls(struct rocker *rocker)
2359 hash_init(rocker->flow_tbl);
2360 spin_lock_init(&rocker->flow_tbl_lock);
2362 hash_init(rocker->group_tbl);
2363 spin_lock_init(&rocker->group_tbl_lock);
2365 hash_init(rocker->fdb_tbl);
2366 spin_lock_init(&rocker->fdb_tbl_lock);
2368 hash_init(rocker->internal_vlan_tbl);
2369 spin_lock_init(&rocker->internal_vlan_tbl_lock);
2371 hash_init(rocker->neigh_tbl);
2372 spin_lock_init(&rocker->neigh_tbl_lock);
2377 static void rocker_free_tbls(struct rocker *rocker)
2379 unsigned long flags;
2380 struct rocker_flow_tbl_entry *flow_entry;
2381 struct rocker_group_tbl_entry *group_entry;
2382 struct rocker_fdb_tbl_entry *fdb_entry;
2383 struct rocker_internal_vlan_tbl_entry *internal_vlan_entry;
2384 struct rocker_neigh_tbl_entry *neigh_entry;
2385 struct hlist_node *tmp;
2388 spin_lock_irqsave(&rocker->flow_tbl_lock, flags);
2389 hash_for_each_safe(rocker->flow_tbl, bkt, tmp, flow_entry, entry)
2390 hash_del(&flow_entry->entry);
2391 spin_unlock_irqrestore(&rocker->flow_tbl_lock, flags);
2393 spin_lock_irqsave(&rocker->group_tbl_lock, flags);
2394 hash_for_each_safe(rocker->group_tbl, bkt, tmp, group_entry, entry)
2395 hash_del(&group_entry->entry);
2396 spin_unlock_irqrestore(&rocker->group_tbl_lock, flags);
2398 spin_lock_irqsave(&rocker->fdb_tbl_lock, flags);
2399 hash_for_each_safe(rocker->fdb_tbl, bkt, tmp, fdb_entry, entry)
2400 hash_del(&fdb_entry->entry);
2401 spin_unlock_irqrestore(&rocker->fdb_tbl_lock, flags);
2403 spin_lock_irqsave(&rocker->internal_vlan_tbl_lock, flags);
2404 hash_for_each_safe(rocker->internal_vlan_tbl, bkt,
2405 tmp, internal_vlan_entry, entry)
2406 hash_del(&internal_vlan_entry->entry);
2407 spin_unlock_irqrestore(&rocker->internal_vlan_tbl_lock, flags);
2409 spin_lock_irqsave(&rocker->neigh_tbl_lock, flags);
2410 hash_for_each_safe(rocker->neigh_tbl, bkt, tmp, neigh_entry, entry)
2411 hash_del(&neigh_entry->entry);
2412 spin_unlock_irqrestore(&rocker->neigh_tbl_lock, flags);
2415 static struct rocker_flow_tbl_entry *
2416 rocker_flow_tbl_find(const struct rocker *rocker,
2417 const struct rocker_flow_tbl_entry *match)
2419 struct rocker_flow_tbl_entry *found;
2420 size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
2422 hash_for_each_possible(rocker->flow_tbl, found,
2423 entry, match->key_crc32) {
2424 if (memcmp(&found->key, &match->key, key_len) == 0)
2431 static int rocker_flow_tbl_add(struct rocker_port *rocker_port,
2432 struct switchdev_trans *trans, int flags,
2433 struct rocker_flow_tbl_entry *match)
2435 struct rocker *rocker = rocker_port->rocker;
2436 struct rocker_flow_tbl_entry *found;
2437 size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
2438 unsigned long lock_flags;
2440 match->key_crc32 = crc32(~0, &match->key, key_len);
2442 spin_lock_irqsave(&rocker->flow_tbl_lock, lock_flags);
2444 found = rocker_flow_tbl_find(rocker, match);
2447 match->cookie = found->cookie;
2448 if (!switchdev_trans_ph_prepare(trans))
2449 hash_del(&found->entry);
2450 rocker_port_kfree(trans, found);
2452 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD;
2455 found->cookie = rocker->flow_tbl_next_cookie++;
2456 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD;
2459 if (!switchdev_trans_ph_prepare(trans))
2460 hash_add(rocker->flow_tbl, &found->entry, found->key_crc32);
2462 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags);
2464 return rocker_cmd_exec(rocker_port, trans, flags,
2465 rocker_cmd_flow_tbl_add, found, NULL, NULL);
2468 static int rocker_flow_tbl_del(struct rocker_port *rocker_port,
2469 struct switchdev_trans *trans, int flags,
2470 struct rocker_flow_tbl_entry *match)
2472 struct rocker *rocker = rocker_port->rocker;
2473 struct rocker_flow_tbl_entry *found;
2474 size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
2475 unsigned long lock_flags;
2478 match->key_crc32 = crc32(~0, &match->key, key_len);
2480 spin_lock_irqsave(&rocker->flow_tbl_lock, lock_flags);
2482 found = rocker_flow_tbl_find(rocker, match);
2485 if (!switchdev_trans_ph_prepare(trans))
2486 hash_del(&found->entry);
2487 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL;
2490 spin_unlock_irqrestore(&rocker->flow_tbl_lock, lock_flags);
2492 rocker_port_kfree(trans, match);
2495 err = rocker_cmd_exec(rocker_port, trans, flags,
2496 rocker_cmd_flow_tbl_del,
2498 rocker_port_kfree(trans, found);
2504 static int rocker_flow_tbl_do(struct rocker_port *rocker_port,
2505 struct switchdev_trans *trans, int flags,
2506 struct rocker_flow_tbl_entry *entry)
2508 if (flags & ROCKER_OP_FLAG_REMOVE)
2509 return rocker_flow_tbl_del(rocker_port, trans, flags, entry);
2511 return rocker_flow_tbl_add(rocker_port, trans, flags, entry);
2514 static int rocker_flow_tbl_ig_port(struct rocker_port *rocker_port,
2515 struct switchdev_trans *trans, int flags,
2516 u32 in_pport, u32 in_pport_mask,
2517 enum rocker_of_dpa_table_id goto_tbl)
2519 struct rocker_flow_tbl_entry *entry;
2521 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2525 entry->key.priority = ROCKER_PRIORITY_IG_PORT;
2526 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT;
2527 entry->key.ig_port.in_pport = in_pport;
2528 entry->key.ig_port.in_pport_mask = in_pport_mask;
2529 entry->key.ig_port.goto_tbl = goto_tbl;
2531 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2534 static int rocker_flow_tbl_vlan(struct rocker_port *rocker_port,
2535 struct switchdev_trans *trans, int flags,
2536 u32 in_pport, __be16 vlan_id,
2537 __be16 vlan_id_mask,
2538 enum rocker_of_dpa_table_id goto_tbl,
2539 bool untagged, __be16 new_vlan_id)
2541 struct rocker_flow_tbl_entry *entry;
2543 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2547 entry->key.priority = ROCKER_PRIORITY_VLAN;
2548 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN;
2549 entry->key.vlan.in_pport = in_pport;
2550 entry->key.vlan.vlan_id = vlan_id;
2551 entry->key.vlan.vlan_id_mask = vlan_id_mask;
2552 entry->key.vlan.goto_tbl = goto_tbl;
2554 entry->key.vlan.untagged = untagged;
2555 entry->key.vlan.new_vlan_id = new_vlan_id;
2557 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2560 static int rocker_flow_tbl_term_mac(struct rocker_port *rocker_port,
2561 struct switchdev_trans *trans,
2562 u32 in_pport, u32 in_pport_mask,
2563 __be16 eth_type, const u8 *eth_dst,
2564 const u8 *eth_dst_mask, __be16 vlan_id,
2565 __be16 vlan_id_mask, bool copy_to_cpu,
2568 struct rocker_flow_tbl_entry *entry;
2570 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2574 if (is_multicast_ether_addr(eth_dst)) {
2575 entry->key.priority = ROCKER_PRIORITY_TERM_MAC_MCAST;
2576 entry->key.term_mac.goto_tbl =
2577 ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING;
2579 entry->key.priority = ROCKER_PRIORITY_TERM_MAC_UCAST;
2580 entry->key.term_mac.goto_tbl =
2581 ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
2584 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
2585 entry->key.term_mac.in_pport = in_pport;
2586 entry->key.term_mac.in_pport_mask = in_pport_mask;
2587 entry->key.term_mac.eth_type = eth_type;
2588 ether_addr_copy(entry->key.term_mac.eth_dst, eth_dst);
2589 ether_addr_copy(entry->key.term_mac.eth_dst_mask, eth_dst_mask);
2590 entry->key.term_mac.vlan_id = vlan_id;
2591 entry->key.term_mac.vlan_id_mask = vlan_id_mask;
2592 entry->key.term_mac.copy_to_cpu = copy_to_cpu;
2594 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2597 static int rocker_flow_tbl_bridge(struct rocker_port *rocker_port,
2598 struct switchdev_trans *trans, int flags,
2599 const u8 *eth_dst, const u8 *eth_dst_mask,
2600 __be16 vlan_id, u32 tunnel_id,
2601 enum rocker_of_dpa_table_id goto_tbl,
2602 u32 group_id, bool copy_to_cpu)
2604 struct rocker_flow_tbl_entry *entry;
2606 bool vlan_bridging = !!vlan_id;
2607 bool dflt = !eth_dst || (eth_dst && eth_dst_mask);
2610 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2614 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING;
2617 entry->key.bridge.has_eth_dst = 1;
2618 ether_addr_copy(entry->key.bridge.eth_dst, eth_dst);
2621 entry->key.bridge.has_eth_dst_mask = 1;
2622 ether_addr_copy(entry->key.bridge.eth_dst_mask, eth_dst_mask);
2623 if (!ether_addr_equal(eth_dst_mask, ff_mac))
2627 priority = ROCKER_PRIORITY_UNKNOWN;
2628 if (vlan_bridging && dflt && wild)
2629 priority = ROCKER_PRIORITY_BRIDGING_VLAN_DFLT_WILD;
2630 else if (vlan_bridging && dflt && !wild)
2631 priority = ROCKER_PRIORITY_BRIDGING_VLAN_DFLT_EXACT;
2632 else if (vlan_bridging && !dflt)
2633 priority = ROCKER_PRIORITY_BRIDGING_VLAN;
2634 else if (!vlan_bridging && dflt && wild)
2635 priority = ROCKER_PRIORITY_BRIDGING_TENANT_DFLT_WILD;
2636 else if (!vlan_bridging && dflt && !wild)
2637 priority = ROCKER_PRIORITY_BRIDGING_TENANT_DFLT_EXACT;
2638 else if (!vlan_bridging && !dflt)
2639 priority = ROCKER_PRIORITY_BRIDGING_TENANT;
2641 entry->key.priority = priority;
2642 entry->key.bridge.vlan_id = vlan_id;
2643 entry->key.bridge.tunnel_id = tunnel_id;
2644 entry->key.bridge.goto_tbl = goto_tbl;
2645 entry->key.bridge.group_id = group_id;
2646 entry->key.bridge.copy_to_cpu = copy_to_cpu;
2648 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2651 static int rocker_flow_tbl_ucast4_routing(struct rocker_port *rocker_port,
2652 struct switchdev_trans *trans,
2653 __be16 eth_type, __be32 dst,
2654 __be32 dst_mask, u32 priority,
2655 enum rocker_of_dpa_table_id goto_tbl,
2656 u32 group_id, int flags)
2658 struct rocker_flow_tbl_entry *entry;
2660 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2664 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
2665 entry->key.priority = priority;
2666 entry->key.ucast_routing.eth_type = eth_type;
2667 entry->key.ucast_routing.dst4 = dst;
2668 entry->key.ucast_routing.dst4_mask = dst_mask;
2669 entry->key.ucast_routing.goto_tbl = goto_tbl;
2670 entry->key.ucast_routing.group_id = group_id;
2671 entry->key_len = offsetof(struct rocker_flow_tbl_key,
2672 ucast_routing.group_id);
2674 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2677 static int rocker_flow_tbl_acl(struct rocker_port *rocker_port,
2678 struct switchdev_trans *trans, int flags,
2679 u32 in_pport, u32 in_pport_mask,
2680 const u8 *eth_src, const u8 *eth_src_mask,
2681 const u8 *eth_dst, const u8 *eth_dst_mask,
2682 __be16 eth_type, __be16 vlan_id,
2683 __be16 vlan_id_mask, u8 ip_proto,
2684 u8 ip_proto_mask, u8 ip_tos, u8 ip_tos_mask,
2688 struct rocker_flow_tbl_entry *entry;
2690 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2694 priority = ROCKER_PRIORITY_ACL_NORMAL;
2695 if (eth_dst && eth_dst_mask) {
2696 if (ether_addr_equal(eth_dst_mask, mcast_mac))
2697 priority = ROCKER_PRIORITY_ACL_DFLT;
2698 else if (is_link_local_ether_addr(eth_dst))
2699 priority = ROCKER_PRIORITY_ACL_CTRL;
2702 entry->key.priority = priority;
2703 entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
2704 entry->key.acl.in_pport = in_pport;
2705 entry->key.acl.in_pport_mask = in_pport_mask;
2708 ether_addr_copy(entry->key.acl.eth_src, eth_src);
2710 ether_addr_copy(entry->key.acl.eth_src_mask, eth_src_mask);
2712 ether_addr_copy(entry->key.acl.eth_dst, eth_dst);
2714 ether_addr_copy(entry->key.acl.eth_dst_mask, eth_dst_mask);
2716 entry->key.acl.eth_type = eth_type;
2717 entry->key.acl.vlan_id = vlan_id;
2718 entry->key.acl.vlan_id_mask = vlan_id_mask;
2719 entry->key.acl.ip_proto = ip_proto;
2720 entry->key.acl.ip_proto_mask = ip_proto_mask;
2721 entry->key.acl.ip_tos = ip_tos;
2722 entry->key.acl.ip_tos_mask = ip_tos_mask;
2723 entry->key.acl.group_id = group_id;
2725 return rocker_flow_tbl_do(rocker_port, trans, flags, entry);
2728 static struct rocker_group_tbl_entry *
2729 rocker_group_tbl_find(const struct rocker *rocker,
2730 const struct rocker_group_tbl_entry *match)
2732 struct rocker_group_tbl_entry *found;
2734 hash_for_each_possible(rocker->group_tbl, found,
2735 entry, match->group_id) {
2736 if (found->group_id == match->group_id)
2743 static void rocker_group_tbl_entry_free(struct switchdev_trans *trans,
2744 struct rocker_group_tbl_entry *entry)
2746 switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) {
2747 case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
2748 case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
2749 rocker_port_kfree(trans, entry->group_ids);
2754 rocker_port_kfree(trans, entry);
2757 static int rocker_group_tbl_add(struct rocker_port *rocker_port,
2758 struct switchdev_trans *trans, int flags,
2759 struct rocker_group_tbl_entry *match)
2761 struct rocker *rocker = rocker_port->rocker;
2762 struct rocker_group_tbl_entry *found;
2763 unsigned long lock_flags;
2765 spin_lock_irqsave(&rocker->group_tbl_lock, lock_flags);
2767 found = rocker_group_tbl_find(rocker, match);
2770 if (!switchdev_trans_ph_prepare(trans))
2771 hash_del(&found->entry);
2772 rocker_group_tbl_entry_free(trans, found);
2774 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD;
2777 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD;
2780 if (!switchdev_trans_ph_prepare(trans))
2781 hash_add(rocker->group_tbl, &found->entry, found->group_id);
2783 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags);
2785 return rocker_cmd_exec(rocker_port, trans, flags,
2786 rocker_cmd_group_tbl_add, found, NULL, NULL);
2789 static int rocker_group_tbl_del(struct rocker_port *rocker_port,
2790 struct switchdev_trans *trans, int flags,
2791 struct rocker_group_tbl_entry *match)
2793 struct rocker *rocker = rocker_port->rocker;
2794 struct rocker_group_tbl_entry *found;
2795 unsigned long lock_flags;
2798 spin_lock_irqsave(&rocker->group_tbl_lock, lock_flags);
2800 found = rocker_group_tbl_find(rocker, match);
2803 if (!switchdev_trans_ph_prepare(trans))
2804 hash_del(&found->entry);
2805 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL;
2808 spin_unlock_irqrestore(&rocker->group_tbl_lock, lock_flags);
2810 rocker_group_tbl_entry_free(trans, match);
2813 err = rocker_cmd_exec(rocker_port, trans, flags,
2814 rocker_cmd_group_tbl_del,
2816 rocker_group_tbl_entry_free(trans, found);
2822 static int rocker_group_tbl_do(struct rocker_port *rocker_port,
2823 struct switchdev_trans *trans, int flags,
2824 struct rocker_group_tbl_entry *entry)
2826 if (flags & ROCKER_OP_FLAG_REMOVE)
2827 return rocker_group_tbl_del(rocker_port, trans, flags, entry);
2829 return rocker_group_tbl_add(rocker_port, trans, flags, entry);
2832 static int rocker_group_l2_interface(struct rocker_port *rocker_port,
2833 struct switchdev_trans *trans, int flags,
2834 __be16 vlan_id, u32 out_pport,
2837 struct rocker_group_tbl_entry *entry;
2839 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2843 entry->group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
2844 entry->l2_interface.pop_vlan = pop_vlan;
2846 return rocker_group_tbl_do(rocker_port, trans, flags, entry);
2849 static int rocker_group_l2_fan_out(struct rocker_port *rocker_port,
2850 struct switchdev_trans *trans,
2851 int flags, u8 group_count,
2852 const u32 *group_ids, u32 group_id)
2854 struct rocker_group_tbl_entry *entry;
2856 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2860 entry->group_id = group_id;
2861 entry->group_count = group_count;
2863 entry->group_ids = rocker_port_kcalloc(rocker_port, trans, flags,
2864 group_count, sizeof(u32));
2865 if (!entry->group_ids) {
2866 rocker_port_kfree(trans, entry);
2869 memcpy(entry->group_ids, group_ids, group_count * sizeof(u32));
2871 return rocker_group_tbl_do(rocker_port, trans, flags, entry);
2874 static int rocker_group_l2_flood(struct rocker_port *rocker_port,
2875 struct switchdev_trans *trans, int flags,
2876 __be16 vlan_id, u8 group_count,
2877 const u32 *group_ids, u32 group_id)
2879 return rocker_group_l2_fan_out(rocker_port, trans, flags,
2880 group_count, group_ids,
2884 static int rocker_group_l3_unicast(struct rocker_port *rocker_port,
2885 struct switchdev_trans *trans, int flags,
2886 u32 index, const u8 *src_mac, const u8 *dst_mac,
2887 __be16 vlan_id, bool ttl_check, u32 pport)
2889 struct rocker_group_tbl_entry *entry;
2891 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2895 entry->group_id = ROCKER_GROUP_L3_UNICAST(index);
2897 ether_addr_copy(entry->l3_unicast.eth_src, src_mac);
2899 ether_addr_copy(entry->l3_unicast.eth_dst, dst_mac);
2900 entry->l3_unicast.vlan_id = vlan_id;
2901 entry->l3_unicast.ttl_check = ttl_check;
2902 entry->l3_unicast.group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, pport);
2904 return rocker_group_tbl_do(rocker_port, trans, flags, entry);
2907 static struct rocker_neigh_tbl_entry *
2908 rocker_neigh_tbl_find(const struct rocker *rocker, __be32 ip_addr)
2910 struct rocker_neigh_tbl_entry *found;
2912 hash_for_each_possible(rocker->neigh_tbl, found,
2913 entry, be32_to_cpu(ip_addr))
2914 if (found->ip_addr == ip_addr)
2920 static void _rocker_neigh_add(struct rocker *rocker,
2921 struct switchdev_trans *trans,
2922 struct rocker_neigh_tbl_entry *entry)
2924 if (!switchdev_trans_ph_commit(trans))
2925 entry->index = rocker->neigh_tbl_next_index++;
2926 if (switchdev_trans_ph_prepare(trans))
2929 hash_add(rocker->neigh_tbl, &entry->entry,
2930 be32_to_cpu(entry->ip_addr));
2933 static void _rocker_neigh_del(struct switchdev_trans *trans,
2934 struct rocker_neigh_tbl_entry *entry)
2936 if (switchdev_trans_ph_prepare(trans))
2938 if (--entry->ref_count == 0) {
2939 hash_del(&entry->entry);
2940 rocker_port_kfree(trans, entry);
2944 static void _rocker_neigh_update(struct rocker_neigh_tbl_entry *entry,
2945 struct switchdev_trans *trans,
2946 const u8 *eth_dst, bool ttl_check)
2949 ether_addr_copy(entry->eth_dst, eth_dst);
2950 entry->ttl_check = ttl_check;
2951 } else if (!switchdev_trans_ph_prepare(trans)) {
2956 static int rocker_port_ipv4_neigh(struct rocker_port *rocker_port,
2957 struct switchdev_trans *trans,
2958 int flags, __be32 ip_addr, const u8 *eth_dst)
2960 struct rocker *rocker = rocker_port->rocker;
2961 struct rocker_neigh_tbl_entry *entry;
2962 struct rocker_neigh_tbl_entry *found;
2963 unsigned long lock_flags;
2964 __be16 eth_type = htons(ETH_P_IP);
2965 enum rocker_of_dpa_table_id goto_tbl =
2966 ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
2969 bool adding = !(flags & ROCKER_OP_FLAG_REMOVE);
2974 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
2978 spin_lock_irqsave(&rocker->neigh_tbl_lock, lock_flags);
2980 found = rocker_neigh_tbl_find(rocker, ip_addr);
2982 updating = found && adding;
2983 removing = found && !adding;
2984 adding = !found && adding;
2987 entry->ip_addr = ip_addr;
2988 entry->dev = rocker_port->dev;
2989 ether_addr_copy(entry->eth_dst, eth_dst);
2990 entry->ttl_check = true;
2991 _rocker_neigh_add(rocker, trans, entry);
2992 } else if (removing) {
2993 memcpy(entry, found, sizeof(*entry));
2994 _rocker_neigh_del(trans, found);
2995 } else if (updating) {
2996 _rocker_neigh_update(found, trans, eth_dst, true);
2997 memcpy(entry, found, sizeof(*entry));
3002 spin_unlock_irqrestore(&rocker->neigh_tbl_lock, lock_flags);
3007 /* For each active neighbor, we have an L3 unicast group and
3008 * a /32 route to the neighbor, which uses the L3 unicast
3009 * group. The L3 unicast group can also be referred to by
3010 * other routes' nexthops.
3013 err = rocker_group_l3_unicast(rocker_port, trans, flags,
3015 rocker_port->dev->dev_addr,
3017 rocker_port->internal_vlan_id,
3019 rocker_port->pport);
3021 netdev_err(rocker_port->dev,
3022 "Error (%d) L3 unicast group index %d\n",
3027 if (adding || removing) {
3028 group_id = ROCKER_GROUP_L3_UNICAST(entry->index);
3029 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans,
3036 netdev_err(rocker_port->dev,
3037 "Error (%d) /32 unicast route %pI4 group 0x%08x\n",
3038 err, &entry->ip_addr, group_id);
3043 rocker_port_kfree(trans, entry);
3048 static int rocker_port_ipv4_resolve(struct rocker_port *rocker_port,
3049 struct switchdev_trans *trans,
3052 struct net_device *dev = rocker_port->dev;
3053 struct neighbour *n = __ipv4_neigh_lookup(dev, (__force u32)ip_addr);
3057 n = neigh_create(&arp_tbl, &ip_addr, dev);
3062 /* If the neigh is already resolved, then go ahead and
3063 * install the entry, otherwise start the ARP process to
3064 * resolve the neigh.
3067 if (n->nud_state & NUD_VALID)
3068 err = rocker_port_ipv4_neigh(rocker_port, trans, 0,
3071 neigh_event_send(n, NULL);
3077 static int rocker_port_ipv4_nh(struct rocker_port *rocker_port,
3078 struct switchdev_trans *trans, int flags,
3079 __be32 ip_addr, u32 *index)
3081 struct rocker *rocker = rocker_port->rocker;
3082 struct rocker_neigh_tbl_entry *entry;
3083 struct rocker_neigh_tbl_entry *found;
3084 unsigned long lock_flags;
3085 bool adding = !(flags & ROCKER_OP_FLAG_REMOVE);
3088 bool resolved = true;
3091 entry = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*entry));
3095 spin_lock_irqsave(&rocker->neigh_tbl_lock, lock_flags);
3097 found = rocker_neigh_tbl_find(rocker, ip_addr);
3099 *index = found->index;
3101 updating = found && adding;
3102 removing = found && !adding;
3103 adding = !found && adding;
3106 entry->ip_addr = ip_addr;
3107 entry->dev = rocker_port->dev;
3108 _rocker_neigh_add(rocker, trans, entry);
3109 *index = entry->index;
3111 } else if (removing) {
3112 _rocker_neigh_del(trans, found);
3113 } else if (updating) {
3114 _rocker_neigh_update(found, trans, NULL, false);
3115 resolved = !is_zero_ether_addr(found->eth_dst);
3120 spin_unlock_irqrestore(&rocker->neigh_tbl_lock, lock_flags);
3123 rocker_port_kfree(trans, entry);
3128 /* Resolved means neigh ip_addr is resolved to neigh mac. */
3131 err = rocker_port_ipv4_resolve(rocker_port, trans, ip_addr);
3136 static int rocker_port_vlan_flood_group(struct rocker_port *rocker_port,
3137 struct switchdev_trans *trans,
3138 int flags, __be16 vlan_id)
3140 struct rocker_port *p;
3141 const struct rocker *rocker = rocker_port->rocker;
3142 u32 group_id = ROCKER_GROUP_L2_FLOOD(vlan_id, 0);
3148 group_ids = rocker_port_kcalloc(rocker_port, trans, flags,
3149 rocker->port_count, sizeof(u32));
3153 /* Adjust the flood group for this VLAN. The flood group
3154 * references an L2 interface group for each port in this
3158 for (i = 0; i < rocker->port_count; i++) {
3159 p = rocker->ports[i];
3162 if (!rocker_port_is_bridged(p))
3164 if (test_bit(ntohs(vlan_id), p->vlan_bitmap)) {
3165 group_ids[group_count++] =
3166 ROCKER_GROUP_L2_INTERFACE(vlan_id, p->pport);
3170 /* If there are no bridged ports in this VLAN, we're done */
3171 if (group_count == 0)
3172 goto no_ports_in_vlan;
3174 err = rocker_group_l2_flood(rocker_port, trans, flags, vlan_id,
3175 group_count, group_ids, group_id);
3177 netdev_err(rocker_port->dev,
3178 "Error (%d) port VLAN l2 flood group\n", err);
3181 rocker_port_kfree(trans, group_ids);
3185 static int rocker_port_vlan_l2_groups(struct rocker_port *rocker_port,
3186 struct switchdev_trans *trans, int flags,
3187 __be16 vlan_id, bool pop_vlan)
3189 const struct rocker *rocker = rocker_port->rocker;
3190 struct rocker_port *p;
3191 bool adding = !(flags & ROCKER_OP_FLAG_REMOVE);
3197 /* An L2 interface group for this port in this VLAN, but
3198 * only when port STP state is LEARNING|FORWARDING.
3201 if (rocker_port->stp_state == BR_STATE_LEARNING ||
3202 rocker_port->stp_state == BR_STATE_FORWARDING) {
3203 out_pport = rocker_port->pport;
3204 err = rocker_group_l2_interface(rocker_port, trans, flags,
3205 vlan_id, out_pport, pop_vlan);
3207 netdev_err(rocker_port->dev,
3208 "Error (%d) port VLAN l2 group for pport %d\n",
3214 /* An L2 interface group for this VLAN to CPU port.
3215 * Add when first port joins this VLAN and destroy when
3216 * last port leaves this VLAN.
3219 for (i = 0; i < rocker->port_count; i++) {
3220 p = rocker->ports[i];
3221 if (p && test_bit(ntohs(vlan_id), p->vlan_bitmap))
3225 if ((!adding || ref != 1) && (adding || ref != 0))
3229 err = rocker_group_l2_interface(rocker_port, trans, flags,
3230 vlan_id, out_pport, pop_vlan);
3232 netdev_err(rocker_port->dev,
3233 "Error (%d) port VLAN l2 group for CPU port\n", err);
3240 static struct rocker_ctrl {
3242 const u8 *eth_dst_mask;
3248 } rocker_ctrls[] = {
3249 [ROCKER_CTRL_LINK_LOCAL_MCAST] = {
3250 /* pass link local multicast pkts up to CPU for filtering */
3252 .eth_dst_mask = ll_mask,
3255 [ROCKER_CTRL_LOCAL_ARP] = {
3256 /* pass local ARP pkts up to CPU */
3257 .eth_dst = zero_mac,
3258 .eth_dst_mask = zero_mac,
3259 .eth_type = htons(ETH_P_ARP),
3262 [ROCKER_CTRL_IPV4_MCAST] = {
3263 /* pass IPv4 mcast pkts up to CPU, RFC 1112 */
3264 .eth_dst = ipv4_mcast,
3265 .eth_dst_mask = ipv4_mask,
3266 .eth_type = htons(ETH_P_IP),
3268 .copy_to_cpu = true,
3270 [ROCKER_CTRL_IPV6_MCAST] = {
3271 /* pass IPv6 mcast pkts up to CPU, RFC 2464 */
3272 .eth_dst = ipv6_mcast,
3273 .eth_dst_mask = ipv6_mask,
3274 .eth_type = htons(ETH_P_IPV6),
3276 .copy_to_cpu = true,
3278 [ROCKER_CTRL_DFLT_BRIDGING] = {
3279 /* flood any pkts on vlan */
3281 .copy_to_cpu = true,
3283 [ROCKER_CTRL_DFLT_OVS] = {
3284 /* pass all pkts up to CPU */
3285 .eth_dst = zero_mac,
3286 .eth_dst_mask = zero_mac,
3291 static int rocker_port_ctrl_vlan_acl(struct rocker_port *rocker_port,
3292 struct switchdev_trans *trans, int flags,
3293 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3295 u32 in_pport = rocker_port->pport;
3296 u32 in_pport_mask = 0xffffffff;
3298 const u8 *eth_src = NULL;
3299 const u8 *eth_src_mask = NULL;
3300 __be16 vlan_id_mask = htons(0xffff);
3302 u8 ip_proto_mask = 0;
3305 u32 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
3308 err = rocker_flow_tbl_acl(rocker_port, trans, flags,
3309 in_pport, in_pport_mask,
3310 eth_src, eth_src_mask,
3311 ctrl->eth_dst, ctrl->eth_dst_mask,
3313 vlan_id, vlan_id_mask,
3314 ip_proto, ip_proto_mask,
3315 ip_tos, ip_tos_mask,
3319 netdev_err(rocker_port->dev, "Error (%d) ctrl ACL\n", err);
3324 static int rocker_port_ctrl_vlan_bridge(struct rocker_port *rocker_port,
3325 struct switchdev_trans *trans,
3327 const struct rocker_ctrl *ctrl,
3330 enum rocker_of_dpa_table_id goto_tbl =
3331 ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
3332 u32 group_id = ROCKER_GROUP_L2_FLOOD(vlan_id, 0);
3336 if (!rocker_port_is_bridged(rocker_port))
3339 err = rocker_flow_tbl_bridge(rocker_port, trans, flags,
3340 ctrl->eth_dst, ctrl->eth_dst_mask,
3342 goto_tbl, group_id, ctrl->copy_to_cpu);
3345 netdev_err(rocker_port->dev, "Error (%d) ctrl FLOOD\n", err);
3350 static int rocker_port_ctrl_vlan_term(struct rocker_port *rocker_port,
3351 struct switchdev_trans *trans, int flags,
3352 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3354 u32 in_pport_mask = 0xffffffff;
3355 __be16 vlan_id_mask = htons(0xffff);
3358 if (ntohs(vlan_id) == 0)
3359 vlan_id = rocker_port->internal_vlan_id;
3361 err = rocker_flow_tbl_term_mac(rocker_port, trans,
3362 rocker_port->pport, in_pport_mask,
3363 ctrl->eth_type, ctrl->eth_dst,
3364 ctrl->eth_dst_mask, vlan_id,
3365 vlan_id_mask, ctrl->copy_to_cpu,
3369 netdev_err(rocker_port->dev, "Error (%d) ctrl term\n", err);
3374 static int rocker_port_ctrl_vlan(struct rocker_port *rocker_port,
3375 struct switchdev_trans *trans, int flags,
3376 const struct rocker_ctrl *ctrl, __be16 vlan_id)
3379 return rocker_port_ctrl_vlan_acl(rocker_port, trans, flags,
3382 return rocker_port_ctrl_vlan_bridge(rocker_port, trans, flags,
3386 return rocker_port_ctrl_vlan_term(rocker_port, trans, flags,
3392 static int rocker_port_ctrl_vlan_add(struct rocker_port *rocker_port,
3393 struct switchdev_trans *trans, int flags,
3399 for (i = 0; i < ROCKER_CTRL_MAX; i++) {
3400 if (rocker_port->ctrls[i]) {
3401 err = rocker_port_ctrl_vlan(rocker_port, trans, flags,
3402 &rocker_ctrls[i], vlan_id);
3411 static int rocker_port_ctrl(struct rocker_port *rocker_port,
3412 struct switchdev_trans *trans, int flags,
3413 const struct rocker_ctrl *ctrl)
3418 for (vid = 1; vid < VLAN_N_VID; vid++) {
3419 if (!test_bit(vid, rocker_port->vlan_bitmap))
3421 err = rocker_port_ctrl_vlan(rocker_port, trans, flags,
3430 static int rocker_port_vlan(struct rocker_port *rocker_port,
3431 struct switchdev_trans *trans, int flags, u16 vid)
3433 enum rocker_of_dpa_table_id goto_tbl =
3434 ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
3435 u32 in_pport = rocker_port->pport;
3436 __be16 vlan_id = htons(vid);
3437 __be16 vlan_id_mask = htons(0xffff);
3438 __be16 internal_vlan_id;
3440 bool adding = !(flags & ROCKER_OP_FLAG_REMOVE);
3443 internal_vlan_id = rocker_port_vid_to_vlan(rocker_port, vid, &untagged);
3445 if (adding && test_bit(ntohs(internal_vlan_id),
3446 rocker_port->vlan_bitmap))
3447 return 0; /* already added */
3448 else if (!adding && !test_bit(ntohs(internal_vlan_id),
3449 rocker_port->vlan_bitmap))
3450 return 0; /* already removed */
3452 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap);
3455 err = rocker_port_ctrl_vlan_add(rocker_port, trans, flags,
3458 netdev_err(rocker_port->dev,
3459 "Error (%d) port ctrl vlan add\n", err);
3464 err = rocker_port_vlan_l2_groups(rocker_port, trans, flags,
3465 internal_vlan_id, untagged);
3467 netdev_err(rocker_port->dev,
3468 "Error (%d) port VLAN l2 groups\n", err);
3472 err = rocker_port_vlan_flood_group(rocker_port, trans, flags,
3475 netdev_err(rocker_port->dev,
3476 "Error (%d) port VLAN l2 flood group\n", err);
3480 err = rocker_flow_tbl_vlan(rocker_port, trans, flags,
3481 in_pport, vlan_id, vlan_id_mask,
3482 goto_tbl, untagged, internal_vlan_id);
3484 netdev_err(rocker_port->dev,
3485 "Error (%d) port VLAN table\n", err);
3488 if (switchdev_trans_ph_prepare(trans))
3489 change_bit(ntohs(internal_vlan_id), rocker_port->vlan_bitmap);
3494 static int rocker_port_ig_tbl(struct rocker_port *rocker_port,
3495 struct switchdev_trans *trans, int flags)
3497 enum rocker_of_dpa_table_id goto_tbl;
3502 /* Normal Ethernet Frames. Matches pkts from any local physical
3503 * ports. Goto VLAN tbl.
3507 in_pport_mask = 0xffff0000;
3508 goto_tbl = ROCKER_OF_DPA_TABLE_ID_VLAN;
3510 err = rocker_flow_tbl_ig_port(rocker_port, trans, flags,
3511 in_pport, in_pport_mask,
3514 netdev_err(rocker_port->dev,
3515 "Error (%d) ingress port table entry\n", err);
3520 struct rocker_fdb_learn_work {
3521 struct work_struct work;
3522 struct rocker_port *rocker_port;
3523 struct switchdev_trans *trans;
3529 static void rocker_port_fdb_learn_work(struct work_struct *work)
3531 const struct rocker_fdb_learn_work *lw =
3532 container_of(work, struct rocker_fdb_learn_work, work);
3533 bool removing = (lw->flags & ROCKER_OP_FLAG_REMOVE);
3534 bool learned = (lw->flags & ROCKER_OP_FLAG_LEARNED);
3535 struct switchdev_notifier_fdb_info info;
3537 info.addr = lw->addr;
3540 if (learned && removing)
3541 call_switchdev_notifiers(SWITCHDEV_FDB_DEL,
3542 lw->rocker_port->dev, &info.info);
3543 else if (learned && !removing)
3544 call_switchdev_notifiers(SWITCHDEV_FDB_ADD,
3545 lw->rocker_port->dev, &info.info);
3547 rocker_port_kfree(lw->trans, work);
3550 static int rocker_port_fdb_learn(struct rocker_port *rocker_port,
3551 struct switchdev_trans *trans, int flags,
3552 const u8 *addr, __be16 vlan_id)
3554 struct rocker_fdb_learn_work *lw;
3555 enum rocker_of_dpa_table_id goto_tbl =
3556 ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
3557 u32 out_pport = rocker_port->pport;
3559 u32 group_id = ROCKER_GROUP_NONE;
3560 bool syncing = !!(rocker_port->brport_flags & BR_LEARNING_SYNC);
3561 bool copy_to_cpu = false;
3564 if (rocker_port_is_bridged(rocker_port))
3565 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
3567 if (!(flags & ROCKER_OP_FLAG_REFRESH)) {
3568 err = rocker_flow_tbl_bridge(rocker_port, trans, flags, addr,
3569 NULL, vlan_id, tunnel_id, goto_tbl,
3570 group_id, copy_to_cpu);
3578 if (!rocker_port_is_bridged(rocker_port))
3581 lw = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*lw));
3585 INIT_WORK(&lw->work, rocker_port_fdb_learn_work);
3587 lw->rocker_port = rocker_port;
3590 ether_addr_copy(lw->addr, addr);
3591 lw->vid = rocker_port_vlan_to_vid(rocker_port, vlan_id);
3593 if (switchdev_trans_ph_prepare(trans))
3594 rocker_port_kfree(trans, lw);
3596 schedule_work(&lw->work);
3601 static struct rocker_fdb_tbl_entry *
3602 rocker_fdb_tbl_find(const struct rocker *rocker,
3603 const struct rocker_fdb_tbl_entry *match)
3605 struct rocker_fdb_tbl_entry *found;
3607 hash_for_each_possible(rocker->fdb_tbl, found, entry, match->key_crc32)
3608 if (memcmp(&found->key, &match->key, sizeof(found->key)) == 0)
3614 static int rocker_port_fdb(struct rocker_port *rocker_port,
3615 struct switchdev_trans *trans,
3616 const unsigned char *addr,
3617 __be16 vlan_id, int flags)
3619 struct rocker *rocker = rocker_port->rocker;
3620 struct rocker_fdb_tbl_entry *fdb;
3621 struct rocker_fdb_tbl_entry *found;
3622 bool removing = (flags & ROCKER_OP_FLAG_REMOVE);
3623 unsigned long lock_flags;
3625 fdb = rocker_port_kzalloc(rocker_port, trans, flags, sizeof(*fdb));
3629 fdb->learned = (flags & ROCKER_OP_FLAG_LEARNED);
3630 fdb->touched = jiffies;
3631 fdb->key.rocker_port = rocker_port;
3632 ether_addr_copy(fdb->key.addr, addr);
3633 fdb->key.vlan_id = vlan_id;
3634 fdb->key_crc32 = crc32(~0, &fdb->key, sizeof(fdb->key));
3636 spin_lock_irqsave(&rocker->fdb_tbl_lock, lock_flags);
3638 found = rocker_fdb_tbl_find(rocker, fdb);
3641 found->touched = jiffies;
3643 rocker_port_kfree(trans, fdb);
3644 if (!switchdev_trans_ph_prepare(trans))
3645 hash_del(&found->entry);
3647 } else if (!removing) {
3648 if (!switchdev_trans_ph_prepare(trans))
3649 hash_add(rocker->fdb_tbl, &fdb->entry,
3653 spin_unlock_irqrestore(&rocker->fdb_tbl_lock, lock_flags);
3655 /* Check if adding and already exists, or removing and can't find */
3656 if (!found != !removing) {
3657 rocker_port_kfree(trans, fdb);
3658 if (!found && removing)
3660 /* Refreshing existing to update aging timers */
3661 flags |= ROCKER_OP_FLAG_REFRESH;
3664 return rocker_port_fdb_learn(rocker_port, trans, flags, addr, vlan_id);
3667 static int rocker_port_fdb_flush(struct rocker_port *rocker_port,
3668 struct switchdev_trans *trans, int flags)
3670 struct rocker *rocker = rocker_port->rocker;
3671 struct rocker_fdb_tbl_entry *found;
3672 unsigned long lock_flags;
3673 struct hlist_node *tmp;
3677 if (rocker_port->stp_state == BR_STATE_LEARNING ||
3678 rocker_port->stp_state == BR_STATE_FORWARDING)
3681 flags |= ROCKER_OP_FLAG_REMOVE;
3683 spin_lock_irqsave(&rocker->fdb_tbl_lock, lock_flags);
3685 hash_for_each_safe(rocker->fdb_tbl, bkt, tmp, found, entry) {
3686 if (found->key.rocker_port != rocker_port)
3688 if (!found->learned)
3690 err = rocker_port_fdb_learn(rocker_port, trans, flags,
3692 found->key.vlan_id);
3695 if (!switchdev_trans_ph_prepare(trans))
3696 hash_del(&found->entry);
3700 spin_unlock_irqrestore(&rocker->fdb_tbl_lock, lock_flags);
3705 static void rocker_fdb_cleanup(unsigned long data)
3707 struct rocker *rocker = (struct rocker *)data;
3708 struct rocker_port *rocker_port;
3709 struct rocker_fdb_tbl_entry *entry;
3710 struct hlist_node *tmp;
3711 unsigned long next_timer = jiffies + BR_MIN_AGEING_TIME;
3712 unsigned long expires;
3713 unsigned long lock_flags;
3714 int flags = ROCKER_OP_FLAG_NOWAIT | ROCKER_OP_FLAG_REMOVE |
3715 ROCKER_OP_FLAG_LEARNED;
3718 spin_lock_irqsave(&rocker->fdb_tbl_lock, lock_flags);
3720 hash_for_each_safe(rocker->fdb_tbl, bkt, tmp, entry, entry) {
3721 if (!entry->learned)
3723 rocker_port = entry->key.rocker_port;
3724 expires = entry->touched + rocker_port->ageing_time;
3725 if (time_before_eq(expires, jiffies)) {
3726 rocker_port_fdb_learn(rocker_port, NULL,
3727 flags, entry->key.addr,
3728 entry->key.vlan_id);
3729 hash_del(&entry->entry);
3730 } else if (time_before(expires, next_timer)) {
3731 next_timer = expires;
3735 spin_unlock_irqrestore(&rocker->fdb_tbl_lock, lock_flags);
3737 mod_timer(&rocker->fdb_cleanup_timer, round_jiffies_up(next_timer));
3740 static int rocker_port_router_mac(struct rocker_port *rocker_port,
3741 struct switchdev_trans *trans, int flags,
3744 u32 in_pport_mask = 0xffffffff;
3746 const u8 *dst_mac_mask = ff_mac;
3747 __be16 vlan_id_mask = htons(0xffff);
3748 bool copy_to_cpu = false;
3751 if (ntohs(vlan_id) == 0)
3752 vlan_id = rocker_port->internal_vlan_id;
3754 eth_type = htons(ETH_P_IP);
3755 err = rocker_flow_tbl_term_mac(rocker_port, trans,
3756 rocker_port->pport, in_pport_mask,
3757 eth_type, rocker_port->dev->dev_addr,
3758 dst_mac_mask, vlan_id, vlan_id_mask,
3759 copy_to_cpu, flags);
3763 eth_type = htons(ETH_P_IPV6);
3764 err = rocker_flow_tbl_term_mac(rocker_port, trans,
3765 rocker_port->pport, in_pport_mask,
3766 eth_type, rocker_port->dev->dev_addr,
3767 dst_mac_mask, vlan_id, vlan_id_mask,
3768 copy_to_cpu, flags);
3773 static int rocker_port_fwding(struct rocker_port *rocker_port,
3774 struct switchdev_trans *trans, int flags)
3782 /* Port will be forwarding-enabled if its STP state is LEARNING
3783 * or FORWARDING. Traffic from CPU can still egress, regardless of
3784 * port STP state. Use L2 interface group on port VLANs as a way
3785 * to toggle port forwarding: if forwarding is disabled, L2
3786 * interface group will not exist.
3789 if (rocker_port->stp_state != BR_STATE_LEARNING &&
3790 rocker_port->stp_state != BR_STATE_FORWARDING)
3791 flags |= ROCKER_OP_FLAG_REMOVE;
3793 out_pport = rocker_port->pport;
3794 for (vid = 1; vid < VLAN_N_VID; vid++) {
3795 if (!test_bit(vid, rocker_port->vlan_bitmap))
3797 vlan_id = htons(vid);
3798 pop_vlan = rocker_vlan_id_is_internal(vlan_id);
3799 err = rocker_group_l2_interface(rocker_port, trans, flags,
3800 vlan_id, out_pport, pop_vlan);
3802 netdev_err(rocker_port->dev,
3803 "Error (%d) port VLAN l2 group for pport %d\n",
3812 static int rocker_port_stp_update(struct rocker_port *rocker_port,
3813 struct switchdev_trans *trans, int flags,
3816 bool want[ROCKER_CTRL_MAX] = { 0, };
3817 bool prev_ctrls[ROCKER_CTRL_MAX];
3818 u8 uninitialized_var(prev_state);
3822 if (switchdev_trans_ph_prepare(trans)) {
3823 memcpy(prev_ctrls, rocker_port->ctrls, sizeof(prev_ctrls));
3824 prev_state = rocker_port->stp_state;
3827 if (rocker_port->stp_state == state)
3830 rocker_port->stp_state = state;
3833 case BR_STATE_DISABLED:
3834 /* port is completely disabled */
3836 case BR_STATE_LISTENING:
3837 case BR_STATE_BLOCKING:
3838 want[ROCKER_CTRL_LINK_LOCAL_MCAST] = true;
3840 case BR_STATE_LEARNING:
3841 case BR_STATE_FORWARDING:
3842 if (!rocker_port_is_ovsed(rocker_port))
3843 want[ROCKER_CTRL_LINK_LOCAL_MCAST] = true;
3844 want[ROCKER_CTRL_IPV4_MCAST] = true;
3845 want[ROCKER_CTRL_IPV6_MCAST] = true;
3846 if (rocker_port_is_bridged(rocker_port))
3847 want[ROCKER_CTRL_DFLT_BRIDGING] = true;
3848 else if (rocker_port_is_ovsed(rocker_port))
3849 want[ROCKER_CTRL_DFLT_OVS] = true;
3851 want[ROCKER_CTRL_LOCAL_ARP] = true;
3855 for (i = 0; i < ROCKER_CTRL_MAX; i++) {
3856 if (want[i] != rocker_port->ctrls[i]) {
3857 int ctrl_flags = flags |
3858 (want[i] ? 0 : ROCKER_OP_FLAG_REMOVE);
3859 err = rocker_port_ctrl(rocker_port, trans, ctrl_flags,
3863 rocker_port->ctrls[i] = want[i];
3867 err = rocker_port_fdb_flush(rocker_port, trans, flags);
3871 err = rocker_port_fwding(rocker_port, trans, flags);
3874 if (switchdev_trans_ph_prepare(trans)) {
3875 memcpy(rocker_port->ctrls, prev_ctrls, sizeof(prev_ctrls));
3876 rocker_port->stp_state = prev_state;
3882 static int rocker_port_fwd_enable(struct rocker_port *rocker_port,
3883 struct switchdev_trans *trans, int flags)
3885 if (rocker_port_is_bridged(rocker_port))
3886 /* bridge STP will enable port */
3889 /* port is not bridged, so simulate going to FORWARDING state */
3890 return rocker_port_stp_update(rocker_port, trans, flags,
3891 BR_STATE_FORWARDING);
3894 static int rocker_port_fwd_disable(struct rocker_port *rocker_port,
3895 struct switchdev_trans *trans, int flags)
3897 if (rocker_port_is_bridged(rocker_port))
3898 /* bridge STP will disable port */
3901 /* port is not bridged, so simulate going to DISABLED state */
3902 return rocker_port_stp_update(rocker_port, trans, flags,
3906 static struct rocker_internal_vlan_tbl_entry *
3907 rocker_internal_vlan_tbl_find(const struct rocker *rocker, int ifindex)
3909 struct rocker_internal_vlan_tbl_entry *found;
3911 hash_for_each_possible(rocker->internal_vlan_tbl, found,
3913 if (found->ifindex == ifindex)
3920 static __be16 rocker_port_internal_vlan_id_get(struct rocker_port *rocker_port,
3923 struct rocker *rocker = rocker_port->rocker;
3924 struct rocker_internal_vlan_tbl_entry *entry;
3925 struct rocker_internal_vlan_tbl_entry *found;
3926 unsigned long lock_flags;
3929 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
3933 entry->ifindex = ifindex;
3935 spin_lock_irqsave(&rocker->internal_vlan_tbl_lock, lock_flags);
3937 found = rocker_internal_vlan_tbl_find(rocker, ifindex);
3944 hash_add(rocker->internal_vlan_tbl, &found->entry, found->ifindex);
3946 for (i = 0; i < ROCKER_N_INTERNAL_VLANS; i++) {
3947 if (test_and_set_bit(i, rocker->internal_vlan_bitmap))
3949 found->vlan_id = htons(ROCKER_INTERNAL_VLAN_ID_BASE + i);
3953 netdev_err(rocker_port->dev, "Out of internal VLAN IDs\n");
3957 spin_unlock_irqrestore(&rocker->internal_vlan_tbl_lock, lock_flags);
3959 return found->vlan_id;
3963 rocker_port_internal_vlan_id_put(const struct rocker_port *rocker_port,
3966 struct rocker *rocker = rocker_port->rocker;
3967 struct rocker_internal_vlan_tbl_entry *found;
3968 unsigned long lock_flags;
3971 spin_lock_irqsave(&rocker->internal_vlan_tbl_lock, lock_flags);
3973 found = rocker_internal_vlan_tbl_find(rocker, ifindex);
3975 netdev_err(rocker_port->dev,
3976 "ifindex (%d) not found in internal VLAN tbl\n",
3981 if (--found->ref_count <= 0) {
3982 bit = ntohs(found->vlan_id) - ROCKER_INTERNAL_VLAN_ID_BASE;
3983 clear_bit(bit, rocker->internal_vlan_bitmap);
3984 hash_del(&found->entry);
3989 spin_unlock_irqrestore(&rocker->internal_vlan_tbl_lock, lock_flags);
3992 static int rocker_port_fib_ipv4(struct rocker_port *rocker_port,
3993 struct switchdev_trans *trans, __be32 dst,
3994 int dst_len, const struct fib_info *fi,
3995 u32 tb_id, int flags)
3997 const struct fib_nh *nh;
3998 __be16 eth_type = htons(ETH_P_IP);
3999 __be32 dst_mask = inet_make_mask(dst_len);
4000 __be16 internal_vlan_id = rocker_port->internal_vlan_id;
4001 u32 priority = fi->fib_priority;
4002 enum rocker_of_dpa_table_id goto_tbl =
4003 ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
4010 /* XXX support ECMP */
4013 nh_on_port = (fi->fib_dev == rocker_port->dev);
4014 has_gw = !!nh->nh_gw;
4016 if (has_gw && nh_on_port) {
4017 err = rocker_port_ipv4_nh(rocker_port, trans, flags,
4022 group_id = ROCKER_GROUP_L3_UNICAST(index);
4024 /* Send to CPU for processing */
4025 group_id = ROCKER_GROUP_L2_INTERFACE(internal_vlan_id, 0);
4028 err = rocker_flow_tbl_ucast4_routing(rocker_port, trans, eth_type, dst,
4029 dst_mask, priority, goto_tbl,
4032 netdev_err(rocker_port->dev, "Error (%d) IPv4 route %pI4\n",
4042 static int rocker_port_open(struct net_device *dev)
4044 struct rocker_port *rocker_port = netdev_priv(dev);
4047 err = rocker_port_dma_rings_init(rocker_port);
4051 err = request_irq(rocker_msix_tx_vector(rocker_port),
4052 rocker_tx_irq_handler, 0,
4053 rocker_driver_name, rocker_port);
4055 netdev_err(rocker_port->dev, "cannot assign tx irq\n");
4056 goto err_request_tx_irq;
4059 err = request_irq(rocker_msix_rx_vector(rocker_port),
4060 rocker_rx_irq_handler, 0,
4061 rocker_driver_name, rocker_port);
4063 netdev_err(rocker_port->dev, "cannot assign rx irq\n");
4064 goto err_request_rx_irq;
4067 err = rocker_port_fwd_enable(rocker_port, NULL, 0);
4069 goto err_fwd_enable;
4071 napi_enable(&rocker_port->napi_tx);
4072 napi_enable(&rocker_port->napi_rx);
4073 if (!dev->proto_down)
4074 rocker_port_set_enable(rocker_port, true);
4075 netif_start_queue(dev);
4079 free_irq(rocker_msix_rx_vector(rocker_port), rocker_port);
4081 free_irq(rocker_msix_tx_vector(rocker_port), rocker_port);
4083 rocker_port_dma_rings_fini(rocker_port);
4087 static int rocker_port_stop(struct net_device *dev)
4089 struct rocker_port *rocker_port = netdev_priv(dev);
4091 netif_stop_queue(dev);
4092 rocker_port_set_enable(rocker_port, false);
4093 napi_disable(&rocker_port->napi_rx);
4094 napi_disable(&rocker_port->napi_tx);
4095 rocker_port_fwd_disable(rocker_port, NULL,
4096 ROCKER_OP_FLAG_NOWAIT);
4097 free_irq(rocker_msix_rx_vector(rocker_port), rocker_port);
4098 free_irq(rocker_msix_tx_vector(rocker_port), rocker_port);
4099 rocker_port_dma_rings_fini(rocker_port);
4104 static void rocker_tx_desc_frags_unmap(const struct rocker_port *rocker_port,
4105 const struct rocker_desc_info *desc_info)
4107 const struct rocker *rocker = rocker_port->rocker;
4108 struct pci_dev *pdev = rocker->pdev;
4109 const struct rocker_tlv *attrs[ROCKER_TLV_TX_MAX + 1];
4110 struct rocker_tlv *attr;
4113 rocker_tlv_parse_desc(attrs, ROCKER_TLV_TX_MAX, desc_info);
4114 if (!attrs[ROCKER_TLV_TX_FRAGS])
4116 rocker_tlv_for_each_nested(attr, attrs[ROCKER_TLV_TX_FRAGS], rem) {
4117 const struct rocker_tlv *frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_MAX + 1];
4118 dma_addr_t dma_handle;
4121 if (rocker_tlv_type(attr) != ROCKER_TLV_TX_FRAG)
4123 rocker_tlv_parse_nested(frag_attrs, ROCKER_TLV_TX_FRAG_ATTR_MAX,
4125 if (!frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
4126 !frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN])
4128 dma_handle = rocker_tlv_get_u64(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
4129 len = rocker_tlv_get_u16(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
4130 pci_unmap_single(pdev, dma_handle, len, DMA_TO_DEVICE);
4134 static int rocker_tx_desc_frag_map_put(const struct rocker_port *rocker_port,
4135 struct rocker_desc_info *desc_info,
4136 char *buf, size_t buf_len)
4138 const struct rocker *rocker = rocker_port->rocker;
4139 struct pci_dev *pdev = rocker->pdev;
4140 dma_addr_t dma_handle;
4141 struct rocker_tlv *frag;
4143 dma_handle = pci_map_single(pdev, buf, buf_len, DMA_TO_DEVICE);
4144 if (unlikely(pci_dma_mapping_error(pdev, dma_handle))) {
4145 if (net_ratelimit())
4146 netdev_err(rocker_port->dev, "failed to dma map tx frag\n");
4149 frag = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAG);
4152 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_TX_FRAG_ATTR_ADDR,
4155 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_TX_FRAG_ATTR_LEN,
4158 rocker_tlv_nest_end(desc_info, frag);
4162 rocker_tlv_nest_cancel(desc_info, frag);
4164 pci_unmap_single(pdev, dma_handle, buf_len, DMA_TO_DEVICE);
4168 static netdev_tx_t rocker_port_xmit(struct sk_buff *skb, struct net_device *dev)
4170 struct rocker_port *rocker_port = netdev_priv(dev);
4171 struct rocker *rocker = rocker_port->rocker;
4172 struct rocker_desc_info *desc_info;
4173 struct rocker_tlv *frags;
4177 desc_info = rocker_desc_head_get(&rocker_port->tx_ring);
4178 if (unlikely(!desc_info)) {
4179 if (net_ratelimit())
4180 netdev_err(dev, "tx ring full when queue awake\n");
4181 return NETDEV_TX_BUSY;
4184 rocker_desc_cookie_ptr_set(desc_info, skb);
4186 frags = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAGS);
4189 err = rocker_tx_desc_frag_map_put(rocker_port, desc_info,
4190 skb->data, skb_headlen(skb));
4193 if (skb_shinfo(skb)->nr_frags > ROCKER_TX_FRAGS_MAX) {
4194 err = skb_linearize(skb);
4199 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
4200 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
4202 err = rocker_tx_desc_frag_map_put(rocker_port, desc_info,
4203 skb_frag_address(frag),
4204 skb_frag_size(frag));
4208 rocker_tlv_nest_end(desc_info, frags);
4210 rocker_desc_gen_clear(desc_info);
4211 rocker_desc_head_set(rocker, &rocker_port->tx_ring, desc_info);
4213 desc_info = rocker_desc_head_get(&rocker_port->tx_ring);
4215 netif_stop_queue(dev);
4217 return NETDEV_TX_OK;
4220 rocker_tx_desc_frags_unmap(rocker_port, desc_info);
4222 rocker_tlv_nest_cancel(desc_info, frags);
4225 dev->stats.tx_dropped++;
4227 return NETDEV_TX_OK;
4230 static int rocker_port_set_mac_address(struct net_device *dev, void *p)
4232 struct sockaddr *addr = p;
4233 struct rocker_port *rocker_port = netdev_priv(dev);
4236 if (!is_valid_ether_addr(addr->sa_data))
4237 return -EADDRNOTAVAIL;
4239 err = rocker_cmd_set_port_settings_macaddr(rocker_port, addr->sa_data);
4242 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
4246 static int rocker_port_change_mtu(struct net_device *dev, int new_mtu)
4248 struct rocker_port *rocker_port = netdev_priv(dev);
4249 int running = netif_running(dev);
4252 #define ROCKER_PORT_MIN_MTU 68
4253 #define ROCKER_PORT_MAX_MTU 9000
4255 if (new_mtu < ROCKER_PORT_MIN_MTU || new_mtu > ROCKER_PORT_MAX_MTU)
4259 rocker_port_stop(dev);
4261 netdev_info(dev, "MTU change from %d to %d\n", dev->mtu, new_mtu);
4264 err = rocker_cmd_set_port_settings_mtu(rocker_port, new_mtu);
4269 err = rocker_port_open(dev);
4274 static int rocker_port_get_phys_port_name(struct net_device *dev,
4275 char *buf, size_t len)
4277 struct rocker_port *rocker_port = netdev_priv(dev);
4278 struct port_name name = { .buf = buf, .len = len };
4281 err = rocker_cmd_exec(rocker_port, NULL, 0,
4282 rocker_cmd_get_port_settings_prep, NULL,
4283 rocker_cmd_get_port_settings_phys_name_proc,
4286 return err ? -EOPNOTSUPP : 0;
4289 static int rocker_port_change_proto_down(struct net_device *dev,
4292 struct rocker_port *rocker_port = netdev_priv(dev);
4294 if (rocker_port->dev->flags & IFF_UP)
4295 rocker_port_set_enable(rocker_port, !proto_down);
4296 rocker_port->dev->proto_down = proto_down;
4300 static void rocker_port_neigh_destroy(struct neighbour *n)
4302 struct rocker_port *rocker_port = netdev_priv(n->dev);
4303 int flags = ROCKER_OP_FLAG_REMOVE | ROCKER_OP_FLAG_NOWAIT;
4304 __be32 ip_addr = *(__be32 *)n->primary_key;
4306 rocker_port_ipv4_neigh(rocker_port, NULL,
4307 flags, ip_addr, n->ha);
4310 static const struct net_device_ops rocker_port_netdev_ops = {
4311 .ndo_open = rocker_port_open,
4312 .ndo_stop = rocker_port_stop,
4313 .ndo_start_xmit = rocker_port_xmit,
4314 .ndo_set_mac_address = rocker_port_set_mac_address,
4315 .ndo_change_mtu = rocker_port_change_mtu,
4316 .ndo_bridge_getlink = switchdev_port_bridge_getlink,
4317 .ndo_bridge_setlink = switchdev_port_bridge_setlink,
4318 .ndo_bridge_dellink = switchdev_port_bridge_dellink,
4319 .ndo_fdb_add = switchdev_port_fdb_add,
4320 .ndo_fdb_del = switchdev_port_fdb_del,
4321 .ndo_fdb_dump = switchdev_port_fdb_dump,
4322 .ndo_get_phys_port_name = rocker_port_get_phys_port_name,
4323 .ndo_change_proto_down = rocker_port_change_proto_down,
4324 .ndo_neigh_destroy = rocker_port_neigh_destroy,
4327 /********************
4329 ********************/
4331 static int rocker_port_attr_get(struct net_device *dev,
4332 struct switchdev_attr *attr)
4334 const struct rocker_port *rocker_port = netdev_priv(dev);
4335 const struct rocker *rocker = rocker_port->rocker;
4338 case SWITCHDEV_ATTR_PORT_PARENT_ID:
4339 attr->u.ppid.id_len = sizeof(rocker->hw.id);
4340 memcpy(&attr->u.ppid.id, &rocker->hw.id, attr->u.ppid.id_len);
4342 case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS:
4343 attr->u.brport_flags = rocker_port->brport_flags;
4352 static void rocker_port_trans_abort(const struct rocker_port *rocker_port)
4354 struct list_head *mem, *tmp;
4356 list_for_each_safe(mem, tmp, &rocker_port->trans_mem) {
4362 static int rocker_port_brport_flags_set(struct rocker_port *rocker_port,
4363 struct switchdev_trans *trans,
4364 unsigned long brport_flags)
4366 unsigned long orig_flags;
4369 orig_flags = rocker_port->brport_flags;
4370 rocker_port->brport_flags = brport_flags;
4371 if ((orig_flags ^ rocker_port->brport_flags) & BR_LEARNING)
4372 err = rocker_port_set_learning(rocker_port, trans);
4374 if (switchdev_trans_ph_prepare(trans))
4375 rocker_port->brport_flags = orig_flags;
4380 static int rocker_port_attr_set(struct net_device *dev,
4381 struct switchdev_attr *attr,
4382 struct switchdev_trans *trans)
4384 struct rocker_port *rocker_port = netdev_priv(dev);
4387 switch (trans->ph) {
4388 case SWITCHDEV_TRANS_PREPARE:
4389 BUG_ON(!list_empty(&rocker_port->trans_mem));
4391 case SWITCHDEV_TRANS_ABORT:
4392 rocker_port_trans_abort(rocker_port);
4399 case SWITCHDEV_ATTR_PORT_STP_STATE:
4400 err = rocker_port_stp_update(rocker_port, trans,
4401 ROCKER_OP_FLAG_NOWAIT,
4404 case SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS:
4405 err = rocker_port_brport_flags_set(rocker_port, trans,
4406 attr->u.brport_flags);
4416 static int rocker_port_vlan_add(struct rocker_port *rocker_port,
4417 struct switchdev_trans *trans,
4422 /* XXX deal with flags for PVID and untagged */
4424 err = rocker_port_vlan(rocker_port, trans, 0, vid);
4428 err = rocker_port_router_mac(rocker_port, trans, 0, htons(vid));
4430 rocker_port_vlan(rocker_port, trans,
4431 ROCKER_OP_FLAG_REMOVE, vid);
4436 static int rocker_port_vlans_add(struct rocker_port *rocker_port,
4437 struct switchdev_trans *trans,
4438 const struct switchdev_obj_vlan *vlan)
4443 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
4444 err = rocker_port_vlan_add(rocker_port, trans,
4453 static int rocker_port_fdb_add(struct rocker_port *rocker_port,
4454 struct switchdev_trans *trans,
4455 const struct switchdev_obj_fdb *fdb)
4457 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL);
4460 if (!rocker_port_is_bridged(rocker_port))
4463 return rocker_port_fdb(rocker_port, trans, fdb->addr, vlan_id, flags);
4466 static int rocker_port_obj_add(struct net_device *dev,
4467 struct switchdev_obj *obj,
4468 struct switchdev_trans *trans)
4470 struct rocker_port *rocker_port = netdev_priv(dev);
4471 const struct switchdev_obj_ipv4_fib *fib4;
4474 switch (trans->ph) {
4475 case SWITCHDEV_TRANS_PREPARE:
4476 BUG_ON(!list_empty(&rocker_port->trans_mem));
4478 case SWITCHDEV_TRANS_ABORT:
4479 rocker_port_trans_abort(rocker_port);
4486 case SWITCHDEV_OBJ_PORT_VLAN:
4487 err = rocker_port_vlans_add(rocker_port, trans,
4490 case SWITCHDEV_OBJ_IPV4_FIB:
4491 fib4 = &obj->u.ipv4_fib;
4492 err = rocker_port_fib_ipv4(rocker_port, trans,
4493 htonl(fib4->dst), fib4->dst_len,
4494 fib4->fi, fib4->tb_id, 0);
4496 case SWITCHDEV_OBJ_PORT_FDB:
4497 err = rocker_port_fdb_add(rocker_port, trans, &obj->u.fdb);
4507 static int rocker_port_vlan_del(struct rocker_port *rocker_port,
4512 err = rocker_port_router_mac(rocker_port, NULL,
4513 ROCKER_OP_FLAG_REMOVE, htons(vid));
4517 return rocker_port_vlan(rocker_port, NULL,
4518 ROCKER_OP_FLAG_REMOVE, vid);
4521 static int rocker_port_vlans_del(struct rocker_port *rocker_port,
4522 const struct switchdev_obj_vlan *vlan)
4527 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
4528 err = rocker_port_vlan_del(rocker_port, vid, vlan->flags);
4536 static int rocker_port_fdb_del(struct rocker_port *rocker_port,
4537 struct switchdev_trans *trans,
4538 const struct switchdev_obj_fdb *fdb)
4540 __be16 vlan_id = rocker_port_vid_to_vlan(rocker_port, fdb->vid, NULL);
4541 int flags = ROCKER_OP_FLAG_NOWAIT | ROCKER_OP_FLAG_REMOVE;
4543 if (!rocker_port_is_bridged(rocker_port))
4546 return rocker_port_fdb(rocker_port, trans, fdb->addr, vlan_id, flags);
4549 static int rocker_port_obj_del(struct net_device *dev,
4550 struct switchdev_obj *obj)
4552 struct rocker_port *rocker_port = netdev_priv(dev);
4553 const struct switchdev_obj_ipv4_fib *fib4;
4557 case SWITCHDEV_OBJ_PORT_VLAN:
4558 err = rocker_port_vlans_del(rocker_port, &obj->u.vlan);
4560 case SWITCHDEV_OBJ_IPV4_FIB:
4561 fib4 = &obj->u.ipv4_fib;
4562 err = rocker_port_fib_ipv4(rocker_port, NULL,
4563 htonl(fib4->dst), fib4->dst_len,
4564 fib4->fi, fib4->tb_id,
4565 ROCKER_OP_FLAG_REMOVE);
4567 case SWITCHDEV_OBJ_PORT_FDB:
4568 err = rocker_port_fdb_del(rocker_port, NULL, &obj->u.fdb);
4578 static int rocker_port_fdb_dump(const struct rocker_port *rocker_port,
4579 struct switchdev_obj *obj)
4581 struct rocker *rocker = rocker_port->rocker;
4582 struct switchdev_obj_fdb *fdb = &obj->u.fdb;
4583 struct rocker_fdb_tbl_entry *found;
4584 struct hlist_node *tmp;
4585 unsigned long lock_flags;
4589 spin_lock_irqsave(&rocker->fdb_tbl_lock, lock_flags);
4590 hash_for_each_safe(rocker->fdb_tbl, bkt, tmp, found, entry) {
4591 if (found->key.rocker_port != rocker_port)
4593 fdb->addr = found->key.addr;
4594 fdb->ndm_state = NUD_REACHABLE;
4595 fdb->vid = rocker_port_vlan_to_vid(rocker_port,
4596 found->key.vlan_id);
4597 err = obj->cb(rocker_port->dev, obj);
4601 spin_unlock_irqrestore(&rocker->fdb_tbl_lock, lock_flags);
4606 static int rocker_port_vlan_dump(const struct rocker_port *rocker_port,
4607 struct switchdev_obj *obj)
4609 struct switchdev_obj_vlan *vlan = &obj->u.vlan;
4613 for (vid = 1; vid < VLAN_N_VID; vid++) {
4614 if (!test_bit(vid, rocker_port->vlan_bitmap))
4617 if (rocker_vlan_id_is_internal(htons(vid)))
4618 vlan->flags |= BRIDGE_VLAN_INFO_PVID;
4619 vlan->vid_begin = vlan->vid_end = vid;
4620 err = obj->cb(rocker_port->dev, obj);
4628 static int rocker_port_obj_dump(struct net_device *dev,
4629 struct switchdev_obj *obj)
4631 const struct rocker_port *rocker_port = netdev_priv(dev);
4635 case SWITCHDEV_OBJ_PORT_FDB:
4636 err = rocker_port_fdb_dump(rocker_port, obj);
4638 case SWITCHDEV_OBJ_PORT_VLAN:
4639 err = rocker_port_vlan_dump(rocker_port, obj);
4649 static const struct switchdev_ops rocker_port_switchdev_ops = {
4650 .switchdev_port_attr_get = rocker_port_attr_get,
4651 .switchdev_port_attr_set = rocker_port_attr_set,
4652 .switchdev_port_obj_add = rocker_port_obj_add,
4653 .switchdev_port_obj_del = rocker_port_obj_del,
4654 .switchdev_port_obj_dump = rocker_port_obj_dump,
4657 /********************
4659 ********************/
4661 static int rocker_port_get_settings(struct net_device *dev,
4662 struct ethtool_cmd *ecmd)
4664 struct rocker_port *rocker_port = netdev_priv(dev);
4666 return rocker_cmd_get_port_settings_ethtool(rocker_port, ecmd);
4669 static int rocker_port_set_settings(struct net_device *dev,
4670 struct ethtool_cmd *ecmd)
4672 struct rocker_port *rocker_port = netdev_priv(dev);
4674 return rocker_cmd_set_port_settings_ethtool(rocker_port, ecmd);
4677 static void rocker_port_get_drvinfo(struct net_device *dev,
4678 struct ethtool_drvinfo *drvinfo)
4680 strlcpy(drvinfo->driver, rocker_driver_name, sizeof(drvinfo->driver));
4681 strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
4684 static struct rocker_port_stats {
4685 char str[ETH_GSTRING_LEN];
4687 } rocker_port_stats[] = {
4688 { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS, },
4689 { "rx_bytes", ROCKER_TLV_CMD_PORT_STATS_RX_BYTES, },
4690 { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED, },
4691 { "rx_errors", ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS, },
4693 { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS, },
4694 { "tx_bytes", ROCKER_TLV_CMD_PORT_STATS_TX_BYTES, },
4695 { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED, },
4696 { "tx_errors", ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS, },
4699 #define ROCKER_PORT_STATS_LEN ARRAY_SIZE(rocker_port_stats)
4701 static void rocker_port_get_strings(struct net_device *netdev, u32 stringset,
4707 switch (stringset) {
4709 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
4710 memcpy(p, rocker_port_stats[i].str, ETH_GSTRING_LEN);
4711 p += ETH_GSTRING_LEN;
4718 rocker_cmd_get_port_stats_prep(const struct rocker_port *rocker_port,
4719 struct rocker_desc_info *desc_info,
4722 struct rocker_tlv *cmd_stats;
4724 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
4725 ROCKER_TLV_CMD_TYPE_GET_PORT_STATS))
4728 cmd_stats = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
4732 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_STATS_PPORT,
4733 rocker_port->pport))
4736 rocker_tlv_nest_end(desc_info, cmd_stats);
4742 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port *rocker_port,
4743 const struct rocker_desc_info *desc_info,
4746 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
4747 const struct rocker_tlv *stats_attrs[ROCKER_TLV_CMD_PORT_STATS_MAX + 1];
4748 const struct rocker_tlv *pattr;
4753 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
4755 if (!attrs[ROCKER_TLV_CMD_INFO])
4758 rocker_tlv_parse_nested(stats_attrs, ROCKER_TLV_CMD_PORT_STATS_MAX,
4759 attrs[ROCKER_TLV_CMD_INFO]);
4761 if (!stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT])
4764 pport = rocker_tlv_get_u32(stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT]);
4765 if (pport != rocker_port->pport)
4768 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
4769 pattr = stats_attrs[rocker_port_stats[i].type];
4773 data[i] = rocker_tlv_get_u64(pattr);
4779 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port *rocker_port,
4782 return rocker_cmd_exec(rocker_port, NULL, 0,
4783 rocker_cmd_get_port_stats_prep, NULL,
4784 rocker_cmd_get_port_stats_ethtool_proc,
4788 static void rocker_port_get_stats(struct net_device *dev,
4789 struct ethtool_stats *stats, u64 *data)
4791 struct rocker_port *rocker_port = netdev_priv(dev);
4793 if (rocker_cmd_get_port_stats_ethtool(rocker_port, data) != 0) {
4796 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); ++i)
4801 static int rocker_port_get_sset_count(struct net_device *netdev, int sset)
4805 return ROCKER_PORT_STATS_LEN;
4811 static const struct ethtool_ops rocker_port_ethtool_ops = {
4812 .get_settings = rocker_port_get_settings,
4813 .set_settings = rocker_port_set_settings,
4814 .get_drvinfo = rocker_port_get_drvinfo,
4815 .get_link = ethtool_op_get_link,
4816 .get_strings = rocker_port_get_strings,
4817 .get_ethtool_stats = rocker_port_get_stats,
4818 .get_sset_count = rocker_port_get_sset_count,
4825 static struct rocker_port *rocker_port_napi_tx_get(struct napi_struct *napi)
4827 return container_of(napi, struct rocker_port, napi_tx);
4830 static int rocker_port_poll_tx(struct napi_struct *napi, int budget)
4832 struct rocker_port *rocker_port = rocker_port_napi_tx_get(napi);
4833 const struct rocker *rocker = rocker_port->rocker;
4834 const struct rocker_desc_info *desc_info;
4838 /* Cleanup tx descriptors */
4839 while ((desc_info = rocker_desc_tail_get(&rocker_port->tx_ring))) {
4840 struct sk_buff *skb;
4842 err = rocker_desc_err(desc_info);
4843 if (err && net_ratelimit())
4844 netdev_err(rocker_port->dev, "tx desc received with err %d\n",
4846 rocker_tx_desc_frags_unmap(rocker_port, desc_info);
4848 skb = rocker_desc_cookie_ptr_get(desc_info);
4850 rocker_port->dev->stats.tx_packets++;
4851 rocker_port->dev->stats.tx_bytes += skb->len;
4853 rocker_port->dev->stats.tx_errors++;
4856 dev_kfree_skb_any(skb);
4860 if (credits && netif_queue_stopped(rocker_port->dev))
4861 netif_wake_queue(rocker_port->dev);
4863 napi_complete(napi);
4864 rocker_dma_ring_credits_set(rocker, &rocker_port->tx_ring, credits);
4869 static int rocker_port_rx_proc(const struct rocker *rocker,
4870 const struct rocker_port *rocker_port,
4871 struct rocker_desc_info *desc_info)
4873 const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1];
4874 struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info);
4881 rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info);
4882 if (!attrs[ROCKER_TLV_RX_FRAG_LEN])
4884 if (attrs[ROCKER_TLV_RX_FLAGS])
4885 rx_flags = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FLAGS]);
4887 rocker_dma_rx_ring_skb_unmap(rocker, attrs);
4889 rx_len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_LEN]);
4890 skb_put(skb, rx_len);
4891 skb->protocol = eth_type_trans(skb, rocker_port->dev);
4893 if (rx_flags & ROCKER_RX_FLAGS_FWD_OFFLOAD)
4894 skb->offload_fwd_mark = rocker_port->dev->offload_fwd_mark;
4896 rocker_port->dev->stats.rx_packets++;
4897 rocker_port->dev->stats.rx_bytes += skb->len;
4899 netif_receive_skb(skb);
4901 return rocker_dma_rx_ring_skb_alloc(rocker_port, desc_info);
4904 static struct rocker_port *rocker_port_napi_rx_get(struct napi_struct *napi)
4906 return container_of(napi, struct rocker_port, napi_rx);
4909 static int rocker_port_poll_rx(struct napi_struct *napi, int budget)
4911 struct rocker_port *rocker_port = rocker_port_napi_rx_get(napi);
4912 const struct rocker *rocker = rocker_port->rocker;
4913 struct rocker_desc_info *desc_info;
4917 /* Process rx descriptors */
4918 while (credits < budget &&
4919 (desc_info = rocker_desc_tail_get(&rocker_port->rx_ring))) {
4920 err = rocker_desc_err(desc_info);
4922 if (net_ratelimit())
4923 netdev_err(rocker_port->dev, "rx desc received with err %d\n",
4926 err = rocker_port_rx_proc(rocker, rocker_port,
4928 if (err && net_ratelimit())
4929 netdev_err(rocker_port->dev, "rx processing failed with err %d\n",
4933 rocker_port->dev->stats.rx_errors++;
4935 rocker_desc_gen_clear(desc_info);
4936 rocker_desc_head_set(rocker, &rocker_port->rx_ring, desc_info);
4940 if (credits < budget)
4941 napi_complete(napi);
4943 rocker_dma_ring_credits_set(rocker, &rocker_port->rx_ring, credits);
4952 static void rocker_carrier_init(const struct rocker_port *rocker_port)
4954 const struct rocker *rocker = rocker_port->rocker;
4955 u64 link_status = rocker_read64(rocker, PORT_PHYS_LINK_STATUS);
4958 link_up = link_status & (1 << rocker_port->pport);
4960 netif_carrier_on(rocker_port->dev);
4962 netif_carrier_off(rocker_port->dev);
4965 static void rocker_remove_ports(const struct rocker *rocker)
4967 struct rocker_port *rocker_port;
4970 for (i = 0; i < rocker->port_count; i++) {
4971 rocker_port = rocker->ports[i];
4974 rocker_port_ig_tbl(rocker_port, NULL, ROCKER_OP_FLAG_REMOVE);
4975 unregister_netdev(rocker_port->dev);
4976 free_netdev(rocker_port->dev);
4978 kfree(rocker->ports);
4981 static void rocker_port_dev_addr_init(struct rocker_port *rocker_port)
4983 const struct rocker *rocker = rocker_port->rocker;
4984 const struct pci_dev *pdev = rocker->pdev;
4987 err = rocker_cmd_get_port_settings_macaddr(rocker_port,
4988 rocker_port->dev->dev_addr);
4990 dev_warn(&pdev->dev, "failed to get mac address, using random\n");
4991 eth_hw_addr_random(rocker_port->dev);
4995 static int rocker_probe_port(struct rocker *rocker, unsigned int port_number)
4997 const struct pci_dev *pdev = rocker->pdev;
4998 struct rocker_port *rocker_port;
4999 struct net_device *dev;
5000 u16 untagged_vid = 0;
5003 dev = alloc_etherdev(sizeof(struct rocker_port));
5006 rocker_port = netdev_priv(dev);
5007 rocker_port->dev = dev;
5008 rocker_port->rocker = rocker;
5009 rocker_port->port_number = port_number;
5010 rocker_port->pport = port_number + 1;
5011 rocker_port->brport_flags = BR_LEARNING | BR_LEARNING_SYNC;
5012 rocker_port->ageing_time = BR_DEFAULT_AGEING_TIME;
5013 INIT_LIST_HEAD(&rocker_port->trans_mem);
5015 rocker_port_dev_addr_init(rocker_port);
5016 dev->netdev_ops = &rocker_port_netdev_ops;
5017 dev->ethtool_ops = &rocker_port_ethtool_ops;
5018 dev->switchdev_ops = &rocker_port_switchdev_ops;
5019 netif_napi_add(dev, &rocker_port->napi_tx, rocker_port_poll_tx,
5021 netif_napi_add(dev, &rocker_port->napi_rx, rocker_port_poll_rx,
5023 rocker_carrier_init(rocker_port);
5025 dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_SG;
5027 err = register_netdev(dev);
5029 dev_err(&pdev->dev, "register_netdev failed\n");
5030 goto err_register_netdev;
5032 rocker->ports[port_number] = rocker_port;
5034 switchdev_port_fwd_mark_set(rocker_port->dev, NULL, false);
5036 rocker_port_set_learning(rocker_port, NULL);
5038 err = rocker_port_ig_tbl(rocker_port, NULL, 0);
5040 netdev_err(rocker_port->dev, "install ig port table failed\n");
5041 goto err_port_ig_tbl;
5044 rocker_port->internal_vlan_id =
5045 rocker_port_internal_vlan_id_get(rocker_port, dev->ifindex);
5047 err = rocker_port_vlan_add(rocker_port, NULL, untagged_vid, 0);
5049 netdev_err(rocker_port->dev, "install untagged VLAN failed\n");
5050 goto err_untagged_vlan;
5056 rocker_port_ig_tbl(rocker_port, NULL, ROCKER_OP_FLAG_REMOVE);
5058 rocker->ports[port_number] = NULL;
5059 unregister_netdev(dev);
5060 err_register_netdev:
5065 static int rocker_probe_ports(struct rocker *rocker)
5071 alloc_size = sizeof(struct rocker_port *) * rocker->port_count;
5072 rocker->ports = kzalloc(alloc_size, GFP_KERNEL);
5075 for (i = 0; i < rocker->port_count; i++) {
5076 err = rocker_probe_port(rocker, i);
5083 rocker_remove_ports(rocker);
5087 static int rocker_msix_init(struct rocker *rocker)
5089 struct pci_dev *pdev = rocker->pdev;
5094 msix_entries = pci_msix_vec_count(pdev);
5095 if (msix_entries < 0)
5096 return msix_entries;
5098 if (msix_entries != ROCKER_MSIX_VEC_COUNT(rocker->port_count))
5101 rocker->msix_entries = kmalloc_array(msix_entries,
5102 sizeof(struct msix_entry),
5104 if (!rocker->msix_entries)
5107 for (i = 0; i < msix_entries; i++)
5108 rocker->msix_entries[i].entry = i;
5110 err = pci_enable_msix_exact(pdev, rocker->msix_entries, msix_entries);
5112 goto err_enable_msix;
5117 kfree(rocker->msix_entries);
5121 static void rocker_msix_fini(const struct rocker *rocker)
5123 pci_disable_msix(rocker->pdev);
5124 kfree(rocker->msix_entries);
5127 static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5129 struct rocker *rocker;
5132 rocker = kzalloc(sizeof(*rocker), GFP_KERNEL);
5136 err = pci_enable_device(pdev);
5138 dev_err(&pdev->dev, "pci_enable_device failed\n");
5139 goto err_pci_enable_device;
5142 err = pci_request_regions(pdev, rocker_driver_name);
5144 dev_err(&pdev->dev, "pci_request_regions failed\n");
5145 goto err_pci_request_regions;
5148 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
5150 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
5152 dev_err(&pdev->dev, "pci_set_consistent_dma_mask failed\n");
5153 goto err_pci_set_dma_mask;
5156 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
5158 dev_err(&pdev->dev, "pci_set_dma_mask failed\n");
5159 goto err_pci_set_dma_mask;
5163 if (pci_resource_len(pdev, 0) < ROCKER_PCI_BAR0_SIZE) {
5164 dev_err(&pdev->dev, "invalid PCI region size\n");
5166 goto err_pci_resource_len_check;
5169 rocker->hw_addr = ioremap(pci_resource_start(pdev, 0),
5170 pci_resource_len(pdev, 0));
5171 if (!rocker->hw_addr) {
5172 dev_err(&pdev->dev, "ioremap failed\n");
5176 pci_set_master(pdev);
5178 rocker->pdev = pdev;
5179 pci_set_drvdata(pdev, rocker);
5181 rocker->port_count = rocker_read32(rocker, PORT_PHYS_COUNT);
5183 err = rocker_msix_init(rocker);
5185 dev_err(&pdev->dev, "MSI-X init failed\n");
5189 err = rocker_basic_hw_test(rocker);
5191 dev_err(&pdev->dev, "basic hw test failed\n");
5192 goto err_basic_hw_test;
5195 rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
5197 err = rocker_dma_rings_init(rocker);
5199 goto err_dma_rings_init;
5201 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD),
5202 rocker_cmd_irq_handler, 0,
5203 rocker_driver_name, rocker);
5205 dev_err(&pdev->dev, "cannot assign cmd irq\n");
5206 goto err_request_cmd_irq;
5209 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT),
5210 rocker_event_irq_handler, 0,
5211 rocker_driver_name, rocker);
5213 dev_err(&pdev->dev, "cannot assign event irq\n");
5214 goto err_request_event_irq;
5217 rocker->hw.id = rocker_read64(rocker, SWITCH_ID);
5219 err = rocker_init_tbls(rocker);
5221 dev_err(&pdev->dev, "cannot init rocker tables\n");
5225 setup_timer(&rocker->fdb_cleanup_timer, rocker_fdb_cleanup,
5226 (unsigned long) rocker);
5227 mod_timer(&rocker->fdb_cleanup_timer, jiffies);
5229 err = rocker_probe_ports(rocker);
5231 dev_err(&pdev->dev, "failed to probe ports\n");
5232 goto err_probe_ports;
5235 dev_info(&pdev->dev, "Rocker switch with id %*phN\n",
5236 (int)sizeof(rocker->hw.id), &rocker->hw.id);
5241 del_timer_sync(&rocker->fdb_cleanup_timer);
5242 rocker_free_tbls(rocker);
5244 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
5245 err_request_event_irq:
5246 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
5247 err_request_cmd_irq:
5248 rocker_dma_rings_fini(rocker);
5251 rocker_msix_fini(rocker);
5253 iounmap(rocker->hw_addr);
5255 err_pci_resource_len_check:
5256 err_pci_set_dma_mask:
5257 pci_release_regions(pdev);
5258 err_pci_request_regions:
5259 pci_disable_device(pdev);
5260 err_pci_enable_device:
5265 static void rocker_remove(struct pci_dev *pdev)
5267 struct rocker *rocker = pci_get_drvdata(pdev);
5269 del_timer_sync(&rocker->fdb_cleanup_timer);
5270 rocker_free_tbls(rocker);
5271 rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
5272 rocker_remove_ports(rocker);
5273 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
5274 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
5275 rocker_dma_rings_fini(rocker);
5276 rocker_msix_fini(rocker);
5277 iounmap(rocker->hw_addr);
5278 pci_release_regions(rocker->pdev);
5279 pci_disable_device(rocker->pdev);
5283 static struct pci_driver rocker_pci_driver = {
5284 .name = rocker_driver_name,
5285 .id_table = rocker_pci_id_table,
5286 .probe = rocker_probe,
5287 .remove = rocker_remove,
5290 /************************************
5291 * Net device notifier event handler
5292 ************************************/
5294 static bool rocker_port_dev_check(const struct net_device *dev)
5296 return dev->netdev_ops == &rocker_port_netdev_ops;
5299 static int rocker_port_bridge_join(struct rocker_port *rocker_port,
5300 struct net_device *bridge)
5302 u16 untagged_vid = 0;
5305 /* Port is joining bridge, so the internal VLAN for the
5306 * port is going to change to the bridge internal VLAN.
5307 * Let's remove untagged VLAN (vid=0) from port and
5308 * re-add once internal VLAN has changed.
5311 err = rocker_port_vlan_del(rocker_port, untagged_vid, 0);
5315 rocker_port_internal_vlan_id_put(rocker_port,
5316 rocker_port->dev->ifindex);
5317 rocker_port->internal_vlan_id =
5318 rocker_port_internal_vlan_id_get(rocker_port, bridge->ifindex);
5320 rocker_port->bridge_dev = bridge;
5321 switchdev_port_fwd_mark_set(rocker_port->dev, bridge, true);
5323 return rocker_port_vlan_add(rocker_port, NULL, untagged_vid, 0);
5326 static int rocker_port_bridge_leave(struct rocker_port *rocker_port)
5328 u16 untagged_vid = 0;
5331 err = rocker_port_vlan_del(rocker_port, untagged_vid, 0);
5335 rocker_port_internal_vlan_id_put(rocker_port,
5336 rocker_port->bridge_dev->ifindex);
5337 rocker_port->internal_vlan_id =
5338 rocker_port_internal_vlan_id_get(rocker_port,
5339 rocker_port->dev->ifindex);
5341 switchdev_port_fwd_mark_set(rocker_port->dev, rocker_port->bridge_dev,
5343 rocker_port->bridge_dev = NULL;
5345 err = rocker_port_vlan_add(rocker_port, NULL, untagged_vid, 0);
5349 if (rocker_port->dev->flags & IFF_UP)
5350 err = rocker_port_fwd_enable(rocker_port, NULL, 0);
5356 static int rocker_port_ovs_changed(struct rocker_port *rocker_port,
5357 struct net_device *master)
5361 rocker_port->bridge_dev = master;
5363 err = rocker_port_fwd_disable(rocker_port, NULL, 0);
5366 err = rocker_port_fwd_enable(rocker_port, NULL, 0);
5371 static int rocker_port_master_linked(struct rocker_port *rocker_port,
5372 struct net_device *master)
5376 if (netif_is_bridge_master(master))
5377 err = rocker_port_bridge_join(rocker_port, master);
5378 else if (netif_is_ovs_master(master))
5379 err = rocker_port_ovs_changed(rocker_port, master);
5383 static int rocker_port_master_unlinked(struct rocker_port *rocker_port)
5387 if (rocker_port_is_bridged(rocker_port))
5388 err = rocker_port_bridge_leave(rocker_port);
5389 else if (rocker_port_is_ovsed(rocker_port))
5390 err = rocker_port_ovs_changed(rocker_port, NULL);
5394 static int rocker_netdevice_event(struct notifier_block *unused,
5395 unsigned long event, void *ptr)
5397 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
5398 struct netdev_notifier_changeupper_info *info;
5399 struct rocker_port *rocker_port;
5402 if (!rocker_port_dev_check(dev))
5406 case NETDEV_CHANGEUPPER:
5410 rocker_port = netdev_priv(dev);
5411 if (info->linking) {
5412 err = rocker_port_master_linked(rocker_port,
5415 netdev_warn(dev, "failed to reflect master linked (err %d)\n",
5418 err = rocker_port_master_unlinked(rocker_port);
5420 netdev_warn(dev, "failed to reflect master unlinked (err %d)\n",
5429 static struct notifier_block rocker_netdevice_nb __read_mostly = {
5430 .notifier_call = rocker_netdevice_event,
5433 /************************************
5434 * Net event notifier event handler
5435 ************************************/
5437 static int rocker_neigh_update(struct net_device *dev, struct neighbour *n)
5439 struct rocker_port *rocker_port = netdev_priv(dev);
5440 int flags = (n->nud_state & NUD_VALID ? 0 : ROCKER_OP_FLAG_REMOVE) |
5441 ROCKER_OP_FLAG_NOWAIT;
5442 __be32 ip_addr = *(__be32 *)n->primary_key;
5444 return rocker_port_ipv4_neigh(rocker_port, NULL, flags, ip_addr, n->ha);
5447 static int rocker_netevent_event(struct notifier_block *unused,
5448 unsigned long event, void *ptr)
5450 struct net_device *dev;
5451 struct neighbour *n = ptr;
5455 case NETEVENT_NEIGH_UPDATE:
5456 if (n->tbl != &arp_tbl)
5459 if (!rocker_port_dev_check(dev))
5461 err = rocker_neigh_update(dev, n);
5464 "failed to handle neigh update (err %d)\n",
5472 static struct notifier_block rocker_netevent_nb __read_mostly = {
5473 .notifier_call = rocker_netevent_event,
5476 /***********************
5477 * Module init and exit
5478 ***********************/
5480 static int __init rocker_module_init(void)
5484 register_netdevice_notifier(&rocker_netdevice_nb);
5485 register_netevent_notifier(&rocker_netevent_nb);
5486 err = pci_register_driver(&rocker_pci_driver);
5488 goto err_pci_register_driver;
5491 err_pci_register_driver:
5492 unregister_netevent_notifier(&rocker_netevent_nb);
5493 unregister_netdevice_notifier(&rocker_netdevice_nb);
5497 static void __exit rocker_module_exit(void)
5499 unregister_netevent_notifier(&rocker_netevent_nb);
5500 unregister_netdevice_notifier(&rocker_netdevice_nb);
5501 pci_unregister_driver(&rocker_pci_driver);
5504 module_init(rocker_module_init);
5505 module_exit(rocker_module_exit);
5507 MODULE_LICENSE("GPL v2");
5508 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
5509 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>");
5510 MODULE_DESCRIPTION("Rocker switch device driver");
5511 MODULE_DEVICE_TABLE(pci, rocker_pci_id_table);