sys/dev/netif/mxge/if_mxge.c

   1 /******************************************************************************
   2
   3 Copyright (c) 2006-2009, Myricom Inc.
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Neither the name of the Myricom Inc, nor the names of its
  13     contributors may be used to endorse or promote products derived from
  14     this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26 POSSIBILITY OF SUCH DAMAGE.
  27
  28 ***************************************************************************/
  29
  30 #include <sys/cdefs.h>
  31 /*__FBSDID("$FreeBSD: src/sys/dev/mxge/if_mxge.c,v 1.63 2009/06/26 11:45:06 rwatson Exp $");*/
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/linker.h>
  36 #include <sys/firmware.h>
  37 #include <sys/endian.h>
  38 #include <sys/in_cksum.h>
  39 #include <sys/sockio.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/malloc.h>
  42 #include <sys/kernel.h>
  43 #include <sys/module.h>
  44 #include <sys/serialize.h>
  45 #include <sys/socket.h>
  46 #include <sys/sysctl.h>
  47
  48 /* count xmits ourselves, rather than via drbr */
  49 #define NO_SLOW_STATS
  50 #include <net/if.h>
  51 #include <net/if_arp.h>
  52 #include <net/ifq_var.h>
  53 #include <net/ethernet.h>
  54 #include <net/if_dl.h>
  55 #include <net/if_media.h>
  56
  57 #include <net/bpf.h>
  58
  59 #include <net/if_types.h>
  60 #include <net/vlan/if_vlan_var.h>
  61 #include <net/zlib.h>
  62
  63 #include <netinet/in_systm.h>
  64 #include <netinet/in.h>
  65 #include <netinet/ip.h>
  66 #include <netinet/tcp.h>
  67
  68 #include <sys/bus.h>
  69 #include <sys/rman.h>
  70
  71 #include <bus/pci/pcireg.h>
  72 #include <bus/pci/pcivar.h>
  73 #include <bus/pci/pci_private.h> /* XXX for pci_cfg_restore */
  74
  75 #include <vm/vm.h>              /* for pmap_mapdev() */
  76 #include <vm/pmap.h>
  77
  78 #if defined(__i386) || defined(__amd64)
  79 #include <machine/specialreg.h>
  80 #endif
  81
  82 #include <dev/netif/mxge/mxge_mcp.h>
  83 #include <dev/netif/mxge/mcp_gen_header.h>
  84 /*#define MXGE_FAKE_IFP*/
  85 #include <dev/netif/mxge/if_mxge_var.h>
  86 #ifdef IFNET_BUF_RING
  87 #include <sys/buf_ring.h>
  88 #endif
  89
  90 #include "opt_inet.h"
  91
  92 /* tunable params */
  93 static int mxge_nvidia_ecrc_enable = 1;
  94 static int mxge_force_firmware = 0;
  95 static int mxge_intr_coal_delay = 30;
  96 static int mxge_deassert_wait = 1;
  97 static int mxge_flow_control = 1;
  98 static int mxge_verbose = 0;
  99 static int mxge_lro_cnt = 8;
 100 static int mxge_ticks;
 101 static int mxge_max_slices = 1;
 102 static int mxge_rss_hash_type = MXGEFW_RSS_HASH_TYPE_SRC_PORT;
 103 static int mxge_always_promisc = 0;
 104 static int mxge_initial_mtu = ETHERMTU_JUMBO;
 105 static char *mxge_fw_unaligned = "mxge_ethp_z8e";
 106 static char *mxge_fw_aligned = "mxge_eth_z8e";
 107 static char *mxge_fw_rss_aligned = "mxge_rss_eth_z8e";
 108 static char *mxge_fw_rss_unaligned = "mxge_rss_ethp_z8e";
 109
 110 static int mxge_probe(device_t dev);
 111 static int mxge_attach(device_t dev);
 112 static int mxge_detach(device_t dev);
 113 static int mxge_shutdown(device_t dev);
 114 static void mxge_intr(void *arg);
 115
 116 static device_method_t mxge_methods[] =
 117 {
 118   /* Device interface */
 119   DEVMETHOD(device_probe, mxge_probe),
 120   DEVMETHOD(device_attach, mxge_attach),
 121   DEVMETHOD(device_detach, mxge_detach),
 122   DEVMETHOD(device_shutdown, mxge_shutdown),
 123   {0, 0}
 124 };
 125
 126 static driver_t mxge_driver =
 127 {
 128   "mxge",
 129   mxge_methods,
 130   sizeof(mxge_softc_t),
 131 };
 132
 133 static devclass_t mxge_devclass;
 134
 135 /* Declare ourselves to be a child of the PCI bus.*/
 136 DRIVER_MODULE(mxge, pci, mxge_driver, mxge_devclass, 0, 0);
 137 MODULE_DEPEND(mxge, firmware, 1, 1, 1);
 138 MODULE_DEPEND(mxge, zlib, 1, 1, 1);
 139
 140 static int mxge_load_firmware(mxge_softc_t *sc, int adopt);
 141 static int mxge_send_cmd(mxge_softc_t *sc, uint32_t cmd, mxge_cmd_t *data);
 142 static int mxge_close(mxge_softc_t *sc);
 143 static int mxge_open(mxge_softc_t *sc);
 144 static void mxge_tick(void *arg);
 145
 146 /* XXX: we don't have Large Receive Offload support yet */
 147  inline int
 148 mxge_lro_rx(struct mxge_slice_state *ss, struct mbuf *m_head, uint32_t csum)
 149 {
 150         (void)ss;
 151         (void)m_head;
 152         (void)csum;
 153         return 1;
 154 }
 155
 156  inline void
 157 mxge_lro_flush(struct mxge_slice_state *ss, struct lro_entry *lro)
 158 {
 159         (void)ss;
 160         (void)lro;
 161 }
 162
 163 static int
 164 mxge_probe(device_t dev)
 165 {
 166         int rev;
 167
 168
 169         if ((pci_get_vendor(dev) == MXGE_PCI_VENDOR_MYRICOM) &&
 170             ((pci_get_device(dev) == MXGE_PCI_DEVICE_Z8E) ||
 171              (pci_get_device(dev) == MXGE_PCI_DEVICE_Z8E_9))) {
 172                 rev = pci_get_revid(dev);
 173                 switch (rev) {
 174                 case MXGE_PCI_REV_Z8E:
 175                         device_set_desc(dev, "Myri10G-PCIE-8A");
 176                         break;
 177                 case MXGE_PCI_REV_Z8ES:
 178                         device_set_desc(dev, "Myri10G-PCIE-8B");
 179                         break;
 180                 default:
 181                         device_set_desc(dev, "Myri10G-PCIE-8??");
 182                         device_printf(dev, "Unrecognized rev %d NIC\n",
 183                                       rev);
 184                         break;
 185                 }
 186                 return 0;
 187         }
 188         return ENXIO;
 189 }
 190
 191 static void
 192 mxge_enable_wc(mxge_softc_t *sc)
 193 {
 194 #if 0
 195 #if defined(__i386) || defined(__amd64)
 196         vm_offset_t len;
 197         int err;
 198
 199         sc->wc = 1;
 200         len = rman_get_size(sc->mem_res);
 201         err = pmap_change_attr((vm_offset_t) sc->sram,
 202                                len, PAT_WRITE_COMBINING);
 203         if (err != 0) {
 204                 device_printf(sc->dev, "pmap_change_attr failed, %d\n",
 205                               err);
 206                 sc->wc = 0;
 207         }
 208 #endif
 209 #else
 210         sc->wc = 0;     /* TBD: PAT support */
 211 #endif
 212 }
 213
 214
 215 /* callback to get our DMA address */
 216 static void
 217 mxge_dmamap_callback(void *arg, bus_dma_segment_t *segs, int nsegs,
 218                          int error)
 219 {
 220         if (error == 0) {
 221                 *(bus_addr_t *) arg = segs->ds_addr;
 222         }
 223 }
 224
 225 static int
 226 mxge_dma_alloc(mxge_softc_t *sc, mxge_dma_t *dma, size_t bytes,
 227                    bus_size_t alignment)
 228 {
 229         int err;
 230         device_t dev = sc->dev;
 231         bus_size_t boundary, maxsegsize;
 232
 233         if (bytes > 4096 && alignment == 4096) {
 234                 boundary = 0;
 235                 maxsegsize = bytes;
 236         } else {
 237                 boundary = 4096;
 238                 maxsegsize = 4096;
 239         }
 240
 241         /* allocate DMAable memory tags */
 242         err = bus_dma_tag_create(sc->parent_dmat,       /* parent */
 243                                  alignment,             /* alignment */
 244                                  boundary,              /* boundary */
 245                                  BUS_SPACE_MAXADDR,     /* low */
 246                                  BUS_SPACE_MAXADDR,     /* high */
 247                                  NULL, NULL,            /* filter */
 248                                  bytes,                 /* maxsize */
 249                                  1,                     /* num segs */
 250                                  maxsegsize,            /* maxsegsize */
 251                                  BUS_DMA_COHERENT,      /* flags */
 252                                  &dma->dmat);           /* tag */
 253         if (err != 0) {
 254                 device_printf(dev, "couldn't alloc tag (err = %d)\n", err);
 255                 return err;
 256         }
 257
 258         /* allocate DMAable memory & map */
 259         err = bus_dmamem_alloc(dma->dmat, &dma->addr,
 260                                (BUS_DMA_WAITOK | BUS_DMA_COHERENT
 261                                 | BUS_DMA_ZERO),  &dma->map);
 262         if (err != 0) {
 263                 device_printf(dev, "couldn't alloc mem (err = %d)\n", err);
 264                 goto abort_with_dmat;
 265         }
 266
 267         /* load the memory */
 268         err = bus_dmamap_load(dma->dmat, dma->map, dma->addr, bytes,
 269                               mxge_dmamap_callback,
 270                               (void *)&dma->bus_addr, 0);
 271         if (err != 0) {
 272                 device_printf(dev, "couldn't load map (err = %d)\n", err);
 273                 goto abort_with_mem;
 274         }
 275         return 0;
 276
 277 abort_with_mem:
 278         bus_dmamem_free(dma->dmat, dma->addr, dma->map);
 279 abort_with_dmat:
 280         (void)bus_dma_tag_destroy(dma->dmat);
 281         return err;
 282 }
 283
 284
 285 static void
 286 mxge_dma_free(mxge_dma_t *dma)
 287 {
 288         bus_dmamap_unload(dma->dmat, dma->map);
 289         bus_dmamem_free(dma->dmat, dma->addr, dma->map);
 290         (void)bus_dma_tag_destroy(dma->dmat);
 291 }
 292
 293 /*
 294  * The eeprom strings on the lanaiX have the format
 295  * SN=x\0
 296  * MAC=x:x:x:x:x:x\0
 297  * PC=text\0
 298  */
 299
 300 static int
 301 mxge_parse_strings(mxge_softc_t *sc)
 302 {
 303 #define MXGE_NEXT_STRING(p) while(ptr < limit && *ptr++)
 304
 305         char *ptr, *limit;
 306         int i, found_mac;
 307
 308         ptr = sc->eeprom_strings;
 309         limit = sc->eeprom_strings + MXGE_EEPROM_STRINGS_SIZE;
 310         found_mac = 0;
 311         while (ptr < limit && *ptr != '\0') {
 312                 if (memcmp(ptr, "MAC=", 4) == 0) {
 313                         ptr += 1;
 314                         sc->mac_addr_string = ptr;
 315                         for (i = 0; i < 6; i++) {
 316                                 ptr += 3;
 317                                 if ((ptr + 2) > limit)
 318                                         goto abort;
 319                                 sc->mac_addr[i] = strtoul(ptr, NULL, 16);
 320                                 found_mac = 1;
 321                         }
 322                 } else if (memcmp(ptr, "PC=", 3) == 0) {
 323                         ptr += 3;
 324                         strncpy(sc->product_code_string, ptr,
 325                                 sizeof (sc->product_code_string) - 1);
 326                 } else if (memcmp(ptr, "SN=", 3) == 0) {
 327                         ptr += 3;
 328                         strncpy(sc->serial_number_string, ptr,
 329                                 sizeof (sc->serial_number_string) - 1);
 330                 }
 331                 MXGE_NEXT_STRING(ptr);
 332         }
 333
 334         if (found_mac)
 335                 return 0;
 336
 337  abort:
 338         device_printf(sc->dev, "failed to parse eeprom_strings\n");
 339
 340         return ENXIO;
 341 }
 342
 343 #if defined __i386 || defined i386 || defined __i386__ || defined __x86_64__
 344 static void
 345 mxge_enable_nvidia_ecrc(mxge_softc_t *sc)
 346 {
 347         uint32_t val;
 348         unsigned long base, off;
 349         char *va, *cfgptr;
 350         device_t pdev, mcp55;
 351         uint16_t vendor_id, device_id, word;
 352         uintptr_t bus, slot, func, ivend, idev;
 353         uint32_t *ptr32;
 354
 355
 356         if (!mxge_nvidia_ecrc_enable)
 357                 return;
 358
 359         pdev = device_get_parent(device_get_parent(sc->dev));
 360         if (pdev == NULL) {
 361                 device_printf(sc->dev, "could not find parent?\n");
 362                 return;
 363         }
 364         vendor_id = pci_read_config(pdev, PCIR_VENDOR, 2);
 365         device_id = pci_read_config(pdev, PCIR_DEVICE, 2);
 366
 367         if (vendor_id != 0x10de)
 368                 return;
 369
 370         base = 0;
 371
 372         if (device_id == 0x005d) {
 373                 /* ck804, base address is magic */
 374                 base = 0xe0000000UL;
 375         } else if (device_id >= 0x0374 && device_id <= 0x378) {
 376                 /* mcp55, base address stored in chipset */
 377                 mcp55 = pci_find_bsf(0, 0, 0);
 378                 if (mcp55 &&
 379                     0x10de == pci_read_config(mcp55, PCIR_VENDOR, 2) &&
 380                     0x0369 == pci_read_config(mcp55, PCIR_DEVICE, 2)) {
 381                         word = pci_read_config(mcp55, 0x90, 2);
 382                         base = ((unsigned long)word & 0x7ffeU) << 25;
 383                 }
 384         }
 385         if (!base)
 386                 return;
 387
 388         /* XXXX
 389            Test below is commented because it is believed that doing
 390            config read/write beyond 0xff will access the config space
 391            for the next larger function.  Uncomment this and remove
 392            the hacky pmap_mapdev() way of accessing config space when
 393            FreeBSD grows support for extended pcie config space access
 394         */
 395 #if 0
 396         /* See if we can, by some miracle, access the extended
 397            config space */
 398         val = pci_read_config(pdev, 0x178, 4);
 399         if (val != 0xffffffff) {
 400                 val |= 0x40;
 401                 pci_write_config(pdev, 0x178, val, 4);
 402                 return;
 403         }
 404 #endif
 405         /* Rather than using normal pci config space writes, we must
 406          * map the Nvidia config space ourselves.  This is because on
 407          * opteron/nvidia class machine the 0xe000000 mapping is
 408          * handled by the nvidia chipset, that means the internal PCI
 409          * device (the on-chip northbridge), or the amd-8131 bridge
 410          * and things behind them are not visible by this method.
 411          */
 412
 413         BUS_READ_IVAR(device_get_parent(pdev), pdev,
 414                       PCI_IVAR_BUS, &bus);
 415         BUS_READ_IVAR(device_get_parent(pdev), pdev,
 416                       PCI_IVAR_SLOT, &slot);
 417         BUS_READ_IVAR(device_get_parent(pdev), pdev,
 418                       PCI_IVAR_FUNCTION, &func);
 419         BUS_READ_IVAR(device_get_parent(pdev), pdev,
 420                       PCI_IVAR_VENDOR, &ivend);
 421         BUS_READ_IVAR(device_get_parent(pdev), pdev,
 422                       PCI_IVAR_DEVICE, &idev);
 423
 424         off =  base
 425                 + 0x00100000UL * (unsigned long)bus
 426                 + 0x00001000UL * (unsigned long)(func
 427                                                  + 8 * slot);
 428
 429         /* map it into the kernel */
 430         va = pmap_mapdev(trunc_page((vm_paddr_t)off), PAGE_SIZE);
 431
 432
 433         if (va == NULL) {
 434                 device_printf(sc->dev, "pmap_kenter_temporary didn't\n");
 435                 return;
 436         }
 437         /* get a pointer to the config space mapped into the kernel */
 438         cfgptr = va + (off & PAGE_MASK);
 439
 440         /* make sure that we can really access it */
 441         vendor_id = *(uint16_t *)(cfgptr + PCIR_VENDOR);
 442         device_id = *(uint16_t *)(cfgptr + PCIR_DEVICE);
 443         if (! (vendor_id == ivend && device_id == idev)) {
 444                 device_printf(sc->dev, "mapping failed: 0x%x:0x%x\n",
 445                               vendor_id, device_id);
 446                 pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);
 447                 return;
 448         }
 449
 450         ptr32 = (uint32_t*)(cfgptr + 0x178);
 451         val = *ptr32;
 452
 453         if (val == 0xffffffff) {
 454                 device_printf(sc->dev, "extended mapping failed\n");
 455                 pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);
 456                 return;
 457         }
 458         *ptr32 = val | 0x40;
 459         pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);
 460         if (mxge_verbose)
 461                 device_printf(sc->dev,
 462                               "Enabled ECRC on upstream Nvidia bridge "
 463                               "at %d:%d:%d\n",
 464                               (int)bus, (int)slot, (int)func);
 465         return;
 466 }
 467 #else
 468 static void
 469 mxge_enable_nvidia_ecrc(mxge_softc_t *sc)
 470 {
 471         device_printf(sc->dev,
 472                       "Nforce 4 chipset on non-x86/amd64!?!?!\n");
 473         return;
 474 }
 475 #endif
 476
 477
 478 static int
 479 mxge_dma_test(mxge_softc_t *sc, int test_type)
 480 {
 481         mxge_cmd_t cmd;
 482         bus_addr_t dmatest_bus = sc->dmabench_dma.bus_addr;
 483         int status;
 484         uint32_t len;
 485         char *test = " ";
 486
 487
 488         /* Run a small DMA test.
 489          * The magic multipliers to the length tell the firmware
 490          * to do DMA read, write, or read+write tests.  The
 491          * results are returned in cmd.data0.  The upper 16
 492          * bits of the return is the number of transfers completed.
 493          * The lower 16 bits is the time in 0.5us ticks that the
 494          * transfers took to complete.
 495          */
 496
 497         len = sc->tx_boundary;
 498
 499         cmd.data0 = MXGE_LOWPART_TO_U32(dmatest_bus);
 500         cmd.data1 = MXGE_HIGHPART_TO_U32(dmatest_bus);
 501         cmd.data2 = len * 0x10000;
 502         status = mxge_send_cmd(sc, test_type, &cmd);
 503         if (status != 0) {
 504                 test = "read";
 505                 goto abort;
 506         }
 507         sc->read_dma = ((cmd.data0>>16) * len * 2) /
 508                 (cmd.data0 & 0xffff);
 509         cmd.data0 = MXGE_LOWPART_TO_U32(dmatest_bus);
 510         cmd.data1 = MXGE_HIGHPART_TO_U32(dmatest_bus);
 511         cmd.data2 = len * 0x1;
 512         status = mxge_send_cmd(sc, test_type, &cmd);
 513         if (status != 0) {
 514                 test = "write";
 515                 goto abort;
 516         }
 517         sc->write_dma = ((cmd.data0>>16) * len * 2) /
 518                 (cmd.data0 & 0xffff);
 519
 520         cmd.data0 = MXGE_LOWPART_TO_U32(dmatest_bus);
 521         cmd.data1 = MXGE_HIGHPART_TO_U32(dmatest_bus);
 522         cmd.data2 = len * 0x10001;
 523         status = mxge_send_cmd(sc, test_type, &cmd);
 524         if (status != 0) {
 525                 test = "read/write";
 526                 goto abort;
 527         }
 528         sc->read_write_dma = ((cmd.data0>>16) * len * 2 * 2) /
 529                 (cmd.data0 & 0xffff);
 530
 531 abort:
 532         if (status != 0 && test_type != MXGEFW_CMD_UNALIGNED_TEST)
 533                 device_printf(sc->dev, "DMA %s benchmark failed: %d\n",
 534                               test, status);
 535
 536         return status;
 537 }
 538
 539 /*
 540  * The Lanai Z8E PCI-E interface achieves higher Read-DMA throughput
 541  * when the PCI-E Completion packets are aligned on an 8-byte
 542  * boundary.  Some PCI-E chip sets always align Completion packets; on
 543  * the ones that do not, the alignment can be enforced by enabling
 544  * ECRC generation (if supported).
 545  *
 546  * When PCI-E Completion packets are not aligned, it is actually more
 547  * efficient to limit Read-DMA transactions to 2KB, rather than 4KB.
 548  *
 549  * If the driver can neither enable ECRC nor verify that it has
 550  * already been enabled, then it must use a firmware image which works
 551  * around unaligned completion packets (ethp_z8e.dat), and it should
 552  * also ensure that it never gives the device a Read-DMA which is
 553  * larger than 2KB by setting the tx_boundary to 2KB.  If ECRC is
 554  * enabled, then the driver should use the aligned (eth_z8e.dat)
 555  * firmware image, and set tx_boundary to 4KB.
 556  */
 557
 558 static int
 559 mxge_firmware_probe(mxge_softc_t *sc)
 560 {
 561         device_t dev = sc->dev;
 562         int reg, status;
 563         uint16_t pectl;
 564
 565         sc->tx_boundary = 4096;
 566         /*
 567          * Verify the max read request size was set to 4KB
 568          * before trying the test with 4KB.
 569          */
 570         if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
 571                 pectl = pci_read_config(dev, reg + 0x8, 2);
 572                 if ((pectl & (5 << 12)) != (5 << 12)) {
 573                         device_printf(dev, "Max Read Req. size != 4k (0x%x\n",
 574                                       pectl);
 575                         sc->tx_boundary = 2048;
 576                 }
 577         }
 578
 579         /*
 580          * load the optimized firmware (which assumes aligned PCIe
 581          * completions) in order to see if it works on this host.
 582          */
 583         sc->fw_name = mxge_fw_aligned;
 584         status = mxge_load_firmware(sc, 1);
 585         if (status != 0) {
 586                 return status;
 587         }
 588
 589         /*
 590          * Enable ECRC if possible
 591          */
 592         mxge_enable_nvidia_ecrc(sc);
 593
 594         /*
 595          * Run a DMA test which watches for unaligned completions and
 596          * aborts on the first one seen.
 597          */
 598
 599         status = mxge_dma_test(sc, MXGEFW_CMD_UNALIGNED_TEST);
 600         if (status == 0)
 601                 return 0; /* keep the aligned firmware */
 602
 603         if (status != E2BIG)
 604                 device_printf(dev, "DMA test failed: %d\n", status);
 605         if (status == ENOSYS)
 606                 device_printf(dev, "Falling back to ethp! "
 607                               "Please install up to date fw\n");
 608         return status;
 609 }
 610
 611 static int
 612 mxge_select_firmware(mxge_softc_t *sc)
 613 {
 614         int aligned = 0;
 615
 616
 617         if (mxge_force_firmware != 0) {
 618                 if (mxge_force_firmware == 1)
 619                         aligned = 1;
 620                 else
 621                         aligned = 0;
 622                 if (mxge_verbose)
 623                         device_printf(sc->dev,
 624                                       "Assuming %s completions (forced)\n",
 625                                       aligned ? "aligned" : "unaligned");
 626                 goto abort;
 627         }
 628
 629         /* if the PCIe link width is 4 or less, we can use the aligned
 630            firmware and skip any checks */
 631         if (sc->link_width != 0 && sc->link_width <= 4) {
 632                 device_printf(sc->dev,
 633                               "PCIe x%d Link, expect reduced performance\n",
 634                               sc->link_width);
 635                 aligned = 1;
 636                 goto abort;
 637         }
 638
 639         if (0 == mxge_firmware_probe(sc))
 640                 return 0;
 641
 642 abort:
 643         if (aligned) {
 644                 sc->fw_name = mxge_fw_aligned;
 645                 sc->tx_boundary = 4096;
 646         } else {
 647                 sc->fw_name = mxge_fw_unaligned;
 648                 sc->tx_boundary = 2048;
 649         }
 650         return (mxge_load_firmware(sc, 0));
 651 }
 652
 653 union qualhack
 654 {
 655         const char *ro_char;
 656         char *rw_char;
 657 };
 658
 659 static int
 660 mxge_validate_firmware(mxge_softc_t *sc, const mcp_gen_header_t *hdr)
 661 {
 662
 663
 664         if (be32toh(hdr->mcp_type) != MCP_TYPE_ETH) {
 665                 device_printf(sc->dev, "Bad firmware type: 0x%x\n",
 666                               be32toh(hdr->mcp_type));
 667                 return EIO;
 668         }
 669
 670         /* save firmware version for sysctl */
 671         strncpy(sc->fw_version, hdr->version, sizeof (sc->fw_version));
 672         if (mxge_verbose)
 673                 device_printf(sc->dev, "firmware id: %s\n", hdr->version);
 674
 675         ksscanf(sc->fw_version, "%d.%d.%d", &sc->fw_ver_major,
 676                &sc->fw_ver_minor, &sc->fw_ver_tiny);
 677
 678         if (!(sc->fw_ver_major == MXGEFW_VERSION_MAJOR
 679               && sc->fw_ver_minor == MXGEFW_VERSION_MINOR)) {
 680                 device_printf(sc->dev, "Found firmware version %s\n",
 681                               sc->fw_version);
 682                 device_printf(sc->dev, "Driver needs %d.%d\n",
 683                               MXGEFW_VERSION_MAJOR, MXGEFW_VERSION_MINOR);
 684                 return EINVAL;
 685         }
 686         return 0;
 687
 688 }
 689
 690 #if 0
 691 static void *
 692 z_alloc(void *nil, u_int items, u_int size)
 693 {
 694         void *ptr;
 695
 696         ptr = kmalloc(items * size, M_TEMP, M_NOWAIT);
 697         return ptr;
 698 }
 699
 700 static void
 701 z_free(void *nil, void *ptr)
 702 {
 703         kfree(ptr, M_TEMP);
 704 }
 705 #endif
 706
 707 static int
 708 mxge_load_firmware_helper(mxge_softc_t *sc, uint32_t *limit)
 709 {
 710         struct fw_image *fw;
 711         const mcp_gen_header_t *hdr;
 712         unsigned hdr_offset;
 713         int status;
 714         unsigned int i;
 715         char dummy;
 716         size_t fw_len;
 717
 718         fw = firmware_image_load(sc->fw_name, NULL);
 719         if (fw == NULL) {
 720                 device_printf(sc->dev, "Could not find firmware image %s\n",
 721                               sc->fw_name);
 722                 return ENOENT;
 723         }
 724 #if 0
 725         /* setup zlib and decompress f/w */
 726         bzero(&zs, sizeof (zs));
 727         zs.zalloc = z_alloc;
 728         zs.zfree = z_free;
 729         status = inflateInit(&zs);
 730         if (status != Z_OK) {
 731                 status = EIO;
 732                 goto abort_with_fw;
 733         }
 734
 735         /* the uncompressed size is stored as the firmware version,
 736            which would otherwise go unused */
 737         fw_len = (size_t) fw->version;
 738         inflate_buffer = kmalloc(fw_len, M_TEMP, M_NOWAIT);
 739         if (inflate_buffer == NULL)
 740                 goto abort_with_zs;
 741         zs.avail_in = fw->datasize;
 742         zs.next_in = __DECONST(char *, fw->data);
 743         zs.avail_out = fw_len;
 744         zs.next_out = inflate_buffer;
 745         status = inflate(&zs, Z_FINISH);
 746         if (status != Z_STREAM_END) {
 747                 device_printf(sc->dev, "zlib %d\n", status);
 748                 status = EIO;
 749                 goto abort_with_buffer;
 750         }
 751 #endif
 752         fw_len = fw->fw_imglen;
 753         /* check id */
 754         hdr_offset = htobe32(*(const uint32_t *)
 755                              (fw->fw_image + MCP_HEADER_PTR_OFFSET));
 756         if ((hdr_offset & 3) || hdr_offset + sizeof(*hdr) > fw_len) {
 757                 device_printf(sc->dev, "Bad firmware file");
 758                 status = EIO;
 759                 goto abort_with_fw;
 760         }
 761         hdr = (const void*)(fw->fw_image + hdr_offset);
 762
 763         status = mxge_validate_firmware(sc, hdr);
 764         if (status != 0)
 765                 goto abort_with_fw;
 766
 767         /* Copy the inflated firmware to NIC SRAM. */
 768         for (i = 0; i < fw_len; i += 256) {
 769                 mxge_pio_copy(sc->sram + MXGE_FW_OFFSET + i,
 770                               fw->fw_image + i,
 771                               min(256U, (unsigned)(fw_len - i)));
 772                 wmb();
 773                 dummy = *sc->sram;
 774                 wmb();
 775         }
 776
 777         *limit = fw_len;
 778         status = 0;
 779 #if 0
 780 abort_with_buffer:
 781         kfree(inflate_buffer, M_TEMP);
 782 abort_with_zs:
 783         inflateEnd(&zs);
 784 #endif
 785 abort_with_fw:
 786         firmware_image_unload(fw);
 787         return status;
 788 }
 789
 790 /*
 791  * Enable or disable periodic RDMAs from the host to make certain
 792  * chipsets resend dropped PCIe messages
 793  */
 794
 795 static void
 796 mxge_dummy_rdma(mxge_softc_t *sc, int enable)
 797 {
 798         char buf_bytes[72];
 799         volatile uint32_t *confirm;
 800         volatile char *submit;
 801         uint32_t *buf, dma_low, dma_high;
 802         int i;
 803
 804         buf = (uint32_t *)((unsigned long)(buf_bytes + 7) & ~7UL);
 805
 806         /* clear confirmation addr */
 807         confirm = (volatile uint32_t *)sc->cmd;
 808         *confirm = 0;
 809         wmb();
 810
 811         /* send an rdma command to the PCIe engine, and wait for the
 812            response in the confirmation address.  The firmware should
 813            write a -1 there to indicate it is alive and well
 814         */
 815
 816         dma_low = MXGE_LOWPART_TO_U32(sc->cmd_dma.bus_addr);
 817         dma_high = MXGE_HIGHPART_TO_U32(sc->cmd_dma.bus_addr);
 818         buf[0] = htobe32(dma_high);             /* confirm addr MSW */
 819         buf[1] = htobe32(dma_low);              /* confirm addr LSW */
 820         buf[2] = htobe32(0xffffffff);           /* confirm data */
 821         dma_low = MXGE_LOWPART_TO_U32(sc->zeropad_dma.bus_addr);
 822         dma_high = MXGE_HIGHPART_TO_U32(sc->zeropad_dma.bus_addr);
 823         buf[3] = htobe32(dma_high);             /* dummy addr MSW */
 824         buf[4] = htobe32(dma_low);              /* dummy addr LSW */
 825         buf[5] = htobe32(enable);                       /* enable? */
 826
 827
 828         submit = (volatile char *)(sc->sram + MXGEFW_BOOT_DUMMY_RDMA);
 829
 830         mxge_pio_copy(submit, buf, 64);
 831         wmb();
 832         DELAY(1000);
 833         wmb();
 834         i = 0;
 835         while (*confirm != 0xffffffff && i < 20) {
 836                 DELAY(1000);
 837                 i++;
 838         }
 839         if (*confirm != 0xffffffff) {
 840                 device_printf(sc->dev, "dummy rdma %s failed (%p = 0x%x)",
 841                               (enable ? "enable" : "disable"), confirm,
 842                               *confirm);
 843         }
 844         return;
 845 }
 846
 847 static int
 848 mxge_send_cmd(mxge_softc_t *sc, uint32_t cmd, mxge_cmd_t *data)
 849 {
 850         mcp_cmd_t *buf;
 851         char buf_bytes[sizeof(*buf) + 8];
 852         volatile mcp_cmd_response_t *response = sc->cmd;
 853         volatile char *cmd_addr = sc->sram + MXGEFW_ETH_CMD;
 854         uint32_t dma_low, dma_high;
 855         int err, sleep_total = 0;
 856
 857         /* ensure buf is aligned to 8 bytes */
 858         buf = (mcp_cmd_t *)((unsigned long)(buf_bytes + 7) & ~7UL);
 859
 860         buf->data0 = htobe32(data->data0);
 861         buf->data1 = htobe32(data->data1);
 862         buf->data2 = htobe32(data->data2);
 863         buf->cmd = htobe32(cmd);
 864         dma_low = MXGE_LOWPART_TO_U32(sc->cmd_dma.bus_addr);
 865         dma_high = MXGE_HIGHPART_TO_U32(sc->cmd_dma.bus_addr);
 866
 867         buf->response_addr.low = htobe32(dma_low);
 868         buf->response_addr.high = htobe32(dma_high);
 869
 870         /*
 871          * We may be called during attach, before if_serializer is available.
 872          * This is not a fast path, just check for NULL
 873          */
 874         if (sc->ifp->if_serializer)
 875                 lwkt_serialize_enter(sc->ifp->if_serializer);
 876
 877         response->result = 0xffffffff;
 878         wmb();
 879         mxge_pio_copy((volatile void *)cmd_addr, buf, sizeof (*buf));
 880
 881         /* wait up to 20ms */
 882         err = EAGAIN;
 883         for (sleep_total = 0; sleep_total <  20; sleep_total++) {
 884                 bus_dmamap_sync(sc->cmd_dma.dmat,
 885                                 sc->cmd_dma.map, BUS_DMASYNC_POSTREAD);
 886                 wmb();
 887                 switch (be32toh(response->result)) {
 888                 case 0:
 889                         data->data0 = be32toh(response->data);
 890                         err = 0;
 891                         break;
 892                 case 0xffffffff:
 893                         DELAY(1000);
 894                         break;
 895                 case MXGEFW_CMD_UNKNOWN:
 896                         err = ENOSYS;
 897                         break;
 898                 case MXGEFW_CMD_ERROR_UNALIGNED:
 899                         err = E2BIG;
 900                         break;
 901                 case MXGEFW_CMD_ERROR_BUSY:
 902                         err = EBUSY;
 903                         break;
 904                 default:
 905                         device_printf(sc->dev,
 906                                       "mxge: command %d "
 907                                       "failed, result = %d\n",
 908                                       cmd, be32toh(response->result));
 909                         err = ENXIO;
 910                         break;
 911                 }
 912                 if (err != EAGAIN)
 913                         break;
 914         }
 915         if (err == EAGAIN)
 916                 device_printf(sc->dev, "mxge: command %d timed out"
 917                               "result = %d\n",
 918                               cmd, be32toh(response->result));
 919         if (sc->ifp->if_serializer)
 920                 lwkt_serialize_exit(sc->ifp->if_serializer);
 921         return err;
 922 }
 923
 924 static int
 925 mxge_adopt_running_firmware(mxge_softc_t *sc)
 926 {
 927         struct mcp_gen_header *hdr;
 928         const size_t bytes = sizeof (struct mcp_gen_header);
 929         size_t hdr_offset;
 930         int status;
 931
 932         /* find running firmware header */
 933         hdr_offset = htobe32(*(volatile uint32_t *)
 934                              (sc->sram + MCP_HEADER_PTR_OFFSET));
 935
 936         if ((hdr_offset & 3) || hdr_offset + sizeof(*hdr) > sc->sram_size) {
 937                 device_printf(sc->dev,
 938                               "Running firmware has bad header offset (%d)\n",
 939                               (int)hdr_offset);
 940                 return EIO;
 941         }
 942
 943         /* copy header of running firmware from SRAM to host memory to
 944          * validate firmware */
 945         hdr = kmalloc(bytes, M_DEVBUF, M_NOWAIT);
 946         if (hdr == NULL) {
 947                 device_printf(sc->dev, "could not kmalloc firmware hdr\n");
 948                 return ENOMEM;
 949         }
 950         bus_space_read_region_1(rman_get_bustag(sc->mem_res),
 951                                 rman_get_bushandle(sc->mem_res),
 952                                 hdr_offset, (char *)hdr, bytes);
 953         status = mxge_validate_firmware(sc, hdr);
 954         kfree(hdr, M_DEVBUF);
 955
 956         /*
 957          * check to see if adopted firmware has bug where adopting
 958          * it will cause broadcasts to be filtered unless the NIC
 959          * is kept in ALLMULTI mode
 960          */
 961         if (sc->fw_ver_major == 1 && sc->fw_ver_minor == 4 &&
 962             sc->fw_ver_tiny >= 4 && sc->fw_ver_tiny <= 11) {
 963                 sc->adopted_rx_filter_bug = 1;
 964                 device_printf(sc->dev, "Adopting fw %d.%d.%d: "
 965                               "working around rx filter bug\n",
 966                               sc->fw_ver_major, sc->fw_ver_minor,
 967                               sc->fw_ver_tiny);
 968         }
 969
 970         return status;
 971 }
 972
 973
 974 static int
 975 mxge_load_firmware(mxge_softc_t *sc, int adopt)
 976 {
 977         volatile uint32_t *confirm;
 978         volatile char *submit;
 979         char buf_bytes[72];
 980         uint32_t *buf, size, dma_low, dma_high;
 981         int status, i;
 982
 983         buf = (uint32_t *)((unsigned long)(buf_bytes + 7) & ~7UL);
 984
 985         size = sc->sram_size;
 986         status = mxge_load_firmware_helper(sc, &size);
 987         if (status) {
 988                 if (!adopt)
 989                         return status;
 990                 /* Try to use the currently running firmware, if
 991                    it is new enough */
 992                 status = mxge_adopt_running_firmware(sc);
 993                 if (status) {
 994                         device_printf(sc->dev,
 995                                       "failed to adopt running firmware\n");
 996                         return status;
 997                 }
 998                 device_printf(sc->dev,
 999                               "Successfully adopted running firmware\n");
1000                 if (sc->tx_boundary == 4096) {
1001                         device_printf(sc->dev,
1002                                 "Using firmware currently running on NIC"
1003                                  ".  For optimal\n");
1004                         device_printf(sc->dev,
1005                                  "performance consider loading optimized "
1006                                  "firmware\n");
1007                 }
1008                 sc->fw_name = mxge_fw_unaligned;
1009                 sc->tx_boundary = 2048;
1010                 return 0;
1011         }
1012         /* clear confirmation addr */
1013         confirm = (volatile uint32_t *)sc->cmd;
1014         *confirm = 0;
1015         wmb();
1016         /* send a reload command to the bootstrap MCP, and wait for the
1017            response in the confirmation address.  The firmware should
1018            write a -1 there to indicate it is alive and well
1019         */
1020
1021         dma_low = MXGE_LOWPART_TO_U32(sc->cmd_dma.bus_addr);
1022         dma_high = MXGE_HIGHPART_TO_U32(sc->cmd_dma.bus_addr);
1023
1024         buf[0] = htobe32(dma_high);     /* confirm addr MSW */
1025         buf[1] = htobe32(dma_low);      /* confirm addr LSW */
1026         buf[2] = htobe32(0xffffffff);   /* confirm data */
1027
1028         /* FIX: All newest firmware should un-protect the bottom of
1029            the sram before handoff. However, the very first interfaces
1030            do not. Therefore the handoff copy must skip the first 8 bytes
1031         */
1032                                         /* where the code starts*/
1033         buf[3] = htobe32(MXGE_FW_OFFSET + 8);
1034         buf[4] = htobe32(size - 8);     /* length of code */
1035         buf[5] = htobe32(8);            /* where to copy to */
1036         buf[6] = htobe32(0);            /* where to jump to */
1037
1038         submit = (volatile char *)(sc->sram + MXGEFW_BOOT_HANDOFF);
1039         mxge_pio_copy(submit, buf, 64);
1040         wmb();
1041         DELAY(1000);
1042         wmb();
1043         i = 0;
1044         while (*confirm != 0xffffffff && i < 20) {
1045                 DELAY(1000*10);
1046                 i++;
1047                 bus_dmamap_sync(sc->cmd_dma.dmat,
1048                                 sc->cmd_dma.map, BUS_DMASYNC_POSTREAD);
1049         }
1050         if (*confirm != 0xffffffff) {
1051                 device_printf(sc->dev,"handoff failed (%p = 0x%x)",
1052                         confirm, *confirm);
1053
1054                 return ENXIO;
1055         }
1056         return 0;
1057 }
1058
1059 static int
1060 mxge_update_mac_address(mxge_softc_t *sc)
1061 {
1062         mxge_cmd_t cmd;
1063         uint8_t *addr = sc->mac_addr;
1064         int status;
1065
1066
1067         cmd.data0 = ((addr[0] << 24) | (addr[1] << 16)
1068                      | (addr[2] << 8) | addr[3]);
1069
1070         cmd.data1 = ((addr[4] << 8) | (addr[5]));
1071
1072         status = mxge_send_cmd(sc, MXGEFW_SET_MAC_ADDRESS, &cmd);
1073         return status;
1074 }
1075
1076 static int
1077 mxge_change_pause(mxge_softc_t *sc, int pause)
1078 {
1079         mxge_cmd_t cmd;
1080         int status;
1081
1082         if (pause)
1083                 status = mxge_send_cmd(sc, MXGEFW_ENABLE_FLOW_CONTROL,
1084                                        &cmd);
1085         else
1086                 status = mxge_send_cmd(sc, MXGEFW_DISABLE_FLOW_CONTROL,
1087                                        &cmd);
1088
1089         if (status) {
1090                 device_printf(sc->dev, "Failed to set flow control mode\n");
1091                 return ENXIO;
1092         }
1093         sc->pause = pause;
1094         return 0;
1095 }
1096
1097 static void
1098 mxge_change_promisc(mxge_softc_t *sc, int promisc)
1099 {
1100         mxge_cmd_t cmd;
1101         int status;
1102
1103         if (mxge_always_promisc)
1104                 promisc = 1;
1105
1106         if (promisc)
1107                 status = mxge_send_cmd(sc, MXGEFW_ENABLE_PROMISC,
1108                                        &cmd);
1109         else
1110                 status = mxge_send_cmd(sc, MXGEFW_DISABLE_PROMISC,
1111                                        &cmd);
1112
1113         if (status) {
1114                 device_printf(sc->dev, "Failed to set promisc mode\n");
1115         }
1116 }
1117
1118 static void
1119 mxge_set_multicast_list(mxge_softc_t *sc)
1120 {
1121         mxge_cmd_t cmd;
1122         struct ifmultiaddr *ifma;
1123         struct ifnet *ifp = sc->ifp;
1124         int err;
1125
1126         /* This firmware is known to not support multicast */
1127         if (!sc->fw_multicast_support)
1128                 return;
1129
1130         /* Disable multicast filtering while we play with the lists*/
1131         err = mxge_send_cmd(sc, MXGEFW_ENABLE_ALLMULTI, &cmd);
1132         if (err != 0) {
1133                 device_printf(sc->dev, "Failed MXGEFW_ENABLE_ALLMULTI,"
1134                        " error status: %d\n", err);
1135                 return;
1136         }
1137
1138         if (sc->adopted_rx_filter_bug)
1139                 return;
1140
1141         if (ifp->if_flags & IFF_ALLMULTI)
1142                 /* request to disable multicast filtering, so quit here */
1143                 return;
1144
1145         /* Flush all the filters */
1146
1147         err = mxge_send_cmd(sc, MXGEFW_LEAVE_ALL_MULTICAST_GROUPS, &cmd);
1148         if (err != 0) {
1149                 device_printf(sc->dev,
1150                               "Failed MXGEFW_LEAVE_ALL_MULTICAST_GROUPS"
1151                               ", error status: %d\n", err);
1152                 return;
1153         }
1154
1155         /* Walk the multicast list, and add each address */
1156
1157         lwkt_serialize_enter(ifp->if_serializer);
1158         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1159                 if (ifma->ifma_addr->sa_family != AF_LINK)
1160                         continue;
1161                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1162                       &cmd.data0, 4);
1163                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr) + 4,
1164                       &cmd.data1, 2);
1165                 cmd.data0 = htonl(cmd.data0);
1166                 cmd.data1 = htonl(cmd.data1);
1167                 err = mxge_send_cmd(sc, MXGEFW_JOIN_MULTICAST_GROUP, &cmd);
1168                 if (err != 0) {
1169                         device_printf(sc->dev, "Failed "
1170                                "MXGEFW_JOIN_MULTICAST_GROUP, error status:"
1171                                "%d\t", err);
1172                         /* abort, leaving multicast filtering off */
1173                         lwkt_serialize_exit(ifp->if_serializer);
1174                         return;
1175                 }
1176         }
1177         lwkt_serialize_exit(ifp->if_serializer);
1178         /* Enable multicast filtering */
1179         err = mxge_send_cmd(sc, MXGEFW_DISABLE_ALLMULTI, &cmd);
1180         if (err != 0) {
1181                 device_printf(sc->dev, "Failed MXGEFW_DISABLE_ALLMULTI"
1182                        ", error status: %d\n", err);
1183         }
1184 }
1185
1186 static int
1187 mxge_max_mtu(mxge_softc_t *sc)
1188 {
1189         mxge_cmd_t cmd;
1190         int status;
1191
1192         if (MJUMPAGESIZE - MXGEFW_PAD >  MXGEFW_MAX_MTU)
1193                 return  MXGEFW_MAX_MTU - MXGEFW_PAD;
1194
1195         /* try to set nbufs to see if it we can
1196            use virtually contiguous jumbos */
1197         cmd.data0 = 0;
1198         status = mxge_send_cmd(sc, MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS,
1199                                &cmd);
1200         if (status == 0)
1201                 return  MXGEFW_MAX_MTU - MXGEFW_PAD;
1202
1203         /* otherwise, we're limited to MJUMPAGESIZE */
1204         return MJUMPAGESIZE - MXGEFW_PAD;
1205 }
1206
1207 static int
1208 mxge_reset(mxge_softc_t *sc, int interrupts_setup)
1209 {
1210         struct mxge_slice_state *ss;
1211         mxge_rx_done_t *rx_done;
1212         volatile uint32_t *irq_claim;
1213         mxge_cmd_t cmd;
1214         int slice, status;
1215
1216         /* try to send a reset command to the card to see if it
1217            is alive */
1218         memset(&cmd, 0, sizeof (cmd));
1219         status = mxge_send_cmd(sc, MXGEFW_CMD_RESET, &cmd);
1220         if (status != 0) {
1221                 device_printf(sc->dev, "failed reset\n");
1222                 return ENXIO;
1223         }
1224
1225         mxge_dummy_rdma(sc, 1);
1226
1227
1228         /* set the intrq size */
1229         cmd.data0 = sc->rx_ring_size;
1230         status = mxge_send_cmd(sc, MXGEFW_CMD_SET_INTRQ_SIZE, &cmd);
1231
1232         /*
1233          * Even though we already know how many slices are supported
1234          * via mxge_slice_probe(), MXGEFW_CMD_GET_MAX_RSS_QUEUES
1235          * has magic side effects, and must be called after a reset.
1236          * It must be called prior to calling any RSS related cmds,
1237          * including assigning an interrupt queue for anything but
1238          * slice 0.  It must also be called *after*
1239          * MXGEFW_CMD_SET_INTRQ_SIZE, since the intrq size is used by
1240          * the firmware to compute offsets.
1241          */
1242
1243         if (sc->num_slices > 1) {
1244                 /* ask the maximum number of slices it supports */
1245                 status = mxge_send_cmd(sc, MXGEFW_CMD_GET_MAX_RSS_QUEUES,
1246                                            &cmd);
1247                 if (status != 0) {
1248                         device_printf(sc->dev,
1249                                       "failed to get number of slices\n");
1250                         return status;
1251                 }
1252                 /*
1253                  * MXGEFW_CMD_ENABLE_RSS_QUEUES must be called prior
1254                  * to setting up the interrupt queue DMA
1255                  */
1256                 cmd.data0 = sc->num_slices;
1257                 cmd.data1 = MXGEFW_SLICE_INTR_MODE_ONE_PER_SLICE;
1258 #ifdef IFNET_BUF_RING
1259                 cmd.data1 |= MXGEFW_SLICE_ENABLE_MULTIPLE_TX_QUEUES;
1260 #endif
1261                 status = mxge_send_cmd(sc, MXGEFW_CMD_ENABLE_RSS_QUEUES,
1262                                            &cmd);
1263                 if (status != 0) {
1264                         device_printf(sc->dev,
1265                                       "failed to set number of slices\n");
1266                         return status;
1267                 }
1268         }
1269
1270
1271         if (interrupts_setup) {
1272                 /* Now exchange information about interrupts  */
1273                 for (slice = 0; slice < sc->num_slices; slice++) {
1274                         rx_done = &sc->ss[slice].rx_done;
1275                         memset(rx_done->entry, 0, sc->rx_ring_size);
1276                         cmd.data0 = MXGE_LOWPART_TO_U32(rx_done->dma.bus_addr);
1277                         cmd.data1 = MXGE_HIGHPART_TO_U32(rx_done->dma.bus_addr);
1278                         cmd.data2 = slice;
1279                         status |= mxge_send_cmd(sc,
1280                                                 MXGEFW_CMD_SET_INTRQ_DMA,
1281                                                 &cmd);
1282                 }
1283         }
1284
1285         status |= mxge_send_cmd(sc,
1286                                 MXGEFW_CMD_GET_INTR_COAL_DELAY_OFFSET, &cmd);
1287
1288
1289         sc->intr_coal_delay_ptr = (volatile uint32_t *)(sc->sram + cmd.data0);
1290
1291         status |= mxge_send_cmd(sc, MXGEFW_CMD_GET_IRQ_ACK_OFFSET, &cmd);
1292         irq_claim = (volatile uint32_t *)(sc->sram + cmd.data0);
1293
1294
1295         status |= mxge_send_cmd(sc,  MXGEFW_CMD_GET_IRQ_DEASSERT_OFFSET,
1296                                 &cmd);
1297         sc->irq_deassert = (volatile uint32_t *)(sc->sram + cmd.data0);
1298         if (status != 0) {
1299                 device_printf(sc->dev, "failed set interrupt parameters\n");
1300                 return status;
1301         }
1302
1303
1304         *sc->intr_coal_delay_ptr = htobe32(sc->intr_coal_delay);
1305
1306
1307         /* run a DMA benchmark */
1308         (void) mxge_dma_test(sc, MXGEFW_DMA_TEST);
1309
1310         for (slice = 0; slice < sc->num_slices; slice++) {
1311                 ss = &sc->ss[slice];
1312
1313                 ss->irq_claim = irq_claim + (2 * slice);
1314                 /* reset mcp/driver shared state back to 0 */
1315                 ss->rx_done.idx = 0;
1316                 ss->rx_done.cnt = 0;
1317                 ss->tx.req = 0;
1318                 ss->tx.done = 0;
1319                 ss->tx.pkt_done = 0;
1320                 ss->tx.queue_active = 0;
1321                 ss->tx.activate = 0;
1322                 ss->tx.deactivate = 0;
1323                 ss->tx.wake = 0;
1324                 ss->tx.defrag = 0;
1325                 ss->tx.stall = 0;
1326                 ss->rx_big.cnt = 0;
1327                 ss->rx_small.cnt = 0;
1328                 ss->lro_bad_csum = 0;
1329                 ss->lro_queued = 0;
1330                 ss->lro_flushed = 0;
1331                 if (ss->fw_stats != NULL) {
1332                         ss->fw_stats->valid = 0;
1333                         ss->fw_stats->send_done_count = 0;
1334                 }
1335         }
1336         sc->rdma_tags_available = 15;
1337         status = mxge_update_mac_address(sc);
1338         mxge_change_promisc(sc, sc->ifp->if_flags & IFF_PROMISC);
1339         mxge_change_pause(sc, sc->pause);
1340         mxge_set_multicast_list(sc);
1341         return status;
1342 }
1343
1344 static int
1345 mxge_change_intr_coal(SYSCTL_HANDLER_ARGS)
1346 {
1347         mxge_softc_t *sc;
1348         unsigned int intr_coal_delay;
1349         int err;
1350
1351         sc = arg1;
1352         intr_coal_delay = sc->intr_coal_delay;
1353         err = sysctl_handle_int(oidp, &intr_coal_delay, arg2, req);
1354         if (err != 0) {
1355                 return err;
1356         }
1357         if (intr_coal_delay == sc->intr_coal_delay)
1358                 return 0;
1359
1360         if (intr_coal_delay == 0 || intr_coal_delay > 1000*1000)
1361                 return EINVAL;
1362
1363         lwkt_serialize_enter(sc->ifp->if_serializer);
1364         *sc->intr_coal_delay_ptr = htobe32(intr_coal_delay);
1365         sc->intr_coal_delay = intr_coal_delay;
1366
1367         lwkt_serialize_exit(sc->ifp->if_serializer);
1368         return err;
1369 }
1370
1371 static int
1372 mxge_change_flow_control(SYSCTL_HANDLER_ARGS)
1373 {
1374         mxge_softc_t *sc;
1375         unsigned int enabled;
1376         int err;
1377
1378         sc = arg1;
1379         enabled = sc->pause;
1380         err = sysctl_handle_int(oidp, &enabled, arg2, req);
1381         if (err != 0) {
1382                 return err;
1383         }
1384         if (enabled == sc->pause)
1385                 return 0;
1386
1387         lwkt_serialize_enter(sc->ifp->if_serializer);
1388         err = mxge_change_pause(sc, enabled);
1389         lwkt_serialize_exit(sc->ifp->if_serializer);
1390         return err;
1391 }
1392
1393 static int
1394 mxge_change_lro_locked(mxge_softc_t *sc, int lro_cnt)
1395 {
1396         struct ifnet *ifp;
1397         int err = 0;
1398
1399         ifp = sc->ifp;
1400         if (lro_cnt == 0)
1401                 ifp->if_capenable &= ~IFCAP_LRO;
1402         else
1403                 ifp->if_capenable |= IFCAP_LRO;
1404         sc->lro_cnt = lro_cnt;
1405         if (ifp->if_flags & IFF_RUNNING) {
1406                 mxge_close(sc);
1407                 err = mxge_open(sc);
1408         }
1409         return err;
1410 }
1411
1412 static int
1413 mxge_change_lro(SYSCTL_HANDLER_ARGS)
1414 {
1415         mxge_softc_t *sc;
1416         unsigned int lro_cnt;
1417         int err;
1418
1419         sc = arg1;
1420         lro_cnt = sc->lro_cnt;
1421         err = sysctl_handle_int(oidp, &lro_cnt, arg2, req);
1422         if (err != 0)
1423                 return err;
1424
1425         if (lro_cnt == sc->lro_cnt)
1426                 return 0;
1427
1428         if (lro_cnt > 128)
1429                 return EINVAL;
1430
1431         lwkt_serialize_enter(sc->ifp->if_serializer);
1432         err = mxge_change_lro_locked(sc, lro_cnt);
1433         lwkt_serialize_exit(sc->ifp->if_serializer);
1434         return err;
1435 }
1436
1437 static int
1438 mxge_handle_be32(SYSCTL_HANDLER_ARGS)
1439 {
1440         int err;
1441
1442         if (arg1 == NULL)
1443                 return EFAULT;
1444         arg2 = be32toh(*(int *)arg1);
1445         arg1 = NULL;
1446         err = sysctl_handle_int(oidp, arg1, arg2, req);
1447
1448         return err;
1449 }
1450
1451 static void
1452 mxge_rem_sysctls(mxge_softc_t *sc)
1453 {
1454         struct mxge_slice_state *ss;
1455         int slice;
1456
1457         if (sc->sysctl_tree != NULL) {
1458                 sysctl_ctx_free(&sc->sysctl_ctx);
1459                 sc->sysctl_tree = NULL;
1460         }
1461         if (sc->slice_sysctl_tree == NULL)
1462                 return;
1463
1464         for (slice = 0; slice < sc->num_slices; slice++) {
1465                 ss = &sc->ss[slice];
1466                 if (ss == NULL || ss->sysctl_tree == NULL)
1467                         continue;
1468                 sysctl_ctx_free(&ss->sysctl_ctx);
1469                 ss->sysctl_tree = NULL;
1470         }
1471         sysctl_ctx_free(&sc->slice_sysctl_ctx);
1472         sc->slice_sysctl_tree = NULL;
1473 }
1474
1475 static void
1476 mxge_add_sysctls(mxge_softc_t *sc)
1477 {
1478         struct sysctl_ctx_list *ctx;
1479         struct sysctl_oid_list *children;
1480         mcp_irq_data_t *fw;
1481         struct mxge_slice_state *ss;
1482         int slice;
1483         char slice_num[8];
1484
1485         ctx = &sc->sysctl_ctx;
1486         sysctl_ctx_init(ctx);
1487         sc->sysctl_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_STATIC_CHILDREN(_hw),
1488                                           OID_AUTO,
1489                                           device_get_nameunit(sc->dev),
1490                                           CTLFLAG_RD, 0, "");
1491         if (sc->sysctl_tree == NULL) {
1492                 device_printf(sc->dev, "can't add sysctl node\n");
1493                 return;
1494         }
1495
1496         children = SYSCTL_CHILDREN(sc->sysctl_tree);
1497         fw = sc->ss[0].fw_stats;
1498
1499         /* random information */
1500         SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
1501                        "firmware_version",
1502                        CTLFLAG_RD, &sc->fw_version,
1503                        0, "firmware version");
1504         SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
1505                        "serial_number",
1506                        CTLFLAG_RD, &sc->serial_number_string,
1507                        0, "serial number");
1508         SYSCTL_ADD_STRING(ctx, children, OID_AUTO,
1509                        "product_code",
1510                        CTLFLAG_RD, &sc->product_code_string,
1511                        0, "product_code");
1512         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1513                        "pcie_link_width",
1514                        CTLFLAG_RD, &sc->link_width,
1515                        0, "tx_boundary");
1516         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1517                        "tx_boundary",
1518                        CTLFLAG_RD, &sc->tx_boundary,
1519                        0, "tx_boundary");
1520         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1521                        "write_combine",
1522                        CTLFLAG_RD, &sc->wc,
1523                        0, "write combining PIO?");
1524         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1525                        "read_dma_MBs",
1526                        CTLFLAG_RD, &sc->read_dma,
1527                        0, "DMA Read speed in MB/s");
1528         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1529                        "write_dma_MBs",
1530                        CTLFLAG_RD, &sc->write_dma,
1531                        0, "DMA Write speed in MB/s");
1532         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1533                        "read_write_dma_MBs",
1534                        CTLFLAG_RD, &sc->read_write_dma,
1535                        0, "DMA concurrent Read/Write speed in MB/s");
1536
1537
1538         /* performance related tunables */
1539         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1540                         "intr_coal_delay",
1541                         CTLTYPE_INT|CTLFLAG_RW, sc,
1542                         0, mxge_change_intr_coal,
1543                         "I", "interrupt coalescing delay in usecs");
1544
1545         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1546                         "flow_control_enabled",
1547                         CTLTYPE_INT|CTLFLAG_RW, sc,
1548                         0, mxge_change_flow_control,
1549                         "I", "interrupt coalescing delay in usecs");
1550
1551         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1552                        "deassert_wait",
1553                        CTLFLAG_RW, &mxge_deassert_wait,
1554                        0, "Wait for IRQ line to go low in ihandler");
1555
1556         /* stats block from firmware is in network byte order.
1557            Need to swap it */
1558         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1559                         "link_up",
1560                         CTLTYPE_INT|CTLFLAG_RD, &fw->link_up,
1561                         0, mxge_handle_be32,
1562                         "I", "link up");
1563         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1564                         "rdma_tags_available",
1565                         CTLTYPE_INT|CTLFLAG_RD, &fw->rdma_tags_available,
1566                         0, mxge_handle_be32,
1567                         "I", "rdma_tags_available");
1568         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1569                         "dropped_bad_crc32",
1570                         CTLTYPE_INT|CTLFLAG_RD,
1571                         &fw->dropped_bad_crc32,
1572                         0, mxge_handle_be32,
1573                         "I", "dropped_bad_crc32");
1574         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1575                         "dropped_bad_phy",
1576                         CTLTYPE_INT|CTLFLAG_RD,
1577                         &fw->dropped_bad_phy,
1578                         0, mxge_handle_be32,
1579                         "I", "dropped_bad_phy");
1580         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1581                         "dropped_link_error_or_filtered",
1582                         CTLTYPE_INT|CTLFLAG_RD,
1583                         &fw->dropped_link_error_or_filtered,
1584                         0, mxge_handle_be32,
1585                         "I", "dropped_link_error_or_filtered");
1586         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1587                         "dropped_link_overflow",
1588                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_link_overflow,
1589                         0, mxge_handle_be32,
1590                         "I", "dropped_link_overflow");
1591         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1592                         "dropped_multicast_filtered",
1593                         CTLTYPE_INT|CTLFLAG_RD,
1594                         &fw->dropped_multicast_filtered,
1595                         0, mxge_handle_be32,
1596                         "I", "dropped_multicast_filtered");
1597         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1598                         "dropped_no_big_buffer",
1599                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_no_big_buffer,
1600                         0, mxge_handle_be32,
1601                         "I", "dropped_no_big_buffer");
1602         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1603                         "dropped_no_small_buffer",
1604                         CTLTYPE_INT|CTLFLAG_RD,
1605                         &fw->dropped_no_small_buffer,
1606                         0, mxge_handle_be32,
1607                         "I", "dropped_no_small_buffer");
1608         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1609                         "dropped_overrun",
1610                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_overrun,
1611                         0, mxge_handle_be32,
1612                         "I", "dropped_overrun");
1613         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1614                         "dropped_pause",
1615                         CTLTYPE_INT|CTLFLAG_RD,
1616                         &fw->dropped_pause,
1617                         0, mxge_handle_be32,
1618                         "I", "dropped_pause");
1619         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1620                         "dropped_runt",
1621                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_runt,
1622                         0, mxge_handle_be32,
1623                         "I", "dropped_runt");
1624
1625         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1626                         "dropped_unicast_filtered",
1627                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_unicast_filtered,
1628                         0, mxge_handle_be32,
1629                         "I", "dropped_unicast_filtered");
1630
1631         /* verbose printing? */
1632         SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1633                        "verbose",
1634                        CTLFLAG_RW, &mxge_verbose,
1635                        0, "verbose printing");
1636
1637         /* lro */
1638         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
1639                         "lro_cnt",
1640                         CTLTYPE_INT|CTLFLAG_RW, sc,
1641                         0, mxge_change_lro,
1642                         "I", "number of lro merge queues");
1643
1644
1645         /* add counters exported for debugging from all slices */
1646         sysctl_ctx_init(&sc->slice_sysctl_ctx);
1647         sc->slice_sysctl_tree =
1648                 SYSCTL_ADD_NODE(&sc->slice_sysctl_ctx, children, OID_AUTO,
1649                                 "slice", CTLFLAG_RD, 0, "");
1650
1651         for (slice = 0; slice < sc->num_slices; slice++) {
1652                 ss = &sc->ss[slice];
1653                 sysctl_ctx_init(&ss->sysctl_ctx);
1654                 ctx = &ss->sysctl_ctx;
1655                 children = SYSCTL_CHILDREN(sc->slice_sysctl_tree);
1656                 ksprintf(slice_num, "%d", slice);
1657                 ss->sysctl_tree =
1658                         SYSCTL_ADD_NODE(ctx, children, OID_AUTO, slice_num,
1659                                         CTLFLAG_RD, 0, "");
1660                 children = SYSCTL_CHILDREN(ss->sysctl_tree);
1661                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1662                                "rx_small_cnt",
1663                                CTLFLAG_RD, &ss->rx_small.cnt,
1664                                0, "rx_small_cnt");
1665                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1666                                "rx_big_cnt",
1667                                CTLFLAG_RD, &ss->rx_big.cnt,
1668                                0, "rx_small_cnt");
1669                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1670                                "lro_flushed", CTLFLAG_RD, &ss->lro_flushed,
1671                                0, "number of lro merge queues flushed");
1672
1673                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1674                                "lro_queued", CTLFLAG_RD, &ss->lro_queued,
1675                                0, "number of frames appended to lro merge"
1676                                "queues");
1677
1678 #ifndef IFNET_BUF_RING
1679                 /* only transmit from slice 0 for now */
1680                 if (slice > 0)
1681                         continue;
1682 #endif
1683                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1684                                "tx_req",
1685                                CTLFLAG_RD, &ss->tx.req,
1686                                0, "tx_req");
1687
1688                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1689                                "tx_done",
1690                                CTLFLAG_RD, &ss->tx.done,
1691                                0, "tx_done");
1692                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1693                                "tx_pkt_done",
1694                                CTLFLAG_RD, &ss->tx.pkt_done,
1695                                0, "tx_done");
1696                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1697                                "tx_stall",
1698                                CTLFLAG_RD, &ss->tx.stall,
1699                                0, "tx_stall");
1700                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1701                                "tx_wake",
1702                                CTLFLAG_RD, &ss->tx.wake,
1703                                0, "tx_wake");
1704                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1705                                "tx_defrag",
1706                                CTLFLAG_RD, &ss->tx.defrag,
1707                                0, "tx_defrag");
1708                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1709                                "tx_queue_active",
1710                                CTLFLAG_RD, &ss->tx.queue_active,
1711                                0, "tx_queue_active");
1712                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1713                                "tx_activate",
1714                                CTLFLAG_RD, &ss->tx.activate,
1715                                0, "tx_activate");
1716                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1717                                "tx_deactivate",
1718                                CTLFLAG_RD, &ss->tx.deactivate,
1719                                0, "tx_deactivate");
1720         }
1721 }
1722
1723 /* copy an array of mcp_kreq_ether_send_t's to the mcp.  Copy
1724    backwards one at a time and handle ring wraps */
1725
1726 static inline void
1727 mxge_submit_req_backwards(mxge_tx_ring_t *tx,
1728                             mcp_kreq_ether_send_t *src, int cnt)
1729 {
1730         int idx, starting_slot;
1731         starting_slot = tx->req;
1732         while (cnt > 1) {
1733                 cnt--;
1734                 idx = (starting_slot + cnt) & tx->mask;
1735                 mxge_pio_copy(&tx->lanai[idx],
1736                               &src[cnt], sizeof(*src));
1737                 wmb();
1738         }
1739 }
1740
1741 /*
1742  * copy an array of mcp_kreq_ether_send_t's to the mcp.  Copy
1743  * at most 32 bytes at a time, so as to avoid involving the software
1744  * pio handler in the nic.   We re-write the first segment's flags
1745  * to mark them valid only after writing the entire chain
1746  */
1747
1748 static inline void
1749 mxge_submit_req(mxge_tx_ring_t *tx, mcp_kreq_ether_send_t *src,
1750                   int cnt)
1751 {
1752         int idx, i;
1753         uint32_t *src_ints;
1754         volatile uint32_t *dst_ints;
1755         mcp_kreq_ether_send_t *srcp;
1756         volatile mcp_kreq_ether_send_t *dstp, *dst;
1757         uint8_t last_flags;
1758
1759         idx = tx->req & tx->mask;
1760
1761         last_flags = src->flags;
1762         src->flags = 0;
1763         wmb();
1764         dst = dstp = &tx->lanai[idx];
1765         srcp = src;
1766
1767         if ((idx + cnt) < tx->mask) {
1768                 for (i = 0; i < (cnt - 1); i += 2) {
1769                         mxge_pio_copy(dstp, srcp, 2 * sizeof(*src));
1770                         wmb(); /* force write every 32 bytes */
1771                         srcp += 2;
1772                         dstp += 2;
1773                 }
1774         } else {
1775                 /* submit all but the first request, and ensure
1776                    that it is submitted below */
1777                 mxge_submit_req_backwards(tx, src, cnt);
1778                 i = 0;
1779         }
1780         if (i < cnt) {
1781                 /* submit the first request */
1782                 mxge_pio_copy(dstp, srcp, sizeof(*src));
1783                 wmb(); /* barrier before setting valid flag */
1784         }
1785
1786         /* re-write the last 32-bits with the valid flags */
1787         src->flags = last_flags;
1788         src_ints = (uint32_t *)src;
1789         src_ints+=3;
1790         dst_ints = (volatile uint32_t *)dst;
1791         dst_ints+=3;
1792         *dst_ints =  *src_ints;
1793         tx->req += cnt;
1794         wmb();
1795 }
1796
1797 #if IFCAP_TSO4
1798
1799 static void
1800 mxge_encap_tso(struct mxge_slice_state *ss, struct mbuf *m,
1801                int busdma_seg_cnt, int ip_off)
1802 {
1803         mxge_tx_ring_t *tx;
1804         mcp_kreq_ether_send_t *req;
1805         bus_dma_segment_t *seg;
1806         struct ip *ip;
1807         struct tcphdr *tcp;
1808         uint32_t low, high_swapped;
1809         int len, seglen, cum_len, cum_len_next;
1810         int next_is_first, chop, cnt, rdma_count, small;
1811         uint16_t pseudo_hdr_offset, cksum_offset, mss;
1812         uint8_t flags, flags_next;
1813         static int once;
1814
1815         mss = m->m_pkthdr.tso_segsz;
1816
1817         /* negative cum_len signifies to the
1818          * send loop that we are still in the
1819          * header portion of the TSO packet.
1820          */
1821
1822         /* ensure we have the ethernet, IP and TCP
1823            header together in the first mbuf, copy
1824            it to a scratch buffer if not */
1825         if (__predict_false(m->m_len < ip_off + sizeof (*ip))) {
1826                 m_copydata(m, 0, ip_off + sizeof (*ip),
1827                            ss->scratch);
1828                 ip = (struct ip *)(ss->scratch + ip_off);
1829         } else {
1830                 ip = (struct ip *)(mtod(m, char *) + ip_off);
1831         }
1832         if (__predict_false(m->m_len < ip_off + (ip->ip_hl << 2)
1833                             + sizeof (*tcp))) {
1834                 m_copydata(m, 0, ip_off + (ip->ip_hl << 2)
1835                            + sizeof (*tcp),  ss->scratch);
1836                 ip = (struct ip *)(mtod(m, char *) + ip_off);
1837         }
1838
1839         tcp = (struct tcphdr *)((char *)ip + (ip->ip_hl << 2));
1840         cum_len = -(ip_off + ((ip->ip_hl + tcp->th_off) << 2));
1841
1842         /* TSO implies checksum offload on this hardware */
1843         cksum_offset = ip_off + (ip->ip_hl << 2);
1844         flags = MXGEFW_FLAGS_TSO_HDR | MXGEFW_FLAGS_FIRST;
1845
1846
1847         /* for TSO, pseudo_hdr_offset holds mss.
1848          * The firmware figures out where to put
1849          * the checksum by parsing the header. */
1850         pseudo_hdr_offset = htobe16(mss);
1851
1852         tx = &ss->tx;
1853         req = tx->req_list;
1854         seg = tx->seg_list;
1855         cnt = 0;
1856         rdma_count = 0;
1857         /* "rdma_count" is the number of RDMAs belonging to the
1858          * current packet BEFORE the current send request. For
1859          * non-TSO packets, this is equal to "count".
1860          * For TSO packets, rdma_count needs to be reset
1861          * to 0 after a segment cut.
1862          *
1863          * The rdma_count field of the send request is
1864          * the number of RDMAs of the packet starting at
1865          * that request. For TSO send requests with one ore more cuts
1866          * in the middle, this is the number of RDMAs starting
1867          * after the last cut in the request. All previous
1868          * segments before the last cut implicitly have 1 RDMA.
1869          *
1870          * Since the number of RDMAs is not known beforehand,
1871          * it must be filled-in retroactively - after each
1872          * segmentation cut or at the end of the entire packet.
1873          */
1874
1875         while (busdma_seg_cnt) {
1876                 /* Break the busdma segment up into pieces*/
1877                 low = MXGE_LOWPART_TO_U32(seg->ds_addr);
1878                 high_swapped =  htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
1879                 len = seg->ds_len;
1880
1881                 while (len) {
1882                         flags_next = flags & ~MXGEFW_FLAGS_FIRST;
1883                         seglen = len;
1884                         cum_len_next = cum_len + seglen;
1885                         (req-rdma_count)->rdma_count = rdma_count + 1;
1886                         if (__predict_true(cum_len >= 0)) {
1887                                 /* payload */
1888                                 chop = (cum_len_next > mss);
1889                                 cum_len_next = cum_len_next % mss;
1890                                 next_is_first = (cum_len_next == 0);
1891                                 flags |= chop * MXGEFW_FLAGS_TSO_CHOP;
1892                                 flags_next |= next_is_first *
1893                                         MXGEFW_FLAGS_FIRST;
1894                                 rdma_count |= -(chop | next_is_first);
1895                                 rdma_count += chop & !next_is_first;
1896                         } else if (cum_len_next >= 0) {
1897                                 /* header ends */
1898                                 rdma_count = -1;
1899                                 cum_len_next = 0;
1900                                 seglen = -cum_len;
1901                                 small = (mss <= MXGEFW_SEND_SMALL_SIZE);
1902                                 flags_next = MXGEFW_FLAGS_TSO_PLD |
1903                                         MXGEFW_FLAGS_FIRST |
1904                                         (small * MXGEFW_FLAGS_SMALL);
1905                             }
1906
1907                         req->addr_high = high_swapped;
1908                         req->addr_low = htobe32(low);
1909                         req->pseudo_hdr_offset = pseudo_hdr_offset;
1910                         req->pad = 0;
1911                         req->rdma_count = 1;
1912                         req->length = htobe16(seglen);
1913                         req->cksum_offset = cksum_offset;
1914                         req->flags = flags | ((cum_len & 1) *
1915                                               MXGEFW_FLAGS_ALIGN_ODD);
1916                         low += seglen;
1917                         len -= seglen;
1918                         cum_len = cum_len_next;
1919                         flags = flags_next;
1920                         req++;
1921                         cnt++;
1922                         rdma_count++;
1923                         if (__predict_false(cksum_offset > seglen))
1924                                 cksum_offset -= seglen;
1925                         else
1926                                 cksum_offset = 0;
1927                         if (__predict_false(cnt > tx->max_desc))
1928                                 goto drop;
1929                 }
1930                 busdma_seg_cnt--;
1931                 seg++;
1932         }
1933         (req-rdma_count)->rdma_count = rdma_count;
1934
1935         do {
1936                 req--;
1937                 req->flags |= MXGEFW_FLAGS_TSO_LAST;
1938         } while (!(req->flags & (MXGEFW_FLAGS_TSO_CHOP | MXGEFW_FLAGS_FIRST)));
1939
1940         tx->info[((cnt - 1) + tx->req) & tx->mask].flag = 1;
1941         mxge_submit_req(tx, tx->req_list, cnt);
1942 #ifdef IFNET_BUF_RING
1943         if ((ss->sc->num_slices > 1) && tx->queue_active == 0) {
1944                 /* tell the NIC to start polling this slice */
1945                 *tx->send_go = 1;
1946                 tx->queue_active = 1;
1947                 tx->activate++;
1948                 wmb();
1949         }
1950 #endif
1951         return;
1952
1953 drop:
1954         bus_dmamap_unload(tx->dmat, tx->info[tx->req & tx->mask].map);
1955         m_freem(m);
1956         ss->oerrors++;
1957         if (!once) {
1958                 kprintf("tx->max_desc exceeded via TSO!\n");
1959                 kprintf("mss = %d, %ld, %d!\n", mss,
1960                        (long)seg - (long)tx->seg_list, tx->max_desc);
1961                 once = 1;
1962         }
1963         return;
1964
1965 }
1966
1967 #endif /* IFCAP_TSO4 */
1968
1969 #ifdef MXGE_NEW_VLAN_API
1970 /*
1971  * We reproduce the software vlan tag insertion from
1972  * net/if_vlan.c:vlan_start() here so that we can advertise "hardware"
1973  * vlan tag insertion. We need to advertise this in order to have the
1974  * vlan interface respect our csum offload flags.
1975  */
1976 static struct mbuf *
1977 mxge_vlan_tag_insert(struct mbuf *m)
1978 {
1979         struct ether_vlan_header *evl;
1980
1981         M_PREPEND(m, EVL_ENCAPLEN, MB_DONTWAIT);
1982         if (__predict_false(m == NULL))
1983                 return NULL;
1984         if (m->m_len < sizeof(*evl)) {
1985                 m = m_pullup(m, sizeof(*evl));
1986                 if (__predict_false(m == NULL))
1987                         return NULL;
1988         }
1989         /*
1990          * Transform the Ethernet header into an Ethernet header
1991          * with 802.1Q encapsulation.
1992          */
1993         evl = mtod(m, struct ether_vlan_header *);
1994         bcopy((char *)evl + EVL_ENCAPLEN,
1995               (char *)evl, ETHER_HDR_LEN - ETHER_TYPE_LEN);
1996         evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
1997         evl->evl_tag = htons(m->m_pkthdr.ether_vlantag);
1998         m->m_flags &= ~M_VLANTAG;
1999         return m;
2000 }
2001 #endif /* MXGE_NEW_VLAN_API */
2002
2003 static void
2004 mxge_encap(struct mxge_slice_state *ss, struct mbuf *m)
2005 {
2006         mxge_softc_t *sc;
2007         mcp_kreq_ether_send_t *req;
2008         bus_dma_segment_t *seg;
2009         struct mbuf *m_tmp;
2010         struct ifnet *ifp;
2011         mxge_tx_ring_t *tx;
2012         struct ip *ip;
2013         int cnt, cum_len, err, i, idx, odd_flag, ip_off;
2014         uint16_t pseudo_hdr_offset;
2015         uint8_t flags, cksum_offset;
2016
2017
2018         sc = ss->sc;
2019         ifp = sc->ifp;
2020         tx = &ss->tx;
2021
2022         ip_off = sizeof (struct ether_header);
2023 #ifdef MXGE_NEW_VLAN_API
2024         if (m->m_flags & M_VLANTAG) {
2025                 m = mxge_vlan_tag_insert(m);
2026                 if (__predict_false(m == NULL))
2027                         goto drop;
2028                 ip_off += EVL_ENCAPLEN;
2029         }
2030 #endif
2031         /* (try to) map the frame for DMA */
2032         idx = tx->req & tx->mask;
2033         err = bus_dmamap_load_mbuf_segment(tx->dmat, tx->info[idx].map,
2034                                            m, tx->seg_list, 1, &cnt,
2035                                            BUS_DMA_NOWAIT);
2036         if (__predict_false(err == EFBIG)) {
2037                 /* Too many segments in the chain.  Try
2038                    to defrag */
2039                 m_tmp = m_defrag(m, M_NOWAIT);
2040                 if (m_tmp == NULL) {
2041                         goto drop;
2042                 }
2043                 ss->tx.defrag++;
2044                 m = m_tmp;
2045                 err = bus_dmamap_load_mbuf_segment(tx->dmat,
2046                                               tx->info[idx].map,
2047                                               m, tx->seg_list, 1, &cnt,
2048                                               BUS_DMA_NOWAIT);
2049         }
2050         if (__predict_false(err != 0)) {
2051                 device_printf(sc->dev, "bus_dmamap_load_mbuf_segment returned %d"
2052                               " packet len = %d\n", err, m->m_pkthdr.len);
2053                 goto drop;
2054         }
2055         bus_dmamap_sync(tx->dmat, tx->info[idx].map,
2056                         BUS_DMASYNC_PREWRITE);
2057         tx->info[idx].m = m;
2058
2059 #if IFCAP_TSO4
2060         /* TSO is different enough, we handle it in another routine */
2061         if (m->m_pkthdr.csum_flags & (CSUM_TSO)) {
2062                 mxge_encap_tso(ss, m, cnt, ip_off);
2063                 return;
2064         }
2065 #endif
2066
2067         req = tx->req_list;
2068         cksum_offset = 0;
2069         pseudo_hdr_offset = 0;
2070         flags = MXGEFW_FLAGS_NO_TSO;
2071
2072         /* checksum offloading? */
2073         if (m->m_pkthdr.csum_flags & (CSUM_DELAY_DATA)) {
2074                 /* ensure ip header is in first mbuf, copy
2075                    it to a scratch buffer if not */
2076                 if (__predict_false(m->m_len < ip_off + sizeof (*ip))) {
2077                         m_copydata(m, 0, ip_off + sizeof (*ip),
2078                                    ss->scratch);
2079                         ip = (struct ip *)(ss->scratch + ip_off);
2080                 } else {
2081                         ip = (struct ip *)(mtod(m, char *) + ip_off);
2082                 }
2083                 cksum_offset = ip_off + (ip->ip_hl << 2);
2084                 pseudo_hdr_offset = cksum_offset +  m->m_pkthdr.csum_data;
2085                 pseudo_hdr_offset = htobe16(pseudo_hdr_offset);
2086                 req->cksum_offset = cksum_offset;
2087                 flags |= MXGEFW_FLAGS_CKSUM;
2088                 odd_flag = MXGEFW_FLAGS_ALIGN_ODD;
2089         } else {
2090                 odd_flag = 0;
2091         }
2092         if (m->m_pkthdr.len < MXGEFW_SEND_SMALL_SIZE)
2093                 flags |= MXGEFW_FLAGS_SMALL;
2094
2095         /* convert segments into a request list */
2096         cum_len = 0;
2097         seg = tx->seg_list;
2098         req->flags = MXGEFW_FLAGS_FIRST;
2099         for (i = 0; i < cnt; i++) {
2100                 req->addr_low =
2101                         htobe32(MXGE_LOWPART_TO_U32(seg->ds_addr));
2102                 req->addr_high =
2103                         htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
2104                 req->length = htobe16(seg->ds_len);
2105                 req->cksum_offset = cksum_offset;
2106                 if (cksum_offset > seg->ds_len)
2107                         cksum_offset -= seg->ds_len;
2108                 else
2109                         cksum_offset = 0;
2110                 req->pseudo_hdr_offset = pseudo_hdr_offset;
2111                 req->pad = 0; /* complete solid 16-byte block */
2112                 req->rdma_count = 1;
2113                 req->flags |= flags | ((cum_len & 1) * odd_flag);
2114                 cum_len += seg->ds_len;
2115                 seg++;
2116                 req++;
2117                 req->flags = 0;
2118         }
2119         req--;
2120         /* pad runts to 60 bytes */
2121         if (cum_len < 60) {
2122                 req++;
2123                 req->addr_low =
2124                         htobe32(MXGE_LOWPART_TO_U32(sc->zeropad_dma.bus_addr));
2125                 req->addr_high =
2126                         htobe32(MXGE_HIGHPART_TO_U32(sc->zeropad_dma.bus_addr));
2127                 req->length = htobe16(60 - cum_len);
2128                 req->cksum_offset = 0;
2129                 req->pseudo_hdr_offset = pseudo_hdr_offset;
2130                 req->pad = 0; /* complete solid 16-byte block */
2131                 req->rdma_count = 1;
2132                 req->flags |= flags | ((cum_len & 1) * odd_flag);
2133                 cnt++;
2134         }
2135
2136         tx->req_list[0].rdma_count = cnt;
2137 #if 0
2138         /* print what the firmware will see */
2139         for (i = 0; i < cnt; i++) {
2140                 kprintf("%d: addr: 0x%x 0x%x len:%d pso%d,"
2141                     "cso:%d, flags:0x%x, rdma:%d\n",
2142                     i, (int)ntohl(tx->req_list[i].addr_high),
2143                     (int)ntohl(tx->req_list[i].addr_low),
2144                     (int)ntohs(tx->req_list[i].length),
2145                     (int)ntohs(tx->req_list[i].pseudo_hdr_offset),
2146                     tx->req_list[i].cksum_offset, tx->req_list[i].flags,
2147                     tx->req_list[i].rdma_count);
2148         }
2149         kprintf("--------------\n");
2150 #endif
2151         tx->info[((cnt - 1) + tx->req) & tx->mask].flag = 1;
2152         mxge_submit_req(tx, tx->req_list, cnt);
2153 #ifdef IFNET_BUF_RING
2154         if ((ss->sc->num_slices > 1) && tx->queue_active == 0) {
2155                 /* tell the NIC to start polling this slice */
2156                 *tx->send_go = 1;
2157                 tx->queue_active = 1;
2158                 tx->activate++;
2159                 wmb();
2160         }
2161 #endif
2162         return;
2163
2164 drop:
2165         m_freem(m);
2166         ss->oerrors++;
2167         return;
2168 }
2169
2170 #ifdef IFNET_BUF_RING
2171 static void
2172 mxge_qflush(struct ifnet *ifp)
2173 {
2174         mxge_softc_t *sc = ifp->if_softc;
2175         mxge_tx_ring_t *tx;
2176         struct mbuf *m;
2177         int slice;
2178
2179         for (slice = 0; slice < sc->num_slices; slice++) {
2180                 tx = &sc->ss[slice].tx;
2181                 lwkt_serialize_enter(sc->ifp->if_serializer);
2182                 while ((m = buf_ring_dequeue_sc(tx->br)) != NULL)
2183                         m_freem(m);
2184                 lwkt_serialize_exit(sc->ifp->if_serializer);
2185         }
2186         if_qflush(ifp);
2187 }
2188
2189 static inline void
2190 mxge_start_locked(struct mxge_slice_state *ss)
2191 {
2192         mxge_softc_t *sc;
2193         struct mbuf *m;
2194         struct ifnet *ifp;
2195         mxge_tx_ring_t *tx;
2196
2197         sc = ss->sc;
2198         ifp = sc->ifp;
2199         tx = &ss->tx;
2200
2201         while ((tx->mask - (tx->req - tx->done)) > tx->max_desc) {
2202                 m = drbr_dequeue(ifp, tx->br);
2203                 if (m == NULL) {
2204                         return;
2205                 }
2206                 /* let BPF see it */
2207                 BPF_MTAP(ifp, m);
2208
2209                 /* give it to the nic */
2210                 mxge_encap(ss, m);
2211         }
2212         /* ran out of transmit slots */
2213         if (((ss->if_flags & IFF_OACTIVE) == 0)
2214             && (!drbr_empty(ifp, tx->br))) {
2215                 ss->if_flags |= IFF_OACTIVE;
2216                 tx->stall++;
2217         }
2218 }
2219
2220 static int
2221 mxge_transmit_locked(struct mxge_slice_state *ss, struct mbuf *m)
2222 {
2223         mxge_softc_t *sc;
2224         struct ifnet *ifp;
2225         mxge_tx_ring_t *tx;
2226         int err;
2227
2228         sc = ss->sc;
2229         ifp = sc->ifp;
2230         tx = &ss->tx;
2231
2232         if ((ss->if_flags & (IFF_RUNNING|IFF_OACTIVE)) !=
2233             IFF_RUNNING) {
2234                 err = drbr_enqueue(ifp, tx->br, m);
2235                 return (err);
2236         }
2237
2238         if (drbr_empty(ifp, tx->br) &&
2239             ((tx->mask - (tx->req - tx->done)) > tx->max_desc)) {
2240                 /* let BPF see it */
2241                 BPF_MTAP(ifp, m);
2242                 /* give it to the nic */
2243                 mxge_encap(ss, m);
2244         } else if ((err = drbr_enqueue(ifp, tx->br, m)) != 0) {
2245                 return (err);
2246         }
2247         if (!drbr_empty(ifp, tx->br))
2248                 mxge_start_locked(ss);
2249         return (0);
2250 }
2251
2252 static int
2253 mxge_transmit(struct ifnet *ifp, struct mbuf *m)
2254 {
2255         mxge_softc_t *sc = ifp->if_softc;
2256         struct mxge_slice_state *ss;
2257         mxge_tx_ring_t *tx;
2258         int err = 0;
2259         int slice;
2260
2261 #if 0
2262         slice = m->m_pkthdr.flowid;
2263 #endif
2264         slice &= (sc->num_slices - 1);  /* num_slices always power of 2 */
2265
2266         ss = &sc->ss[slice];
2267         tx = &ss->tx;
2268
2269         if(lwkt_serialize_try(ifp->if_serializer)) {
2270                 err = mxge_transmit_locked(ss, m);
2271                 lwkt_serialize_exit(ifp->if_serializer);
2272         } else {
2273                 err = drbr_enqueue(ifp, tx->br, m);
2274         }
2275
2276         return (err);
2277 }
2278
2279 #else
2280
2281 static inline void
2282 mxge_start_locked(struct mxge_slice_state *ss)
2283 {
2284         mxge_softc_t *sc;
2285         struct mbuf *m;
2286         struct ifnet *ifp;
2287         mxge_tx_ring_t *tx;
2288
2289         sc = ss->sc;
2290         ifp = sc->ifp;
2291         tx = &ss->tx;
2292         while ((tx->mask - (tx->req - tx->done)) > tx->max_desc) {
2293                 m = ifq_dequeue(&ifp->if_snd, NULL);
2294                 if (m == NULL) {
2295                         return;
2296                 }
2297                 /* let BPF see it */
2298                 BPF_MTAP(ifp, m);
2299
2300                 /* give it to the nic */
2301                 mxge_encap(ss, m);
2302         }
2303         /* ran out of transmit slots */
2304         if ((sc->ifp->if_flags & IFF_OACTIVE) == 0) {
2305                 sc->ifp->if_flags |= IFF_OACTIVE;
2306                 tx->stall++;
2307         }
2308 }
2309 #endif
2310 static void
2311 mxge_start(struct ifnet *ifp)
2312 {
2313         mxge_softc_t *sc = ifp->if_softc;
2314         struct mxge_slice_state *ss;
2315
2316         /* only use the first slice for now */
2317         ss = &sc->ss[0];
2318         lwkt_serialize_enter(ifp->if_serializer);
2319         mxge_start_locked(ss);
2320         lwkt_serialize_exit(ifp->if_serializer);
2321 }
2322
2323 /*
2324  * copy an array of mcp_kreq_ether_recv_t's to the mcp.  Copy
2325  * at most 32 bytes at a time, so as to avoid involving the software
2326  * pio handler in the nic.   We re-write the first segment's low
2327  * DMA address to mark it valid only after we write the entire chunk
2328  * in a burst
2329  */
2330 static inline void
2331 mxge_submit_8rx(volatile mcp_kreq_ether_recv_t *dst,
2332                 mcp_kreq_ether_recv_t *src)
2333 {
2334         uint32_t low;
2335
2336         low = src->addr_low;
2337         src->addr_low = 0xffffffff;
2338         mxge_pio_copy(dst, src, 4 * sizeof (*src));
2339         wmb();
2340         mxge_pio_copy(dst + 4, src + 4, 4 * sizeof (*src));
2341         wmb();
2342         src->addr_low = low;
2343         dst->addr_low = low;
2344         wmb();
2345 }
2346
2347 static int
2348 mxge_get_buf_small(struct mxge_slice_state *ss, bus_dmamap_t map, int idx)
2349 {
2350         bus_dma_segment_t seg;
2351         struct mbuf *m;
2352         mxge_rx_ring_t *rx = &ss->rx_small;
2353         int cnt, err;
2354
2355         m = m_gethdr(MB_DONTWAIT, MT_DATA);
2356         if (m == NULL) {
2357                 rx->alloc_fail++;
2358                 err = ENOBUFS;
2359                 goto done;
2360         }
2361         m->m_len = MHLEN;
2362         err = bus_dmamap_load_mbuf_segment(rx->dmat, map, m,
2363                                       &seg, 1, &cnt, BUS_DMA_NOWAIT);
2364         if (err != 0) {
2365                 m_free(m);
2366                 goto done;
2367         }
2368         rx->info[idx].m = m;
2369         rx->shadow[idx].addr_low =
2370                 htobe32(MXGE_LOWPART_TO_U32(seg.ds_addr));
2371         rx->shadow[idx].addr_high =
2372                 htobe32(MXGE_HIGHPART_TO_U32(seg.ds_addr));
2373
2374 done:
2375         if ((idx & 7) == 7)
2376                 mxge_submit_8rx(&rx->lanai[idx - 7], &rx->shadow[idx - 7]);
2377         return err;
2378 }
2379
2380
2381 static int
2382 mxge_get_buf_big(struct mxge_slice_state *ss, bus_dmamap_t map, int idx)
2383 {
2384         bus_dma_segment_t seg[3];
2385         struct mbuf *m;
2386         mxge_rx_ring_t *rx = &ss->rx_big;
2387         int cnt, err, i;
2388
2389         if (rx->cl_size == MCLBYTES)
2390                 m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
2391         else {
2392 #if 0
2393                 m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, rx->cl_size);
2394 #else
2395                 /*
2396                  * XXX: allocate normal sized buffers for big buffers.
2397                  * We should be fine as long as we don't get any jumbo frames
2398                  */
2399                 m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
2400 #endif
2401         }
2402         if (m == NULL) {
2403                 rx->alloc_fail++;
2404                 err = ENOBUFS;
2405                 goto done;
2406         }
2407         m->m_len = rx->mlen;
2408         err = bus_dmamap_load_mbuf_segment(rx->dmat, map, m,
2409                                       seg, 1, &cnt, BUS_DMA_NOWAIT);
2410         if (err != 0) {
2411                 m_free(m);
2412                 goto done;
2413         }
2414         rx->info[idx].m = m;
2415         rx->shadow[idx].addr_low =
2416                 htobe32(MXGE_LOWPART_TO_U32(seg->ds_addr));
2417         rx->shadow[idx].addr_high =
2418                 htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
2419
2420 #if MXGE_VIRT_JUMBOS
2421         for (i = 1; i < cnt; i++) {
2422                 rx->shadow[idx + i].addr_low =
2423                         htobe32(MXGE_LOWPART_TO_U32(seg[i].ds_addr));
2424                 rx->shadow[idx + i].addr_high =
2425                         htobe32(MXGE_HIGHPART_TO_U32(seg[i].ds_addr));
2426        }
2427 #endif
2428
2429 done:
2430        for (i = 0; i < rx->nbufs; i++) {
2431                 if ((idx & 7) == 7) {
2432                         mxge_submit_8rx(&rx->lanai[idx - 7],
2433                                         &rx->shadow[idx - 7]);
2434                 }
2435                 idx++;
2436         }
2437         return err;
2438 }
2439
2440 /*
2441  *  Myri10GE hardware checksums are not valid if the sender
2442  *  padded the frame with non-zero padding.  This is because
2443  *  the firmware just does a simple 16-bit 1s complement
2444  *  checksum across the entire frame, excluding the first 14
2445  *  bytes.  It is best to simply to check the checksum and
2446  *  tell the stack about it only if the checksum is good
2447  */
2448
2449 static inline uint16_t
2450 mxge_rx_csum(struct mbuf *m, int csum)
2451 {
2452         struct ether_header *eh;
2453         struct ip *ip;
2454         uint16_t c;
2455
2456         eh = mtod(m, struct ether_header *);
2457
2458         /* only deal with IPv4 TCP & UDP for now */
2459         if (__predict_false(eh->ether_type != htons(ETHERTYPE_IP)))
2460                 return 1;
2461         ip = (struct ip *)(eh + 1);
2462         if (__predict_false(ip->ip_p != IPPROTO_TCP &&
2463                             ip->ip_p != IPPROTO_UDP))
2464                 return 1;
2465 #ifdef INET
2466         c = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
2467                       htonl(ntohs(csum) + ntohs(ip->ip_len) +
2468                             - (ip->ip_hl << 2) + ip->ip_p));
2469 #else
2470         c = 1;
2471 #endif
2472         c ^= 0xffff;
2473         return (c);
2474 }
2475
2476 static void
2477 mxge_vlan_tag_remove(struct mbuf *m, uint32_t *csum)
2478 {
2479         struct ether_vlan_header *evl;
2480         struct ether_header *eh;
2481         uint32_t partial;
2482
2483         evl = mtod(m, struct ether_vlan_header *);
2484         eh = mtod(m, struct ether_header *);
2485
2486         /*
2487          * fix checksum by subtracting EVL_ENCAPLEN bytes
2488          * after what the firmware thought was the end of the ethernet
2489          * header.
2490          */
2491
2492         /* put checksum into host byte order */
2493         *csum = ntohs(*csum);
2494         partial = ntohl(*(uint32_t *)(mtod(m, char *) + ETHER_HDR_LEN));
2495         (*csum) += ~partial;
2496         (*csum) +=  ((*csum) < ~partial);
2497         (*csum) = ((*csum) >> 16) + ((*csum) & 0xFFFF);
2498         (*csum) = ((*csum) >> 16) + ((*csum) & 0xFFFF);
2499
2500         /* restore checksum to network byte order;
2501            later consumers expect this */
2502         *csum = htons(*csum);
2503
2504         /* save the tag */
2505 #ifdef MXGE_NEW_VLAN_API
2506         m->m_pkthdr.ether_vlantag = ntohs(evl->evl_tag);
2507 #else
2508         {
2509                 struct m_tag *mtag;
2510                 mtag = m_tag_alloc(MTAG_VLAN, MTAG_VLAN_TAG, sizeof(u_int),
2511                                    MB_DONTWAIT);
2512                 if (mtag == NULL)
2513                         return;
2514                 VLAN_TAG_VALUE(mtag) = ntohs(evl->evl_tag);
2515                 m_tag_prepend(m, mtag);
2516         }
2517
2518 #endif
2519         m->m_flags |= M_VLANTAG;
2520
2521         /*
2522          * Remove the 802.1q header by copying the Ethernet
2523          * addresses over it and adjusting the beginning of
2524          * the data in the mbuf.  The encapsulated Ethernet
2525          * type field is already in place.
2526          */
2527         bcopy((char *)evl, (char *)evl + EVL_ENCAPLEN,
2528               ETHER_HDR_LEN - ETHER_TYPE_LEN);
2529         m_adj(m, EVL_ENCAPLEN);
2530 }
2531
2532
2533 static inline void
2534 mxge_rx_done_big(struct mxge_slice_state *ss, uint32_t len, uint32_t csum)
2535 {
2536         mxge_softc_t *sc;
2537         struct ifnet *ifp;
2538         struct mbuf *m;
2539         struct ether_header *eh;
2540         mxge_rx_ring_t *rx;
2541         bus_dmamap_t old_map;
2542         int idx;
2543         uint16_t tcpudp_csum;
2544
2545         sc = ss->sc;
2546         ifp = sc->ifp;
2547         rx = &ss->rx_big;
2548         idx = rx->cnt & rx->mask;
2549         rx->cnt += rx->nbufs;
2550         /* save a pointer to the received mbuf */
2551         m = rx->info[idx].m;
2552         /* try to replace the received mbuf */
2553         if (mxge_get_buf_big(ss, rx->extra_map, idx)) {
2554                 /* drop the frame -- the old mbuf is re-cycled */
2555                 ifp->if_ierrors++;
2556                 return;
2557         }
2558
2559         /* unmap the received buffer */
2560         old_map = rx->info[idx].map;
2561         bus_dmamap_sync(rx->dmat, old_map, BUS_DMASYNC_POSTREAD);
2562         bus_dmamap_unload(rx->dmat, old_map);
2563
2564         /* swap the bus_dmamap_t's */
2565         rx->info[idx].map = rx->extra_map;
2566         rx->extra_map = old_map;
2567
2568         /* mcp implicitly skips 1st 2 bytes so that packet is properly
2569          * aligned */
2570         m->m_data += MXGEFW_PAD;
2571
2572         m->m_pkthdr.rcvif = ifp;
2573         m->m_len = m->m_pkthdr.len = len;
2574         ss->ipackets++;
2575         eh = mtod(m, struct ether_header *);
2576         if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2577                 mxge_vlan_tag_remove(m, &csum);
2578         }
2579         /* if the checksum is valid, mark it in the mbuf header */
2580         if (sc->csum_flag && (0 == (tcpudp_csum = mxge_rx_csum(m, csum)))) {
2581                 if (sc->lro_cnt && (0 == mxge_lro_rx(ss, m, csum)))
2582                         return;
2583                 /* otherwise, it was a UDP frame, or a TCP frame which
2584                    we could not do LRO on.  Tell the stack that the
2585                    checksum is good */
2586                 m->m_pkthdr.csum_data = 0xffff;
2587                 m->m_pkthdr.csum_flags = CSUM_PSEUDO_HDR | CSUM_DATA_VALID;
2588         }
2589 #if 0
2590         /* flowid only valid if RSS hashing is enabled */
2591         if (sc->num_slices > 1) {
2592                 m->m_pkthdr.flowid = (ss - sc->ss);
2593                 m->m_flags |= M_FLOWID;
2594         }
2595 #endif
2596         /* pass the frame up the stack */
2597         (*ifp->if_input)(ifp, m);
2598 }
2599
2600 static inline void
2601 mxge_rx_done_small(struct mxge_slice_state *ss, uint32_t len, uint32_t csum)
2602 {
2603         mxge_softc_t *sc;
2604         struct ifnet *ifp;
2605         struct ether_header *eh;
2606         struct mbuf *m;
2607         mxge_rx_ring_t *rx;
2608         bus_dmamap_t old_map;
2609         int idx;
2610         uint16_t tcpudp_csum;
2611
2612         sc = ss->sc;
2613         ifp = sc->ifp;
2614         rx = &ss->rx_small;
2615         idx = rx->cnt & rx->mask;
2616         rx->cnt++;
2617         /* save a pointer to the received mbuf */
2618         m = rx->info[idx].m;
2619         /* try to replace the received mbuf */
2620         if (mxge_get_buf_small(ss, rx->extra_map, idx)) {
2621                 /* drop the frame -- the old mbuf is re-cycled */
2622                 ifp->if_ierrors++;
2623                 return;
2624         }
2625
2626         /* unmap the received buffer */
2627         old_map = rx->info[idx].map;
2628         bus_dmamap_sync(rx->dmat, old_map, BUS_DMASYNC_POSTREAD);
2629         bus_dmamap_unload(rx->dmat, old_map);
2630
2631         /* swap the bus_dmamap_t's */
2632         rx->info[idx].map = rx->extra_map;
2633         rx->extra_map = old_map;
2634
2635         /* mcp implicitly skips 1st 2 bytes so that packet is properly
2636          * aligned */
2637         m->m_data += MXGEFW_PAD;
2638
2639         m->m_pkthdr.rcvif = ifp;
2640         m->m_len = m->m_pkthdr.len = len;
2641         ss->ipackets++;
2642         eh = mtod(m, struct ether_header *);
2643         if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2644                 mxge_vlan_tag_remove(m, &csum);
2645         }
2646         /* if the checksum is valid, mark it in the mbuf header */
2647         if (sc->csum_flag && (0 == (tcpudp_csum = mxge_rx_csum(m, csum)))) {
2648                 if (sc->lro_cnt && (0 == mxge_lro_rx(ss, m, csum)))
2649                         return;
2650                 /* otherwise, it was a UDP frame, or a TCP frame which
2651                    we could not do LRO on.  Tell the stack that the
2652                    checksum is good */
2653                 m->m_pkthdr.csum_data = 0xffff;
2654                 m->m_pkthdr.csum_flags = CSUM_PSEUDO_HDR | CSUM_DATA_VALID;
2655         }
2656 #if 0
2657         /* flowid only valid if RSS hashing is enabled */
2658         if (sc->num_slices > 1) {
2659                 m->m_pkthdr.flowid = (ss - sc->ss);
2660                 m->m_flags |= M_FLOWID;
2661         }
2662 #endif
2663         /* pass the frame up the stack */
2664         (*ifp->if_input)(ifp, m);
2665 }
2666
2667 static inline void
2668 mxge_clean_rx_done(struct mxge_slice_state *ss)
2669 {
2670         mxge_rx_done_t *rx_done = &ss->rx_done;
2671         int limit = 0;
2672         uint16_t length;
2673         uint16_t checksum;
2674
2675
2676         while (rx_done->entry[rx_done->idx].length != 0) {
2677                 length = ntohs(rx_done->entry[rx_done->idx].length);
2678                 rx_done->entry[rx_done->idx].length = 0;
2679                 checksum = rx_done->entry[rx_done->idx].checksum;
2680                 if (length <= (MHLEN - MXGEFW_PAD))
2681                         mxge_rx_done_small(ss, length, checksum);
2682                 else
2683                         mxge_rx_done_big(ss, length, checksum);
2684                 rx_done->cnt++;
2685                 rx_done->idx = rx_done->cnt & rx_done->mask;
2686
2687                 /* limit potential for livelock */
2688                 if (__predict_false(++limit > rx_done->mask / 2))
2689                         break;
2690         }
2691 #ifdef INET
2692         while (!SLIST_EMPTY(&ss->lro_active)) {
2693                 struct lro_entry *lro = SLIST_FIRST(&ss->lro_active);
2694                 SLIST_REMOVE_HEAD(&ss->lro_active, next);
2695                 mxge_lro_flush(ss, lro);
2696         }
2697 #endif
2698 }
2699
2700
2701 static inline void
2702 mxge_tx_done(struct mxge_slice_state *ss, uint32_t mcp_idx)
2703 {
2704         struct ifnet *ifp;
2705         mxge_tx_ring_t *tx;
2706         struct mbuf *m;
2707         bus_dmamap_t map;
2708         int idx;
2709         int *flags;
2710
2711         tx = &ss->tx;
2712         ifp = ss->sc->ifp;
2713         while (tx->pkt_done != mcp_idx) {
2714                 idx = tx->done & tx->mask;
2715                 tx->done++;
2716                 m = tx->info[idx].m;
2717                 /* mbuf and DMA map only attached to the first
2718                    segment per-mbuf */
2719                 if (m != NULL) {
2720                         ss->obytes += m->m_pkthdr.len;
2721                         if (m->m_flags & M_MCAST)
2722                                 ss->omcasts++;
2723                         ss->opackets++;
2724                         tx->info[idx].m = NULL;
2725                         map = tx->info[idx].map;
2726                         bus_dmamap_unload(tx->dmat, map);
2727                         m_freem(m);
2728                 }
2729                 if (tx->info[idx].flag) {
2730                         tx->info[idx].flag = 0;
2731                         tx->pkt_done++;
2732                 }
2733         }
2734
2735         /* If we have space, clear IFF_OACTIVE to tell the stack that
2736            its OK to send packets */
2737 #ifdef IFNET_BUF_RING
2738         flags = &ss->if_flags;
2739 #else
2740         flags = &ifp->if_flags;
2741 #endif
2742         lwkt_serialize_enter(ifp->if_serializer);
2743         if ((*flags) & IFF_OACTIVE &&
2744             tx->req - tx->done < (tx->mask + 1)/4) {
2745                 *(flags) &= ~IFF_OACTIVE;
2746                 ss->tx.wake++;
2747                 mxge_start_locked(ss);
2748         }
2749 #ifdef IFNET_BUF_RING
2750         if ((ss->sc->num_slices > 1) && (tx->req == tx->done)) {
2751                 /* let the NIC stop polling this queue, since there
2752                  * are no more transmits pending */
2753                 if (tx->req == tx->done) {
2754                         *tx->send_stop = 1;
2755                         tx->queue_active = 0;
2756                         tx->deactivate++;
2757                         wmb();
2758                 }
2759         }
2760 #endif
2761         lwkt_serialize_exit(ifp->if_serializer);
2762
2763 }
2764
2765 static struct mxge_media_type mxge_xfp_media_types[] =
2766 {
2767         {IFM_10G_CX4,   0x7f,           "10GBASE-CX4 (module)"},
2768         {IFM_10G_SR,    (1 << 7),       "10GBASE-SR"},
2769         {IFM_10G_LR,    (1 << 6),       "10GBASE-LR"},
2770         {0,             (1 << 5),       "10GBASE-ER"},
2771         {IFM_10G_LRM,   (1 << 4),       "10GBASE-LRM"},
2772         {0,             (1 << 3),       "10GBASE-SW"},
2773         {0,             (1 << 2),       "10GBASE-LW"},
2774         {0,             (1 << 1),       "10GBASE-EW"},
2775         {0,             (1 << 0),       "Reserved"}
2776 };
2777 static struct mxge_media_type mxge_sfp_media_types[] =
2778 {
2779         {0,             (1 << 7),       "Reserved"},
2780         {IFM_10G_LRM,   (1 << 6),       "10GBASE-LRM"},
2781         {IFM_10G_LR,    (1 << 5),       "10GBASE-LR"},
2782         {IFM_10G_SR,    (1 << 4),       "10GBASE-SR"}
2783 };
2784
2785 static void
2786 mxge_set_media(mxge_softc_t *sc, int type)
2787 {
2788         sc->media_flags |= type;
2789         ifmedia_add(&sc->media, sc->media_flags, 0, NULL);
2790         ifmedia_set(&sc->media, sc->media_flags);
2791 }
2792
2793
2794 /*
2795  * Determine the media type for a NIC.  Some XFPs will identify
2796  * themselves only when their link is up, so this is initiated via a
2797  * link up interrupt.  However, this can potentially take up to
2798  * several milliseconds, so it is run via the watchdog routine, rather
2799  * than in the interrupt handler itself.   This need only be done
2800  * once, not each time the link is up.
2801  */
2802 static void
2803 mxge_media_probe(mxge_softc_t *sc)
2804 {
2805         mxge_cmd_t cmd;
2806         char *cage_type;
2807         char *ptr;
2808         struct mxge_media_type *mxge_media_types = NULL;
2809         int i, err, ms, mxge_media_type_entries;
2810         uint32_t byte;
2811
2812         sc->need_media_probe = 0;
2813
2814         /* if we've already set a media type, we're done */
2815         if (sc->media_flags  != (IFM_ETHER | IFM_AUTO))
2816                 return;
2817
2818         /*
2819          * parse the product code to deterimine the interface type
2820          * (CX4, XFP, Quad Ribbon Fiber) by looking at the character
2821          * after the 3rd dash in the driver's cached copy of the
2822          * EEPROM's product code string.
2823          */
2824         ptr = sc->product_code_string;
2825         if (ptr == NULL) {
2826                 device_printf(sc->dev, "Missing product code\n");
2827         }
2828
2829         for (i = 0; i < 3; i++, ptr++) {
2830                 ptr = index(ptr, '-');
2831                 if (ptr == NULL) {
2832                         device_printf(sc->dev,
2833                                       "only %d dashes in PC?!?\n", i);
2834                         return;
2835                 }
2836         }
2837         if (*ptr == 'C') {
2838                 /* -C is CX4 */
2839                 mxge_set_media(sc, IFM_10G_CX4);
2840                 return;
2841         }
2842         else if (*ptr == 'Q') {
2843                 /* -Q is Quad Ribbon Fiber */
2844                 device_printf(sc->dev, "Quad Ribbon Fiber Media\n");
2845                 /* FreeBSD has no media type for Quad ribbon fiber */
2846                 return;
2847         }
2848
2849         if (*ptr == 'R') {
2850                 /* -R is XFP */
2851                 mxge_media_types = mxge_xfp_media_types;
2852                 mxge_media_type_entries =
2853                         sizeof (mxge_xfp_media_types) /
2854                         sizeof (mxge_xfp_media_types[0]);
2855                 byte = MXGE_XFP_COMPLIANCE_BYTE;
2856                 cage_type = "XFP";
2857         }
2858
2859         if (*ptr == 'S' || *(ptr +1) == 'S') {
2860                 /* -S or -2S is SFP+ */
2861                 mxge_media_types = mxge_sfp_media_types;
2862                 mxge_media_type_entries =
2863                         sizeof (mxge_sfp_media_types) /
2864                         sizeof (mxge_sfp_media_types[0]);
2865                 cage_type = "SFP+";
2866                 byte = 3;
2867         }
2868
2869         if (mxge_media_types == NULL) {
2870                 device_printf(sc->dev, "Unknown media type: %c\n", *ptr);
2871                 return;
2872         }
2873
2874         /*
2875          * At this point we know the NIC has an XFP cage, so now we
2876          * try to determine what is in the cage by using the
2877          * firmware's XFP I2C commands to read the XFP 10GbE compilance
2878          * register.  We read just one byte, which may take over
2879          * a millisecond
2880          */
2881
2882         cmd.data0 = 0;   /* just fetch 1 byte, not all 256 */
2883         cmd.data1 = byte;
2884         err = mxge_send_cmd(sc, MXGEFW_CMD_I2C_READ, &cmd);
2885         if (err == MXGEFW_CMD_ERROR_I2C_FAILURE) {
2886                 device_printf(sc->dev, "failed to read XFP\n");
2887         }
2888         if (err == MXGEFW_CMD_ERROR_I2C_ABSENT) {
2889                 device_printf(sc->dev, "Type R/S with no XFP!?!?\n");
2890         }
2891         if (err != MXGEFW_CMD_OK) {
2892                 return;
2893         }
2894
2895         /* now we wait for the data to be cached */
2896         cmd.data0 = byte;
2897         err = mxge_send_cmd(sc, MXGEFW_CMD_I2C_BYTE, &cmd);
2898         for (ms = 0; (err == EBUSY) && (ms < 50); ms++) {
2899                 DELAY(1000);
2900                 cmd.data0 = byte;
2901                 err = mxge_send_cmd(sc, MXGEFW_CMD_I2C_BYTE, &cmd);
2902         }
2903         if (err != MXGEFW_CMD_OK) {
2904                 device_printf(sc->dev, "failed to read %s (%d, %dms)\n",
2905                               cage_type, err, ms);
2906                 return;
2907         }
2908
2909         if (cmd.data0 == mxge_media_types[0].bitmask) {
2910                 if (mxge_verbose)
2911                         device_printf(sc->dev, "%s:%s\n", cage_type,
2912                                       mxge_media_types[0].name);
2913                 mxge_set_media(sc, IFM_10G_CX4);
2914                 return;
2915         }
2916         for (i = 1; i < mxge_media_type_entries; i++) {
2917                 if (cmd.data0 & mxge_media_types[i].bitmask) {
2918                         if (mxge_verbose)
2919                                 device_printf(sc->dev, "%s:%s\n",
2920                                               cage_type,
2921                                               mxge_media_types[i].name);
2922
2923                         mxge_set_media(sc, mxge_media_types[i].flag);
2924                         return;
2925                 }
2926         }
2927         device_printf(sc->dev, "%s media 0x%x unknown\n", cage_type,
2928                       cmd.data0);
2929
2930         return;
2931 }
2932
2933 static void
2934 mxge_intr(void *arg)
2935 {
2936         struct mxge_slice_state *ss = arg;
2937         mxge_softc_t *sc = ss->sc;
2938         mcp_irq_data_t *stats = ss->fw_stats;
2939         mxge_tx_ring_t *tx = &ss->tx;
2940         mxge_rx_done_t *rx_done = &ss->rx_done;
2941         uint32_t send_done_count;
2942         uint8_t valid;
2943
2944
2945 #ifndef IFNET_BUF_RING
2946         /* an interrupt on a non-zero slice is implicitly valid
2947            since MSI-X irqs are not shared */
2948         if (ss != sc->ss) {
2949                 mxge_clean_rx_done(ss);
2950                 *ss->irq_claim = be32toh(3);
2951                 return;
2952         }
2953 #endif
2954
2955         /* make sure the DMA has finished */
2956         if (!stats->valid) {
2957                 return;
2958         }
2959         valid = stats->valid;
2960
2961         if (sc->legacy_irq) {
2962                 /* lower legacy IRQ  */
2963                 *sc->irq_deassert = 0;
2964                 if (!mxge_deassert_wait)
2965                         /* don't wait for conf. that irq is low */
2966                         stats->valid = 0;
2967         } else {
2968                 stats->valid = 0;
2969         }
2970
2971         /* loop while waiting for legacy irq deassertion */
2972         do {
2973                 /* check for transmit completes and receives */
2974                 send_done_count = be32toh(stats->send_done_count);
2975                 while ((send_done_count != tx->pkt_done) ||
2976                        (rx_done->entry[rx_done->idx].length != 0)) {
2977                         if (send_done_count != tx->pkt_done)
2978                                 mxge_tx_done(ss, (int)send_done_count);
2979                         mxge_clean_rx_done(ss);
2980                         send_done_count = be32toh(stats->send_done_count);
2981                 }
2982                 if (sc->legacy_irq && mxge_deassert_wait)
2983                         wmb();
2984         } while (*((volatile uint8_t *) &stats->valid));
2985
2986         /* fw link & error stats meaningful only on the first slice */
2987         if (__predict_false((ss == sc->ss) && stats->stats_updated)) {
2988                 if (sc->link_state != stats->link_up) {
2989                         sc->link_state = stats->link_up;
2990                         if (sc->link_state) {
2991                                 sc->ifp->if_link_state = LINK_STATE_UP;
2992                                 if_link_state_change(sc->ifp);
2993                                 if (mxge_verbose)
2994                                         device_printf(sc->dev, "link up\n");
2995                         } else {
2996                                 sc->ifp->if_link_state = LINK_STATE_DOWN;
2997                                 if_link_state_change(sc->ifp);
2998                                 if (mxge_verbose)
2999                                         device_printf(sc->dev, "link down\n");
3000                         }
3001                         sc->need_media_probe = 1;
3002                 }
3003                 if (sc->rdma_tags_available !=
3004                     be32toh(stats->rdma_tags_available)) {
3005                         sc->rdma_tags_available =
3006                                 be32toh(stats->rdma_tags_available);
3007                         device_printf(sc->dev, "RDMA timed out! %d tags "
3008                                       "left\n", sc->rdma_tags_available);
3009                 }
3010
3011                 if (stats->link_down) {
3012                         sc->down_cnt += stats->link_down;
3013                         sc->link_state = 0;
3014                         sc->ifp->if_link_state = LINK_STATE_DOWN;
3015                         if_link_state_change(sc->ifp);
3016                 }
3017         }
3018
3019         /* check to see if we have rx token to pass back */
3020         if (valid & 0x1)
3021             *ss->irq_claim = be32toh(3);
3022         *(ss->irq_claim + 1) = be32toh(3);
3023 }
3024
3025 static void
3026 mxge_init(void *arg)
3027 {
3028 }
3029
3030
3031
3032 static void
3033 mxge_free_slice_mbufs(struct mxge_slice_state *ss)
3034 {
3035         struct lro_entry *lro_entry;
3036         int i;
3037
3038         while (!SLIST_EMPTY(&ss->lro_free)) {
3039                 lro_entry = SLIST_FIRST(&ss->lro_free);
3040                 SLIST_REMOVE_HEAD(&ss->lro_free, next);
3041                 kfree(lro_entry, M_DEVBUF);
3042         }
3043
3044         for (i = 0; i <= ss->rx_big.mask; i++) {
3045                 if (ss->rx_big.info[i].m == NULL)
3046                         continue;
3047                 bus_dmamap_unload(ss->rx_big.dmat,
3048                                   ss->rx_big.info[i].map);
3049                 m_freem(ss->rx_big.info[i].m);
3050                 ss->rx_big.info[i].m = NULL;
3051         }
3052
3053         for (i = 0; i <= ss->rx_small.mask; i++) {
3054                 if (ss->rx_small.info[i].m == NULL)
3055                         continue;
3056                 bus_dmamap_unload(ss->rx_small.dmat,
3057                                   ss->rx_small.info[i].map);
3058                 m_freem(ss->rx_small.info[i].m);
3059                 ss->rx_small.info[i].m = NULL;
3060         }
3061
3062         /* transmit ring used only on the first slice */
3063         if (ss->tx.info == NULL)
3064                 return;
3065
3066         for (i = 0; i <= ss->tx.mask; i++) {
3067                 ss->tx.info[i].flag = 0;
3068                 if (ss->tx.info[i].m == NULL)
3069                         continue;
3070                 bus_dmamap_unload(ss->tx.dmat,
3071                                   ss->tx.info[i].map);
3072                 m_freem(ss->tx.info[i].m);
3073                 ss->tx.info[i].m = NULL;
3074         }
3075 }
3076
3077 static void
3078 mxge_free_mbufs(mxge_softc_t *sc)
3079 {
3080         int slice;
3081
3082         for (slice = 0; slice < sc->num_slices; slice++)
3083                 mxge_free_slice_mbufs(&sc->ss[slice]);
3084 }
3085
3086 static void
3087 mxge_free_slice_rings(struct mxge_slice_state *ss)
3088 {
3089         int i;
3090
3091
3092         if (ss->rx_done.entry != NULL)
3093                 mxge_dma_free(&ss->rx_done.dma);
3094         ss->rx_done.entry = NULL;
3095
3096         if (ss->tx.req_bytes != NULL)
3097                 kfree(ss->tx.req_bytes, M_DEVBUF);
3098         ss->tx.req_bytes = NULL;
3099
3100         if (ss->tx.seg_list != NULL)
3101                 kfree(ss->tx.seg_list, M_DEVBUF);
3102         ss->tx.seg_list = NULL;
3103
3104         if (ss->rx_small.shadow != NULL)
3105                 kfree(ss->rx_small.shadow, M_DEVBUF);
3106         ss->rx_small.shadow = NULL;
3107
3108         if (ss->rx_big.shadow != NULL)
3109                 kfree(ss->rx_big.shadow, M_DEVBUF);
3110         ss->rx_big.shadow = NULL;
3111
3112         if (ss->tx.info != NULL) {
3113                 if (ss->tx.dmat != NULL) {
3114                         for (i = 0; i <= ss->tx.mask; i++) {
3115                                 bus_dmamap_destroy(ss->tx.dmat,
3116                                                    ss->tx.info[i].map);
3117                         }
3118                         bus_dma_tag_destroy(ss->tx.dmat);
3119                 }
3120                 kfree(ss->tx.info, M_DEVBUF);
3121         }
3122         ss->tx.info = NULL;
3123
3124         if (ss->rx_small.info != NULL) {
3125                 if (ss->rx_small.dmat != NULL) {
3126                         for (i = 0; i <= ss->rx_small.mask; i++) {
3127                                 bus_dmamap_destroy(ss->rx_small.dmat,
3128                                                    ss->rx_small.info[i].map);
3129                         }
3130                         bus_dmamap_destroy(ss->rx_small.dmat,
3131                                            ss->rx_small.extra_map);
3132                         bus_dma_tag_destroy(ss->rx_small.dmat);
3133                 }
3134                 kfree(ss->rx_small.info, M_DEVBUF);
3135         }
3136         ss->rx_small.info = NULL;
3137
3138         if (ss->rx_big.info != NULL) {
3139                 if (ss->rx_big.dmat != NULL) {
3140                         for (i = 0; i <= ss->rx_big.mask; i++) {
3141                                 bus_dmamap_destroy(ss->rx_big.dmat,
3142                                                    ss->rx_big.info[i].map);
3143                         }
3144                         bus_dmamap_destroy(ss->rx_big.dmat,
3145                                            ss->rx_big.extra_map);
3146                         bus_dma_tag_destroy(ss->rx_big.dmat);
3147                 }
3148                 kfree(ss->rx_big.info, M_DEVBUF);
3149         }
3150         ss->rx_big.info = NULL;
3151 }
3152
3153 static void
3154 mxge_free_rings(mxge_softc_t *sc)
3155 {
3156         int slice;
3157
3158         for (slice = 0; slice < sc->num_slices; slice++)
3159                 mxge_free_slice_rings(&sc->ss[slice]);
3160 }
3161
3162 static int
3163 mxge_alloc_slice_rings(struct mxge_slice_state *ss, int rx_ring_entries,
3164                        int tx_ring_entries)
3165 {
3166         mxge_softc_t *sc = ss->sc;
3167         size_t bytes;
3168         int err, i;
3169
3170         err = ENOMEM;
3171
3172         /* allocate per-slice receive resources */
3173
3174         ss->rx_small.mask = ss->rx_big.mask = rx_ring_entries - 1;
3175         ss->rx_done.mask = (2 * rx_ring_entries) - 1;
3176
3177         /* allocate the rx shadow rings */
3178         bytes = rx_ring_entries * sizeof (*ss->rx_small.shadow);
3179         ss->rx_small.shadow = kmalloc(bytes, M_DEVBUF, M_ZERO|M_WAITOK);
3180         if (ss->rx_small.shadow == NULL)
3181                 return err;;
3182
3183         bytes = rx_ring_entries * sizeof (*ss->rx_big.shadow);
3184         ss->rx_big.shadow = kmalloc(bytes, M_DEVBUF, M_ZERO|M_WAITOK);
3185         if (ss->rx_big.shadow == NULL)
3186                 return err;;
3187
3188         /* allocate the rx host info rings */
3189         bytes = rx_ring_entries * sizeof (*ss->rx_small.info);
3190         ss->rx_small.info = kmalloc(bytes, M_DEVBUF, M_ZERO|M_WAITOK);
3191         if (ss->rx_small.info == NULL)
3192                 return err;;
3193
3194         bytes = rx_ring_entries * sizeof (*ss->rx_big.info);
3195         ss->rx_big.info = kmalloc(bytes, M_DEVBUF, M_ZERO|M_WAITOK);
3196         if (ss->rx_big.info == NULL)
3197                 return err;;
3198
3199         /* allocate the rx busdma resources */
3200         err = bus_dma_tag_create(sc->parent_dmat,       /* parent */
3201                                  1,                     /* alignment */
3202                                  4096,                  /* boundary */
3203                                  BUS_SPACE_MAXADDR,     /* low */
3204                                  BUS_SPACE_MAXADDR,     /* high */
3205                                  NULL, NULL,            /* filter */
3206                                  MHLEN,                 /* maxsize */
3207                                  1,                     /* num segs */
3208                                  MHLEN,                 /* maxsegsize */
3209                                  BUS_DMA_ALLOCNOW,      /* flags */
3210                                  &ss->rx_small.dmat);   /* tag */
3211         if (err != 0) {
3212                 device_printf(sc->dev, "Err %d allocating rx_small dmat\n",
3213                               err);
3214                 return err;;
3215         }
3216
3217         err = bus_dma_tag_create(sc->parent_dmat,       /* parent */
3218                                  1,                     /* alignment */
3219 #if MXGE_VIRT_JUMBOS
3220                                  4096,                  /* boundary */
3221 #else
3222                                  0,                     /* boundary */
3223 #endif
3224                                  BUS_SPACE_MAXADDR,     /* low */
3225                                  BUS_SPACE_MAXADDR,     /* high */
3226                                  NULL, NULL,            /* filter */
3227                                  3*4096,                /* maxsize */
3228 #if MXGE_VIRT_JUMBOS
3229                                  3,                     /* num segs */
3230                                  4096,                  /* maxsegsize*/
3231 #else
3232                                  1,                     /* num segs */
3233                                  MJUM9BYTES,            /* maxsegsize*/
3234 #endif
3235                                  BUS_DMA_ALLOCNOW,      /* flags */
3236                                  &ss->rx_big.dmat);     /* tag */
3237         if (err != 0) {
3238                 device_printf(sc->dev, "Err %d allocating rx_big dmat\n",
3239                               err);
3240                 return err;;
3241         }
3242         for (i = 0; i <= ss->rx_small.mask; i++) {
3243                 err = bus_dmamap_create(ss->rx_small.dmat, 0,
3244                                         &ss->rx_small.info[i].map);
3245                 if (err != 0) {
3246                         device_printf(sc->dev, "Err %d  rx_small dmamap\n",
3247                                       err);
3248                         return err;;
3249                 }
3250         }
3251         err = bus_dmamap_create(ss->rx_small.dmat, 0,
3252                                 &ss->rx_small.extra_map);
3253         if (err != 0) {
3254                 device_printf(sc->dev, "Err %d extra rx_small dmamap\n",
3255                               err);
3256                 return err;;
3257         }
3258
3259         for (i = 0; i <= ss->rx_big.mask; i++) {
3260                 err = bus_dmamap_create(ss->rx_big.dmat, 0,
3261                                         &ss->rx_big.info[i].map);
3262                 if (err != 0) {
3263                         device_printf(sc->dev, "Err %d  rx_big dmamap\n",
3264                                       err);
3265                         return err;;
3266                 }
3267         }
3268         err = bus_dmamap_create(ss->rx_big.dmat, 0,
3269                                 &ss->rx_big.extra_map);
3270         if (err != 0) {
3271                 device_printf(sc->dev, "Err %d extra rx_big dmamap\n",
3272                               err);
3273                 return err;;
3274         }
3275
3276         /* now allocate TX resouces */
3277
3278 #ifndef IFNET_BUF_RING
3279         /* only use a single TX ring for now */
3280         if (ss != ss->sc->ss)
3281                 return 0;
3282 #endif
3283
3284         ss->tx.mask = tx_ring_entries - 1;
3285         ss->tx.max_desc = MIN(MXGE_MAX_SEND_DESC, tx_ring_entries / 4);
3286
3287
3288         /* allocate the tx request copy block */
3289         bytes = 8 +
3290                 sizeof (*ss->tx.req_list) * (ss->tx.max_desc + 4);
3291         ss->tx.req_bytes = kmalloc(bytes, M_DEVBUF, M_WAITOK);
3292         if (ss->tx.req_bytes == NULL)
3293                 return err;;
3294         /* ensure req_list entries are aligned to 8 bytes */
3295         ss->tx.req_list = (mcp_kreq_ether_send_t *)
3296                 ((unsigned long)(ss->tx.req_bytes + 7) & ~7UL);
3297
3298         /* allocate the tx busdma segment list */
3299         bytes = sizeof (*ss->tx.seg_list) * ss->tx.max_desc;
3300         ss->tx.seg_list = (bus_dma_segment_t *)
3301                 kmalloc(bytes, M_DEVBUF, M_WAITOK);
3302         if (ss->tx.seg_list == NULL)
3303                 return err;;
3304
3305         /* allocate the tx host info ring */
3306         bytes = tx_ring_entries * sizeof (*ss->tx.info);
3307         ss->tx.info = kmalloc(bytes, M_DEVBUF, M_ZERO|M_WAITOK);
3308         if (ss->tx.info == NULL)
3309                 return err;;
3310
3311         /* allocate the tx busdma resources */
3312         err = bus_dma_tag_create(sc->parent_dmat,       /* parent */
3313                                  1,                     /* alignment */
3314                                  sc->tx_boundary,       /* boundary */
3315                                  BUS_SPACE_MAXADDR,     /* low */
3316                                  BUS_SPACE_MAXADDR,     /* high */
3317                                  NULL, NULL,            /* filter */
3318                                  65536 + 256,           /* maxsize */
3319                                  ss->tx.max_desc - 2,   /* num segs */
3320                                  sc->tx_boundary,       /* maxsegsz */
3321                                  BUS_DMA_ALLOCNOW,      /* flags */
3322                                  &ss->tx.dmat);         /* tag */
3323
3324         if (err != 0) {
3325                 device_printf(sc->dev, "Err %d allocating tx dmat\n",
3326                               err);
3327                 return err;;
3328         }
3329
3330         /* now use these tags to setup dmamaps for each slot
3331            in the ring */
3332         for (i = 0; i <= ss->tx.mask; i++) {
3333                 err = bus_dmamap_create(ss->tx.dmat, 0,
3334                                         &ss->tx.info[i].map);
3335                 if (err != 0) {
3336                         device_printf(sc->dev, "Err %d  tx dmamap\n",
3337                                       err);
3338                         return err;;
3339                 }
3340         }
3341         return 0;
3342
3343 }
3344
3345 static int
3346 mxge_alloc_rings(mxge_softc_t *sc)
3347 {
3348         mxge_cmd_t cmd;
3349         int tx_ring_size;
3350         int tx_ring_entries, rx_ring_entries;
3351         int err, slice;
3352
3353         /* get ring sizes */
3354         err = mxge_send_cmd(sc, MXGEFW_CMD_GET_SEND_RING_SIZE, &cmd);
3355         tx_ring_size = cmd.data0;
3356         if (err != 0) {
3357                 device_printf(sc->dev, "Cannot determine tx ring sizes\n");
3358                 goto abort;
3359         }
3360
3361         tx_ring_entries = tx_ring_size / sizeof (mcp_kreq_ether_send_t);
3362         rx_ring_entries = sc->rx_ring_size / sizeof (mcp_dma_addr_t);
3363         ifq_set_maxlen(&sc->ifp->if_snd, tx_ring_entries - 1);
3364         ifq_set_ready(&sc->ifp->if_snd);
3365
3366         for (slice = 0; slice < sc->num_slices; slice++) {
3367                 err = mxge_alloc_slice_rings(&sc->ss[slice],
3368                                              rx_ring_entries,
3369                                              tx_ring_entries);
3370                 if (err != 0)
3371                         goto abort;
3372         }
3373         return 0;
3374
3375 abort:
3376         mxge_free_rings(sc);
3377         return err;
3378
3379 }
3380
3381
3382 static void
3383 mxge_choose_params(int mtu, int *big_buf_size, int *cl_size, int *nbufs)
3384 {
3385         int bufsize = mtu + ETHER_HDR_LEN + EVL_ENCAPLEN + MXGEFW_PAD;
3386
3387         if (bufsize < MCLBYTES) {
3388                 /* easy, everything fits in a single buffer */
3389                 *big_buf_size = MCLBYTES;
3390                 *cl_size = MCLBYTES;
3391                 *nbufs = 1;
3392                 return;
3393         }
3394
3395         if (bufsize < MJUMPAGESIZE) {
3396                 /* still easy, everything still fits in a single buffer */
3397                 *big_buf_size = MJUMPAGESIZE;
3398                 *cl_size = MJUMPAGESIZE;
3399                 *nbufs = 1;
3400                 return;
3401         }
3402 #if MXGE_VIRT_JUMBOS
3403         /* now we need to use virtually contiguous buffers */
3404         *cl_size = MJUM9BYTES;
3405         *big_buf_size = 4096;
3406         *nbufs = mtu / 4096 + 1;
3407         /* needs to be a power of two, so round up */
3408         if (*nbufs == 3)
3409                 *nbufs = 4;
3410 #else
3411         *cl_size = MJUM9BYTES;
3412         *big_buf_size = MJUM9BYTES;
3413         *nbufs = 1;
3414 #endif
3415 }
3416
3417 static int
3418 mxge_slice_open(struct mxge_slice_state *ss, int nbufs, int cl_size)
3419 {
3420         mxge_softc_t *sc;
3421         mxge_cmd_t cmd;
3422         bus_dmamap_t map;
3423         struct lro_entry *lro_entry;
3424         int err, i, slice;
3425
3426
3427         sc = ss->sc;
3428         slice = ss - sc->ss;
3429
3430         SLIST_INIT(&ss->lro_free);
3431         SLIST_INIT(&ss->lro_active);
3432
3433         for (i = 0; i < sc->lro_cnt; i++) {
3434                 lro_entry = (struct lro_entry *)
3435                         kmalloc(sizeof (*lro_entry), M_DEVBUF,
3436                                M_NOWAIT | M_ZERO);
3437                 if (lro_entry == NULL) {
3438                         sc->lro_cnt = i;
3439                         break;
3440                 }
3441                 SLIST_INSERT_HEAD(&ss->lro_free, lro_entry, next);
3442         }
3443         /* get the lanai pointers to the send and receive rings */
3444
3445         err = 0;
3446 #ifndef IFNET_BUF_RING
3447         /* We currently only send from the first slice */
3448         if (slice == 0) {
3449 #endif
3450                 cmd.data0 = slice;
3451                 err = mxge_send_cmd(sc, MXGEFW_CMD_GET_SEND_OFFSET, &cmd);
3452                 ss->tx.lanai =
3453                         (volatile mcp_kreq_ether_send_t *)(sc->sram + cmd.data0);
3454                 ss->tx.send_go = (volatile uint32_t *)
3455                         (sc->sram + MXGEFW_ETH_SEND_GO + 64 * slice);
3456                 ss->tx.send_stop = (volatile uint32_t *)
3457                 (sc->sram + MXGEFW_ETH_SEND_STOP + 64 * slice);
3458 #ifndef IFNET_BUF_RING
3459         }
3460 #endif
3461         cmd.data0 = slice;
3462         err |= mxge_send_cmd(sc,
3463                              MXGEFW_CMD_GET_SMALL_RX_OFFSET, &cmd);
3464         ss->rx_small.lanai =
3465                 (volatile mcp_kreq_ether_recv_t *)(sc->sram + cmd.data0);
3466         cmd.data0 = slice;
3467         err |= mxge_send_cmd(sc, MXGEFW_CMD_GET_BIG_RX_OFFSET, &cmd);
3468         ss->rx_big.lanai =
3469                 (volatile mcp_kreq_ether_recv_t *)(sc->sram + cmd.data0);
3470
3471         if (err != 0) {
3472                 device_printf(sc->dev,
3473                               "failed to get ring sizes or locations\n");
3474                 return EIO;
3475         }
3476
3477         /* stock receive rings */
3478         for (i = 0; i <= ss->rx_small.mask; i++) {
3479                 map = ss->rx_small.info[i].map;
3480                 err = mxge_get_buf_small(ss, map, i);
3481                 if (err) {
3482                         device_printf(sc->dev, "alloced %d/%d smalls\n",
3483                                       i, ss->rx_small.mask + 1);
3484                         return ENOMEM;
3485                 }
3486         }
3487         for (i = 0; i <= ss->rx_big.mask; i++) {
3488                 ss->rx_big.shadow[i].addr_low = 0xffffffff;
3489                 ss->rx_big.shadow[i].addr_high = 0xffffffff;
3490         }
3491         ss->rx_big.nbufs = nbufs;
3492         ss->rx_big.cl_size = cl_size;
3493         ss->rx_big.mlen = ss->sc->ifp->if_mtu + ETHER_HDR_LEN +
3494                 EVL_ENCAPLEN + MXGEFW_PAD;
3495         for (i = 0; i <= ss->rx_big.mask; i += ss->rx_big.nbufs) {
3496                 map = ss->rx_big.info[i].map;
3497                 err = mxge_get_buf_big(ss, map, i);
3498                 if (err) {
3499                         device_printf(sc->dev, "alloced %d/%d bigs\n",
3500                                       i, ss->rx_big.mask + 1);
3501                         return ENOMEM;
3502                 }
3503         }
3504         return 0;
3505 }
3506
3507 static int
3508 mxge_open(mxge_softc_t *sc)
3509 {
3510         mxge_cmd_t cmd;
3511         int err, big_bytes, nbufs, slice, cl_size, i;
3512         bus_addr_t bus;
3513         volatile uint8_t *itable;
3514         struct mxge_slice_state *ss;
3515
3516         /* Copy the MAC address in case it was overridden */
3517         bcopy(IF_LLADDR(sc->ifp), sc->mac_addr, ETHER_ADDR_LEN);
3518
3519         err = mxge_reset(sc, 1);
3520         if (err != 0) {
3521                 device_printf(sc->dev, "failed to reset\n");
3522                 return EIO;
3523         }
3524
3525         if (sc->num_slices > 1) {
3526                 /* setup the indirection table */
3527                 cmd.data0 = sc->num_slices;
3528                 err = mxge_send_cmd(sc, MXGEFW_CMD_SET_RSS_TABLE_SIZE,
3529                                     &cmd);
3530
3531                 err |= mxge_send_cmd(sc, MXGEFW_CMD_GET_RSS_TABLE_OFFSET,
3532                                      &cmd);
3533                 if (err != 0) {
3534                         device_printf(sc->dev,
3535                                       "failed to setup rss tables\n");
3536                         return err;
3537                 }
3538
3539                 /* just enable an identity mapping */
3540                 itable = sc->sram + cmd.data0;
3541                 for (i = 0; i < sc->num_slices; i++)
3542                         itable[i] = (uint8_t)i;
3543
3544                 cmd.data0 = 1;
3545                 cmd.data1 = mxge_rss_hash_type;
3546                 err = mxge_send_cmd(sc, MXGEFW_CMD_SET_RSS_ENABLE, &cmd);
3547                 if (err != 0) {
3548                         device_printf(sc->dev, "failed to enable slices\n");
3549                         return err;
3550                 }
3551         }
3552
3553
3554         mxge_choose_params(sc->ifp->if_mtu, &big_bytes, &cl_size, &nbufs);
3555
3556         cmd.data0 = nbufs;
3557         err = mxge_send_cmd(sc, MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS,
3558                             &cmd);
3559         /* error is only meaningful if we're trying to set
3560            MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS > 1 */
3561         if (err && nbufs > 1) {
3562                 device_printf(sc->dev,
3563                               "Failed to set alway-use-n to %d\n",
3564                               nbufs);
3565                 return EIO;
3566         }
3567         /* Give the firmware the mtu and the big and small buffer
3568            sizes.  The firmware wants the big buf size to be a power
3569            of two. Luckily, FreeBSD's clusters are powers of two */
3570         cmd.data0 = sc->ifp->if_mtu + ETHER_HDR_LEN + EVL_ENCAPLEN;
3571         err = mxge_send_cmd(sc, MXGEFW_CMD_SET_MTU, &cmd);
3572         cmd.data0 = MHLEN - MXGEFW_PAD;
3573         err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_SMALL_BUFFER_SIZE,
3574                              &cmd);
3575         cmd.data0 = big_bytes;
3576         err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_BIG_BUFFER_SIZE, &cmd);
3577
3578         if (err != 0) {
3579                 device_printf(sc->dev, "failed to setup params\n");
3580                 goto abort;
3581         }
3582
3583         /* Now give him the pointer to the stats block */
3584         for (slice = 0;
3585 #ifdef IFNET_BUF_RING
3586              slice < sc->num_slices;
3587 #else
3588              slice < 1;
3589 #endif
3590              slice++) {
3591                 ss = &sc->ss[slice];
3592                 cmd.data0 =
3593                         MXGE_LOWPART_TO_U32(ss->fw_stats_dma.bus_addr);
3594                 cmd.data1 =
3595                         MXGE_HIGHPART_TO_U32(ss->fw_stats_dma.bus_addr);
3596                 cmd.data2 = sizeof(struct mcp_irq_data);
3597                 cmd.data2 |= (slice << 16);
3598                 err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_STATS_DMA_V2, &cmd);
3599         }
3600
3601         if (err != 0) {
3602                 bus = sc->ss->fw_stats_dma.bus_addr;
3603                 bus += offsetof(struct mcp_irq_data, send_done_count);
3604                 cmd.data0 = MXGE_LOWPART_TO_U32(bus);
3605                 cmd.data1 = MXGE_HIGHPART_TO_U32(bus);
3606                 err = mxge_send_cmd(sc,
3607                                     MXGEFW_CMD_SET_STATS_DMA_OBSOLETE,
3608                                     &cmd);
3609                 /* Firmware cannot support multicast without STATS_DMA_V2 */
3610                 sc->fw_multicast_support = 0;
3611         } else {
3612                 sc->fw_multicast_support = 1;
3613         }
3614
3615         if (err != 0) {
3616                 device_printf(sc->dev, "failed to setup params\n");
3617                 goto abort;
3618         }
3619
3620         for (slice = 0; slice < sc->num_slices; slice++) {
3621                 err = mxge_slice_open(&sc->ss[slice], nbufs, cl_size);
3622                 if (err != 0) {
3623                         device_printf(sc->dev, "couldn't open slice %d\n",
3624                                       slice);
3625                         goto abort;
3626                 }
3627         }
3628
3629         /* Finally, start the firmware running */
3630         err = mxge_send_cmd(sc, MXGEFW_CMD_ETHERNET_UP, &cmd);
3631         if (err) {
3632                 device_printf(sc->dev, "Couldn't bring up link\n");
3633                 goto abort;
3634         }
3635 #ifdef IFNET_BUF_RING
3636         for (slice = 0; slice < sc->num_slices; slice++) {
3637                 ss = &sc->ss[slice];
3638                 ss->if_flags |= IFF_RUNNING;
3639                 ss->if_flags &= ~IFF_OACTIVE;
3640         }
3641 #endif
3642         sc->ifp->if_flags |= IFF_RUNNING;
3643         sc->ifp->if_flags &= ~IFF_OACTIVE;
3644         callout_reset(&sc->co_hdl, mxge_ticks, mxge_tick, sc);
3645
3646         return 0;
3647
3648
3649 abort:
3650         mxge_free_mbufs(sc);
3651
3652         return err;
3653 }
3654
3655 static int
3656 mxge_close(mxge_softc_t *sc)
3657 {
3658         mxge_cmd_t cmd;
3659         int err, old_down_cnt;
3660 #ifdef IFNET_BUF_RING
3661         struct mxge_slice_state *ss;
3662         int slice;
3663 #endif
3664
3665         callout_stop(&sc->co_hdl);
3666 #ifdef IFNET_BUF_RING
3667         for (slice = 0; slice < sc->num_slices; slice++) {
3668                 ss = &sc->ss[slice];
3669                 ss->if_flags &= ~IFF_RUNNING;
3670         }
3671 #endif
3672         sc->ifp->if_flags &= ~IFF_RUNNING;
3673         old_down_cnt = sc->down_cnt;
3674         wmb();
3675         err = mxge_send_cmd(sc, MXGEFW_CMD_ETHERNET_DOWN, &cmd);
3676         if (err) {
3677                 device_printf(sc->dev, "Couldn't bring down link\n");
3678         }
3679         if (old_down_cnt == sc->down_cnt) {
3680                 /* wait for down irq */
3681                 DELAY(10 * sc->intr_coal_delay);
3682         }
3683         wmb();
3684         if (old_down_cnt == sc->down_cnt) {
3685                 device_printf(sc->dev, "never got down irq\n");
3686         }
3687
3688         mxge_free_mbufs(sc);
3689
3690         return 0;
3691 }
3692
3693 static void
3694 mxge_setup_cfg_space(mxge_softc_t *sc)
3695 {
3696         device_t dev = sc->dev;
3697         int reg;
3698         uint16_t cmd, lnk, pectl;
3699
3700         /* find the PCIe link width and set max read request to 4KB*/
3701         if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
3702                 lnk = pci_read_config(dev, reg + 0x12, 2);
3703                 sc->link_width = (lnk >> 4) & 0x3f;
3704
3705                 pectl = pci_read_config(dev, reg + 0x8, 2);
3706                 pectl = (pectl & ~0x7000) | (5 << 12);
3707                 pci_write_config(dev, reg + 0x8, pectl, 2);
3708         }
3709
3710         /* Enable DMA and Memory space access */
3711         pci_enable_busmaster(dev);
3712         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3713         cmd |= PCIM_CMD_MEMEN;
3714         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
3715 }
3716
3717 static uint32_t
3718 mxge_read_reboot(mxge_softc_t *sc)
3719 {
3720         device_t dev = sc->dev;
3721         uint32_t vs;
3722
3723         /* find the vendor specific offset */
3724         if (pci_find_extcap(dev, PCIY_VENDOR, &vs) != 0) {
3725                 device_printf(sc->dev,
3726                               "could not find vendor specific offset\n");
3727                 return (uint32_t)-1;
3728         }
3729         /* enable read32 mode */
3730         pci_write_config(dev, vs + 0x10, 0x3, 1);
3731         /* tell NIC which register to read */
3732         pci_write_config(dev, vs + 0x18, 0xfffffff0, 4);
3733         return (pci_read_config(dev, vs + 0x14, 4));
3734 }
3735
3736 static int
3737 mxge_watchdog_reset(mxge_softc_t *sc, int slice)
3738 {
3739         struct pci_devinfo *dinfo;
3740         mxge_tx_ring_t *tx;
3741         int err;
3742         uint32_t reboot;
3743         uint16_t cmd;
3744
3745         err = ENXIO;
3746
3747         device_printf(sc->dev, "Watchdog reset!\n");
3748
3749         /*
3750          * check to see if the NIC rebooted.  If it did, then all of
3751          * PCI config space has been reset, and things like the
3752          * busmaster bit will be zero.  If this is the case, then we
3753          * must restore PCI config space before the NIC can be used
3754          * again
3755          */
3756         cmd = pci_read_config(sc->dev, PCIR_COMMAND, 2);
3757         if (cmd == 0xffff) {
3758                 /*
3759                  * maybe the watchdog caught the NIC rebooting; wait
3760                  * up to 100ms for it to finish.  If it does not come
3761                  * back, then give up
3762                  */
3763                 DELAY(1000*100);
3764                 cmd = pci_read_config(sc->dev, PCIR_COMMAND, 2);
3765                 if (cmd == 0xffff) {
3766                         device_printf(sc->dev, "NIC disappeared!\n");
3767                         return (err);
3768                 }
3769         }
3770         if ((cmd & PCIM_CMD_BUSMASTEREN) == 0) {
3771                 /* print the reboot status */
3772                 reboot = mxge_read_reboot(sc);
3773                 device_printf(sc->dev, "NIC rebooted, status = 0x%x\n",
3774                               reboot);
3775                 /* restore PCI configuration space */
3776                 dinfo = device_get_ivars(sc->dev);
3777                 pci_cfg_restore(sc->dev, dinfo);
3778
3779                 /* and redo any changes we made to our config space */
3780                 mxge_setup_cfg_space(sc);
3781
3782                 if (sc->ifp->if_flags & IFF_RUNNING) {
3783                         mxge_close(sc);
3784                         err = mxge_open(sc);
3785                 }
3786         } else {
3787                 tx = &sc->ss[slice].tx;
3788                 device_printf(sc->dev,
3789                               "NIC did not reboot, slice %d ring state:\n",
3790                               slice);
3791                 device_printf(sc->dev,
3792                               "tx.req=%d tx.done=%d, tx.queue_active=%d\n",
3793                               tx->req, tx->done, tx->queue_active);
3794                 device_printf(sc->dev, "tx.activate=%d tx.deactivate=%d\n",
3795                               tx->activate, tx->deactivate);
3796                 device_printf(sc->dev, "pkt_done=%d fw=%d\n",
3797                               tx->pkt_done,
3798                               be32toh(sc->ss->fw_stats->send_done_count));
3799                 device_printf(sc->dev, "not resetting\n");
3800         }
3801         return (err);
3802 }
3803
3804 static int
3805 mxge_watchdog(mxge_softc_t *sc)
3806 {
3807         mxge_tx_ring_t *tx;
3808         uint32_t rx_pause = be32toh(sc->ss->fw_stats->dropped_pause);
3809         int i, err = 0;
3810
3811         /* see if we have outstanding transmits, which
3812            have been pending for more than mxge_ticks */
3813         for (i = 0;
3814 #ifdef IFNET_BUF_RING
3815              (i < sc->num_slices) && (err == 0);
3816 #else
3817              (i < 1) && (err == 0);
3818 #endif
3819              i++) {
3820                 tx = &sc->ss[i].tx;
3821                 if (tx->req != tx->done &&
3822                     tx->watchdog_req != tx->watchdog_done &&
3823                     tx->done == tx->watchdog_done) {
3824                         /* check for pause blocking before resetting */
3825                         if (tx->watchdog_rx_pause == rx_pause)
3826                                 err = mxge_watchdog_reset(sc, i);
3827                         else
3828                                 device_printf(sc->dev, "Flow control blocking "
3829                                               "xmits, check link partner\n");
3830                 }
3831
3832                 tx->watchdog_req = tx->req;
3833                 tx->watchdog_done = tx->done;
3834                 tx->watchdog_rx_pause = rx_pause;
3835         }
3836
3837         if (sc->need_media_probe)
3838                 mxge_media_probe(sc);
3839         return (err);
3840 }
3841
3842 static void
3843 mxge_update_stats(mxge_softc_t *sc)
3844 {
3845         struct mxge_slice_state *ss;
3846         u_long ipackets = 0;
3847         u_long opackets = 0;
3848 #ifdef IFNET_BUF_RING
3849         u_long obytes = 0;
3850         u_long omcasts = 0;
3851         u_long odrops = 0;
3852 #endif
3853         u_long oerrors = 0;
3854         int slice;
3855
3856         for (slice = 0; slice < sc->num_slices; slice++) {
3857                 ss = &sc->ss[slice];
3858                 ipackets += ss->ipackets;
3859                 opackets += ss->opackets;
3860 #ifdef IFNET_BUF_RING
3861                 obytes += ss->obytes;
3862                 omcasts += ss->omcasts;
3863                 odrops += ss->tx.br->br_drops;
3864 #endif
3865                 oerrors += ss->oerrors;
3866         }
3867         sc->ifp->if_ipackets = ipackets;
3868         sc->ifp->if_opackets = opackets;
3869 #ifdef IFNET_BUF_RING
3870         sc->ifp->if_obytes = obytes;
3871         sc->ifp->if_omcasts = omcasts;
3872         sc->ifp->if_snd.ifq_drops = odrops;
3873 #endif
3874         sc->ifp->if_oerrors = oerrors;
3875 }
3876
3877 static void
3878 mxge_tick(void *arg)
3879 {
3880         mxge_softc_t *sc = arg;
3881         int err = 0;
3882
3883         lwkt_serialize_enter(sc->ifp->if_serializer);
3884         /* aggregate stats from different slices */
3885         mxge_update_stats(sc);
3886         if (!sc->watchdog_countdown) {
3887                 err = mxge_watchdog(sc);
3888                 sc->watchdog_countdown = 4;
3889         }
3890         sc->watchdog_countdown--;
3891         if (err == 0)
3892                 callout_reset(&sc->co_hdl, mxge_ticks, mxge_tick, sc);
3893         lwkt_serialize_exit(sc->ifp->if_serializer);
3894 }
3895
3896 static int
3897 mxge_media_change(struct ifnet *ifp)
3898 {
3899         return EINVAL;
3900 }
3901
3902 static int
3903 mxge_change_mtu(mxge_softc_t *sc, int mtu)
3904 {
3905         struct ifnet *ifp = sc->ifp;
3906         int real_mtu, old_mtu;
3907         int err = 0;
3908
3909
3910         real_mtu = mtu + ETHER_HDR_LEN + EVL_ENCAPLEN;
3911         if ((real_mtu > sc->max_mtu) || real_mtu < 60)
3912                 return EINVAL;
3913         lwkt_serialize_enter(ifp->if_serializer);
3914         old_mtu = ifp->if_mtu;
3915         ifp->if_mtu = mtu;
3916         if (ifp->if_flags & IFF_RUNNING) {
3917                 mxge_close(sc);
3918                 err = mxge_open(sc);
3919                 if (err != 0) {
3920                         ifp->if_mtu = old_mtu;
3921                         mxge_close(sc);
3922                         (void) mxge_open(sc);
3923                 }
3924         }
3925         lwkt_serialize_exit(ifp->if_serializer);
3926         return err;
3927 }
3928
3929 static void
3930 mxge_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
3931 {
3932         mxge_softc_t *sc = ifp->if_softc;
3933
3934
3935         if (sc == NULL)
3936                 return;
3937         ifmr->ifm_status = IFM_AVALID;
3938         ifmr->ifm_status |= sc->link_state ? IFM_ACTIVE : 0;
3939         ifmr->ifm_active = IFM_AUTO | IFM_ETHER;
3940         ifmr->ifm_active |= sc->link_state ? IFM_FDX : 0;
3941 }
3942
3943 static int
3944 mxge_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
3945 {
3946         mxge_softc_t *sc = ifp->if_softc;
3947         struct ifreq *ifr = (struct ifreq *)data;
3948         int err, mask;
3949
3950         (void)cr;
3951         err = 0;
3952         ASSERT_SERIALIZED(ifp->if_serializer);
3953         switch (command) {
3954         case SIOCSIFADDR:
3955         case SIOCGIFADDR:
3956                 err = ether_ioctl(ifp, command, data);
3957                 break;
3958
3959         case SIOCSIFMTU:
3960                 err = mxge_change_mtu(sc, ifr->ifr_mtu);
3961                 break;
3962
3963         case SIOCSIFFLAGS:
3964                 if (sc->dying) {
3965                         return EINVAL;
3966                 }
3967                 if (ifp->if_flags & IFF_UP) {
3968                         if (!(ifp->if_flags & IFF_RUNNING)) {
3969                                 err = mxge_open(sc);
3970                         } else {
3971                                 /* take care of promis can allmulti
3972                                    flag chages */
3973                                 mxge_change_promisc(sc,
3974                                                     ifp->if_flags & IFF_PROMISC);
3975                                 mxge_set_multicast_list(sc);
3976                         }
3977                 } else {
3978                         if (ifp->if_flags & IFF_RUNNING) {
3979                                 mxge_close(sc);
3980                         }
3981                 }
3982                 break;
3983
3984         case SIOCADDMULTI:
3985         case SIOCDELMULTI:
3986                 mxge_set_multicast_list(sc);
3987                 break;
3988
3989         case SIOCSIFCAP:
3990                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
3991                 if (mask & IFCAP_TXCSUM) {
3992                         if (IFCAP_TXCSUM & ifp->if_capenable) {
3993                                 ifp->if_capenable &= ~(IFCAP_TXCSUM|IFCAP_TSO4);
3994                                 ifp->if_hwassist &= ~(CSUM_TCP | CSUM_UDP
3995                                                       | CSUM_TSO);
3996                         } else {
3997                                 ifp->if_capenable |= IFCAP_TXCSUM;
3998                                 ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP);
3999                         }
4000                 } else if (mask & IFCAP_RXCSUM) {
4001                         if (IFCAP_RXCSUM & ifp->if_capenable) {
4002                                 ifp->if_capenable &= ~IFCAP_RXCSUM;
4003                                 sc->csum_flag = 0;
4004                         } else {
4005                                 ifp->if_capenable |= IFCAP_RXCSUM;
4006                                 sc->csum_flag = 1;
4007                         }
4008                 }
4009                 if (mask & IFCAP_TSO4) {
4010                         if (IFCAP_TSO4 & ifp->if_capenable) {
4011                                 ifp->if_capenable &= ~IFCAP_TSO4;
4012                                 ifp->if_hwassist &= ~CSUM_TSO;
4013                         } else if (IFCAP_TXCSUM & ifp->if_capenable) {
4014                                 ifp->if_capenable |= IFCAP_TSO4;
4015                                 ifp->if_hwassist |= CSUM_TSO;
4016                         } else {
4017                                 kprintf("mxge requires tx checksum offload"
4018                                        " be enabled to use TSO\n");
4019                                 err = EINVAL;
4020                         }
4021                 }
4022                 if (mask & IFCAP_LRO) {
4023                         if (IFCAP_LRO & ifp->if_capenable)
4024                                 err = mxge_change_lro_locked(sc, 0);
4025                         else
4026                                 err = mxge_change_lro_locked(sc, mxge_lro_cnt);
4027                 }
4028                 if (mask & IFCAP_VLAN_HWTAGGING)
4029                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
4030                 VLAN_CAPABILITIES(ifp);
4031
4032                 break;
4033
4034         case SIOCGIFMEDIA:
4035                 err = ifmedia_ioctl(ifp, (struct ifreq *)data,
4036                                     &sc->media, command);
4037                 break;
4038
4039         default:
4040                 err = ENOTTY;
4041         }
4042         return err;
4043 }
4044
4045 static void
4046 mxge_fetch_tunables(mxge_softc_t *sc)
4047 {
4048
4049         TUNABLE_INT_FETCH("hw.mxge.max_slices", &mxge_max_slices);
4050         TUNABLE_INT_FETCH("hw.mxge.flow_control_enabled",
4051                           &mxge_flow_control);
4052         TUNABLE_INT_FETCH("hw.mxge.intr_coal_delay",
4053                           &mxge_intr_coal_delay);
4054         TUNABLE_INT_FETCH("hw.mxge.nvidia_ecrc_enable",
4055                           &mxge_nvidia_ecrc_enable);
4056         TUNABLE_INT_FETCH("hw.mxge.force_firmware",
4057                           &mxge_force_firmware);
4058         TUNABLE_INT_FETCH("hw.mxge.deassert_wait",
4059                           &mxge_deassert_wait);
4060         TUNABLE_INT_FETCH("hw.mxge.verbose",
4061                           &mxge_verbose);
4062         TUNABLE_INT_FETCH("hw.mxge.ticks", &mxge_ticks);
4063         TUNABLE_INT_FETCH("hw.mxge.lro_cnt", &sc->lro_cnt);
4064         TUNABLE_INT_FETCH("hw.mxge.always_promisc", &mxge_always_promisc);
4065         TUNABLE_INT_FETCH("hw.mxge.rss_hash_type", &mxge_rss_hash_type);
4066         TUNABLE_INT_FETCH("hw.mxge.initial_mtu", &mxge_initial_mtu);
4067         if (sc->lro_cnt != 0)
4068                 mxge_lro_cnt = sc->lro_cnt;
4069
4070         if (bootverbose)
4071                 mxge_verbose = 1;
4072         if (mxge_intr_coal_delay < 0 || mxge_intr_coal_delay > 10*1000)
4073                 mxge_intr_coal_delay = 30;
4074         if (mxge_ticks == 0)
4075                 mxge_ticks = hz / 2;
4076         sc->pause = mxge_flow_control;
4077         if (mxge_rss_hash_type < MXGEFW_RSS_HASH_TYPE_IPV4
4078             || mxge_rss_hash_type > MXGEFW_RSS_HASH_TYPE_MAX) {
4079                 mxge_rss_hash_type = MXGEFW_RSS_HASH_TYPE_SRC_PORT;
4080         }
4081         if (mxge_initial_mtu > ETHERMTU_JUMBO ||
4082             mxge_initial_mtu < ETHER_MIN_LEN)
4083                 mxge_initial_mtu = ETHERMTU_JUMBO;
4084 }
4085
4086
4087 static void
4088 mxge_free_slices(mxge_softc_t *sc)
4089 {
4090         struct mxge_slice_state *ss;
4091         int i;
4092
4093
4094         if (sc->ss == NULL)
4095                 return;
4096
4097         for (i = 0; i < sc->num_slices; i++) {
4098                 ss = &sc->ss[i];
4099                 if (ss->fw_stats != NULL) {
4100                         mxge_dma_free(&ss->fw_stats_dma);
4101                         ss->fw_stats = NULL;
4102 #ifdef IFNET_BUF_RING
4103                         if (ss->tx.br != NULL) {
4104                                 drbr_free(ss->tx.br, M_DEVBUF);
4105                                 ss->tx.br = NULL;
4106                         }
4107 #endif
4108                 }
4109                 if (ss->rx_done.entry != NULL) {
4110                         mxge_dma_free(&ss->rx_done.dma);
4111                         ss->rx_done.entry = NULL;
4112                 }
4113         }
4114         kfree(sc->ss, M_DEVBUF);
4115         sc->ss = NULL;
4116 }
4117
4118 static int
4119 mxge_alloc_slices(mxge_softc_t *sc)
4120 {
4121         mxge_cmd_t cmd;
4122         struct mxge_slice_state *ss;
4123         size_t bytes;
4124         int err, i, max_intr_slots;
4125
4126         err = mxge_send_cmd(sc, MXGEFW_CMD_GET_RX_RING_SIZE, &cmd);
4127         if (err != 0) {
4128                 device_printf(sc->dev, "Cannot determine rx ring size\n");
4129                 return err;
4130         }
4131         sc->rx_ring_size = cmd.data0;
4132         max_intr_slots = 2 * (sc->rx_ring_size / sizeof (mcp_dma_addr_t));
4133
4134         bytes = sizeof (*sc->ss) * sc->num_slices;
4135         sc->ss = kmalloc(bytes, M_DEVBUF, M_NOWAIT | M_ZERO);
4136         if (sc->ss == NULL)
4137                 return (ENOMEM);
4138         for (i = 0; i < sc->num_slices; i++) {
4139                 ss = &sc->ss[i];
4140
4141                 ss->sc = sc;
4142
4143                 /* allocate per-slice rx interrupt queues */
4144
4145                 bytes = max_intr_slots * sizeof (*ss->rx_done.entry);
4146                 err = mxge_dma_alloc(sc, &ss->rx_done.dma, bytes, 4096);
4147                 if (err != 0)
4148                         goto abort;
4149                 ss->rx_done.entry = ss->rx_done.dma.addr;
4150                 bzero(ss->rx_done.entry, bytes);
4151
4152                 /*
4153                  * allocate the per-slice firmware stats; stats
4154                  * (including tx) are used used only on the first
4155                  * slice for now
4156                  */
4157 #ifndef IFNET_BUF_RING
4158                 if (i > 0)
4159                         continue;
4160 #endif
4161
4162                 bytes = sizeof (*ss->fw_stats);
4163                 err = mxge_dma_alloc(sc, &ss->fw_stats_dma,
4164                                      sizeof (*ss->fw_stats), 64);
4165                 if (err != 0)
4166                         goto abort;
4167                 ss->fw_stats = (mcp_irq_data_t *)ss->fw_stats_dma.addr;
4168 #ifdef IFNET_BUF_RING
4169                 ss->tx.br = buf_ring_alloc(2048, M_DEVBUF, M_WAITOK,
4170                                            &ss->tx.lock);
4171 #endif
4172         }
4173
4174         return (0);
4175
4176 abort:
4177         mxge_free_slices(sc);
4178         return (ENOMEM);
4179 }
4180
4181 static void
4182 mxge_slice_probe(mxge_softc_t *sc)
4183 {
4184         mxge_cmd_t cmd;
4185         char *old_fw;
4186         int msix_cnt, status, max_intr_slots;
4187
4188         sc->num_slices = 1;
4189         /*
4190          *  don't enable multiple slices if they are not enabled,
4191          *  or if this is not an SMP system
4192          */
4193
4194         if (mxge_max_slices == 0 || mxge_max_slices == 1 || ncpus < 2)
4195                 return;
4196
4197         /* see how many MSI-X interrupts are available */
4198         msix_cnt = pci_msix_count(sc->dev);
4199         if (msix_cnt < 2)
4200                 return;
4201
4202         /* now load the slice aware firmware see what it supports */
4203         old_fw = sc->fw_name;
4204         if (old_fw == mxge_fw_aligned)
4205                 sc->fw_name = mxge_fw_rss_aligned;
4206         else
4207                 sc->fw_name = mxge_fw_rss_unaligned;
4208         status = mxge_load_firmware(sc, 0);
4209         if (status != 0) {
4210                 device_printf(sc->dev, "Falling back to a single slice\n");
4211                 return;
4212         }
4213
4214         /* try to send a reset command to the card to see if it
4215            is alive */
4216         memset(&cmd, 0, sizeof (cmd));
4217         status = mxge_send_cmd(sc, MXGEFW_CMD_RESET, &cmd);
4218         if (status != 0) {
4219                 device_printf(sc->dev, "failed reset\n");
4220                 goto abort_with_fw;
4221         }
4222
4223         /* get rx ring size */
4224         status = mxge_send_cmd(sc, MXGEFW_CMD_GET_RX_RING_SIZE, &cmd);
4225         if (status != 0) {
4226                 device_printf(sc->dev, "Cannot determine rx ring size\n");
4227                 goto abort_with_fw;
4228         }
4229         max_intr_slots = 2 * (cmd.data0 / sizeof (mcp_dma_addr_t));
4230
4231         /* tell it the size of the interrupt queues */
4232         cmd.data0 = max_intr_slots * sizeof (struct mcp_slot);
4233         status = mxge_send_cmd(sc, MXGEFW_CMD_SET_INTRQ_SIZE, &cmd);
4234         if (status != 0) {
4235                 device_printf(sc->dev, "failed MXGEFW_CMD_SET_INTRQ_SIZE\n");
4236                 goto abort_with_fw;
4237         }
4238
4239         /* ask the maximum number of slices it supports */
4240         status = mxge_send_cmd(sc, MXGEFW_CMD_GET_MAX_RSS_QUEUES, &cmd);
4241         if (status != 0) {
4242                 device_printf(sc->dev,
4243                               "failed MXGEFW_CMD_GET_MAX_RSS_QUEUES\n");
4244                 goto abort_with_fw;
4245         }
4246         sc->num_slices = cmd.data0;
4247         if (sc->num_slices > msix_cnt)
4248                 sc->num_slices = msix_cnt;
4249
4250         if (mxge_max_slices == -1) {
4251                 /* cap to number of CPUs in system */
4252                 if (sc->num_slices > ncpus)
4253                         sc->num_slices = ncpus;
4254         } else {
4255                 if (sc->num_slices > mxge_max_slices)
4256                         sc->num_slices = mxge_max_slices;
4257         }
4258         /* make sure it is a power of two */
4259         while (sc->num_slices & (sc->num_slices - 1))
4260                 sc->num_slices--;
4261
4262         if (mxge_verbose)
4263                 device_printf(sc->dev, "using %d slices\n",
4264                               sc->num_slices);
4265
4266         return;
4267
4268 abort_with_fw:
4269         sc->fw_name = old_fw;
4270         (void) mxge_load_firmware(sc, 0);
4271 }
4272
4273 static int
4274 mxge_add_msix_irqs(mxge_softc_t *sc)
4275 {
4276         size_t bytes;
4277         int count, err, i, rid;
4278
4279         rid = PCIR_BAR(2);
4280         sc->msix_table_res = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
4281                                                     &rid, RF_ACTIVE);
4282
4283         if (sc->msix_table_res == NULL) {
4284                 device_printf(sc->dev, "couldn't alloc MSIX table res\n");
4285                 return ENXIO;
4286         }
4287
4288         count = sc->num_slices;
4289         err = pci_alloc_msix(sc->dev, &count);
4290         if (err != 0) {
4291                 device_printf(sc->dev, "pci_alloc_msix: failed, wanted %d"
4292                               "err = %d \n", sc->num_slices, err);
4293                 goto abort_with_msix_table;
4294         }
4295         if (count < sc->num_slices) {
4296                 device_printf(sc->dev, "pci_alloc_msix: need %d, got %d\n",
4297                               count, sc->num_slices);
4298                 device_printf(sc->dev,
4299                               "Try setting hw.mxge.max_slices to %d\n",
4300                               count);
4301                 err = ENOSPC;
4302                 goto abort_with_msix;
4303         }
4304         bytes = sizeof (*sc->msix_irq_res) * sc->num_slices;
4305         sc->msix_irq_res = kmalloc(bytes, M_DEVBUF, M_NOWAIT|M_ZERO);
4306         if (sc->msix_irq_res == NULL) {
4307                 err = ENOMEM;
4308                 goto abort_with_msix;
4309         }
4310
4311         for (i = 0; i < sc->num_slices; i++) {
4312                 rid = i + 1;
4313                 sc->msix_irq_res[i] = bus_alloc_resource_any(sc->dev,
4314                                                           SYS_RES_IRQ,
4315                                                           &rid, RF_ACTIVE);
4316                 if (sc->msix_irq_res[i] == NULL) {
4317                         device_printf(sc->dev, "couldn't allocate IRQ res"
4318                                       " for message %d\n", i);
4319                         err = ENXIO;
4320                         goto abort_with_res;
4321                 }
4322         }
4323
4324         bytes = sizeof (*sc->msix_ih) * sc->num_slices;
4325         sc->msix_ih =  kmalloc(bytes, M_DEVBUF, M_NOWAIT|M_ZERO);
4326
4327         for (i = 0; i < sc->num_slices; i++) {
4328                 err = bus_setup_intr(sc->dev, sc->msix_irq_res[i],
4329                                      INTR_MPSAFE,
4330                                      mxge_intr, &sc->ss[i], &sc->msix_ih[i],
4331                                      sc->ifp->if_serializer);
4332                 if (err != 0) {
4333                         device_printf(sc->dev, "couldn't setup intr for "
4334                                       "message %d\n", i);
4335                         goto abort_with_intr;
4336                 }
4337         }
4338
4339         if (mxge_verbose) {
4340                 device_printf(sc->dev, "using %d msix IRQs:",
4341                               sc->num_slices);
4342                 for (i = 0; i < sc->num_slices; i++)
4343                         kprintf(" %ld",  rman_get_start(sc->msix_irq_res[i]));
4344                 kprintf("\n");
4345         }
4346         return (0);
4347
4348 abort_with_intr:
4349         for (i = 0; i < sc->num_slices; i++) {
4350                 if (sc->msix_ih[i] != NULL) {
4351                         bus_teardown_intr(sc->dev, sc->msix_irq_res[i],
4352                                           sc->msix_ih[i]);
4353                         sc->msix_ih[i] = NULL;
4354                 }
4355         }
4356         kfree(sc->msix_ih, M_DEVBUF);
4357
4358
4359 abort_with_res:
4360         for (i = 0; i < sc->num_slices; i++) {
4361                 rid = i + 1;
4362                 if (sc->msix_irq_res[i] != NULL)
4363                         bus_release_resource(sc->dev, SYS_RES_IRQ, rid,
4364                                              sc->msix_irq_res[i]);
4365                 sc->msix_irq_res[i] = NULL;
4366         }
4367         kfree(sc->msix_irq_res, M_DEVBUF);
4368
4369
4370 abort_with_msix:
4371         pci_release_msi(sc->dev);
4372
4373 abort_with_msix_table:
4374         bus_release_resource(sc->dev, SYS_RES_MEMORY, PCIR_BAR(2),
4375                              sc->msix_table_res);
4376
4377         return err;
4378 }
4379
4380 static int
4381 mxge_add_single_irq(mxge_softc_t *sc)
4382 {
4383         int count, err, rid;
4384
4385         count = pci_msi_count(sc->dev);
4386         if (count == 1 && pci_alloc_msi(sc->dev, &count) == 0) {
4387                 rid = 1;
4388         } else {
4389                 rid = 0;
4390                 sc->legacy_irq = 1;
4391         }
4392         sc->irq_res = bus_alloc_resource(sc->dev, SYS_RES_IRQ, &rid, 0, ~0,
4393                                          1, RF_SHAREABLE | RF_ACTIVE);
4394         if (sc->irq_res == NULL) {
4395                 device_printf(sc->dev, "could not alloc interrupt\n");
4396                 return ENXIO;
4397         }
4398         if (mxge_verbose)
4399                 device_printf(sc->dev, "using %s irq %ld\n",
4400                               sc->legacy_irq ? "INTx" : "MSI",
4401                               rman_get_start(sc->irq_res));
4402         err = bus_setup_intr(sc->dev, sc->irq_res,
4403                              INTR_MPSAFE,
4404                              mxge_intr, &sc->ss[0], &sc->ih,
4405                              sc->ifp->if_serializer);
4406         if (err != 0) {
4407                 bus_release_resource(sc->dev, SYS_RES_IRQ,
4408                                      sc->legacy_irq ? 0 : 1, sc->irq_res);
4409                 if (!sc->legacy_irq)
4410                         pci_release_msi(sc->dev);
4411         }
4412         return err;
4413 }
4414
4415 static void
4416 mxge_rem_msix_irqs(mxge_softc_t *sc)
4417 {
4418         int i, rid;
4419
4420         for (i = 0; i < sc->num_slices; i++) {
4421                 if (sc->msix_ih[i] != NULL) {
4422                         bus_teardown_intr(sc->dev, sc->msix_irq_res[i],
4423                                           sc->msix_ih[i]);
4424                         sc->msix_ih[i] = NULL;
4425                 }
4426         }
4427         kfree(sc->msix_ih, M_DEVBUF);
4428
4429         for (i = 0; i < sc->num_slices; i++) {
4430                 rid = i + 1;
4431                 if (sc->msix_irq_res[i] != NULL)
4432                         bus_release_resource(sc->dev, SYS_RES_IRQ, rid,
4433                                              sc->msix_irq_res[i]);
4434                 sc->msix_irq_res[i] = NULL;
4435         }
4436         kfree(sc->msix_irq_res, M_DEVBUF);
4437
4438         bus_release_resource(sc->dev, SYS_RES_MEMORY, PCIR_BAR(2),
4439                              sc->msix_table_res);
4440
4441         pci_release_msi(sc->dev);
4442         return;
4443 }
4444
4445 static void
4446 mxge_rem_single_irq(mxge_softc_t *sc)
4447 {
4448         bus_teardown_intr(sc->dev, sc->irq_res, sc->ih);
4449         bus_release_resource(sc->dev, SYS_RES_IRQ,
4450                              sc->legacy_irq ? 0 : 1, sc->irq_res);
4451         if (!sc->legacy_irq)
4452                 pci_release_msi(sc->dev);
4453 }
4454
4455 static void
4456 mxge_rem_irq(mxge_softc_t *sc)
4457 {
4458         if (sc->num_slices > 1)
4459                 mxge_rem_msix_irqs(sc);
4460         else
4461                 mxge_rem_single_irq(sc);
4462 }
4463
4464 static int
4465 mxge_add_irq(mxge_softc_t *sc)
4466 {
4467         int err;
4468
4469         if (sc->num_slices > 1)
4470                 err = mxge_add_msix_irqs(sc);
4471         else
4472                 err = mxge_add_single_irq(sc);
4473
4474         if (0 && err == 0 && sc->num_slices > 1) {
4475                 mxge_rem_msix_irqs(sc);
4476                 err = mxge_add_msix_irqs(sc);
4477         }
4478         return err;
4479 }
4480
4481
4482 static int
4483 mxge_attach(device_t dev)
4484 {
4485         mxge_softc_t *sc = device_get_softc(dev);
4486         struct ifnet *ifp = &sc->arpcom.ac_if;
4487         int err, rid;
4488
4489         /*
4490          * avoid rewriting half the lines in this file to use
4491          * &sc->arpcom.ac_if instead
4492          */
4493         sc->ifp = ifp;
4494         sc->dev = dev;
4495         mxge_fetch_tunables(sc);
4496
4497         err = bus_dma_tag_create(NULL,                  /* parent */
4498                                  1,                     /* alignment */
4499                                  0,                     /* boundary */
4500                                  BUS_SPACE_MAXADDR,     /* low */
4501                                  BUS_SPACE_MAXADDR,     /* high */
4502                                  NULL, NULL,            /* filter */
4503                                  65536 + 256,           /* maxsize */
4504                                  MXGE_MAX_SEND_DESC,    /* num segs */
4505                                  65536,                 /* maxsegsize */
4506                                  0,                     /* flags */
4507                                  &sc->parent_dmat);     /* tag */
4508
4509         if (err != 0) {
4510                 device_printf(sc->dev, "Err %d allocating parent dmat\n",
4511                               err);
4512                 goto abort_with_nothing;
4513         }
4514
4515         sc->ifp = ifp;
4516         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
4517
4518         callout_init_mp(&sc->co_hdl);
4519
4520         mxge_setup_cfg_space(sc);
4521
4522         /* Map the board into the kernel */
4523         rid = PCIR_BARS;
4524         sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0,
4525                                          ~0, 1, RF_ACTIVE);
4526         if (sc->mem_res == NULL) {
4527                 device_printf(dev, "could not map memory\n");
4528                 err = ENXIO;
4529                 goto abort_with_nothing;
4530         }
4531         sc->sram = rman_get_virtual(sc->mem_res);
4532         sc->sram_size = 2*1024*1024 - (2*(48*1024)+(32*1024)) - 0x100;
4533         if (sc->sram_size > rman_get_size(sc->mem_res)) {
4534                 device_printf(dev, "impossible memory region size %ld\n",
4535                               rman_get_size(sc->mem_res));
4536                 err = ENXIO;
4537                 goto abort_with_mem_res;
4538         }
4539
4540         /* make NULL terminated copy of the EEPROM strings section of
4541            lanai SRAM */
4542         bzero(sc->eeprom_strings, MXGE_EEPROM_STRINGS_SIZE);
4543         bus_space_read_region_1(rman_get_bustag(sc->mem_res),
4544                                 rman_get_bushandle(sc->mem_res),
4545                                 sc->sram_size - MXGE_EEPROM_STRINGS_SIZE,
4546                                 sc->eeprom_strings,
4547                                 MXGE_EEPROM_STRINGS_SIZE - 2);
4548         err = mxge_parse_strings(sc);
4549         if (err != 0)
4550                 goto abort_with_mem_res;
4551
4552         /* Enable write combining for efficient use of PCIe bus */
4553         mxge_enable_wc(sc);
4554
4555         /* Allocate the out of band dma memory */
4556         err = mxge_dma_alloc(sc, &sc->cmd_dma,
4557                              sizeof (mxge_cmd_t), 64);
4558         if (err != 0)
4559                 goto abort_with_mem_res;
4560         sc->cmd = (mcp_cmd_response_t *) sc->cmd_dma.addr;
4561         err = mxge_dma_alloc(sc, &sc->zeropad_dma, 64, 64);
4562         if (err != 0)
4563                 goto abort_with_cmd_dma;
4564
4565         err = mxge_dma_alloc(sc, &sc->dmabench_dma, 4096, 4096);
4566         if (err != 0)
4567                 goto abort_with_zeropad_dma;
4568
4569         /* select & load the firmware */
4570         err = mxge_select_firmware(sc);
4571         if (err != 0)
4572                 goto abort_with_dmabench;
4573         sc->intr_coal_delay = mxge_intr_coal_delay;
4574
4575         mxge_slice_probe(sc);
4576         err = mxge_alloc_slices(sc);
4577         if (err != 0)
4578                 goto abort_with_dmabench;
4579
4580         err = mxge_reset(sc, 0);
4581         if (err != 0)
4582                 goto abort_with_slices;
4583
4584         err = mxge_alloc_rings(sc);
4585         if (err != 0) {
4586                 device_printf(sc->dev, "failed to allocate rings\n");
4587                 goto abort_with_dmabench;
4588         }
4589
4590         err = mxge_add_irq(sc);
4591         if (err != 0) {
4592                 device_printf(sc->dev, "failed to add irq\n");
4593                 goto abort_with_rings;
4594         }
4595
4596         ifp->if_baudrate = IF_Gbps(10UL);
4597         ifp->if_capabilities = IFCAP_RXCSUM | IFCAP_TXCSUM | IFCAP_TSO4 |
4598                 IFCAP_VLAN_MTU;
4599 #ifdef INET
4600         ifp->if_capabilities |= IFCAP_LRO;
4601 #endif
4602
4603 #ifdef MXGE_NEW_VLAN_API
4604         ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM;
4605 #endif
4606
4607         sc->max_mtu = mxge_max_mtu(sc);
4608         if (sc->max_mtu >= 9000)
4609                 ifp->if_capabilities |= IFCAP_JUMBO_MTU;
4610         else
4611                 device_printf(dev, "MTU limited to %d.  Install "
4612                               "latest firmware for 9000 byte jumbo support\n",
4613                               sc->max_mtu - ETHER_HDR_LEN);
4614         ifp->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_TSO;
4615         ifp->if_capenable = ifp->if_capabilities;
4616         if (sc->lro_cnt == 0)
4617                 ifp->if_capenable &= ~IFCAP_LRO;
4618         sc->csum_flag = 1;
4619         ifp->if_init = mxge_init;
4620         ifp->if_softc = sc;
4621         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
4622         ifp->if_ioctl = mxge_ioctl;
4623         ifp->if_start = mxge_start;
4624         /* Initialise the ifmedia structure */
4625         ifmedia_init(&sc->media, 0, mxge_media_change,
4626                      mxge_media_status);
4627         mxge_set_media(sc, IFM_ETHER | IFM_AUTO);
4628         mxge_media_probe(sc);
4629         sc->dying = 0;
4630         ether_ifattach(ifp, sc->mac_addr, NULL);
4631         /* ether_ifattach sets mtu to ETHERMTU */
4632         if (mxge_initial_mtu != ETHERMTU)
4633                 mxge_change_mtu(sc, mxge_initial_mtu);
4634
4635         mxge_add_sysctls(sc);
4636 #ifdef IFNET_BUF_RING
4637         ifp->if_transmit = mxge_transmit;
4638         ifp->if_qflush = mxge_qflush;
4639 #endif
4640         return 0;
4641
4642 abort_with_rings:
4643         mxge_free_rings(sc);
4644 abort_with_slices:
4645         mxge_free_slices(sc);
4646 abort_with_dmabench:
4647         mxge_dma_free(&sc->dmabench_dma);
4648 abort_with_zeropad_dma:
4649         mxge_dma_free(&sc->zeropad_dma);
4650 abort_with_cmd_dma:
4651         mxge_dma_free(&sc->cmd_dma);
4652 abort_with_mem_res:
4653         bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BARS, sc->mem_res);
4654         pci_disable_busmaster(dev);
4655         bus_dma_tag_destroy(sc->parent_dmat);
4656 abort_with_nothing:
4657         return err;
4658 }
4659
4660 static int
4661 mxge_detach(device_t dev)
4662 {
4663         mxge_softc_t *sc = device_get_softc(dev);
4664
4665         lwkt_serialize_enter(sc->ifp->if_serializer);
4666         sc->dying = 1;
4667         if (sc->ifp->if_flags & IFF_RUNNING)
4668                 mxge_close(sc);
4669         /*
4670          * XXX: race: the callout callback could be spinning on
4671          * the serializer and run anyway
4672          */
4673         callout_stop(&sc->co_hdl);
4674         lwkt_serialize_exit(sc->ifp->if_serializer);
4675
4676         ether_ifdetach(sc->ifp);
4677         ifmedia_removeall(&sc->media);
4678         mxge_dummy_rdma(sc, 0);
4679         mxge_rem_sysctls(sc);
4680         mxge_rem_irq(sc);
4681         mxge_free_rings(sc);
4682         mxge_free_slices(sc);
4683         mxge_dma_free(&sc->dmabench_dma);
4684         mxge_dma_free(&sc->zeropad_dma);
4685         mxge_dma_free(&sc->cmd_dma);
4686         bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BARS, sc->mem_res);
4687         pci_disable_busmaster(dev);
4688         bus_dma_tag_destroy(sc->parent_dmat);
4689         return 0;
4690 }
4691
4692 static int
4693 mxge_shutdown(device_t dev)
4694 {
4695         return 0;
4696 }
4697
4698 /*
4699   This file uses Myri10GE driver indentation.
4700
4701   Local Variables:
4702   c-file-style:"linux"
4703   tab-width:8
4704   End:
4705 */