1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * drivers/net/ethernet/rocker/rocker.c - Rocker switch device driver 4 * Copyright (c) 2014-2016 Jiri Pirko <jiri@mellanox.com> 5 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com> 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/pci.h> 11 #include <linux/interrupt.h> 12 #include <linux/sched.h> 13 #include <linux/wait.h> 14 #include <linux/spinlock.h> 15 #include <linux/sort.h> 16 #include <linux/random.h> 17 #include <linux/netdevice.h> 18 #include <linux/skbuff.h> 19 #include <linux/socket.h> 20 #include <linux/etherdevice.h> 21 #include <linux/ethtool.h> 22 #include <linux/if_ether.h> 23 #include <linux/if_vlan.h> 24 #include <linux/if_bridge.h> 25 #include <linux/bitops.h> 26 #include <linux/ctype.h> 27 #include <linux/workqueue.h> 28 #include <net/switchdev.h> 29 #include <net/rtnetlink.h> 30 #include <net/netevent.h> 31 #include <net/arp.h> 32 #include <net/fib_rules.h> 33 #include <net/fib_notifier.h> 34 #include <linux/io-64-nonatomic-lo-hi.h> 35 #include <generated/utsrelease.h> 36 37 #include "rocker_hw.h" 38 #include "rocker.h" 39 #include "rocker_tlv.h" 40 41 static const char rocker_driver_name[] = "rocker"; 42 43 static const struct pci_device_id rocker_pci_id_table[] = { 44 {PCI_VDEVICE(REDHAT, PCI_DEVICE_ID_REDHAT_ROCKER), 0}, 45 {0, } 46 }; 47 48 struct rocker_wait { 49 wait_queue_head_t wait; 50 bool done; 51 bool nowait; 52 }; 53 54 static void rocker_wait_reset(struct rocker_wait *wait) 55 { 56 wait->done = false; 57 wait->nowait = false; 58 } 59 60 static void rocker_wait_init(struct rocker_wait *wait) 61 { 62 init_waitqueue_head(&wait->wait); 63 rocker_wait_reset(wait); 64 } 65 66 static struct rocker_wait *rocker_wait_create(void) 67 { 68 struct rocker_wait *wait; 69 70 wait = kzalloc(sizeof(*wait), GFP_KERNEL); 71 if (!wait) 72 return NULL; 73 return wait; 74 } 75 76 static void rocker_wait_destroy(struct rocker_wait *wait) 77 { 78 kfree(wait); 79 } 80 81 static bool rocker_wait_event_timeout(struct rocker_wait *wait, 82 unsigned long timeout) 83 { 84 wait_event_timeout(wait->wait, wait->done, HZ / 10); 85 if (!wait->done) 86 return false; 87 return true; 88 } 89 90 static void rocker_wait_wake_up(struct rocker_wait *wait) 91 { 92 wait->done = true; 93 wake_up(&wait->wait); 94 } 95 96 static u32 rocker_msix_vector(const struct rocker *rocker, unsigned int vector) 97 { 98 return rocker->msix_entries[vector].vector; 99 } 100 101 static u32 rocker_msix_tx_vector(const struct rocker_port *rocker_port) 102 { 103 return rocker_msix_vector(rocker_port->rocker, 104 ROCKER_MSIX_VEC_TX(rocker_port->port_number)); 105 } 106 107 static u32 rocker_msix_rx_vector(const struct rocker_port *rocker_port) 108 { 109 return rocker_msix_vector(rocker_port->rocker, 110 ROCKER_MSIX_VEC_RX(rocker_port->port_number)); 111 } 112 113 #define rocker_write32(rocker, reg, val) \ 114 writel((val), (rocker)->hw_addr + (ROCKER_ ## reg)) 115 #define rocker_read32(rocker, reg) \ 116 readl((rocker)->hw_addr + (ROCKER_ ## reg)) 117 #define rocker_write64(rocker, reg, val) \ 118 writeq((val), (rocker)->hw_addr + (ROCKER_ ## reg)) 119 #define rocker_read64(rocker, reg) \ 120 readq((rocker)->hw_addr + (ROCKER_ ## reg)) 121 122 /***************************** 123 * HW basic testing functions 124 *****************************/ 125 126 static int rocker_reg_test(const struct rocker *rocker) 127 { 128 const struct pci_dev *pdev = rocker->pdev; 129 u64 test_reg; 130 u64 rnd; 131 132 rnd = prandom_u32(); 133 rnd >>= 1; 134 rocker_write32(rocker, TEST_REG, rnd); 135 test_reg = rocker_read32(rocker, TEST_REG); 136 if (test_reg != rnd * 2) { 137 dev_err(&pdev->dev, "unexpected 32bit register value %08llx, expected %08llx\n", 138 test_reg, rnd * 2); 139 return -EIO; 140 } 141 142 rnd = prandom_u32(); 143 rnd <<= 31; 144 rnd |= prandom_u32(); 145 rocker_write64(rocker, TEST_REG64, rnd); 146 test_reg = rocker_read64(rocker, TEST_REG64); 147 if (test_reg != rnd * 2) { 148 dev_err(&pdev->dev, "unexpected 64bit register value %16llx, expected %16llx\n", 149 test_reg, rnd * 2); 150 return -EIO; 151 } 152 153 return 0; 154 } 155 156 static int rocker_dma_test_one(const struct rocker *rocker, 157 struct rocker_wait *wait, u32 test_type, 158 dma_addr_t dma_handle, const unsigned char *buf, 159 const unsigned char *expect, size_t size) 160 { 161 const struct pci_dev *pdev = rocker->pdev; 162 int i; 163 164 rocker_wait_reset(wait); 165 rocker_write32(rocker, TEST_DMA_CTRL, test_type); 166 167 if (!rocker_wait_event_timeout(wait, HZ / 10)) { 168 dev_err(&pdev->dev, "no interrupt received within a timeout\n"); 169 return -EIO; 170 } 171 172 for (i = 0; i < size; i++) { 173 if (buf[i] != expect[i]) { 174 dev_err(&pdev->dev, "unexpected memory content %02x at byte %x\n, %02x expected", 175 buf[i], i, expect[i]); 176 return -EIO; 177 } 178 } 179 return 0; 180 } 181 182 #define ROCKER_TEST_DMA_BUF_SIZE (PAGE_SIZE * 4) 183 #define ROCKER_TEST_DMA_FILL_PATTERN 0x96 184 185 static int rocker_dma_test_offset(const struct rocker *rocker, 186 struct rocker_wait *wait, int offset) 187 { 188 struct pci_dev *pdev = rocker->pdev; 189 unsigned char *alloc; 190 unsigned char *buf; 191 unsigned char *expect; 192 dma_addr_t dma_handle; 193 int i; 194 int err; 195 196 alloc = kzalloc(ROCKER_TEST_DMA_BUF_SIZE * 2 + offset, 197 GFP_KERNEL | GFP_DMA); 198 if (!alloc) 199 return -ENOMEM; 200 buf = alloc + offset; 201 expect = buf + ROCKER_TEST_DMA_BUF_SIZE; 202 203 dma_handle = dma_map_single(&pdev->dev, buf, ROCKER_TEST_DMA_BUF_SIZE, 204 DMA_BIDIRECTIONAL); 205 if (dma_mapping_error(&pdev->dev, dma_handle)) { 206 err = -EIO; 207 goto free_alloc; 208 } 209 210 rocker_write64(rocker, TEST_DMA_ADDR, dma_handle); 211 rocker_write32(rocker, TEST_DMA_SIZE, ROCKER_TEST_DMA_BUF_SIZE); 212 213 memset(expect, ROCKER_TEST_DMA_FILL_PATTERN, ROCKER_TEST_DMA_BUF_SIZE); 214 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_FILL, 215 dma_handle, buf, expect, 216 ROCKER_TEST_DMA_BUF_SIZE); 217 if (err) 218 goto unmap; 219 220 memset(expect, 0, ROCKER_TEST_DMA_BUF_SIZE); 221 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_CLEAR, 222 dma_handle, buf, expect, 223 ROCKER_TEST_DMA_BUF_SIZE); 224 if (err) 225 goto unmap; 226 227 prandom_bytes(buf, ROCKER_TEST_DMA_BUF_SIZE); 228 for (i = 0; i < ROCKER_TEST_DMA_BUF_SIZE; i++) 229 expect[i] = ~buf[i]; 230 err = rocker_dma_test_one(rocker, wait, ROCKER_TEST_DMA_CTRL_INVERT, 231 dma_handle, buf, expect, 232 ROCKER_TEST_DMA_BUF_SIZE); 233 if (err) 234 goto unmap; 235 236 unmap: 237 dma_unmap_single(&pdev->dev, dma_handle, ROCKER_TEST_DMA_BUF_SIZE, 238 DMA_BIDIRECTIONAL); 239 free_alloc: 240 kfree(alloc); 241 242 return err; 243 } 244 245 static int rocker_dma_test(const struct rocker *rocker, 246 struct rocker_wait *wait) 247 { 248 int i; 249 int err; 250 251 for (i = 0; i < 8; i++) { 252 err = rocker_dma_test_offset(rocker, wait, i); 253 if (err) 254 return err; 255 } 256 return 0; 257 } 258 259 static irqreturn_t rocker_test_irq_handler(int irq, void *dev_id) 260 { 261 struct rocker_wait *wait = dev_id; 262 263 rocker_wait_wake_up(wait); 264 265 return IRQ_HANDLED; 266 } 267 268 static int rocker_basic_hw_test(const struct rocker *rocker) 269 { 270 const struct pci_dev *pdev = rocker->pdev; 271 struct rocker_wait wait; 272 int err; 273 274 err = rocker_reg_test(rocker); 275 if (err) { 276 dev_err(&pdev->dev, "reg test failed\n"); 277 return err; 278 } 279 280 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_TEST), 281 rocker_test_irq_handler, 0, 282 rocker_driver_name, &wait); 283 if (err) { 284 dev_err(&pdev->dev, "cannot assign test irq\n"); 285 return err; 286 } 287 288 rocker_wait_init(&wait); 289 rocker_write32(rocker, TEST_IRQ, ROCKER_MSIX_VEC_TEST); 290 291 if (!rocker_wait_event_timeout(&wait, HZ / 10)) { 292 dev_err(&pdev->dev, "no interrupt received within a timeout\n"); 293 err = -EIO; 294 goto free_irq; 295 } 296 297 err = rocker_dma_test(rocker, &wait); 298 if (err) 299 dev_err(&pdev->dev, "dma test failed\n"); 300 301 free_irq: 302 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_TEST), &wait); 303 return err; 304 } 305 306 /****************************************** 307 * DMA rings and descriptors manipulations 308 ******************************************/ 309 310 static u32 __pos_inc(u32 pos, size_t limit) 311 { 312 return ++pos == limit ? 0 : pos; 313 } 314 315 static int rocker_desc_err(const struct rocker_desc_info *desc_info) 316 { 317 int err = desc_info->desc->comp_err & ~ROCKER_DMA_DESC_COMP_ERR_GEN; 318 319 switch (err) { 320 case ROCKER_OK: 321 return 0; 322 case -ROCKER_ENOENT: 323 return -ENOENT; 324 case -ROCKER_ENXIO: 325 return -ENXIO; 326 case -ROCKER_ENOMEM: 327 return -ENOMEM; 328 case -ROCKER_EEXIST: 329 return -EEXIST; 330 case -ROCKER_EINVAL: 331 return -EINVAL; 332 case -ROCKER_EMSGSIZE: 333 return -EMSGSIZE; 334 case -ROCKER_ENOTSUP: 335 return -EOPNOTSUPP; 336 case -ROCKER_ENOBUFS: 337 return -ENOBUFS; 338 } 339 340 return -EINVAL; 341 } 342 343 static void rocker_desc_gen_clear(const struct rocker_desc_info *desc_info) 344 { 345 desc_info->desc->comp_err &= ~ROCKER_DMA_DESC_COMP_ERR_GEN; 346 } 347 348 static bool rocker_desc_gen(const struct rocker_desc_info *desc_info) 349 { 350 u32 comp_err = desc_info->desc->comp_err; 351 352 return comp_err & ROCKER_DMA_DESC_COMP_ERR_GEN ? true : false; 353 } 354 355 static void * 356 rocker_desc_cookie_ptr_get(const struct rocker_desc_info *desc_info) 357 { 358 return (void *)(uintptr_t)desc_info->desc->cookie; 359 } 360 361 static void rocker_desc_cookie_ptr_set(const struct rocker_desc_info *desc_info, 362 void *ptr) 363 { 364 desc_info->desc->cookie = (uintptr_t) ptr; 365 } 366 367 static struct rocker_desc_info * 368 rocker_desc_head_get(const struct rocker_dma_ring_info *info) 369 { 370 struct rocker_desc_info *desc_info; 371 u32 head = __pos_inc(info->head, info->size); 372 373 desc_info = &info->desc_info[info->head]; 374 if (head == info->tail) 375 return NULL; /* ring full */ 376 desc_info->tlv_size = 0; 377 return desc_info; 378 } 379 380 static void rocker_desc_commit(const struct rocker_desc_info *desc_info) 381 { 382 desc_info->desc->buf_size = desc_info->data_size; 383 desc_info->desc->tlv_size = desc_info->tlv_size; 384 } 385 386 static void rocker_desc_head_set(const struct rocker *rocker, 387 struct rocker_dma_ring_info *info, 388 const struct rocker_desc_info *desc_info) 389 { 390 u32 head = __pos_inc(info->head, info->size); 391 392 BUG_ON(head == info->tail); 393 rocker_desc_commit(desc_info); 394 info->head = head; 395 rocker_write32(rocker, DMA_DESC_HEAD(info->type), head); 396 } 397 398 static struct rocker_desc_info * 399 rocker_desc_tail_get(struct rocker_dma_ring_info *info) 400 { 401 struct rocker_desc_info *desc_info; 402 403 if (info->tail == info->head) 404 return NULL; /* nothing to be done between head and tail */ 405 desc_info = &info->desc_info[info->tail]; 406 if (!rocker_desc_gen(desc_info)) 407 return NULL; /* gen bit not set, desc is not ready yet */ 408 info->tail = __pos_inc(info->tail, info->size); 409 desc_info->tlv_size = desc_info->desc->tlv_size; 410 return desc_info; 411 } 412 413 static void rocker_dma_ring_credits_set(const struct rocker *rocker, 414 const struct rocker_dma_ring_info *info, 415 u32 credits) 416 { 417 if (credits) 418 rocker_write32(rocker, DMA_DESC_CREDITS(info->type), credits); 419 } 420 421 static unsigned long rocker_dma_ring_size_fix(size_t size) 422 { 423 return max(ROCKER_DMA_SIZE_MIN, 424 min(roundup_pow_of_two(size), ROCKER_DMA_SIZE_MAX)); 425 } 426 427 static int rocker_dma_ring_create(const struct rocker *rocker, 428 unsigned int type, 429 size_t size, 430 struct rocker_dma_ring_info *info) 431 { 432 int i; 433 434 BUG_ON(size != rocker_dma_ring_size_fix(size)); 435 info->size = size; 436 info->type = type; 437 info->head = 0; 438 info->tail = 0; 439 info->desc_info = kcalloc(info->size, sizeof(*info->desc_info), 440 GFP_KERNEL); 441 if (!info->desc_info) 442 return -ENOMEM; 443 444 info->desc = dma_alloc_coherent(&rocker->pdev->dev, 445 info->size * sizeof(*info->desc), 446 &info->mapaddr, GFP_KERNEL); 447 if (!info->desc) { 448 kfree(info->desc_info); 449 return -ENOMEM; 450 } 451 452 for (i = 0; i < info->size; i++) 453 info->desc_info[i].desc = &info->desc[i]; 454 455 rocker_write32(rocker, DMA_DESC_CTRL(info->type), 456 ROCKER_DMA_DESC_CTRL_RESET); 457 rocker_write64(rocker, DMA_DESC_ADDR(info->type), info->mapaddr); 458 rocker_write32(rocker, DMA_DESC_SIZE(info->type), info->size); 459 460 return 0; 461 } 462 463 static void rocker_dma_ring_destroy(const struct rocker *rocker, 464 const struct rocker_dma_ring_info *info) 465 { 466 rocker_write64(rocker, DMA_DESC_ADDR(info->type), 0); 467 468 dma_free_coherent(&rocker->pdev->dev, 469 info->size * sizeof(struct rocker_desc), info->desc, 470 info->mapaddr); 471 kfree(info->desc_info); 472 } 473 474 static void rocker_dma_ring_pass_to_producer(const struct rocker *rocker, 475 struct rocker_dma_ring_info *info) 476 { 477 int i; 478 479 BUG_ON(info->head || info->tail); 480 481 /* When ring is consumer, we need to advance head for each desc. 482 * That tells hw that the desc is ready to be used by it. 483 */ 484 for (i = 0; i < info->size - 1; i++) 485 rocker_desc_head_set(rocker, info, &info->desc_info[i]); 486 rocker_desc_commit(&info->desc_info[i]); 487 } 488 489 static int rocker_dma_ring_bufs_alloc(const struct rocker *rocker, 490 const struct rocker_dma_ring_info *info, 491 int direction, size_t buf_size) 492 { 493 struct pci_dev *pdev = rocker->pdev; 494 int i; 495 int err; 496 497 for (i = 0; i < info->size; i++) { 498 struct rocker_desc_info *desc_info = &info->desc_info[i]; 499 struct rocker_desc *desc = &info->desc[i]; 500 dma_addr_t dma_handle; 501 char *buf; 502 503 buf = kzalloc(buf_size, GFP_KERNEL | GFP_DMA); 504 if (!buf) { 505 err = -ENOMEM; 506 goto rollback; 507 } 508 509 dma_handle = dma_map_single(&pdev->dev, buf, buf_size, 510 direction); 511 if (dma_mapping_error(&pdev->dev, dma_handle)) { 512 kfree(buf); 513 err = -EIO; 514 goto rollback; 515 } 516 517 desc_info->data = buf; 518 desc_info->data_size = buf_size; 519 dma_unmap_addr_set(desc_info, mapaddr, dma_handle); 520 521 desc->buf_addr = dma_handle; 522 desc->buf_size = buf_size; 523 } 524 return 0; 525 526 rollback: 527 for (i--; i >= 0; i--) { 528 const struct rocker_desc_info *desc_info = &info->desc_info[i]; 529 530 dma_unmap_single(&pdev->dev, 531 dma_unmap_addr(desc_info, mapaddr), 532 desc_info->data_size, direction); 533 kfree(desc_info->data); 534 } 535 return err; 536 } 537 538 static void rocker_dma_ring_bufs_free(const struct rocker *rocker, 539 const struct rocker_dma_ring_info *info, 540 int direction) 541 { 542 struct pci_dev *pdev = rocker->pdev; 543 int i; 544 545 for (i = 0; i < info->size; i++) { 546 const struct rocker_desc_info *desc_info = &info->desc_info[i]; 547 struct rocker_desc *desc = &info->desc[i]; 548 549 desc->buf_addr = 0; 550 desc->buf_size = 0; 551 dma_unmap_single(&pdev->dev, 552 dma_unmap_addr(desc_info, mapaddr), 553 desc_info->data_size, direction); 554 kfree(desc_info->data); 555 } 556 } 557 558 static int rocker_dma_cmd_ring_wait_alloc(struct rocker_desc_info *desc_info) 559 { 560 struct rocker_wait *wait; 561 562 wait = rocker_wait_create(); 563 if (!wait) 564 return -ENOMEM; 565 rocker_desc_cookie_ptr_set(desc_info, wait); 566 return 0; 567 } 568 569 static void 570 rocker_dma_cmd_ring_wait_free(const struct rocker_desc_info *desc_info) 571 { 572 struct rocker_wait *wait = rocker_desc_cookie_ptr_get(desc_info); 573 574 rocker_wait_destroy(wait); 575 } 576 577 static int rocker_dma_cmd_ring_waits_alloc(const struct rocker *rocker) 578 { 579 const struct rocker_dma_ring_info *cmd_ring = &rocker->cmd_ring; 580 int i; 581 int err; 582 583 for (i = 0; i < cmd_ring->size; i++) { 584 err = rocker_dma_cmd_ring_wait_alloc(&cmd_ring->desc_info[i]); 585 if (err) 586 goto rollback; 587 } 588 return 0; 589 590 rollback: 591 for (i--; i >= 0; i--) 592 rocker_dma_cmd_ring_wait_free(&cmd_ring->desc_info[i]); 593 return err; 594 } 595 596 static void rocker_dma_cmd_ring_waits_free(const struct rocker *rocker) 597 { 598 const struct rocker_dma_ring_info *cmd_ring = &rocker->cmd_ring; 599 int i; 600 601 for (i = 0; i < cmd_ring->size; i++) 602 rocker_dma_cmd_ring_wait_free(&cmd_ring->desc_info[i]); 603 } 604 605 static int rocker_dma_rings_init(struct rocker *rocker) 606 { 607 const struct pci_dev *pdev = rocker->pdev; 608 int err; 609 610 err = rocker_dma_ring_create(rocker, ROCKER_DMA_CMD, 611 ROCKER_DMA_CMD_DEFAULT_SIZE, 612 &rocker->cmd_ring); 613 if (err) { 614 dev_err(&pdev->dev, "failed to create command dma ring\n"); 615 return err; 616 } 617 618 spin_lock_init(&rocker->cmd_ring_lock); 619 620 err = rocker_dma_ring_bufs_alloc(rocker, &rocker->cmd_ring, 621 DMA_BIDIRECTIONAL, PAGE_SIZE); 622 if (err) { 623 dev_err(&pdev->dev, "failed to alloc command dma ring buffers\n"); 624 goto err_dma_cmd_ring_bufs_alloc; 625 } 626 627 err = rocker_dma_cmd_ring_waits_alloc(rocker); 628 if (err) { 629 dev_err(&pdev->dev, "failed to alloc command dma ring waits\n"); 630 goto err_dma_cmd_ring_waits_alloc; 631 } 632 633 err = rocker_dma_ring_create(rocker, ROCKER_DMA_EVENT, 634 ROCKER_DMA_EVENT_DEFAULT_SIZE, 635 &rocker->event_ring); 636 if (err) { 637 dev_err(&pdev->dev, "failed to create event dma ring\n"); 638 goto err_dma_event_ring_create; 639 } 640 641 err = rocker_dma_ring_bufs_alloc(rocker, &rocker->event_ring, 642 DMA_FROM_DEVICE, PAGE_SIZE); 643 if (err) { 644 dev_err(&pdev->dev, "failed to alloc event dma ring buffers\n"); 645 goto err_dma_event_ring_bufs_alloc; 646 } 647 rocker_dma_ring_pass_to_producer(rocker, &rocker->event_ring); 648 return 0; 649 650 err_dma_event_ring_bufs_alloc: 651 rocker_dma_ring_destroy(rocker, &rocker->event_ring); 652 err_dma_event_ring_create: 653 rocker_dma_cmd_ring_waits_free(rocker); 654 err_dma_cmd_ring_waits_alloc: 655 rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring, 656 DMA_BIDIRECTIONAL); 657 err_dma_cmd_ring_bufs_alloc: 658 rocker_dma_ring_destroy(rocker, &rocker->cmd_ring); 659 return err; 660 } 661 662 static void rocker_dma_rings_fini(struct rocker *rocker) 663 { 664 rocker_dma_ring_bufs_free(rocker, &rocker->event_ring, 665 DMA_BIDIRECTIONAL); 666 rocker_dma_ring_destroy(rocker, &rocker->event_ring); 667 rocker_dma_cmd_ring_waits_free(rocker); 668 rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring, 669 DMA_BIDIRECTIONAL); 670 rocker_dma_ring_destroy(rocker, &rocker->cmd_ring); 671 } 672 673 static int rocker_dma_rx_ring_skb_map(const struct rocker_port *rocker_port, 674 struct rocker_desc_info *desc_info, 675 struct sk_buff *skb, size_t buf_len) 676 { 677 const struct rocker *rocker = rocker_port->rocker; 678 struct pci_dev *pdev = rocker->pdev; 679 dma_addr_t dma_handle; 680 681 dma_handle = dma_map_single(&pdev->dev, skb->data, buf_len, 682 DMA_FROM_DEVICE); 683 if (dma_mapping_error(&pdev->dev, dma_handle)) 684 return -EIO; 685 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_RX_FRAG_ADDR, dma_handle)) 686 goto tlv_put_failure; 687 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_RX_FRAG_MAX_LEN, buf_len)) 688 goto tlv_put_failure; 689 return 0; 690 691 tlv_put_failure: 692 dma_unmap_single(&pdev->dev, dma_handle, buf_len, DMA_FROM_DEVICE); 693 desc_info->tlv_size = 0; 694 return -EMSGSIZE; 695 } 696 697 static size_t rocker_port_rx_buf_len(const struct rocker_port *rocker_port) 698 { 699 return rocker_port->dev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN; 700 } 701 702 static int rocker_dma_rx_ring_skb_alloc(const struct rocker_port *rocker_port, 703 struct rocker_desc_info *desc_info) 704 { 705 struct net_device *dev = rocker_port->dev; 706 struct sk_buff *skb; 707 size_t buf_len = rocker_port_rx_buf_len(rocker_port); 708 int err; 709 710 /* Ensure that hw will see tlv_size zero in case of an error. 711 * That tells hw to use another descriptor. 712 */ 713 rocker_desc_cookie_ptr_set(desc_info, NULL); 714 desc_info->tlv_size = 0; 715 716 skb = netdev_alloc_skb_ip_align(dev, buf_len); 717 if (!skb) 718 return -ENOMEM; 719 err = rocker_dma_rx_ring_skb_map(rocker_port, desc_info, skb, buf_len); 720 if (err) { 721 dev_kfree_skb_any(skb); 722 return err; 723 } 724 rocker_desc_cookie_ptr_set(desc_info, skb); 725 return 0; 726 } 727 728 static void rocker_dma_rx_ring_skb_unmap(const struct rocker *rocker, 729 const struct rocker_tlv **attrs) 730 { 731 struct pci_dev *pdev = rocker->pdev; 732 dma_addr_t dma_handle; 733 size_t len; 734 735 if (!attrs[ROCKER_TLV_RX_FRAG_ADDR] || 736 !attrs[ROCKER_TLV_RX_FRAG_MAX_LEN]) 737 return; 738 dma_handle = rocker_tlv_get_u64(attrs[ROCKER_TLV_RX_FRAG_ADDR]); 739 len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_MAX_LEN]); 740 dma_unmap_single(&pdev->dev, dma_handle, len, DMA_FROM_DEVICE); 741 } 742 743 static void rocker_dma_rx_ring_skb_free(const struct rocker *rocker, 744 const struct rocker_desc_info *desc_info) 745 { 746 const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1]; 747 struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info); 748 749 if (!skb) 750 return; 751 rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info); 752 rocker_dma_rx_ring_skb_unmap(rocker, attrs); 753 dev_kfree_skb_any(skb); 754 } 755 756 static int rocker_dma_rx_ring_skbs_alloc(const struct rocker_port *rocker_port) 757 { 758 const struct rocker_dma_ring_info *rx_ring = &rocker_port->rx_ring; 759 const struct rocker *rocker = rocker_port->rocker; 760 int i; 761 int err; 762 763 for (i = 0; i < rx_ring->size; i++) { 764 err = rocker_dma_rx_ring_skb_alloc(rocker_port, 765 &rx_ring->desc_info[i]); 766 if (err) 767 goto rollback; 768 } 769 return 0; 770 771 rollback: 772 for (i--; i >= 0; i--) 773 rocker_dma_rx_ring_skb_free(rocker, &rx_ring->desc_info[i]); 774 return err; 775 } 776 777 static void rocker_dma_rx_ring_skbs_free(const struct rocker_port *rocker_port) 778 { 779 const struct rocker_dma_ring_info *rx_ring = &rocker_port->rx_ring; 780 const struct rocker *rocker = rocker_port->rocker; 781 int i; 782 783 for (i = 0; i < rx_ring->size; i++) 784 rocker_dma_rx_ring_skb_free(rocker, &rx_ring->desc_info[i]); 785 } 786 787 static int rocker_port_dma_rings_init(struct rocker_port *rocker_port) 788 { 789 struct rocker *rocker = rocker_port->rocker; 790 int err; 791 792 err = rocker_dma_ring_create(rocker, 793 ROCKER_DMA_TX(rocker_port->port_number), 794 ROCKER_DMA_TX_DEFAULT_SIZE, 795 &rocker_port->tx_ring); 796 if (err) { 797 netdev_err(rocker_port->dev, "failed to create tx dma ring\n"); 798 return err; 799 } 800 801 err = rocker_dma_ring_bufs_alloc(rocker, &rocker_port->tx_ring, 802 DMA_TO_DEVICE, 803 ROCKER_DMA_TX_DESC_SIZE); 804 if (err) { 805 netdev_err(rocker_port->dev, "failed to alloc tx dma ring buffers\n"); 806 goto err_dma_tx_ring_bufs_alloc; 807 } 808 809 err = rocker_dma_ring_create(rocker, 810 ROCKER_DMA_RX(rocker_port->port_number), 811 ROCKER_DMA_RX_DEFAULT_SIZE, 812 &rocker_port->rx_ring); 813 if (err) { 814 netdev_err(rocker_port->dev, "failed to create rx dma ring\n"); 815 goto err_dma_rx_ring_create; 816 } 817 818 err = rocker_dma_ring_bufs_alloc(rocker, &rocker_port->rx_ring, 819 DMA_BIDIRECTIONAL, 820 ROCKER_DMA_RX_DESC_SIZE); 821 if (err) { 822 netdev_err(rocker_port->dev, "failed to alloc rx dma ring buffers\n"); 823 goto err_dma_rx_ring_bufs_alloc; 824 } 825 826 err = rocker_dma_rx_ring_skbs_alloc(rocker_port); 827 if (err) { 828 netdev_err(rocker_port->dev, "failed to alloc rx dma ring skbs\n"); 829 goto err_dma_rx_ring_skbs_alloc; 830 } 831 rocker_dma_ring_pass_to_producer(rocker, &rocker_port->rx_ring); 832 833 return 0; 834 835 err_dma_rx_ring_skbs_alloc: 836 rocker_dma_ring_bufs_free(rocker, &rocker_port->rx_ring, 837 DMA_BIDIRECTIONAL); 838 err_dma_rx_ring_bufs_alloc: 839 rocker_dma_ring_destroy(rocker, &rocker_port->rx_ring); 840 err_dma_rx_ring_create: 841 rocker_dma_ring_bufs_free(rocker, &rocker_port->tx_ring, 842 DMA_TO_DEVICE); 843 err_dma_tx_ring_bufs_alloc: 844 rocker_dma_ring_destroy(rocker, &rocker_port->tx_ring); 845 return err; 846 } 847 848 static void rocker_port_dma_rings_fini(struct rocker_port *rocker_port) 849 { 850 struct rocker *rocker = rocker_port->rocker; 851 852 rocker_dma_rx_ring_skbs_free(rocker_port); 853 rocker_dma_ring_bufs_free(rocker, &rocker_port->rx_ring, 854 DMA_BIDIRECTIONAL); 855 rocker_dma_ring_destroy(rocker, &rocker_port->rx_ring); 856 rocker_dma_ring_bufs_free(rocker, &rocker_port->tx_ring, 857 DMA_TO_DEVICE); 858 rocker_dma_ring_destroy(rocker, &rocker_port->tx_ring); 859 } 860 861 static void rocker_port_set_enable(const struct rocker_port *rocker_port, 862 bool enable) 863 { 864 u64 val = rocker_read64(rocker_port->rocker, PORT_PHYS_ENABLE); 865 866 if (enable) 867 val |= 1ULL << rocker_port->pport; 868 else 869 val &= ~(1ULL << rocker_port->pport); 870 rocker_write64(rocker_port->rocker, PORT_PHYS_ENABLE, val); 871 } 872 873 /******************************** 874 * Interrupt handler and helpers 875 ********************************/ 876 877 static irqreturn_t rocker_cmd_irq_handler(int irq, void *dev_id) 878 { 879 struct rocker *rocker = dev_id; 880 const struct rocker_desc_info *desc_info; 881 struct rocker_wait *wait; 882 u32 credits = 0; 883 884 spin_lock(&rocker->cmd_ring_lock); 885 while ((desc_info = rocker_desc_tail_get(&rocker->cmd_ring))) { 886 wait = rocker_desc_cookie_ptr_get(desc_info); 887 if (wait->nowait) { 888 rocker_desc_gen_clear(desc_info); 889 } else { 890 rocker_wait_wake_up(wait); 891 } 892 credits++; 893 } 894 spin_unlock(&rocker->cmd_ring_lock); 895 rocker_dma_ring_credits_set(rocker, &rocker->cmd_ring, credits); 896 897 return IRQ_HANDLED; 898 } 899 900 static void rocker_port_link_up(const struct rocker_port *rocker_port) 901 { 902 netif_carrier_on(rocker_port->dev); 903 netdev_info(rocker_port->dev, "Link is up\n"); 904 } 905 906 static void rocker_port_link_down(const struct rocker_port *rocker_port) 907 { 908 netif_carrier_off(rocker_port->dev); 909 netdev_info(rocker_port->dev, "Link is down\n"); 910 } 911 912 static int rocker_event_link_change(const struct rocker *rocker, 913 const struct rocker_tlv *info) 914 { 915 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_LINK_CHANGED_MAX + 1]; 916 unsigned int port_number; 917 bool link_up; 918 struct rocker_port *rocker_port; 919 920 rocker_tlv_parse_nested(attrs, ROCKER_TLV_EVENT_LINK_CHANGED_MAX, info); 921 if (!attrs[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT] || 922 !attrs[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP]) 923 return -EIO; 924 port_number = 925 rocker_tlv_get_u32(attrs[ROCKER_TLV_EVENT_LINK_CHANGED_PPORT]) - 1; 926 link_up = rocker_tlv_get_u8(attrs[ROCKER_TLV_EVENT_LINK_CHANGED_LINKUP]); 927 928 if (port_number >= rocker->port_count) 929 return -EINVAL; 930 931 rocker_port = rocker->ports[port_number]; 932 if (netif_carrier_ok(rocker_port->dev) != link_up) { 933 if (link_up) 934 rocker_port_link_up(rocker_port); 935 else 936 rocker_port_link_down(rocker_port); 937 } 938 939 return 0; 940 } 941 942 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port *rocker_port, 943 const unsigned char *addr, 944 __be16 vlan_id); 945 946 static int rocker_event_mac_vlan_seen(const struct rocker *rocker, 947 const struct rocker_tlv *info) 948 { 949 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAX + 1]; 950 unsigned int port_number; 951 struct rocker_port *rocker_port; 952 const unsigned char *addr; 953 __be16 vlan_id; 954 955 rocker_tlv_parse_nested(attrs, ROCKER_TLV_EVENT_MAC_VLAN_MAX, info); 956 if (!attrs[ROCKER_TLV_EVENT_MAC_VLAN_PPORT] || 957 !attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAC] || 958 !attrs[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID]) 959 return -EIO; 960 port_number = 961 rocker_tlv_get_u32(attrs[ROCKER_TLV_EVENT_MAC_VLAN_PPORT]) - 1; 962 addr = rocker_tlv_data(attrs[ROCKER_TLV_EVENT_MAC_VLAN_MAC]); 963 vlan_id = rocker_tlv_get_be16(attrs[ROCKER_TLV_EVENT_MAC_VLAN_VLAN_ID]); 964 965 if (port_number >= rocker->port_count) 966 return -EINVAL; 967 968 rocker_port = rocker->ports[port_number]; 969 return rocker_world_port_ev_mac_vlan_seen(rocker_port, addr, vlan_id); 970 } 971 972 static int rocker_event_process(const struct rocker *rocker, 973 const struct rocker_desc_info *desc_info) 974 { 975 const struct rocker_tlv *attrs[ROCKER_TLV_EVENT_MAX + 1]; 976 const struct rocker_tlv *info; 977 u16 type; 978 979 rocker_tlv_parse_desc(attrs, ROCKER_TLV_EVENT_MAX, desc_info); 980 if (!attrs[ROCKER_TLV_EVENT_TYPE] || 981 !attrs[ROCKER_TLV_EVENT_INFO]) 982 return -EIO; 983 984 type = rocker_tlv_get_u16(attrs[ROCKER_TLV_EVENT_TYPE]); 985 info = attrs[ROCKER_TLV_EVENT_INFO]; 986 987 switch (type) { 988 case ROCKER_TLV_EVENT_TYPE_LINK_CHANGED: 989 return rocker_event_link_change(rocker, info); 990 case ROCKER_TLV_EVENT_TYPE_MAC_VLAN_SEEN: 991 return rocker_event_mac_vlan_seen(rocker, info); 992 } 993 994 return -EOPNOTSUPP; 995 } 996 997 static irqreturn_t rocker_event_irq_handler(int irq, void *dev_id) 998 { 999 struct rocker *rocker = dev_id; 1000 const struct pci_dev *pdev = rocker->pdev; 1001 const struct rocker_desc_info *desc_info; 1002 u32 credits = 0; 1003 int err; 1004 1005 while ((desc_info = rocker_desc_tail_get(&rocker->event_ring))) { 1006 err = rocker_desc_err(desc_info); 1007 if (err) { 1008 dev_err(&pdev->dev, "event desc received with err %d\n", 1009 err); 1010 } else { 1011 err = rocker_event_process(rocker, desc_info); 1012 if (err) 1013 dev_err(&pdev->dev, "event processing failed with err %d\n", 1014 err); 1015 } 1016 rocker_desc_gen_clear(desc_info); 1017 rocker_desc_head_set(rocker, &rocker->event_ring, desc_info); 1018 credits++; 1019 } 1020 rocker_dma_ring_credits_set(rocker, &rocker->event_ring, credits); 1021 1022 return IRQ_HANDLED; 1023 } 1024 1025 static irqreturn_t rocker_tx_irq_handler(int irq, void *dev_id) 1026 { 1027 struct rocker_port *rocker_port = dev_id; 1028 1029 napi_schedule(&rocker_port->napi_tx); 1030 return IRQ_HANDLED; 1031 } 1032 1033 static irqreturn_t rocker_rx_irq_handler(int irq, void *dev_id) 1034 { 1035 struct rocker_port *rocker_port = dev_id; 1036 1037 napi_schedule(&rocker_port->napi_rx); 1038 return IRQ_HANDLED; 1039 } 1040 1041 /******************** 1042 * Command interface 1043 ********************/ 1044 1045 int rocker_cmd_exec(struct rocker_port *rocker_port, bool nowait, 1046 rocker_cmd_prep_cb_t prepare, void *prepare_priv, 1047 rocker_cmd_proc_cb_t process, void *process_priv) 1048 { 1049 struct rocker *rocker = rocker_port->rocker; 1050 struct rocker_desc_info *desc_info; 1051 struct rocker_wait *wait; 1052 unsigned long lock_flags; 1053 int err; 1054 1055 spin_lock_irqsave(&rocker->cmd_ring_lock, lock_flags); 1056 1057 desc_info = rocker_desc_head_get(&rocker->cmd_ring); 1058 if (!desc_info) { 1059 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags); 1060 return -EAGAIN; 1061 } 1062 1063 wait = rocker_desc_cookie_ptr_get(desc_info); 1064 rocker_wait_init(wait); 1065 wait->nowait = nowait; 1066 1067 err = prepare(rocker_port, desc_info, prepare_priv); 1068 if (err) { 1069 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags); 1070 return err; 1071 } 1072 1073 rocker_desc_head_set(rocker, &rocker->cmd_ring, desc_info); 1074 1075 spin_unlock_irqrestore(&rocker->cmd_ring_lock, lock_flags); 1076 1077 if (nowait) 1078 return 0; 1079 1080 if (!rocker_wait_event_timeout(wait, HZ / 10)) 1081 return -EIO; 1082 1083 err = rocker_desc_err(desc_info); 1084 if (err) 1085 return err; 1086 1087 if (process) 1088 err = process(rocker_port, desc_info, process_priv); 1089 1090 rocker_desc_gen_clear(desc_info); 1091 return err; 1092 } 1093 1094 static int 1095 rocker_cmd_get_port_settings_prep(const struct rocker_port *rocker_port, 1096 struct rocker_desc_info *desc_info, 1097 void *priv) 1098 { 1099 struct rocker_tlv *cmd_info; 1100 1101 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 1102 ROCKER_TLV_CMD_TYPE_GET_PORT_SETTINGS)) 1103 return -EMSGSIZE; 1104 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 1105 if (!cmd_info) 1106 return -EMSGSIZE; 1107 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, 1108 rocker_port->pport)) 1109 return -EMSGSIZE; 1110 rocker_tlv_nest_end(desc_info, cmd_info); 1111 return 0; 1112 } 1113 1114 static int 1115 rocker_cmd_get_port_settings_ethtool_proc(const struct rocker_port *rocker_port, 1116 const struct rocker_desc_info *desc_info, 1117 void *priv) 1118 { 1119 struct ethtool_link_ksettings *ecmd = priv; 1120 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1]; 1121 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; 1122 u32 speed; 1123 u8 duplex; 1124 u8 autoneg; 1125 1126 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info); 1127 if (!attrs[ROCKER_TLV_CMD_INFO]) 1128 return -EIO; 1129 1130 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, 1131 attrs[ROCKER_TLV_CMD_INFO]); 1132 if (!info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED] || 1133 !info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX] || 1134 !info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]) 1135 return -EIO; 1136 1137 speed = rocker_tlv_get_u32(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_SPEED]); 1138 duplex = rocker_tlv_get_u8(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX]); 1139 autoneg = rocker_tlv_get_u8(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG]); 1140 1141 ethtool_link_ksettings_zero_link_mode(ecmd, supported); 1142 ethtool_link_ksettings_add_link_mode(ecmd, supported, TP); 1143 1144 ecmd->base.phy_address = 0xff; 1145 ecmd->base.port = PORT_TP; 1146 ecmd->base.speed = speed; 1147 ecmd->base.duplex = duplex ? DUPLEX_FULL : DUPLEX_HALF; 1148 ecmd->base.autoneg = autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE; 1149 1150 return 0; 1151 } 1152 1153 static int 1154 rocker_cmd_get_port_settings_macaddr_proc(const struct rocker_port *rocker_port, 1155 const struct rocker_desc_info *desc_info, 1156 void *priv) 1157 { 1158 unsigned char *macaddr = priv; 1159 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1]; 1160 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; 1161 const struct rocker_tlv *attr; 1162 1163 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info); 1164 if (!attrs[ROCKER_TLV_CMD_INFO]) 1165 return -EIO; 1166 1167 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, 1168 attrs[ROCKER_TLV_CMD_INFO]); 1169 attr = info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR]; 1170 if (!attr) 1171 return -EIO; 1172 1173 if (rocker_tlv_len(attr) != ETH_ALEN) 1174 return -EINVAL; 1175 1176 ether_addr_copy(macaddr, rocker_tlv_data(attr)); 1177 return 0; 1178 } 1179 1180 static int 1181 rocker_cmd_get_port_settings_mode_proc(const struct rocker_port *rocker_port, 1182 const struct rocker_desc_info *desc_info, 1183 void *priv) 1184 { 1185 u8 *p_mode = priv; 1186 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1]; 1187 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; 1188 const struct rocker_tlv *attr; 1189 1190 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info); 1191 if (!attrs[ROCKER_TLV_CMD_INFO]) 1192 return -EIO; 1193 1194 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, 1195 attrs[ROCKER_TLV_CMD_INFO]); 1196 attr = info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]; 1197 if (!attr) 1198 return -EIO; 1199 1200 *p_mode = rocker_tlv_get_u8(info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MODE]); 1201 return 0; 1202 } 1203 1204 struct port_name { 1205 char *buf; 1206 size_t len; 1207 }; 1208 1209 static int 1210 rocker_cmd_get_port_settings_phys_name_proc(const struct rocker_port *rocker_port, 1211 const struct rocker_desc_info *desc_info, 1212 void *priv) 1213 { 1214 const struct rocker_tlv *info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_MAX + 1]; 1215 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1]; 1216 struct port_name *name = priv; 1217 const struct rocker_tlv *attr; 1218 size_t i, j, len; 1219 const char *str; 1220 1221 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info); 1222 if (!attrs[ROCKER_TLV_CMD_INFO]) 1223 return -EIO; 1224 1225 rocker_tlv_parse_nested(info_attrs, ROCKER_TLV_CMD_PORT_SETTINGS_MAX, 1226 attrs[ROCKER_TLV_CMD_INFO]); 1227 attr = info_attrs[ROCKER_TLV_CMD_PORT_SETTINGS_PHYS_NAME]; 1228 if (!attr) 1229 return -EIO; 1230 1231 len = min_t(size_t, rocker_tlv_len(attr), name->len); 1232 str = rocker_tlv_data(attr); 1233 1234 /* make sure name only contains alphanumeric characters */ 1235 for (i = j = 0; i < len; ++i) { 1236 if (isalnum(str[i])) { 1237 name->buf[j] = str[i]; 1238 j++; 1239 } 1240 } 1241 1242 if (j == 0) 1243 return -EIO; 1244 1245 name->buf[j] = '\0'; 1246 1247 return 0; 1248 } 1249 1250 static int 1251 rocker_cmd_set_port_settings_ethtool_prep(const struct rocker_port *rocker_port, 1252 struct rocker_desc_info *desc_info, 1253 void *priv) 1254 { 1255 struct ethtool_link_ksettings *ecmd = priv; 1256 struct rocker_tlv *cmd_info; 1257 1258 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 1259 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS)) 1260 return -EMSGSIZE; 1261 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 1262 if (!cmd_info) 1263 return -EMSGSIZE; 1264 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, 1265 rocker_port->pport)) 1266 return -EMSGSIZE; 1267 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_SPEED, 1268 ecmd->base.speed)) 1269 return -EMSGSIZE; 1270 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_DUPLEX, 1271 ecmd->base.duplex)) 1272 return -EMSGSIZE; 1273 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_AUTONEG, 1274 ecmd->base.autoneg)) 1275 return -EMSGSIZE; 1276 rocker_tlv_nest_end(desc_info, cmd_info); 1277 return 0; 1278 } 1279 1280 static int 1281 rocker_cmd_set_port_settings_macaddr_prep(const struct rocker_port *rocker_port, 1282 struct rocker_desc_info *desc_info, 1283 void *priv) 1284 { 1285 const unsigned char *macaddr = priv; 1286 struct rocker_tlv *cmd_info; 1287 1288 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 1289 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS)) 1290 return -EMSGSIZE; 1291 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 1292 if (!cmd_info) 1293 return -EMSGSIZE; 1294 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, 1295 rocker_port->pport)) 1296 return -EMSGSIZE; 1297 if (rocker_tlv_put(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_MACADDR, 1298 ETH_ALEN, macaddr)) 1299 return -EMSGSIZE; 1300 rocker_tlv_nest_end(desc_info, cmd_info); 1301 return 0; 1302 } 1303 1304 static int 1305 rocker_cmd_set_port_settings_mtu_prep(const struct rocker_port *rocker_port, 1306 struct rocker_desc_info *desc_info, 1307 void *priv) 1308 { 1309 int mtu = *(int *)priv; 1310 struct rocker_tlv *cmd_info; 1311 1312 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 1313 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS)) 1314 return -EMSGSIZE; 1315 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 1316 if (!cmd_info) 1317 return -EMSGSIZE; 1318 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, 1319 rocker_port->pport)) 1320 return -EMSGSIZE; 1321 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_MTU, 1322 mtu)) 1323 return -EMSGSIZE; 1324 rocker_tlv_nest_end(desc_info, cmd_info); 1325 return 0; 1326 } 1327 1328 static int 1329 rocker_cmd_set_port_learning_prep(const struct rocker_port *rocker_port, 1330 struct rocker_desc_info *desc_info, 1331 void *priv) 1332 { 1333 bool learning = *(bool *)priv; 1334 struct rocker_tlv *cmd_info; 1335 1336 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 1337 ROCKER_TLV_CMD_TYPE_SET_PORT_SETTINGS)) 1338 return -EMSGSIZE; 1339 cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 1340 if (!cmd_info) 1341 return -EMSGSIZE; 1342 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_PPORT, 1343 rocker_port->pport)) 1344 return -EMSGSIZE; 1345 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_CMD_PORT_SETTINGS_LEARNING, 1346 learning)) 1347 return -EMSGSIZE; 1348 rocker_tlv_nest_end(desc_info, cmd_info); 1349 return 0; 1350 } 1351 1352 static int 1353 rocker_cmd_get_port_settings_ethtool(struct rocker_port *rocker_port, 1354 struct ethtool_link_ksettings *ecmd) 1355 { 1356 return rocker_cmd_exec(rocker_port, false, 1357 rocker_cmd_get_port_settings_prep, NULL, 1358 rocker_cmd_get_port_settings_ethtool_proc, 1359 ecmd); 1360 } 1361 1362 static int rocker_cmd_get_port_settings_macaddr(struct rocker_port *rocker_port, 1363 unsigned char *macaddr) 1364 { 1365 return rocker_cmd_exec(rocker_port, false, 1366 rocker_cmd_get_port_settings_prep, NULL, 1367 rocker_cmd_get_port_settings_macaddr_proc, 1368 macaddr); 1369 } 1370 1371 static int rocker_cmd_get_port_settings_mode(struct rocker_port *rocker_port, 1372 u8 *p_mode) 1373 { 1374 return rocker_cmd_exec(rocker_port, false, 1375 rocker_cmd_get_port_settings_prep, NULL, 1376 rocker_cmd_get_port_settings_mode_proc, p_mode); 1377 } 1378 1379 static int 1380 rocker_cmd_set_port_settings_ethtool(struct rocker_port *rocker_port, 1381 const struct ethtool_link_ksettings *ecmd) 1382 { 1383 struct ethtool_link_ksettings copy_ecmd; 1384 1385 memcpy(©_ecmd, ecmd, sizeof(copy_ecmd)); 1386 1387 return rocker_cmd_exec(rocker_port, false, 1388 rocker_cmd_set_port_settings_ethtool_prep, 1389 ©_ecmd, NULL, NULL); 1390 } 1391 1392 static int rocker_cmd_set_port_settings_macaddr(struct rocker_port *rocker_port, 1393 unsigned char *macaddr) 1394 { 1395 return rocker_cmd_exec(rocker_port, false, 1396 rocker_cmd_set_port_settings_macaddr_prep, 1397 macaddr, NULL, NULL); 1398 } 1399 1400 static int rocker_cmd_set_port_settings_mtu(struct rocker_port *rocker_port, 1401 int mtu) 1402 { 1403 return rocker_cmd_exec(rocker_port, false, 1404 rocker_cmd_set_port_settings_mtu_prep, 1405 &mtu, NULL, NULL); 1406 } 1407 1408 int rocker_port_set_learning(struct rocker_port *rocker_port, 1409 bool learning) 1410 { 1411 return rocker_cmd_exec(rocker_port, false, 1412 rocker_cmd_set_port_learning_prep, 1413 &learning, NULL, NULL); 1414 } 1415 1416 /********************** 1417 * Worlds manipulation 1418 **********************/ 1419 1420 static struct rocker_world_ops *rocker_world_ops[] = { 1421 &rocker_ofdpa_ops, 1422 }; 1423 1424 #define ROCKER_WORLD_OPS_LEN ARRAY_SIZE(rocker_world_ops) 1425 1426 static struct rocker_world_ops *rocker_world_ops_find(u8 mode) 1427 { 1428 int i; 1429 1430 for (i = 0; i < ROCKER_WORLD_OPS_LEN; i++) 1431 if (rocker_world_ops[i]->mode == mode) 1432 return rocker_world_ops[i]; 1433 return NULL; 1434 } 1435 1436 static int rocker_world_init(struct rocker *rocker, u8 mode) 1437 { 1438 struct rocker_world_ops *wops; 1439 int err; 1440 1441 wops = rocker_world_ops_find(mode); 1442 if (!wops) { 1443 dev_err(&rocker->pdev->dev, "port mode \"%d\" is not supported\n", 1444 mode); 1445 return -EINVAL; 1446 } 1447 rocker->wops = wops; 1448 rocker->wpriv = kzalloc(wops->priv_size, GFP_KERNEL); 1449 if (!rocker->wpriv) 1450 return -ENOMEM; 1451 if (!wops->init) 1452 return 0; 1453 err = wops->init(rocker); 1454 if (err) 1455 kfree(rocker->wpriv); 1456 return err; 1457 } 1458 1459 static void rocker_world_fini(struct rocker *rocker) 1460 { 1461 struct rocker_world_ops *wops = rocker->wops; 1462 1463 if (!wops || !wops->fini) 1464 return; 1465 wops->fini(rocker); 1466 kfree(rocker->wpriv); 1467 } 1468 1469 static int rocker_world_check_init(struct rocker_port *rocker_port) 1470 { 1471 struct rocker *rocker = rocker_port->rocker; 1472 u8 mode; 1473 int err; 1474 1475 err = rocker_cmd_get_port_settings_mode(rocker_port, &mode); 1476 if (err) { 1477 dev_err(&rocker->pdev->dev, "failed to get port mode\n"); 1478 return err; 1479 } 1480 if (rocker->wops) { 1481 if (rocker->wops->mode != mode) { 1482 dev_err(&rocker->pdev->dev, "hardware has ports in different worlds, which is not supported\n"); 1483 return -EINVAL; 1484 } 1485 return 0; 1486 } 1487 return rocker_world_init(rocker, mode); 1488 } 1489 1490 static int rocker_world_port_pre_init(struct rocker_port *rocker_port) 1491 { 1492 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1493 int err; 1494 1495 rocker_port->wpriv = kzalloc(wops->port_priv_size, GFP_KERNEL); 1496 if (!rocker_port->wpriv) 1497 return -ENOMEM; 1498 if (!wops->port_pre_init) 1499 return 0; 1500 err = wops->port_pre_init(rocker_port); 1501 if (err) 1502 kfree(rocker_port->wpriv); 1503 return 0; 1504 } 1505 1506 static int rocker_world_port_init(struct rocker_port *rocker_port) 1507 { 1508 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1509 1510 if (!wops->port_init) 1511 return 0; 1512 return wops->port_init(rocker_port); 1513 } 1514 1515 static void rocker_world_port_fini(struct rocker_port *rocker_port) 1516 { 1517 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1518 1519 if (!wops->port_fini) 1520 return; 1521 wops->port_fini(rocker_port); 1522 } 1523 1524 static void rocker_world_port_post_fini(struct rocker_port *rocker_port) 1525 { 1526 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1527 1528 if (!wops->port_post_fini) 1529 return; 1530 wops->port_post_fini(rocker_port); 1531 kfree(rocker_port->wpriv); 1532 } 1533 1534 static int rocker_world_port_open(struct rocker_port *rocker_port) 1535 { 1536 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1537 1538 if (!wops->port_open) 1539 return 0; 1540 return wops->port_open(rocker_port); 1541 } 1542 1543 static void rocker_world_port_stop(struct rocker_port *rocker_port) 1544 { 1545 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1546 1547 if (!wops->port_stop) 1548 return; 1549 wops->port_stop(rocker_port); 1550 } 1551 1552 static int rocker_world_port_attr_stp_state_set(struct rocker_port *rocker_port, 1553 u8 state, 1554 struct switchdev_trans *trans) 1555 { 1556 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1557 1558 if (!wops->port_attr_stp_state_set) 1559 return -EOPNOTSUPP; 1560 1561 if (switchdev_trans_ph_prepare(trans)) 1562 return 0; 1563 1564 return wops->port_attr_stp_state_set(rocker_port, state); 1565 } 1566 1567 static int 1568 rocker_world_port_attr_bridge_flags_support_get(const struct rocker_port * 1569 rocker_port, 1570 unsigned long * 1571 p_brport_flags_support) 1572 { 1573 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1574 1575 if (!wops->port_attr_bridge_flags_support_get) 1576 return -EOPNOTSUPP; 1577 return wops->port_attr_bridge_flags_support_get(rocker_port, 1578 p_brport_flags_support); 1579 } 1580 1581 static int 1582 rocker_world_port_attr_pre_bridge_flags_set(struct rocker_port *rocker_port, 1583 unsigned long brport_flags, 1584 struct switchdev_trans *trans) 1585 { 1586 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1587 unsigned long brport_flags_s; 1588 int err; 1589 1590 if (!wops->port_attr_bridge_flags_set) 1591 return -EOPNOTSUPP; 1592 1593 err = rocker_world_port_attr_bridge_flags_support_get(rocker_port, 1594 &brport_flags_s); 1595 if (err) 1596 return err; 1597 1598 if (brport_flags & ~brport_flags_s) 1599 return -EINVAL; 1600 1601 return 0; 1602 } 1603 1604 static int 1605 rocker_world_port_attr_bridge_flags_set(struct rocker_port *rocker_port, 1606 unsigned long brport_flags, 1607 struct switchdev_trans *trans) 1608 { 1609 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1610 1611 if (!wops->port_attr_bridge_flags_set) 1612 return -EOPNOTSUPP; 1613 1614 if (switchdev_trans_ph_prepare(trans)) 1615 return 0; 1616 1617 return wops->port_attr_bridge_flags_set(rocker_port, brport_flags, 1618 trans); 1619 } 1620 1621 static int 1622 rocker_world_port_attr_bridge_ageing_time_set(struct rocker_port *rocker_port, 1623 u32 ageing_time, 1624 struct switchdev_trans *trans) 1625 1626 { 1627 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1628 1629 if (!wops->port_attr_bridge_ageing_time_set) 1630 return -EOPNOTSUPP; 1631 1632 if (switchdev_trans_ph_prepare(trans)) 1633 return 0; 1634 1635 return wops->port_attr_bridge_ageing_time_set(rocker_port, ageing_time, 1636 trans); 1637 } 1638 1639 static int 1640 rocker_world_port_obj_vlan_add(struct rocker_port *rocker_port, 1641 const struct switchdev_obj_port_vlan *vlan, 1642 struct switchdev_trans *trans) 1643 { 1644 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1645 1646 if (!wops->port_obj_vlan_add) 1647 return -EOPNOTSUPP; 1648 1649 if (switchdev_trans_ph_prepare(trans)) 1650 return 0; 1651 1652 return wops->port_obj_vlan_add(rocker_port, vlan); 1653 } 1654 1655 static int 1656 rocker_world_port_obj_vlan_del(struct rocker_port *rocker_port, 1657 const struct switchdev_obj_port_vlan *vlan) 1658 { 1659 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1660 1661 if (netif_is_bridge_master(vlan->obj.orig_dev)) 1662 return -EOPNOTSUPP; 1663 1664 if (!wops->port_obj_vlan_del) 1665 return -EOPNOTSUPP; 1666 return wops->port_obj_vlan_del(rocker_port, vlan); 1667 } 1668 1669 static int 1670 rocker_world_port_fdb_add(struct rocker_port *rocker_port, 1671 struct switchdev_notifier_fdb_info *info) 1672 { 1673 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1674 1675 if (!wops->port_obj_fdb_add) 1676 return -EOPNOTSUPP; 1677 1678 return wops->port_obj_fdb_add(rocker_port, info->vid, info->addr); 1679 } 1680 1681 static int 1682 rocker_world_port_fdb_del(struct rocker_port *rocker_port, 1683 struct switchdev_notifier_fdb_info *info) 1684 { 1685 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1686 1687 if (!wops->port_obj_fdb_del) 1688 return -EOPNOTSUPP; 1689 return wops->port_obj_fdb_del(rocker_port, info->vid, info->addr); 1690 } 1691 1692 static int rocker_world_port_master_linked(struct rocker_port *rocker_port, 1693 struct net_device *master) 1694 { 1695 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1696 1697 if (!wops->port_master_linked) 1698 return -EOPNOTSUPP; 1699 return wops->port_master_linked(rocker_port, master); 1700 } 1701 1702 static int rocker_world_port_master_unlinked(struct rocker_port *rocker_port, 1703 struct net_device *master) 1704 { 1705 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1706 1707 if (!wops->port_master_unlinked) 1708 return -EOPNOTSUPP; 1709 return wops->port_master_unlinked(rocker_port, master); 1710 } 1711 1712 static int rocker_world_port_neigh_update(struct rocker_port *rocker_port, 1713 struct neighbour *n) 1714 { 1715 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1716 1717 if (!wops->port_neigh_update) 1718 return -EOPNOTSUPP; 1719 return wops->port_neigh_update(rocker_port, n); 1720 } 1721 1722 static int rocker_world_port_neigh_destroy(struct rocker_port *rocker_port, 1723 struct neighbour *n) 1724 { 1725 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1726 1727 if (!wops->port_neigh_destroy) 1728 return -EOPNOTSUPP; 1729 return wops->port_neigh_destroy(rocker_port, n); 1730 } 1731 1732 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port *rocker_port, 1733 const unsigned char *addr, 1734 __be16 vlan_id) 1735 { 1736 struct rocker_world_ops *wops = rocker_port->rocker->wops; 1737 1738 if (!wops->port_ev_mac_vlan_seen) 1739 return -EOPNOTSUPP; 1740 return wops->port_ev_mac_vlan_seen(rocker_port, addr, vlan_id); 1741 } 1742 1743 static int rocker_world_fib4_add(struct rocker *rocker, 1744 const struct fib_entry_notifier_info *fen_info) 1745 { 1746 struct rocker_world_ops *wops = rocker->wops; 1747 1748 if (!wops->fib4_add) 1749 return 0; 1750 return wops->fib4_add(rocker, fen_info); 1751 } 1752 1753 static int rocker_world_fib4_del(struct rocker *rocker, 1754 const struct fib_entry_notifier_info *fen_info) 1755 { 1756 struct rocker_world_ops *wops = rocker->wops; 1757 1758 if (!wops->fib4_del) 1759 return 0; 1760 return wops->fib4_del(rocker, fen_info); 1761 } 1762 1763 static void rocker_world_fib4_abort(struct rocker *rocker) 1764 { 1765 struct rocker_world_ops *wops = rocker->wops; 1766 1767 if (wops->fib4_abort) 1768 wops->fib4_abort(rocker); 1769 } 1770 1771 /***************** 1772 * Net device ops 1773 *****************/ 1774 1775 static int rocker_port_open(struct net_device *dev) 1776 { 1777 struct rocker_port *rocker_port = netdev_priv(dev); 1778 int err; 1779 1780 err = rocker_port_dma_rings_init(rocker_port); 1781 if (err) 1782 return err; 1783 1784 err = request_irq(rocker_msix_tx_vector(rocker_port), 1785 rocker_tx_irq_handler, 0, 1786 rocker_driver_name, rocker_port); 1787 if (err) { 1788 netdev_err(rocker_port->dev, "cannot assign tx irq\n"); 1789 goto err_request_tx_irq; 1790 } 1791 1792 err = request_irq(rocker_msix_rx_vector(rocker_port), 1793 rocker_rx_irq_handler, 0, 1794 rocker_driver_name, rocker_port); 1795 if (err) { 1796 netdev_err(rocker_port->dev, "cannot assign rx irq\n"); 1797 goto err_request_rx_irq; 1798 } 1799 1800 err = rocker_world_port_open(rocker_port); 1801 if (err) { 1802 netdev_err(rocker_port->dev, "cannot open port in world\n"); 1803 goto err_world_port_open; 1804 } 1805 1806 napi_enable(&rocker_port->napi_tx); 1807 napi_enable(&rocker_port->napi_rx); 1808 if (!dev->proto_down) 1809 rocker_port_set_enable(rocker_port, true); 1810 netif_start_queue(dev); 1811 return 0; 1812 1813 err_world_port_open: 1814 free_irq(rocker_msix_rx_vector(rocker_port), rocker_port); 1815 err_request_rx_irq: 1816 free_irq(rocker_msix_tx_vector(rocker_port), rocker_port); 1817 err_request_tx_irq: 1818 rocker_port_dma_rings_fini(rocker_port); 1819 return err; 1820 } 1821 1822 static int rocker_port_stop(struct net_device *dev) 1823 { 1824 struct rocker_port *rocker_port = netdev_priv(dev); 1825 1826 netif_stop_queue(dev); 1827 rocker_port_set_enable(rocker_port, false); 1828 napi_disable(&rocker_port->napi_rx); 1829 napi_disable(&rocker_port->napi_tx); 1830 rocker_world_port_stop(rocker_port); 1831 free_irq(rocker_msix_rx_vector(rocker_port), rocker_port); 1832 free_irq(rocker_msix_tx_vector(rocker_port), rocker_port); 1833 rocker_port_dma_rings_fini(rocker_port); 1834 1835 return 0; 1836 } 1837 1838 static void rocker_tx_desc_frags_unmap(const struct rocker_port *rocker_port, 1839 const struct rocker_desc_info *desc_info) 1840 { 1841 const struct rocker *rocker = rocker_port->rocker; 1842 struct pci_dev *pdev = rocker->pdev; 1843 const struct rocker_tlv *attrs[ROCKER_TLV_TX_MAX + 1]; 1844 struct rocker_tlv *attr; 1845 int rem; 1846 1847 rocker_tlv_parse_desc(attrs, ROCKER_TLV_TX_MAX, desc_info); 1848 if (!attrs[ROCKER_TLV_TX_FRAGS]) 1849 return; 1850 rocker_tlv_for_each_nested(attr, attrs[ROCKER_TLV_TX_FRAGS], rem) { 1851 const struct rocker_tlv *frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_MAX + 1]; 1852 dma_addr_t dma_handle; 1853 size_t len; 1854 1855 if (rocker_tlv_type(attr) != ROCKER_TLV_TX_FRAG) 1856 continue; 1857 rocker_tlv_parse_nested(frag_attrs, ROCKER_TLV_TX_FRAG_ATTR_MAX, 1858 attr); 1859 if (!frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] || 1860 !frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) 1861 continue; 1862 dma_handle = rocker_tlv_get_u64(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]); 1863 len = rocker_tlv_get_u16(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN]); 1864 dma_unmap_single(&pdev->dev, dma_handle, len, DMA_TO_DEVICE); 1865 } 1866 } 1867 1868 static int rocker_tx_desc_frag_map_put(const struct rocker_port *rocker_port, 1869 struct rocker_desc_info *desc_info, 1870 char *buf, size_t buf_len) 1871 { 1872 const struct rocker *rocker = rocker_port->rocker; 1873 struct pci_dev *pdev = rocker->pdev; 1874 dma_addr_t dma_handle; 1875 struct rocker_tlv *frag; 1876 1877 dma_handle = dma_map_single(&pdev->dev, buf, buf_len, DMA_TO_DEVICE); 1878 if (unlikely(dma_mapping_error(&pdev->dev, dma_handle))) { 1879 if (net_ratelimit()) 1880 netdev_err(rocker_port->dev, "failed to dma map tx frag\n"); 1881 return -EIO; 1882 } 1883 frag = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAG); 1884 if (!frag) 1885 goto unmap_frag; 1886 if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_TX_FRAG_ATTR_ADDR, 1887 dma_handle)) 1888 goto nest_cancel; 1889 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_TX_FRAG_ATTR_LEN, 1890 buf_len)) 1891 goto nest_cancel; 1892 rocker_tlv_nest_end(desc_info, frag); 1893 return 0; 1894 1895 nest_cancel: 1896 rocker_tlv_nest_cancel(desc_info, frag); 1897 unmap_frag: 1898 dma_unmap_single(&pdev->dev, dma_handle, buf_len, DMA_TO_DEVICE); 1899 return -EMSGSIZE; 1900 } 1901 1902 static netdev_tx_t rocker_port_xmit(struct sk_buff *skb, struct net_device *dev) 1903 { 1904 struct rocker_port *rocker_port = netdev_priv(dev); 1905 struct rocker *rocker = rocker_port->rocker; 1906 struct rocker_desc_info *desc_info; 1907 struct rocker_tlv *frags; 1908 int i; 1909 int err; 1910 1911 desc_info = rocker_desc_head_get(&rocker_port->tx_ring); 1912 if (unlikely(!desc_info)) { 1913 if (net_ratelimit()) 1914 netdev_err(dev, "tx ring full when queue awake\n"); 1915 return NETDEV_TX_BUSY; 1916 } 1917 1918 rocker_desc_cookie_ptr_set(desc_info, skb); 1919 1920 frags = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAGS); 1921 if (!frags) 1922 goto out; 1923 err = rocker_tx_desc_frag_map_put(rocker_port, desc_info, 1924 skb->data, skb_headlen(skb)); 1925 if (err) 1926 goto nest_cancel; 1927 if (skb_shinfo(skb)->nr_frags > ROCKER_TX_FRAGS_MAX) { 1928 err = skb_linearize(skb); 1929 if (err) 1930 goto unmap_frags; 1931 } 1932 1933 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 1934 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 1935 1936 err = rocker_tx_desc_frag_map_put(rocker_port, desc_info, 1937 skb_frag_address(frag), 1938 skb_frag_size(frag)); 1939 if (err) 1940 goto unmap_frags; 1941 } 1942 rocker_tlv_nest_end(desc_info, frags); 1943 1944 rocker_desc_gen_clear(desc_info); 1945 rocker_desc_head_set(rocker, &rocker_port->tx_ring, desc_info); 1946 1947 desc_info = rocker_desc_head_get(&rocker_port->tx_ring); 1948 if (!desc_info) 1949 netif_stop_queue(dev); 1950 1951 return NETDEV_TX_OK; 1952 1953 unmap_frags: 1954 rocker_tx_desc_frags_unmap(rocker_port, desc_info); 1955 nest_cancel: 1956 rocker_tlv_nest_cancel(desc_info, frags); 1957 out: 1958 dev_kfree_skb(skb); 1959 dev->stats.tx_dropped++; 1960 1961 return NETDEV_TX_OK; 1962 } 1963 1964 static int rocker_port_set_mac_address(struct net_device *dev, void *p) 1965 { 1966 struct sockaddr *addr = p; 1967 struct rocker_port *rocker_port = netdev_priv(dev); 1968 int err; 1969 1970 if (!is_valid_ether_addr(addr->sa_data)) 1971 return -EADDRNOTAVAIL; 1972 1973 err = rocker_cmd_set_port_settings_macaddr(rocker_port, addr->sa_data); 1974 if (err) 1975 return err; 1976 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 1977 return 0; 1978 } 1979 1980 static int rocker_port_change_mtu(struct net_device *dev, int new_mtu) 1981 { 1982 struct rocker_port *rocker_port = netdev_priv(dev); 1983 int running = netif_running(dev); 1984 int err; 1985 1986 if (running) 1987 rocker_port_stop(dev); 1988 1989 netdev_info(dev, "MTU change from %d to %d\n", dev->mtu, new_mtu); 1990 dev->mtu = new_mtu; 1991 1992 err = rocker_cmd_set_port_settings_mtu(rocker_port, new_mtu); 1993 if (err) 1994 return err; 1995 1996 if (running) 1997 err = rocker_port_open(dev); 1998 1999 return err; 2000 } 2001 2002 static int rocker_port_get_phys_port_name(struct net_device *dev, 2003 char *buf, size_t len) 2004 { 2005 struct rocker_port *rocker_port = netdev_priv(dev); 2006 struct port_name name = { .buf = buf, .len = len }; 2007 int err; 2008 2009 err = rocker_cmd_exec(rocker_port, false, 2010 rocker_cmd_get_port_settings_prep, NULL, 2011 rocker_cmd_get_port_settings_phys_name_proc, 2012 &name); 2013 2014 return err ? -EOPNOTSUPP : 0; 2015 } 2016 2017 static int rocker_port_change_proto_down(struct net_device *dev, 2018 bool proto_down) 2019 { 2020 struct rocker_port *rocker_port = netdev_priv(dev); 2021 2022 if (rocker_port->dev->flags & IFF_UP) 2023 rocker_port_set_enable(rocker_port, !proto_down); 2024 rocker_port->dev->proto_down = proto_down; 2025 return 0; 2026 } 2027 2028 static void rocker_port_neigh_destroy(struct net_device *dev, 2029 struct neighbour *n) 2030 { 2031 struct rocker_port *rocker_port = netdev_priv(n->dev); 2032 int err; 2033 2034 err = rocker_world_port_neigh_destroy(rocker_port, n); 2035 if (err) 2036 netdev_warn(rocker_port->dev, "failed to handle neigh destroy (err %d)\n", 2037 err); 2038 } 2039 2040 static int rocker_port_get_port_parent_id(struct net_device *dev, 2041 struct netdev_phys_item_id *ppid) 2042 { 2043 const struct rocker_port *rocker_port = netdev_priv(dev); 2044 const struct rocker *rocker = rocker_port->rocker; 2045 2046 ppid->id_len = sizeof(rocker->hw.id); 2047 memcpy(&ppid->id, &rocker->hw.id, ppid->id_len); 2048 2049 return 0; 2050 } 2051 2052 static const struct net_device_ops rocker_port_netdev_ops = { 2053 .ndo_open = rocker_port_open, 2054 .ndo_stop = rocker_port_stop, 2055 .ndo_start_xmit = rocker_port_xmit, 2056 .ndo_set_mac_address = rocker_port_set_mac_address, 2057 .ndo_change_mtu = rocker_port_change_mtu, 2058 .ndo_get_phys_port_name = rocker_port_get_phys_port_name, 2059 .ndo_change_proto_down = rocker_port_change_proto_down, 2060 .ndo_neigh_destroy = rocker_port_neigh_destroy, 2061 .ndo_get_port_parent_id = rocker_port_get_port_parent_id, 2062 }; 2063 2064 /******************** 2065 * swdev interface 2066 ********************/ 2067 2068 static int rocker_port_attr_set(struct net_device *dev, 2069 const struct switchdev_attr *attr, 2070 struct switchdev_trans *trans) 2071 { 2072 struct rocker_port *rocker_port = netdev_priv(dev); 2073 int err = 0; 2074 2075 switch (attr->id) { 2076 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 2077 err = rocker_world_port_attr_stp_state_set(rocker_port, 2078 attr->u.stp_state, 2079 trans); 2080 break; 2081 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 2082 err = rocker_world_port_attr_pre_bridge_flags_set(rocker_port, 2083 attr->u.brport_flags, 2084 trans); 2085 break; 2086 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 2087 err = rocker_world_port_attr_bridge_flags_set(rocker_port, 2088 attr->u.brport_flags, 2089 trans); 2090 break; 2091 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 2092 err = rocker_world_port_attr_bridge_ageing_time_set(rocker_port, 2093 attr->u.ageing_time, 2094 trans); 2095 break; 2096 default: 2097 err = -EOPNOTSUPP; 2098 break; 2099 } 2100 2101 return err; 2102 } 2103 2104 static int rocker_port_obj_add(struct net_device *dev, 2105 const struct switchdev_obj *obj, 2106 struct switchdev_trans *trans) 2107 { 2108 struct rocker_port *rocker_port = netdev_priv(dev); 2109 int err = 0; 2110 2111 switch (obj->id) { 2112 case SWITCHDEV_OBJ_ID_PORT_VLAN: 2113 err = rocker_world_port_obj_vlan_add(rocker_port, 2114 SWITCHDEV_OBJ_PORT_VLAN(obj), 2115 trans); 2116 break; 2117 default: 2118 err = -EOPNOTSUPP; 2119 break; 2120 } 2121 2122 return err; 2123 } 2124 2125 static int rocker_port_obj_del(struct net_device *dev, 2126 const struct switchdev_obj *obj) 2127 { 2128 struct rocker_port *rocker_port = netdev_priv(dev); 2129 int err = 0; 2130 2131 switch (obj->id) { 2132 case SWITCHDEV_OBJ_ID_PORT_VLAN: 2133 err = rocker_world_port_obj_vlan_del(rocker_port, 2134 SWITCHDEV_OBJ_PORT_VLAN(obj)); 2135 break; 2136 default: 2137 err = -EOPNOTSUPP; 2138 break; 2139 } 2140 2141 return err; 2142 } 2143 2144 struct rocker_fib_event_work { 2145 struct work_struct work; 2146 union { 2147 struct fib_entry_notifier_info fen_info; 2148 struct fib_rule_notifier_info fr_info; 2149 }; 2150 struct rocker *rocker; 2151 unsigned long event; 2152 }; 2153 2154 static void rocker_router_fib_event_work(struct work_struct *work) 2155 { 2156 struct rocker_fib_event_work *fib_work = 2157 container_of(work, struct rocker_fib_event_work, work); 2158 struct rocker *rocker = fib_work->rocker; 2159 struct fib_rule *rule; 2160 int err; 2161 2162 /* Protect internal structures from changes */ 2163 rtnl_lock(); 2164 switch (fib_work->event) { 2165 case FIB_EVENT_ENTRY_REPLACE: 2166 err = rocker_world_fib4_add(rocker, &fib_work->fen_info); 2167 if (err) 2168 rocker_world_fib4_abort(rocker); 2169 fib_info_put(fib_work->fen_info.fi); 2170 break; 2171 case FIB_EVENT_ENTRY_DEL: 2172 rocker_world_fib4_del(rocker, &fib_work->fen_info); 2173 fib_info_put(fib_work->fen_info.fi); 2174 break; 2175 case FIB_EVENT_RULE_ADD: 2176 case FIB_EVENT_RULE_DEL: 2177 rule = fib_work->fr_info.rule; 2178 if (!fib4_rule_default(rule)) 2179 rocker_world_fib4_abort(rocker); 2180 fib_rule_put(rule); 2181 break; 2182 } 2183 rtnl_unlock(); 2184 kfree(fib_work); 2185 } 2186 2187 /* Called with rcu_read_lock() */ 2188 static int rocker_router_fib_event(struct notifier_block *nb, 2189 unsigned long event, void *ptr) 2190 { 2191 struct rocker *rocker = container_of(nb, struct rocker, fib_nb); 2192 struct rocker_fib_event_work *fib_work; 2193 struct fib_notifier_info *info = ptr; 2194 2195 if (info->family != AF_INET) 2196 return NOTIFY_DONE; 2197 2198 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC); 2199 if (WARN_ON(!fib_work)) 2200 return NOTIFY_BAD; 2201 2202 INIT_WORK(&fib_work->work, rocker_router_fib_event_work); 2203 fib_work->rocker = rocker; 2204 fib_work->event = event; 2205 2206 switch (event) { 2207 case FIB_EVENT_ENTRY_REPLACE: 2208 case FIB_EVENT_ENTRY_DEL: 2209 if (info->family == AF_INET) { 2210 struct fib_entry_notifier_info *fen_info = ptr; 2211 2212 if (fen_info->fi->fib_nh_is_v6) { 2213 NL_SET_ERR_MSG_MOD(info->extack, "IPv6 gateway with IPv4 route is not supported"); 2214 kfree(fib_work); 2215 return notifier_from_errno(-EINVAL); 2216 } 2217 if (fen_info->fi->nh) { 2218 NL_SET_ERR_MSG_MOD(info->extack, "IPv4 route with nexthop objects is not supported"); 2219 kfree(fib_work); 2220 return notifier_from_errno(-EINVAL); 2221 } 2222 } 2223 2224 memcpy(&fib_work->fen_info, ptr, sizeof(fib_work->fen_info)); 2225 /* Take referece on fib_info to prevent it from being 2226 * freed while work is queued. Release it afterwards. 2227 */ 2228 fib_info_hold(fib_work->fen_info.fi); 2229 break; 2230 case FIB_EVENT_RULE_ADD: 2231 case FIB_EVENT_RULE_DEL: 2232 memcpy(&fib_work->fr_info, ptr, sizeof(fib_work->fr_info)); 2233 fib_rule_get(fib_work->fr_info.rule); 2234 break; 2235 } 2236 2237 queue_work(rocker->rocker_owq, &fib_work->work); 2238 2239 return NOTIFY_DONE; 2240 } 2241 2242 /******************** 2243 * ethtool interface 2244 ********************/ 2245 2246 static int 2247 rocker_port_get_link_ksettings(struct net_device *dev, 2248 struct ethtool_link_ksettings *ecmd) 2249 { 2250 struct rocker_port *rocker_port = netdev_priv(dev); 2251 2252 return rocker_cmd_get_port_settings_ethtool(rocker_port, ecmd); 2253 } 2254 2255 static int 2256 rocker_port_set_link_ksettings(struct net_device *dev, 2257 const struct ethtool_link_ksettings *ecmd) 2258 { 2259 struct rocker_port *rocker_port = netdev_priv(dev); 2260 2261 return rocker_cmd_set_port_settings_ethtool(rocker_port, ecmd); 2262 } 2263 2264 static void rocker_port_get_drvinfo(struct net_device *dev, 2265 struct ethtool_drvinfo *drvinfo) 2266 { 2267 strlcpy(drvinfo->driver, rocker_driver_name, sizeof(drvinfo->driver)); 2268 strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version)); 2269 } 2270 2271 static struct rocker_port_stats { 2272 char str[ETH_GSTRING_LEN]; 2273 int type; 2274 } rocker_port_stats[] = { 2275 { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS, }, 2276 { "rx_bytes", ROCKER_TLV_CMD_PORT_STATS_RX_BYTES, }, 2277 { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED, }, 2278 { "rx_errors", ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS, }, 2279 2280 { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS, }, 2281 { "tx_bytes", ROCKER_TLV_CMD_PORT_STATS_TX_BYTES, }, 2282 { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED, }, 2283 { "tx_errors", ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS, }, 2284 }; 2285 2286 #define ROCKER_PORT_STATS_LEN ARRAY_SIZE(rocker_port_stats) 2287 2288 static void rocker_port_get_strings(struct net_device *netdev, u32 stringset, 2289 u8 *data) 2290 { 2291 u8 *p = data; 2292 int i; 2293 2294 switch (stringset) { 2295 case ETH_SS_STATS: 2296 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) { 2297 memcpy(p, rocker_port_stats[i].str, ETH_GSTRING_LEN); 2298 p += ETH_GSTRING_LEN; 2299 } 2300 break; 2301 } 2302 } 2303 2304 static int 2305 rocker_cmd_get_port_stats_prep(const struct rocker_port *rocker_port, 2306 struct rocker_desc_info *desc_info, 2307 void *priv) 2308 { 2309 struct rocker_tlv *cmd_stats; 2310 2311 if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, 2312 ROCKER_TLV_CMD_TYPE_GET_PORT_STATS)) 2313 return -EMSGSIZE; 2314 2315 cmd_stats = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO); 2316 if (!cmd_stats) 2317 return -EMSGSIZE; 2318 2319 if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_STATS_PPORT, 2320 rocker_port->pport)) 2321 return -EMSGSIZE; 2322 2323 rocker_tlv_nest_end(desc_info, cmd_stats); 2324 2325 return 0; 2326 } 2327 2328 static int 2329 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port *rocker_port, 2330 const struct rocker_desc_info *desc_info, 2331 void *priv) 2332 { 2333 const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1]; 2334 const struct rocker_tlv *stats_attrs[ROCKER_TLV_CMD_PORT_STATS_MAX + 1]; 2335 const struct rocker_tlv *pattr; 2336 u32 pport; 2337 u64 *data = priv; 2338 int i; 2339 2340 rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info); 2341 2342 if (!attrs[ROCKER_TLV_CMD_INFO]) 2343 return -EIO; 2344 2345 rocker_tlv_parse_nested(stats_attrs, ROCKER_TLV_CMD_PORT_STATS_MAX, 2346 attrs[ROCKER_TLV_CMD_INFO]); 2347 2348 if (!stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT]) 2349 return -EIO; 2350 2351 pport = rocker_tlv_get_u32(stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT]); 2352 if (pport != rocker_port->pport) 2353 return -EIO; 2354 2355 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) { 2356 pattr = stats_attrs[rocker_port_stats[i].type]; 2357 if (!pattr) 2358 continue; 2359 2360 data[i] = rocker_tlv_get_u64(pattr); 2361 } 2362 2363 return 0; 2364 } 2365 2366 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port *rocker_port, 2367 void *priv) 2368 { 2369 return rocker_cmd_exec(rocker_port, false, 2370 rocker_cmd_get_port_stats_prep, NULL, 2371 rocker_cmd_get_port_stats_ethtool_proc, 2372 priv); 2373 } 2374 2375 static void rocker_port_get_stats(struct net_device *dev, 2376 struct ethtool_stats *stats, u64 *data) 2377 { 2378 struct rocker_port *rocker_port = netdev_priv(dev); 2379 2380 if (rocker_cmd_get_port_stats_ethtool(rocker_port, data) != 0) { 2381 int i; 2382 2383 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); ++i) 2384 data[i] = 0; 2385 } 2386 } 2387 2388 static int rocker_port_get_sset_count(struct net_device *netdev, int sset) 2389 { 2390 switch (sset) { 2391 case ETH_SS_STATS: 2392 return ROCKER_PORT_STATS_LEN; 2393 default: 2394 return -EOPNOTSUPP; 2395 } 2396 } 2397 2398 static const struct ethtool_ops rocker_port_ethtool_ops = { 2399 .get_drvinfo = rocker_port_get_drvinfo, 2400 .get_link = ethtool_op_get_link, 2401 .get_strings = rocker_port_get_strings, 2402 .get_ethtool_stats = rocker_port_get_stats, 2403 .get_sset_count = rocker_port_get_sset_count, 2404 .get_link_ksettings = rocker_port_get_link_ksettings, 2405 .set_link_ksettings = rocker_port_set_link_ksettings, 2406 }; 2407 2408 /***************** 2409 * NAPI interface 2410 *****************/ 2411 2412 static struct rocker_port *rocker_port_napi_tx_get(struct napi_struct *napi) 2413 { 2414 return container_of(napi, struct rocker_port, napi_tx); 2415 } 2416 2417 static int rocker_port_poll_tx(struct napi_struct *napi, int budget) 2418 { 2419 struct rocker_port *rocker_port = rocker_port_napi_tx_get(napi); 2420 const struct rocker *rocker = rocker_port->rocker; 2421 const struct rocker_desc_info *desc_info; 2422 u32 credits = 0; 2423 int err; 2424 2425 /* Cleanup tx descriptors */ 2426 while ((desc_info = rocker_desc_tail_get(&rocker_port->tx_ring))) { 2427 struct sk_buff *skb; 2428 2429 err = rocker_desc_err(desc_info); 2430 if (err && net_ratelimit()) 2431 netdev_err(rocker_port->dev, "tx desc received with err %d\n", 2432 err); 2433 rocker_tx_desc_frags_unmap(rocker_port, desc_info); 2434 2435 skb = rocker_desc_cookie_ptr_get(desc_info); 2436 if (err == 0) { 2437 rocker_port->dev->stats.tx_packets++; 2438 rocker_port->dev->stats.tx_bytes += skb->len; 2439 } else { 2440 rocker_port->dev->stats.tx_errors++; 2441 } 2442 2443 dev_kfree_skb_any(skb); 2444 credits++; 2445 } 2446 2447 if (credits && netif_queue_stopped(rocker_port->dev)) 2448 netif_wake_queue(rocker_port->dev); 2449 2450 napi_complete(napi); 2451 rocker_dma_ring_credits_set(rocker, &rocker_port->tx_ring, credits); 2452 2453 return 0; 2454 } 2455 2456 static int rocker_port_rx_proc(const struct rocker *rocker, 2457 const struct rocker_port *rocker_port, 2458 struct rocker_desc_info *desc_info) 2459 { 2460 const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1]; 2461 struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info); 2462 size_t rx_len; 2463 u16 rx_flags = 0; 2464 2465 if (!skb) 2466 return -ENOENT; 2467 2468 rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info); 2469 if (!attrs[ROCKER_TLV_RX_FRAG_LEN]) 2470 return -EINVAL; 2471 if (attrs[ROCKER_TLV_RX_FLAGS]) 2472 rx_flags = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FLAGS]); 2473 2474 rocker_dma_rx_ring_skb_unmap(rocker, attrs); 2475 2476 rx_len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_LEN]); 2477 skb_put(skb, rx_len); 2478 skb->protocol = eth_type_trans(skb, rocker_port->dev); 2479 2480 if (rx_flags & ROCKER_RX_FLAGS_FWD_OFFLOAD) 2481 skb->offload_fwd_mark = 1; 2482 2483 rocker_port->dev->stats.rx_packets++; 2484 rocker_port->dev->stats.rx_bytes += skb->len; 2485 2486 netif_receive_skb(skb); 2487 2488 return rocker_dma_rx_ring_skb_alloc(rocker_port, desc_info); 2489 } 2490 2491 static struct rocker_port *rocker_port_napi_rx_get(struct napi_struct *napi) 2492 { 2493 return container_of(napi, struct rocker_port, napi_rx); 2494 } 2495 2496 static int rocker_port_poll_rx(struct napi_struct *napi, int budget) 2497 { 2498 struct rocker_port *rocker_port = rocker_port_napi_rx_get(napi); 2499 const struct rocker *rocker = rocker_port->rocker; 2500 struct rocker_desc_info *desc_info; 2501 u32 credits = 0; 2502 int err; 2503 2504 /* Process rx descriptors */ 2505 while (credits < budget && 2506 (desc_info = rocker_desc_tail_get(&rocker_port->rx_ring))) { 2507 err = rocker_desc_err(desc_info); 2508 if (err) { 2509 if (net_ratelimit()) 2510 netdev_err(rocker_port->dev, "rx desc received with err %d\n", 2511 err); 2512 } else { 2513 err = rocker_port_rx_proc(rocker, rocker_port, 2514 desc_info); 2515 if (err && net_ratelimit()) 2516 netdev_err(rocker_port->dev, "rx processing failed with err %d\n", 2517 err); 2518 } 2519 if (err) 2520 rocker_port->dev->stats.rx_errors++; 2521 2522 rocker_desc_gen_clear(desc_info); 2523 rocker_desc_head_set(rocker, &rocker_port->rx_ring, desc_info); 2524 credits++; 2525 } 2526 2527 if (credits < budget) 2528 napi_complete_done(napi, credits); 2529 2530 rocker_dma_ring_credits_set(rocker, &rocker_port->rx_ring, credits); 2531 2532 return credits; 2533 } 2534 2535 /***************** 2536 * PCI driver ops 2537 *****************/ 2538 2539 static void rocker_carrier_init(const struct rocker_port *rocker_port) 2540 { 2541 const struct rocker *rocker = rocker_port->rocker; 2542 u64 link_status = rocker_read64(rocker, PORT_PHYS_LINK_STATUS); 2543 bool link_up; 2544 2545 link_up = link_status & (1 << rocker_port->pport); 2546 if (link_up) 2547 netif_carrier_on(rocker_port->dev); 2548 else 2549 netif_carrier_off(rocker_port->dev); 2550 } 2551 2552 static void rocker_remove_ports(struct rocker *rocker) 2553 { 2554 struct rocker_port *rocker_port; 2555 int i; 2556 2557 for (i = 0; i < rocker->port_count; i++) { 2558 rocker_port = rocker->ports[i]; 2559 if (!rocker_port) 2560 continue; 2561 rocker_world_port_fini(rocker_port); 2562 unregister_netdev(rocker_port->dev); 2563 rocker_world_port_post_fini(rocker_port); 2564 free_netdev(rocker_port->dev); 2565 } 2566 rocker_world_fini(rocker); 2567 kfree(rocker->ports); 2568 } 2569 2570 static void rocker_port_dev_addr_init(struct rocker_port *rocker_port) 2571 { 2572 const struct rocker *rocker = rocker_port->rocker; 2573 const struct pci_dev *pdev = rocker->pdev; 2574 int err; 2575 2576 err = rocker_cmd_get_port_settings_macaddr(rocker_port, 2577 rocker_port->dev->dev_addr); 2578 if (err) { 2579 dev_warn(&pdev->dev, "failed to get mac address, using random\n"); 2580 eth_hw_addr_random(rocker_port->dev); 2581 } 2582 } 2583 2584 #define ROCKER_PORT_MIN_MTU ETH_MIN_MTU 2585 #define ROCKER_PORT_MAX_MTU 9000 2586 static int rocker_probe_port(struct rocker *rocker, unsigned int port_number) 2587 { 2588 struct pci_dev *pdev = rocker->pdev; 2589 struct rocker_port *rocker_port; 2590 struct net_device *dev; 2591 int err; 2592 2593 dev = alloc_etherdev(sizeof(struct rocker_port)); 2594 if (!dev) 2595 return -ENOMEM; 2596 SET_NETDEV_DEV(dev, &pdev->dev); 2597 rocker_port = netdev_priv(dev); 2598 rocker_port->dev = dev; 2599 rocker_port->rocker = rocker; 2600 rocker_port->port_number = port_number; 2601 rocker_port->pport = port_number + 1; 2602 2603 err = rocker_world_check_init(rocker_port); 2604 if (err) { 2605 dev_err(&pdev->dev, "world init failed\n"); 2606 goto err_world_check_init; 2607 } 2608 2609 rocker_port_dev_addr_init(rocker_port); 2610 dev->netdev_ops = &rocker_port_netdev_ops; 2611 dev->ethtool_ops = &rocker_port_ethtool_ops; 2612 netif_tx_napi_add(dev, &rocker_port->napi_tx, rocker_port_poll_tx, 2613 NAPI_POLL_WEIGHT); 2614 netif_napi_add(dev, &rocker_port->napi_rx, rocker_port_poll_rx, 2615 NAPI_POLL_WEIGHT); 2616 rocker_carrier_init(rocker_port); 2617 2618 dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_SG; 2619 2620 /* MTU range: 68 - 9000 */ 2621 dev->min_mtu = ROCKER_PORT_MIN_MTU; 2622 dev->max_mtu = ROCKER_PORT_MAX_MTU; 2623 2624 err = rocker_world_port_pre_init(rocker_port); 2625 if (err) { 2626 dev_err(&pdev->dev, "port world pre-init failed\n"); 2627 goto err_world_port_pre_init; 2628 } 2629 err = register_netdev(dev); 2630 if (err) { 2631 dev_err(&pdev->dev, "register_netdev failed\n"); 2632 goto err_register_netdev; 2633 } 2634 rocker->ports[port_number] = rocker_port; 2635 2636 err = rocker_world_port_init(rocker_port); 2637 if (err) { 2638 dev_err(&pdev->dev, "port world init failed\n"); 2639 goto err_world_port_init; 2640 } 2641 2642 return 0; 2643 2644 err_world_port_init: 2645 rocker->ports[port_number] = NULL; 2646 unregister_netdev(dev); 2647 err_register_netdev: 2648 rocker_world_port_post_fini(rocker_port); 2649 err_world_port_pre_init: 2650 err_world_check_init: 2651 free_netdev(dev); 2652 return err; 2653 } 2654 2655 static int rocker_probe_ports(struct rocker *rocker) 2656 { 2657 int i; 2658 size_t alloc_size; 2659 int err; 2660 2661 alloc_size = sizeof(struct rocker_port *) * rocker->port_count; 2662 rocker->ports = kzalloc(alloc_size, GFP_KERNEL); 2663 if (!rocker->ports) 2664 return -ENOMEM; 2665 for (i = 0; i < rocker->port_count; i++) { 2666 err = rocker_probe_port(rocker, i); 2667 if (err) 2668 goto remove_ports; 2669 } 2670 return 0; 2671 2672 remove_ports: 2673 rocker_remove_ports(rocker); 2674 return err; 2675 } 2676 2677 static int rocker_msix_init(struct rocker *rocker) 2678 { 2679 struct pci_dev *pdev = rocker->pdev; 2680 int msix_entries; 2681 int i; 2682 int err; 2683 2684 msix_entries = pci_msix_vec_count(pdev); 2685 if (msix_entries < 0) 2686 return msix_entries; 2687 2688 if (msix_entries != ROCKER_MSIX_VEC_COUNT(rocker->port_count)) 2689 return -EINVAL; 2690 2691 rocker->msix_entries = kmalloc_array(msix_entries, 2692 sizeof(struct msix_entry), 2693 GFP_KERNEL); 2694 if (!rocker->msix_entries) 2695 return -ENOMEM; 2696 2697 for (i = 0; i < msix_entries; i++) 2698 rocker->msix_entries[i].entry = i; 2699 2700 err = pci_enable_msix_exact(pdev, rocker->msix_entries, msix_entries); 2701 if (err < 0) 2702 goto err_enable_msix; 2703 2704 return 0; 2705 2706 err_enable_msix: 2707 kfree(rocker->msix_entries); 2708 return err; 2709 } 2710 2711 static void rocker_msix_fini(const struct rocker *rocker) 2712 { 2713 pci_disable_msix(rocker->pdev); 2714 kfree(rocker->msix_entries); 2715 } 2716 2717 static bool rocker_port_dev_check(const struct net_device *dev) 2718 { 2719 return dev->netdev_ops == &rocker_port_netdev_ops; 2720 } 2721 2722 static int 2723 rocker_switchdev_port_attr_set_event(struct net_device *netdev, 2724 struct switchdev_notifier_port_attr_info *port_attr_info) 2725 { 2726 int err; 2727 2728 err = rocker_port_attr_set(netdev, port_attr_info->attr, 2729 port_attr_info->trans); 2730 2731 port_attr_info->handled = true; 2732 return notifier_from_errno(err); 2733 } 2734 2735 struct rocker_switchdev_event_work { 2736 struct work_struct work; 2737 struct switchdev_notifier_fdb_info fdb_info; 2738 struct rocker_port *rocker_port; 2739 unsigned long event; 2740 }; 2741 2742 static void 2743 rocker_fdb_offload_notify(struct rocker_port *rocker_port, 2744 struct switchdev_notifier_fdb_info *recv_info) 2745 { 2746 struct switchdev_notifier_fdb_info info; 2747 2748 info.addr = recv_info->addr; 2749 info.vid = recv_info->vid; 2750 info.offloaded = true; 2751 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, 2752 rocker_port->dev, &info.info, NULL); 2753 } 2754 2755 static void rocker_switchdev_event_work(struct work_struct *work) 2756 { 2757 struct rocker_switchdev_event_work *switchdev_work = 2758 container_of(work, struct rocker_switchdev_event_work, work); 2759 struct rocker_port *rocker_port = switchdev_work->rocker_port; 2760 struct switchdev_notifier_fdb_info *fdb_info; 2761 int err; 2762 2763 rtnl_lock(); 2764 switch (switchdev_work->event) { 2765 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2766 fdb_info = &switchdev_work->fdb_info; 2767 if (!fdb_info->added_by_user) 2768 break; 2769 err = rocker_world_port_fdb_add(rocker_port, fdb_info); 2770 if (err) { 2771 netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err); 2772 break; 2773 } 2774 rocker_fdb_offload_notify(rocker_port, fdb_info); 2775 break; 2776 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2777 fdb_info = &switchdev_work->fdb_info; 2778 if (!fdb_info->added_by_user) 2779 break; 2780 err = rocker_world_port_fdb_del(rocker_port, fdb_info); 2781 if (err) 2782 netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err); 2783 break; 2784 } 2785 rtnl_unlock(); 2786 2787 kfree(switchdev_work->fdb_info.addr); 2788 kfree(switchdev_work); 2789 dev_put(rocker_port->dev); 2790 } 2791 2792 /* called under rcu_read_lock() */ 2793 static int rocker_switchdev_event(struct notifier_block *unused, 2794 unsigned long event, void *ptr) 2795 { 2796 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2797 struct rocker_switchdev_event_work *switchdev_work; 2798 struct switchdev_notifier_fdb_info *fdb_info = ptr; 2799 struct rocker_port *rocker_port; 2800 2801 if (!rocker_port_dev_check(dev)) 2802 return NOTIFY_DONE; 2803 2804 if (event == SWITCHDEV_PORT_ATTR_SET) 2805 return rocker_switchdev_port_attr_set_event(dev, ptr); 2806 2807 rocker_port = netdev_priv(dev); 2808 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 2809 if (WARN_ON(!switchdev_work)) 2810 return NOTIFY_BAD; 2811 2812 INIT_WORK(&switchdev_work->work, rocker_switchdev_event_work); 2813 switchdev_work->rocker_port = rocker_port; 2814 switchdev_work->event = event; 2815 2816 switch (event) { 2817 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2818 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2819 memcpy(&switchdev_work->fdb_info, ptr, 2820 sizeof(switchdev_work->fdb_info)); 2821 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 2822 if (unlikely(!switchdev_work->fdb_info.addr)) { 2823 kfree(switchdev_work); 2824 return NOTIFY_BAD; 2825 } 2826 2827 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 2828 fdb_info->addr); 2829 /* Take a reference on the rocker device */ 2830 dev_hold(dev); 2831 break; 2832 default: 2833 kfree(switchdev_work); 2834 return NOTIFY_DONE; 2835 } 2836 2837 queue_work(rocker_port->rocker->rocker_owq, 2838 &switchdev_work->work); 2839 return NOTIFY_DONE; 2840 } 2841 2842 static int 2843 rocker_switchdev_port_obj_event(unsigned long event, struct net_device *netdev, 2844 struct switchdev_notifier_port_obj_info *port_obj_info) 2845 { 2846 int err = -EOPNOTSUPP; 2847 2848 switch (event) { 2849 case SWITCHDEV_PORT_OBJ_ADD: 2850 err = rocker_port_obj_add(netdev, port_obj_info->obj, 2851 port_obj_info->trans); 2852 break; 2853 case SWITCHDEV_PORT_OBJ_DEL: 2854 err = rocker_port_obj_del(netdev, port_obj_info->obj); 2855 break; 2856 } 2857 2858 port_obj_info->handled = true; 2859 return notifier_from_errno(err); 2860 } 2861 2862 static int rocker_switchdev_blocking_event(struct notifier_block *unused, 2863 unsigned long event, void *ptr) 2864 { 2865 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2866 2867 if (!rocker_port_dev_check(dev)) 2868 return NOTIFY_DONE; 2869 2870 switch (event) { 2871 case SWITCHDEV_PORT_OBJ_ADD: 2872 case SWITCHDEV_PORT_OBJ_DEL: 2873 return rocker_switchdev_port_obj_event(event, dev, ptr); 2874 case SWITCHDEV_PORT_ATTR_SET: 2875 return rocker_switchdev_port_attr_set_event(dev, ptr); 2876 } 2877 2878 return NOTIFY_DONE; 2879 } 2880 2881 static struct notifier_block rocker_switchdev_notifier = { 2882 .notifier_call = rocker_switchdev_event, 2883 }; 2884 2885 static struct notifier_block rocker_switchdev_blocking_notifier = { 2886 .notifier_call = rocker_switchdev_blocking_event, 2887 }; 2888 2889 static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id) 2890 { 2891 struct notifier_block *nb; 2892 struct rocker *rocker; 2893 int err; 2894 2895 rocker = kzalloc(sizeof(*rocker), GFP_KERNEL); 2896 if (!rocker) 2897 return -ENOMEM; 2898 2899 err = pci_enable_device(pdev); 2900 if (err) { 2901 dev_err(&pdev->dev, "pci_enable_device failed\n"); 2902 goto err_pci_enable_device; 2903 } 2904 2905 err = pci_request_regions(pdev, rocker_driver_name); 2906 if (err) { 2907 dev_err(&pdev->dev, "pci_request_regions failed\n"); 2908 goto err_pci_request_regions; 2909 } 2910 2911 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); 2912 if (!err) { 2913 err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)); 2914 if (err) { 2915 dev_err(&pdev->dev, "dma_set_coherent_mask failed\n"); 2916 goto err_pci_set_dma_mask; 2917 } 2918 } else { 2919 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); 2920 if (err) { 2921 dev_err(&pdev->dev, "dma_set_mask failed\n"); 2922 goto err_pci_set_dma_mask; 2923 } 2924 } 2925 2926 if (pci_resource_len(pdev, 0) < ROCKER_PCI_BAR0_SIZE) { 2927 dev_err(&pdev->dev, "invalid PCI region size\n"); 2928 err = -EINVAL; 2929 goto err_pci_resource_len_check; 2930 } 2931 2932 rocker->hw_addr = ioremap(pci_resource_start(pdev, 0), 2933 pci_resource_len(pdev, 0)); 2934 if (!rocker->hw_addr) { 2935 dev_err(&pdev->dev, "ioremap failed\n"); 2936 err = -EIO; 2937 goto err_ioremap; 2938 } 2939 pci_set_master(pdev); 2940 2941 rocker->pdev = pdev; 2942 pci_set_drvdata(pdev, rocker); 2943 2944 rocker->port_count = rocker_read32(rocker, PORT_PHYS_COUNT); 2945 2946 err = rocker_msix_init(rocker); 2947 if (err) { 2948 dev_err(&pdev->dev, "MSI-X init failed\n"); 2949 goto err_msix_init; 2950 } 2951 2952 err = rocker_basic_hw_test(rocker); 2953 if (err) { 2954 dev_err(&pdev->dev, "basic hw test failed\n"); 2955 goto err_basic_hw_test; 2956 } 2957 2958 rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET); 2959 2960 err = rocker_dma_rings_init(rocker); 2961 if (err) 2962 goto err_dma_rings_init; 2963 2964 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), 2965 rocker_cmd_irq_handler, 0, 2966 rocker_driver_name, rocker); 2967 if (err) { 2968 dev_err(&pdev->dev, "cannot assign cmd irq\n"); 2969 goto err_request_cmd_irq; 2970 } 2971 2972 err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), 2973 rocker_event_irq_handler, 0, 2974 rocker_driver_name, rocker); 2975 if (err) { 2976 dev_err(&pdev->dev, "cannot assign event irq\n"); 2977 goto err_request_event_irq; 2978 } 2979 2980 rocker->rocker_owq = alloc_ordered_workqueue(rocker_driver_name, 2981 WQ_MEM_RECLAIM); 2982 if (!rocker->rocker_owq) { 2983 err = -ENOMEM; 2984 goto err_alloc_ordered_workqueue; 2985 } 2986 2987 err = rocker_probe_ports(rocker); 2988 if (err) { 2989 dev_err(&pdev->dev, "failed to probe ports\n"); 2990 goto err_probe_ports; 2991 } 2992 2993 /* Only FIBs pointing to our own netdevs are programmed into 2994 * the device, so no need to pass a callback. 2995 */ 2996 rocker->fib_nb.notifier_call = rocker_router_fib_event; 2997 err = register_fib_notifier(&init_net, &rocker->fib_nb, NULL, NULL); 2998 if (err) 2999 goto err_register_fib_notifier; 3000 3001 err = register_switchdev_notifier(&rocker_switchdev_notifier); 3002 if (err) { 3003 dev_err(&pdev->dev, "Failed to register switchdev notifier\n"); 3004 goto err_register_switchdev_notifier; 3005 } 3006 3007 nb = &rocker_switchdev_blocking_notifier; 3008 err = register_switchdev_blocking_notifier(nb); 3009 if (err) { 3010 dev_err(&pdev->dev, "Failed to register switchdev blocking notifier\n"); 3011 goto err_register_switchdev_blocking_notifier; 3012 } 3013 3014 rocker->hw.id = rocker_read64(rocker, SWITCH_ID); 3015 3016 dev_info(&pdev->dev, "Rocker switch with id %*phN\n", 3017 (int)sizeof(rocker->hw.id), &rocker->hw.id); 3018 3019 return 0; 3020 3021 err_register_switchdev_blocking_notifier: 3022 unregister_switchdev_notifier(&rocker_switchdev_notifier); 3023 err_register_switchdev_notifier: 3024 unregister_fib_notifier(&init_net, &rocker->fib_nb); 3025 err_register_fib_notifier: 3026 rocker_remove_ports(rocker); 3027 err_probe_ports: 3028 destroy_workqueue(rocker->rocker_owq); 3029 err_alloc_ordered_workqueue: 3030 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker); 3031 err_request_event_irq: 3032 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker); 3033 err_request_cmd_irq: 3034 rocker_dma_rings_fini(rocker); 3035 err_dma_rings_init: 3036 err_basic_hw_test: 3037 rocker_msix_fini(rocker); 3038 err_msix_init: 3039 iounmap(rocker->hw_addr); 3040 err_ioremap: 3041 err_pci_resource_len_check: 3042 err_pci_set_dma_mask: 3043 pci_release_regions(pdev); 3044 err_pci_request_regions: 3045 pci_disable_device(pdev); 3046 err_pci_enable_device: 3047 kfree(rocker); 3048 return err; 3049 } 3050 3051 static void rocker_remove(struct pci_dev *pdev) 3052 { 3053 struct rocker *rocker = pci_get_drvdata(pdev); 3054 struct notifier_block *nb; 3055 3056 nb = &rocker_switchdev_blocking_notifier; 3057 unregister_switchdev_blocking_notifier(nb); 3058 3059 unregister_switchdev_notifier(&rocker_switchdev_notifier); 3060 unregister_fib_notifier(&init_net, &rocker->fib_nb); 3061 rocker_remove_ports(rocker); 3062 rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET); 3063 destroy_workqueue(rocker->rocker_owq); 3064 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker); 3065 free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker); 3066 rocker_dma_rings_fini(rocker); 3067 rocker_msix_fini(rocker); 3068 iounmap(rocker->hw_addr); 3069 pci_release_regions(rocker->pdev); 3070 pci_disable_device(rocker->pdev); 3071 kfree(rocker); 3072 } 3073 3074 static struct pci_driver rocker_pci_driver = { 3075 .name = rocker_driver_name, 3076 .id_table = rocker_pci_id_table, 3077 .probe = rocker_probe, 3078 .remove = rocker_remove, 3079 }; 3080 3081 /************************************ 3082 * Net device notifier event handler 3083 ************************************/ 3084 3085 static bool rocker_port_dev_check_under(const struct net_device *dev, 3086 struct rocker *rocker) 3087 { 3088 struct rocker_port *rocker_port; 3089 3090 if (!rocker_port_dev_check(dev)) 3091 return false; 3092 3093 rocker_port = netdev_priv(dev); 3094 if (rocker_port->rocker != rocker) 3095 return false; 3096 3097 return true; 3098 } 3099 3100 struct rocker_walk_data { 3101 struct rocker *rocker; 3102 struct rocker_port *port; 3103 }; 3104 3105 static int rocker_lower_dev_walk(struct net_device *lower_dev, 3106 struct netdev_nested_priv *priv) 3107 { 3108 struct rocker_walk_data *data = (struct rocker_walk_data *)priv->data; 3109 int ret = 0; 3110 3111 if (rocker_port_dev_check_under(lower_dev, data->rocker)) { 3112 data->port = netdev_priv(lower_dev); 3113 ret = 1; 3114 } 3115 3116 return ret; 3117 } 3118 3119 struct rocker_port *rocker_port_dev_lower_find(struct net_device *dev, 3120 struct rocker *rocker) 3121 { 3122 struct netdev_nested_priv priv; 3123 struct rocker_walk_data data; 3124 3125 if (rocker_port_dev_check_under(dev, rocker)) 3126 return netdev_priv(dev); 3127 3128 data.rocker = rocker; 3129 data.port = NULL; 3130 priv.data = (void *)&data; 3131 netdev_walk_all_lower_dev(dev, rocker_lower_dev_walk, &priv); 3132 3133 return data.port; 3134 } 3135 3136 static int rocker_netdevice_event(struct notifier_block *unused, 3137 unsigned long event, void *ptr) 3138 { 3139 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 3140 struct netdev_notifier_changeupper_info *info; 3141 struct rocker_port *rocker_port; 3142 int err; 3143 3144 if (!rocker_port_dev_check(dev)) 3145 return NOTIFY_DONE; 3146 3147 switch (event) { 3148 case NETDEV_CHANGEUPPER: 3149 info = ptr; 3150 if (!info->master) 3151 goto out; 3152 rocker_port = netdev_priv(dev); 3153 if (info->linking) { 3154 err = rocker_world_port_master_linked(rocker_port, 3155 info->upper_dev); 3156 if (err) 3157 netdev_warn(dev, "failed to reflect master linked (err %d)\n", 3158 err); 3159 } else { 3160 err = rocker_world_port_master_unlinked(rocker_port, 3161 info->upper_dev); 3162 if (err) 3163 netdev_warn(dev, "failed to reflect master unlinked (err %d)\n", 3164 err); 3165 } 3166 } 3167 out: 3168 return NOTIFY_DONE; 3169 } 3170 3171 static struct notifier_block rocker_netdevice_nb __read_mostly = { 3172 .notifier_call = rocker_netdevice_event, 3173 }; 3174 3175 /************************************ 3176 * Net event notifier event handler 3177 ************************************/ 3178 3179 static int rocker_netevent_event(struct notifier_block *unused, 3180 unsigned long event, void *ptr) 3181 { 3182 struct rocker_port *rocker_port; 3183 struct net_device *dev; 3184 struct neighbour *n = ptr; 3185 int err; 3186 3187 switch (event) { 3188 case NETEVENT_NEIGH_UPDATE: 3189 if (n->tbl != &arp_tbl) 3190 return NOTIFY_DONE; 3191 dev = n->dev; 3192 if (!rocker_port_dev_check(dev)) 3193 return NOTIFY_DONE; 3194 rocker_port = netdev_priv(dev); 3195 err = rocker_world_port_neigh_update(rocker_port, n); 3196 if (err) 3197 netdev_warn(dev, "failed to handle neigh update (err %d)\n", 3198 err); 3199 break; 3200 } 3201 3202 return NOTIFY_DONE; 3203 } 3204 3205 static struct notifier_block rocker_netevent_nb __read_mostly = { 3206 .notifier_call = rocker_netevent_event, 3207 }; 3208 3209 /*********************** 3210 * Module init and exit 3211 ***********************/ 3212 3213 static int __init rocker_module_init(void) 3214 { 3215 int err; 3216 3217 register_netdevice_notifier(&rocker_netdevice_nb); 3218 register_netevent_notifier(&rocker_netevent_nb); 3219 err = pci_register_driver(&rocker_pci_driver); 3220 if (err) 3221 goto err_pci_register_driver; 3222 return 0; 3223 3224 err_pci_register_driver: 3225 unregister_netevent_notifier(&rocker_netevent_nb); 3226 unregister_netdevice_notifier(&rocker_netdevice_nb); 3227 return err; 3228 } 3229 3230 static void __exit rocker_module_exit(void) 3231 { 3232 unregister_netevent_notifier(&rocker_netevent_nb); 3233 unregister_netdevice_notifier(&rocker_netdevice_nb); 3234 pci_unregister_driver(&rocker_pci_driver); 3235 } 3236 3237 module_init(rocker_module_init); 3238 module_exit(rocker_module_exit); 3239 3240 MODULE_LICENSE("GPL v2"); 3241 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>"); 3242 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>"); 3243 MODULE_DESCRIPTION("Rocker switch device driver"); 3244 MODULE_DEVICE_TABLE(pci, rocker_pci_id_table); 3245