drivers/net/ethernet/rocker/rocker_main.c

   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(&copy_ecmd, ecmd, sizeof(copy_ecmd));
1387
1388         return rocker_cmd_exec(rocker_port, false,
1389                                rocker_cmd_set_port_settings_ethtool_prep,
1390                                &copy_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_get(struct net_device *dev,
2070                                 struct switchdev_attr *attr)
2071 {
2072         const struct rocker_port *rocker_port = netdev_priv(dev);
2073         int err = 0;
2074
2075         switch (attr->id) {
2076         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
2077                 err = rocker_world_port_attr_bridge_flags_support_get(rocker_port,
2078                                                                       &attr->u.brport_flags_support);
2079                 break;
2080         default:
2081                 return -EOPNOTSUPP;
2082         }
2083
2084         return err;
2085 }
2086
2087 static int rocker_port_attr_set(struct net_device *dev,
2088                                 const struct switchdev_attr *attr,
2089                                 struct switchdev_trans *trans)
2090 {
2091         struct rocker_port *rocker_port = netdev_priv(dev);
2092         int err = 0;
2093
2094         switch (attr->id) {
2095         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
2096                 err = rocker_world_port_attr_stp_state_set(rocker_port,
2097                                                            attr->u.stp_state,
2098                                                            trans);
2099                 break;
2100         case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
2101                 err = rocker_world_port_attr_pre_bridge_flags_set(rocker_port,
2102                                                               attr->u.brport_flags,
2103                                                               trans);
2104         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
2105                 err = rocker_world_port_attr_bridge_flags_set(rocker_port,
2106                                                               attr->u.brport_flags,
2107                                                               trans);
2108                 break;
2109         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
2110                 err = rocker_world_port_attr_bridge_ageing_time_set(rocker_port,
2111                                                                     attr->u.ageing_time,
2112                                                                     trans);
2113                 break;
2114         default:
2115                 err = -EOPNOTSUPP;
2116                 break;
2117         }
2118
2119         return err;
2120 }
2121
2122 static int rocker_port_obj_add(struct net_device *dev,
2123                                const struct switchdev_obj *obj,
2124                                struct switchdev_trans *trans)
2125 {
2126         struct rocker_port *rocker_port = netdev_priv(dev);
2127         int err = 0;
2128
2129         switch (obj->id) {
2130         case SWITCHDEV_OBJ_ID_PORT_VLAN:
2131                 err = rocker_world_port_obj_vlan_add(rocker_port,
2132                                                      SWITCHDEV_OBJ_PORT_VLAN(obj),
2133                                                      trans);
2134                 break;
2135         default:
2136                 err = -EOPNOTSUPP;
2137                 break;
2138         }
2139
2140         return err;
2141 }
2142
2143 static int rocker_port_obj_del(struct net_device *dev,
2144                                const struct switchdev_obj *obj)
2145 {
2146         struct rocker_port *rocker_port = netdev_priv(dev);
2147         int err = 0;
2148
2149         switch (obj->id) {
2150         case SWITCHDEV_OBJ_ID_PORT_VLAN:
2151                 err = rocker_world_port_obj_vlan_del(rocker_port,
2152                                                      SWITCHDEV_OBJ_PORT_VLAN(obj));
2153                 break;
2154         default:
2155                 err = -EOPNOTSUPP;
2156                 break;
2157         }
2158
2159         return err;
2160 }
2161
2162 static const struct switchdev_ops rocker_port_switchdev_ops = {
2163         .switchdev_port_attr_get        = rocker_port_attr_get,
2164         .switchdev_port_attr_set        = rocker_port_attr_set,
2165 };
2166
2167 struct rocker_fib_event_work {
2168         struct work_struct work;
2169         union {
2170                 struct fib_entry_notifier_info fen_info;
2171                 struct fib_rule_notifier_info fr_info;
2172         };
2173         struct rocker *rocker;
2174         unsigned long event;
2175 };
2176
2177 static void rocker_router_fib_event_work(struct work_struct *work)
2178 {
2179         struct rocker_fib_event_work *fib_work =
2180                 container_of(work, struct rocker_fib_event_work, work);
2181         struct rocker *rocker = fib_work->rocker;
2182         struct fib_rule *rule;
2183         int err;
2184
2185         /* Protect internal structures from changes */
2186         rtnl_lock();
2187         switch (fib_work->event) {
2188         case FIB_EVENT_ENTRY_ADD:
2189                 err = rocker_world_fib4_add(rocker, &fib_work->fen_info);
2190                 if (err)
2191                         rocker_world_fib4_abort(rocker);
2192                 fib_info_put(fib_work->fen_info.fi);
2193                 break;
2194         case FIB_EVENT_ENTRY_DEL:
2195                 rocker_world_fib4_del(rocker, &fib_work->fen_info);
2196                 fib_info_put(fib_work->fen_info.fi);
2197                 break;
2198         case FIB_EVENT_RULE_ADD: /* fall through */
2199         case FIB_EVENT_RULE_DEL:
2200                 rule = fib_work->fr_info.rule;
2201                 if (!fib4_rule_default(rule))
2202                         rocker_world_fib4_abort(rocker);
2203                 fib_rule_put(rule);
2204                 break;
2205         }
2206         rtnl_unlock();
2207         kfree(fib_work);
2208 }
2209
2210 /* Called with rcu_read_lock() */
2211 static int rocker_router_fib_event(struct notifier_block *nb,
2212                                    unsigned long event, void *ptr)
2213 {
2214         struct rocker *rocker = container_of(nb, struct rocker, fib_nb);
2215         struct rocker_fib_event_work *fib_work;
2216         struct fib_notifier_info *info = ptr;
2217
2218         if (info->family != AF_INET)
2219                 return NOTIFY_DONE;
2220
2221         fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
2222         if (WARN_ON(!fib_work))
2223                 return NOTIFY_BAD;
2224
2225         INIT_WORK(&fib_work->work, rocker_router_fib_event_work);
2226         fib_work->rocker = rocker;
2227         fib_work->event = event;
2228
2229         switch (event) {
2230         case FIB_EVENT_ENTRY_ADD: /* fall through */
2231         case FIB_EVENT_ENTRY_DEL:
2232                 memcpy(&fib_work->fen_info, ptr, sizeof(fib_work->fen_info));
2233                 /* Take referece on fib_info to prevent it from being
2234                  * freed while work is queued. Release it afterwards.
2235                  */
2236                 fib_info_hold(fib_work->fen_info.fi);
2237                 break;
2238         case FIB_EVENT_RULE_ADD: /* fall through */
2239         case FIB_EVENT_RULE_DEL:
2240                 memcpy(&fib_work->fr_info, ptr, sizeof(fib_work->fr_info));
2241                 fib_rule_get(fib_work->fr_info.rule);
2242                 break;
2243         }
2244
2245         queue_work(rocker->rocker_owq, &fib_work->work);
2246
2247         return NOTIFY_DONE;
2248 }
2249
2250 /********************
2251  * ethtool interface
2252  ********************/
2253
2254 static int
2255 rocker_port_get_link_ksettings(struct net_device *dev,
2256                                struct ethtool_link_ksettings *ecmd)
2257 {
2258         struct rocker_port *rocker_port = netdev_priv(dev);
2259
2260         return rocker_cmd_get_port_settings_ethtool(rocker_port, ecmd);
2261 }
2262
2263 static int
2264 rocker_port_set_link_ksettings(struct net_device *dev,
2265                                const struct ethtool_link_ksettings *ecmd)
2266 {
2267         struct rocker_port *rocker_port = netdev_priv(dev);
2268
2269         return rocker_cmd_set_port_settings_ethtool(rocker_port, ecmd);
2270 }
2271
2272 static void rocker_port_get_drvinfo(struct net_device *dev,
2273                                     struct ethtool_drvinfo *drvinfo)
2274 {
2275         strlcpy(drvinfo->driver, rocker_driver_name, sizeof(drvinfo->driver));
2276         strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
2277 }
2278
2279 static struct rocker_port_stats {
2280         char str[ETH_GSTRING_LEN];
2281         int type;
2282 } rocker_port_stats[] = {
2283         { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS,    },
2284         { "rx_bytes",   ROCKER_TLV_CMD_PORT_STATS_RX_BYTES,   },
2285         { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED, },
2286         { "rx_errors",  ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS,  },
2287
2288         { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS,    },
2289         { "tx_bytes",   ROCKER_TLV_CMD_PORT_STATS_TX_BYTES,   },
2290         { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED, },
2291         { "tx_errors",  ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS,  },
2292 };
2293
2294 #define ROCKER_PORT_STATS_LEN  ARRAY_SIZE(rocker_port_stats)
2295
2296 static void rocker_port_get_strings(struct net_device *netdev, u32 stringset,
2297                                     u8 *data)
2298 {
2299         u8 *p = data;
2300         int i;
2301
2302         switch (stringset) {
2303         case ETH_SS_STATS:
2304                 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
2305                         memcpy(p, rocker_port_stats[i].str, ETH_GSTRING_LEN);
2306                         p += ETH_GSTRING_LEN;
2307                 }
2308                 break;
2309         }
2310 }
2311
2312 static int
2313 rocker_cmd_get_port_stats_prep(const struct rocker_port *rocker_port,
2314                                struct rocker_desc_info *desc_info,
2315                                void *priv)
2316 {
2317         struct rocker_tlv *cmd_stats;
2318
2319         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
2320                                ROCKER_TLV_CMD_TYPE_GET_PORT_STATS))
2321                 return -EMSGSIZE;
2322
2323         cmd_stats = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2324         if (!cmd_stats)
2325                 return -EMSGSIZE;
2326
2327         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_STATS_PPORT,
2328                                rocker_port->pport))
2329                 return -EMSGSIZE;
2330
2331         rocker_tlv_nest_end(desc_info, cmd_stats);
2332
2333         return 0;
2334 }
2335
2336 static int
2337 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port *rocker_port,
2338                                        const struct rocker_desc_info *desc_info,
2339                                        void *priv)
2340 {
2341         const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
2342         const struct rocker_tlv *stats_attrs[ROCKER_TLV_CMD_PORT_STATS_MAX + 1];
2343         const struct rocker_tlv *pattr;
2344         u32 pport;
2345         u64 *data = priv;
2346         int i;
2347
2348         rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
2349
2350         if (!attrs[ROCKER_TLV_CMD_INFO])
2351                 return -EIO;
2352
2353         rocker_tlv_parse_nested(stats_attrs, ROCKER_TLV_CMD_PORT_STATS_MAX,
2354                                 attrs[ROCKER_TLV_CMD_INFO]);
2355
2356         if (!stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT])
2357                 return -EIO;
2358
2359         pport = rocker_tlv_get_u32(stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT]);
2360         if (pport != rocker_port->pport)
2361                 return -EIO;
2362
2363         for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
2364                 pattr = stats_attrs[rocker_port_stats[i].type];
2365                 if (!pattr)
2366                         continue;
2367
2368                 data[i] = rocker_tlv_get_u64(pattr);
2369         }
2370
2371         return 0;
2372 }
2373
2374 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port *rocker_port,
2375                                              void *priv)
2376 {
2377         return rocker_cmd_exec(rocker_port, false,
2378                                rocker_cmd_get_port_stats_prep, NULL,
2379                                rocker_cmd_get_port_stats_ethtool_proc,
2380                                priv);
2381 }
2382
2383 static void rocker_port_get_stats(struct net_device *dev,
2384                                   struct ethtool_stats *stats, u64 *data)
2385 {
2386         struct rocker_port *rocker_port = netdev_priv(dev);
2387
2388         if (rocker_cmd_get_port_stats_ethtool(rocker_port, data) != 0) {
2389                 int i;
2390
2391                 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); ++i)
2392                         data[i] = 0;
2393         }
2394 }
2395
2396 static int rocker_port_get_sset_count(struct net_device *netdev, int sset)
2397 {
2398         switch (sset) {
2399         case ETH_SS_STATS:
2400                 return ROCKER_PORT_STATS_LEN;
2401         default:
2402                 return -EOPNOTSUPP;
2403         }
2404 }
2405
2406 static const struct ethtool_ops rocker_port_ethtool_ops = {
2407         .get_drvinfo            = rocker_port_get_drvinfo,
2408         .get_link               = ethtool_op_get_link,
2409         .get_strings            = rocker_port_get_strings,
2410         .get_ethtool_stats      = rocker_port_get_stats,
2411         .get_sset_count         = rocker_port_get_sset_count,
2412         .get_link_ksettings     = rocker_port_get_link_ksettings,
2413         .set_link_ksettings     = rocker_port_set_link_ksettings,
2414 };
2415
2416 /*****************
2417  * NAPI interface
2418  *****************/
2419
2420 static struct rocker_port *rocker_port_napi_tx_get(struct napi_struct *napi)
2421 {
2422         return container_of(napi, struct rocker_port, napi_tx);
2423 }
2424
2425 static int rocker_port_poll_tx(struct napi_struct *napi, int budget)
2426 {
2427         struct rocker_port *rocker_port = rocker_port_napi_tx_get(napi);
2428         const struct rocker *rocker = rocker_port->rocker;
2429         const struct rocker_desc_info *desc_info;
2430         u32 credits = 0;
2431         int err;
2432
2433         /* Cleanup tx descriptors */
2434         while ((desc_info = rocker_desc_tail_get(&rocker_port->tx_ring))) {
2435                 struct sk_buff *skb;
2436
2437                 err = rocker_desc_err(desc_info);
2438                 if (err && net_ratelimit())
2439                         netdev_err(rocker_port->dev, "tx desc received with err %d\n",
2440                                    err);
2441                 rocker_tx_desc_frags_unmap(rocker_port, desc_info);
2442
2443                 skb = rocker_desc_cookie_ptr_get(desc_info);
2444                 if (err == 0) {
2445                         rocker_port->dev->stats.tx_packets++;
2446                         rocker_port->dev->stats.tx_bytes += skb->len;
2447                 } else {
2448                         rocker_port->dev->stats.tx_errors++;
2449                 }
2450
2451                 dev_kfree_skb_any(skb);
2452                 credits++;
2453         }
2454
2455         if (credits && netif_queue_stopped(rocker_port->dev))
2456                 netif_wake_queue(rocker_port->dev);
2457
2458         napi_complete(napi);
2459         rocker_dma_ring_credits_set(rocker, &rocker_port->tx_ring, credits);
2460
2461         return 0;
2462 }
2463
2464 static int rocker_port_rx_proc(const struct rocker *rocker,
2465                                const struct rocker_port *rocker_port,
2466                                struct rocker_desc_info *desc_info)
2467 {
2468         const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1];
2469         struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info);
2470         size_t rx_len;
2471         u16 rx_flags = 0;
2472
2473         if (!skb)
2474                 return -ENOENT;
2475
2476         rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info);
2477         if (!attrs[ROCKER_TLV_RX_FRAG_LEN])
2478                 return -EINVAL;
2479         if (attrs[ROCKER_TLV_RX_FLAGS])
2480                 rx_flags = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FLAGS]);
2481
2482         rocker_dma_rx_ring_skb_unmap(rocker, attrs);
2483
2484         rx_len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_LEN]);
2485         skb_put(skb, rx_len);
2486         skb->protocol = eth_type_trans(skb, rocker_port->dev);
2487
2488         if (rx_flags & ROCKER_RX_FLAGS_FWD_OFFLOAD)
2489                 skb->offload_fwd_mark = 1;
2490
2491         rocker_port->dev->stats.rx_packets++;
2492         rocker_port->dev->stats.rx_bytes += skb->len;
2493
2494         netif_receive_skb(skb);
2495
2496         return rocker_dma_rx_ring_skb_alloc(rocker_port, desc_info);
2497 }
2498
2499 static struct rocker_port *rocker_port_napi_rx_get(struct napi_struct *napi)
2500 {
2501         return container_of(napi, struct rocker_port, napi_rx);
2502 }
2503
2504 static int rocker_port_poll_rx(struct napi_struct *napi, int budget)
2505 {
2506         struct rocker_port *rocker_port = rocker_port_napi_rx_get(napi);
2507         const struct rocker *rocker = rocker_port->rocker;
2508         struct rocker_desc_info *desc_info;
2509         u32 credits = 0;
2510         int err;
2511
2512         /* Process rx descriptors */
2513         while (credits < budget &&
2514                (desc_info = rocker_desc_tail_get(&rocker_port->rx_ring))) {
2515                 err = rocker_desc_err(desc_info);
2516                 if (err) {
2517                         if (net_ratelimit())
2518                                 netdev_err(rocker_port->dev, "rx desc received with err %d\n",
2519                                            err);
2520                 } else {
2521                         err = rocker_port_rx_proc(rocker, rocker_port,
2522                                                   desc_info);
2523                         if (err && net_ratelimit())
2524                                 netdev_err(rocker_port->dev, "rx processing failed with err %d\n",
2525                                            err);
2526                 }
2527                 if (err)
2528                         rocker_port->dev->stats.rx_errors++;
2529
2530                 rocker_desc_gen_clear(desc_info);
2531                 rocker_desc_head_set(rocker, &rocker_port->rx_ring, desc_info);
2532                 credits++;
2533         }
2534
2535         if (credits < budget)
2536                 napi_complete_done(napi, credits);
2537
2538         rocker_dma_ring_credits_set(rocker, &rocker_port->rx_ring, credits);
2539
2540         return credits;
2541 }
2542
2543 /*****************
2544  * PCI driver ops
2545  *****************/
2546
2547 static void rocker_carrier_init(const struct rocker_port *rocker_port)
2548 {
2549         const struct rocker *rocker = rocker_port->rocker;
2550         u64 link_status = rocker_read64(rocker, PORT_PHYS_LINK_STATUS);
2551         bool link_up;
2552
2553         link_up = link_status & (1 << rocker_port->pport);
2554         if (link_up)
2555                 netif_carrier_on(rocker_port->dev);
2556         else
2557                 netif_carrier_off(rocker_port->dev);
2558 }
2559
2560 static void rocker_remove_ports(struct rocker *rocker)
2561 {
2562         struct rocker_port *rocker_port;
2563         int i;
2564
2565         for (i = 0; i < rocker->port_count; i++) {
2566                 rocker_port = rocker->ports[i];
2567                 if (!rocker_port)
2568                         continue;
2569                 rocker_world_port_fini(rocker_port);
2570                 unregister_netdev(rocker_port->dev);
2571                 rocker_world_port_post_fini(rocker_port);
2572                 free_netdev(rocker_port->dev);
2573         }
2574         rocker_world_fini(rocker);
2575         kfree(rocker->ports);
2576 }
2577
2578 static void rocker_port_dev_addr_init(struct rocker_port *rocker_port)
2579 {
2580         const struct rocker *rocker = rocker_port->rocker;
2581         const struct pci_dev *pdev = rocker->pdev;
2582         int err;
2583
2584         err = rocker_cmd_get_port_settings_macaddr(rocker_port,
2585                                                    rocker_port->dev->dev_addr);
2586         if (err) {
2587                 dev_warn(&pdev->dev, "failed to get mac address, using random\n");
2588                 eth_hw_addr_random(rocker_port->dev);
2589         }
2590 }
2591
2592 #define ROCKER_PORT_MIN_MTU     ETH_MIN_MTU
2593 #define ROCKER_PORT_MAX_MTU     9000
2594 static int rocker_probe_port(struct rocker *rocker, unsigned int port_number)
2595 {
2596         struct pci_dev *pdev = rocker->pdev;
2597         struct rocker_port *rocker_port;
2598         struct net_device *dev;
2599         int err;
2600
2601         dev = alloc_etherdev(sizeof(struct rocker_port));
2602         if (!dev)
2603                 return -ENOMEM;
2604         SET_NETDEV_DEV(dev, &pdev->dev);
2605         rocker_port = netdev_priv(dev);
2606         rocker_port->dev = dev;
2607         rocker_port->rocker = rocker;
2608         rocker_port->port_number = port_number;
2609         rocker_port->pport = port_number + 1;
2610
2611         err = rocker_world_check_init(rocker_port);
2612         if (err) {
2613                 dev_err(&pdev->dev, "world init failed\n");
2614                 goto err_world_check_init;
2615         }
2616
2617         rocker_port_dev_addr_init(rocker_port);
2618         dev->netdev_ops = &rocker_port_netdev_ops;
2619         dev->ethtool_ops = &rocker_port_ethtool_ops;
2620         dev->switchdev_ops = &rocker_port_switchdev_ops;
2621         netif_tx_napi_add(dev, &rocker_port->napi_tx, rocker_port_poll_tx,
2622                           NAPI_POLL_WEIGHT);
2623         netif_napi_add(dev, &rocker_port->napi_rx, rocker_port_poll_rx,
2624                        NAPI_POLL_WEIGHT);
2625         rocker_carrier_init(rocker_port);
2626
2627         dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_SG;
2628
2629         /* MTU range: 68 - 9000 */
2630         dev->min_mtu = ROCKER_PORT_MIN_MTU;
2631         dev->max_mtu = ROCKER_PORT_MAX_MTU;
2632
2633         err = rocker_world_port_pre_init(rocker_port);
2634         if (err) {
2635                 dev_err(&pdev->dev, "port world pre-init failed\n");
2636                 goto err_world_port_pre_init;
2637         }
2638         err = register_netdev(dev);
2639         if (err) {
2640                 dev_err(&pdev->dev, "register_netdev failed\n");
2641                 goto err_register_netdev;
2642         }
2643         rocker->ports[port_number] = rocker_port;
2644
2645         err = rocker_world_port_init(rocker_port);
2646         if (err) {
2647                 dev_err(&pdev->dev, "port world init failed\n");
2648                 goto err_world_port_init;
2649         }
2650
2651         return 0;
2652
2653 err_world_port_init:
2654         rocker->ports[port_number] = NULL;
2655         unregister_netdev(dev);
2656 err_register_netdev:
2657         rocker_world_port_post_fini(rocker_port);
2658 err_world_port_pre_init:
2659 err_world_check_init:
2660         free_netdev(dev);
2661         return err;
2662 }
2663
2664 static int rocker_probe_ports(struct rocker *rocker)
2665 {
2666         int i;
2667         size_t alloc_size;
2668         int err;
2669
2670         alloc_size = sizeof(struct rocker_port *) * rocker->port_count;
2671         rocker->ports = kzalloc(alloc_size, GFP_KERNEL);
2672         if (!rocker->ports)
2673                 return -ENOMEM;
2674         for (i = 0; i < rocker->port_count; i++) {
2675                 err = rocker_probe_port(rocker, i);
2676                 if (err)
2677                         goto remove_ports;
2678         }
2679         return 0;
2680
2681 remove_ports:
2682         rocker_remove_ports(rocker);
2683         return err;
2684 }
2685
2686 static int rocker_msix_init(struct rocker *rocker)
2687 {
2688         struct pci_dev *pdev = rocker->pdev;
2689         int msix_entries;
2690         int i;
2691         int err;
2692
2693         msix_entries = pci_msix_vec_count(pdev);
2694         if (msix_entries < 0)
2695                 return msix_entries;
2696
2697         if (msix_entries != ROCKER_MSIX_VEC_COUNT(rocker->port_count))
2698                 return -EINVAL;
2699
2700         rocker->msix_entries = kmalloc_array(msix_entries,
2701                                              sizeof(struct msix_entry),
2702                                              GFP_KERNEL);
2703         if (!rocker->msix_entries)
2704                 return -ENOMEM;
2705
2706         for (i = 0; i < msix_entries; i++)
2707                 rocker->msix_entries[i].entry = i;
2708
2709         err = pci_enable_msix_exact(pdev, rocker->msix_entries, msix_entries);
2710         if (err < 0)
2711                 goto err_enable_msix;
2712
2713         return 0;
2714
2715 err_enable_msix:
2716         kfree(rocker->msix_entries);
2717         return err;
2718 }
2719
2720 static void rocker_msix_fini(const struct rocker *rocker)
2721 {
2722         pci_disable_msix(rocker->pdev);
2723         kfree(rocker->msix_entries);
2724 }
2725
2726 static bool rocker_port_dev_check(const struct net_device *dev)
2727 {
2728         return dev->netdev_ops == &rocker_port_netdev_ops;
2729 }
2730
2731 struct rocker_switchdev_event_work {
2732         struct work_struct work;
2733         struct switchdev_notifier_fdb_info fdb_info;
2734         struct rocker_port *rocker_port;
2735         unsigned long event;
2736 };
2737
2738 static void
2739 rocker_fdb_offload_notify(struct rocker_port *rocker_port,
2740                           struct switchdev_notifier_fdb_info *recv_info)
2741 {
2742         struct switchdev_notifier_fdb_info info;
2743
2744         info.addr = recv_info->addr;
2745         info.vid = recv_info->vid;
2746         info.offloaded = true;
2747         call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED,
2748                                  rocker_port->dev, &info.info, NULL);
2749 }
2750
2751 static void rocker_switchdev_event_work(struct work_struct *work)
2752 {
2753         struct rocker_switchdev_event_work *switchdev_work =
2754                 container_of(work, struct rocker_switchdev_event_work, work);
2755         struct rocker_port *rocker_port = switchdev_work->rocker_port;
2756         struct switchdev_notifier_fdb_info *fdb_info;
2757         int err;
2758
2759         rtnl_lock();
2760         switch (switchdev_work->event) {
2761         case SWITCHDEV_FDB_ADD_TO_DEVICE:
2762                 fdb_info = &switchdev_work->fdb_info;
2763                 if (!fdb_info->added_by_user)
2764                         break;
2765                 err = rocker_world_port_fdb_add(rocker_port, fdb_info);
2766                 if (err) {
2767                         netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err);
2768                         break;
2769                 }
2770                 rocker_fdb_offload_notify(rocker_port, fdb_info);
2771                 break;
2772         case SWITCHDEV_FDB_DEL_TO_DEVICE:
2773                 fdb_info = &switchdev_work->fdb_info;
2774                 if (!fdb_info->added_by_user)
2775                         break;
2776                 err = rocker_world_port_fdb_del(rocker_port, fdb_info);
2777                 if (err)
2778                         netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err);
2779                 break;
2780         }
2781         rtnl_unlock();
2782
2783         kfree(switchdev_work->fdb_info.addr);
2784         kfree(switchdev_work);
2785         dev_put(rocker_port->dev);
2786 }
2787
2788 /* called under rcu_read_lock() */
2789 static int rocker_switchdev_event(struct notifier_block *unused,
2790                                   unsigned long event, void *ptr)
2791 {
2792         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2793         struct rocker_switchdev_event_work *switchdev_work;
2794         struct switchdev_notifier_fdb_info *fdb_info = ptr;
2795         struct rocker_port *rocker_port;
2796
2797         if (!rocker_port_dev_check(dev))
2798                 return NOTIFY_DONE;
2799
2800         rocker_port = netdev_priv(dev);
2801         switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
2802         if (WARN_ON(!switchdev_work))
2803                 return NOTIFY_BAD;
2804
2805         INIT_WORK(&switchdev_work->work, rocker_switchdev_event_work);
2806         switchdev_work->rocker_port = rocker_port;
2807         switchdev_work->event = event;
2808
2809         switch (event) {
2810         case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
2811         case SWITCHDEV_FDB_DEL_TO_DEVICE:
2812                 memcpy(&switchdev_work->fdb_info, ptr,
2813                        sizeof(switchdev_work->fdb_info));
2814                 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
2815                 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
2816                                 fdb_info->addr);
2817                 /* Take a reference on the rocker device */
2818                 dev_hold(dev);
2819                 break;
2820         default:
2821                 kfree(switchdev_work);
2822                 return NOTIFY_DONE;
2823         }
2824
2825         queue_work(rocker_port->rocker->rocker_owq,
2826                    &switchdev_work->work);
2827         return NOTIFY_DONE;
2828 }
2829
2830 static int
2831 rocker_switchdev_port_obj_event(unsigned long event, struct net_device *netdev,
2832                         struct switchdev_notifier_port_obj_info *port_obj_info)
2833 {
2834         int err = -EOPNOTSUPP;
2835
2836         switch (event) {
2837         case SWITCHDEV_PORT_OBJ_ADD:
2838                 err = rocker_port_obj_add(netdev, port_obj_info->obj,
2839                                           port_obj_info->trans);
2840                 break;
2841         case SWITCHDEV_PORT_OBJ_DEL:
2842                 err = rocker_port_obj_del(netdev, port_obj_info->obj);
2843                 break;
2844         }
2845
2846         port_obj_info->handled = true;
2847         return notifier_from_errno(err);
2848 }
2849
2850 static int rocker_switchdev_blocking_event(struct notifier_block *unused,
2851                                            unsigned long event, void *ptr)
2852 {
2853         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2854
2855         if (!rocker_port_dev_check(dev))
2856                 return NOTIFY_DONE;
2857
2858         switch (event) {
2859         case SWITCHDEV_PORT_OBJ_ADD:
2860         case SWITCHDEV_PORT_OBJ_DEL:
2861                 return rocker_switchdev_port_obj_event(event, dev, ptr);
2862         }
2863
2864         return NOTIFY_DONE;
2865 }
2866
2867 static struct notifier_block rocker_switchdev_notifier = {
2868         .notifier_call = rocker_switchdev_event,
2869 };
2870
2871 static struct notifier_block rocker_switchdev_blocking_notifier = {
2872         .notifier_call = rocker_switchdev_blocking_event,
2873 };
2874
2875 static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2876 {
2877         struct notifier_block *nb;
2878         struct rocker *rocker;
2879         int err;
2880
2881         rocker = kzalloc(sizeof(*rocker), GFP_KERNEL);
2882         if (!rocker)
2883                 return -ENOMEM;
2884
2885         err = pci_enable_device(pdev);
2886         if (err) {
2887                 dev_err(&pdev->dev, "pci_enable_device failed\n");
2888                 goto err_pci_enable_device;
2889         }
2890
2891         err = pci_request_regions(pdev, rocker_driver_name);
2892         if (err) {
2893                 dev_err(&pdev->dev, "pci_request_regions failed\n");
2894                 goto err_pci_request_regions;
2895         }
2896
2897         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2898         if (!err) {
2899                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2900                 if (err) {
2901                         dev_err(&pdev->dev, "pci_set_consistent_dma_mask failed\n");
2902                         goto err_pci_set_dma_mask;
2903                 }
2904         } else {
2905                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2906                 if (err) {
2907                         dev_err(&pdev->dev, "pci_set_dma_mask failed\n");
2908                         goto err_pci_set_dma_mask;
2909                 }
2910         }
2911
2912         if (pci_resource_len(pdev, 0) < ROCKER_PCI_BAR0_SIZE) {
2913                 dev_err(&pdev->dev, "invalid PCI region size\n");
2914                 err = -EINVAL;
2915                 goto err_pci_resource_len_check;
2916         }
2917
2918         rocker->hw_addr = ioremap(pci_resource_start(pdev, 0),
2919                                   pci_resource_len(pdev, 0));
2920         if (!rocker->hw_addr) {
2921                 dev_err(&pdev->dev, "ioremap failed\n");
2922                 err = -EIO;
2923                 goto err_ioremap;
2924         }
2925         pci_set_master(pdev);
2926
2927         rocker->pdev = pdev;
2928         pci_set_drvdata(pdev, rocker);
2929
2930         rocker->port_count = rocker_read32(rocker, PORT_PHYS_COUNT);
2931
2932         err = rocker_msix_init(rocker);
2933         if (err) {
2934                 dev_err(&pdev->dev, "MSI-X init failed\n");
2935                 goto err_msix_init;
2936         }
2937
2938         err = rocker_basic_hw_test(rocker);
2939         if (err) {
2940                 dev_err(&pdev->dev, "basic hw test failed\n");
2941                 goto err_basic_hw_test;
2942         }
2943
2944         rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
2945
2946         err = rocker_dma_rings_init(rocker);
2947         if (err)
2948                 goto err_dma_rings_init;
2949
2950         err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD),
2951                           rocker_cmd_irq_handler, 0,
2952                           rocker_driver_name, rocker);
2953         if (err) {
2954                 dev_err(&pdev->dev, "cannot assign cmd irq\n");
2955                 goto err_request_cmd_irq;
2956         }
2957
2958         err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT),
2959                           rocker_event_irq_handler, 0,
2960                           rocker_driver_name, rocker);
2961         if (err) {
2962                 dev_err(&pdev->dev, "cannot assign event irq\n");
2963                 goto err_request_event_irq;
2964         }
2965
2966         rocker->rocker_owq = alloc_ordered_workqueue(rocker_driver_name,
2967                                                      WQ_MEM_RECLAIM);
2968         if (!rocker->rocker_owq) {
2969                 err = -ENOMEM;
2970                 goto err_alloc_ordered_workqueue;
2971         }
2972
2973         err = rocker_probe_ports(rocker);
2974         if (err) {
2975                 dev_err(&pdev->dev, "failed to probe ports\n");
2976                 goto err_probe_ports;
2977         }
2978
2979         /* Only FIBs pointing to our own netdevs are programmed into
2980          * the device, so no need to pass a callback.
2981          */
2982         rocker->fib_nb.notifier_call = rocker_router_fib_event;
2983         err = register_fib_notifier(&rocker->fib_nb, NULL);
2984         if (err)
2985                 goto err_register_fib_notifier;
2986
2987         err = register_switchdev_notifier(&rocker_switchdev_notifier);
2988         if (err) {
2989                 dev_err(&pdev->dev, "Failed to register switchdev notifier\n");
2990                 goto err_register_switchdev_notifier;
2991         }
2992
2993         nb = &rocker_switchdev_blocking_notifier;
2994         err = register_switchdev_blocking_notifier(nb);
2995         if (err) {
2996                 dev_err(&pdev->dev, "Failed to register switchdev blocking notifier\n");
2997                 goto err_register_switchdev_blocking_notifier;
2998         }
2999
3000         rocker->hw.id = rocker_read64(rocker, SWITCH_ID);
3001
3002         dev_info(&pdev->dev, "Rocker switch with id %*phN\n",
3003                  (int)sizeof(rocker->hw.id), &rocker->hw.id);
3004
3005         return 0;
3006
3007 err_register_switchdev_blocking_notifier:
3008         unregister_switchdev_notifier(&rocker_switchdev_notifier);
3009 err_register_switchdev_notifier:
3010         unregister_fib_notifier(&rocker->fib_nb);
3011 err_register_fib_notifier:
3012         rocker_remove_ports(rocker);
3013 err_probe_ports:
3014         destroy_workqueue(rocker->rocker_owq);
3015 err_alloc_ordered_workqueue:
3016         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
3017 err_request_event_irq:
3018         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
3019 err_request_cmd_irq:
3020         rocker_dma_rings_fini(rocker);
3021 err_dma_rings_init:
3022 err_basic_hw_test:
3023         rocker_msix_fini(rocker);
3024 err_msix_init:
3025         iounmap(rocker->hw_addr);
3026 err_ioremap:
3027 err_pci_resource_len_check:
3028 err_pci_set_dma_mask:
3029         pci_release_regions(pdev);
3030 err_pci_request_regions:
3031         pci_disable_device(pdev);
3032 err_pci_enable_device:
3033         kfree(rocker);
3034         return err;
3035 }
3036
3037 static void rocker_remove(struct pci_dev *pdev)
3038 {
3039         struct rocker *rocker = pci_get_drvdata(pdev);
3040         struct notifier_block *nb;
3041
3042         nb = &rocker_switchdev_blocking_notifier;
3043         unregister_switchdev_blocking_notifier(nb);
3044
3045         unregister_switchdev_notifier(&rocker_switchdev_notifier);
3046         unregister_fib_notifier(&rocker->fib_nb);
3047         rocker_remove_ports(rocker);
3048         rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
3049         destroy_workqueue(rocker->rocker_owq);
3050         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
3051         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
3052         rocker_dma_rings_fini(rocker);
3053         rocker_msix_fini(rocker);
3054         iounmap(rocker->hw_addr);
3055         pci_release_regions(rocker->pdev);
3056         pci_disable_device(rocker->pdev);
3057         kfree(rocker);
3058 }
3059
3060 static struct pci_driver rocker_pci_driver = {
3061         .name           = rocker_driver_name,
3062         .id_table       = rocker_pci_id_table,
3063         .probe          = rocker_probe,
3064         .remove         = rocker_remove,
3065 };
3066
3067 /************************************
3068  * Net device notifier event handler
3069  ************************************/
3070
3071 static bool rocker_port_dev_check_under(const struct net_device *dev,
3072                                         struct rocker *rocker)
3073 {
3074         struct rocker_port *rocker_port;
3075
3076         if (!rocker_port_dev_check(dev))
3077                 return false;
3078
3079         rocker_port = netdev_priv(dev);
3080         if (rocker_port->rocker != rocker)
3081                 return false;
3082
3083         return true;
3084 }
3085
3086 struct rocker_walk_data {
3087         struct rocker *rocker;
3088         struct rocker_port *port;
3089 };
3090
3091 static int rocker_lower_dev_walk(struct net_device *lower_dev, void *_data)
3092 {
3093         struct rocker_walk_data *data = _data;
3094         int ret = 0;
3095
3096         if (rocker_port_dev_check_under(lower_dev, data->rocker)) {
3097                 data->port = netdev_priv(lower_dev);
3098                 ret = 1;
3099         }
3100
3101         return ret;
3102 }
3103
3104 struct rocker_port *rocker_port_dev_lower_find(struct net_device *dev,
3105                                                struct rocker *rocker)
3106 {
3107         struct rocker_walk_data data;
3108
3109         if (rocker_port_dev_check_under(dev, rocker))
3110                 return netdev_priv(dev);
3111
3112         data.rocker = rocker;
3113         data.port = NULL;
3114         netdev_walk_all_lower_dev(dev, rocker_lower_dev_walk, &data);
3115
3116         return data.port;
3117 }
3118
3119 static int rocker_netdevice_event(struct notifier_block *unused,
3120                                   unsigned long event, void *ptr)
3121 {
3122         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3123         struct netdev_notifier_changeupper_info *info;
3124         struct rocker_port *rocker_port;
3125         int err;
3126
3127         if (!rocker_port_dev_check(dev))
3128                 return NOTIFY_DONE;
3129
3130         switch (event) {
3131         case NETDEV_CHANGEUPPER:
3132                 info = ptr;
3133                 if (!info->master)
3134                         goto out;
3135                 rocker_port = netdev_priv(dev);
3136                 if (info->linking) {
3137                         err = rocker_world_port_master_linked(rocker_port,
3138                                                               info->upper_dev);
3139                         if (err)
3140                                 netdev_warn(dev, "failed to reflect master linked (err %d)\n",
3141                                             err);
3142                 } else {
3143                         err = rocker_world_port_master_unlinked(rocker_port,
3144                                                                 info->upper_dev);
3145                         if (err)
3146                                 netdev_warn(dev, "failed to reflect master unlinked (err %d)\n",
3147                                             err);
3148                 }
3149         }
3150 out:
3151         return NOTIFY_DONE;
3152 }
3153
3154 static struct notifier_block rocker_netdevice_nb __read_mostly = {
3155         .notifier_call = rocker_netdevice_event,
3156 };
3157
3158 /************************************
3159  * Net event notifier event handler
3160  ************************************/
3161
3162 static int rocker_netevent_event(struct notifier_block *unused,
3163                                  unsigned long event, void *ptr)
3164 {
3165         struct rocker_port *rocker_port;
3166         struct net_device *dev;
3167         struct neighbour *n = ptr;
3168         int err;
3169
3170         switch (event) {
3171         case NETEVENT_NEIGH_UPDATE:
3172                 if (n->tbl != &arp_tbl)
3173                         return NOTIFY_DONE;
3174                 dev = n->dev;
3175                 if (!rocker_port_dev_check(dev))
3176                         return NOTIFY_DONE;
3177                 rocker_port = netdev_priv(dev);
3178                 err = rocker_world_port_neigh_update(rocker_port, n);
3179                 if (err)
3180                         netdev_warn(dev, "failed to handle neigh update (err %d)\n",
3181                                     err);
3182                 break;
3183         }
3184
3185         return NOTIFY_DONE;
3186 }
3187
3188 static struct notifier_block rocker_netevent_nb __read_mostly = {
3189         .notifier_call = rocker_netevent_event,
3190 };
3191
3192 /***********************
3193  * Module init and exit
3194  ***********************/
3195
3196 static int __init rocker_module_init(void)
3197 {
3198         int err;
3199
3200         register_netdevice_notifier(&rocker_netdevice_nb);
3201         register_netevent_notifier(&rocker_netevent_nb);
3202         err = pci_register_driver(&rocker_pci_driver);
3203         if (err)
3204                 goto err_pci_register_driver;
3205         return 0;
3206
3207 err_pci_register_driver:
3208         unregister_netevent_notifier(&rocker_netevent_nb);
3209         unregister_netdevice_notifier(&rocker_netdevice_nb);
3210         return err;
3211 }
3212
3213 static void __exit rocker_module_exit(void)
3214 {
3215         unregister_netevent_notifier(&rocker_netevent_nb);
3216         unregister_netdevice_notifier(&rocker_netdevice_nb);
3217         pci_unregister_driver(&rocker_pci_driver);
3218 }
3219
3220 module_init(rocker_module_init);
3221 module_exit(rocker_module_exit);
3222
3223 MODULE_LICENSE("GPL v2");
3224 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
3225 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>");
3226 MODULE_DESCRIPTION("Rocker switch device driver");
3227 MODULE_DEVICE_TABLE(pci, rocker_pci_id_table);