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