2 * drivers/net/ethernet/rocker/rocker.c - Rocker switch device driver
3 * Copyright (c) 2014-2016 Jiri Pirko <jiri@mellanox.com>
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/sort.h>
20 #include <linux/random.h>
21 #include <linux/netdevice.h>
22 #include <linux/skbuff.h>
23 #include <linux/socket.h>
24 #include <linux/etherdevice.h>
25 #include <linux/ethtool.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/if_bridge.h>
29 #include <linux/bitops.h>
30 #include <linux/ctype.h>
31 #include <linux/workqueue.h>
32 #include <net/switchdev.h>
33 #include <net/rtnetlink.h>
34 #include <net/netevent.h>
36 #include <net/fib_rules.h>
37 #include <net/fib_notifier.h>
38 #include <linux/io-64-nonatomic-lo-hi.h>
39 #include <generated/utsrelease.h>
41 #include "rocker_hw.h"
43 #include "rocker_tlv.h"
45 static const char rocker_driver_name
[] = "rocker";
47 static const struct pci_device_id rocker_pci_id_table
[] = {
48 {PCI_VDEVICE(REDHAT
, PCI_DEVICE_ID_REDHAT_ROCKER
), 0},
53 wait_queue_head_t wait
;
58 static void rocker_wait_reset(struct rocker_wait
*wait
)
64 static void rocker_wait_init(struct rocker_wait
*wait
)
66 init_waitqueue_head(&wait
->wait
);
67 rocker_wait_reset(wait
);
70 static struct rocker_wait
*rocker_wait_create(void)
72 struct rocker_wait
*wait
;
74 wait
= kzalloc(sizeof(*wait
), GFP_KERNEL
);
80 static void rocker_wait_destroy(struct rocker_wait
*wait
)
85 static bool rocker_wait_event_timeout(struct rocker_wait
*wait
,
86 unsigned long timeout
)
88 wait_event_timeout(wait
->wait
, wait
->done
, HZ
/ 10);
94 static void rocker_wait_wake_up(struct rocker_wait
*wait
)
100 static u32
rocker_msix_vector(const struct rocker
*rocker
, unsigned int vector
)
102 return rocker
->msix_entries
[vector
].vector
;
105 static u32
rocker_msix_tx_vector(const struct rocker_port
*rocker_port
)
107 return rocker_msix_vector(rocker_port
->rocker
,
108 ROCKER_MSIX_VEC_TX(rocker_port
->port_number
));
111 static u32
rocker_msix_rx_vector(const struct rocker_port
*rocker_port
)
113 return rocker_msix_vector(rocker_port
->rocker
,
114 ROCKER_MSIX_VEC_RX(rocker_port
->port_number
));
117 #define rocker_write32(rocker, reg, val) \
118 writel((val), (rocker)->hw_addr + (ROCKER_ ## reg))
119 #define rocker_read32(rocker, reg) \
120 readl((rocker)->hw_addr + (ROCKER_ ## reg))
121 #define rocker_write64(rocker, reg, val) \
122 writeq((val), (rocker)->hw_addr + (ROCKER_ ## reg))
123 #define rocker_read64(rocker, reg) \
124 readq((rocker)->hw_addr + (ROCKER_ ## reg))
126 /*****************************
127 * HW basic testing functions
128 *****************************/
130 static int rocker_reg_test(const struct rocker
*rocker
)
132 const struct pci_dev
*pdev
= rocker
->pdev
;
138 rocker_write32(rocker
, TEST_REG
, rnd
);
139 test_reg
= rocker_read32(rocker
, TEST_REG
);
140 if (test_reg
!= rnd
* 2) {
141 dev_err(&pdev
->dev
, "unexpected 32bit register value %08llx, expected %08llx\n",
148 rnd
|= prandom_u32();
149 rocker_write64(rocker
, TEST_REG64
, rnd
);
150 test_reg
= rocker_read64(rocker
, TEST_REG64
);
151 if (test_reg
!= rnd
* 2) {
152 dev_err(&pdev
->dev
, "unexpected 64bit register value %16llx, expected %16llx\n",
160 static int rocker_dma_test_one(const struct rocker
*rocker
,
161 struct rocker_wait
*wait
, u32 test_type
,
162 dma_addr_t dma_handle
, const unsigned char *buf
,
163 const unsigned char *expect
, size_t size
)
165 const struct pci_dev
*pdev
= rocker
->pdev
;
168 rocker_wait_reset(wait
);
169 rocker_write32(rocker
, TEST_DMA_CTRL
, test_type
);
171 if (!rocker_wait_event_timeout(wait
, HZ
/ 10)) {
172 dev_err(&pdev
->dev
, "no interrupt received within a timeout\n");
176 for (i
= 0; i
< size
; i
++) {
177 if (buf
[i
] != expect
[i
]) {
178 dev_err(&pdev
->dev
, "unexpected memory content %02x at byte %x\n, %02x expected",
179 buf
[i
], i
, expect
[i
]);
186 #define ROCKER_TEST_DMA_BUF_SIZE (PAGE_SIZE * 4)
187 #define ROCKER_TEST_DMA_FILL_PATTERN 0x96
189 static int rocker_dma_test_offset(const struct rocker
*rocker
,
190 struct rocker_wait
*wait
, int offset
)
192 struct pci_dev
*pdev
= rocker
->pdev
;
193 unsigned char *alloc
;
195 unsigned char *expect
;
196 dma_addr_t dma_handle
;
200 alloc
= kzalloc(ROCKER_TEST_DMA_BUF_SIZE
* 2 + offset
,
201 GFP_KERNEL
| GFP_DMA
);
204 buf
= alloc
+ offset
;
205 expect
= buf
+ ROCKER_TEST_DMA_BUF_SIZE
;
207 dma_handle
= pci_map_single(pdev
, buf
, ROCKER_TEST_DMA_BUF_SIZE
,
208 PCI_DMA_BIDIRECTIONAL
);
209 if (pci_dma_mapping_error(pdev
, dma_handle
)) {
214 rocker_write64(rocker
, TEST_DMA_ADDR
, dma_handle
);
215 rocker_write32(rocker
, TEST_DMA_SIZE
, ROCKER_TEST_DMA_BUF_SIZE
);
217 memset(expect
, ROCKER_TEST_DMA_FILL_PATTERN
, ROCKER_TEST_DMA_BUF_SIZE
);
218 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_FILL
,
219 dma_handle
, buf
, expect
,
220 ROCKER_TEST_DMA_BUF_SIZE
);
224 memset(expect
, 0, ROCKER_TEST_DMA_BUF_SIZE
);
225 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_CLEAR
,
226 dma_handle
, buf
, expect
,
227 ROCKER_TEST_DMA_BUF_SIZE
);
231 prandom_bytes(buf
, ROCKER_TEST_DMA_BUF_SIZE
);
232 for (i
= 0; i
< ROCKER_TEST_DMA_BUF_SIZE
; i
++)
234 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_INVERT
,
235 dma_handle
, buf
, expect
,
236 ROCKER_TEST_DMA_BUF_SIZE
);
241 pci_unmap_single(pdev
, dma_handle
, ROCKER_TEST_DMA_BUF_SIZE
,
242 PCI_DMA_BIDIRECTIONAL
);
249 static int rocker_dma_test(const struct rocker
*rocker
,
250 struct rocker_wait
*wait
)
255 for (i
= 0; i
< 8; i
++) {
256 err
= rocker_dma_test_offset(rocker
, wait
, i
);
263 static irqreturn_t
rocker_test_irq_handler(int irq
, void *dev_id
)
265 struct rocker_wait
*wait
= dev_id
;
267 rocker_wait_wake_up(wait
);
272 static int rocker_basic_hw_test(const struct rocker
*rocker
)
274 const struct pci_dev
*pdev
= rocker
->pdev
;
275 struct rocker_wait wait
;
278 err
= rocker_reg_test(rocker
);
280 dev_err(&pdev
->dev
, "reg test failed\n");
284 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_TEST
),
285 rocker_test_irq_handler
, 0,
286 rocker_driver_name
, &wait
);
288 dev_err(&pdev
->dev
, "cannot assign test irq\n");
292 rocker_wait_init(&wait
);
293 rocker_write32(rocker
, TEST_IRQ
, ROCKER_MSIX_VEC_TEST
);
295 if (!rocker_wait_event_timeout(&wait
, HZ
/ 10)) {
296 dev_err(&pdev
->dev
, "no interrupt received within a timeout\n");
301 err
= rocker_dma_test(rocker
, &wait
);
303 dev_err(&pdev
->dev
, "dma test failed\n");
306 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_TEST
), &wait
);
310 /******************************************
311 * DMA rings and descriptors manipulations
312 ******************************************/
314 static u32
__pos_inc(u32 pos
, size_t limit
)
316 return ++pos
== limit
? 0 : pos
;
319 static int rocker_desc_err(const struct rocker_desc_info
*desc_info
)
321 int err
= desc_info
->desc
->comp_err
& ~ROCKER_DMA_DESC_COMP_ERR_GEN
;
336 case -ROCKER_EMSGSIZE
:
338 case -ROCKER_ENOTSUP
:
340 case -ROCKER_ENOBUFS
:
347 static void rocker_desc_gen_clear(const struct rocker_desc_info
*desc_info
)
349 desc_info
->desc
->comp_err
&= ~ROCKER_DMA_DESC_COMP_ERR_GEN
;
352 static bool rocker_desc_gen(const struct rocker_desc_info
*desc_info
)
354 u32 comp_err
= desc_info
->desc
->comp_err
;
356 return comp_err
& ROCKER_DMA_DESC_COMP_ERR_GEN
? true : false;
360 rocker_desc_cookie_ptr_get(const struct rocker_desc_info
*desc_info
)
362 return (void *)(uintptr_t)desc_info
->desc
->cookie
;
365 static void rocker_desc_cookie_ptr_set(const struct rocker_desc_info
*desc_info
,
368 desc_info
->desc
->cookie
= (uintptr_t) ptr
;
371 static struct rocker_desc_info
*
372 rocker_desc_head_get(const struct rocker_dma_ring_info
*info
)
374 struct rocker_desc_info
*desc_info
;
375 u32 head
= __pos_inc(info
->head
, info
->size
);
377 desc_info
= &info
->desc_info
[info
->head
];
378 if (head
== info
->tail
)
379 return NULL
; /* ring full */
380 desc_info
->tlv_size
= 0;
384 static void rocker_desc_commit(const struct rocker_desc_info
*desc_info
)
386 desc_info
->desc
->buf_size
= desc_info
->data_size
;
387 desc_info
->desc
->tlv_size
= desc_info
->tlv_size
;
390 static void rocker_desc_head_set(const struct rocker
*rocker
,
391 struct rocker_dma_ring_info
*info
,
392 const struct rocker_desc_info
*desc_info
)
394 u32 head
= __pos_inc(info
->head
, info
->size
);
396 BUG_ON(head
== info
->tail
);
397 rocker_desc_commit(desc_info
);
399 rocker_write32(rocker
, DMA_DESC_HEAD(info
->type
), head
);
402 static struct rocker_desc_info
*
403 rocker_desc_tail_get(struct rocker_dma_ring_info
*info
)
405 struct rocker_desc_info
*desc_info
;
407 if (info
->tail
== info
->head
)
408 return NULL
; /* nothing to be done between head and tail */
409 desc_info
= &info
->desc_info
[info
->tail
];
410 if (!rocker_desc_gen(desc_info
))
411 return NULL
; /* gen bit not set, desc is not ready yet */
412 info
->tail
= __pos_inc(info
->tail
, info
->size
);
413 desc_info
->tlv_size
= desc_info
->desc
->tlv_size
;
417 static void rocker_dma_ring_credits_set(const struct rocker
*rocker
,
418 const struct rocker_dma_ring_info
*info
,
422 rocker_write32(rocker
, DMA_DESC_CREDITS(info
->type
), credits
);
425 static unsigned long rocker_dma_ring_size_fix(size_t size
)
427 return max(ROCKER_DMA_SIZE_MIN
,
428 min(roundup_pow_of_two(size
), ROCKER_DMA_SIZE_MAX
));
431 static int rocker_dma_ring_create(const struct rocker
*rocker
,
434 struct rocker_dma_ring_info
*info
)
438 BUG_ON(size
!= rocker_dma_ring_size_fix(size
));
443 info
->desc_info
= kcalloc(info
->size
, sizeof(*info
->desc_info
),
445 if (!info
->desc_info
)
448 info
->desc
= pci_alloc_consistent(rocker
->pdev
,
449 info
->size
* sizeof(*info
->desc
),
452 kfree(info
->desc_info
);
456 for (i
= 0; i
< info
->size
; i
++)
457 info
->desc_info
[i
].desc
= &info
->desc
[i
];
459 rocker_write32(rocker
, DMA_DESC_CTRL(info
->type
),
460 ROCKER_DMA_DESC_CTRL_RESET
);
461 rocker_write64(rocker
, DMA_DESC_ADDR(info
->type
), info
->mapaddr
);
462 rocker_write32(rocker
, DMA_DESC_SIZE(info
->type
), info
->size
);
467 static void rocker_dma_ring_destroy(const struct rocker
*rocker
,
468 const struct rocker_dma_ring_info
*info
)
470 rocker_write64(rocker
, DMA_DESC_ADDR(info
->type
), 0);
472 pci_free_consistent(rocker
->pdev
,
473 info
->size
* sizeof(struct rocker_desc
),
474 info
->desc
, info
->mapaddr
);
475 kfree(info
->desc_info
);
478 static void rocker_dma_ring_pass_to_producer(const struct rocker
*rocker
,
479 struct rocker_dma_ring_info
*info
)
483 BUG_ON(info
->head
|| info
->tail
);
485 /* When ring is consumer, we need to advance head for each desc.
486 * That tells hw that the desc is ready to be used by it.
488 for (i
= 0; i
< info
->size
- 1; i
++)
489 rocker_desc_head_set(rocker
, info
, &info
->desc_info
[i
]);
490 rocker_desc_commit(&info
->desc_info
[i
]);
493 static int rocker_dma_ring_bufs_alloc(const struct rocker
*rocker
,
494 const struct rocker_dma_ring_info
*info
,
495 int direction
, size_t buf_size
)
497 struct pci_dev
*pdev
= rocker
->pdev
;
501 for (i
= 0; i
< info
->size
; i
++) {
502 struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
503 struct rocker_desc
*desc
= &info
->desc
[i
];
504 dma_addr_t dma_handle
;
507 buf
= kzalloc(buf_size
, GFP_KERNEL
| GFP_DMA
);
513 dma_handle
= pci_map_single(pdev
, buf
, buf_size
, direction
);
514 if (pci_dma_mapping_error(pdev
, dma_handle
)) {
520 desc_info
->data
= buf
;
521 desc_info
->data_size
= buf_size
;
522 dma_unmap_addr_set(desc_info
, mapaddr
, dma_handle
);
524 desc
->buf_addr
= dma_handle
;
525 desc
->buf_size
= buf_size
;
530 for (i
--; i
>= 0; i
--) {
531 const struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
533 pci_unmap_single(pdev
, dma_unmap_addr(desc_info
, mapaddr
),
534 desc_info
->data_size
, direction
);
535 kfree(desc_info
->data
);
540 static void rocker_dma_ring_bufs_free(const struct rocker
*rocker
,
541 const struct rocker_dma_ring_info
*info
,
544 struct pci_dev
*pdev
= rocker
->pdev
;
547 for (i
= 0; i
< info
->size
; i
++) {
548 const struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
549 struct rocker_desc
*desc
= &info
->desc
[i
];
553 pci_unmap_single(pdev
, dma_unmap_addr(desc_info
, mapaddr
),
554 desc_info
->data_size
, direction
);
555 kfree(desc_info
->data
);
559 static int rocker_dma_cmd_ring_wait_alloc(struct rocker_desc_info
*desc_info
)
561 struct rocker_wait
*wait
;
563 wait
= rocker_wait_create();
566 rocker_desc_cookie_ptr_set(desc_info
, wait
);
571 rocker_dma_cmd_ring_wait_free(const struct rocker_desc_info
*desc_info
)
573 struct rocker_wait
*wait
= rocker_desc_cookie_ptr_get(desc_info
);
575 rocker_wait_destroy(wait
);
578 static int rocker_dma_cmd_ring_waits_alloc(const struct rocker
*rocker
)
580 const struct rocker_dma_ring_info
*cmd_ring
= &rocker
->cmd_ring
;
584 for (i
= 0; i
< cmd_ring
->size
; i
++) {
585 err
= rocker_dma_cmd_ring_wait_alloc(&cmd_ring
->desc_info
[i
]);
592 for (i
--; i
>= 0; i
--)
593 rocker_dma_cmd_ring_wait_free(&cmd_ring
->desc_info
[i
]);
597 static void rocker_dma_cmd_ring_waits_free(const struct rocker
*rocker
)
599 const struct rocker_dma_ring_info
*cmd_ring
= &rocker
->cmd_ring
;
602 for (i
= 0; i
< cmd_ring
->size
; i
++)
603 rocker_dma_cmd_ring_wait_free(&cmd_ring
->desc_info
[i
]);
606 static int rocker_dma_rings_init(struct rocker
*rocker
)
608 const struct pci_dev
*pdev
= rocker
->pdev
;
611 err
= rocker_dma_ring_create(rocker
, ROCKER_DMA_CMD
,
612 ROCKER_DMA_CMD_DEFAULT_SIZE
,
615 dev_err(&pdev
->dev
, "failed to create command dma ring\n");
619 spin_lock_init(&rocker
->cmd_ring_lock
);
621 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker
->cmd_ring
,
622 PCI_DMA_BIDIRECTIONAL
, PAGE_SIZE
);
624 dev_err(&pdev
->dev
, "failed to alloc command dma ring buffers\n");
625 goto err_dma_cmd_ring_bufs_alloc
;
628 err
= rocker_dma_cmd_ring_waits_alloc(rocker
);
630 dev_err(&pdev
->dev
, "failed to alloc command dma ring waits\n");
631 goto err_dma_cmd_ring_waits_alloc
;
634 err
= rocker_dma_ring_create(rocker
, ROCKER_DMA_EVENT
,
635 ROCKER_DMA_EVENT_DEFAULT_SIZE
,
636 &rocker
->event_ring
);
638 dev_err(&pdev
->dev
, "failed to create event dma ring\n");
639 goto err_dma_event_ring_create
;
642 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker
->event_ring
,
643 PCI_DMA_FROMDEVICE
, PAGE_SIZE
);
645 dev_err(&pdev
->dev
, "failed to alloc event dma ring buffers\n");
646 goto err_dma_event_ring_bufs_alloc
;
648 rocker_dma_ring_pass_to_producer(rocker
, &rocker
->event_ring
);
651 err_dma_event_ring_bufs_alloc
:
652 rocker_dma_ring_destroy(rocker
, &rocker
->event_ring
);
653 err_dma_event_ring_create
:
654 rocker_dma_ring_bufs_free(rocker
, &rocker
->cmd_ring
,
655 PCI_DMA_BIDIRECTIONAL
);
656 err_dma_cmd_ring_waits_alloc
:
657 rocker_dma_cmd_ring_waits_free(rocker
);
658 err_dma_cmd_ring_bufs_alloc
:
659 rocker_dma_ring_destroy(rocker
, &rocker
->cmd_ring
);
663 static void rocker_dma_rings_fini(struct rocker
*rocker
)
665 rocker_dma_ring_bufs_free(rocker
, &rocker
->event_ring
,
666 PCI_DMA_BIDIRECTIONAL
);
667 rocker_dma_ring_destroy(rocker
, &rocker
->event_ring
);
668 rocker_dma_cmd_ring_waits_free(rocker
);
669 rocker_dma_ring_bufs_free(rocker
, &rocker
->cmd_ring
,
670 PCI_DMA_BIDIRECTIONAL
);
671 rocker_dma_ring_destroy(rocker
, &rocker
->cmd_ring
);
674 static int rocker_dma_rx_ring_skb_map(const struct rocker_port
*rocker_port
,
675 struct rocker_desc_info
*desc_info
,
676 struct sk_buff
*skb
, size_t buf_len
)
678 const struct rocker
*rocker
= rocker_port
->rocker
;
679 struct pci_dev
*pdev
= rocker
->pdev
;
680 dma_addr_t dma_handle
;
682 dma_handle
= pci_map_single(pdev
, skb
->data
, buf_len
,
684 if (pci_dma_mapping_error(pdev
, dma_handle
))
686 if (rocker_tlv_put_u64(desc_info
, ROCKER_TLV_RX_FRAG_ADDR
, dma_handle
))
687 goto tlv_put_failure
;
688 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_RX_FRAG_MAX_LEN
, buf_len
))
689 goto tlv_put_failure
;
693 pci_unmap_single(pdev
, dma_handle
, buf_len
, PCI_DMA_FROMDEVICE
);
694 desc_info
->tlv_size
= 0;
698 static size_t rocker_port_rx_buf_len(const struct rocker_port
*rocker_port
)
700 return rocker_port
->dev
->mtu
+ ETH_HLEN
+ ETH_FCS_LEN
+ VLAN_HLEN
;
703 static int rocker_dma_rx_ring_skb_alloc(const struct rocker_port
*rocker_port
,
704 struct rocker_desc_info
*desc_info
)
706 struct net_device
*dev
= rocker_port
->dev
;
708 size_t buf_len
= rocker_port_rx_buf_len(rocker_port
);
711 /* Ensure that hw will see tlv_size zero in case of an error.
712 * That tells hw to use another descriptor.
714 rocker_desc_cookie_ptr_set(desc_info
, NULL
);
715 desc_info
->tlv_size
= 0;
717 skb
= netdev_alloc_skb_ip_align(dev
, buf_len
);
720 err
= rocker_dma_rx_ring_skb_map(rocker_port
, desc_info
, skb
, buf_len
);
722 dev_kfree_skb_any(skb
);
725 rocker_desc_cookie_ptr_set(desc_info
, skb
);
729 static void rocker_dma_rx_ring_skb_unmap(const struct rocker
*rocker
,
730 const struct rocker_tlv
**attrs
)
732 struct pci_dev
*pdev
= rocker
->pdev
;
733 dma_addr_t dma_handle
;
736 if (!attrs
[ROCKER_TLV_RX_FRAG_ADDR
] ||
737 !attrs
[ROCKER_TLV_RX_FRAG_MAX_LEN
])
739 dma_handle
= rocker_tlv_get_u64(attrs
[ROCKER_TLV_RX_FRAG_ADDR
]);
740 len
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FRAG_MAX_LEN
]);
741 pci_unmap_single(pdev
, dma_handle
, len
, PCI_DMA_FROMDEVICE
);
744 static void rocker_dma_rx_ring_skb_free(const struct rocker
*rocker
,
745 const struct rocker_desc_info
*desc_info
)
747 const struct rocker_tlv
*attrs
[ROCKER_TLV_RX_MAX
+ 1];
748 struct sk_buff
*skb
= rocker_desc_cookie_ptr_get(desc_info
);
752 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_RX_MAX
, desc_info
);
753 rocker_dma_rx_ring_skb_unmap(rocker
, attrs
);
754 dev_kfree_skb_any(skb
);
757 static int rocker_dma_rx_ring_skbs_alloc(const struct rocker_port
*rocker_port
)
759 const struct rocker_dma_ring_info
*rx_ring
= &rocker_port
->rx_ring
;
760 const struct rocker
*rocker
= rocker_port
->rocker
;
764 for (i
= 0; i
< rx_ring
->size
; i
++) {
765 err
= rocker_dma_rx_ring_skb_alloc(rocker_port
,
766 &rx_ring
->desc_info
[i
]);
773 for (i
--; i
>= 0; i
--)
774 rocker_dma_rx_ring_skb_free(rocker
, &rx_ring
->desc_info
[i
]);
778 static void rocker_dma_rx_ring_skbs_free(const struct rocker_port
*rocker_port
)
780 const struct rocker_dma_ring_info
*rx_ring
= &rocker_port
->rx_ring
;
781 const struct rocker
*rocker
= rocker_port
->rocker
;
784 for (i
= 0; i
< rx_ring
->size
; i
++)
785 rocker_dma_rx_ring_skb_free(rocker
, &rx_ring
->desc_info
[i
]);
788 static int rocker_port_dma_rings_init(struct rocker_port
*rocker_port
)
790 struct rocker
*rocker
= rocker_port
->rocker
;
793 err
= rocker_dma_ring_create(rocker
,
794 ROCKER_DMA_TX(rocker_port
->port_number
),
795 ROCKER_DMA_TX_DEFAULT_SIZE
,
796 &rocker_port
->tx_ring
);
798 netdev_err(rocker_port
->dev
, "failed to create tx dma ring\n");
802 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker_port
->tx_ring
,
804 ROCKER_DMA_TX_DESC_SIZE
);
806 netdev_err(rocker_port
->dev
, "failed to alloc tx dma ring buffers\n");
807 goto err_dma_tx_ring_bufs_alloc
;
810 err
= rocker_dma_ring_create(rocker
,
811 ROCKER_DMA_RX(rocker_port
->port_number
),
812 ROCKER_DMA_RX_DEFAULT_SIZE
,
813 &rocker_port
->rx_ring
);
815 netdev_err(rocker_port
->dev
, "failed to create rx dma ring\n");
816 goto err_dma_rx_ring_create
;
819 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker_port
->rx_ring
,
820 PCI_DMA_BIDIRECTIONAL
,
821 ROCKER_DMA_RX_DESC_SIZE
);
823 netdev_err(rocker_port
->dev
, "failed to alloc rx dma ring buffers\n");
824 goto err_dma_rx_ring_bufs_alloc
;
827 err
= rocker_dma_rx_ring_skbs_alloc(rocker_port
);
829 netdev_err(rocker_port
->dev
, "failed to alloc rx dma ring skbs\n");
830 goto err_dma_rx_ring_skbs_alloc
;
832 rocker_dma_ring_pass_to_producer(rocker
, &rocker_port
->rx_ring
);
836 err_dma_rx_ring_skbs_alloc
:
837 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->rx_ring
,
838 PCI_DMA_BIDIRECTIONAL
);
839 err_dma_rx_ring_bufs_alloc
:
840 rocker_dma_ring_destroy(rocker
, &rocker_port
->rx_ring
);
841 err_dma_rx_ring_create
:
842 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->tx_ring
,
844 err_dma_tx_ring_bufs_alloc
:
845 rocker_dma_ring_destroy(rocker
, &rocker_port
->tx_ring
);
849 static void rocker_port_dma_rings_fini(struct rocker_port
*rocker_port
)
851 struct rocker
*rocker
= rocker_port
->rocker
;
853 rocker_dma_rx_ring_skbs_free(rocker_port
);
854 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->rx_ring
,
855 PCI_DMA_BIDIRECTIONAL
);
856 rocker_dma_ring_destroy(rocker
, &rocker_port
->rx_ring
);
857 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->tx_ring
,
859 rocker_dma_ring_destroy(rocker
, &rocker_port
->tx_ring
);
862 static void rocker_port_set_enable(const struct rocker_port
*rocker_port
,
865 u64 val
= rocker_read64(rocker_port
->rocker
, PORT_PHYS_ENABLE
);
868 val
|= 1ULL << rocker_port
->pport
;
870 val
&= ~(1ULL << rocker_port
->pport
);
871 rocker_write64(rocker_port
->rocker
, PORT_PHYS_ENABLE
, val
);
874 /********************************
875 * Interrupt handler and helpers
876 ********************************/
878 static irqreturn_t
rocker_cmd_irq_handler(int irq
, void *dev_id
)
880 struct rocker
*rocker
= dev_id
;
881 const struct rocker_desc_info
*desc_info
;
882 struct rocker_wait
*wait
;
885 spin_lock(&rocker
->cmd_ring_lock
);
886 while ((desc_info
= rocker_desc_tail_get(&rocker
->cmd_ring
))) {
887 wait
= rocker_desc_cookie_ptr_get(desc_info
);
889 rocker_desc_gen_clear(desc_info
);
891 rocker_wait_wake_up(wait
);
895 spin_unlock(&rocker
->cmd_ring_lock
);
896 rocker_dma_ring_credits_set(rocker
, &rocker
->cmd_ring
, credits
);
901 static void rocker_port_link_up(const struct rocker_port
*rocker_port
)
903 netif_carrier_on(rocker_port
->dev
);
904 netdev_info(rocker_port
->dev
, "Link is up\n");
907 static void rocker_port_link_down(const struct rocker_port
*rocker_port
)
909 netif_carrier_off(rocker_port
->dev
);
910 netdev_info(rocker_port
->dev
, "Link is down\n");
913 static int rocker_event_link_change(const struct rocker
*rocker
,
914 const struct rocker_tlv
*info
)
916 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_MAX
+ 1];
917 unsigned int port_number
;
919 struct rocker_port
*rocker_port
;
921 rocker_tlv_parse_nested(attrs
, ROCKER_TLV_EVENT_LINK_CHANGED_MAX
, info
);
922 if (!attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT
] ||
923 !attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP
])
926 rocker_tlv_get_u32(attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT
]) - 1;
927 link_up
= rocker_tlv_get_u8(attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP
]);
929 if (port_number
>= rocker
->port_count
)
932 rocker_port
= rocker
->ports
[port_number
];
933 if (netif_carrier_ok(rocker_port
->dev
) != link_up
) {
935 rocker_port_link_up(rocker_port
);
937 rocker_port_link_down(rocker_port
);
943 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port
*rocker_port
,
944 const unsigned char *addr
,
947 static int rocker_event_mac_vlan_seen(const struct rocker
*rocker
,
948 const struct rocker_tlv
*info
)
950 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAX
+ 1];
951 unsigned int port_number
;
952 struct rocker_port
*rocker_port
;
953 const unsigned char *addr
;
956 rocker_tlv_parse_nested(attrs
, ROCKER_TLV_EVENT_MAC_VLAN_MAX
, info
);
957 if (!attrs
[ROCKER_TLV_EVENT_MAC_VLAN_PPORT
] ||
958 !attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAC
] ||
959 !attrs
[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID
])
962 rocker_tlv_get_u32(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_PPORT
]) - 1;
963 addr
= rocker_tlv_data(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAC
]);
964 vlan_id
= rocker_tlv_get_be16(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID
]);
966 if (port_number
>= rocker
->port_count
)
969 rocker_port
= rocker
->ports
[port_number
];
970 return rocker_world_port_ev_mac_vlan_seen(rocker_port
, addr
, vlan_id
);
973 static int rocker_event_process(const struct rocker
*rocker
,
974 const struct rocker_desc_info
*desc_info
)
976 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_MAX
+ 1];
977 const struct rocker_tlv
*info
;
980 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_EVENT_MAX
, desc_info
);
981 if (!attrs
[ROCKER_TLV_EVENT_TYPE
] ||
982 !attrs
[ROCKER_TLV_EVENT_INFO
])
985 type
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_EVENT_TYPE
]);
986 info
= attrs
[ROCKER_TLV_EVENT_INFO
];
989 case ROCKER_TLV_EVENT_TYPE_LINK_CHANGED
:
990 return rocker_event_link_change(rocker
, info
);
991 case ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN
:
992 return rocker_event_mac_vlan_seen(rocker
, info
);
998 static irqreturn_t
rocker_event_irq_handler(int irq
, void *dev_id
)
1000 struct rocker
*rocker
= dev_id
;
1001 const struct pci_dev
*pdev
= rocker
->pdev
;
1002 const struct rocker_desc_info
*desc_info
;
1006 while ((desc_info
= rocker_desc_tail_get(&rocker
->event_ring
))) {
1007 err
= rocker_desc_err(desc_info
);
1009 dev_err(&pdev
->dev
, "event desc received with err %d\n",
1012 err
= rocker_event_process(rocker
, desc_info
);
1014 dev_err(&pdev
->dev
, "event processing failed with err %d\n",
1017 rocker_desc_gen_clear(desc_info
);
1018 rocker_desc_head_set(rocker
, &rocker
->event_ring
, desc_info
);
1021 rocker_dma_ring_credits_set(rocker
, &rocker
->event_ring
, credits
);
1026 static irqreturn_t
rocker_tx_irq_handler(int irq
, void *dev_id
)
1028 struct rocker_port
*rocker_port
= dev_id
;
1030 napi_schedule(&rocker_port
->napi_tx
);
1034 static irqreturn_t
rocker_rx_irq_handler(int irq
, void *dev_id
)
1036 struct rocker_port
*rocker_port
= dev_id
;
1038 napi_schedule(&rocker_port
->napi_rx
);
1042 /********************
1044 ********************/
1046 int rocker_cmd_exec(struct rocker_port
*rocker_port
, bool nowait
,
1047 rocker_cmd_prep_cb_t prepare
, void *prepare_priv
,
1048 rocker_cmd_proc_cb_t process
, void *process_priv
)
1050 struct rocker
*rocker
= rocker_port
->rocker
;
1051 struct rocker_desc_info
*desc_info
;
1052 struct rocker_wait
*wait
;
1053 unsigned long lock_flags
;
1056 spin_lock_irqsave(&rocker
->cmd_ring_lock
, lock_flags
);
1058 desc_info
= rocker_desc_head_get(&rocker
->cmd_ring
);
1060 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1064 wait
= rocker_desc_cookie_ptr_get(desc_info
);
1065 rocker_wait_init(wait
);
1066 wait
->nowait
= nowait
;
1068 err
= prepare(rocker_port
, desc_info
, prepare_priv
);
1070 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1074 rocker_desc_head_set(rocker
, &rocker
->cmd_ring
, desc_info
);
1076 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1081 if (!rocker_wait_event_timeout(wait
, HZ
/ 10))
1084 err
= rocker_desc_err(desc_info
);
1089 err
= process(rocker_port
, desc_info
, process_priv
);
1091 rocker_desc_gen_clear(desc_info
);
1096 rocker_cmd_get_port_settings_prep(const struct rocker_port
*rocker_port
,
1097 struct rocker_desc_info
*desc_info
,
1100 struct rocker_tlv
*cmd_info
;
1102 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1103 ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS
))
1105 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1108 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1109 rocker_port
->pport
))
1111 rocker_tlv_nest_end(desc_info
, cmd_info
);
1116 rocker_cmd_get_port_settings_ethtool_proc(const struct rocker_port
*rocker_port
,
1117 const struct rocker_desc_info
*desc_info
,
1120 struct ethtool_link_ksettings
*ecmd
= priv
;
1121 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1122 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1127 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1128 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1131 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1132 attrs
[ROCKER_TLV_CMD_INFO
]);
1133 if (!info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
] ||
1134 !info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
] ||
1135 !info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
])
1138 speed
= rocker_tlv_get_u32(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
]);
1139 duplex
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
]);
1140 autoneg
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
]);
1142 ethtool_link_ksettings_zero_link_mode(ecmd
, supported
);
1143 ethtool_link_ksettings_add_link_mode(ecmd
, supported
, TP
);
1145 ecmd
->base
.phy_address
= 0xff;
1146 ecmd
->base
.port
= PORT_TP
;
1147 ecmd
->base
.speed
= speed
;
1148 ecmd
->base
.duplex
= duplex
? DUPLEX_FULL
: DUPLEX_HALF
;
1149 ecmd
->base
.autoneg
= autoneg
? AUTONEG_ENABLE
: AUTONEG_DISABLE
;
1155 rocker_cmd_get_port_settings_macaddr_proc(const struct rocker_port
*rocker_port
,
1156 const struct rocker_desc_info
*desc_info
,
1159 unsigned char *macaddr
= priv
;
1160 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1161 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1162 const struct rocker_tlv
*attr
;
1164 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1165 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1168 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1169 attrs
[ROCKER_TLV_CMD_INFO
]);
1170 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR
];
1174 if (rocker_tlv_len(attr
) != ETH_ALEN
)
1177 ether_addr_copy(macaddr
, rocker_tlv_data(attr
));
1182 rocker_cmd_get_port_settings_mode_proc(const struct rocker_port
*rocker_port
,
1183 const struct rocker_desc_info
*desc_info
,
1187 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1188 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1189 const struct rocker_tlv
*attr
;
1191 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1192 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1195 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1196 attrs
[ROCKER_TLV_CMD_INFO
]);
1197 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MODE
];
1201 *p_mode
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MODE
]);
1211 rocker_cmd_get_port_settings_phys_name_proc(const struct rocker_port
*rocker_port
,
1212 const struct rocker_desc_info
*desc_info
,
1215 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1216 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1217 struct port_name
*name
= priv
;
1218 const struct rocker_tlv
*attr
;
1222 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1223 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1226 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1227 attrs
[ROCKER_TLV_CMD_INFO
]);
1228 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME
];
1232 len
= min_t(size_t, rocker_tlv_len(attr
), name
->len
);
1233 str
= rocker_tlv_data(attr
);
1235 /* make sure name only contains alphanumeric characters */
1236 for (i
= j
= 0; i
< len
; ++i
) {
1237 if (isalnum(str
[i
])) {
1238 name
->buf
[j
] = str
[i
];
1246 name
->buf
[j
] = '\0';
1252 rocker_cmd_set_port_settings_ethtool_prep(const struct rocker_port
*rocker_port
,
1253 struct rocker_desc_info
*desc_info
,
1256 struct ethtool_link_ksettings
*ecmd
= priv
;
1257 struct rocker_tlv
*cmd_info
;
1259 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1260 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1262 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1265 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1266 rocker_port
->pport
))
1268 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
,
1271 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
,
1274 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
,
1275 ecmd
->base
.autoneg
))
1277 rocker_tlv_nest_end(desc_info
, cmd_info
);
1282 rocker_cmd_set_port_settings_macaddr_prep(const struct rocker_port
*rocker_port
,
1283 struct rocker_desc_info
*desc_info
,
1286 const unsigned char *macaddr
= priv
;
1287 struct rocker_tlv
*cmd_info
;
1289 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1290 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1292 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1295 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1296 rocker_port
->pport
))
1298 if (rocker_tlv_put(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR
,
1301 rocker_tlv_nest_end(desc_info
, cmd_info
);
1306 rocker_cmd_set_port_settings_mtu_prep(const struct rocker_port
*rocker_port
,
1307 struct rocker_desc_info
*desc_info
,
1310 int mtu
= *(int *)priv
;
1311 struct rocker_tlv
*cmd_info
;
1313 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1314 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1316 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1319 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1320 rocker_port
->pport
))
1322 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_MTU
,
1325 rocker_tlv_nest_end(desc_info
, cmd_info
);
1330 rocker_cmd_set_port_learning_prep(const struct rocker_port
*rocker_port
,
1331 struct rocker_desc_info
*desc_info
,
1334 bool learning
= *(bool *)priv
;
1335 struct rocker_tlv
*cmd_info
;
1337 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1338 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1340 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1343 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1344 rocker_port
->pport
))
1346 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING
,
1349 rocker_tlv_nest_end(desc_info
, cmd_info
);
1354 rocker_cmd_get_port_settings_ethtool(struct rocker_port
*rocker_port
,
1355 struct ethtool_link_ksettings
*ecmd
)
1357 return rocker_cmd_exec(rocker_port
, false,
1358 rocker_cmd_get_port_settings_prep
, NULL
,
1359 rocker_cmd_get_port_settings_ethtool_proc
,
1363 static int rocker_cmd_get_port_settings_macaddr(struct rocker_port
*rocker_port
,
1364 unsigned char *macaddr
)
1366 return rocker_cmd_exec(rocker_port
, false,
1367 rocker_cmd_get_port_settings_prep
, NULL
,
1368 rocker_cmd_get_port_settings_macaddr_proc
,
1372 static int rocker_cmd_get_port_settings_mode(struct rocker_port
*rocker_port
,
1375 return rocker_cmd_exec(rocker_port
, false,
1376 rocker_cmd_get_port_settings_prep
, NULL
,
1377 rocker_cmd_get_port_settings_mode_proc
, p_mode
);
1381 rocker_cmd_set_port_settings_ethtool(struct rocker_port
*rocker_port
,
1382 const struct ethtool_link_ksettings
*ecmd
)
1384 struct ethtool_link_ksettings copy_ecmd
;
1386 memcpy(©_ecmd
, ecmd
, sizeof(copy_ecmd
));
1388 return rocker_cmd_exec(rocker_port
, false,
1389 rocker_cmd_set_port_settings_ethtool_prep
,
1390 ©_ecmd
, NULL
, NULL
);
1393 static int rocker_cmd_set_port_settings_macaddr(struct rocker_port
*rocker_port
,
1394 unsigned char *macaddr
)
1396 return rocker_cmd_exec(rocker_port
, false,
1397 rocker_cmd_set_port_settings_macaddr_prep
,
1398 macaddr
, NULL
, NULL
);
1401 static int rocker_cmd_set_port_settings_mtu(struct rocker_port
*rocker_port
,
1404 return rocker_cmd_exec(rocker_port
, false,
1405 rocker_cmd_set_port_settings_mtu_prep
,
1409 int rocker_port_set_learning(struct rocker_port
*rocker_port
,
1412 return rocker_cmd_exec(rocker_port
, false,
1413 rocker_cmd_set_port_learning_prep
,
1414 &learning
, NULL
, NULL
);
1417 /**********************
1418 * Worlds manipulation
1419 **********************/
1421 static struct rocker_world_ops
*rocker_world_ops
[] = {
1425 #define ROCKER_WORLD_OPS_LEN ARRAY_SIZE(rocker_world_ops)
1427 static struct rocker_world_ops
*rocker_world_ops_find(u8 mode
)
1431 for (i
= 0; i
< ROCKER_WORLD_OPS_LEN
; i
++)
1432 if (rocker_world_ops
[i
]->mode
== mode
)
1433 return rocker_world_ops
[i
];
1437 static int rocker_world_init(struct rocker
*rocker
, u8 mode
)
1439 struct rocker_world_ops
*wops
;
1442 wops
= rocker_world_ops_find(mode
);
1444 dev_err(&rocker
->pdev
->dev
, "port mode \"%d\" is not supported\n",
1448 rocker
->wops
= wops
;
1449 rocker
->wpriv
= kzalloc(wops
->priv_size
, GFP_KERNEL
);
1454 err
= wops
->init(rocker
);
1456 kfree(rocker
->wpriv
);
1460 static void rocker_world_fini(struct rocker
*rocker
)
1462 struct rocker_world_ops
*wops
= rocker
->wops
;
1464 if (!wops
|| !wops
->fini
)
1467 kfree(rocker
->wpriv
);
1470 static int rocker_world_check_init(struct rocker_port
*rocker_port
)
1472 struct rocker
*rocker
= rocker_port
->rocker
;
1476 err
= rocker_cmd_get_port_settings_mode(rocker_port
, &mode
);
1478 dev_err(&rocker
->pdev
->dev
, "failed to get port mode\n");
1482 if (rocker
->wops
->mode
!= mode
) {
1483 dev_err(&rocker
->pdev
->dev
, "hardware has ports in different worlds, which is not supported\n");
1488 return rocker_world_init(rocker
, mode
);
1491 static int rocker_world_port_pre_init(struct rocker_port
*rocker_port
)
1493 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1496 rocker_port
->wpriv
= kzalloc(wops
->port_priv_size
, GFP_KERNEL
);
1497 if (!rocker_port
->wpriv
)
1499 if (!wops
->port_pre_init
)
1501 err
= wops
->port_pre_init(rocker_port
);
1503 kfree(rocker_port
->wpriv
);
1507 static int rocker_world_port_init(struct rocker_port
*rocker_port
)
1509 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1511 if (!wops
->port_init
)
1513 return wops
->port_init(rocker_port
);
1516 static void rocker_world_port_fini(struct rocker_port
*rocker_port
)
1518 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1520 if (!wops
->port_fini
)
1522 wops
->port_fini(rocker_port
);
1525 static void rocker_world_port_post_fini(struct rocker_port
*rocker_port
)
1527 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1529 if (!wops
->port_post_fini
)
1531 wops
->port_post_fini(rocker_port
);
1532 kfree(rocker_port
->wpriv
);
1535 static int rocker_world_port_open(struct rocker_port
*rocker_port
)
1537 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1539 if (!wops
->port_open
)
1541 return wops
->port_open(rocker_port
);
1544 static void rocker_world_port_stop(struct rocker_port
*rocker_port
)
1546 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1548 if (!wops
->port_stop
)
1550 wops
->port_stop(rocker_port
);
1553 static int rocker_world_port_attr_stp_state_set(struct rocker_port
*rocker_port
,
1555 struct switchdev_trans
*trans
)
1557 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1559 if (!wops
->port_attr_stp_state_set
)
1562 if (switchdev_trans_ph_prepare(trans
))
1565 return wops
->port_attr_stp_state_set(rocker_port
, state
);
1569 rocker_world_port_attr_bridge_flags_set(struct rocker_port
*rocker_port
,
1570 unsigned long brport_flags
,
1571 struct switchdev_trans
*trans
)
1573 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1575 if (!wops
->port_attr_bridge_flags_set
)
1578 if (switchdev_trans_ph_prepare(trans
))
1581 return wops
->port_attr_bridge_flags_set(rocker_port
, brport_flags
,
1586 rocker_world_port_attr_bridge_flags_get(const struct rocker_port
*rocker_port
,
1587 unsigned long *p_brport_flags
)
1589 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1591 if (!wops
->port_attr_bridge_flags_get
)
1593 return wops
->port_attr_bridge_flags_get(rocker_port
, p_brport_flags
);
1597 rocker_world_port_attr_bridge_flags_support_get(const struct rocker_port
*
1600 p_brport_flags_support
)
1602 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1604 if (!wops
->port_attr_bridge_flags_support_get
)
1606 return wops
->port_attr_bridge_flags_support_get(rocker_port
,
1607 p_brport_flags_support
);
1611 rocker_world_port_attr_bridge_ageing_time_set(struct rocker_port
*rocker_port
,
1613 struct switchdev_trans
*trans
)
1616 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1618 if (!wops
->port_attr_bridge_ageing_time_set
)
1621 if (switchdev_trans_ph_prepare(trans
))
1624 return wops
->port_attr_bridge_ageing_time_set(rocker_port
, ageing_time
,
1629 rocker_world_port_obj_vlan_add(struct rocker_port
*rocker_port
,
1630 const struct switchdev_obj_port_vlan
*vlan
,
1631 struct switchdev_trans
*trans
)
1633 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1635 if (!wops
->port_obj_vlan_add
)
1638 if (switchdev_trans_ph_prepare(trans
))
1641 return wops
->port_obj_vlan_add(rocker_port
, vlan
);
1645 rocker_world_port_obj_vlan_del(struct rocker_port
*rocker_port
,
1646 const struct switchdev_obj_port_vlan
*vlan
)
1648 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1650 if (netif_is_bridge_master(vlan
->obj
.orig_dev
))
1653 if (!wops
->port_obj_vlan_del
)
1655 return wops
->port_obj_vlan_del(rocker_port
, vlan
);
1659 rocker_world_port_fdb_add(struct rocker_port
*rocker_port
,
1660 struct switchdev_notifier_fdb_info
*info
)
1662 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1664 if (!wops
->port_obj_fdb_add
)
1667 return wops
->port_obj_fdb_add(rocker_port
, info
->vid
, info
->addr
);
1671 rocker_world_port_fdb_del(struct rocker_port
*rocker_port
,
1672 struct switchdev_notifier_fdb_info
*info
)
1674 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1676 if (!wops
->port_obj_fdb_del
)
1678 return wops
->port_obj_fdb_del(rocker_port
, info
->vid
, info
->addr
);
1681 static int rocker_world_port_master_linked(struct rocker_port
*rocker_port
,
1682 struct net_device
*master
)
1684 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1686 if (!wops
->port_master_linked
)
1688 return wops
->port_master_linked(rocker_port
, master
);
1691 static int rocker_world_port_master_unlinked(struct rocker_port
*rocker_port
,
1692 struct net_device
*master
)
1694 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1696 if (!wops
->port_master_unlinked
)
1698 return wops
->port_master_unlinked(rocker_port
, master
);
1701 static int rocker_world_port_neigh_update(struct rocker_port
*rocker_port
,
1702 struct neighbour
*n
)
1704 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1706 if (!wops
->port_neigh_update
)
1708 return wops
->port_neigh_update(rocker_port
, n
);
1711 static int rocker_world_port_neigh_destroy(struct rocker_port
*rocker_port
,
1712 struct neighbour
*n
)
1714 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1716 if (!wops
->port_neigh_destroy
)
1718 return wops
->port_neigh_destroy(rocker_port
, n
);
1721 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port
*rocker_port
,
1722 const unsigned char *addr
,
1725 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1727 if (!wops
->port_ev_mac_vlan_seen
)
1729 return wops
->port_ev_mac_vlan_seen(rocker_port
, addr
, vlan_id
);
1732 static int rocker_world_fib4_add(struct rocker
*rocker
,
1733 const struct fib_entry_notifier_info
*fen_info
)
1735 struct rocker_world_ops
*wops
= rocker
->wops
;
1737 if (!wops
->fib4_add
)
1739 return wops
->fib4_add(rocker
, fen_info
);
1742 static int rocker_world_fib4_del(struct rocker
*rocker
,
1743 const struct fib_entry_notifier_info
*fen_info
)
1745 struct rocker_world_ops
*wops
= rocker
->wops
;
1747 if (!wops
->fib4_del
)
1749 return wops
->fib4_del(rocker
, fen_info
);
1752 static void rocker_world_fib4_abort(struct rocker
*rocker
)
1754 struct rocker_world_ops
*wops
= rocker
->wops
;
1756 if (wops
->fib4_abort
)
1757 wops
->fib4_abort(rocker
);
1764 static int rocker_port_open(struct net_device
*dev
)
1766 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1769 err
= rocker_port_dma_rings_init(rocker_port
);
1773 err
= request_irq(rocker_msix_tx_vector(rocker_port
),
1774 rocker_tx_irq_handler
, 0,
1775 rocker_driver_name
, rocker_port
);
1777 netdev_err(rocker_port
->dev
, "cannot assign tx irq\n");
1778 goto err_request_tx_irq
;
1781 err
= request_irq(rocker_msix_rx_vector(rocker_port
),
1782 rocker_rx_irq_handler
, 0,
1783 rocker_driver_name
, rocker_port
);
1785 netdev_err(rocker_port
->dev
, "cannot assign rx irq\n");
1786 goto err_request_rx_irq
;
1789 err
= rocker_world_port_open(rocker_port
);
1791 netdev_err(rocker_port
->dev
, "cannot open port in world\n");
1792 goto err_world_port_open
;
1795 napi_enable(&rocker_port
->napi_tx
);
1796 napi_enable(&rocker_port
->napi_rx
);
1797 if (!dev
->proto_down
)
1798 rocker_port_set_enable(rocker_port
, true);
1799 netif_start_queue(dev
);
1802 err_world_port_open
:
1803 free_irq(rocker_msix_rx_vector(rocker_port
), rocker_port
);
1805 free_irq(rocker_msix_tx_vector(rocker_port
), rocker_port
);
1807 rocker_port_dma_rings_fini(rocker_port
);
1811 static int rocker_port_stop(struct net_device
*dev
)
1813 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1815 netif_stop_queue(dev
);
1816 rocker_port_set_enable(rocker_port
, false);
1817 napi_disable(&rocker_port
->napi_rx
);
1818 napi_disable(&rocker_port
->napi_tx
);
1819 rocker_world_port_stop(rocker_port
);
1820 free_irq(rocker_msix_rx_vector(rocker_port
), rocker_port
);
1821 free_irq(rocker_msix_tx_vector(rocker_port
), rocker_port
);
1822 rocker_port_dma_rings_fini(rocker_port
);
1827 static void rocker_tx_desc_frags_unmap(const struct rocker_port
*rocker_port
,
1828 const struct rocker_desc_info
*desc_info
)
1830 const struct rocker
*rocker
= rocker_port
->rocker
;
1831 struct pci_dev
*pdev
= rocker
->pdev
;
1832 const struct rocker_tlv
*attrs
[ROCKER_TLV_TX_MAX
+ 1];
1833 struct rocker_tlv
*attr
;
1836 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_TX_MAX
, desc_info
);
1837 if (!attrs
[ROCKER_TLV_TX_FRAGS
])
1839 rocker_tlv_for_each_nested(attr
, attrs
[ROCKER_TLV_TX_FRAGS
], rem
) {
1840 const struct rocker_tlv
*frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_MAX
+ 1];
1841 dma_addr_t dma_handle
;
1844 if (rocker_tlv_type(attr
) != ROCKER_TLV_TX_FRAG
)
1846 rocker_tlv_parse_nested(frag_attrs
, ROCKER_TLV_TX_FRAG_ATTR_MAX
,
1848 if (!frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_ADDR
] ||
1849 !frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_LEN
])
1851 dma_handle
= rocker_tlv_get_u64(frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_ADDR
]);
1852 len
= rocker_tlv_get_u16(frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_LEN
]);
1853 pci_unmap_single(pdev
, dma_handle
, len
, DMA_TO_DEVICE
);
1857 static int rocker_tx_desc_frag_map_put(const struct rocker_port
*rocker_port
,
1858 struct rocker_desc_info
*desc_info
,
1859 char *buf
, size_t buf_len
)
1861 const struct rocker
*rocker
= rocker_port
->rocker
;
1862 struct pci_dev
*pdev
= rocker
->pdev
;
1863 dma_addr_t dma_handle
;
1864 struct rocker_tlv
*frag
;
1866 dma_handle
= pci_map_single(pdev
, buf
, buf_len
, DMA_TO_DEVICE
);
1867 if (unlikely(pci_dma_mapping_error(pdev
, dma_handle
))) {
1868 if (net_ratelimit())
1869 netdev_err(rocker_port
->dev
, "failed to dma map tx frag\n");
1872 frag
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_TX_FRAG
);
1875 if (rocker_tlv_put_u64(desc_info
, ROCKER_TLV_TX_FRAG_ATTR_ADDR
,
1878 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_TX_FRAG_ATTR_LEN
,
1881 rocker_tlv_nest_end(desc_info
, frag
);
1885 rocker_tlv_nest_cancel(desc_info
, frag
);
1887 pci_unmap_single(pdev
, dma_handle
, buf_len
, DMA_TO_DEVICE
);
1891 static netdev_tx_t
rocker_port_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1893 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1894 struct rocker
*rocker
= rocker_port
->rocker
;
1895 struct rocker_desc_info
*desc_info
;
1896 struct rocker_tlv
*frags
;
1900 desc_info
= rocker_desc_head_get(&rocker_port
->tx_ring
);
1901 if (unlikely(!desc_info
)) {
1902 if (net_ratelimit())
1903 netdev_err(dev
, "tx ring full when queue awake\n");
1904 return NETDEV_TX_BUSY
;
1907 rocker_desc_cookie_ptr_set(desc_info
, skb
);
1909 frags
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_TX_FRAGS
);
1912 err
= rocker_tx_desc_frag_map_put(rocker_port
, desc_info
,
1913 skb
->data
, skb_headlen(skb
));
1916 if (skb_shinfo(skb
)->nr_frags
> ROCKER_TX_FRAGS_MAX
) {
1917 err
= skb_linearize(skb
);
1922 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1923 const skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
1925 err
= rocker_tx_desc_frag_map_put(rocker_port
, desc_info
,
1926 skb_frag_address(frag
),
1927 skb_frag_size(frag
));
1931 rocker_tlv_nest_end(desc_info
, frags
);
1933 rocker_desc_gen_clear(desc_info
);
1934 rocker_desc_head_set(rocker
, &rocker_port
->tx_ring
, desc_info
);
1936 desc_info
= rocker_desc_head_get(&rocker_port
->tx_ring
);
1938 netif_stop_queue(dev
);
1940 return NETDEV_TX_OK
;
1943 rocker_tx_desc_frags_unmap(rocker_port
, desc_info
);
1945 rocker_tlv_nest_cancel(desc_info
, frags
);
1948 dev
->stats
.tx_dropped
++;
1950 return NETDEV_TX_OK
;
1953 static int rocker_port_set_mac_address(struct net_device
*dev
, void *p
)
1955 struct sockaddr
*addr
= p
;
1956 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1959 if (!is_valid_ether_addr(addr
->sa_data
))
1960 return -EADDRNOTAVAIL
;
1962 err
= rocker_cmd_set_port_settings_macaddr(rocker_port
, addr
->sa_data
);
1965 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1969 static int rocker_port_change_mtu(struct net_device
*dev
, int new_mtu
)
1971 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1972 int running
= netif_running(dev
);
1976 rocker_port_stop(dev
);
1978 netdev_info(dev
, "MTU change from %d to %d\n", dev
->mtu
, new_mtu
);
1981 err
= rocker_cmd_set_port_settings_mtu(rocker_port
, new_mtu
);
1986 err
= rocker_port_open(dev
);
1991 static int rocker_port_get_phys_port_name(struct net_device
*dev
,
1992 char *buf
, size_t len
)
1994 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1995 struct port_name name
= { .buf
= buf
, .len
= len
};
1998 err
= rocker_cmd_exec(rocker_port
, false,
1999 rocker_cmd_get_port_settings_prep
, NULL
,
2000 rocker_cmd_get_port_settings_phys_name_proc
,
2003 return err
? -EOPNOTSUPP
: 0;
2006 static int rocker_port_change_proto_down(struct net_device
*dev
,
2009 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2011 if (rocker_port
->dev
->flags
& IFF_UP
)
2012 rocker_port_set_enable(rocker_port
, !proto_down
);
2013 rocker_port
->dev
->proto_down
= proto_down
;
2017 static void rocker_port_neigh_destroy(struct net_device
*dev
,
2018 struct neighbour
*n
)
2020 struct rocker_port
*rocker_port
= netdev_priv(n
->dev
);
2023 err
= rocker_world_port_neigh_destroy(rocker_port
, n
);
2025 netdev_warn(rocker_port
->dev
, "failed to handle neigh destroy (err %d)\n",
2029 static const struct net_device_ops rocker_port_netdev_ops
= {
2030 .ndo_open
= rocker_port_open
,
2031 .ndo_stop
= rocker_port_stop
,
2032 .ndo_start_xmit
= rocker_port_xmit
,
2033 .ndo_set_mac_address
= rocker_port_set_mac_address
,
2034 .ndo_change_mtu
= rocker_port_change_mtu
,
2035 .ndo_get_phys_port_name
= rocker_port_get_phys_port_name
,
2036 .ndo_change_proto_down
= rocker_port_change_proto_down
,
2037 .ndo_neigh_destroy
= rocker_port_neigh_destroy
,
2040 /********************
2042 ********************/
2044 static int rocker_port_attr_get(struct net_device
*dev
,
2045 struct switchdev_attr
*attr
)
2047 const struct rocker_port
*rocker_port
= netdev_priv(dev
);
2048 const struct rocker
*rocker
= rocker_port
->rocker
;
2052 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID
:
2053 attr
->u
.ppid
.id_len
= sizeof(rocker
->hw
.id
);
2054 memcpy(&attr
->u
.ppid
.id
, &rocker
->hw
.id
, attr
->u
.ppid
.id_len
);
2056 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
2057 err
= rocker_world_port_attr_bridge_flags_get(rocker_port
,
2058 &attr
->u
.brport_flags
);
2060 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT
:
2061 err
= rocker_world_port_attr_bridge_flags_support_get(rocker_port
,
2062 &attr
->u
.brport_flags_support
);
2071 static int rocker_port_attr_set(struct net_device
*dev
,
2072 const struct switchdev_attr
*attr
,
2073 struct switchdev_trans
*trans
)
2075 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2079 case SWITCHDEV_ATTR_ID_PORT_STP_STATE
:
2080 err
= rocker_world_port_attr_stp_state_set(rocker_port
,
2084 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
2085 err
= rocker_world_port_attr_bridge_flags_set(rocker_port
,
2086 attr
->u
.brport_flags
,
2089 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME
:
2090 err
= rocker_world_port_attr_bridge_ageing_time_set(rocker_port
,
2091 attr
->u
.ageing_time
,
2102 static int rocker_port_obj_add(struct net_device
*dev
,
2103 const struct switchdev_obj
*obj
,
2104 struct switchdev_trans
*trans
)
2106 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2110 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
2111 err
= rocker_world_port_obj_vlan_add(rocker_port
,
2112 SWITCHDEV_OBJ_PORT_VLAN(obj
),
2123 static int rocker_port_obj_del(struct net_device
*dev
,
2124 const struct switchdev_obj
*obj
)
2126 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2130 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
2131 err
= rocker_world_port_obj_vlan_del(rocker_port
,
2132 SWITCHDEV_OBJ_PORT_VLAN(obj
));
2142 static const struct switchdev_ops rocker_port_switchdev_ops
= {
2143 .switchdev_port_attr_get
= rocker_port_attr_get
,
2144 .switchdev_port_attr_set
= rocker_port_attr_set
,
2147 struct rocker_fib_event_work
{
2148 struct work_struct work
;
2150 struct fib_entry_notifier_info fen_info
;
2151 struct fib_rule_notifier_info fr_info
;
2153 struct rocker
*rocker
;
2154 unsigned long event
;
2157 static void rocker_router_fib_event_work(struct work_struct
*work
)
2159 struct rocker_fib_event_work
*fib_work
=
2160 container_of(work
, struct rocker_fib_event_work
, work
);
2161 struct rocker
*rocker
= fib_work
->rocker
;
2162 struct fib_rule
*rule
;
2165 /* Protect internal structures from changes */
2167 switch (fib_work
->event
) {
2168 case FIB_EVENT_ENTRY_ADD
:
2169 err
= rocker_world_fib4_add(rocker
, &fib_work
->fen_info
);
2171 rocker_world_fib4_abort(rocker
);
2172 fib_info_put(fib_work
->fen_info
.fi
);
2174 case FIB_EVENT_ENTRY_DEL
:
2175 rocker_world_fib4_del(rocker
, &fib_work
->fen_info
);
2176 fib_info_put(fib_work
->fen_info
.fi
);
2178 case FIB_EVENT_RULE_ADD
: /* fall through */
2179 case FIB_EVENT_RULE_DEL
:
2180 rule
= fib_work
->fr_info
.rule
;
2181 if (!fib4_rule_default(rule
))
2182 rocker_world_fib4_abort(rocker
);
2190 /* Called with rcu_read_lock() */
2191 static int rocker_router_fib_event(struct notifier_block
*nb
,
2192 unsigned long event
, void *ptr
)
2194 struct rocker
*rocker
= container_of(nb
, struct rocker
, fib_nb
);
2195 struct rocker_fib_event_work
*fib_work
;
2196 struct fib_notifier_info
*info
= ptr
;
2198 if (info
->family
!= AF_INET
)
2201 fib_work
= kzalloc(sizeof(*fib_work
), GFP_ATOMIC
);
2202 if (WARN_ON(!fib_work
))
2205 INIT_WORK(&fib_work
->work
, rocker_router_fib_event_work
);
2206 fib_work
->rocker
= rocker
;
2207 fib_work
->event
= event
;
2210 case FIB_EVENT_ENTRY_ADD
: /* fall through */
2211 case FIB_EVENT_ENTRY_DEL
:
2212 memcpy(&fib_work
->fen_info
, ptr
, sizeof(fib_work
->fen_info
));
2213 /* Take referece on fib_info to prevent it from being
2214 * freed while work is queued. Release it afterwards.
2216 fib_info_hold(fib_work
->fen_info
.fi
);
2218 case FIB_EVENT_RULE_ADD
: /* fall through */
2219 case FIB_EVENT_RULE_DEL
:
2220 memcpy(&fib_work
->fr_info
, ptr
, sizeof(fib_work
->fr_info
));
2221 fib_rule_get(fib_work
->fr_info
.rule
);
2225 queue_work(rocker
->rocker_owq
, &fib_work
->work
);
2230 /********************
2232 ********************/
2235 rocker_port_get_link_ksettings(struct net_device
*dev
,
2236 struct ethtool_link_ksettings
*ecmd
)
2238 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2240 return rocker_cmd_get_port_settings_ethtool(rocker_port
, ecmd
);
2244 rocker_port_set_link_ksettings(struct net_device
*dev
,
2245 const struct ethtool_link_ksettings
*ecmd
)
2247 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2249 return rocker_cmd_set_port_settings_ethtool(rocker_port
, ecmd
);
2252 static void rocker_port_get_drvinfo(struct net_device
*dev
,
2253 struct ethtool_drvinfo
*drvinfo
)
2255 strlcpy(drvinfo
->driver
, rocker_driver_name
, sizeof(drvinfo
->driver
));
2256 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
2259 static struct rocker_port_stats
{
2260 char str
[ETH_GSTRING_LEN
];
2262 } rocker_port_stats
[] = {
2263 { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS
, },
2264 { "rx_bytes", ROCKER_TLV_CMD_PORT_STATS_RX_BYTES
, },
2265 { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED
, },
2266 { "rx_errors", ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS
, },
2268 { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS
, },
2269 { "tx_bytes", ROCKER_TLV_CMD_PORT_STATS_TX_BYTES
, },
2270 { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED
, },
2271 { "tx_errors", ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS
, },
2274 #define ROCKER_PORT_STATS_LEN ARRAY_SIZE(rocker_port_stats)
2276 static void rocker_port_get_strings(struct net_device
*netdev
, u32 stringset
,
2282 switch (stringset
) {
2284 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); i
++) {
2285 memcpy(p
, rocker_port_stats
[i
].str
, ETH_GSTRING_LEN
);
2286 p
+= ETH_GSTRING_LEN
;
2293 rocker_cmd_get_port_stats_prep(const struct rocker_port
*rocker_port
,
2294 struct rocker_desc_info
*desc_info
,
2297 struct rocker_tlv
*cmd_stats
;
2299 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
2300 ROCKER_TLV_CMD_TYPE_GET_PORT_STATS
))
2303 cmd_stats
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
2307 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_STATS_PPORT
,
2308 rocker_port
->pport
))
2311 rocker_tlv_nest_end(desc_info
, cmd_stats
);
2317 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port
*rocker_port
,
2318 const struct rocker_desc_info
*desc_info
,
2321 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
2322 const struct rocker_tlv
*stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_MAX
+ 1];
2323 const struct rocker_tlv
*pattr
;
2328 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
2330 if (!attrs
[ROCKER_TLV_CMD_INFO
])
2333 rocker_tlv_parse_nested(stats_attrs
, ROCKER_TLV_CMD_PORT_STATS_MAX
,
2334 attrs
[ROCKER_TLV_CMD_INFO
]);
2336 if (!stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_PPORT
])
2339 pport
= rocker_tlv_get_u32(stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_PPORT
]);
2340 if (pport
!= rocker_port
->pport
)
2343 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); i
++) {
2344 pattr
= stats_attrs
[rocker_port_stats
[i
].type
];
2348 data
[i
] = rocker_tlv_get_u64(pattr
);
2354 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port
*rocker_port
,
2357 return rocker_cmd_exec(rocker_port
, false,
2358 rocker_cmd_get_port_stats_prep
, NULL
,
2359 rocker_cmd_get_port_stats_ethtool_proc
,
2363 static void rocker_port_get_stats(struct net_device
*dev
,
2364 struct ethtool_stats
*stats
, u64
*data
)
2366 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2368 if (rocker_cmd_get_port_stats_ethtool(rocker_port
, data
) != 0) {
2371 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); ++i
)
2376 static int rocker_port_get_sset_count(struct net_device
*netdev
, int sset
)
2380 return ROCKER_PORT_STATS_LEN
;
2386 static const struct ethtool_ops rocker_port_ethtool_ops
= {
2387 .get_drvinfo
= rocker_port_get_drvinfo
,
2388 .get_link
= ethtool_op_get_link
,
2389 .get_strings
= rocker_port_get_strings
,
2390 .get_ethtool_stats
= rocker_port_get_stats
,
2391 .get_sset_count
= rocker_port_get_sset_count
,
2392 .get_link_ksettings
= rocker_port_get_link_ksettings
,
2393 .set_link_ksettings
= rocker_port_set_link_ksettings
,
2400 static struct rocker_port
*rocker_port_napi_tx_get(struct napi_struct
*napi
)
2402 return container_of(napi
, struct rocker_port
, napi_tx
);
2405 static int rocker_port_poll_tx(struct napi_struct
*napi
, int budget
)
2407 struct rocker_port
*rocker_port
= rocker_port_napi_tx_get(napi
);
2408 const struct rocker
*rocker
= rocker_port
->rocker
;
2409 const struct rocker_desc_info
*desc_info
;
2413 /* Cleanup tx descriptors */
2414 while ((desc_info
= rocker_desc_tail_get(&rocker_port
->tx_ring
))) {
2415 struct sk_buff
*skb
;
2417 err
= rocker_desc_err(desc_info
);
2418 if (err
&& net_ratelimit())
2419 netdev_err(rocker_port
->dev
, "tx desc received with err %d\n",
2421 rocker_tx_desc_frags_unmap(rocker_port
, desc_info
);
2423 skb
= rocker_desc_cookie_ptr_get(desc_info
);
2425 rocker_port
->dev
->stats
.tx_packets
++;
2426 rocker_port
->dev
->stats
.tx_bytes
+= skb
->len
;
2428 rocker_port
->dev
->stats
.tx_errors
++;
2431 dev_kfree_skb_any(skb
);
2435 if (credits
&& netif_queue_stopped(rocker_port
->dev
))
2436 netif_wake_queue(rocker_port
->dev
);
2438 napi_complete(napi
);
2439 rocker_dma_ring_credits_set(rocker
, &rocker_port
->tx_ring
, credits
);
2444 static int rocker_port_rx_proc(const struct rocker
*rocker
,
2445 const struct rocker_port
*rocker_port
,
2446 struct rocker_desc_info
*desc_info
)
2448 const struct rocker_tlv
*attrs
[ROCKER_TLV_RX_MAX
+ 1];
2449 struct sk_buff
*skb
= rocker_desc_cookie_ptr_get(desc_info
);
2456 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_RX_MAX
, desc_info
);
2457 if (!attrs
[ROCKER_TLV_RX_FRAG_LEN
])
2459 if (attrs
[ROCKER_TLV_RX_FLAGS
])
2460 rx_flags
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FLAGS
]);
2462 rocker_dma_rx_ring_skb_unmap(rocker
, attrs
);
2464 rx_len
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FRAG_LEN
]);
2465 skb_put(skb
, rx_len
);
2466 skb
->protocol
= eth_type_trans(skb
, rocker_port
->dev
);
2468 if (rx_flags
& ROCKER_RX_FLAGS_FWD_OFFLOAD
)
2469 skb
->offload_fwd_mark
= 1;
2471 rocker_port
->dev
->stats
.rx_packets
++;
2472 rocker_port
->dev
->stats
.rx_bytes
+= skb
->len
;
2474 netif_receive_skb(skb
);
2476 return rocker_dma_rx_ring_skb_alloc(rocker_port
, desc_info
);
2479 static struct rocker_port
*rocker_port_napi_rx_get(struct napi_struct
*napi
)
2481 return container_of(napi
, struct rocker_port
, napi_rx
);
2484 static int rocker_port_poll_rx(struct napi_struct
*napi
, int budget
)
2486 struct rocker_port
*rocker_port
= rocker_port_napi_rx_get(napi
);
2487 const struct rocker
*rocker
= rocker_port
->rocker
;
2488 struct rocker_desc_info
*desc_info
;
2492 /* Process rx descriptors */
2493 while (credits
< budget
&&
2494 (desc_info
= rocker_desc_tail_get(&rocker_port
->rx_ring
))) {
2495 err
= rocker_desc_err(desc_info
);
2497 if (net_ratelimit())
2498 netdev_err(rocker_port
->dev
, "rx desc received with err %d\n",
2501 err
= rocker_port_rx_proc(rocker
, rocker_port
,
2503 if (err
&& net_ratelimit())
2504 netdev_err(rocker_port
->dev
, "rx processing failed with err %d\n",
2508 rocker_port
->dev
->stats
.rx_errors
++;
2510 rocker_desc_gen_clear(desc_info
);
2511 rocker_desc_head_set(rocker
, &rocker_port
->rx_ring
, desc_info
);
2515 if (credits
< budget
)
2516 napi_complete_done(napi
, credits
);
2518 rocker_dma_ring_credits_set(rocker
, &rocker_port
->rx_ring
, credits
);
2527 static void rocker_carrier_init(const struct rocker_port
*rocker_port
)
2529 const struct rocker
*rocker
= rocker_port
->rocker
;
2530 u64 link_status
= rocker_read64(rocker
, PORT_PHYS_LINK_STATUS
);
2533 link_up
= link_status
& (1 << rocker_port
->pport
);
2535 netif_carrier_on(rocker_port
->dev
);
2537 netif_carrier_off(rocker_port
->dev
);
2540 static void rocker_remove_ports(struct rocker
*rocker
)
2542 struct rocker_port
*rocker_port
;
2545 for (i
= 0; i
< rocker
->port_count
; i
++) {
2546 rocker_port
= rocker
->ports
[i
];
2549 rocker_world_port_fini(rocker_port
);
2550 unregister_netdev(rocker_port
->dev
);
2551 rocker_world_port_post_fini(rocker_port
);
2552 free_netdev(rocker_port
->dev
);
2554 rocker_world_fini(rocker
);
2555 kfree(rocker
->ports
);
2558 static void rocker_port_dev_addr_init(struct rocker_port
*rocker_port
)
2560 const struct rocker
*rocker
= rocker_port
->rocker
;
2561 const struct pci_dev
*pdev
= rocker
->pdev
;
2564 err
= rocker_cmd_get_port_settings_macaddr(rocker_port
,
2565 rocker_port
->dev
->dev_addr
);
2567 dev_warn(&pdev
->dev
, "failed to get mac address, using random\n");
2568 eth_hw_addr_random(rocker_port
->dev
);
2572 #define ROCKER_PORT_MIN_MTU ETH_MIN_MTU
2573 #define ROCKER_PORT_MAX_MTU 9000
2574 static int rocker_probe_port(struct rocker
*rocker
, unsigned int port_number
)
2576 struct pci_dev
*pdev
= rocker
->pdev
;
2577 struct rocker_port
*rocker_port
;
2578 struct net_device
*dev
;
2581 dev
= alloc_etherdev(sizeof(struct rocker_port
));
2584 SET_NETDEV_DEV(dev
, &pdev
->dev
);
2585 rocker_port
= netdev_priv(dev
);
2586 rocker_port
->dev
= dev
;
2587 rocker_port
->rocker
= rocker
;
2588 rocker_port
->port_number
= port_number
;
2589 rocker_port
->pport
= port_number
+ 1;
2591 err
= rocker_world_check_init(rocker_port
);
2593 dev_err(&pdev
->dev
, "world init failed\n");
2594 goto err_world_check_init
;
2597 rocker_port_dev_addr_init(rocker_port
);
2598 dev
->netdev_ops
= &rocker_port_netdev_ops
;
2599 dev
->ethtool_ops
= &rocker_port_ethtool_ops
;
2600 dev
->switchdev_ops
= &rocker_port_switchdev_ops
;
2601 netif_tx_napi_add(dev
, &rocker_port
->napi_tx
, rocker_port_poll_tx
,
2603 netif_napi_add(dev
, &rocker_port
->napi_rx
, rocker_port_poll_rx
,
2605 rocker_carrier_init(rocker_port
);
2607 dev
->features
|= NETIF_F_NETNS_LOCAL
| NETIF_F_SG
;
2609 /* MTU range: 68 - 9000 */
2610 dev
->min_mtu
= ROCKER_PORT_MIN_MTU
;
2611 dev
->max_mtu
= ROCKER_PORT_MAX_MTU
;
2613 err
= rocker_world_port_pre_init(rocker_port
);
2615 dev_err(&pdev
->dev
, "port world pre-init failed\n");
2616 goto err_world_port_pre_init
;
2618 err
= register_netdev(dev
);
2620 dev_err(&pdev
->dev
, "register_netdev failed\n");
2621 goto err_register_netdev
;
2623 rocker
->ports
[port_number
] = rocker_port
;
2625 err
= rocker_world_port_init(rocker_port
);
2627 dev_err(&pdev
->dev
, "port world init failed\n");
2628 goto err_world_port_init
;
2633 err_world_port_init
:
2634 rocker
->ports
[port_number
] = NULL
;
2635 unregister_netdev(dev
);
2636 err_register_netdev
:
2637 rocker_world_port_post_fini(rocker_port
);
2638 err_world_port_pre_init
:
2639 err_world_check_init
:
2644 static int rocker_probe_ports(struct rocker
*rocker
)
2650 alloc_size
= sizeof(struct rocker_port
*) * rocker
->port_count
;
2651 rocker
->ports
= kzalloc(alloc_size
, GFP_KERNEL
);
2654 for (i
= 0; i
< rocker
->port_count
; i
++) {
2655 err
= rocker_probe_port(rocker
, i
);
2662 rocker_remove_ports(rocker
);
2666 static int rocker_msix_init(struct rocker
*rocker
)
2668 struct pci_dev
*pdev
= rocker
->pdev
;
2673 msix_entries
= pci_msix_vec_count(pdev
);
2674 if (msix_entries
< 0)
2675 return msix_entries
;
2677 if (msix_entries
!= ROCKER_MSIX_VEC_COUNT(rocker
->port_count
))
2680 rocker
->msix_entries
= kmalloc_array(msix_entries
,
2681 sizeof(struct msix_entry
),
2683 if (!rocker
->msix_entries
)
2686 for (i
= 0; i
< msix_entries
; i
++)
2687 rocker
->msix_entries
[i
].entry
= i
;
2689 err
= pci_enable_msix_exact(pdev
, rocker
->msix_entries
, msix_entries
);
2691 goto err_enable_msix
;
2696 kfree(rocker
->msix_entries
);
2700 static void rocker_msix_fini(const struct rocker
*rocker
)
2702 pci_disable_msix(rocker
->pdev
);
2703 kfree(rocker
->msix_entries
);
2706 static bool rocker_port_dev_check(const struct net_device
*dev
)
2708 return dev
->netdev_ops
== &rocker_port_netdev_ops
;
2711 struct rocker_switchdev_event_work
{
2712 struct work_struct work
;
2713 struct switchdev_notifier_fdb_info fdb_info
;
2714 struct rocker_port
*rocker_port
;
2715 unsigned long event
;
2719 rocker_fdb_offload_notify(struct rocker_port
*rocker_port
,
2720 struct switchdev_notifier_fdb_info
*recv_info
)
2722 struct switchdev_notifier_fdb_info info
;
2724 info
.addr
= recv_info
->addr
;
2725 info
.vid
= recv_info
->vid
;
2726 info
.offloaded
= true;
2727 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED
,
2728 rocker_port
->dev
, &info
.info
);
2731 static void rocker_switchdev_event_work(struct work_struct
*work
)
2733 struct rocker_switchdev_event_work
*switchdev_work
=
2734 container_of(work
, struct rocker_switchdev_event_work
, work
);
2735 struct rocker_port
*rocker_port
= switchdev_work
->rocker_port
;
2736 struct switchdev_notifier_fdb_info
*fdb_info
;
2740 switch (switchdev_work
->event
) {
2741 case SWITCHDEV_FDB_ADD_TO_DEVICE
:
2742 fdb_info
= &switchdev_work
->fdb_info
;
2743 if (!fdb_info
->added_by_user
)
2745 err
= rocker_world_port_fdb_add(rocker_port
, fdb_info
);
2747 netdev_dbg(rocker_port
->dev
, "fdb add failed err=%d\n", err
);
2750 rocker_fdb_offload_notify(rocker_port
, fdb_info
);
2752 case SWITCHDEV_FDB_DEL_TO_DEVICE
:
2753 fdb_info
= &switchdev_work
->fdb_info
;
2754 if (!fdb_info
->added_by_user
)
2756 err
= rocker_world_port_fdb_del(rocker_port
, fdb_info
);
2758 netdev_dbg(rocker_port
->dev
, "fdb add failed err=%d\n", err
);
2763 kfree(switchdev_work
->fdb_info
.addr
);
2764 kfree(switchdev_work
);
2765 dev_put(rocker_port
->dev
);
2768 /* called under rcu_read_lock() */
2769 static int rocker_switchdev_event(struct notifier_block
*unused
,
2770 unsigned long event
, void *ptr
)
2772 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
2773 struct rocker_switchdev_event_work
*switchdev_work
;
2774 struct switchdev_notifier_fdb_info
*fdb_info
= ptr
;
2775 struct rocker_port
*rocker_port
;
2777 if (!rocker_port_dev_check(dev
))
2780 rocker_port
= netdev_priv(dev
);
2781 switchdev_work
= kzalloc(sizeof(*switchdev_work
), GFP_ATOMIC
);
2782 if (WARN_ON(!switchdev_work
))
2785 INIT_WORK(&switchdev_work
->work
, rocker_switchdev_event_work
);
2786 switchdev_work
->rocker_port
= rocker_port
;
2787 switchdev_work
->event
= event
;
2790 case SWITCHDEV_FDB_ADD_TO_DEVICE
: /* fall through */
2791 case SWITCHDEV_FDB_DEL_TO_DEVICE
:
2792 memcpy(&switchdev_work
->fdb_info
, ptr
,
2793 sizeof(switchdev_work
->fdb_info
));
2794 switchdev_work
->fdb_info
.addr
= kzalloc(ETH_ALEN
, GFP_ATOMIC
);
2795 ether_addr_copy((u8
*)switchdev_work
->fdb_info
.addr
,
2797 /* Take a reference on the rocker device */
2801 kfree(switchdev_work
);
2805 queue_work(rocker_port
->rocker
->rocker_owq
,
2806 &switchdev_work
->work
);
2811 rocker_switchdev_port_obj_event(unsigned long event
, struct net_device
*netdev
,
2812 struct switchdev_notifier_port_obj_info
*port_obj_info
)
2814 int err
= -EOPNOTSUPP
;
2817 case SWITCHDEV_PORT_OBJ_ADD
:
2818 err
= rocker_port_obj_add(netdev
, port_obj_info
->obj
,
2819 port_obj_info
->trans
);
2821 case SWITCHDEV_PORT_OBJ_DEL
:
2822 err
= rocker_port_obj_del(netdev
, port_obj_info
->obj
);
2826 port_obj_info
->handled
= true;
2827 return notifier_from_errno(err
);
2830 static int rocker_switchdev_blocking_event(struct notifier_block
*unused
,
2831 unsigned long event
, void *ptr
)
2833 struct net_device
*dev
= switchdev_notifier_info_to_dev(ptr
);
2835 if (!rocker_port_dev_check(dev
))
2839 case SWITCHDEV_PORT_OBJ_ADD
:
2840 case SWITCHDEV_PORT_OBJ_DEL
:
2841 return rocker_switchdev_port_obj_event(event
, dev
, ptr
);
2847 static struct notifier_block rocker_switchdev_notifier
= {
2848 .notifier_call
= rocker_switchdev_event
,
2851 static struct notifier_block rocker_switchdev_blocking_notifier
= {
2852 .notifier_call
= rocker_switchdev_blocking_event
,
2855 static int rocker_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
2857 struct notifier_block
*nb
;
2858 struct rocker
*rocker
;
2861 rocker
= kzalloc(sizeof(*rocker
), GFP_KERNEL
);
2865 err
= pci_enable_device(pdev
);
2867 dev_err(&pdev
->dev
, "pci_enable_device failed\n");
2868 goto err_pci_enable_device
;
2871 err
= pci_request_regions(pdev
, rocker_driver_name
);
2873 dev_err(&pdev
->dev
, "pci_request_regions failed\n");
2874 goto err_pci_request_regions
;
2877 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(64));
2879 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64));
2881 dev_err(&pdev
->dev
, "pci_set_consistent_dma_mask failed\n");
2882 goto err_pci_set_dma_mask
;
2885 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2887 dev_err(&pdev
->dev
, "pci_set_dma_mask failed\n");
2888 goto err_pci_set_dma_mask
;
2892 if (pci_resource_len(pdev
, 0) < ROCKER_PCI_BAR0_SIZE
) {
2893 dev_err(&pdev
->dev
, "invalid PCI region size\n");
2895 goto err_pci_resource_len_check
;
2898 rocker
->hw_addr
= ioremap(pci_resource_start(pdev
, 0),
2899 pci_resource_len(pdev
, 0));
2900 if (!rocker
->hw_addr
) {
2901 dev_err(&pdev
->dev
, "ioremap failed\n");
2905 pci_set_master(pdev
);
2907 rocker
->pdev
= pdev
;
2908 pci_set_drvdata(pdev
, rocker
);
2910 rocker
->port_count
= rocker_read32(rocker
, PORT_PHYS_COUNT
);
2912 err
= rocker_msix_init(rocker
);
2914 dev_err(&pdev
->dev
, "MSI-X init failed\n");
2918 err
= rocker_basic_hw_test(rocker
);
2920 dev_err(&pdev
->dev
, "basic hw test failed\n");
2921 goto err_basic_hw_test
;
2924 rocker_write32(rocker
, CONTROL
, ROCKER_CONTROL_RESET
);
2926 err
= rocker_dma_rings_init(rocker
);
2928 goto err_dma_rings_init
;
2930 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
),
2931 rocker_cmd_irq_handler
, 0,
2932 rocker_driver_name
, rocker
);
2934 dev_err(&pdev
->dev
, "cannot assign cmd irq\n");
2935 goto err_request_cmd_irq
;
2938 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
),
2939 rocker_event_irq_handler
, 0,
2940 rocker_driver_name
, rocker
);
2942 dev_err(&pdev
->dev
, "cannot assign event irq\n");
2943 goto err_request_event_irq
;
2946 rocker
->rocker_owq
= alloc_ordered_workqueue(rocker_driver_name
,
2948 if (!rocker
->rocker_owq
) {
2950 goto err_alloc_ordered_workqueue
;
2953 err
= rocker_probe_ports(rocker
);
2955 dev_err(&pdev
->dev
, "failed to probe ports\n");
2956 goto err_probe_ports
;
2959 /* Only FIBs pointing to our own netdevs are programmed into
2960 * the device, so no need to pass a callback.
2962 rocker
->fib_nb
.notifier_call
= rocker_router_fib_event
;
2963 err
= register_fib_notifier(&rocker
->fib_nb
, NULL
);
2965 goto err_register_fib_notifier
;
2967 err
= register_switchdev_notifier(&rocker_switchdev_notifier
);
2969 dev_err(&pdev
->dev
, "Failed to register switchdev notifier\n");
2970 goto err_register_switchdev_notifier
;
2973 nb
= &rocker_switchdev_blocking_notifier
;
2974 err
= register_switchdev_blocking_notifier(nb
);
2976 dev_err(&pdev
->dev
, "Failed to register switchdev blocking notifier\n");
2977 goto err_register_switchdev_blocking_notifier
;
2980 rocker
->hw
.id
= rocker_read64(rocker
, SWITCH_ID
);
2982 dev_info(&pdev
->dev
, "Rocker switch with id %*phN\n",
2983 (int)sizeof(rocker
->hw
.id
), &rocker
->hw
.id
);
2987 err_register_switchdev_blocking_notifier
:
2988 unregister_switchdev_notifier(&rocker_switchdev_notifier
);
2989 err_register_switchdev_notifier
:
2990 unregister_fib_notifier(&rocker
->fib_nb
);
2991 err_register_fib_notifier
:
2992 rocker_remove_ports(rocker
);
2994 destroy_workqueue(rocker
->rocker_owq
);
2995 err_alloc_ordered_workqueue
:
2996 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
), rocker
);
2997 err_request_event_irq
:
2998 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
), rocker
);
2999 err_request_cmd_irq
:
3000 rocker_dma_rings_fini(rocker
);
3003 rocker_msix_fini(rocker
);
3005 iounmap(rocker
->hw_addr
);
3007 err_pci_resource_len_check
:
3008 err_pci_set_dma_mask
:
3009 pci_release_regions(pdev
);
3010 err_pci_request_regions
:
3011 pci_disable_device(pdev
);
3012 err_pci_enable_device
:
3017 static void rocker_remove(struct pci_dev
*pdev
)
3019 struct rocker
*rocker
= pci_get_drvdata(pdev
);
3020 struct notifier_block
*nb
;
3022 nb
= &rocker_switchdev_blocking_notifier
;
3023 unregister_switchdev_blocking_notifier(nb
);
3025 unregister_switchdev_notifier(&rocker_switchdev_notifier
);
3026 unregister_fib_notifier(&rocker
->fib_nb
);
3027 rocker_remove_ports(rocker
);
3028 rocker_write32(rocker
, CONTROL
, ROCKER_CONTROL_RESET
);
3029 destroy_workqueue(rocker
->rocker_owq
);
3030 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
), rocker
);
3031 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
), rocker
);
3032 rocker_dma_rings_fini(rocker
);
3033 rocker_msix_fini(rocker
);
3034 iounmap(rocker
->hw_addr
);
3035 pci_release_regions(rocker
->pdev
);
3036 pci_disable_device(rocker
->pdev
);
3040 static struct pci_driver rocker_pci_driver
= {
3041 .name
= rocker_driver_name
,
3042 .id_table
= rocker_pci_id_table
,
3043 .probe
= rocker_probe
,
3044 .remove
= rocker_remove
,
3047 /************************************
3048 * Net device notifier event handler
3049 ************************************/
3051 static bool rocker_port_dev_check_under(const struct net_device
*dev
,
3052 struct rocker
*rocker
)
3054 struct rocker_port
*rocker_port
;
3056 if (!rocker_port_dev_check(dev
))
3059 rocker_port
= netdev_priv(dev
);
3060 if (rocker_port
->rocker
!= rocker
)
3066 struct rocker_walk_data
{
3067 struct rocker
*rocker
;
3068 struct rocker_port
*port
;
3071 static int rocker_lower_dev_walk(struct net_device
*lower_dev
, void *_data
)
3073 struct rocker_walk_data
*data
= _data
;
3076 if (rocker_port_dev_check_under(lower_dev
, data
->rocker
)) {
3077 data
->port
= netdev_priv(lower_dev
);
3084 struct rocker_port
*rocker_port_dev_lower_find(struct net_device
*dev
,
3085 struct rocker
*rocker
)
3087 struct rocker_walk_data data
;
3089 if (rocker_port_dev_check_under(dev
, rocker
))
3090 return netdev_priv(dev
);
3092 data
.rocker
= rocker
;
3094 netdev_walk_all_lower_dev(dev
, rocker_lower_dev_walk
, &data
);
3099 static int rocker_netdevice_event(struct notifier_block
*unused
,
3100 unsigned long event
, void *ptr
)
3102 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
3103 struct netdev_notifier_changeupper_info
*info
;
3104 struct rocker_port
*rocker_port
;
3107 if (!rocker_port_dev_check(dev
))
3111 case NETDEV_CHANGEUPPER
:
3115 rocker_port
= netdev_priv(dev
);
3116 if (info
->linking
) {
3117 err
= rocker_world_port_master_linked(rocker_port
,
3120 netdev_warn(dev
, "failed to reflect master linked (err %d)\n",
3123 err
= rocker_world_port_master_unlinked(rocker_port
,
3126 netdev_warn(dev
, "failed to reflect master unlinked (err %d)\n",
3134 static struct notifier_block rocker_netdevice_nb __read_mostly
= {
3135 .notifier_call
= rocker_netdevice_event
,
3138 /************************************
3139 * Net event notifier event handler
3140 ************************************/
3142 static int rocker_netevent_event(struct notifier_block
*unused
,
3143 unsigned long event
, void *ptr
)
3145 struct rocker_port
*rocker_port
;
3146 struct net_device
*dev
;
3147 struct neighbour
*n
= ptr
;
3151 case NETEVENT_NEIGH_UPDATE
:
3152 if (n
->tbl
!= &arp_tbl
)
3155 if (!rocker_port_dev_check(dev
))
3157 rocker_port
= netdev_priv(dev
);
3158 err
= rocker_world_port_neigh_update(rocker_port
, n
);
3160 netdev_warn(dev
, "failed to handle neigh update (err %d)\n",
3168 static struct notifier_block rocker_netevent_nb __read_mostly
= {
3169 .notifier_call
= rocker_netevent_event
,
3172 /***********************
3173 * Module init and exit
3174 ***********************/
3176 static int __init
rocker_module_init(void)
3180 register_netdevice_notifier(&rocker_netdevice_nb
);
3181 register_netevent_notifier(&rocker_netevent_nb
);
3182 err
= pci_register_driver(&rocker_pci_driver
);
3184 goto err_pci_register_driver
;
3187 err_pci_register_driver
:
3188 unregister_netevent_notifier(&rocker_netevent_nb
);
3189 unregister_netdevice_notifier(&rocker_netdevice_nb
);
3193 static void __exit
rocker_module_exit(void)
3195 unregister_netevent_notifier(&rocker_netevent_nb
);
3196 unregister_netdevice_notifier(&rocker_netdevice_nb
);
3197 pci_unregister_driver(&rocker_pci_driver
);
3200 module_init(rocker_module_init
);
3201 module_exit(rocker_module_exit
);
3203 MODULE_LICENSE("GPL v2");
3204 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
3205 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>");
3206 MODULE_DESCRIPTION("Rocker switch device driver");
3207 MODULE_DEVICE_TABLE(pci
, rocker_pci_id_table
);