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 <net/switchdev.h>
32 #include <net/rtnetlink.h>
33 #include <net/netevent.h>
35 #include <linux/io-64-nonatomic-lo-hi.h>
36 #include <generated/utsrelease.h>
38 #include "rocker_hw.h"
40 #include "rocker_tlv.h"
42 static const char rocker_driver_name
[] = "rocker";
44 static const struct pci_device_id rocker_pci_id_table
[] = {
45 {PCI_VDEVICE(REDHAT
, PCI_DEVICE_ID_REDHAT_ROCKER
), 0},
50 wait_queue_head_t wait
;
55 static void rocker_wait_reset(struct rocker_wait
*wait
)
61 static void rocker_wait_init(struct rocker_wait
*wait
)
63 init_waitqueue_head(&wait
->wait
);
64 rocker_wait_reset(wait
);
67 static struct rocker_wait
*rocker_wait_create(void)
69 struct rocker_wait
*wait
;
71 wait
= kzalloc(sizeof(*wait
), GFP_KERNEL
);
77 static void rocker_wait_destroy(struct rocker_wait
*wait
)
82 static bool rocker_wait_event_timeout(struct rocker_wait
*wait
,
83 unsigned long timeout
)
85 wait_event_timeout(wait
->wait
, wait
->done
, HZ
/ 10);
91 static void rocker_wait_wake_up(struct rocker_wait
*wait
)
97 static u32
rocker_msix_vector(const struct rocker
*rocker
, unsigned int vector
)
99 return rocker
->msix_entries
[vector
].vector
;
102 static u32
rocker_msix_tx_vector(const struct rocker_port
*rocker_port
)
104 return rocker_msix_vector(rocker_port
->rocker
,
105 ROCKER_MSIX_VEC_TX(rocker_port
->port_number
));
108 static u32
rocker_msix_rx_vector(const struct rocker_port
*rocker_port
)
110 return rocker_msix_vector(rocker_port
->rocker
,
111 ROCKER_MSIX_VEC_RX(rocker_port
->port_number
));
114 #define rocker_write32(rocker, reg, val) \
115 writel((val), (rocker)->hw_addr + (ROCKER_ ## reg))
116 #define rocker_read32(rocker, reg) \
117 readl((rocker)->hw_addr + (ROCKER_ ## reg))
118 #define rocker_write64(rocker, reg, val) \
119 writeq((val), (rocker)->hw_addr + (ROCKER_ ## reg))
120 #define rocker_read64(rocker, reg) \
121 readq((rocker)->hw_addr + (ROCKER_ ## reg))
123 /*****************************
124 * HW basic testing functions
125 *****************************/
127 static int rocker_reg_test(const struct rocker
*rocker
)
129 const struct pci_dev
*pdev
= rocker
->pdev
;
135 rocker_write32(rocker
, TEST_REG
, rnd
);
136 test_reg
= rocker_read32(rocker
, TEST_REG
);
137 if (test_reg
!= rnd
* 2) {
138 dev_err(&pdev
->dev
, "unexpected 32bit register value %08llx, expected %08llx\n",
145 rnd
|= prandom_u32();
146 rocker_write64(rocker
, TEST_REG64
, rnd
);
147 test_reg
= rocker_read64(rocker
, TEST_REG64
);
148 if (test_reg
!= rnd
* 2) {
149 dev_err(&pdev
->dev
, "unexpected 64bit register value %16llx, expected %16llx\n",
157 static int rocker_dma_test_one(const struct rocker
*rocker
,
158 struct rocker_wait
*wait
, u32 test_type
,
159 dma_addr_t dma_handle
, const unsigned char *buf
,
160 const unsigned char *expect
, size_t size
)
162 const struct pci_dev
*pdev
= rocker
->pdev
;
165 rocker_wait_reset(wait
);
166 rocker_write32(rocker
, TEST_DMA_CTRL
, test_type
);
168 if (!rocker_wait_event_timeout(wait
, HZ
/ 10)) {
169 dev_err(&pdev
->dev
, "no interrupt received within a timeout\n");
173 for (i
= 0; i
< size
; i
++) {
174 if (buf
[i
] != expect
[i
]) {
175 dev_err(&pdev
->dev
, "unexpected memory content %02x at byte %x\n, %02x expected",
176 buf
[i
], i
, expect
[i
]);
183 #define ROCKER_TEST_DMA_BUF_SIZE (PAGE_SIZE * 4)
184 #define ROCKER_TEST_DMA_FILL_PATTERN 0x96
186 static int rocker_dma_test_offset(const struct rocker
*rocker
,
187 struct rocker_wait
*wait
, int offset
)
189 struct pci_dev
*pdev
= rocker
->pdev
;
190 unsigned char *alloc
;
192 unsigned char *expect
;
193 dma_addr_t dma_handle
;
197 alloc
= kzalloc(ROCKER_TEST_DMA_BUF_SIZE
* 2 + offset
,
198 GFP_KERNEL
| GFP_DMA
);
201 buf
= alloc
+ offset
;
202 expect
= buf
+ ROCKER_TEST_DMA_BUF_SIZE
;
204 dma_handle
= pci_map_single(pdev
, buf
, ROCKER_TEST_DMA_BUF_SIZE
,
205 PCI_DMA_BIDIRECTIONAL
);
206 if (pci_dma_mapping_error(pdev
, dma_handle
)) {
211 rocker_write64(rocker
, TEST_DMA_ADDR
, dma_handle
);
212 rocker_write32(rocker
, TEST_DMA_SIZE
, ROCKER_TEST_DMA_BUF_SIZE
);
214 memset(expect
, ROCKER_TEST_DMA_FILL_PATTERN
, ROCKER_TEST_DMA_BUF_SIZE
);
215 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_FILL
,
216 dma_handle
, buf
, expect
,
217 ROCKER_TEST_DMA_BUF_SIZE
);
221 memset(expect
, 0, ROCKER_TEST_DMA_BUF_SIZE
);
222 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_CLEAR
,
223 dma_handle
, buf
, expect
,
224 ROCKER_TEST_DMA_BUF_SIZE
);
228 prandom_bytes(buf
, ROCKER_TEST_DMA_BUF_SIZE
);
229 for (i
= 0; i
< ROCKER_TEST_DMA_BUF_SIZE
; i
++)
231 err
= rocker_dma_test_one(rocker
, wait
, ROCKER_TEST_DMA_CTRL_INVERT
,
232 dma_handle
, buf
, expect
,
233 ROCKER_TEST_DMA_BUF_SIZE
);
238 pci_unmap_single(pdev
, dma_handle
, ROCKER_TEST_DMA_BUF_SIZE
,
239 PCI_DMA_BIDIRECTIONAL
);
246 static int rocker_dma_test(const struct rocker
*rocker
,
247 struct rocker_wait
*wait
)
252 for (i
= 0; i
< 8; i
++) {
253 err
= rocker_dma_test_offset(rocker
, wait
, i
);
260 static irqreturn_t
rocker_test_irq_handler(int irq
, void *dev_id
)
262 struct rocker_wait
*wait
= dev_id
;
264 rocker_wait_wake_up(wait
);
269 static int rocker_basic_hw_test(const struct rocker
*rocker
)
271 const struct pci_dev
*pdev
= rocker
->pdev
;
272 struct rocker_wait wait
;
275 err
= rocker_reg_test(rocker
);
277 dev_err(&pdev
->dev
, "reg test failed\n");
281 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_TEST
),
282 rocker_test_irq_handler
, 0,
283 rocker_driver_name
, &wait
);
285 dev_err(&pdev
->dev
, "cannot assign test irq\n");
289 rocker_wait_init(&wait
);
290 rocker_write32(rocker
, TEST_IRQ
, ROCKER_MSIX_VEC_TEST
);
292 if (!rocker_wait_event_timeout(&wait
, HZ
/ 10)) {
293 dev_err(&pdev
->dev
, "no interrupt received within a timeout\n");
298 err
= rocker_dma_test(rocker
, &wait
);
300 dev_err(&pdev
->dev
, "dma test failed\n");
303 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_TEST
), &wait
);
307 /******************************************
308 * DMA rings and descriptors manipulations
309 ******************************************/
311 static u32
__pos_inc(u32 pos
, size_t limit
)
313 return ++pos
== limit
? 0 : pos
;
316 static int rocker_desc_err(const struct rocker_desc_info
*desc_info
)
318 int err
= desc_info
->desc
->comp_err
& ~ROCKER_DMA_DESC_COMP_ERR_GEN
;
333 case -ROCKER_EMSGSIZE
:
335 case -ROCKER_ENOTSUP
:
337 case -ROCKER_ENOBUFS
:
344 static void rocker_desc_gen_clear(const struct rocker_desc_info
*desc_info
)
346 desc_info
->desc
->comp_err
&= ~ROCKER_DMA_DESC_COMP_ERR_GEN
;
349 static bool rocker_desc_gen(const struct rocker_desc_info
*desc_info
)
351 u32 comp_err
= desc_info
->desc
->comp_err
;
353 return comp_err
& ROCKER_DMA_DESC_COMP_ERR_GEN
? true : false;
357 rocker_desc_cookie_ptr_get(const struct rocker_desc_info
*desc_info
)
359 return (void *)(uintptr_t)desc_info
->desc
->cookie
;
362 static void rocker_desc_cookie_ptr_set(const struct rocker_desc_info
*desc_info
,
365 desc_info
->desc
->cookie
= (uintptr_t) ptr
;
368 static struct rocker_desc_info
*
369 rocker_desc_head_get(const struct rocker_dma_ring_info
*info
)
371 static struct rocker_desc_info
*desc_info
;
372 u32 head
= __pos_inc(info
->head
, info
->size
);
374 desc_info
= &info
->desc_info
[info
->head
];
375 if (head
== info
->tail
)
376 return NULL
; /* ring full */
377 desc_info
->tlv_size
= 0;
381 static void rocker_desc_commit(const struct rocker_desc_info
*desc_info
)
383 desc_info
->desc
->buf_size
= desc_info
->data_size
;
384 desc_info
->desc
->tlv_size
= desc_info
->tlv_size
;
387 static void rocker_desc_head_set(const struct rocker
*rocker
,
388 struct rocker_dma_ring_info
*info
,
389 const struct rocker_desc_info
*desc_info
)
391 u32 head
= __pos_inc(info
->head
, info
->size
);
393 BUG_ON(head
== info
->tail
);
394 rocker_desc_commit(desc_info
);
396 rocker_write32(rocker
, DMA_DESC_HEAD(info
->type
), head
);
399 static struct rocker_desc_info
*
400 rocker_desc_tail_get(struct rocker_dma_ring_info
*info
)
402 static struct rocker_desc_info
*desc_info
;
404 if (info
->tail
== info
->head
)
405 return NULL
; /* nothing to be done between head and tail */
406 desc_info
= &info
->desc_info
[info
->tail
];
407 if (!rocker_desc_gen(desc_info
))
408 return NULL
; /* gen bit not set, desc is not ready yet */
409 info
->tail
= __pos_inc(info
->tail
, info
->size
);
410 desc_info
->tlv_size
= desc_info
->desc
->tlv_size
;
414 static void rocker_dma_ring_credits_set(const struct rocker
*rocker
,
415 const struct rocker_dma_ring_info
*info
,
419 rocker_write32(rocker
, DMA_DESC_CREDITS(info
->type
), credits
);
422 static unsigned long rocker_dma_ring_size_fix(size_t size
)
424 return max(ROCKER_DMA_SIZE_MIN
,
425 min(roundup_pow_of_two(size
), ROCKER_DMA_SIZE_MAX
));
428 static int rocker_dma_ring_create(const struct rocker
*rocker
,
431 struct rocker_dma_ring_info
*info
)
435 BUG_ON(size
!= rocker_dma_ring_size_fix(size
));
440 info
->desc_info
= kcalloc(info
->size
, sizeof(*info
->desc_info
),
442 if (!info
->desc_info
)
445 info
->desc
= pci_alloc_consistent(rocker
->pdev
,
446 info
->size
* sizeof(*info
->desc
),
449 kfree(info
->desc_info
);
453 for (i
= 0; i
< info
->size
; i
++)
454 info
->desc_info
[i
].desc
= &info
->desc
[i
];
456 rocker_write32(rocker
, DMA_DESC_CTRL(info
->type
),
457 ROCKER_DMA_DESC_CTRL_RESET
);
458 rocker_write64(rocker
, DMA_DESC_ADDR(info
->type
), info
->mapaddr
);
459 rocker_write32(rocker
, DMA_DESC_SIZE(info
->type
), info
->size
);
464 static void rocker_dma_ring_destroy(const struct rocker
*rocker
,
465 const struct rocker_dma_ring_info
*info
)
467 rocker_write64(rocker
, DMA_DESC_ADDR(info
->type
), 0);
469 pci_free_consistent(rocker
->pdev
,
470 info
->size
* sizeof(struct rocker_desc
),
471 info
->desc
, info
->mapaddr
);
472 kfree(info
->desc_info
);
475 static void rocker_dma_ring_pass_to_producer(const struct rocker
*rocker
,
476 struct rocker_dma_ring_info
*info
)
480 BUG_ON(info
->head
|| info
->tail
);
482 /* When ring is consumer, we need to advance head for each desc.
483 * That tells hw that the desc is ready to be used by it.
485 for (i
= 0; i
< info
->size
- 1; i
++)
486 rocker_desc_head_set(rocker
, info
, &info
->desc_info
[i
]);
487 rocker_desc_commit(&info
->desc_info
[i
]);
490 static int rocker_dma_ring_bufs_alloc(const struct rocker
*rocker
,
491 const struct rocker_dma_ring_info
*info
,
492 int direction
, size_t buf_size
)
494 struct pci_dev
*pdev
= rocker
->pdev
;
498 for (i
= 0; i
< info
->size
; i
++) {
499 struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
500 struct rocker_desc
*desc
= &info
->desc
[i
];
501 dma_addr_t dma_handle
;
504 buf
= kzalloc(buf_size
, GFP_KERNEL
| GFP_DMA
);
510 dma_handle
= pci_map_single(pdev
, buf
, buf_size
, direction
);
511 if (pci_dma_mapping_error(pdev
, dma_handle
)) {
517 desc_info
->data
= buf
;
518 desc_info
->data_size
= buf_size
;
519 dma_unmap_addr_set(desc_info
, mapaddr
, dma_handle
);
521 desc
->buf_addr
= dma_handle
;
522 desc
->buf_size
= buf_size
;
527 for (i
--; i
>= 0; i
--) {
528 const struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
530 pci_unmap_single(pdev
, dma_unmap_addr(desc_info
, mapaddr
),
531 desc_info
->data_size
, direction
);
532 kfree(desc_info
->data
);
537 static void rocker_dma_ring_bufs_free(const struct rocker
*rocker
,
538 const struct rocker_dma_ring_info
*info
,
541 struct pci_dev
*pdev
= rocker
->pdev
;
544 for (i
= 0; i
< info
->size
; i
++) {
545 const struct rocker_desc_info
*desc_info
= &info
->desc_info
[i
];
546 struct rocker_desc
*desc
= &info
->desc
[i
];
550 pci_unmap_single(pdev
, dma_unmap_addr(desc_info
, mapaddr
),
551 desc_info
->data_size
, direction
);
552 kfree(desc_info
->data
);
556 static int rocker_dma_cmd_ring_wait_alloc(struct rocker_desc_info
*desc_info
)
558 struct rocker_wait
*wait
;
560 wait
= rocker_wait_create();
563 rocker_desc_cookie_ptr_set(desc_info
, wait
);
568 rocker_dma_cmd_ring_wait_free(const struct rocker_desc_info
*desc_info
)
570 struct rocker_wait
*wait
= rocker_desc_cookie_ptr_get(desc_info
);
572 rocker_wait_destroy(wait
);
575 static int rocker_dma_cmd_ring_waits_alloc(const struct rocker
*rocker
)
577 const struct rocker_dma_ring_info
*cmd_ring
= &rocker
->cmd_ring
;
581 for (i
= 0; i
< cmd_ring
->size
; i
++) {
582 err
= rocker_dma_cmd_ring_wait_alloc(&cmd_ring
->desc_info
[i
]);
589 for (i
--; i
>= 0; i
--)
590 rocker_dma_cmd_ring_wait_free(&cmd_ring
->desc_info
[i
]);
594 static void rocker_dma_cmd_ring_waits_free(const struct rocker
*rocker
)
596 const struct rocker_dma_ring_info
*cmd_ring
= &rocker
->cmd_ring
;
599 for (i
= 0; i
< cmd_ring
->size
; i
++)
600 rocker_dma_cmd_ring_wait_free(&cmd_ring
->desc_info
[i
]);
603 static int rocker_dma_rings_init(struct rocker
*rocker
)
605 const struct pci_dev
*pdev
= rocker
->pdev
;
608 err
= rocker_dma_ring_create(rocker
, ROCKER_DMA_CMD
,
609 ROCKER_DMA_CMD_DEFAULT_SIZE
,
612 dev_err(&pdev
->dev
, "failed to create command dma ring\n");
616 spin_lock_init(&rocker
->cmd_ring_lock
);
618 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker
->cmd_ring
,
619 PCI_DMA_BIDIRECTIONAL
, PAGE_SIZE
);
621 dev_err(&pdev
->dev
, "failed to alloc command dma ring buffers\n");
622 goto err_dma_cmd_ring_bufs_alloc
;
625 err
= rocker_dma_cmd_ring_waits_alloc(rocker
);
627 dev_err(&pdev
->dev
, "failed to alloc command dma ring waits\n");
628 goto err_dma_cmd_ring_waits_alloc
;
631 err
= rocker_dma_ring_create(rocker
, ROCKER_DMA_EVENT
,
632 ROCKER_DMA_EVENT_DEFAULT_SIZE
,
633 &rocker
->event_ring
);
635 dev_err(&pdev
->dev
, "failed to create event dma ring\n");
636 goto err_dma_event_ring_create
;
639 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker
->event_ring
,
640 PCI_DMA_FROMDEVICE
, PAGE_SIZE
);
642 dev_err(&pdev
->dev
, "failed to alloc event dma ring buffers\n");
643 goto err_dma_event_ring_bufs_alloc
;
645 rocker_dma_ring_pass_to_producer(rocker
, &rocker
->event_ring
);
648 err_dma_event_ring_bufs_alloc
:
649 rocker_dma_ring_destroy(rocker
, &rocker
->event_ring
);
650 err_dma_event_ring_create
:
651 rocker_dma_ring_bufs_free(rocker
, &rocker
->cmd_ring
,
652 PCI_DMA_BIDIRECTIONAL
);
653 err_dma_cmd_ring_waits_alloc
:
654 rocker_dma_cmd_ring_waits_free(rocker
);
655 err_dma_cmd_ring_bufs_alloc
:
656 rocker_dma_ring_destroy(rocker
, &rocker
->cmd_ring
);
660 static void rocker_dma_rings_fini(struct rocker
*rocker
)
662 rocker_dma_ring_bufs_free(rocker
, &rocker
->event_ring
,
663 PCI_DMA_BIDIRECTIONAL
);
664 rocker_dma_ring_destroy(rocker
, &rocker
->event_ring
);
665 rocker_dma_cmd_ring_waits_free(rocker
);
666 rocker_dma_ring_bufs_free(rocker
, &rocker
->cmd_ring
,
667 PCI_DMA_BIDIRECTIONAL
);
668 rocker_dma_ring_destroy(rocker
, &rocker
->cmd_ring
);
671 static int rocker_dma_rx_ring_skb_map(const struct rocker_port
*rocker_port
,
672 struct rocker_desc_info
*desc_info
,
673 struct sk_buff
*skb
, size_t buf_len
)
675 const struct rocker
*rocker
= rocker_port
->rocker
;
676 struct pci_dev
*pdev
= rocker
->pdev
;
677 dma_addr_t dma_handle
;
679 dma_handle
= pci_map_single(pdev
, skb
->data
, buf_len
,
681 if (pci_dma_mapping_error(pdev
, dma_handle
))
683 if (rocker_tlv_put_u64(desc_info
, ROCKER_TLV_RX_FRAG_ADDR
, dma_handle
))
684 goto tlv_put_failure
;
685 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_RX_FRAG_MAX_LEN
, buf_len
))
686 goto tlv_put_failure
;
690 pci_unmap_single(pdev
, dma_handle
, buf_len
, PCI_DMA_FROMDEVICE
);
691 desc_info
->tlv_size
= 0;
695 static size_t rocker_port_rx_buf_len(const struct rocker_port
*rocker_port
)
697 return rocker_port
->dev
->mtu
+ ETH_HLEN
+ ETH_FCS_LEN
+ VLAN_HLEN
;
700 static int rocker_dma_rx_ring_skb_alloc(const struct rocker_port
*rocker_port
,
701 struct rocker_desc_info
*desc_info
)
703 struct net_device
*dev
= rocker_port
->dev
;
705 size_t buf_len
= rocker_port_rx_buf_len(rocker_port
);
708 /* Ensure that hw will see tlv_size zero in case of an error.
709 * That tells hw to use another descriptor.
711 rocker_desc_cookie_ptr_set(desc_info
, NULL
);
712 desc_info
->tlv_size
= 0;
714 skb
= netdev_alloc_skb_ip_align(dev
, buf_len
);
717 err
= rocker_dma_rx_ring_skb_map(rocker_port
, desc_info
, skb
, buf_len
);
719 dev_kfree_skb_any(skb
);
722 rocker_desc_cookie_ptr_set(desc_info
, skb
);
726 static void rocker_dma_rx_ring_skb_unmap(const struct rocker
*rocker
,
727 const struct rocker_tlv
**attrs
)
729 struct pci_dev
*pdev
= rocker
->pdev
;
730 dma_addr_t dma_handle
;
733 if (!attrs
[ROCKER_TLV_RX_FRAG_ADDR
] ||
734 !attrs
[ROCKER_TLV_RX_FRAG_MAX_LEN
])
736 dma_handle
= rocker_tlv_get_u64(attrs
[ROCKER_TLV_RX_FRAG_ADDR
]);
737 len
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FRAG_MAX_LEN
]);
738 pci_unmap_single(pdev
, dma_handle
, len
, PCI_DMA_FROMDEVICE
);
741 static void rocker_dma_rx_ring_skb_free(const struct rocker
*rocker
,
742 const struct rocker_desc_info
*desc_info
)
744 const struct rocker_tlv
*attrs
[ROCKER_TLV_RX_MAX
+ 1];
745 struct sk_buff
*skb
= rocker_desc_cookie_ptr_get(desc_info
);
749 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_RX_MAX
, desc_info
);
750 rocker_dma_rx_ring_skb_unmap(rocker
, attrs
);
751 dev_kfree_skb_any(skb
);
754 static int rocker_dma_rx_ring_skbs_alloc(const struct rocker_port
*rocker_port
)
756 const struct rocker_dma_ring_info
*rx_ring
= &rocker_port
->rx_ring
;
757 const struct rocker
*rocker
= rocker_port
->rocker
;
761 for (i
= 0; i
< rx_ring
->size
; i
++) {
762 err
= rocker_dma_rx_ring_skb_alloc(rocker_port
,
763 &rx_ring
->desc_info
[i
]);
770 for (i
--; i
>= 0; i
--)
771 rocker_dma_rx_ring_skb_free(rocker
, &rx_ring
->desc_info
[i
]);
775 static void rocker_dma_rx_ring_skbs_free(const struct rocker_port
*rocker_port
)
777 const struct rocker_dma_ring_info
*rx_ring
= &rocker_port
->rx_ring
;
778 const struct rocker
*rocker
= rocker_port
->rocker
;
781 for (i
= 0; i
< rx_ring
->size
; i
++)
782 rocker_dma_rx_ring_skb_free(rocker
, &rx_ring
->desc_info
[i
]);
785 static int rocker_port_dma_rings_init(struct rocker_port
*rocker_port
)
787 struct rocker
*rocker
= rocker_port
->rocker
;
790 err
= rocker_dma_ring_create(rocker
,
791 ROCKER_DMA_TX(rocker_port
->port_number
),
792 ROCKER_DMA_TX_DEFAULT_SIZE
,
793 &rocker_port
->tx_ring
);
795 netdev_err(rocker_port
->dev
, "failed to create tx dma ring\n");
799 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker_port
->tx_ring
,
801 ROCKER_DMA_TX_DESC_SIZE
);
803 netdev_err(rocker_port
->dev
, "failed to alloc tx dma ring buffers\n");
804 goto err_dma_tx_ring_bufs_alloc
;
807 err
= rocker_dma_ring_create(rocker
,
808 ROCKER_DMA_RX(rocker_port
->port_number
),
809 ROCKER_DMA_RX_DEFAULT_SIZE
,
810 &rocker_port
->rx_ring
);
812 netdev_err(rocker_port
->dev
, "failed to create rx dma ring\n");
813 goto err_dma_rx_ring_create
;
816 err
= rocker_dma_ring_bufs_alloc(rocker
, &rocker_port
->rx_ring
,
817 PCI_DMA_BIDIRECTIONAL
,
818 ROCKER_DMA_RX_DESC_SIZE
);
820 netdev_err(rocker_port
->dev
, "failed to alloc rx dma ring buffers\n");
821 goto err_dma_rx_ring_bufs_alloc
;
824 err
= rocker_dma_rx_ring_skbs_alloc(rocker_port
);
826 netdev_err(rocker_port
->dev
, "failed to alloc rx dma ring skbs\n");
827 goto err_dma_rx_ring_skbs_alloc
;
829 rocker_dma_ring_pass_to_producer(rocker
, &rocker_port
->rx_ring
);
833 err_dma_rx_ring_skbs_alloc
:
834 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->rx_ring
,
835 PCI_DMA_BIDIRECTIONAL
);
836 err_dma_rx_ring_bufs_alloc
:
837 rocker_dma_ring_destroy(rocker
, &rocker_port
->rx_ring
);
838 err_dma_rx_ring_create
:
839 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->tx_ring
,
841 err_dma_tx_ring_bufs_alloc
:
842 rocker_dma_ring_destroy(rocker
, &rocker_port
->tx_ring
);
846 static void rocker_port_dma_rings_fini(struct rocker_port
*rocker_port
)
848 struct rocker
*rocker
= rocker_port
->rocker
;
850 rocker_dma_rx_ring_skbs_free(rocker_port
);
851 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->rx_ring
,
852 PCI_DMA_BIDIRECTIONAL
);
853 rocker_dma_ring_destroy(rocker
, &rocker_port
->rx_ring
);
854 rocker_dma_ring_bufs_free(rocker
, &rocker_port
->tx_ring
,
856 rocker_dma_ring_destroy(rocker
, &rocker_port
->tx_ring
);
859 static void rocker_port_set_enable(const struct rocker_port
*rocker_port
,
862 u64 val
= rocker_read64(rocker_port
->rocker
, PORT_PHYS_ENABLE
);
865 val
|= 1ULL << rocker_port
->pport
;
867 val
&= ~(1ULL << rocker_port
->pport
);
868 rocker_write64(rocker_port
->rocker
, PORT_PHYS_ENABLE
, val
);
871 /********************************
872 * Interrupt handler and helpers
873 ********************************/
875 static irqreturn_t
rocker_cmd_irq_handler(int irq
, void *dev_id
)
877 struct rocker
*rocker
= dev_id
;
878 const struct rocker_desc_info
*desc_info
;
879 struct rocker_wait
*wait
;
882 spin_lock(&rocker
->cmd_ring_lock
);
883 while ((desc_info
= rocker_desc_tail_get(&rocker
->cmd_ring
))) {
884 wait
= rocker_desc_cookie_ptr_get(desc_info
);
886 rocker_desc_gen_clear(desc_info
);
888 rocker_wait_wake_up(wait
);
892 spin_unlock(&rocker
->cmd_ring_lock
);
893 rocker_dma_ring_credits_set(rocker
, &rocker
->cmd_ring
, credits
);
898 static void rocker_port_link_up(const struct rocker_port
*rocker_port
)
900 netif_carrier_on(rocker_port
->dev
);
901 netdev_info(rocker_port
->dev
, "Link is up\n");
904 static void rocker_port_link_down(const struct rocker_port
*rocker_port
)
906 netif_carrier_off(rocker_port
->dev
);
907 netdev_info(rocker_port
->dev
, "Link is down\n");
910 static int rocker_event_link_change(const struct rocker
*rocker
,
911 const struct rocker_tlv
*info
)
913 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_MAX
+ 1];
914 unsigned int port_number
;
916 struct rocker_port
*rocker_port
;
918 rocker_tlv_parse_nested(attrs
, ROCKER_TLV_EVENT_LINK_CHANGED_MAX
, info
);
919 if (!attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT
] ||
920 !attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP
])
923 rocker_tlv_get_u32(attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT
]) - 1;
924 link_up
= rocker_tlv_get_u8(attrs
[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP
]);
926 if (port_number
>= rocker
->port_count
)
929 rocker_port
= rocker
->ports
[port_number
];
930 if (netif_carrier_ok(rocker_port
->dev
) != link_up
) {
932 rocker_port_link_up(rocker_port
);
934 rocker_port_link_down(rocker_port
);
940 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port
*rocker_port
,
941 const unsigned char *addr
,
944 static int rocker_event_mac_vlan_seen(const struct rocker
*rocker
,
945 const struct rocker_tlv
*info
)
947 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAX
+ 1];
948 unsigned int port_number
;
949 struct rocker_port
*rocker_port
;
950 const unsigned char *addr
;
953 rocker_tlv_parse_nested(attrs
, ROCKER_TLV_EVENT_MAC_VLAN_MAX
, info
);
954 if (!attrs
[ROCKER_TLV_EVENT_MAC_VLAN_PPORT
] ||
955 !attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAC
] ||
956 !attrs
[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID
])
959 rocker_tlv_get_u32(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_PPORT
]) - 1;
960 addr
= rocker_tlv_data(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_MAC
]);
961 vlan_id
= rocker_tlv_get_be16(attrs
[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID
]);
963 if (port_number
>= rocker
->port_count
)
966 rocker_port
= rocker
->ports
[port_number
];
967 return rocker_world_port_ev_mac_vlan_seen(rocker_port
, addr
, vlan_id
);
970 static int rocker_event_process(const struct rocker
*rocker
,
971 const struct rocker_desc_info
*desc_info
)
973 const struct rocker_tlv
*attrs
[ROCKER_TLV_EVENT_MAX
+ 1];
974 const struct rocker_tlv
*info
;
977 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_EVENT_MAX
, desc_info
);
978 if (!attrs
[ROCKER_TLV_EVENT_TYPE
] ||
979 !attrs
[ROCKER_TLV_EVENT_INFO
])
982 type
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_EVENT_TYPE
]);
983 info
= attrs
[ROCKER_TLV_EVENT_INFO
];
986 case ROCKER_TLV_EVENT_TYPE_LINK_CHANGED
:
987 return rocker_event_link_change(rocker
, info
);
988 case ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN
:
989 return rocker_event_mac_vlan_seen(rocker
, info
);
995 static irqreturn_t
rocker_event_irq_handler(int irq
, void *dev_id
)
997 struct rocker
*rocker
= dev_id
;
998 const struct pci_dev
*pdev
= rocker
->pdev
;
999 const struct rocker_desc_info
*desc_info
;
1003 while ((desc_info
= rocker_desc_tail_get(&rocker
->event_ring
))) {
1004 err
= rocker_desc_err(desc_info
);
1006 dev_err(&pdev
->dev
, "event desc received with err %d\n",
1009 err
= rocker_event_process(rocker
, desc_info
);
1011 dev_err(&pdev
->dev
, "event processing failed with err %d\n",
1014 rocker_desc_gen_clear(desc_info
);
1015 rocker_desc_head_set(rocker
, &rocker
->event_ring
, desc_info
);
1018 rocker_dma_ring_credits_set(rocker
, &rocker
->event_ring
, credits
);
1023 static irqreturn_t
rocker_tx_irq_handler(int irq
, void *dev_id
)
1025 struct rocker_port
*rocker_port
= dev_id
;
1027 napi_schedule(&rocker_port
->napi_tx
);
1031 static irqreturn_t
rocker_rx_irq_handler(int irq
, void *dev_id
)
1033 struct rocker_port
*rocker_port
= dev_id
;
1035 napi_schedule(&rocker_port
->napi_rx
);
1039 /********************
1041 ********************/
1043 int rocker_cmd_exec(struct rocker_port
*rocker_port
, bool nowait
,
1044 rocker_cmd_prep_cb_t prepare
, void *prepare_priv
,
1045 rocker_cmd_proc_cb_t process
, void *process_priv
)
1047 struct rocker
*rocker
= rocker_port
->rocker
;
1048 struct rocker_desc_info
*desc_info
;
1049 struct rocker_wait
*wait
;
1050 unsigned long lock_flags
;
1053 spin_lock_irqsave(&rocker
->cmd_ring_lock
, lock_flags
);
1055 desc_info
= rocker_desc_head_get(&rocker
->cmd_ring
);
1057 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1061 wait
= rocker_desc_cookie_ptr_get(desc_info
);
1062 rocker_wait_init(wait
);
1063 wait
->nowait
= nowait
;
1065 err
= prepare(rocker_port
, desc_info
, prepare_priv
);
1067 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1071 rocker_desc_head_set(rocker
, &rocker
->cmd_ring
, desc_info
);
1073 spin_unlock_irqrestore(&rocker
->cmd_ring_lock
, lock_flags
);
1078 if (!rocker_wait_event_timeout(wait
, HZ
/ 10))
1081 err
= rocker_desc_err(desc_info
);
1086 err
= process(rocker_port
, desc_info
, process_priv
);
1088 rocker_desc_gen_clear(desc_info
);
1093 rocker_cmd_get_port_settings_prep(const struct rocker_port
*rocker_port
,
1094 struct rocker_desc_info
*desc_info
,
1097 struct rocker_tlv
*cmd_info
;
1099 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1100 ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS
))
1102 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1105 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1106 rocker_port
->pport
))
1108 rocker_tlv_nest_end(desc_info
, cmd_info
);
1113 rocker_cmd_get_port_settings_ethtool_proc(const struct rocker_port
*rocker_port
,
1114 const struct rocker_desc_info
*desc_info
,
1117 struct ethtool_cmd
*ecmd
= priv
;
1118 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1119 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1124 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1125 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1128 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1129 attrs
[ROCKER_TLV_CMD_INFO
]);
1130 if (!info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
] ||
1131 !info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
] ||
1132 !info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
])
1135 speed
= rocker_tlv_get_u32(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
]);
1136 duplex
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
]);
1137 autoneg
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
]);
1139 ecmd
->transceiver
= XCVR_INTERNAL
;
1140 ecmd
->supported
= SUPPORTED_TP
;
1141 ecmd
->phy_address
= 0xff;
1142 ecmd
->port
= PORT_TP
;
1143 ethtool_cmd_speed_set(ecmd
, speed
);
1144 ecmd
->duplex
= duplex
? DUPLEX_FULL
: DUPLEX_HALF
;
1145 ecmd
->autoneg
= autoneg
? AUTONEG_ENABLE
: AUTONEG_DISABLE
;
1151 rocker_cmd_get_port_settings_macaddr_proc(const struct rocker_port
*rocker_port
,
1152 const struct rocker_desc_info
*desc_info
,
1155 unsigned char *macaddr
= priv
;
1156 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1157 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1158 const struct rocker_tlv
*attr
;
1160 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1161 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1164 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1165 attrs
[ROCKER_TLV_CMD_INFO
]);
1166 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR
];
1170 if (rocker_tlv_len(attr
) != ETH_ALEN
)
1173 ether_addr_copy(macaddr
, rocker_tlv_data(attr
));
1178 rocker_cmd_get_port_settings_mode_proc(const struct rocker_port
*rocker_port
,
1179 const struct rocker_desc_info
*desc_info
,
1183 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1184 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1185 const struct rocker_tlv
*attr
;
1187 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1188 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1191 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1192 attrs
[ROCKER_TLV_CMD_INFO
]);
1193 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MODE
];
1197 *p_mode
= rocker_tlv_get_u8(info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MODE
]);
1207 rocker_cmd_get_port_settings_phys_name_proc(const struct rocker_port
*rocker_port
,
1208 const struct rocker_desc_info
*desc_info
,
1211 const struct rocker_tlv
*info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_MAX
+ 1];
1212 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
1213 struct port_name
*name
= priv
;
1214 const struct rocker_tlv
*attr
;
1218 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
1219 if (!attrs
[ROCKER_TLV_CMD_INFO
])
1222 rocker_tlv_parse_nested(info_attrs
, ROCKER_TLV_CMD_PORT_SETTINGS_MAX
,
1223 attrs
[ROCKER_TLV_CMD_INFO
]);
1224 attr
= info_attrs
[ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME
];
1228 len
= min_t(size_t, rocker_tlv_len(attr
), name
->len
);
1229 str
= rocker_tlv_data(attr
);
1231 /* make sure name only contains alphanumeric characters */
1232 for (i
= j
= 0; i
< len
; ++i
) {
1233 if (isalnum(str
[i
])) {
1234 name
->buf
[j
] = str
[i
];
1242 name
->buf
[j
] = '\0';
1248 rocker_cmd_set_port_settings_ethtool_prep(const struct rocker_port
*rocker_port
,
1249 struct rocker_desc_info
*desc_info
,
1252 struct ethtool_cmd
*ecmd
= priv
;
1253 struct rocker_tlv
*cmd_info
;
1255 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1256 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1258 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1261 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1262 rocker_port
->pport
))
1264 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED
,
1265 ethtool_cmd_speed(ecmd
)))
1267 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX
,
1270 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG
,
1273 rocker_tlv_nest_end(desc_info
, cmd_info
);
1278 rocker_cmd_set_port_settings_macaddr_prep(const struct rocker_port
*rocker_port
,
1279 struct rocker_desc_info
*desc_info
,
1282 const unsigned char *macaddr
= priv
;
1283 struct rocker_tlv
*cmd_info
;
1285 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1286 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1288 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1291 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1292 rocker_port
->pport
))
1294 if (rocker_tlv_put(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR
,
1297 rocker_tlv_nest_end(desc_info
, cmd_info
);
1302 rocker_cmd_set_port_settings_mtu_prep(const struct rocker_port
*rocker_port
,
1303 struct rocker_desc_info
*desc_info
,
1306 int mtu
= *(int *)priv
;
1307 struct rocker_tlv
*cmd_info
;
1309 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1310 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1312 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1315 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1316 rocker_port
->pport
))
1318 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_MTU
,
1321 rocker_tlv_nest_end(desc_info
, cmd_info
);
1326 rocker_cmd_set_port_learning_prep(const struct rocker_port
*rocker_port
,
1327 struct rocker_desc_info
*desc_info
,
1330 bool learning
= *(bool *)priv
;
1331 struct rocker_tlv
*cmd_info
;
1333 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
1334 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS
))
1336 cmd_info
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
1339 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT
,
1340 rocker_port
->pport
))
1342 if (rocker_tlv_put_u8(desc_info
, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING
,
1345 rocker_tlv_nest_end(desc_info
, cmd_info
);
1349 static int rocker_cmd_get_port_settings_ethtool(struct rocker_port
*rocker_port
,
1350 struct ethtool_cmd
*ecmd
)
1352 return rocker_cmd_exec(rocker_port
, false,
1353 rocker_cmd_get_port_settings_prep
, NULL
,
1354 rocker_cmd_get_port_settings_ethtool_proc
,
1358 static int rocker_cmd_get_port_settings_macaddr(struct rocker_port
*rocker_port
,
1359 unsigned char *macaddr
)
1361 return rocker_cmd_exec(rocker_port
, false,
1362 rocker_cmd_get_port_settings_prep
, NULL
,
1363 rocker_cmd_get_port_settings_macaddr_proc
,
1367 static int rocker_cmd_get_port_settings_mode(struct rocker_port
*rocker_port
,
1370 return rocker_cmd_exec(rocker_port
, false,
1371 rocker_cmd_get_port_settings_prep
, NULL
,
1372 rocker_cmd_get_port_settings_mode_proc
, p_mode
);
1375 static int rocker_cmd_set_port_settings_ethtool(struct rocker_port
*rocker_port
,
1376 struct ethtool_cmd
*ecmd
)
1378 return rocker_cmd_exec(rocker_port
, false,
1379 rocker_cmd_set_port_settings_ethtool_prep
,
1383 static int rocker_cmd_set_port_settings_macaddr(struct rocker_port
*rocker_port
,
1384 unsigned char *macaddr
)
1386 return rocker_cmd_exec(rocker_port
, false,
1387 rocker_cmd_set_port_settings_macaddr_prep
,
1388 macaddr
, NULL
, NULL
);
1391 static int rocker_cmd_set_port_settings_mtu(struct rocker_port
*rocker_port
,
1394 return rocker_cmd_exec(rocker_port
, false,
1395 rocker_cmd_set_port_settings_mtu_prep
,
1399 int rocker_port_set_learning(struct rocker_port
*rocker_port
,
1402 return rocker_cmd_exec(rocker_port
, false,
1403 rocker_cmd_set_port_learning_prep
,
1404 &learning
, NULL
, NULL
);
1407 /**********************
1408 * Worlds manipulation
1409 **********************/
1411 static struct rocker_world_ops
*rocker_world_ops
[] = {
1415 #define ROCKER_WORLD_OPS_LEN ARRAY_SIZE(rocker_world_ops)
1417 static struct rocker_world_ops
*rocker_world_ops_find(u8 mode
)
1421 for (i
= 0; i
< ROCKER_WORLD_OPS_LEN
; i
++)
1422 if (rocker_world_ops
[i
]->mode
== mode
)
1423 return rocker_world_ops
[i
];
1427 static int rocker_world_init(struct rocker
*rocker
, u8 mode
)
1429 struct rocker_world_ops
*wops
;
1432 wops
= rocker_world_ops_find(mode
);
1434 dev_err(&rocker
->pdev
->dev
, "port mode \"%d\" is not supported\n",
1438 rocker
->wops
= wops
;
1439 rocker
->wpriv
= kzalloc(wops
->priv_size
, GFP_KERNEL
);
1444 err
= wops
->init(rocker
);
1446 kfree(rocker
->wpriv
);
1450 static void rocker_world_fini(struct rocker
*rocker
)
1452 struct rocker_world_ops
*wops
= rocker
->wops
;
1454 if (!wops
|| !wops
->fini
)
1457 kfree(rocker
->wpriv
);
1460 static int rocker_world_check_init(struct rocker_port
*rocker_port
)
1462 struct rocker
*rocker
= rocker_port
->rocker
;
1466 err
= rocker_cmd_get_port_settings_mode(rocker_port
, &mode
);
1468 dev_err(&rocker
->pdev
->dev
, "failed to get port mode\n");
1472 if (rocker
->wops
->mode
!= mode
) {
1473 dev_err(&rocker
->pdev
->dev
, "hardware has ports in different worlds, which is not supported\n");
1478 return rocker_world_init(rocker
, mode
);
1481 static int rocker_world_port_pre_init(struct rocker_port
*rocker_port
)
1483 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1486 rocker_port
->wpriv
= kzalloc(wops
->port_priv_size
, GFP_KERNEL
);
1487 if (!rocker_port
->wpriv
)
1489 if (!wops
->port_pre_init
)
1491 err
= wops
->port_pre_init(rocker_port
);
1493 kfree(rocker_port
->wpriv
);
1497 static int rocker_world_port_init(struct rocker_port
*rocker_port
)
1499 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1501 if (!wops
->port_init
)
1503 return wops
->port_init(rocker_port
);
1506 static void rocker_world_port_fini(struct rocker_port
*rocker_port
)
1508 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1510 if (!wops
->port_fini
)
1512 wops
->port_fini(rocker_port
);
1515 static void rocker_world_port_post_fini(struct rocker_port
*rocker_port
)
1517 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1519 if (!wops
->port_post_fini
)
1521 wops
->port_post_fini(rocker_port
);
1522 kfree(rocker_port
->wpriv
);
1525 static int rocker_world_port_open(struct rocker_port
*rocker_port
)
1527 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1529 if (!wops
->port_open
)
1531 return wops
->port_open(rocker_port
);
1534 static void rocker_world_port_stop(struct rocker_port
*rocker_port
)
1536 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1538 if (!wops
->port_stop
)
1540 wops
->port_stop(rocker_port
);
1543 static int rocker_world_port_attr_stp_state_set(struct rocker_port
*rocker_port
,
1545 struct switchdev_trans
*trans
)
1547 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1549 if (!wops
->port_attr_stp_state_set
)
1551 return wops
->port_attr_stp_state_set(rocker_port
, state
, trans
);
1555 rocker_world_port_attr_bridge_flags_set(struct rocker_port
*rocker_port
,
1556 unsigned long brport_flags
,
1557 struct switchdev_trans
*trans
)
1559 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1561 if (!wops
->port_attr_bridge_flags_set
)
1563 return wops
->port_attr_bridge_flags_set(rocker_port
, brport_flags
,
1568 rocker_world_port_attr_bridge_flags_get(const struct rocker_port
*rocker_port
,
1569 unsigned long *p_brport_flags
)
1571 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1573 if (!wops
->port_attr_bridge_flags_get
)
1575 return wops
->port_attr_bridge_flags_get(rocker_port
, p_brport_flags
);
1579 rocker_world_port_attr_bridge_ageing_time_set(struct rocker_port
*rocker_port
,
1581 struct switchdev_trans
*trans
)
1584 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1586 if (!wops
->port_attr_bridge_ageing_time_set
)
1588 return wops
->port_attr_bridge_ageing_time_set(rocker_port
, ageing_time
,
1593 rocker_world_port_obj_vlan_add(struct rocker_port
*rocker_port
,
1594 const struct switchdev_obj_port_vlan
*vlan
,
1595 struct switchdev_trans
*trans
)
1597 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1599 if (!wops
->port_obj_vlan_add
)
1601 return wops
->port_obj_vlan_add(rocker_port
, vlan
, trans
);
1605 rocker_world_port_obj_vlan_del(struct rocker_port
*rocker_port
,
1606 const struct switchdev_obj_port_vlan
*vlan
)
1608 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1610 if (!wops
->port_obj_vlan_del
)
1612 return wops
->port_obj_vlan_del(rocker_port
, vlan
);
1616 rocker_world_port_obj_vlan_dump(const struct rocker_port
*rocker_port
,
1617 struct switchdev_obj_port_vlan
*vlan
,
1618 switchdev_obj_dump_cb_t
*cb
)
1620 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1622 if (!wops
->port_obj_vlan_dump
)
1624 return wops
->port_obj_vlan_dump(rocker_port
, vlan
, cb
);
1628 rocker_world_port_obj_fdb_add(struct rocker_port
*rocker_port
,
1629 const struct switchdev_obj_port_fdb
*fdb
,
1630 struct switchdev_trans
*trans
)
1632 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1634 if (!wops
->port_obj_fdb_add
)
1636 return wops
->port_obj_fdb_add(rocker_port
, fdb
, trans
);
1640 rocker_world_port_obj_fdb_del(struct rocker_port
*rocker_port
,
1641 const struct switchdev_obj_port_fdb
*fdb
)
1643 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1645 if (!wops
->port_obj_fdb_del
)
1647 return wops
->port_obj_fdb_del(rocker_port
, fdb
);
1651 rocker_world_port_obj_fdb_dump(const struct rocker_port
*rocker_port
,
1652 struct switchdev_obj_port_fdb
*fdb
,
1653 switchdev_obj_dump_cb_t
*cb
)
1655 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1657 if (!wops
->port_obj_fdb_dump
)
1659 return wops
->port_obj_fdb_dump(rocker_port
, fdb
, cb
);
1662 static int rocker_world_port_master_linked(struct rocker_port
*rocker_port
,
1663 struct net_device
*master
)
1665 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1667 if (!wops
->port_master_linked
)
1669 return wops
->port_master_linked(rocker_port
, master
);
1672 static int rocker_world_port_master_unlinked(struct rocker_port
*rocker_port
,
1673 struct net_device
*master
)
1675 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1677 if (!wops
->port_master_unlinked
)
1679 return wops
->port_master_unlinked(rocker_port
, master
);
1682 static int rocker_world_port_neigh_update(struct rocker_port
*rocker_port
,
1683 struct neighbour
*n
)
1685 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1687 if (!wops
->port_neigh_update
)
1689 return wops
->port_neigh_update(rocker_port
, n
);
1692 static int rocker_world_port_neigh_destroy(struct rocker_port
*rocker_port
,
1693 struct neighbour
*n
)
1695 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1697 if (!wops
->port_neigh_destroy
)
1699 return wops
->port_neigh_destroy(rocker_port
, n
);
1702 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port
*rocker_port
,
1703 const unsigned char *addr
,
1706 struct rocker_world_ops
*wops
= rocker_port
->rocker
->wops
;
1708 if (!wops
->port_ev_mac_vlan_seen
)
1710 return wops
->port_ev_mac_vlan_seen(rocker_port
, addr
, vlan_id
);
1713 static int rocker_world_fib4_add(struct rocker
*rocker
,
1714 const struct fib_entry_notifier_info
*fen_info
)
1716 struct rocker_world_ops
*wops
= rocker
->wops
;
1718 if (!wops
->fib4_add
)
1720 return wops
->fib4_add(rocker
, fen_info
);
1723 static int rocker_world_fib4_del(struct rocker
*rocker
,
1724 const struct fib_entry_notifier_info
*fen_info
)
1726 struct rocker_world_ops
*wops
= rocker
->wops
;
1728 if (!wops
->fib4_del
)
1730 return wops
->fib4_del(rocker
, fen_info
);
1733 static void rocker_world_fib4_abort(struct rocker
*rocker
)
1735 struct rocker_world_ops
*wops
= rocker
->wops
;
1737 if (wops
->fib4_abort
)
1738 wops
->fib4_abort(rocker
);
1745 static int rocker_port_open(struct net_device
*dev
)
1747 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1750 err
= rocker_port_dma_rings_init(rocker_port
);
1754 err
= request_irq(rocker_msix_tx_vector(rocker_port
),
1755 rocker_tx_irq_handler
, 0,
1756 rocker_driver_name
, rocker_port
);
1758 netdev_err(rocker_port
->dev
, "cannot assign tx irq\n");
1759 goto err_request_tx_irq
;
1762 err
= request_irq(rocker_msix_rx_vector(rocker_port
),
1763 rocker_rx_irq_handler
, 0,
1764 rocker_driver_name
, rocker_port
);
1766 netdev_err(rocker_port
->dev
, "cannot assign rx irq\n");
1767 goto err_request_rx_irq
;
1770 err
= rocker_world_port_open(rocker_port
);
1772 netdev_err(rocker_port
->dev
, "cannot open port in world\n");
1773 goto err_world_port_open
;
1776 napi_enable(&rocker_port
->napi_tx
);
1777 napi_enable(&rocker_port
->napi_rx
);
1778 if (!dev
->proto_down
)
1779 rocker_port_set_enable(rocker_port
, true);
1780 netif_start_queue(dev
);
1783 err_world_port_open
:
1784 free_irq(rocker_msix_rx_vector(rocker_port
), rocker_port
);
1786 free_irq(rocker_msix_tx_vector(rocker_port
), rocker_port
);
1788 rocker_port_dma_rings_fini(rocker_port
);
1792 static int rocker_port_stop(struct net_device
*dev
)
1794 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1796 netif_stop_queue(dev
);
1797 rocker_port_set_enable(rocker_port
, false);
1798 napi_disable(&rocker_port
->napi_rx
);
1799 napi_disable(&rocker_port
->napi_tx
);
1800 rocker_world_port_stop(rocker_port
);
1801 free_irq(rocker_msix_rx_vector(rocker_port
), rocker_port
);
1802 free_irq(rocker_msix_tx_vector(rocker_port
), rocker_port
);
1803 rocker_port_dma_rings_fini(rocker_port
);
1808 static void rocker_tx_desc_frags_unmap(const struct rocker_port
*rocker_port
,
1809 const struct rocker_desc_info
*desc_info
)
1811 const struct rocker
*rocker
= rocker_port
->rocker
;
1812 struct pci_dev
*pdev
= rocker
->pdev
;
1813 const struct rocker_tlv
*attrs
[ROCKER_TLV_TX_MAX
+ 1];
1814 struct rocker_tlv
*attr
;
1817 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_TX_MAX
, desc_info
);
1818 if (!attrs
[ROCKER_TLV_TX_FRAGS
])
1820 rocker_tlv_for_each_nested(attr
, attrs
[ROCKER_TLV_TX_FRAGS
], rem
) {
1821 const struct rocker_tlv
*frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_MAX
+ 1];
1822 dma_addr_t dma_handle
;
1825 if (rocker_tlv_type(attr
) != ROCKER_TLV_TX_FRAG
)
1827 rocker_tlv_parse_nested(frag_attrs
, ROCKER_TLV_TX_FRAG_ATTR_MAX
,
1829 if (!frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_ADDR
] ||
1830 !frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_LEN
])
1832 dma_handle
= rocker_tlv_get_u64(frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_ADDR
]);
1833 len
= rocker_tlv_get_u16(frag_attrs
[ROCKER_TLV_TX_FRAG_ATTR_LEN
]);
1834 pci_unmap_single(pdev
, dma_handle
, len
, DMA_TO_DEVICE
);
1838 static int rocker_tx_desc_frag_map_put(const struct rocker_port
*rocker_port
,
1839 struct rocker_desc_info
*desc_info
,
1840 char *buf
, size_t buf_len
)
1842 const struct rocker
*rocker
= rocker_port
->rocker
;
1843 struct pci_dev
*pdev
= rocker
->pdev
;
1844 dma_addr_t dma_handle
;
1845 struct rocker_tlv
*frag
;
1847 dma_handle
= pci_map_single(pdev
, buf
, buf_len
, DMA_TO_DEVICE
);
1848 if (unlikely(pci_dma_mapping_error(pdev
, dma_handle
))) {
1849 if (net_ratelimit())
1850 netdev_err(rocker_port
->dev
, "failed to dma map tx frag\n");
1853 frag
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_TX_FRAG
);
1856 if (rocker_tlv_put_u64(desc_info
, ROCKER_TLV_TX_FRAG_ATTR_ADDR
,
1859 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_TX_FRAG_ATTR_LEN
,
1862 rocker_tlv_nest_end(desc_info
, frag
);
1866 rocker_tlv_nest_cancel(desc_info
, frag
);
1868 pci_unmap_single(pdev
, dma_handle
, buf_len
, DMA_TO_DEVICE
);
1872 static netdev_tx_t
rocker_port_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1874 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1875 struct rocker
*rocker
= rocker_port
->rocker
;
1876 struct rocker_desc_info
*desc_info
;
1877 struct rocker_tlv
*frags
;
1881 desc_info
= rocker_desc_head_get(&rocker_port
->tx_ring
);
1882 if (unlikely(!desc_info
)) {
1883 if (net_ratelimit())
1884 netdev_err(dev
, "tx ring full when queue awake\n");
1885 return NETDEV_TX_BUSY
;
1888 rocker_desc_cookie_ptr_set(desc_info
, skb
);
1890 frags
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_TX_FRAGS
);
1893 err
= rocker_tx_desc_frag_map_put(rocker_port
, desc_info
,
1894 skb
->data
, skb_headlen(skb
));
1897 if (skb_shinfo(skb
)->nr_frags
> ROCKER_TX_FRAGS_MAX
) {
1898 err
= skb_linearize(skb
);
1903 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1904 const skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
1906 err
= rocker_tx_desc_frag_map_put(rocker_port
, desc_info
,
1907 skb_frag_address(frag
),
1908 skb_frag_size(frag
));
1912 rocker_tlv_nest_end(desc_info
, frags
);
1914 rocker_desc_gen_clear(desc_info
);
1915 rocker_desc_head_set(rocker
, &rocker_port
->tx_ring
, desc_info
);
1917 desc_info
= rocker_desc_head_get(&rocker_port
->tx_ring
);
1919 netif_stop_queue(dev
);
1921 return NETDEV_TX_OK
;
1924 rocker_tx_desc_frags_unmap(rocker_port
, desc_info
);
1926 rocker_tlv_nest_cancel(desc_info
, frags
);
1929 dev
->stats
.tx_dropped
++;
1931 return NETDEV_TX_OK
;
1934 static int rocker_port_set_mac_address(struct net_device
*dev
, void *p
)
1936 struct sockaddr
*addr
= p
;
1937 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1940 if (!is_valid_ether_addr(addr
->sa_data
))
1941 return -EADDRNOTAVAIL
;
1943 err
= rocker_cmd_set_port_settings_macaddr(rocker_port
, addr
->sa_data
);
1946 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1950 static int rocker_port_change_mtu(struct net_device
*dev
, int new_mtu
)
1952 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1953 int running
= netif_running(dev
);
1957 rocker_port_stop(dev
);
1959 netdev_info(dev
, "MTU change from %d to %d\n", dev
->mtu
, new_mtu
);
1962 err
= rocker_cmd_set_port_settings_mtu(rocker_port
, new_mtu
);
1967 err
= rocker_port_open(dev
);
1972 static int rocker_port_get_phys_port_name(struct net_device
*dev
,
1973 char *buf
, size_t len
)
1975 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1976 struct port_name name
= { .buf
= buf
, .len
= len
};
1979 err
= rocker_cmd_exec(rocker_port
, false,
1980 rocker_cmd_get_port_settings_prep
, NULL
,
1981 rocker_cmd_get_port_settings_phys_name_proc
,
1984 return err
? -EOPNOTSUPP
: 0;
1987 static int rocker_port_change_proto_down(struct net_device
*dev
,
1990 struct rocker_port
*rocker_port
= netdev_priv(dev
);
1992 if (rocker_port
->dev
->flags
& IFF_UP
)
1993 rocker_port_set_enable(rocker_port
, !proto_down
);
1994 rocker_port
->dev
->proto_down
= proto_down
;
1998 static void rocker_port_neigh_destroy(struct net_device
*dev
,
1999 struct neighbour
*n
)
2001 struct rocker_port
*rocker_port
= netdev_priv(n
->dev
);
2004 err
= rocker_world_port_neigh_destroy(rocker_port
, n
);
2006 netdev_warn(rocker_port
->dev
, "failed to handle neigh destroy (err %d)\n",
2010 static const struct net_device_ops rocker_port_netdev_ops
= {
2011 .ndo_open
= rocker_port_open
,
2012 .ndo_stop
= rocker_port_stop
,
2013 .ndo_start_xmit
= rocker_port_xmit
,
2014 .ndo_set_mac_address
= rocker_port_set_mac_address
,
2015 .ndo_change_mtu
= rocker_port_change_mtu
,
2016 .ndo_bridge_getlink
= switchdev_port_bridge_getlink
,
2017 .ndo_bridge_setlink
= switchdev_port_bridge_setlink
,
2018 .ndo_bridge_dellink
= switchdev_port_bridge_dellink
,
2019 .ndo_fdb_add
= switchdev_port_fdb_add
,
2020 .ndo_fdb_del
= switchdev_port_fdb_del
,
2021 .ndo_fdb_dump
= switchdev_port_fdb_dump
,
2022 .ndo_get_phys_port_name
= rocker_port_get_phys_port_name
,
2023 .ndo_change_proto_down
= rocker_port_change_proto_down
,
2024 .ndo_neigh_destroy
= rocker_port_neigh_destroy
,
2027 /********************
2029 ********************/
2031 static int rocker_port_attr_get(struct net_device
*dev
,
2032 struct switchdev_attr
*attr
)
2034 const struct rocker_port
*rocker_port
= netdev_priv(dev
);
2035 const struct rocker
*rocker
= rocker_port
->rocker
;
2039 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID
:
2040 attr
->u
.ppid
.id_len
= sizeof(rocker
->hw
.id
);
2041 memcpy(&attr
->u
.ppid
.id
, &rocker
->hw
.id
, attr
->u
.ppid
.id_len
);
2043 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
2044 err
= rocker_world_port_attr_bridge_flags_get(rocker_port
,
2045 &attr
->u
.brport_flags
);
2054 static int rocker_port_attr_set(struct net_device
*dev
,
2055 const struct switchdev_attr
*attr
,
2056 struct switchdev_trans
*trans
)
2058 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2062 case SWITCHDEV_ATTR_ID_PORT_STP_STATE
:
2063 err
= rocker_world_port_attr_stp_state_set(rocker_port
,
2067 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
:
2068 err
= rocker_world_port_attr_bridge_flags_set(rocker_port
,
2069 attr
->u
.brport_flags
,
2072 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME
:
2073 err
= rocker_world_port_attr_bridge_ageing_time_set(rocker_port
,
2074 attr
->u
.ageing_time
,
2085 static int rocker_port_obj_add(struct net_device
*dev
,
2086 const struct switchdev_obj
*obj
,
2087 struct switchdev_trans
*trans
)
2089 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2093 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
2094 err
= rocker_world_port_obj_vlan_add(rocker_port
,
2095 SWITCHDEV_OBJ_PORT_VLAN(obj
),
2098 case SWITCHDEV_OBJ_ID_PORT_FDB
:
2099 err
= rocker_world_port_obj_fdb_add(rocker_port
,
2100 SWITCHDEV_OBJ_PORT_FDB(obj
),
2111 static int rocker_port_obj_del(struct net_device
*dev
,
2112 const struct switchdev_obj
*obj
)
2114 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2118 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
2119 err
= rocker_world_port_obj_vlan_del(rocker_port
,
2120 SWITCHDEV_OBJ_PORT_VLAN(obj
));
2122 case SWITCHDEV_OBJ_ID_PORT_FDB
:
2123 err
= rocker_world_port_obj_fdb_del(rocker_port
,
2124 SWITCHDEV_OBJ_PORT_FDB(obj
));
2134 static int rocker_port_obj_dump(struct net_device
*dev
,
2135 struct switchdev_obj
*obj
,
2136 switchdev_obj_dump_cb_t
*cb
)
2138 const struct rocker_port
*rocker_port
= netdev_priv(dev
);
2142 case SWITCHDEV_OBJ_ID_PORT_FDB
:
2143 err
= rocker_world_port_obj_fdb_dump(rocker_port
,
2144 SWITCHDEV_OBJ_PORT_FDB(obj
),
2147 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
2148 err
= rocker_world_port_obj_vlan_dump(rocker_port
,
2149 SWITCHDEV_OBJ_PORT_VLAN(obj
),
2160 static const struct switchdev_ops rocker_port_switchdev_ops
= {
2161 .switchdev_port_attr_get
= rocker_port_attr_get
,
2162 .switchdev_port_attr_set
= rocker_port_attr_set
,
2163 .switchdev_port_obj_add
= rocker_port_obj_add
,
2164 .switchdev_port_obj_del
= rocker_port_obj_del
,
2165 .switchdev_port_obj_dump
= rocker_port_obj_dump
,
2168 static int rocker_router_fib_event(struct notifier_block
*nb
,
2169 unsigned long event
, void *ptr
)
2171 struct rocker
*rocker
= container_of(nb
, struct rocker
, fib_nb
);
2172 struct fib_entry_notifier_info
*fen_info
= ptr
;
2176 case FIB_EVENT_ENTRY_ADD
:
2177 err
= rocker_world_fib4_add(rocker
, fen_info
);
2179 rocker_world_fib4_abort(rocker
);
2182 case FIB_EVENT_ENTRY_DEL
:
2183 rocker_world_fib4_del(rocker
, fen_info
);
2185 case FIB_EVENT_RULE_ADD
: /* fall through */
2186 case FIB_EVENT_RULE_DEL
:
2187 rocker_world_fib4_abort(rocker
);
2193 /********************
2195 ********************/
2197 static int rocker_port_get_settings(struct net_device
*dev
,
2198 struct ethtool_cmd
*ecmd
)
2200 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2202 return rocker_cmd_get_port_settings_ethtool(rocker_port
, ecmd
);
2205 static int rocker_port_set_settings(struct net_device
*dev
,
2206 struct ethtool_cmd
*ecmd
)
2208 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2210 return rocker_cmd_set_port_settings_ethtool(rocker_port
, ecmd
);
2213 static void rocker_port_get_drvinfo(struct net_device
*dev
,
2214 struct ethtool_drvinfo
*drvinfo
)
2216 strlcpy(drvinfo
->driver
, rocker_driver_name
, sizeof(drvinfo
->driver
));
2217 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
2220 static struct rocker_port_stats
{
2221 char str
[ETH_GSTRING_LEN
];
2223 } rocker_port_stats
[] = {
2224 { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS
, },
2225 { "rx_bytes", ROCKER_TLV_CMD_PORT_STATS_RX_BYTES
, },
2226 { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED
, },
2227 { "rx_errors", ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS
, },
2229 { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS
, },
2230 { "tx_bytes", ROCKER_TLV_CMD_PORT_STATS_TX_BYTES
, },
2231 { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED
, },
2232 { "tx_errors", ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS
, },
2235 #define ROCKER_PORT_STATS_LEN ARRAY_SIZE(rocker_port_stats)
2237 static void rocker_port_get_strings(struct net_device
*netdev
, u32 stringset
,
2243 switch (stringset
) {
2245 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); i
++) {
2246 memcpy(p
, rocker_port_stats
[i
].str
, ETH_GSTRING_LEN
);
2247 p
+= ETH_GSTRING_LEN
;
2254 rocker_cmd_get_port_stats_prep(const struct rocker_port
*rocker_port
,
2255 struct rocker_desc_info
*desc_info
,
2258 struct rocker_tlv
*cmd_stats
;
2260 if (rocker_tlv_put_u16(desc_info
, ROCKER_TLV_CMD_TYPE
,
2261 ROCKER_TLV_CMD_TYPE_GET_PORT_STATS
))
2264 cmd_stats
= rocker_tlv_nest_start(desc_info
, ROCKER_TLV_CMD_INFO
);
2268 if (rocker_tlv_put_u32(desc_info
, ROCKER_TLV_CMD_PORT_STATS_PPORT
,
2269 rocker_port
->pport
))
2272 rocker_tlv_nest_end(desc_info
, cmd_stats
);
2278 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port
*rocker_port
,
2279 const struct rocker_desc_info
*desc_info
,
2282 const struct rocker_tlv
*attrs
[ROCKER_TLV_CMD_MAX
+ 1];
2283 const struct rocker_tlv
*stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_MAX
+ 1];
2284 const struct rocker_tlv
*pattr
;
2289 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_CMD_MAX
, desc_info
);
2291 if (!attrs
[ROCKER_TLV_CMD_INFO
])
2294 rocker_tlv_parse_nested(stats_attrs
, ROCKER_TLV_CMD_PORT_STATS_MAX
,
2295 attrs
[ROCKER_TLV_CMD_INFO
]);
2297 if (!stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_PPORT
])
2300 pport
= rocker_tlv_get_u32(stats_attrs
[ROCKER_TLV_CMD_PORT_STATS_PPORT
]);
2301 if (pport
!= rocker_port
->pport
)
2304 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); i
++) {
2305 pattr
= stats_attrs
[rocker_port_stats
[i
].type
];
2309 data
[i
] = rocker_tlv_get_u64(pattr
);
2315 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port
*rocker_port
,
2318 return rocker_cmd_exec(rocker_port
, false,
2319 rocker_cmd_get_port_stats_prep
, NULL
,
2320 rocker_cmd_get_port_stats_ethtool_proc
,
2324 static void rocker_port_get_stats(struct net_device
*dev
,
2325 struct ethtool_stats
*stats
, u64
*data
)
2327 struct rocker_port
*rocker_port
= netdev_priv(dev
);
2329 if (rocker_cmd_get_port_stats_ethtool(rocker_port
, data
) != 0) {
2332 for (i
= 0; i
< ARRAY_SIZE(rocker_port_stats
); ++i
)
2337 static int rocker_port_get_sset_count(struct net_device
*netdev
, int sset
)
2341 return ROCKER_PORT_STATS_LEN
;
2347 static const struct ethtool_ops rocker_port_ethtool_ops
= {
2348 .get_settings
= rocker_port_get_settings
,
2349 .set_settings
= rocker_port_set_settings
,
2350 .get_drvinfo
= rocker_port_get_drvinfo
,
2351 .get_link
= ethtool_op_get_link
,
2352 .get_strings
= rocker_port_get_strings
,
2353 .get_ethtool_stats
= rocker_port_get_stats
,
2354 .get_sset_count
= rocker_port_get_sset_count
,
2361 static struct rocker_port
*rocker_port_napi_tx_get(struct napi_struct
*napi
)
2363 return container_of(napi
, struct rocker_port
, napi_tx
);
2366 static int rocker_port_poll_tx(struct napi_struct
*napi
, int budget
)
2368 struct rocker_port
*rocker_port
= rocker_port_napi_tx_get(napi
);
2369 const struct rocker
*rocker
= rocker_port
->rocker
;
2370 const struct rocker_desc_info
*desc_info
;
2374 /* Cleanup tx descriptors */
2375 while ((desc_info
= rocker_desc_tail_get(&rocker_port
->tx_ring
))) {
2376 struct sk_buff
*skb
;
2378 err
= rocker_desc_err(desc_info
);
2379 if (err
&& net_ratelimit())
2380 netdev_err(rocker_port
->dev
, "tx desc received with err %d\n",
2382 rocker_tx_desc_frags_unmap(rocker_port
, desc_info
);
2384 skb
= rocker_desc_cookie_ptr_get(desc_info
);
2386 rocker_port
->dev
->stats
.tx_packets
++;
2387 rocker_port
->dev
->stats
.tx_bytes
+= skb
->len
;
2389 rocker_port
->dev
->stats
.tx_errors
++;
2392 dev_kfree_skb_any(skb
);
2396 if (credits
&& netif_queue_stopped(rocker_port
->dev
))
2397 netif_wake_queue(rocker_port
->dev
);
2399 napi_complete(napi
);
2400 rocker_dma_ring_credits_set(rocker
, &rocker_port
->tx_ring
, credits
);
2405 static int rocker_port_rx_proc(const struct rocker
*rocker
,
2406 const struct rocker_port
*rocker_port
,
2407 struct rocker_desc_info
*desc_info
)
2409 const struct rocker_tlv
*attrs
[ROCKER_TLV_RX_MAX
+ 1];
2410 struct sk_buff
*skb
= rocker_desc_cookie_ptr_get(desc_info
);
2417 rocker_tlv_parse_desc(attrs
, ROCKER_TLV_RX_MAX
, desc_info
);
2418 if (!attrs
[ROCKER_TLV_RX_FRAG_LEN
])
2420 if (attrs
[ROCKER_TLV_RX_FLAGS
])
2421 rx_flags
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FLAGS
]);
2423 rocker_dma_rx_ring_skb_unmap(rocker
, attrs
);
2425 rx_len
= rocker_tlv_get_u16(attrs
[ROCKER_TLV_RX_FRAG_LEN
]);
2426 skb_put(skb
, rx_len
);
2427 skb
->protocol
= eth_type_trans(skb
, rocker_port
->dev
);
2429 if (rx_flags
& ROCKER_RX_FLAGS_FWD_OFFLOAD
)
2430 skb
->offload_fwd_mark
= 1;
2432 rocker_port
->dev
->stats
.rx_packets
++;
2433 rocker_port
->dev
->stats
.rx_bytes
+= skb
->len
;
2435 netif_receive_skb(skb
);
2437 return rocker_dma_rx_ring_skb_alloc(rocker_port
, desc_info
);
2440 static struct rocker_port
*rocker_port_napi_rx_get(struct napi_struct
*napi
)
2442 return container_of(napi
, struct rocker_port
, napi_rx
);
2445 static int rocker_port_poll_rx(struct napi_struct
*napi
, int budget
)
2447 struct rocker_port
*rocker_port
= rocker_port_napi_rx_get(napi
);
2448 const struct rocker
*rocker
= rocker_port
->rocker
;
2449 struct rocker_desc_info
*desc_info
;
2453 /* Process rx descriptors */
2454 while (credits
< budget
&&
2455 (desc_info
= rocker_desc_tail_get(&rocker_port
->rx_ring
))) {
2456 err
= rocker_desc_err(desc_info
);
2458 if (net_ratelimit())
2459 netdev_err(rocker_port
->dev
, "rx desc received with err %d\n",
2462 err
= rocker_port_rx_proc(rocker
, rocker_port
,
2464 if (err
&& net_ratelimit())
2465 netdev_err(rocker_port
->dev
, "rx processing failed with err %d\n",
2469 rocker_port
->dev
->stats
.rx_errors
++;
2471 rocker_desc_gen_clear(desc_info
);
2472 rocker_desc_head_set(rocker
, &rocker_port
->rx_ring
, desc_info
);
2476 if (credits
< budget
)
2477 napi_complete(napi
);
2479 rocker_dma_ring_credits_set(rocker
, &rocker_port
->rx_ring
, credits
);
2488 static void rocker_carrier_init(const struct rocker_port
*rocker_port
)
2490 const struct rocker
*rocker
= rocker_port
->rocker
;
2491 u64 link_status
= rocker_read64(rocker
, PORT_PHYS_LINK_STATUS
);
2494 link_up
= link_status
& (1 << rocker_port
->pport
);
2496 netif_carrier_on(rocker_port
->dev
);
2498 netif_carrier_off(rocker_port
->dev
);
2501 static void rocker_remove_ports(struct rocker
*rocker
)
2503 struct rocker_port
*rocker_port
;
2506 for (i
= 0; i
< rocker
->port_count
; i
++) {
2507 rocker_port
= rocker
->ports
[i
];
2510 rocker_world_port_fini(rocker_port
);
2511 unregister_netdev(rocker_port
->dev
);
2512 rocker_world_port_post_fini(rocker_port
);
2513 free_netdev(rocker_port
->dev
);
2515 rocker_world_fini(rocker
);
2516 kfree(rocker
->ports
);
2519 static void rocker_port_dev_addr_init(struct rocker_port
*rocker_port
)
2521 const struct rocker
*rocker
= rocker_port
->rocker
;
2522 const struct pci_dev
*pdev
= rocker
->pdev
;
2525 err
= rocker_cmd_get_port_settings_macaddr(rocker_port
,
2526 rocker_port
->dev
->dev_addr
);
2528 dev_warn(&pdev
->dev
, "failed to get mac address, using random\n");
2529 eth_hw_addr_random(rocker_port
->dev
);
2533 #define ROCKER_PORT_MIN_MTU ETH_MIN_MTU
2534 #define ROCKER_PORT_MAX_MTU 9000
2535 static int rocker_probe_port(struct rocker
*rocker
, unsigned int port_number
)
2537 struct pci_dev
*pdev
= rocker
->pdev
;
2538 struct rocker_port
*rocker_port
;
2539 struct net_device
*dev
;
2542 dev
= alloc_etherdev(sizeof(struct rocker_port
));
2545 SET_NETDEV_DEV(dev
, &pdev
->dev
);
2546 rocker_port
= netdev_priv(dev
);
2547 rocker_port
->dev
= dev
;
2548 rocker_port
->rocker
= rocker
;
2549 rocker_port
->port_number
= port_number
;
2550 rocker_port
->pport
= port_number
+ 1;
2552 err
= rocker_world_check_init(rocker_port
);
2554 dev_err(&pdev
->dev
, "world init failed\n");
2555 goto err_world_check_init
;
2558 rocker_port_dev_addr_init(rocker_port
);
2559 dev
->netdev_ops
= &rocker_port_netdev_ops
;
2560 dev
->ethtool_ops
= &rocker_port_ethtool_ops
;
2561 dev
->switchdev_ops
= &rocker_port_switchdev_ops
;
2562 netif_tx_napi_add(dev
, &rocker_port
->napi_tx
, rocker_port_poll_tx
,
2564 netif_napi_add(dev
, &rocker_port
->napi_rx
, rocker_port_poll_rx
,
2566 rocker_carrier_init(rocker_port
);
2568 dev
->features
|= NETIF_F_NETNS_LOCAL
| NETIF_F_SG
;
2570 /* MTU range: 68 - 9000 */
2571 dev
->min_mtu
= ROCKER_PORT_MIN_MTU
;
2572 dev
->max_mtu
= ROCKER_PORT_MAX_MTU
;
2574 err
= rocker_world_port_pre_init(rocker_port
);
2576 dev_err(&pdev
->dev
, "port world pre-init failed\n");
2577 goto err_world_port_pre_init
;
2579 err
= register_netdev(dev
);
2581 dev_err(&pdev
->dev
, "register_netdev failed\n");
2582 goto err_register_netdev
;
2584 rocker
->ports
[port_number
] = rocker_port
;
2586 err
= rocker_world_port_init(rocker_port
);
2588 dev_err(&pdev
->dev
, "port world init failed\n");
2589 goto err_world_port_init
;
2594 err_world_port_init
:
2595 rocker
->ports
[port_number
] = NULL
;
2596 unregister_netdev(dev
);
2597 err_register_netdev
:
2598 rocker_world_port_post_fini(rocker_port
);
2599 err_world_port_pre_init
:
2600 err_world_check_init
:
2605 static int rocker_probe_ports(struct rocker
*rocker
)
2611 alloc_size
= sizeof(struct rocker_port
*) * rocker
->port_count
;
2612 rocker
->ports
= kzalloc(alloc_size
, GFP_KERNEL
);
2615 for (i
= 0; i
< rocker
->port_count
; i
++) {
2616 err
= rocker_probe_port(rocker
, i
);
2623 rocker_remove_ports(rocker
);
2627 static int rocker_msix_init(struct rocker
*rocker
)
2629 struct pci_dev
*pdev
= rocker
->pdev
;
2634 msix_entries
= pci_msix_vec_count(pdev
);
2635 if (msix_entries
< 0)
2636 return msix_entries
;
2638 if (msix_entries
!= ROCKER_MSIX_VEC_COUNT(rocker
->port_count
))
2641 rocker
->msix_entries
= kmalloc_array(msix_entries
,
2642 sizeof(struct msix_entry
),
2644 if (!rocker
->msix_entries
)
2647 for (i
= 0; i
< msix_entries
; i
++)
2648 rocker
->msix_entries
[i
].entry
= i
;
2650 err
= pci_enable_msix_exact(pdev
, rocker
->msix_entries
, msix_entries
);
2652 goto err_enable_msix
;
2657 kfree(rocker
->msix_entries
);
2661 static void rocker_msix_fini(const struct rocker
*rocker
)
2663 pci_disable_msix(rocker
->pdev
);
2664 kfree(rocker
->msix_entries
);
2667 static int rocker_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
2669 struct rocker
*rocker
;
2672 rocker
= kzalloc(sizeof(*rocker
), GFP_KERNEL
);
2676 err
= pci_enable_device(pdev
);
2678 dev_err(&pdev
->dev
, "pci_enable_device failed\n");
2679 goto err_pci_enable_device
;
2682 err
= pci_request_regions(pdev
, rocker_driver_name
);
2684 dev_err(&pdev
->dev
, "pci_request_regions failed\n");
2685 goto err_pci_request_regions
;
2688 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(64));
2690 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64));
2692 dev_err(&pdev
->dev
, "pci_set_consistent_dma_mask failed\n");
2693 goto err_pci_set_dma_mask
;
2696 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2698 dev_err(&pdev
->dev
, "pci_set_dma_mask failed\n");
2699 goto err_pci_set_dma_mask
;
2703 if (pci_resource_len(pdev
, 0) < ROCKER_PCI_BAR0_SIZE
) {
2704 dev_err(&pdev
->dev
, "invalid PCI region size\n");
2706 goto err_pci_resource_len_check
;
2709 rocker
->hw_addr
= ioremap(pci_resource_start(pdev
, 0),
2710 pci_resource_len(pdev
, 0));
2711 if (!rocker
->hw_addr
) {
2712 dev_err(&pdev
->dev
, "ioremap failed\n");
2716 pci_set_master(pdev
);
2718 rocker
->pdev
= pdev
;
2719 pci_set_drvdata(pdev
, rocker
);
2721 rocker
->port_count
= rocker_read32(rocker
, PORT_PHYS_COUNT
);
2723 err
= rocker_msix_init(rocker
);
2725 dev_err(&pdev
->dev
, "MSI-X init failed\n");
2729 err
= rocker_basic_hw_test(rocker
);
2731 dev_err(&pdev
->dev
, "basic hw test failed\n");
2732 goto err_basic_hw_test
;
2735 rocker_write32(rocker
, CONTROL
, ROCKER_CONTROL_RESET
);
2737 err
= rocker_dma_rings_init(rocker
);
2739 goto err_dma_rings_init
;
2741 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
),
2742 rocker_cmd_irq_handler
, 0,
2743 rocker_driver_name
, rocker
);
2745 dev_err(&pdev
->dev
, "cannot assign cmd irq\n");
2746 goto err_request_cmd_irq
;
2749 err
= request_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
),
2750 rocker_event_irq_handler
, 0,
2751 rocker_driver_name
, rocker
);
2753 dev_err(&pdev
->dev
, "cannot assign event irq\n");
2754 goto err_request_event_irq
;
2757 rocker
->hw
.id
= rocker_read64(rocker
, SWITCH_ID
);
2759 err
= rocker_probe_ports(rocker
);
2761 dev_err(&pdev
->dev
, "failed to probe ports\n");
2762 goto err_probe_ports
;
2765 rocker
->fib_nb
.notifier_call
= rocker_router_fib_event
;
2766 register_fib_notifier(&rocker
->fib_nb
);
2768 dev_info(&pdev
->dev
, "Rocker switch with id %*phN\n",
2769 (int)sizeof(rocker
->hw
.id
), &rocker
->hw
.id
);
2774 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
), rocker
);
2775 err_request_event_irq
:
2776 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
), rocker
);
2777 err_request_cmd_irq
:
2778 rocker_dma_rings_fini(rocker
);
2781 rocker_msix_fini(rocker
);
2783 iounmap(rocker
->hw_addr
);
2785 err_pci_resource_len_check
:
2786 err_pci_set_dma_mask
:
2787 pci_release_regions(pdev
);
2788 err_pci_request_regions
:
2789 pci_disable_device(pdev
);
2790 err_pci_enable_device
:
2795 static void rocker_remove(struct pci_dev
*pdev
)
2797 struct rocker
*rocker
= pci_get_drvdata(pdev
);
2799 unregister_fib_notifier(&rocker
->fib_nb
);
2800 rocker_write32(rocker
, CONTROL
, ROCKER_CONTROL_RESET
);
2801 rocker_remove_ports(rocker
);
2802 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_EVENT
), rocker
);
2803 free_irq(rocker_msix_vector(rocker
, ROCKER_MSIX_VEC_CMD
), rocker
);
2804 rocker_dma_rings_fini(rocker
);
2805 rocker_msix_fini(rocker
);
2806 iounmap(rocker
->hw_addr
);
2807 pci_release_regions(rocker
->pdev
);
2808 pci_disable_device(rocker
->pdev
);
2812 static struct pci_driver rocker_pci_driver
= {
2813 .name
= rocker_driver_name
,
2814 .id_table
= rocker_pci_id_table
,
2815 .probe
= rocker_probe
,
2816 .remove
= rocker_remove
,
2819 /************************************
2820 * Net device notifier event handler
2821 ************************************/
2823 static bool rocker_port_dev_check(const struct net_device
*dev
)
2825 return dev
->netdev_ops
== &rocker_port_netdev_ops
;
2828 static bool rocker_port_dev_check_under(const struct net_device
*dev
,
2829 struct rocker
*rocker
)
2831 struct rocker_port
*rocker_port
;
2833 if (!rocker_port_dev_check(dev
))
2836 rocker_port
= netdev_priv(dev
);
2837 if (rocker_port
->rocker
!= rocker
)
2843 struct rocker_walk_data
{
2844 struct rocker
*rocker
;
2845 struct rocker_port
*port
;
2848 static int rocker_lower_dev_walk(struct net_device
*lower_dev
, void *_data
)
2850 struct rocker_walk_data
*data
= _data
;
2853 if (rocker_port_dev_check_under(lower_dev
, data
->rocker
)) {
2854 data
->port
= netdev_priv(lower_dev
);
2861 struct rocker_port
*rocker_port_dev_lower_find(struct net_device
*dev
,
2862 struct rocker
*rocker
)
2864 struct rocker_walk_data data
;
2866 if (rocker_port_dev_check_under(dev
, rocker
))
2867 return netdev_priv(dev
);
2869 data
.rocker
= rocker
;
2871 netdev_walk_all_lower_dev(dev
, rocker_lower_dev_walk
, &data
);
2876 static int rocker_netdevice_event(struct notifier_block
*unused
,
2877 unsigned long event
, void *ptr
)
2879 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
2880 struct netdev_notifier_changeupper_info
*info
;
2881 struct rocker_port
*rocker_port
;
2884 if (!rocker_port_dev_check(dev
))
2888 case NETDEV_CHANGEUPPER
:
2892 rocker_port
= netdev_priv(dev
);
2893 if (info
->linking
) {
2894 err
= rocker_world_port_master_linked(rocker_port
,
2897 netdev_warn(dev
, "failed to reflect master linked (err %d)\n",
2900 err
= rocker_world_port_master_unlinked(rocker_port
,
2903 netdev_warn(dev
, "failed to reflect master unlinked (err %d)\n",
2911 static struct notifier_block rocker_netdevice_nb __read_mostly
= {
2912 .notifier_call
= rocker_netdevice_event
,
2915 /************************************
2916 * Net event notifier event handler
2917 ************************************/
2919 static int rocker_netevent_event(struct notifier_block
*unused
,
2920 unsigned long event
, void *ptr
)
2922 struct rocker_port
*rocker_port
;
2923 struct net_device
*dev
;
2924 struct neighbour
*n
= ptr
;
2928 case NETEVENT_NEIGH_UPDATE
:
2929 if (n
->tbl
!= &arp_tbl
)
2932 if (!rocker_port_dev_check(dev
))
2934 rocker_port
= netdev_priv(dev
);
2935 err
= rocker_world_port_neigh_update(rocker_port
, n
);
2937 netdev_warn(dev
, "failed to handle neigh update (err %d)\n",
2945 static struct notifier_block rocker_netevent_nb __read_mostly
= {
2946 .notifier_call
= rocker_netevent_event
,
2949 /***********************
2950 * Module init and exit
2951 ***********************/
2953 static int __init
rocker_module_init(void)
2957 register_netdevice_notifier(&rocker_netdevice_nb
);
2958 register_netevent_notifier(&rocker_netevent_nb
);
2959 err
= pci_register_driver(&rocker_pci_driver
);
2961 goto err_pci_register_driver
;
2964 err_pci_register_driver
:
2965 unregister_netevent_notifier(&rocker_netevent_nb
);
2966 unregister_netdevice_notifier(&rocker_netdevice_nb
);
2970 static void __exit
rocker_module_exit(void)
2972 unregister_netevent_notifier(&rocker_netevent_nb
);
2973 unregister_netdevice_notifier(&rocker_netdevice_nb
);
2974 pci_unregister_driver(&rocker_pci_driver
);
2977 module_init(rocker_module_init
);
2978 module_exit(rocker_module_exit
);
2980 MODULE_LICENSE("GPL v2");
2981 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
2982 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>");
2983 MODULE_DESCRIPTION("Rocker switch device driver");
2984 MODULE_DEVICE_TABLE(pci
, rocker_pci_id_table
);