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