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         static 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         static 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_cmd_ring_waits_free(rocker);
 655 err_dma_cmd_ring_waits_alloc:
 656         rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring,
 657                                   PCI_DMA_BIDIRECTIONAL);
 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_set(struct rocker_port *rocker_port,
1570                                         unsigned long brport_flags,
1571                                         struct switchdev_trans *trans)
1572 {
1573         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1574
1575         if (!wops->port_attr_bridge_flags_set)
1576                 return -EOPNOTSUPP;
1577
1578         if (switchdev_trans_ph_prepare(trans))
1579                 return 0;
1580
1581         return wops->port_attr_bridge_flags_set(rocker_port, brport_flags,
1582                                                 trans);
1583 }
1584
1585 static int
1586 rocker_world_port_attr_bridge_flags_get(const struct rocker_port *rocker_port,
1587                                         unsigned long *p_brport_flags)
1588 {
1589         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1590
1591         if (!wops->port_attr_bridge_flags_get)
1592                 return -EOPNOTSUPP;
1593         return wops->port_attr_bridge_flags_get(rocker_port, p_brport_flags);
1594 }
1595
1596 static int
1597 rocker_world_port_attr_bridge_flags_support_get(const struct rocker_port *
1598                                                 rocker_port,
1599                                                 unsigned long *
1600                                                 p_brport_flags_support)
1601 {
1602         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1603
1604         if (!wops->port_attr_bridge_flags_support_get)
1605                 return -EOPNOTSUPP;
1606         return wops->port_attr_bridge_flags_support_get(rocker_port,
1607                                                         p_brport_flags_support);
1608 }
1609
1610 static int
1611 rocker_world_port_attr_bridge_ageing_time_set(struct rocker_port *rocker_port,
1612                                               u32 ageing_time,
1613                                               struct switchdev_trans *trans)
1614
1615 {
1616         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1617
1618         if (!wops->port_attr_bridge_ageing_time_set)
1619                 return -EOPNOTSUPP;
1620
1621         if (switchdev_trans_ph_prepare(trans))
1622                 return 0;
1623
1624         return wops->port_attr_bridge_ageing_time_set(rocker_port, ageing_time,
1625                                                       trans);
1626 }
1627
1628 static int
1629 rocker_world_port_obj_vlan_add(struct rocker_port *rocker_port,
1630                                const struct switchdev_obj_port_vlan *vlan,
1631                                struct switchdev_trans *trans)
1632 {
1633         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1634
1635         if (netif_is_bridge_master(vlan->obj.orig_dev))
1636                 return -EOPNOTSUPP;
1637
1638         if (!wops->port_obj_vlan_add)
1639                 return -EOPNOTSUPP;
1640
1641         if (switchdev_trans_ph_prepare(trans))
1642                 return 0;
1643
1644         return wops->port_obj_vlan_add(rocker_port, vlan);
1645 }
1646
1647 static int
1648 rocker_world_port_obj_vlan_del(struct rocker_port *rocker_port,
1649                                const struct switchdev_obj_port_vlan *vlan)
1650 {
1651         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1652
1653         if (netif_is_bridge_master(vlan->obj.orig_dev))
1654                 return -EOPNOTSUPP;
1655
1656         if (!wops->port_obj_vlan_del)
1657                 return -EOPNOTSUPP;
1658         return wops->port_obj_vlan_del(rocker_port, vlan);
1659 }
1660
1661 static int
1662 rocker_world_port_fdb_add(struct rocker_port *rocker_port,
1663                           struct switchdev_notifier_fdb_info *info)
1664 {
1665         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1666
1667         if (!wops->port_obj_fdb_add)
1668                 return -EOPNOTSUPP;
1669
1670         return wops->port_obj_fdb_add(rocker_port, info->vid, info->addr);
1671 }
1672
1673 static int
1674 rocker_world_port_fdb_del(struct rocker_port *rocker_port,
1675                           struct switchdev_notifier_fdb_info *info)
1676 {
1677         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1678
1679         if (!wops->port_obj_fdb_del)
1680                 return -EOPNOTSUPP;
1681         return wops->port_obj_fdb_del(rocker_port, info->vid, info->addr);
1682 }
1683
1684 static int rocker_world_port_master_linked(struct rocker_port *rocker_port,
1685                                            struct net_device *master)
1686 {
1687         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1688
1689         if (!wops->port_master_linked)
1690                 return -EOPNOTSUPP;
1691         return wops->port_master_linked(rocker_port, master);
1692 }
1693
1694 static int rocker_world_port_master_unlinked(struct rocker_port *rocker_port,
1695                                              struct net_device *master)
1696 {
1697         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1698
1699         if (!wops->port_master_unlinked)
1700                 return -EOPNOTSUPP;
1701         return wops->port_master_unlinked(rocker_port, master);
1702 }
1703
1704 static int rocker_world_port_neigh_update(struct rocker_port *rocker_port,
1705                                           struct neighbour *n)
1706 {
1707         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1708
1709         if (!wops->port_neigh_update)
1710                 return -EOPNOTSUPP;
1711         return wops->port_neigh_update(rocker_port, n);
1712 }
1713
1714 static int rocker_world_port_neigh_destroy(struct rocker_port *rocker_port,
1715                                            struct neighbour *n)
1716 {
1717         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1718
1719         if (!wops->port_neigh_destroy)
1720                 return -EOPNOTSUPP;
1721         return wops->port_neigh_destroy(rocker_port, n);
1722 }
1723
1724 static int rocker_world_port_ev_mac_vlan_seen(struct rocker_port *rocker_port,
1725                                               const unsigned char *addr,
1726                                               __be16 vlan_id)
1727 {
1728         struct rocker_world_ops *wops = rocker_port->rocker->wops;
1729
1730         if (!wops->port_ev_mac_vlan_seen)
1731                 return -EOPNOTSUPP;
1732         return wops->port_ev_mac_vlan_seen(rocker_port, addr, vlan_id);
1733 }
1734
1735 static int rocker_world_fib4_add(struct rocker *rocker,
1736                                  const struct fib_entry_notifier_info *fen_info)
1737 {
1738         struct rocker_world_ops *wops = rocker->wops;
1739
1740         if (!wops->fib4_add)
1741                 return 0;
1742         return wops->fib4_add(rocker, fen_info);
1743 }
1744
1745 static int rocker_world_fib4_del(struct rocker *rocker,
1746                                  const struct fib_entry_notifier_info *fen_info)
1747 {
1748         struct rocker_world_ops *wops = rocker->wops;
1749
1750         if (!wops->fib4_del)
1751                 return 0;
1752         return wops->fib4_del(rocker, fen_info);
1753 }
1754
1755 static void rocker_world_fib4_abort(struct rocker *rocker)
1756 {
1757         struct rocker_world_ops *wops = rocker->wops;
1758
1759         if (wops->fib4_abort)
1760                 wops->fib4_abort(rocker);
1761 }
1762
1763 /*****************
1764  * Net device ops
1765  *****************/
1766
1767 static int rocker_port_open(struct net_device *dev)
1768 {
1769         struct rocker_port *rocker_port = netdev_priv(dev);
1770         int err;
1771
1772         err = rocker_port_dma_rings_init(rocker_port);
1773         if (err)
1774                 return err;
1775
1776         err = request_irq(rocker_msix_tx_vector(rocker_port),
1777                           rocker_tx_irq_handler, 0,
1778                           rocker_driver_name, rocker_port);
1779         if (err) {
1780                 netdev_err(rocker_port->dev, "cannot assign tx irq\n");
1781                 goto err_request_tx_irq;
1782         }
1783
1784         err = request_irq(rocker_msix_rx_vector(rocker_port),
1785                           rocker_rx_irq_handler, 0,
1786                           rocker_driver_name, rocker_port);
1787         if (err) {
1788                 netdev_err(rocker_port->dev, "cannot assign rx irq\n");
1789                 goto err_request_rx_irq;
1790         }
1791
1792         err = rocker_world_port_open(rocker_port);
1793         if (err) {
1794                 netdev_err(rocker_port->dev, "cannot open port in world\n");
1795                 goto err_world_port_open;
1796         }
1797
1798         napi_enable(&rocker_port->napi_tx);
1799         napi_enable(&rocker_port->napi_rx);
1800         if (!dev->proto_down)
1801                 rocker_port_set_enable(rocker_port, true);
1802         netif_start_queue(dev);
1803         return 0;
1804
1805 err_world_port_open:
1806         free_irq(rocker_msix_rx_vector(rocker_port), rocker_port);
1807 err_request_rx_irq:
1808         free_irq(rocker_msix_tx_vector(rocker_port), rocker_port);
1809 err_request_tx_irq:
1810         rocker_port_dma_rings_fini(rocker_port);
1811         return err;
1812 }
1813
1814 static int rocker_port_stop(struct net_device *dev)
1815 {
1816         struct rocker_port *rocker_port = netdev_priv(dev);
1817
1818         netif_stop_queue(dev);
1819         rocker_port_set_enable(rocker_port, false);
1820         napi_disable(&rocker_port->napi_rx);
1821         napi_disable(&rocker_port->napi_tx);
1822         rocker_world_port_stop(rocker_port);
1823         free_irq(rocker_msix_rx_vector(rocker_port), rocker_port);
1824         free_irq(rocker_msix_tx_vector(rocker_port), rocker_port);
1825         rocker_port_dma_rings_fini(rocker_port);
1826
1827         return 0;
1828 }
1829
1830 static void rocker_tx_desc_frags_unmap(const struct rocker_port *rocker_port,
1831                                        const struct rocker_desc_info *desc_info)
1832 {
1833         const struct rocker *rocker = rocker_port->rocker;
1834         struct pci_dev *pdev = rocker->pdev;
1835         const struct rocker_tlv *attrs[ROCKER_TLV_TX_MAX + 1];
1836         struct rocker_tlv *attr;
1837         int rem;
1838
1839         rocker_tlv_parse_desc(attrs, ROCKER_TLV_TX_MAX, desc_info);
1840         if (!attrs[ROCKER_TLV_TX_FRAGS])
1841                 return;
1842         rocker_tlv_for_each_nested(attr, attrs[ROCKER_TLV_TX_FRAGS], rem) {
1843                 const struct rocker_tlv *frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_MAX + 1];
1844                 dma_addr_t dma_handle;
1845                 size_t len;
1846
1847                 if (rocker_tlv_type(attr) != ROCKER_TLV_TX_FRAG)
1848                         continue;
1849                 rocker_tlv_parse_nested(frag_attrs, ROCKER_TLV_TX_FRAG_ATTR_MAX,
1850                                         attr);
1851                 if (!frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
1852                     !frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN])
1853                         continue;
1854                 dma_handle = rocker_tlv_get_u64(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
1855                 len = rocker_tlv_get_u16(frag_attrs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
1856                 pci_unmap_single(pdev, dma_handle, len, DMA_TO_DEVICE);
1857         }
1858 }
1859
1860 static int rocker_tx_desc_frag_map_put(const struct rocker_port *rocker_port,
1861                                        struct rocker_desc_info *desc_info,
1862                                        char *buf, size_t buf_len)
1863 {
1864         const struct rocker *rocker = rocker_port->rocker;
1865         struct pci_dev *pdev = rocker->pdev;
1866         dma_addr_t dma_handle;
1867         struct rocker_tlv *frag;
1868
1869         dma_handle = pci_map_single(pdev, buf, buf_len, DMA_TO_DEVICE);
1870         if (unlikely(pci_dma_mapping_error(pdev, dma_handle))) {
1871                 if (net_ratelimit())
1872                         netdev_err(rocker_port->dev, "failed to dma map tx frag\n");
1873                 return -EIO;
1874         }
1875         frag = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAG);
1876         if (!frag)
1877                 goto unmap_frag;
1878         if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_TX_FRAG_ATTR_ADDR,
1879                                dma_handle))
1880                 goto nest_cancel;
1881         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_TX_FRAG_ATTR_LEN,
1882                                buf_len))
1883                 goto nest_cancel;
1884         rocker_tlv_nest_end(desc_info, frag);
1885         return 0;
1886
1887 nest_cancel:
1888         rocker_tlv_nest_cancel(desc_info, frag);
1889 unmap_frag:
1890         pci_unmap_single(pdev, dma_handle, buf_len, DMA_TO_DEVICE);
1891         return -EMSGSIZE;
1892 }
1893
1894 static netdev_tx_t rocker_port_xmit(struct sk_buff *skb, struct net_device *dev)
1895 {
1896         struct rocker_port *rocker_port = netdev_priv(dev);
1897         struct rocker *rocker = rocker_port->rocker;
1898         struct rocker_desc_info *desc_info;
1899         struct rocker_tlv *frags;
1900         int i;
1901         int err;
1902
1903         desc_info = rocker_desc_head_get(&rocker_port->tx_ring);
1904         if (unlikely(!desc_info)) {
1905                 if (net_ratelimit())
1906                         netdev_err(dev, "tx ring full when queue awake\n");
1907                 return NETDEV_TX_BUSY;
1908         }
1909
1910         rocker_desc_cookie_ptr_set(desc_info, skb);
1911
1912         frags = rocker_tlv_nest_start(desc_info, ROCKER_TLV_TX_FRAGS);
1913         if (!frags)
1914                 goto out;
1915         err = rocker_tx_desc_frag_map_put(rocker_port, desc_info,
1916                                           skb->data, skb_headlen(skb));
1917         if (err)
1918                 goto nest_cancel;
1919         if (skb_shinfo(skb)->nr_frags > ROCKER_TX_FRAGS_MAX) {
1920                 err = skb_linearize(skb);
1921                 if (err)
1922                         goto unmap_frags;
1923         }
1924
1925         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1926                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1927
1928                 err = rocker_tx_desc_frag_map_put(rocker_port, desc_info,
1929                                                   skb_frag_address(frag),
1930                                                   skb_frag_size(frag));
1931                 if (err)
1932                         goto unmap_frags;
1933         }
1934         rocker_tlv_nest_end(desc_info, frags);
1935
1936         rocker_desc_gen_clear(desc_info);
1937         rocker_desc_head_set(rocker, &rocker_port->tx_ring, desc_info);
1938
1939         desc_info = rocker_desc_head_get(&rocker_port->tx_ring);
1940         if (!desc_info)
1941                 netif_stop_queue(dev);
1942
1943         return NETDEV_TX_OK;
1944
1945 unmap_frags:
1946         rocker_tx_desc_frags_unmap(rocker_port, desc_info);
1947 nest_cancel:
1948         rocker_tlv_nest_cancel(desc_info, frags);
1949 out:
1950         dev_kfree_skb(skb);
1951         dev->stats.tx_dropped++;
1952
1953         return NETDEV_TX_OK;
1954 }
1955
1956 static int rocker_port_set_mac_address(struct net_device *dev, void *p)
1957 {
1958         struct sockaddr *addr = p;
1959         struct rocker_port *rocker_port = netdev_priv(dev);
1960         int err;
1961
1962         if (!is_valid_ether_addr(addr->sa_data))
1963                 return -EADDRNOTAVAIL;
1964
1965         err = rocker_cmd_set_port_settings_macaddr(rocker_port, addr->sa_data);
1966         if (err)
1967                 return err;
1968         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1969         return 0;
1970 }
1971
1972 static int rocker_port_change_mtu(struct net_device *dev, int new_mtu)
1973 {
1974         struct rocker_port *rocker_port = netdev_priv(dev);
1975         int running = netif_running(dev);
1976         int err;
1977
1978         if (running)
1979                 rocker_port_stop(dev);
1980
1981         netdev_info(dev, "MTU change from %d to %d\n", dev->mtu, new_mtu);
1982         dev->mtu = new_mtu;
1983
1984         err = rocker_cmd_set_port_settings_mtu(rocker_port, new_mtu);
1985         if (err)
1986                 return err;
1987
1988         if (running)
1989                 err = rocker_port_open(dev);
1990
1991         return err;
1992 }
1993
1994 static int rocker_port_get_phys_port_name(struct net_device *dev,
1995                                           char *buf, size_t len)
1996 {
1997         struct rocker_port *rocker_port = netdev_priv(dev);
1998         struct port_name name = { .buf = buf, .len = len };
1999         int err;
2000
2001         err = rocker_cmd_exec(rocker_port, false,
2002                               rocker_cmd_get_port_settings_prep, NULL,
2003                               rocker_cmd_get_port_settings_phys_name_proc,
2004                               &name);
2005
2006         return err ? -EOPNOTSUPP : 0;
2007 }
2008
2009 static int rocker_port_change_proto_down(struct net_device *dev,
2010                                          bool proto_down)
2011 {
2012         struct rocker_port *rocker_port = netdev_priv(dev);
2013
2014         if (rocker_port->dev->flags & IFF_UP)
2015                 rocker_port_set_enable(rocker_port, !proto_down);
2016         rocker_port->dev->proto_down = proto_down;
2017         return 0;
2018 }
2019
2020 static void rocker_port_neigh_destroy(struct net_device *dev,
2021                                       struct neighbour *n)
2022 {
2023         struct rocker_port *rocker_port = netdev_priv(n->dev);
2024         int err;
2025
2026         err = rocker_world_port_neigh_destroy(rocker_port, n);
2027         if (err)
2028                 netdev_warn(rocker_port->dev, "failed to handle neigh destroy (err %d)\n",
2029                             err);
2030 }
2031
2032 static const struct net_device_ops rocker_port_netdev_ops = {
2033         .ndo_open                       = rocker_port_open,
2034         .ndo_stop                       = rocker_port_stop,
2035         .ndo_start_xmit                 = rocker_port_xmit,
2036         .ndo_set_mac_address            = rocker_port_set_mac_address,
2037         .ndo_change_mtu                 = rocker_port_change_mtu,
2038         .ndo_get_phys_port_name         = rocker_port_get_phys_port_name,
2039         .ndo_change_proto_down          = rocker_port_change_proto_down,
2040         .ndo_neigh_destroy              = rocker_port_neigh_destroy,
2041 };
2042
2043 /********************
2044  * swdev interface
2045  ********************/
2046
2047 static int rocker_port_attr_get(struct net_device *dev,
2048                                 struct switchdev_attr *attr)
2049 {
2050         const struct rocker_port *rocker_port = netdev_priv(dev);
2051         const struct rocker *rocker = rocker_port->rocker;
2052         int err = 0;
2053
2054         switch (attr->id) {
2055         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
2056                 attr->u.ppid.id_len = sizeof(rocker->hw.id);
2057                 memcpy(&attr->u.ppid.id, &rocker->hw.id, attr->u.ppid.id_len);
2058                 break;
2059         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
2060                 err = rocker_world_port_attr_bridge_flags_get(rocker_port,
2061                                                               &attr->u.brport_flags);
2062                 break;
2063         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
2064                 err = rocker_world_port_attr_bridge_flags_support_get(rocker_port,
2065                                                                       &attr->u.brport_flags_support);
2066                 break;
2067         default:
2068                 return -EOPNOTSUPP;
2069         }
2070
2071         return err;
2072 }
2073
2074 static int rocker_port_attr_set(struct net_device *dev,
2075                                 const struct switchdev_attr *attr,
2076                                 struct switchdev_trans *trans)
2077 {
2078         struct rocker_port *rocker_port = netdev_priv(dev);
2079         int err = 0;
2080
2081         switch (attr->id) {
2082         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
2083                 err = rocker_world_port_attr_stp_state_set(rocker_port,
2084                                                            attr->u.stp_state,
2085                                                            trans);
2086                 break;
2087         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
2088                 err = rocker_world_port_attr_bridge_flags_set(rocker_port,
2089                                                               attr->u.brport_flags,
2090                                                               trans);
2091                 break;
2092         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
2093                 err = rocker_world_port_attr_bridge_ageing_time_set(rocker_port,
2094                                                                     attr->u.ageing_time,
2095                                                                     trans);
2096                 break;
2097         default:
2098                 err = -EOPNOTSUPP;
2099                 break;
2100         }
2101
2102         return err;
2103 }
2104
2105 static int rocker_port_obj_add(struct net_device *dev,
2106                                const struct switchdev_obj *obj,
2107                                struct switchdev_trans *trans)
2108 {
2109         struct rocker_port *rocker_port = netdev_priv(dev);
2110         int err = 0;
2111
2112         switch (obj->id) {
2113         case SWITCHDEV_OBJ_ID_PORT_VLAN:
2114                 err = rocker_world_port_obj_vlan_add(rocker_port,
2115                                                      SWITCHDEV_OBJ_PORT_VLAN(obj),
2116                                                      trans);
2117                 break;
2118         default:
2119                 err = -EOPNOTSUPP;
2120                 break;
2121         }
2122
2123         return err;
2124 }
2125
2126 static int rocker_port_obj_del(struct net_device *dev,
2127                                const struct switchdev_obj *obj)
2128 {
2129         struct rocker_port *rocker_port = netdev_priv(dev);
2130         int err = 0;
2131
2132         switch (obj->id) {
2133         case SWITCHDEV_OBJ_ID_PORT_VLAN:
2134                 err = rocker_world_port_obj_vlan_del(rocker_port,
2135                                                      SWITCHDEV_OBJ_PORT_VLAN(obj));
2136                 break;
2137         default:
2138                 err = -EOPNOTSUPP;
2139                 break;
2140         }
2141
2142         return err;
2143 }
2144
2145 static const struct switchdev_ops rocker_port_switchdev_ops = {
2146         .switchdev_port_attr_get        = rocker_port_attr_get,
2147         .switchdev_port_attr_set        = rocker_port_attr_set,
2148         .switchdev_port_obj_add         = rocker_port_obj_add,
2149         .switchdev_port_obj_del         = rocker_port_obj_del,
2150 };
2151
2152 struct rocker_fib_event_work {
2153         struct work_struct work;
2154         union {
2155                 struct fib_entry_notifier_info fen_info;
2156                 struct fib_rule_notifier_info fr_info;
2157         };
2158         struct rocker *rocker;
2159         unsigned long event;
2160 };
2161
2162 static void rocker_router_fib_event_work(struct work_struct *work)
2163 {
2164         struct rocker_fib_event_work *fib_work =
2165                 container_of(work, struct rocker_fib_event_work, work);
2166         struct rocker *rocker = fib_work->rocker;
2167         struct fib_rule *rule;
2168         int err;
2169
2170         /* Protect internal structures from changes */
2171         rtnl_lock();
2172         switch (fib_work->event) {
2173         case FIB_EVENT_ENTRY_ADD:
2174                 err = rocker_world_fib4_add(rocker, &fib_work->fen_info);
2175                 if (err)
2176                         rocker_world_fib4_abort(rocker);
2177                 fib_info_put(fib_work->fen_info.fi);
2178                 break;
2179         case FIB_EVENT_ENTRY_DEL:
2180                 rocker_world_fib4_del(rocker, &fib_work->fen_info);
2181                 fib_info_put(fib_work->fen_info.fi);
2182                 break;
2183         case FIB_EVENT_RULE_ADD: /* fall through */
2184         case FIB_EVENT_RULE_DEL:
2185                 rule = fib_work->fr_info.rule;
2186                 if (!fib4_rule_default(rule))
2187                         rocker_world_fib4_abort(rocker);
2188                 fib_rule_put(rule);
2189                 break;
2190         }
2191         rtnl_unlock();
2192         kfree(fib_work);
2193 }
2194
2195 /* Called with rcu_read_lock() */
2196 static int rocker_router_fib_event(struct notifier_block *nb,
2197                                    unsigned long event, void *ptr)
2198 {
2199         struct rocker *rocker = container_of(nb, struct rocker, fib_nb);
2200         struct rocker_fib_event_work *fib_work;
2201         struct fib_notifier_info *info = ptr;
2202
2203         if (info->family != AF_INET)
2204                 return NOTIFY_DONE;
2205
2206         fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
2207         if (WARN_ON(!fib_work))
2208                 return NOTIFY_BAD;
2209
2210         INIT_WORK(&fib_work->work, rocker_router_fib_event_work);
2211         fib_work->rocker = rocker;
2212         fib_work->event = event;
2213
2214         switch (event) {
2215         case FIB_EVENT_ENTRY_ADD: /* fall through */
2216         case FIB_EVENT_ENTRY_DEL:
2217                 memcpy(&fib_work->fen_info, ptr, sizeof(fib_work->fen_info));
2218                 /* Take referece on fib_info to prevent it from being
2219                  * freed while work is queued. Release it afterwards.
2220                  */
2221                 fib_info_hold(fib_work->fen_info.fi);
2222                 break;
2223         case FIB_EVENT_RULE_ADD: /* fall through */
2224         case FIB_EVENT_RULE_DEL:
2225                 memcpy(&fib_work->fr_info, ptr, sizeof(fib_work->fr_info));
2226                 fib_rule_get(fib_work->fr_info.rule);
2227                 break;
2228         }
2229
2230         queue_work(rocker->rocker_owq, &fib_work->work);
2231
2232         return NOTIFY_DONE;
2233 }
2234
2235 /********************
2236  * ethtool interface
2237  ********************/
2238
2239 static int
2240 rocker_port_get_link_ksettings(struct net_device *dev,
2241                                struct ethtool_link_ksettings *ecmd)
2242 {
2243         struct rocker_port *rocker_port = netdev_priv(dev);
2244
2245         return rocker_cmd_get_port_settings_ethtool(rocker_port, ecmd);
2246 }
2247
2248 static int
2249 rocker_port_set_link_ksettings(struct net_device *dev,
2250                                const struct ethtool_link_ksettings *ecmd)
2251 {
2252         struct rocker_port *rocker_port = netdev_priv(dev);
2253
2254         return rocker_cmd_set_port_settings_ethtool(rocker_port, ecmd);
2255 }
2256
2257 static void rocker_port_get_drvinfo(struct net_device *dev,
2258                                     struct ethtool_drvinfo *drvinfo)
2259 {
2260         strlcpy(drvinfo->driver, rocker_driver_name, sizeof(drvinfo->driver));
2261         strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
2262 }
2263
2264 static struct rocker_port_stats {
2265         char str[ETH_GSTRING_LEN];
2266         int type;
2267 } rocker_port_stats[] = {
2268         { "rx_packets", ROCKER_TLV_CMD_PORT_STATS_RX_PKTS,    },
2269         { "rx_bytes",   ROCKER_TLV_CMD_PORT_STATS_RX_BYTES,   },
2270         { "rx_dropped", ROCKER_TLV_CMD_PORT_STATS_RX_DROPPED, },
2271         { "rx_errors",  ROCKER_TLV_CMD_PORT_STATS_RX_ERRORS,  },
2272
2273         { "tx_packets", ROCKER_TLV_CMD_PORT_STATS_TX_PKTS,    },
2274         { "tx_bytes",   ROCKER_TLV_CMD_PORT_STATS_TX_BYTES,   },
2275         { "tx_dropped", ROCKER_TLV_CMD_PORT_STATS_TX_DROPPED, },
2276         { "tx_errors",  ROCKER_TLV_CMD_PORT_STATS_TX_ERRORS,  },
2277 };
2278
2279 #define ROCKER_PORT_STATS_LEN  ARRAY_SIZE(rocker_port_stats)
2280
2281 static void rocker_port_get_strings(struct net_device *netdev, u32 stringset,
2282                                     u8 *data)
2283 {
2284         u8 *p = data;
2285         int i;
2286
2287         switch (stringset) {
2288         case ETH_SS_STATS:
2289                 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
2290                         memcpy(p, rocker_port_stats[i].str, ETH_GSTRING_LEN);
2291                         p += ETH_GSTRING_LEN;
2292                 }
2293                 break;
2294         }
2295 }
2296
2297 static int
2298 rocker_cmd_get_port_stats_prep(const struct rocker_port *rocker_port,
2299                                struct rocker_desc_info *desc_info,
2300                                void *priv)
2301 {
2302         struct rocker_tlv *cmd_stats;
2303
2304         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE,
2305                                ROCKER_TLV_CMD_TYPE_GET_PORT_STATS))
2306                 return -EMSGSIZE;
2307
2308         cmd_stats = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
2309         if (!cmd_stats)
2310                 return -EMSGSIZE;
2311
2312         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_CMD_PORT_STATS_PPORT,
2313                                rocker_port->pport))
2314                 return -EMSGSIZE;
2315
2316         rocker_tlv_nest_end(desc_info, cmd_stats);
2317
2318         return 0;
2319 }
2320
2321 static int
2322 rocker_cmd_get_port_stats_ethtool_proc(const struct rocker_port *rocker_port,
2323                                        const struct rocker_desc_info *desc_info,
2324                                        void *priv)
2325 {
2326         const struct rocker_tlv *attrs[ROCKER_TLV_CMD_MAX + 1];
2327         const struct rocker_tlv *stats_attrs[ROCKER_TLV_CMD_PORT_STATS_MAX + 1];
2328         const struct rocker_tlv *pattr;
2329         u32 pport;
2330         u64 *data = priv;
2331         int i;
2332
2333         rocker_tlv_parse_desc(attrs, ROCKER_TLV_CMD_MAX, desc_info);
2334
2335         if (!attrs[ROCKER_TLV_CMD_INFO])
2336                 return -EIO;
2337
2338         rocker_tlv_parse_nested(stats_attrs, ROCKER_TLV_CMD_PORT_STATS_MAX,
2339                                 attrs[ROCKER_TLV_CMD_INFO]);
2340
2341         if (!stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT])
2342                 return -EIO;
2343
2344         pport = rocker_tlv_get_u32(stats_attrs[ROCKER_TLV_CMD_PORT_STATS_PPORT]);
2345         if (pport != rocker_port->pport)
2346                 return -EIO;
2347
2348         for (i = 0; i < ARRAY_SIZE(rocker_port_stats); i++) {
2349                 pattr = stats_attrs[rocker_port_stats[i].type];
2350                 if (!pattr)
2351                         continue;
2352
2353                 data[i] = rocker_tlv_get_u64(pattr);
2354         }
2355
2356         return 0;
2357 }
2358
2359 static int rocker_cmd_get_port_stats_ethtool(struct rocker_port *rocker_port,
2360                                              void *priv)
2361 {
2362         return rocker_cmd_exec(rocker_port, false,
2363                                rocker_cmd_get_port_stats_prep, NULL,
2364                                rocker_cmd_get_port_stats_ethtool_proc,
2365                                priv);
2366 }
2367
2368 static void rocker_port_get_stats(struct net_device *dev,
2369                                   struct ethtool_stats *stats, u64 *data)
2370 {
2371         struct rocker_port *rocker_port = netdev_priv(dev);
2372
2373         if (rocker_cmd_get_port_stats_ethtool(rocker_port, data) != 0) {
2374                 int i;
2375
2376                 for (i = 0; i < ARRAY_SIZE(rocker_port_stats); ++i)
2377                         data[i] = 0;
2378         }
2379 }
2380
2381 static int rocker_port_get_sset_count(struct net_device *netdev, int sset)
2382 {
2383         switch (sset) {
2384         case ETH_SS_STATS:
2385                 return ROCKER_PORT_STATS_LEN;
2386         default:
2387                 return -EOPNOTSUPP;
2388         }
2389 }
2390
2391 static const struct ethtool_ops rocker_port_ethtool_ops = {
2392         .get_drvinfo            = rocker_port_get_drvinfo,
2393         .get_link               = ethtool_op_get_link,
2394         .get_strings            = rocker_port_get_strings,
2395         .get_ethtool_stats      = rocker_port_get_stats,
2396         .get_sset_count         = rocker_port_get_sset_count,
2397         .get_link_ksettings     = rocker_port_get_link_ksettings,
2398         .set_link_ksettings     = rocker_port_set_link_ksettings,
2399 };
2400
2401 /*****************
2402  * NAPI interface
2403  *****************/
2404
2405 static struct rocker_port *rocker_port_napi_tx_get(struct napi_struct *napi)
2406 {
2407         return container_of(napi, struct rocker_port, napi_tx);
2408 }
2409
2410 static int rocker_port_poll_tx(struct napi_struct *napi, int budget)
2411 {
2412         struct rocker_port *rocker_port = rocker_port_napi_tx_get(napi);
2413         const struct rocker *rocker = rocker_port->rocker;
2414         const struct rocker_desc_info *desc_info;
2415         u32 credits = 0;
2416         int err;
2417
2418         /* Cleanup tx descriptors */
2419         while ((desc_info = rocker_desc_tail_get(&rocker_port->tx_ring))) {
2420                 struct sk_buff *skb;
2421
2422                 err = rocker_desc_err(desc_info);
2423                 if (err && net_ratelimit())
2424                         netdev_err(rocker_port->dev, "tx desc received with err %d\n",
2425                                    err);
2426                 rocker_tx_desc_frags_unmap(rocker_port, desc_info);
2427
2428                 skb = rocker_desc_cookie_ptr_get(desc_info);
2429                 if (err == 0) {
2430                         rocker_port->dev->stats.tx_packets++;
2431                         rocker_port->dev->stats.tx_bytes += skb->len;
2432                 } else {
2433                         rocker_port->dev->stats.tx_errors++;
2434                 }
2435
2436                 dev_kfree_skb_any(skb);
2437                 credits++;
2438         }
2439
2440         if (credits && netif_queue_stopped(rocker_port->dev))
2441                 netif_wake_queue(rocker_port->dev);
2442
2443         napi_complete(napi);
2444         rocker_dma_ring_credits_set(rocker, &rocker_port->tx_ring, credits);
2445
2446         return 0;
2447 }
2448
2449 static int rocker_port_rx_proc(const struct rocker *rocker,
2450                                const struct rocker_port *rocker_port,
2451                                struct rocker_desc_info *desc_info)
2452 {
2453         const struct rocker_tlv *attrs[ROCKER_TLV_RX_MAX + 1];
2454         struct sk_buff *skb = rocker_desc_cookie_ptr_get(desc_info);
2455         size_t rx_len;
2456         u16 rx_flags = 0;
2457
2458         if (!skb)
2459                 return -ENOENT;
2460
2461         rocker_tlv_parse_desc(attrs, ROCKER_TLV_RX_MAX, desc_info);
2462         if (!attrs[ROCKER_TLV_RX_FRAG_LEN])
2463                 return -EINVAL;
2464         if (attrs[ROCKER_TLV_RX_FLAGS])
2465                 rx_flags = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FLAGS]);
2466
2467         rocker_dma_rx_ring_skb_unmap(rocker, attrs);
2468
2469         rx_len = rocker_tlv_get_u16(attrs[ROCKER_TLV_RX_FRAG_LEN]);
2470         skb_put(skb, rx_len);
2471         skb->protocol = eth_type_trans(skb, rocker_port->dev);
2472
2473         if (rx_flags & ROCKER_RX_FLAGS_FWD_OFFLOAD)
2474                 skb->offload_fwd_mark = 1;
2475
2476         rocker_port->dev->stats.rx_packets++;
2477         rocker_port->dev->stats.rx_bytes += skb->len;
2478
2479         netif_receive_skb(skb);
2480
2481         return rocker_dma_rx_ring_skb_alloc(rocker_port, desc_info);
2482 }
2483
2484 static struct rocker_port *rocker_port_napi_rx_get(struct napi_struct *napi)
2485 {
2486         return container_of(napi, struct rocker_port, napi_rx);
2487 }
2488
2489 static int rocker_port_poll_rx(struct napi_struct *napi, int budget)
2490 {
2491         struct rocker_port *rocker_port = rocker_port_napi_rx_get(napi);
2492         const struct rocker *rocker = rocker_port->rocker;
2493         struct rocker_desc_info *desc_info;
2494         u32 credits = 0;
2495         int err;
2496
2497         /* Process rx descriptors */
2498         while (credits < budget &&
2499                (desc_info = rocker_desc_tail_get(&rocker_port->rx_ring))) {
2500                 err = rocker_desc_err(desc_info);
2501                 if (err) {
2502                         if (net_ratelimit())
2503                                 netdev_err(rocker_port->dev, "rx desc received with err %d\n",
2504                                            err);
2505                 } else {
2506                         err = rocker_port_rx_proc(rocker, rocker_port,
2507                                                   desc_info);
2508                         if (err && net_ratelimit())
2509                                 netdev_err(rocker_port->dev, "rx processing failed with err %d\n",
2510                                            err);
2511                 }
2512                 if (err)
2513                         rocker_port->dev->stats.rx_errors++;
2514
2515                 rocker_desc_gen_clear(desc_info);
2516                 rocker_desc_head_set(rocker, &rocker_port->rx_ring, desc_info);
2517                 credits++;
2518         }
2519
2520         if (credits < budget)
2521                 napi_complete_done(napi, credits);
2522
2523         rocker_dma_ring_credits_set(rocker, &rocker_port->rx_ring, credits);
2524
2525         return credits;
2526 }
2527
2528 /*****************
2529  * PCI driver ops
2530  *****************/
2531
2532 static void rocker_carrier_init(const struct rocker_port *rocker_port)
2533 {
2534         const struct rocker *rocker = rocker_port->rocker;
2535         u64 link_status = rocker_read64(rocker, PORT_PHYS_LINK_STATUS);
2536         bool link_up;
2537
2538         link_up = link_status & (1 << rocker_port->pport);
2539         if (link_up)
2540                 netif_carrier_on(rocker_port->dev);
2541         else
2542                 netif_carrier_off(rocker_port->dev);
2543 }
2544
2545 static void rocker_remove_ports(struct rocker *rocker)
2546 {
2547         struct rocker_port *rocker_port;
2548         int i;
2549
2550         for (i = 0; i < rocker->port_count; i++) {
2551                 rocker_port = rocker->ports[i];
2552                 if (!rocker_port)
2553                         continue;
2554                 rocker_world_port_fini(rocker_port);
2555                 unregister_netdev(rocker_port->dev);
2556                 rocker_world_port_post_fini(rocker_port);
2557                 free_netdev(rocker_port->dev);
2558         }
2559         rocker_world_fini(rocker);
2560         kfree(rocker->ports);
2561 }
2562
2563 static void rocker_port_dev_addr_init(struct rocker_port *rocker_port)
2564 {
2565         const struct rocker *rocker = rocker_port->rocker;
2566         const struct pci_dev *pdev = rocker->pdev;
2567         int err;
2568
2569         err = rocker_cmd_get_port_settings_macaddr(rocker_port,
2570                                                    rocker_port->dev->dev_addr);
2571         if (err) {
2572                 dev_warn(&pdev->dev, "failed to get mac address, using random\n");
2573                 eth_hw_addr_random(rocker_port->dev);
2574         }
2575 }
2576
2577 #define ROCKER_PORT_MIN_MTU     ETH_MIN_MTU
2578 #define ROCKER_PORT_MAX_MTU     9000
2579 static int rocker_probe_port(struct rocker *rocker, unsigned int port_number)
2580 {
2581         struct pci_dev *pdev = rocker->pdev;
2582         struct rocker_port *rocker_port;
2583         struct net_device *dev;
2584         int err;
2585
2586         dev = alloc_etherdev(sizeof(struct rocker_port));
2587         if (!dev)
2588                 return -ENOMEM;
2589         SET_NETDEV_DEV(dev, &pdev->dev);
2590         rocker_port = netdev_priv(dev);
2591         rocker_port->dev = dev;
2592         rocker_port->rocker = rocker;
2593         rocker_port->port_number = port_number;
2594         rocker_port->pport = port_number + 1;
2595
2596         err = rocker_world_check_init(rocker_port);
2597         if (err) {
2598                 dev_err(&pdev->dev, "world init failed\n");
2599                 goto err_world_check_init;
2600         }
2601
2602         rocker_port_dev_addr_init(rocker_port);
2603         dev->netdev_ops = &rocker_port_netdev_ops;
2604         dev->ethtool_ops = &rocker_port_ethtool_ops;
2605         dev->switchdev_ops = &rocker_port_switchdev_ops;
2606         netif_tx_napi_add(dev, &rocker_port->napi_tx, rocker_port_poll_tx,
2607                           NAPI_POLL_WEIGHT);
2608         netif_napi_add(dev, &rocker_port->napi_rx, rocker_port_poll_rx,
2609                        NAPI_POLL_WEIGHT);
2610         rocker_carrier_init(rocker_port);
2611
2612         dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_SG;
2613
2614         /* MTU range: 68 - 9000 */
2615         dev->min_mtu = ROCKER_PORT_MIN_MTU;
2616         dev->max_mtu = ROCKER_PORT_MAX_MTU;
2617
2618         err = rocker_world_port_pre_init(rocker_port);
2619         if (err) {
2620                 dev_err(&pdev->dev, "port world pre-init failed\n");
2621                 goto err_world_port_pre_init;
2622         }
2623         err = register_netdev(dev);
2624         if (err) {
2625                 dev_err(&pdev->dev, "register_netdev failed\n");
2626                 goto err_register_netdev;
2627         }
2628         rocker->ports[port_number] = rocker_port;
2629
2630         err = rocker_world_port_init(rocker_port);
2631         if (err) {
2632                 dev_err(&pdev->dev, "port world init failed\n");
2633                 goto err_world_port_init;
2634         }
2635
2636         return 0;
2637
2638 err_world_port_init:
2639         rocker->ports[port_number] = NULL;
2640         unregister_netdev(dev);
2641 err_register_netdev:
2642         rocker_world_port_post_fini(rocker_port);
2643 err_world_port_pre_init:
2644 err_world_check_init:
2645         free_netdev(dev);
2646         return err;
2647 }
2648
2649 static int rocker_probe_ports(struct rocker *rocker)
2650 {
2651         int i;
2652         size_t alloc_size;
2653         int err;
2654
2655         alloc_size = sizeof(struct rocker_port *) * rocker->port_count;
2656         rocker->ports = kzalloc(alloc_size, GFP_KERNEL);
2657         if (!rocker->ports)
2658                 return -ENOMEM;
2659         for (i = 0; i < rocker->port_count; i++) {
2660                 err = rocker_probe_port(rocker, i);
2661                 if (err)
2662                         goto remove_ports;
2663         }
2664         return 0;
2665
2666 remove_ports:
2667         rocker_remove_ports(rocker);
2668         return err;
2669 }
2670
2671 static int rocker_msix_init(struct rocker *rocker)
2672 {
2673         struct pci_dev *pdev = rocker->pdev;
2674         int msix_entries;
2675         int i;
2676         int err;
2677
2678         msix_entries = pci_msix_vec_count(pdev);
2679         if (msix_entries < 0)
2680                 return msix_entries;
2681
2682         if (msix_entries != ROCKER_MSIX_VEC_COUNT(rocker->port_count))
2683                 return -EINVAL;
2684
2685         rocker->msix_entries = kmalloc_array(msix_entries,
2686                                              sizeof(struct msix_entry),
2687                                              GFP_KERNEL);
2688         if (!rocker->msix_entries)
2689                 return -ENOMEM;
2690
2691         for (i = 0; i < msix_entries; i++)
2692                 rocker->msix_entries[i].entry = i;
2693
2694         err = pci_enable_msix_exact(pdev, rocker->msix_entries, msix_entries);
2695         if (err < 0)
2696                 goto err_enable_msix;
2697
2698         return 0;
2699
2700 err_enable_msix:
2701         kfree(rocker->msix_entries);
2702         return err;
2703 }
2704
2705 static void rocker_msix_fini(const struct rocker *rocker)
2706 {
2707         pci_disable_msix(rocker->pdev);
2708         kfree(rocker->msix_entries);
2709 }
2710
2711 static bool rocker_port_dev_check(const struct net_device *dev)
2712 {
2713         return dev->netdev_ops == &rocker_port_netdev_ops;
2714 }
2715
2716 struct rocker_switchdev_event_work {
2717         struct work_struct work;
2718         struct switchdev_notifier_fdb_info fdb_info;
2719         struct rocker_port *rocker_port;
2720         unsigned long event;
2721 };
2722
2723 static void
2724 rocker_fdb_offload_notify(struct rocker_port *rocker_port,
2725                           struct switchdev_notifier_fdb_info *recv_info)
2726 {
2727         struct switchdev_notifier_fdb_info info;
2728
2729         info.addr = recv_info->addr;
2730         info.vid = recv_info->vid;
2731         call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED,
2732                                  rocker_port->dev, &info.info);
2733 }
2734
2735 static void rocker_switchdev_event_work(struct work_struct *work)
2736 {
2737         struct rocker_switchdev_event_work *switchdev_work =
2738                 container_of(work, struct rocker_switchdev_event_work, work);
2739         struct rocker_port *rocker_port = switchdev_work->rocker_port;
2740         struct switchdev_notifier_fdb_info *fdb_info;
2741         int err;
2742
2743         rtnl_lock();
2744         switch (switchdev_work->event) {
2745         case SWITCHDEV_FDB_ADD_TO_DEVICE:
2746                 fdb_info = &switchdev_work->fdb_info;
2747                 if (!fdb_info->added_by_user)
2748                         break;
2749                 err = rocker_world_port_fdb_add(rocker_port, fdb_info);
2750                 if (err) {
2751                         netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err);
2752                         break;
2753                 }
2754                 rocker_fdb_offload_notify(rocker_port, fdb_info);
2755                 break;
2756         case SWITCHDEV_FDB_DEL_TO_DEVICE:
2757                 fdb_info = &switchdev_work->fdb_info;
2758                 if (!fdb_info->added_by_user)
2759                         break;
2760                 err = rocker_world_port_fdb_del(rocker_port, fdb_info);
2761                 if (err)
2762                         netdev_dbg(rocker_port->dev, "fdb add failed err=%d\n", err);
2763                 break;
2764         }
2765         rtnl_unlock();
2766
2767         kfree(switchdev_work->fdb_info.addr);
2768         kfree(switchdev_work);
2769         dev_put(rocker_port->dev);
2770 }
2771
2772 /* called under rcu_read_lock() */
2773 static int rocker_switchdev_event(struct notifier_block *unused,
2774                                   unsigned long event, void *ptr)
2775 {
2776         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2777         struct rocker_switchdev_event_work *switchdev_work;
2778         struct switchdev_notifier_fdb_info *fdb_info = ptr;
2779         struct rocker_port *rocker_port;
2780
2781         if (!rocker_port_dev_check(dev))
2782                 return NOTIFY_DONE;
2783
2784         rocker_port = netdev_priv(dev);
2785         switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
2786         if (WARN_ON(!switchdev_work))
2787                 return NOTIFY_BAD;
2788
2789         INIT_WORK(&switchdev_work->work, rocker_switchdev_event_work);
2790         switchdev_work->rocker_port = rocker_port;
2791         switchdev_work->event = event;
2792
2793         switch (event) {
2794         case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
2795         case SWITCHDEV_FDB_DEL_TO_DEVICE:
2796                 memcpy(&switchdev_work->fdb_info, ptr,
2797                        sizeof(switchdev_work->fdb_info));
2798                 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
2799                 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
2800                                 fdb_info->addr);
2801                 /* Take a reference on the rocker device */
2802                 dev_hold(dev);
2803                 break;
2804         default:
2805                 kfree(switchdev_work);
2806                 return NOTIFY_DONE;
2807         }
2808
2809         queue_work(rocker_port->rocker->rocker_owq,
2810                    &switchdev_work->work);
2811         return NOTIFY_DONE;
2812 }
2813
2814 static struct notifier_block rocker_switchdev_notifier = {
2815         .notifier_call = rocker_switchdev_event,
2816 };
2817
2818 static int rocker_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2819 {
2820         struct rocker *rocker;
2821         int err;
2822
2823         rocker = kzalloc(sizeof(*rocker), GFP_KERNEL);
2824         if (!rocker)
2825                 return -ENOMEM;
2826
2827         err = pci_enable_device(pdev);
2828         if (err) {
2829                 dev_err(&pdev->dev, "pci_enable_device failed\n");
2830                 goto err_pci_enable_device;
2831         }
2832
2833         err = pci_request_regions(pdev, rocker_driver_name);
2834         if (err) {
2835                 dev_err(&pdev->dev, "pci_request_regions failed\n");
2836                 goto err_pci_request_regions;
2837         }
2838
2839         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2840         if (!err) {
2841                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2842                 if (err) {
2843                         dev_err(&pdev->dev, "pci_set_consistent_dma_mask failed\n");
2844                         goto err_pci_set_dma_mask;
2845                 }
2846         } else {
2847                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2848                 if (err) {
2849                         dev_err(&pdev->dev, "pci_set_dma_mask failed\n");
2850                         goto err_pci_set_dma_mask;
2851                 }
2852         }
2853
2854         if (pci_resource_len(pdev, 0) < ROCKER_PCI_BAR0_SIZE) {
2855                 dev_err(&pdev->dev, "invalid PCI region size\n");
2856                 err = -EINVAL;
2857                 goto err_pci_resource_len_check;
2858         }
2859
2860         rocker->hw_addr = ioremap(pci_resource_start(pdev, 0),
2861                                   pci_resource_len(pdev, 0));
2862         if (!rocker->hw_addr) {
2863                 dev_err(&pdev->dev, "ioremap failed\n");
2864                 err = -EIO;
2865                 goto err_ioremap;
2866         }
2867         pci_set_master(pdev);
2868
2869         rocker->pdev = pdev;
2870         pci_set_drvdata(pdev, rocker);
2871
2872         rocker->port_count = rocker_read32(rocker, PORT_PHYS_COUNT);
2873
2874         err = rocker_msix_init(rocker);
2875         if (err) {
2876                 dev_err(&pdev->dev, "MSI-X init failed\n");
2877                 goto err_msix_init;
2878         }
2879
2880         err = rocker_basic_hw_test(rocker);
2881         if (err) {
2882                 dev_err(&pdev->dev, "basic hw test failed\n");
2883                 goto err_basic_hw_test;
2884         }
2885
2886         rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
2887
2888         err = rocker_dma_rings_init(rocker);
2889         if (err)
2890                 goto err_dma_rings_init;
2891
2892         err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD),
2893                           rocker_cmd_irq_handler, 0,
2894                           rocker_driver_name, rocker);
2895         if (err) {
2896                 dev_err(&pdev->dev, "cannot assign cmd irq\n");
2897                 goto err_request_cmd_irq;
2898         }
2899
2900         err = request_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT),
2901                           rocker_event_irq_handler, 0,
2902                           rocker_driver_name, rocker);
2903         if (err) {
2904                 dev_err(&pdev->dev, "cannot assign event irq\n");
2905                 goto err_request_event_irq;
2906         }
2907
2908         rocker->rocker_owq = alloc_ordered_workqueue(rocker_driver_name,
2909                                                      WQ_MEM_RECLAIM);
2910         if (!rocker->rocker_owq) {
2911                 err = -ENOMEM;
2912                 goto err_alloc_ordered_workqueue;
2913         }
2914
2915         err = rocker_probe_ports(rocker);
2916         if (err) {
2917                 dev_err(&pdev->dev, "failed to probe ports\n");
2918                 goto err_probe_ports;
2919         }
2920
2921         /* Only FIBs pointing to our own netdevs are programmed into
2922          * the device, so no need to pass a callback.
2923          */
2924         rocker->fib_nb.notifier_call = rocker_router_fib_event;
2925         err = register_fib_notifier(&rocker->fib_nb, NULL);
2926         if (err)
2927                 goto err_register_fib_notifier;
2928
2929         err = register_switchdev_notifier(&rocker_switchdev_notifier);
2930         if (err) {
2931                 dev_err(&pdev->dev, "Failed to register switchdev notifier\n");
2932                 goto err_register_switchdev_notifier;
2933         }
2934
2935         rocker->hw.id = rocker_read64(rocker, SWITCH_ID);
2936
2937         dev_info(&pdev->dev, "Rocker switch with id %*phN\n",
2938                  (int)sizeof(rocker->hw.id), &rocker->hw.id);
2939
2940         return 0;
2941
2942 err_register_switchdev_notifier:
2943         unregister_fib_notifier(&rocker->fib_nb);
2944 err_register_fib_notifier:
2945         rocker_remove_ports(rocker);
2946 err_probe_ports:
2947         destroy_workqueue(rocker->rocker_owq);
2948 err_alloc_ordered_workqueue:
2949         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
2950 err_request_event_irq:
2951         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
2952 err_request_cmd_irq:
2953         rocker_dma_rings_fini(rocker);
2954 err_dma_rings_init:
2955 err_basic_hw_test:
2956         rocker_msix_fini(rocker);
2957 err_msix_init:
2958         iounmap(rocker->hw_addr);
2959 err_ioremap:
2960 err_pci_resource_len_check:
2961 err_pci_set_dma_mask:
2962         pci_release_regions(pdev);
2963 err_pci_request_regions:
2964         pci_disable_device(pdev);
2965 err_pci_enable_device:
2966         kfree(rocker);
2967         return err;
2968 }
2969
2970 static void rocker_remove(struct pci_dev *pdev)
2971 {
2972         struct rocker *rocker = pci_get_drvdata(pdev);
2973
2974         unregister_switchdev_notifier(&rocker_switchdev_notifier);
2975         unregister_fib_notifier(&rocker->fib_nb);
2976         rocker_remove_ports(rocker);
2977         rocker_write32(rocker, CONTROL, ROCKER_CONTROL_RESET);
2978         destroy_workqueue(rocker->rocker_owq);
2979         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_EVENT), rocker);
2980         free_irq(rocker_msix_vector(rocker, ROCKER_MSIX_VEC_CMD), rocker);
2981         rocker_dma_rings_fini(rocker);
2982         rocker_msix_fini(rocker);
2983         iounmap(rocker->hw_addr);
2984         pci_release_regions(rocker->pdev);
2985         pci_disable_device(rocker->pdev);
2986         kfree(rocker);
2987 }
2988
2989 static struct pci_driver rocker_pci_driver = {
2990         .name           = rocker_driver_name,
2991         .id_table       = rocker_pci_id_table,
2992         .probe          = rocker_probe,
2993         .remove         = rocker_remove,
2994 };
2995
2996 /************************************
2997  * Net device notifier event handler
2998  ************************************/
2999
3000 static bool rocker_port_dev_check_under(const struct net_device *dev,
3001                                         struct rocker *rocker)
3002 {
3003         struct rocker_port *rocker_port;
3004
3005         if (!rocker_port_dev_check(dev))
3006                 return false;
3007
3008         rocker_port = netdev_priv(dev);
3009         if (rocker_port->rocker != rocker)
3010                 return false;
3011
3012         return true;
3013 }
3014
3015 struct rocker_walk_data {
3016         struct rocker *rocker;
3017         struct rocker_port *port;
3018 };
3019
3020 static int rocker_lower_dev_walk(struct net_device *lower_dev, void *_data)
3021 {
3022         struct rocker_walk_data *data = _data;
3023         int ret = 0;
3024
3025         if (rocker_port_dev_check_under(lower_dev, data->rocker)) {
3026                 data->port = netdev_priv(lower_dev);
3027                 ret = 1;
3028         }
3029
3030         return ret;
3031 }
3032
3033 struct rocker_port *rocker_port_dev_lower_find(struct net_device *dev,
3034                                                struct rocker *rocker)
3035 {
3036         struct rocker_walk_data data;
3037
3038         if (rocker_port_dev_check_under(dev, rocker))
3039                 return netdev_priv(dev);
3040
3041         data.rocker = rocker;
3042         data.port = NULL;
3043         netdev_walk_all_lower_dev(dev, rocker_lower_dev_walk, &data);
3044
3045         return data.port;
3046 }
3047
3048 static int rocker_netdevice_event(struct notifier_block *unused,
3049                                   unsigned long event, void *ptr)
3050 {
3051         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3052         struct netdev_notifier_changeupper_info *info;
3053         struct rocker_port *rocker_port;
3054         int err;
3055
3056         if (!rocker_port_dev_check(dev))
3057                 return NOTIFY_DONE;
3058
3059         switch (event) {
3060         case NETDEV_CHANGEUPPER:
3061                 info = ptr;
3062                 if (!info->master)
3063                         goto out;
3064                 rocker_port = netdev_priv(dev);
3065                 if (info->linking) {
3066                         err = rocker_world_port_master_linked(rocker_port,
3067                                                               info->upper_dev);
3068                         if (err)
3069                                 netdev_warn(dev, "failed to reflect master linked (err %d)\n",
3070                                             err);
3071                 } else {
3072                         err = rocker_world_port_master_unlinked(rocker_port,
3073                                                                 info->upper_dev);
3074                         if (err)
3075                                 netdev_warn(dev, "failed to reflect master unlinked (err %d)\n",
3076                                             err);
3077                 }
3078         }
3079 out:
3080         return NOTIFY_DONE;
3081 }
3082
3083 static struct notifier_block rocker_netdevice_nb __read_mostly = {
3084         .notifier_call = rocker_netdevice_event,
3085 };
3086
3087 /************************************
3088  * Net event notifier event handler
3089  ************************************/
3090
3091 static int rocker_netevent_event(struct notifier_block *unused,
3092                                  unsigned long event, void *ptr)
3093 {
3094         struct rocker_port *rocker_port;
3095         struct net_device *dev;
3096         struct neighbour *n = ptr;
3097         int err;
3098
3099         switch (event) {
3100         case NETEVENT_NEIGH_UPDATE:
3101                 if (n->tbl != &arp_tbl)
3102                         return NOTIFY_DONE;
3103                 dev = n->dev;
3104                 if (!rocker_port_dev_check(dev))
3105                         return NOTIFY_DONE;
3106                 rocker_port = netdev_priv(dev);
3107                 err = rocker_world_port_neigh_update(rocker_port, n);
3108                 if (err)
3109                         netdev_warn(dev, "failed to handle neigh update (err %d)\n",
3110                                     err);
3111                 break;
3112         }
3113
3114         return NOTIFY_DONE;
3115 }
3116
3117 static struct notifier_block rocker_netevent_nb __read_mostly = {
3118         .notifier_call = rocker_netevent_event,
3119 };
3120
3121 /***********************
3122  * Module init and exit
3123  ***********************/
3124
3125 static int __init rocker_module_init(void)
3126 {
3127         int err;
3128
3129         register_netdevice_notifier(&rocker_netdevice_nb);
3130         register_netevent_notifier(&rocker_netevent_nb);
3131         err = pci_register_driver(&rocker_pci_driver);
3132         if (err)
3133                 goto err_pci_register_driver;
3134         return 0;
3135
3136 err_pci_register_driver:
3137         unregister_netevent_notifier(&rocker_netevent_nb);
3138         unregister_netdevice_notifier(&rocker_netdevice_nb);
3139         return err;
3140 }
3141
3142 static void __exit rocker_module_exit(void)
3143 {
3144         unregister_netevent_notifier(&rocker_netevent_nb);
3145         unregister_netdevice_notifier(&rocker_netdevice_nb);
3146         pci_unregister_driver(&rocker_pci_driver);
3147 }
3148
3149 module_init(rocker_module_init);
3150 module_exit(rocker_module_exit);
3151
3152 MODULE_LICENSE("GPL v2");
3153 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
3154 MODULE_AUTHOR("Scott Feldman <sfeldma@gmail.com>");
3155 MODULE_DESCRIPTION("Rocker switch device driver");
3156 MODULE_DEVICE_TABLE(pci, rocker_pci_id_table);