5395c033af590d32994a464e8d4e2f3f474f5a4e
[dragonfly.git] / 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         /*
858          * We may be called during attach, before if_serializer is available.
859          * This is not a fast path, just check for NULL
860          */
861
862         if (sc->ifp->if_serializer)
863                 ASSERT_SERIALIZED(sc->ifp->if_serializer);
864
865         /* ensure buf is aligned to 8 bytes */
866         buf = (mcp_cmd_t *)((unsigned long)(buf_bytes + 7) & ~7UL);
867
868         buf->data0 = htobe32(data->data0);
869         buf->data1 = htobe32(data->data1);
870         buf->data2 = htobe32(data->data2);
871         buf->cmd = htobe32(cmd);
872         dma_low = MXGE_LOWPART_TO_U32(sc->cmd_dma.bus_addr);
873         dma_high = MXGE_HIGHPART_TO_U32(sc->cmd_dma.bus_addr);
874
875         buf->response_addr.low = htobe32(dma_low);
876         buf->response_addr.high = htobe32(dma_high);
877
878
879         response->result = 0xffffffff;
880         wmb();
881         mxge_pio_copy((volatile void *)cmd_addr, buf, sizeof (*buf));
882
883         /* wait up to 20ms */
884         err = EAGAIN;
885         for (sleep_total = 0; sleep_total <  20; sleep_total++) {
886                 bus_dmamap_sync(sc->cmd_dma.dmat, 
887                                 sc->cmd_dma.map, BUS_DMASYNC_POSTREAD);
888                 wmb();
889                 switch (be32toh(response->result)) {
890                 case 0:
891                         data->data0 = be32toh(response->data);
892                         err = 0;
893                         break;
894                 case 0xffffffff:
895                         DELAY(1000);
896                         break;
897                 case MXGEFW_CMD_UNKNOWN:
898                         err = ENOSYS;
899                         break;
900                 case MXGEFW_CMD_ERROR_UNALIGNED:
901                         err = E2BIG;
902                         break;
903                 case MXGEFW_CMD_ERROR_BUSY:
904                         err = EBUSY;
905                         break;
906                 default:
907                         device_printf(sc->dev, 
908                                       "mxge: command %d "
909                                       "failed, result = %d\n",
910                                       cmd, be32toh(response->result));
911                         err = ENXIO;
912                         break;
913                 }
914                 if (err != EAGAIN)
915                         break;
916         }
917         if (err == EAGAIN)
918                 device_printf(sc->dev, "mxge: command %d timed out"
919                               "result = %d\n",
920                               cmd, be32toh(response->result));
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( sc->ifp->if_serializer)
1104                 ASSERT_SERIALIZED(sc->ifp->if_serializer);
1105         if (mxge_always_promisc)
1106                 promisc = 1;
1107
1108         if (promisc)
1109                 status = mxge_send_cmd(sc, MXGEFW_ENABLE_PROMISC,
1110                                        &cmd);
1111         else
1112                 status = mxge_send_cmd(sc, MXGEFW_DISABLE_PROMISC,
1113                                        &cmd);
1114
1115         if (status) {
1116                 device_printf(sc->dev, "Failed to set promisc mode\n");
1117         }
1118 }
1119
1120 static void
1121 mxge_set_multicast_list(mxge_softc_t *sc)
1122 {
1123         mxge_cmd_t cmd;
1124         struct ifmultiaddr *ifma;
1125         struct ifnet *ifp = sc->ifp;
1126         int err;
1127
1128         if (ifp->if_serializer)
1129                 ASSERT_SERIALIZED(ifp->if_serializer);
1130
1131         /* This firmware is known to not support multicast */
1132         if (!sc->fw_multicast_support)
1133                 return;
1134
1135         /* Disable multicast filtering while we play with the lists*/
1136         err = mxge_send_cmd(sc, MXGEFW_ENABLE_ALLMULTI, &cmd);
1137         if (err != 0) {
1138                 device_printf(sc->dev, "Failed MXGEFW_ENABLE_ALLMULTI,"
1139                        " error status: %d\n", err);
1140                 return;
1141         }
1142         
1143         if (sc->adopted_rx_filter_bug)
1144                 return;
1145         
1146         if (ifp->if_flags & IFF_ALLMULTI)
1147                 /* request to disable multicast filtering, so quit here */
1148                 return;
1149
1150         /* Flush all the filters */
1151
1152         err = mxge_send_cmd(sc, MXGEFW_LEAVE_ALL_MULTICAST_GROUPS, &cmd);
1153         if (err != 0) {
1154                 device_printf(sc->dev, 
1155                               "Failed MXGEFW_LEAVE_ALL_MULTICAST_GROUPS"
1156                               ", error status: %d\n", err);
1157                 return;
1158         }
1159
1160         /* Walk the multicast list, and add each address */
1161
1162         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1163                 if (ifma->ifma_addr->sa_family != AF_LINK)
1164                         continue;
1165                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1166                       &cmd.data0, 4);
1167                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr) + 4,
1168                       &cmd.data1, 2);
1169                 cmd.data0 = htonl(cmd.data0);
1170                 cmd.data1 = htonl(cmd.data1);
1171                 err = mxge_send_cmd(sc, MXGEFW_JOIN_MULTICAST_GROUP, &cmd);
1172                 if (err != 0) {
1173                         device_printf(sc->dev, "Failed "
1174                                "MXGEFW_JOIN_MULTICAST_GROUP, error status:"
1175                                "%d\t", err);
1176                         /* abort, leaving multicast filtering off */
1177                         return;
1178                 }
1179         }
1180         /* Enable multicast filtering */
1181         err = mxge_send_cmd(sc, MXGEFW_DISABLE_ALLMULTI, &cmd);
1182         if (err != 0) {
1183                 device_printf(sc->dev, "Failed MXGEFW_DISABLE_ALLMULTI"
1184                        ", error status: %d\n", err);
1185         }
1186 }
1187
1188 static int
1189 mxge_max_mtu(mxge_softc_t *sc)
1190 {
1191         mxge_cmd_t cmd;
1192         int status;
1193
1194         if (MJUMPAGESIZE - MXGEFW_PAD >  MXGEFW_MAX_MTU)
1195                 return  MXGEFW_MAX_MTU - MXGEFW_PAD;
1196
1197         /* try to set nbufs to see if it we can
1198            use virtually contiguous jumbos */
1199         cmd.data0 = 0;
1200         status = mxge_send_cmd(sc, MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS,
1201                                &cmd);
1202         if (status == 0)
1203                 return  MXGEFW_MAX_MTU - MXGEFW_PAD;
1204
1205         /* otherwise, we're limited to MJUMPAGESIZE */
1206         return MJUMPAGESIZE - MXGEFW_PAD;
1207 }
1208
1209 static int
1210 mxge_reset(mxge_softc_t *sc, int interrupts_setup)
1211 {
1212         struct mxge_slice_state *ss;
1213         mxge_rx_done_t *rx_done;
1214         volatile uint32_t *irq_claim;
1215         mxge_cmd_t cmd;
1216         int slice, status;
1217
1218         /* try to send a reset command to the card to see if it
1219            is alive */
1220         memset(&cmd, 0, sizeof (cmd));
1221         status = mxge_send_cmd(sc, MXGEFW_CMD_RESET, &cmd);
1222         if (status != 0) {
1223                 device_printf(sc->dev, "failed reset\n");
1224                 return ENXIO;
1225         }
1226
1227         mxge_dummy_rdma(sc, 1);
1228
1229
1230         /* set the intrq size */
1231         cmd.data0 = sc->rx_ring_size;
1232         status = mxge_send_cmd(sc, MXGEFW_CMD_SET_INTRQ_SIZE, &cmd);
1233
1234         /* 
1235          * Even though we already know how many slices are supported
1236          * via mxge_slice_probe(), MXGEFW_CMD_GET_MAX_RSS_QUEUES
1237          * has magic side effects, and must be called after a reset.
1238          * It must be called prior to calling any RSS related cmds,
1239          * including assigning an interrupt queue for anything but
1240          * slice 0.  It must also be called *after*
1241          * MXGEFW_CMD_SET_INTRQ_SIZE, since the intrq size is used by
1242          * the firmware to compute offsets.
1243          */
1244          
1245         if (sc->num_slices > 1) {
1246                 /* ask the maximum number of slices it supports */
1247                 status = mxge_send_cmd(sc, MXGEFW_CMD_GET_MAX_RSS_QUEUES,
1248                                            &cmd);
1249                 if (status != 0) {
1250                         device_printf(sc->dev, 
1251                                       "failed to get number of slices\n");
1252                         return status;
1253                 }
1254                 /* 
1255                  * MXGEFW_CMD_ENABLE_RSS_QUEUES must be called prior
1256                  * to setting up the interrupt queue DMA
1257                  */
1258                 cmd.data0 = sc->num_slices;
1259                 cmd.data1 = MXGEFW_SLICE_INTR_MODE_ONE_PER_SLICE;
1260 #ifdef IFNET_BUF_RING
1261                 cmd.data1 |= MXGEFW_SLICE_ENABLE_MULTIPLE_TX_QUEUES;
1262 #endif
1263                 status = mxge_send_cmd(sc, MXGEFW_CMD_ENABLE_RSS_QUEUES,
1264                                            &cmd);
1265                 if (status != 0) {
1266                         device_printf(sc->dev,
1267                                       "failed to set number of slices\n");
1268                         return status;
1269                 }
1270         }
1271
1272
1273         if (interrupts_setup) {
1274                 /* Now exchange information about interrupts  */
1275                 for (slice = 0; slice < sc->num_slices; slice++) {
1276                         rx_done = &sc->ss[slice].rx_done;
1277                         memset(rx_done->entry, 0, sc->rx_ring_size);
1278                         cmd.data0 = MXGE_LOWPART_TO_U32(rx_done->dma.bus_addr);
1279                         cmd.data1 = MXGE_HIGHPART_TO_U32(rx_done->dma.bus_addr);
1280                         cmd.data2 = slice;
1281                         status |= mxge_send_cmd(sc,
1282                                                 MXGEFW_CMD_SET_INTRQ_DMA,
1283                                                 &cmd);
1284                 }
1285         }
1286
1287         status |= mxge_send_cmd(sc, 
1288                                 MXGEFW_CMD_GET_INTR_COAL_DELAY_OFFSET, &cmd);
1289         
1290
1291         sc->intr_coal_delay_ptr = (volatile uint32_t *)(sc->sram + cmd.data0);
1292
1293         status |= mxge_send_cmd(sc, MXGEFW_CMD_GET_IRQ_ACK_OFFSET, &cmd);
1294         irq_claim = (volatile uint32_t *)(sc->sram + cmd.data0);
1295
1296
1297         status |= mxge_send_cmd(sc,  MXGEFW_CMD_GET_IRQ_DEASSERT_OFFSET, 
1298                                 &cmd);
1299         sc->irq_deassert = (volatile uint32_t *)(sc->sram + cmd.data0);
1300         if (status != 0) {
1301                 device_printf(sc->dev, "failed set interrupt parameters\n");
1302                 return status;
1303         }
1304         
1305
1306         *sc->intr_coal_delay_ptr = htobe32(sc->intr_coal_delay);
1307
1308         
1309         /* run a DMA benchmark */
1310         (void) mxge_dma_test(sc, MXGEFW_DMA_TEST);
1311
1312         for (slice = 0; slice < sc->num_slices; slice++) {
1313                 ss = &sc->ss[slice];
1314
1315                 ss->irq_claim = irq_claim + (2 * slice);
1316                 /* reset mcp/driver shared state back to 0 */
1317                 ss->rx_done.idx = 0;
1318                 ss->rx_done.cnt = 0;
1319                 ss->tx.req = 0;
1320                 ss->tx.done = 0;
1321                 ss->tx.pkt_done = 0;
1322                 ss->tx.queue_active = 0;
1323                 ss->tx.activate = 0;
1324                 ss->tx.deactivate = 0;
1325                 ss->tx.wake = 0;
1326                 ss->tx.defrag = 0;
1327                 ss->tx.stall = 0;
1328                 ss->rx_big.cnt = 0;
1329                 ss->rx_small.cnt = 0;
1330                 ss->lro_bad_csum = 0;
1331                 ss->lro_queued = 0;
1332                 ss->lro_flushed = 0;
1333                 if (ss->fw_stats != NULL) {
1334                         ss->fw_stats->valid = 0;
1335                         ss->fw_stats->send_done_count = 0;
1336                 }
1337         }
1338         sc->rdma_tags_available = 15;
1339         status = mxge_update_mac_address(sc);
1340         mxge_change_promisc(sc, sc->ifp->if_flags & IFF_PROMISC);
1341         mxge_change_pause(sc, sc->pause);
1342         mxge_set_multicast_list(sc);
1343         return status;
1344 }
1345
1346 static int
1347 mxge_change_intr_coal(SYSCTL_HANDLER_ARGS)
1348 {
1349         mxge_softc_t *sc;
1350         unsigned int intr_coal_delay;
1351         int err;
1352
1353         sc = arg1;
1354         intr_coal_delay = sc->intr_coal_delay;
1355         err = sysctl_handle_int(oidp, &intr_coal_delay, arg2, req);
1356         if (err != 0) {
1357                 return err;
1358         }
1359         if (intr_coal_delay == sc->intr_coal_delay)
1360                 return 0;
1361
1362         if (intr_coal_delay == 0 || intr_coal_delay > 1000*1000)
1363                 return EINVAL;
1364
1365         lwkt_serialize_enter(sc->ifp->if_serializer);
1366         *sc->intr_coal_delay_ptr = htobe32(intr_coal_delay);
1367         sc->intr_coal_delay = intr_coal_delay;
1368
1369         lwkt_serialize_exit(sc->ifp->if_serializer);
1370         return err;
1371 }
1372
1373 static int
1374 mxge_change_flow_control(SYSCTL_HANDLER_ARGS)
1375 {
1376         mxge_softc_t *sc;
1377         unsigned int enabled;
1378         int err;
1379
1380         sc = arg1;
1381         enabled = sc->pause;
1382         err = sysctl_handle_int(oidp, &enabled, arg2, req);
1383         if (err != 0) {
1384                 return err;
1385         }
1386         if (enabled == sc->pause)
1387                 return 0;
1388
1389         lwkt_serialize_enter(sc->ifp->if_serializer);
1390         err = mxge_change_pause(sc, enabled);
1391         lwkt_serialize_exit(sc->ifp->if_serializer);
1392         return err;
1393 }
1394
1395 static int
1396 mxge_change_lro_locked(mxge_softc_t *sc, int lro_cnt)
1397 {
1398         struct ifnet *ifp;
1399         int err = 0;
1400
1401         ifp = sc->ifp;
1402         if (lro_cnt == 0) 
1403                 ifp->if_capenable &= ~IFCAP_LRO;
1404         else
1405                 ifp->if_capenable |= IFCAP_LRO;
1406         sc->lro_cnt = lro_cnt;
1407         if (ifp->if_flags & IFF_RUNNING) {
1408                 mxge_close(sc);
1409                 err = mxge_open(sc);
1410         }
1411         return err;
1412 }
1413
1414 static int
1415 mxge_change_lro(SYSCTL_HANDLER_ARGS)
1416 {
1417         mxge_softc_t *sc;
1418         unsigned int lro_cnt;
1419         int err;
1420
1421         sc = arg1;
1422         lro_cnt = sc->lro_cnt;
1423         err = sysctl_handle_int(oidp, &lro_cnt, arg2, req);
1424         if (err != 0)
1425                 return err;
1426
1427         if (lro_cnt == sc->lro_cnt)
1428                 return 0;
1429
1430         if (lro_cnt > 128)
1431                 return EINVAL;
1432
1433         lwkt_serialize_enter(sc->ifp->if_serializer);
1434         err = mxge_change_lro_locked(sc, lro_cnt);
1435         lwkt_serialize_exit(sc->ifp->if_serializer);
1436         return err;
1437 }
1438
1439 static int
1440 mxge_handle_be32(SYSCTL_HANDLER_ARGS)
1441 {
1442         int err;
1443
1444         if (arg1 == NULL)
1445                 return EFAULT;
1446         arg2 = be32toh(*(int *)arg1);
1447         arg1 = NULL;
1448         err = sysctl_handle_int(oidp, arg1, arg2, req);
1449
1450         return err;
1451 }
1452
1453 static void
1454 mxge_rem_sysctls(mxge_softc_t *sc)
1455 {
1456         struct mxge_slice_state *ss;
1457         int slice;
1458
1459         if (sc->sysctl_tree != NULL) {
1460                 sysctl_ctx_free(&sc->sysctl_ctx);
1461                 sc->sysctl_tree = NULL;
1462         }
1463         if (sc->slice_sysctl_tree == NULL)
1464                 return;
1465
1466         for (slice = 0; slice < sc->num_slices; slice++) {
1467                 ss = &sc->ss[slice];
1468                 if (ss == NULL || ss->sysctl_tree == NULL)
1469                         continue;
1470                 sysctl_ctx_free(&ss->sysctl_ctx);
1471                 ss->sysctl_tree = NULL;
1472         }
1473         sysctl_ctx_free(&sc->slice_sysctl_ctx);
1474         sc->slice_sysctl_tree = NULL;
1475 }
1476
1477 static void
1478 mxge_add_sysctls(mxge_softc_t *sc)
1479 {
1480         struct sysctl_ctx_list *ctx;
1481         struct sysctl_oid_list *children;
1482         mcp_irq_data_t *fw;
1483         struct mxge_slice_state *ss;
1484         int slice;
1485         char slice_num[8];
1486
1487         ctx = &sc->sysctl_ctx;
1488         sysctl_ctx_init(ctx);
1489         sc->sysctl_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_STATIC_CHILDREN(_hw),
1490                                           OID_AUTO,
1491                                           device_get_nameunit(sc->dev),
1492                                           CTLFLAG_RD, 0, "");
1493         if (sc->sysctl_tree == NULL) {
1494                 device_printf(sc->dev, "can't add sysctl node\n");
1495                 return;
1496         }
1497
1498         children = SYSCTL_CHILDREN(sc->sysctl_tree);
1499         fw = sc->ss[0].fw_stats;
1500
1501         /* random information */
1502         SYSCTL_ADD_STRING(ctx, children, OID_AUTO, 
1503                        "firmware_version",
1504                        CTLFLAG_RD, &sc->fw_version,
1505                        0, "firmware version");
1506         SYSCTL_ADD_STRING(ctx, children, OID_AUTO, 
1507                        "serial_number",
1508                        CTLFLAG_RD, &sc->serial_number_string,
1509                        0, "serial number");
1510         SYSCTL_ADD_STRING(ctx, children, OID_AUTO, 
1511                        "product_code",
1512                        CTLFLAG_RD, &sc->product_code_string,
1513                        0, "product_code");
1514         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1515                        "pcie_link_width",
1516                        CTLFLAG_RD, &sc->link_width,
1517                        0, "tx_boundary");
1518         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1519                        "tx_boundary",
1520                        CTLFLAG_RD, &sc->tx_boundary,
1521                        0, "tx_boundary");
1522         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1523                        "write_combine",
1524                        CTLFLAG_RD, &sc->wc,
1525                        0, "write combining PIO?");
1526         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1527                        "read_dma_MBs",
1528                        CTLFLAG_RD, &sc->read_dma,
1529                        0, "DMA Read speed in MB/s");
1530         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1531                        "write_dma_MBs",
1532                        CTLFLAG_RD, &sc->write_dma,
1533                        0, "DMA Write speed in MB/s");
1534         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1535                        "read_write_dma_MBs",
1536                        CTLFLAG_RD, &sc->read_write_dma,
1537                        0, "DMA concurrent Read/Write speed in MB/s");
1538
1539
1540         /* performance related tunables */
1541         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1542                         "intr_coal_delay",
1543                         CTLTYPE_INT|CTLFLAG_RW, sc,
1544                         0, mxge_change_intr_coal, 
1545                         "I", "interrupt coalescing delay in usecs");
1546
1547         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1548                         "flow_control_enabled",
1549                         CTLTYPE_INT|CTLFLAG_RW, sc,
1550                         0, mxge_change_flow_control,
1551                         "I", "interrupt coalescing delay in usecs");
1552
1553         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1554                        "deassert_wait",
1555                        CTLFLAG_RW, &mxge_deassert_wait,
1556                        0, "Wait for IRQ line to go low in ihandler");
1557
1558         /* stats block from firmware is in network byte order.  
1559            Need to swap it */
1560         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1561                         "link_up",
1562                         CTLTYPE_INT|CTLFLAG_RD, &fw->link_up,
1563                         0, mxge_handle_be32,
1564                         "I", "link up");
1565         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1566                         "rdma_tags_available",
1567                         CTLTYPE_INT|CTLFLAG_RD, &fw->rdma_tags_available,
1568                         0, mxge_handle_be32,
1569                         "I", "rdma_tags_available");
1570         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1571                         "dropped_bad_crc32",
1572                         CTLTYPE_INT|CTLFLAG_RD, 
1573                         &fw->dropped_bad_crc32,
1574                         0, mxge_handle_be32,
1575                         "I", "dropped_bad_crc32");
1576         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1577                         "dropped_bad_phy",
1578                         CTLTYPE_INT|CTLFLAG_RD, 
1579                         &fw->dropped_bad_phy,
1580                         0, mxge_handle_be32,
1581                         "I", "dropped_bad_phy");
1582         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1583                         "dropped_link_error_or_filtered",
1584                         CTLTYPE_INT|CTLFLAG_RD, 
1585                         &fw->dropped_link_error_or_filtered,
1586                         0, mxge_handle_be32,
1587                         "I", "dropped_link_error_or_filtered");
1588         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1589                         "dropped_link_overflow",
1590                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_link_overflow,
1591                         0, mxge_handle_be32,
1592                         "I", "dropped_link_overflow");
1593         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1594                         "dropped_multicast_filtered",
1595                         CTLTYPE_INT|CTLFLAG_RD, 
1596                         &fw->dropped_multicast_filtered,
1597                         0, mxge_handle_be32,
1598                         "I", "dropped_multicast_filtered");
1599         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1600                         "dropped_no_big_buffer",
1601                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_no_big_buffer,
1602                         0, mxge_handle_be32,
1603                         "I", "dropped_no_big_buffer");
1604         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1605                         "dropped_no_small_buffer",
1606                         CTLTYPE_INT|CTLFLAG_RD, 
1607                         &fw->dropped_no_small_buffer,
1608                         0, mxge_handle_be32,
1609                         "I", "dropped_no_small_buffer");
1610         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1611                         "dropped_overrun",
1612                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_overrun,
1613                         0, mxge_handle_be32,
1614                         "I", "dropped_overrun");
1615         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1616                         "dropped_pause",
1617                         CTLTYPE_INT|CTLFLAG_RD, 
1618                         &fw->dropped_pause,
1619                         0, mxge_handle_be32,
1620                         "I", "dropped_pause");
1621         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1622                         "dropped_runt",
1623                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_runt,
1624                         0, mxge_handle_be32,
1625                         "I", "dropped_runt");
1626
1627         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1628                         "dropped_unicast_filtered",
1629                         CTLTYPE_INT|CTLFLAG_RD, &fw->dropped_unicast_filtered,
1630                         0, mxge_handle_be32,
1631                         "I", "dropped_unicast_filtered");
1632
1633         /* verbose printing? */
1634         SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1635                        "verbose",
1636                        CTLFLAG_RW, &mxge_verbose,
1637                        0, "verbose printing");
1638
1639         /* lro */
1640         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, 
1641                         "lro_cnt",
1642                         CTLTYPE_INT|CTLFLAG_RW, sc,
1643                         0, mxge_change_lro,
1644                         "I", "number of lro merge queues");
1645
1646
1647         /* add counters exported for debugging from all slices */
1648         sysctl_ctx_init(&sc->slice_sysctl_ctx);
1649         sc->slice_sysctl_tree = 
1650                 SYSCTL_ADD_NODE(&sc->slice_sysctl_ctx, children, OID_AUTO,
1651                                 "slice", CTLFLAG_RD, 0, "");
1652
1653         for (slice = 0; slice < sc->num_slices; slice++) {
1654                 ss = &sc->ss[slice];
1655                 sysctl_ctx_init(&ss->sysctl_ctx);
1656                 ctx = &ss->sysctl_ctx;
1657                 children = SYSCTL_CHILDREN(sc->slice_sysctl_tree);
1658                 ksprintf(slice_num, "%d", slice);
1659                 ss->sysctl_tree = 
1660                         SYSCTL_ADD_NODE(ctx, children, OID_AUTO, slice_num,
1661                                         CTLFLAG_RD, 0, "");
1662                 children = SYSCTL_CHILDREN(ss->sysctl_tree);
1663                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1664                                "rx_small_cnt",
1665                                CTLFLAG_RD, &ss->rx_small.cnt,
1666                                0, "rx_small_cnt");
1667                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1668                                "rx_big_cnt",
1669                                CTLFLAG_RD, &ss->rx_big.cnt,
1670                                0, "rx_small_cnt");
1671                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1672                                "lro_flushed", CTLFLAG_RD, &ss->lro_flushed,
1673                                0, "number of lro merge queues flushed");
1674
1675                 SYSCTL_ADD_INT(ctx, children, OID_AUTO,
1676                                "lro_queued", CTLFLAG_RD, &ss->lro_queued,
1677                                0, "number of frames appended to lro merge"
1678                                "queues");
1679
1680 #ifndef IFNET_BUF_RING
1681                 /* only transmit from slice 0 for now */
1682                 if (slice > 0)
1683                         continue;
1684 #endif
1685                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1686                                "tx_req",
1687                                CTLFLAG_RD, &ss->tx.req,
1688                                0, "tx_req");
1689
1690                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1691                                "tx_done",
1692                                CTLFLAG_RD, &ss->tx.done,
1693                                0, "tx_done");
1694                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1695                                "tx_pkt_done",
1696                                CTLFLAG_RD, &ss->tx.pkt_done,
1697                                0, "tx_done");
1698                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1699                                "tx_stall",
1700                                CTLFLAG_RD, &ss->tx.stall,
1701                                0, "tx_stall");
1702                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1703                                "tx_wake",
1704                                CTLFLAG_RD, &ss->tx.wake,
1705                                0, "tx_wake");
1706                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1707                                "tx_defrag",
1708                                CTLFLAG_RD, &ss->tx.defrag,
1709                                0, "tx_defrag");
1710                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1711                                "tx_queue_active",
1712                                CTLFLAG_RD, &ss->tx.queue_active,
1713                                0, "tx_queue_active");
1714                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1715                                "tx_activate",
1716                                CTLFLAG_RD, &ss->tx.activate,
1717                                0, "tx_activate");
1718                 SYSCTL_ADD_INT(ctx, children, OID_AUTO, 
1719                                "tx_deactivate",
1720                                CTLFLAG_RD, &ss->tx.deactivate,
1721                                0, "tx_deactivate");
1722         }
1723 }
1724
1725 /* copy an array of mcp_kreq_ether_send_t's to the mcp.  Copy 
1726    backwards one at a time and handle ring wraps */
1727
1728 static inline void 
1729 mxge_submit_req_backwards(mxge_tx_ring_t *tx, 
1730                             mcp_kreq_ether_send_t *src, int cnt)
1731 {
1732         int idx, starting_slot;
1733         starting_slot = tx->req;
1734         while (cnt > 1) {
1735                 cnt--;
1736                 idx = (starting_slot + cnt) & tx->mask;
1737                 mxge_pio_copy(&tx->lanai[idx],
1738                               &src[cnt], sizeof(*src));
1739                 wmb();
1740         }
1741 }
1742
1743 /*
1744  * copy an array of mcp_kreq_ether_send_t's to the mcp.  Copy
1745  * at most 32 bytes at a time, so as to avoid involving the software
1746  * pio handler in the nic.   We re-write the first segment's flags
1747  * to mark them valid only after writing the entire chain 
1748  */
1749
1750 static inline void 
1751 mxge_submit_req(mxge_tx_ring_t *tx, mcp_kreq_ether_send_t *src, 
1752                   int cnt)
1753 {
1754         int idx, i;
1755         uint32_t *src_ints;
1756         volatile uint32_t *dst_ints;
1757         mcp_kreq_ether_send_t *srcp;
1758         volatile mcp_kreq_ether_send_t *dstp, *dst;
1759         uint8_t last_flags;
1760         
1761         idx = tx->req & tx->mask;
1762
1763         last_flags = src->flags;
1764         src->flags = 0;
1765         wmb();
1766         dst = dstp = &tx->lanai[idx];
1767         srcp = src;
1768
1769         if ((idx + cnt) < tx->mask) {
1770                 for (i = 0; i < (cnt - 1); i += 2) {
1771                         mxge_pio_copy(dstp, srcp, 2 * sizeof(*src));
1772                         wmb(); /* force write every 32 bytes */
1773                         srcp += 2;
1774                         dstp += 2;
1775                 }
1776         } else {
1777                 /* submit all but the first request, and ensure 
1778                    that it is submitted below */
1779                 mxge_submit_req_backwards(tx, src, cnt);
1780                 i = 0;
1781         }
1782         if (i < cnt) {
1783                 /* submit the first request */
1784                 mxge_pio_copy(dstp, srcp, sizeof(*src));
1785                 wmb(); /* barrier before setting valid flag */
1786         }
1787
1788         /* re-write the last 32-bits with the valid flags */
1789         src->flags = last_flags;
1790         src_ints = (uint32_t *)src;
1791         src_ints+=3;
1792         dst_ints = (volatile uint32_t *)dst;
1793         dst_ints+=3;
1794         *dst_ints =  *src_ints;
1795         tx->req += cnt;
1796         wmb();
1797 }
1798
1799 #if IFCAP_TSO4
1800
1801 static void
1802 mxge_encap_tso(struct mxge_slice_state *ss, struct mbuf *m,
1803                int busdma_seg_cnt, int ip_off)
1804 {
1805         mxge_tx_ring_t *tx;
1806         mcp_kreq_ether_send_t *req;
1807         bus_dma_segment_t *seg;
1808         struct ip *ip;
1809         struct tcphdr *tcp;
1810         uint32_t low, high_swapped;
1811         int len, seglen, cum_len, cum_len_next;
1812         int next_is_first, chop, cnt, rdma_count, small;
1813         uint16_t pseudo_hdr_offset, cksum_offset, mss;
1814         uint8_t flags, flags_next;
1815         static int once;
1816
1817         mss = m->m_pkthdr.tso_segsz;
1818
1819         /* negative cum_len signifies to the
1820          * send loop that we are still in the
1821          * header portion of the TSO packet.
1822          */
1823
1824         /* ensure we have the ethernet, IP and TCP
1825            header together in the first mbuf, copy
1826            it to a scratch buffer if not */
1827         if (__predict_false(m->m_len < ip_off + sizeof (*ip))) {
1828                 m_copydata(m, 0, ip_off + sizeof (*ip),
1829                            ss->scratch);
1830                 ip = (struct ip *)(ss->scratch + ip_off);
1831         } else {
1832                 ip = (struct ip *)(mtod(m, char *) + ip_off);
1833         }
1834         if (__predict_false(m->m_len < ip_off + (ip->ip_hl << 2)
1835                             + sizeof (*tcp))) {
1836                 m_copydata(m, 0, ip_off + (ip->ip_hl << 2)
1837                            + sizeof (*tcp),  ss->scratch);
1838                 ip = (struct ip *)(mtod(m, char *) + ip_off);
1839         } 
1840
1841         tcp = (struct tcphdr *)((char *)ip + (ip->ip_hl << 2));
1842         cum_len = -(ip_off + ((ip->ip_hl + tcp->th_off) << 2));
1843
1844         /* TSO implies checksum offload on this hardware */
1845         cksum_offset = ip_off + (ip->ip_hl << 2);
1846         flags = MXGEFW_FLAGS_TSO_HDR | MXGEFW_FLAGS_FIRST;
1847
1848         
1849         /* for TSO, pseudo_hdr_offset holds mss.
1850          * The firmware figures out where to put
1851          * the checksum by parsing the header. */
1852         pseudo_hdr_offset = htobe16(mss);
1853
1854         tx = &ss->tx;
1855         req = tx->req_list;
1856         seg = tx->seg_list;
1857         cnt = 0;
1858         rdma_count = 0;
1859         /* "rdma_count" is the number of RDMAs belonging to the
1860          * current packet BEFORE the current send request. For
1861          * non-TSO packets, this is equal to "count".
1862          * For TSO packets, rdma_count needs to be reset
1863          * to 0 after a segment cut.
1864          *
1865          * The rdma_count field of the send request is
1866          * the number of RDMAs of the packet starting at
1867          * that request. For TSO send requests with one ore more cuts
1868          * in the middle, this is the number of RDMAs starting
1869          * after the last cut in the request. All previous
1870          * segments before the last cut implicitly have 1 RDMA.
1871          *
1872          * Since the number of RDMAs is not known beforehand,
1873          * it must be filled-in retroactively - after each
1874          * segmentation cut or at the end of the entire packet.
1875          */
1876
1877         while (busdma_seg_cnt) {
1878                 /* Break the busdma segment up into pieces*/
1879                 low = MXGE_LOWPART_TO_U32(seg->ds_addr);
1880                 high_swapped =  htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
1881                 len = seg->ds_len;
1882
1883                 while (len) {
1884                         flags_next = flags & ~MXGEFW_FLAGS_FIRST;
1885                         seglen = len;
1886                         cum_len_next = cum_len + seglen;
1887                         (req-rdma_count)->rdma_count = rdma_count + 1;
1888                         if (__predict_true(cum_len >= 0)) {
1889                                 /* payload */
1890                                 chop = (cum_len_next > mss);
1891                                 cum_len_next = cum_len_next % mss;
1892                                 next_is_first = (cum_len_next == 0);
1893                                 flags |= chop * MXGEFW_FLAGS_TSO_CHOP;
1894                                 flags_next |= next_is_first *
1895                                         MXGEFW_FLAGS_FIRST;
1896                                 rdma_count |= -(chop | next_is_first);
1897                                 rdma_count += chop & !next_is_first;
1898                         } else if (cum_len_next >= 0) {
1899                                 /* header ends */
1900                                 rdma_count = -1;
1901                                 cum_len_next = 0;
1902                                 seglen = -cum_len;
1903                                 small = (mss <= MXGEFW_SEND_SMALL_SIZE);
1904                                 flags_next = MXGEFW_FLAGS_TSO_PLD |
1905                                         MXGEFW_FLAGS_FIRST | 
1906                                         (small * MXGEFW_FLAGS_SMALL);
1907                             }
1908                         
1909                         req->addr_high = high_swapped;
1910                         req->addr_low = htobe32(low);
1911                         req->pseudo_hdr_offset = pseudo_hdr_offset;
1912                         req->pad = 0;
1913                         req->rdma_count = 1;
1914                         req->length = htobe16(seglen);
1915                         req->cksum_offset = cksum_offset;
1916                         req->flags = flags | ((cum_len & 1) *
1917                                               MXGEFW_FLAGS_ALIGN_ODD);
1918                         low += seglen;
1919                         len -= seglen;
1920                         cum_len = cum_len_next;
1921                         flags = flags_next;
1922                         req++;
1923                         cnt++;
1924                         rdma_count++;
1925                         if (__predict_false(cksum_offset > seglen))
1926                                 cksum_offset -= seglen;
1927                         else
1928                                 cksum_offset = 0;
1929                         if (__predict_false(cnt > tx->max_desc))
1930                                 goto drop;
1931                 }
1932                 busdma_seg_cnt--;
1933                 seg++;
1934         }
1935         (req-rdma_count)->rdma_count = rdma_count;
1936
1937         do {
1938                 req--;
1939                 req->flags |= MXGEFW_FLAGS_TSO_LAST;
1940         } while (!(req->flags & (MXGEFW_FLAGS_TSO_CHOP | MXGEFW_FLAGS_FIRST)));
1941
1942         tx->info[((cnt - 1) + tx->req) & tx->mask].flag = 1;
1943         mxge_submit_req(tx, tx->req_list, cnt);
1944 #ifdef IFNET_BUF_RING
1945         if ((ss->sc->num_slices > 1) && tx->queue_active == 0) {
1946                 /* tell the NIC to start polling this slice */
1947                 *tx->send_go = 1;
1948                 tx->queue_active = 1;
1949                 tx->activate++;
1950                 wmb();
1951         }
1952 #endif
1953         return;
1954
1955 drop:
1956         bus_dmamap_unload(tx->dmat, tx->info[tx->req & tx->mask].map);
1957         m_freem(m);
1958         ss->oerrors++;
1959         if (!once) {
1960                 kprintf("tx->max_desc exceeded via TSO!\n");
1961                 kprintf("mss = %d, %ld, %d!\n", mss,
1962                        (long)seg - (long)tx->seg_list, tx->max_desc);
1963                 once = 1;
1964         }
1965         return;
1966
1967 }
1968
1969 #endif /* IFCAP_TSO4 */
1970
1971 #ifdef MXGE_NEW_VLAN_API
1972 /* 
1973  * We reproduce the software vlan tag insertion from
1974  * net/if_vlan.c:vlan_start() here so that we can advertise "hardware"
1975  * vlan tag insertion. We need to advertise this in order to have the
1976  * vlan interface respect our csum offload flags.
1977  */
1978 static struct mbuf *
1979 mxge_vlan_tag_insert(struct mbuf *m)
1980 {
1981         struct ether_vlan_header *evl;
1982
1983         M_PREPEND(m, EVL_ENCAPLEN, MB_DONTWAIT);
1984         if (__predict_false(m == NULL))
1985                 return NULL;
1986         if (m->m_len < sizeof(*evl)) {
1987                 m = m_pullup(m, sizeof(*evl));
1988                 if (__predict_false(m == NULL))
1989                         return NULL;
1990         }
1991         /*
1992          * Transform the Ethernet header into an Ethernet header
1993          * with 802.1Q encapsulation.
1994          */
1995         evl = mtod(m, struct ether_vlan_header *);
1996         bcopy((char *)evl + EVL_ENCAPLEN,
1997               (char *)evl, ETHER_HDR_LEN - ETHER_TYPE_LEN);
1998         evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
1999         evl->evl_tag = htons(m->m_pkthdr.ether_vlantag);
2000         m->m_flags &= ~M_VLANTAG;
2001         return m;
2002 }
2003 #endif /* MXGE_NEW_VLAN_API */
2004
2005 static void
2006 mxge_encap(struct mxge_slice_state *ss, struct mbuf *m)
2007 {
2008         mxge_softc_t *sc;
2009         mcp_kreq_ether_send_t *req;
2010         bus_dma_segment_t *seg;
2011         struct mbuf *m_tmp;
2012         struct ifnet *ifp;
2013         mxge_tx_ring_t *tx;
2014         struct ip *ip;
2015         int cnt, cum_len, err, i, idx, odd_flag, ip_off;
2016         uint16_t pseudo_hdr_offset;
2017         uint8_t flags, cksum_offset;
2018
2019
2020         sc = ss->sc;
2021         ifp = sc->ifp;
2022         tx = &ss->tx;
2023
2024         ip_off = sizeof (struct ether_header);
2025 #ifdef MXGE_NEW_VLAN_API
2026         if (m->m_flags & M_VLANTAG) {
2027                 m = mxge_vlan_tag_insert(m);
2028                 if (__predict_false(m == NULL))
2029                         goto drop;
2030                 ip_off += EVL_ENCAPLEN;
2031         }
2032 #endif
2033         /* (try to) map the frame for DMA */
2034         idx = tx->req & tx->mask;
2035         err = bus_dmamap_load_mbuf_segment(tx->dmat, tx->info[idx].map,
2036                                            m, tx->seg_list, 1, &cnt, 
2037                                            BUS_DMA_NOWAIT);
2038         if (__predict_false(err == EFBIG)) {
2039                 /* Too many segments in the chain.  Try
2040                    to defrag */
2041                 m_tmp = m_defrag(m, M_NOWAIT);
2042                 if (m_tmp == NULL) {
2043                         goto drop;
2044                 }
2045                 ss->tx.defrag++;
2046                 m = m_tmp;
2047                 err = bus_dmamap_load_mbuf_segment(tx->dmat, 
2048                                               tx->info[idx].map,
2049                                               m, tx->seg_list, 1, &cnt, 
2050                                               BUS_DMA_NOWAIT);
2051         }
2052         if (__predict_false(err != 0)) {
2053                 device_printf(sc->dev, "bus_dmamap_load_mbuf_segment returned %d"
2054                               " packet len = %d\n", err, m->m_pkthdr.len);
2055                 goto drop;
2056         }
2057         bus_dmamap_sync(tx->dmat, tx->info[idx].map,
2058                         BUS_DMASYNC_PREWRITE);
2059         tx->info[idx].m = m;
2060
2061 #if IFCAP_TSO4
2062         /* TSO is different enough, we handle it in another routine */
2063         if (m->m_pkthdr.csum_flags & (CSUM_TSO)) {
2064                 mxge_encap_tso(ss, m, cnt, ip_off);
2065                 return;
2066         }
2067 #endif
2068
2069         req = tx->req_list;
2070         cksum_offset = 0;
2071         pseudo_hdr_offset = 0;
2072         flags = MXGEFW_FLAGS_NO_TSO;
2073
2074         /* checksum offloading? */
2075         if (m->m_pkthdr.csum_flags & (CSUM_DELAY_DATA)) {
2076                 /* ensure ip header is in first mbuf, copy
2077                    it to a scratch buffer if not */
2078                 if (__predict_false(m->m_len < ip_off + sizeof (*ip))) {
2079                         m_copydata(m, 0, ip_off + sizeof (*ip),
2080                                    ss->scratch);
2081                         ip = (struct ip *)(ss->scratch + ip_off);
2082                 } else {
2083                         ip = (struct ip *)(mtod(m, char *) + ip_off);
2084                 }
2085                 cksum_offset = ip_off + (ip->ip_hl << 2);
2086                 pseudo_hdr_offset = cksum_offset +  m->m_pkthdr.csum_data;
2087                 pseudo_hdr_offset = htobe16(pseudo_hdr_offset);
2088                 req->cksum_offset = cksum_offset;
2089                 flags |= MXGEFW_FLAGS_CKSUM;
2090                 odd_flag = MXGEFW_FLAGS_ALIGN_ODD;
2091         } else {
2092                 odd_flag = 0;
2093         }
2094         if (m->m_pkthdr.len < MXGEFW_SEND_SMALL_SIZE)
2095                 flags |= MXGEFW_FLAGS_SMALL;
2096
2097         /* convert segments into a request list */
2098         cum_len = 0;
2099         seg = tx->seg_list;
2100         req->flags = MXGEFW_FLAGS_FIRST;
2101         for (i = 0; i < cnt; i++) {
2102                 req->addr_low = 
2103                         htobe32(MXGE_LOWPART_TO_U32(seg->ds_addr));
2104                 req->addr_high = 
2105                         htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
2106                 req->length = htobe16(seg->ds_len);
2107                 req->cksum_offset = cksum_offset;
2108                 if (cksum_offset > seg->ds_len)
2109                         cksum_offset -= seg->ds_len;
2110                 else
2111                         cksum_offset = 0;
2112                 req->pseudo_hdr_offset = pseudo_hdr_offset;
2113                 req->pad = 0; /* complete solid 16-byte block */
2114                 req->rdma_count = 1;
2115                 req->flags |= flags | ((cum_len & 1) * odd_flag);
2116                 cum_len += seg->ds_len;
2117                 seg++;
2118                 req++;
2119                 req->flags = 0;
2120         }
2121         req--;
2122         /* pad runts to 60 bytes */
2123         if (cum_len < 60) {
2124                 req++;
2125                 req->addr_low = 
2126                         htobe32(MXGE_LOWPART_TO_U32(sc->zeropad_dma.bus_addr));
2127                 req->addr_high = 
2128                         htobe32(MXGE_HIGHPART_TO_U32(sc->zeropad_dma.bus_addr));
2129                 req->length = htobe16(60 - cum_len);
2130                 req->cksum_offset = 0;
2131                 req->pseudo_hdr_offset = pseudo_hdr_offset;
2132                 req->pad = 0; /* complete solid 16-byte block */
2133                 req->rdma_count = 1;
2134                 req->flags |= flags | ((cum_len & 1) * odd_flag);
2135                 cnt++;
2136         }
2137
2138         tx->req_list[0].rdma_count = cnt;
2139 #if 0
2140         /* print what the firmware will see */
2141         for (i = 0; i < cnt; i++) {
2142                 kprintf("%d: addr: 0x%x 0x%x len:%d pso%d,"
2143                     "cso:%d, flags:0x%x, rdma:%d\n",
2144                     i, (int)ntohl(tx->req_list[i].addr_high),
2145                     (int)ntohl(tx->req_list[i].addr_low),
2146                     (int)ntohs(tx->req_list[i].length),
2147                     (int)ntohs(tx->req_list[i].pseudo_hdr_offset),
2148                     tx->req_list[i].cksum_offset, tx->req_list[i].flags,
2149                     tx->req_list[i].rdma_count);
2150         }
2151         kprintf("--------------\n");
2152 #endif
2153         tx->info[((cnt - 1) + tx->req) & tx->mask].flag = 1;
2154         mxge_submit_req(tx, tx->req_list, cnt);
2155 #ifdef IFNET_BUF_RING
2156         if ((ss->sc->num_slices > 1) && tx->queue_active == 0) {
2157                 /* tell the NIC to start polling this slice */
2158                 *tx->send_go = 1;
2159                 tx->queue_active = 1;
2160                 tx->activate++;
2161                 wmb();
2162         }
2163 #endif
2164         return;
2165
2166 drop:
2167         m_freem(m);
2168         ss->oerrors++;
2169         return;
2170 }
2171
2172 #ifdef IFNET_BUF_RING
2173 static void
2174 mxge_qflush(struct ifnet *ifp)
2175 {
2176         mxge_softc_t *sc = ifp->if_softc;
2177         mxge_tx_ring_t *tx;
2178         struct mbuf *m;
2179         int slice;
2180
2181         for (slice = 0; slice < sc->num_slices; slice++) {
2182                 tx = &sc->ss[slice].tx;
2183                 lwkt_serialize_enter(sc->ifp->if_serializer);
2184                 while ((m = buf_ring_dequeue_sc(tx->br)) != NULL)
2185                         m_freem(m);
2186                 lwkt_serialize_exit(sc->ifp->if_serializer);
2187         }
2188         if_qflush(ifp);
2189 }
2190
2191 static inline void
2192 mxge_start_locked(struct mxge_slice_state *ss)
2193 {
2194         mxge_softc_t *sc;
2195         struct mbuf *m;
2196         struct ifnet *ifp;
2197         mxge_tx_ring_t *tx;
2198
2199         sc = ss->sc;
2200         ifp = sc->ifp;
2201         tx = &ss->tx;
2202
2203         while ((tx->mask - (tx->req - tx->done)) > tx->max_desc) {
2204                 m = drbr_dequeue(ifp, tx->br);
2205                 if (m == NULL) {
2206                         return;
2207                 }
2208                 /* let BPF see it */
2209                 BPF_MTAP(ifp, m);
2210
2211                 /* give it to the nic */
2212                 mxge_encap(ss, m);
2213         }
2214         /* ran out of transmit slots */
2215         if (((ss->if_flags & IFF_OACTIVE) == 0)
2216             && (!drbr_empty(ifp, tx->br))) {
2217                 ss->if_flags |= IFF_OACTIVE;
2218                 tx->stall++;
2219         }
2220 }
2221
2222 static int
2223 mxge_transmit_locked(struct mxge_slice_state *ss, struct mbuf *m)
2224 {
2225         mxge_softc_t *sc;
2226         struct ifnet *ifp;
2227         mxge_tx_ring_t *tx;
2228         int err;
2229
2230         sc = ss->sc;
2231         ifp = sc->ifp;
2232         tx = &ss->tx;
2233
2234         if ((ss->if_flags & (IFF_RUNNING|IFF_OACTIVE)) !=
2235             IFF_RUNNING) {
2236                 err = drbr_enqueue(ifp, tx->br, m);
2237                 return (err);
2238         }
2239
2240         if (drbr_empty(ifp, tx->br) &&
2241             ((tx->mask - (tx->req - tx->done)) > tx->max_desc)) {
2242                 /* let BPF see it */
2243                 BPF_MTAP(ifp, m);
2244                 /* give it to the nic */
2245                 mxge_encap(ss, m);
2246         } else if ((err = drbr_enqueue(ifp, tx->br, m)) != 0) {
2247                 return (err);
2248         }
2249         if (!drbr_empty(ifp, tx->br))
2250                 mxge_start_locked(ss);
2251         return (0);
2252 }
2253
2254 static int
2255 mxge_transmit(struct ifnet *ifp, struct mbuf *m)
2256 {
2257         mxge_softc_t *sc = ifp->if_softc;
2258         struct mxge_slice_state *ss;
2259         mxge_tx_ring_t *tx;
2260         int err = 0;
2261         int slice;
2262
2263 #if 0
2264         slice = m->m_pkthdr.flowid;
2265 #endif
2266         slice &= (sc->num_slices - 1);  /* num_slices always power of 2 */
2267
2268         ss = &sc->ss[slice];
2269         tx = &ss->tx;
2270
2271         if(lwkt_serialize_try(ifp->if_serializer)) {
2272                 err = mxge_transmit_locked(ss, m);
2273                 lwkt_serialize_exit(ifp->if_serializer);
2274         } else {
2275                 err = drbr_enqueue(ifp, tx->br, m);
2276         }
2277
2278         return (err);
2279 }
2280
2281 #else
2282
2283 static inline void
2284 mxge_start_locked(struct mxge_slice_state *ss)
2285 {
2286         mxge_softc_t *sc;
2287         struct mbuf *m;
2288         struct ifnet *ifp;
2289         mxge_tx_ring_t *tx;
2290
2291         sc = ss->sc;
2292         ifp = sc->ifp;
2293         tx = &ss->tx;
2294         while ((tx->mask - (tx->req - tx->done)) > tx->max_desc) {
2295                 m = ifq_dequeue(&ifp->if_snd, NULL);
2296                 if (m == NULL) {
2297                         return;
2298                 }
2299                 /* let BPF see it */
2300                 BPF_MTAP(ifp, m);
2301
2302                 /* give it to the nic */
2303                 mxge_encap(ss, m);
2304         }
2305         /* ran out of transmit slots */
2306         if ((sc->ifp->if_flags & IFF_OACTIVE) == 0) {
2307                 sc->ifp->if_flags |= IFF_OACTIVE;
2308                 tx->stall++;
2309         }
2310 }
2311 #endif
2312 static void
2313 mxge_start(struct ifnet *ifp)
2314 {
2315         mxge_softc_t *sc = ifp->if_softc;
2316         struct mxge_slice_state *ss;
2317
2318         ASSERT_SERIALIZED(sc->ifp->if_serializer);
2319         /* only use the first slice for now */
2320         ss = &sc->ss[0];
2321         mxge_start_locked(ss);
2322 }
2323
2324 /*
2325  * copy an array of mcp_kreq_ether_recv_t's to the mcp.  Copy
2326  * at most 32 bytes at a time, so as to avoid involving the software
2327  * pio handler in the nic.   We re-write the first segment's low
2328  * DMA address to mark it valid only after we write the entire chunk
2329  * in a burst
2330  */
2331 static inline void
2332 mxge_submit_8rx(volatile mcp_kreq_ether_recv_t *dst,
2333                 mcp_kreq_ether_recv_t *src)
2334 {
2335         uint32_t low;
2336
2337         low = src->addr_low;
2338         src->addr_low = 0xffffffff;
2339         mxge_pio_copy(dst, src, 4 * sizeof (*src));
2340         wmb();
2341         mxge_pio_copy(dst + 4, src + 4, 4 * sizeof (*src));
2342         wmb();
2343         src->addr_low = low;
2344         dst->addr_low = low;
2345         wmb();
2346 }
2347
2348 static int
2349 mxge_get_buf_small(struct mxge_slice_state *ss, bus_dmamap_t map, int idx)
2350 {
2351         bus_dma_segment_t seg;
2352         struct mbuf *m;
2353         mxge_rx_ring_t *rx = &ss->rx_small;
2354         int cnt, err;
2355
2356         m = m_gethdr(MB_DONTWAIT, MT_DATA);
2357         if (m == NULL) {
2358                 rx->alloc_fail++;
2359                 err = ENOBUFS;
2360                 goto done;
2361         }
2362         m->m_len = MHLEN;
2363         err = bus_dmamap_load_mbuf_segment(rx->dmat, map, m, 
2364                                       &seg, 1, &cnt, BUS_DMA_NOWAIT);
2365         if (err != 0) {
2366                 m_free(m);
2367                 goto done;
2368         }
2369         rx->info[idx].m = m;
2370         rx->shadow[idx].addr_low = 
2371                 htobe32(MXGE_LOWPART_TO_U32(seg.ds_addr));
2372         rx->shadow[idx].addr_high = 
2373                 htobe32(MXGE_HIGHPART_TO_U32(seg.ds_addr));
2374
2375 done:
2376         if ((idx & 7) == 7)
2377                 mxge_submit_8rx(&rx->lanai[idx - 7], &rx->shadow[idx - 7]);
2378         return err;
2379 }
2380
2381
2382 static int
2383 mxge_get_buf_big(struct mxge_slice_state *ss, bus_dmamap_t map, int idx)
2384 {
2385         bus_dma_segment_t seg[3];
2386         struct mbuf *m;
2387         mxge_rx_ring_t *rx = &ss->rx_big;
2388         int cnt, err, i;
2389
2390         if (rx->cl_size == MCLBYTES)
2391                 m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
2392         else {
2393 #if 0
2394                 m = m_getjcl(MB_DONTWAIT, MT_DATA, M_PKTHDR, rx->cl_size);
2395 #else
2396                 /*
2397                  * XXX: allocate normal sized buffers for big buffers.
2398                  * We should be fine as long as we don't get any jumbo frames
2399                  */
2400                 m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
2401 #endif
2402         }
2403         if (m == NULL) {
2404                 rx->alloc_fail++;
2405                 err = ENOBUFS;
2406                 goto done;
2407         }
2408         m->m_len = rx->mlen;
2409         err = bus_dmamap_load_mbuf_segment(rx->dmat, map, m, 
2410                                       seg, 1, &cnt, BUS_DMA_NOWAIT);
2411         if (err != 0) {
2412                 m_free(m);
2413                 goto done;
2414         }
2415         rx->info[idx].m = m;
2416         rx->shadow[idx].addr_low = 
2417                 htobe32(MXGE_LOWPART_TO_U32(seg->ds_addr));
2418         rx->shadow[idx].addr_high = 
2419                 htobe32(MXGE_HIGHPART_TO_U32(seg->ds_addr));
2420
2421 #if MXGE_VIRT_JUMBOS
2422         for (i = 1; i < cnt; i++) {
2423                 rx->shadow[idx + i].addr_low = 
2424                         htobe32(MXGE_LOWPART_TO_U32(seg[i].ds_addr));
2425                 rx->shadow[idx + i].addr_high = 
2426                         htobe32(MXGE_HIGHPART_TO_U32(seg[i].ds_addr));
2427        }
2428 #endif
2429
2430 done:
2431        for (i = 0; i < rx->nbufs; i++) {
2432                 if ((idx & 7) == 7) {
2433                         mxge_submit_8rx(&rx->lanai[idx - 7],
2434                                         &rx->shadow[idx - 7]);
2435                 }
2436                 idx++;
2437         }
2438         return err;
2439 }
2440
2441 /* 
2442  *  Myri10GE hardware checksums are not valid if the sender
2443  *  padded the frame with non-zero padding.  This is because
2444  *  the firmware just does a simple 16-bit 1s complement
2445  *  checksum across the entire frame, excluding the first 14
2446  *  bytes.  It is best to simply to check the checksum and
2447  *  tell the stack about it only if the checksum is good
2448  */
2449
2450 static inline uint16_t
2451 mxge_rx_csum(struct mbuf *m, int csum)
2452 {
2453         struct ether_header *eh;
2454         struct ip *ip;
2455         uint16_t c;
2456
2457         eh = mtod(m, struct ether_header *);
2458
2459         /* only deal with IPv4 TCP & UDP for now */
2460         if (__predict_false(eh->ether_type != htons(ETHERTYPE_IP)))
2461                 return 1;
2462         ip = (struct ip *)(eh + 1);
2463         if (__predict_false(ip->ip_p != IPPROTO_TCP &&
2464                             ip->ip_p != IPPROTO_UDP))
2465                 return 1;
2466 #ifdef INET
2467         c = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
2468                       htonl(ntohs(csum) + ntohs(ip->ip_len) +
2469                             - (ip->ip_hl << 2) + ip->ip_p));
2470 #else
2471         c = 1;
2472 #endif
2473         c ^= 0xffff;
2474         return (c);
2475 }
2476
2477 static void
2478 mxge_vlan_tag_remove(struct mbuf *m, uint32_t *csum)
2479 {
2480         struct ether_vlan_header *evl;
2481         struct ether_header *eh;
2482         uint32_t partial;
2483
2484         evl = mtod(m, struct ether_vlan_header *);
2485         eh = mtod(m, struct ether_header *);
2486
2487         /*
2488          * fix checksum by subtracting EVL_ENCAPLEN bytes
2489          * after what the firmware thought was the end of the ethernet
2490          * header.
2491          */
2492
2493         /* put checksum into host byte order */
2494         *csum = ntohs(*csum); 
2495         partial = ntohl(*(uint32_t *)(mtod(m, char *) + ETHER_HDR_LEN));
2496         (*csum) += ~partial;
2497         (*csum) +=  ((*csum) < ~partial);
2498         (*csum) = ((*csum) >> 16) + ((*csum) & 0xFFFF);
2499         (*csum) = ((*csum) >> 16) + ((*csum) & 0xFFFF);
2500
2501         /* restore checksum to network byte order; 
2502            later consumers expect this */
2503         *csum = htons(*csum);
2504
2505         /* save the tag */
2506 #ifdef MXGE_NEW_VLAN_API        
2507         m->m_pkthdr.ether_vlantag = ntohs(evl->evl_tag);
2508 #else
2509         {
2510                 struct m_tag *mtag;
2511                 mtag = m_tag_alloc(MTAG_VLAN, MTAG_VLAN_TAG, sizeof(u_int),
2512                                    MB_DONTWAIT);
2513                 if (mtag == NULL)
2514                         return;
2515                 VLAN_TAG_VALUE(mtag) = ntohs(evl->evl_tag);
2516                 m_tag_prepend(m, mtag);
2517         }
2518
2519 #endif
2520         m->m_flags |= M_VLANTAG;
2521
2522         /*
2523          * Remove the 802.1q header by copying the Ethernet
2524          * addresses over it and adjusting the beginning of
2525          * the data in the mbuf.  The encapsulated Ethernet
2526          * type field is already in place.
2527          */
2528         bcopy((char *)evl, (char *)evl + EVL_ENCAPLEN,
2529               ETHER_HDR_LEN - ETHER_TYPE_LEN);
2530         m_adj(m, EVL_ENCAPLEN);
2531 }
2532
2533
2534 static inline void
2535 mxge_rx_done_big(struct mxge_slice_state *ss, uint32_t len, uint32_t csum)
2536 {
2537         mxge_softc_t *sc;
2538         struct ifnet *ifp;
2539         struct mbuf *m;
2540         struct ether_header *eh;
2541         mxge_rx_ring_t *rx;
2542         bus_dmamap_t old_map;
2543         int idx;
2544         uint16_t tcpudp_csum;
2545
2546         sc = ss->sc;
2547         ifp = sc->ifp;
2548         rx = &ss->rx_big;
2549         idx = rx->cnt & rx->mask;
2550         rx->cnt += rx->nbufs;
2551         /* save a pointer to the received mbuf */
2552         m = rx->info[idx].m;
2553         /* try to replace the received mbuf */
2554         if (mxge_get_buf_big(ss, rx->extra_map, idx)) {
2555                 /* drop the frame -- the old mbuf is re-cycled */
2556                 ifp->if_ierrors++;
2557                 return;
2558         }
2559
2560         /* unmap the received buffer */
2561         old_map = rx->info[idx].map;
2562         bus_dmamap_sync(rx->dmat, old_map, BUS_DMASYNC_POSTREAD);
2563         bus_dmamap_unload(rx->dmat, old_map);
2564
2565         /* swap the bus_dmamap_t's */
2566         rx->info[idx].map = rx->extra_map;
2567         rx->extra_map = old_map;
2568
2569         /* mcp implicitly skips 1st 2 bytes so that packet is properly
2570          * aligned */
2571         m->m_data += MXGEFW_PAD;
2572
2573         m->m_pkthdr.rcvif = ifp;
2574         m->m_len = m->m_pkthdr.len = len;
2575         ss->ipackets++;
2576         eh = mtod(m, struct ether_header *);
2577         if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2578                 mxge_vlan_tag_remove(m, &csum);
2579         }
2580         /* if the checksum is valid, mark it in the mbuf header */
2581         if (sc->csum_flag && (0 == (tcpudp_csum = mxge_rx_csum(m, csum)))) {
2582                 if (sc->lro_cnt && (0 == mxge_lro_rx(ss, m, csum)))
2583                         return;
2584                 /* otherwise, it was a UDP frame, or a TCP frame which
2585                    we could not do LRO on.  Tell the stack that the
2586                    checksum is good */
2587                 m->m_pkthdr.csum_data = 0xffff;
2588                 m->m_pkthdr.csum_flags = CSUM_PSEUDO_HDR | CSUM_DATA_VALID;
2589         }
2590 #if 0
2591         /* flowid only valid if RSS hashing is enabled */
2592         if (sc->num_slices > 1) {
2593                 m->m_pkthdr.flowid = (ss - sc->ss);
2594                 m->m_flags |= M_FLOWID;
2595         }
2596 #endif
2597         /* pass the frame up the stack */
2598         (*ifp->if_input)(ifp, m);
2599 }
2600
2601 static inline void
2602 mxge_rx_done_small(struct mxge_slice_state *ss, uint32_t len, uint32_t csum)
2603 {
2604         mxge_softc_t *sc;
2605         struct ifnet *ifp;
2606         struct ether_header *eh;
2607         struct mbuf *m;
2608         mxge_rx_ring_t *rx;
2609         bus_dmamap_t old_map;
2610         int idx;
2611         uint16_t tcpudp_csum;
2612
2613         sc = ss->sc;
2614         ifp = sc->ifp;
2615         rx = &ss->rx_small;
2616         idx = rx->cnt & rx->mask;
2617         rx->cnt++;
2618         /* save a pointer to the received mbuf */
2619         m = rx->info[idx].m;
2620         /* try to replace the received mbuf */
2621         if (mxge_get_buf_small(ss, rx->extra_map, idx)) {
2622                 /* drop the frame -- the old mbuf is re-cycled */
2623                 ifp->if_ierrors++;
2624                 return;
2625         }
2626
2627         /* unmap the received buffer */
2628         old_map = rx->info[idx].map;
2629         bus_dmamap_sync(rx->dmat, old_map, BUS_DMASYNC_POSTREAD);
2630         bus_dmamap_unload(rx->dmat, old_map);
2631
2632         /* swap the bus_dmamap_t's */
2633         rx->info[idx].map = rx->extra_map;
2634         rx->extra_map = old_map;
2635
2636         /* mcp implicitly skips 1st 2 bytes so that packet is properly
2637          * aligned */
2638         m->m_data += MXGEFW_PAD;
2639
2640         m->m_pkthdr.rcvif = ifp;
2641         m->m_len = m->m_pkthdr.len = len;
2642         ss->ipackets++;
2643         eh = mtod(m, struct ether_header *);
2644         if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2645                 mxge_vlan_tag_remove(m, &csum);
2646         }
2647         /* if the checksum is valid, mark it in the mbuf header */
2648         if (sc->csum_flag && (0 == (tcpudp_csum = mxge_rx_csum(m, csum)))) {
2649                 if (sc->lro_cnt && (0 == mxge_lro_rx(ss, m, csum)))
2650                         return;
2651                 /* otherwise, it was a UDP frame, or a TCP frame which
2652                    we could not do LRO on.  Tell the stack that the
2653                    checksum is good */
2654                 m->m_pkthdr.csum_data = 0xffff;
2655                 m->m_pkthdr.csum_flags = CSUM_PSEUDO_HDR | CSUM_DATA_VALID;
2656         }
2657 #if 0
2658         /* flowid only valid if RSS hashing is enabled */
2659         if (sc->num_slices > 1) {
2660                 m->m_pkthdr.flowid = (ss - sc->ss);
2661                 m->m_flags |= M_FLOWID;
2662         }
2663 #endif
2664         /* pass the frame up the stack */
2665         (*ifp->if_input)(ifp, m);
2666 }
2667
2668 static inline void
2669 mxge_clean_rx_done(struct mxge_slice_state *ss)
2670 {
2671         mxge_rx_done_t *rx_done = &ss->rx_done;
2672         int limit = 0;
2673         uint16_t length;
2674         uint16_t checksum;
2675
2676
2677         while (rx_done->entry[rx_done->idx].length != 0) {
2678                 length = ntohs(rx_done->entry[rx_done->idx].length);
2679                 rx_done->entry[rx_done->idx].length = 0;
2680                 checksum = rx_done->entry[rx_done->idx].checksum;
2681                 if (length <= (MHLEN - MXGEFW_PAD))
2682                         mxge_rx_done_small(ss, length, checksum);
2683                 else
2684                         mxge_rx_done_big(ss, length, checksum);
2685                 rx_done->cnt++;
2686                 rx_done->idx = rx_done->cnt & rx_done->mask;
2687
2688                 /* limit potential for livelock */
2689                 if (__predict_false(++limit > rx_done->mask / 2))
2690                         break;
2691         }
2692 #ifdef INET
2693         while (!SLIST_EMPTY(&ss->lro_active)) {
2694                 struct lro_entry *lro = SLIST_FIRST(&ss->lro_active);
2695                 SLIST_REMOVE_HEAD(&ss->lro_active, next);
2696                 mxge_lro_flush(ss, lro);
2697         }
2698 #endif
2699 }
2700
2701
2702 static inline void
2703 mxge_tx_done(struct mxge_slice_state *ss, uint32_t mcp_idx)
2704 {
2705         struct ifnet *ifp;
2706         mxge_tx_ring_t *tx;
2707         struct mbuf *m;
2708         bus_dmamap_t map;
2709         int idx;
2710         int *flags;
2711
2712         tx = &ss->tx;
2713         ifp = ss->sc->ifp;
2714         ASSERT_SERIALIZED(ifp->if_serializer);
2715         while (tx->pkt_done != mcp_idx) {
2716                 idx = tx->done & tx->mask;
2717                 tx->done++;
2718                 m = tx->info[idx].m;
2719                 /* mbuf and DMA map only attached to the first
2720                    segment per-mbuf */
2721                 if (m != NULL) {
2722                         ss->obytes += m->m_pkthdr.len;
2723                         if (m->m_flags & M_MCAST)
2724                                 ss->omcasts++;
2725                         ss->opackets++;
2726                         tx->info[idx].m = NULL;
2727                         map = tx->info[idx].map;
2728                         bus_dmamap_unload(tx->dmat, map);
2729                         m_freem(m);
2730                 }
2731                 if (tx->info[idx].flag) {
2732                         tx->info[idx].flag = 0;
2733                         tx->pkt_done++;
2734                 }
2735         }
2736         
2737         /* If we have space, clear IFF_OACTIVE to tell the stack that
2738            its OK to send packets */
2739 #ifdef IFNET_BUF_RING
2740         flags = &ss->if_flags;
2741 #else
2742         flags = &ifp->if_flags;
2743 #endif
2744         if ((*flags) & IFF_OACTIVE &&
2745             tx->req - tx->done < (tx->mask + 1)/4) {
2746                 *(flags) &= ~IFF_OACTIVE;
2747                 ss->tx.wake++;
2748                 mxge_start_locked(ss);
2749         }
2750 #ifdef IFNET_BUF_RING
2751         if ((ss->sc->num_slices > 1) && (tx->req == tx->done)) {
2752                 /* let the NIC stop polling this queue, since there
2753                  * are no more transmits pending */
2754                 if (tx->req == tx->done) {
2755                         *tx->send_stop = 1;
2756                         tx->queue_active = 0;
2757                         tx->deactivate++;
2758                         wmb();
2759                 }
2760         }
2761 #endif
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         ASSERT_SERIALIZED(sc->ifp->if_serializer);
3517         /* Copy the MAC address in case it was overridden */
3518         bcopy(IF_LLADDR(sc->ifp), sc->mac_addr, ETHER_ADDR_LEN);
3519
3520         err = mxge_reset(sc, 1);
3521         if (err != 0) {
3522                 device_printf(sc->dev, "failed to reset\n");
3523                 return EIO;
3524         }
3525
3526         if (sc->num_slices > 1) {
3527                 /* setup the indirection table */
3528                 cmd.data0 = sc->num_slices;
3529                 err = mxge_send_cmd(sc, MXGEFW_CMD_SET_RSS_TABLE_SIZE,
3530                                     &cmd);
3531
3532                 err |= mxge_send_cmd(sc, MXGEFW_CMD_GET_RSS_TABLE_OFFSET,
3533                                      &cmd);
3534                 if (err != 0) {
3535                         device_printf(sc->dev,
3536                                       "failed to setup rss tables\n");
3537                         return err;
3538                 }
3539
3540                 /* just enable an identity mapping */
3541                 itable = sc->sram + cmd.data0;
3542                 for (i = 0; i < sc->num_slices; i++)
3543                         itable[i] = (uint8_t)i;
3544
3545                 cmd.data0 = 1;
3546                 cmd.data1 = mxge_rss_hash_type;
3547                 err = mxge_send_cmd(sc, MXGEFW_CMD_SET_RSS_ENABLE, &cmd);
3548                 if (err != 0) {
3549                         device_printf(sc->dev, "failed to enable slices\n");
3550                         return err;
3551                 }
3552         }
3553
3554
3555         mxge_choose_params(sc->ifp->if_mtu, &big_bytes, &cl_size, &nbufs);
3556
3557         cmd.data0 = nbufs;
3558         err = mxge_send_cmd(sc, MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS,
3559                             &cmd);
3560         /* error is only meaningful if we're trying to set 
3561            MXGEFW_CMD_ALWAYS_USE_N_BIG_BUFFERS > 1 */
3562         if (err && nbufs > 1) {
3563                 device_printf(sc->dev,
3564                               "Failed to set alway-use-n to %d\n",
3565                               nbufs);
3566                 return EIO;
3567         }
3568         /* Give the firmware the mtu and the big and small buffer
3569            sizes.  The firmware wants the big buf size to be a power
3570            of two. Luckily, FreeBSD's clusters are powers of two */
3571         cmd.data0 = sc->ifp->if_mtu + ETHER_HDR_LEN + EVL_ENCAPLEN;
3572         err = mxge_send_cmd(sc, MXGEFW_CMD_SET_MTU, &cmd);
3573         cmd.data0 = MHLEN - MXGEFW_PAD;
3574         err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_SMALL_BUFFER_SIZE,
3575                              &cmd);
3576         cmd.data0 = big_bytes;
3577         err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_BIG_BUFFER_SIZE, &cmd);
3578
3579         if (err != 0) {
3580                 device_printf(sc->dev, "failed to setup params\n");
3581                 goto abort;
3582         }
3583
3584         /* Now give him the pointer to the stats block */
3585         for (slice = 0; 
3586 #ifdef IFNET_BUF_RING
3587              slice < sc->num_slices;
3588 #else
3589              slice < 1;
3590 #endif
3591              slice++) {
3592                 ss = &sc->ss[slice];
3593                 cmd.data0 =
3594                         MXGE_LOWPART_TO_U32(ss->fw_stats_dma.bus_addr);
3595                 cmd.data1 =
3596                         MXGE_HIGHPART_TO_U32(ss->fw_stats_dma.bus_addr);
3597                 cmd.data2 = sizeof(struct mcp_irq_data);
3598                 cmd.data2 |= (slice << 16);
3599                 err |= mxge_send_cmd(sc, MXGEFW_CMD_SET_STATS_DMA_V2, &cmd);
3600         }
3601
3602         if (err != 0) {
3603                 bus = sc->ss->fw_stats_dma.bus_addr;
3604                 bus += offsetof(struct mcp_irq_data, send_done_count);
3605                 cmd.data0 = MXGE_LOWPART_TO_U32(bus);
3606                 cmd.data1 = MXGE_HIGHPART_TO_U32(bus);
3607                 err = mxge_send_cmd(sc,
3608                                     MXGEFW_CMD_SET_STATS_DMA_OBSOLETE,
3609                                     &cmd);
3610                 /* Firmware cannot support multicast without STATS_DMA_V2 */
3611                 sc->fw_multicast_support = 0;
3612         } else {
3613                 sc->fw_multicast_support = 1;
3614         }
3615
3616         if (err != 0) {
3617                 device_printf(sc->dev, "failed to setup params\n");
3618                 goto abort;
3619         }
3620
3621         for (slice = 0; slice < sc->num_slices; slice++) {
3622                 err = mxge_slice_open(&sc->ss[slice], nbufs, cl_size);
3623                 if (err != 0) {
3624                         device_printf(sc->dev, "couldn't open slice %d\n",
3625                                       slice);
3626                         goto abort;
3627                 }
3628         }
3629
3630         /* Finally, start the firmware running */
3631         err = mxge_send_cmd(sc, MXGEFW_CMD_ETHERNET_UP, &cmd);
3632         if (err) {
3633                 device_printf(sc->dev, "Couldn't bring up link\n");
3634                 goto abort;
3635         }
3636 #ifdef IFNET_BUF_RING
3637         for (slice = 0; slice < sc->num_slices; slice++) {
3638                 ss = &sc->ss[slice];
3639                 ss->if_flags |= IFF_RUNNING;
3640                 ss->if_flags &= ~IFF_OACTIVE;
3641         }
3642 #endif
3643         sc->ifp->if_flags |= IFF_RUNNING;
3644         sc->ifp->if_flags &= ~IFF_OACTIVE;
3645         callout_reset(&sc->co_hdl, mxge_ticks, mxge_tick, sc);
3646
3647         return 0;
3648
3649
3650 abort:
3651         mxge_free_mbufs(sc);
3652
3653         return err;
3654 }
3655
3656 static int
3657 mxge_close(mxge_softc_t *sc)
3658 {
3659         mxge_cmd_t cmd;
3660         int err, old_down_cnt;
3661 #ifdef IFNET_BUF_RING
3662         struct mxge_slice_state *ss;    
3663         int slice;
3664 #endif
3665
3666         ASSERT_SERIALIZED(sc->ifp->if_serializer);
3667         callout_stop(&sc->co_hdl);
3668 #ifdef IFNET_BUF_RING
3669         for (slice = 0; slice < sc->num_slices; slice++) {
3670                 ss = &sc->ss[slice];
3671                 ss->if_flags &= ~IFF_RUNNING;
3672         }
3673 #endif
3674         sc->ifp->if_flags &= ~IFF_RUNNING;
3675         old_down_cnt = sc->down_cnt;
3676         wmb();
3677         err = mxge_send_cmd(sc, MXGEFW_CMD_ETHERNET_DOWN, &cmd);
3678         if (err) {
3679                 device_printf(sc->dev, "Couldn't bring down link\n");
3680         }
3681         if (old_down_cnt == sc->down_cnt) {
3682                 /* wait for down irq */
3683                 DELAY(10 * sc->intr_coal_delay);
3684         }
3685         wmb();
3686         if (old_down_cnt == sc->down_cnt) {
3687                 device_printf(sc->dev, "never got down irq\n");
3688         }
3689
3690         mxge_free_mbufs(sc);
3691
3692         return 0;
3693 }
3694
3695 static void
3696 mxge_setup_cfg_space(mxge_softc_t *sc)
3697 {
3698         device_t dev = sc->dev;
3699         int reg;
3700         uint16_t cmd, lnk, pectl;
3701
3702         /* find the PCIe link width and set max read request to 4KB*/
3703         if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
3704                 lnk = pci_read_config(dev, reg + 0x12, 2);
3705                 sc->link_width = (lnk >> 4) & 0x3f;
3706                 
3707                 pectl = pci_read_config(dev, reg + 0x8, 2);
3708                 pectl = (pectl & ~0x7000) | (5 << 12);
3709                 pci_write_config(dev, reg + 0x8, pectl, 2);
3710         }
3711
3712         /* Enable DMA and Memory space access */
3713         pci_enable_busmaster(dev);
3714         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
3715         cmd |= PCIM_CMD_MEMEN;
3716         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
3717 }
3718
3719 static uint32_t
3720 mxge_read_reboot(mxge_softc_t *sc)
3721 {
3722         device_t dev = sc->dev;
3723         uint32_t vs;
3724
3725         /* find the vendor specific offset */
3726         if (pci_find_extcap(dev, PCIY_VENDOR, &vs) != 0) {
3727                 device_printf(sc->dev,
3728                               "could not find vendor specific offset\n");
3729                 return (uint32_t)-1;
3730         }
3731         /* enable read32 mode */
3732         pci_write_config(dev, vs + 0x10, 0x3, 1);
3733         /* tell NIC which register to read */
3734         pci_write_config(dev, vs + 0x18, 0xfffffff0, 4);
3735         return (pci_read_config(dev, vs + 0x14, 4));
3736 }
3737
3738 static int
3739 mxge_watchdog_reset(mxge_softc_t *sc, int slice)
3740 {
3741         struct pci_devinfo *dinfo;
3742         mxge_tx_ring_t *tx;
3743         int err;
3744         uint32_t reboot;
3745         uint16_t cmd;
3746
3747         err = ENXIO;
3748
3749         device_printf(sc->dev, "Watchdog reset!\n");
3750
3751         /* 
3752          * check to see if the NIC rebooted.  If it did, then all of
3753          * PCI config space has been reset, and things like the
3754          * busmaster bit will be zero.  If this is the case, then we
3755          * must restore PCI config space before the NIC can be used
3756          * again
3757          */
3758         cmd = pci_read_config(sc->dev, PCIR_COMMAND, 2);
3759         if (cmd == 0xffff) {
3760                 /* 
3761                  * maybe the watchdog caught the NIC rebooting; wait
3762                  * up to 100ms for it to finish.  If it does not come
3763                  * back, then give up 
3764                  */
3765                 DELAY(1000*100);
3766                 cmd = pci_read_config(sc->dev, PCIR_COMMAND, 2);
3767                 if (cmd == 0xffff) {
3768                         device_printf(sc->dev, "NIC disappeared!\n");
3769                         return (err);
3770                 }
3771         }
3772         if ((cmd & PCIM_CMD_BUSMASTEREN) == 0) {
3773                 /* print the reboot status */
3774                 reboot = mxge_read_reboot(sc);
3775                 device_printf(sc->dev, "NIC rebooted, status = 0x%x\n",
3776                               reboot);
3777                 /* restore PCI configuration space */
3778                 dinfo = device_get_ivars(sc->dev);
3779                 pci_cfg_restore(sc->dev, dinfo);
3780
3781                 /* and redo any changes we made to our config space */
3782                 mxge_setup_cfg_space(sc);
3783
3784                 if (sc->ifp->if_flags & IFF_RUNNING) {
3785                         mxge_close(sc);
3786                         err = mxge_open(sc);
3787                 }
3788         } else {
3789                 tx = &sc->ss[slice].tx;
3790                 device_printf(sc->dev,
3791                               "NIC did not reboot, slice %d ring state:\n",
3792                               slice);
3793                 device_printf(sc->dev,
3794                               "tx.req=%d tx.done=%d, tx.queue_active=%d\n",
3795                               tx->req, tx->done, tx->queue_active);
3796                 device_printf(sc->dev, "tx.activate=%d tx.deactivate=%d\n",
3797                               tx->activate, tx->deactivate);
3798                 device_printf(sc->dev, "pkt_done=%d fw=%d\n",
3799                               tx->pkt_done,
3800                               be32toh(sc->ss->fw_stats->send_done_count));
3801                 device_printf(sc->dev, "not resetting\n");
3802         }
3803         return (err);
3804 }
3805
3806 static int
3807 mxge_watchdog(mxge_softc_t *sc)
3808 {
3809         mxge_tx_ring_t *tx;
3810         uint32_t rx_pause = be32toh(sc->ss->fw_stats->dropped_pause);
3811         int i, err = 0;
3812
3813         /* see if we have outstanding transmits, which
3814            have been pending for more than mxge_ticks */
3815         for (i = 0; 
3816 #ifdef IFNET_BUF_RING
3817              (i < sc->num_slices) && (err == 0);
3818 #else
3819              (i < 1) && (err == 0);
3820 #endif
3821              i++) {
3822                 tx = &sc->ss[i].tx;             
3823                 if (tx->req != tx->done &&
3824                     tx->watchdog_req != tx->watchdog_done &&
3825                     tx->done == tx->watchdog_done) {
3826                         /* check for pause blocking before resetting */
3827                         if (tx->watchdog_rx_pause == rx_pause)
3828                                 err = mxge_watchdog_reset(sc, i);
3829                         else
3830                                 device_printf(sc->dev, "Flow control blocking "
3831                                               "xmits, check link partner\n");
3832                 }
3833
3834                 tx->watchdog_req = tx->req;
3835                 tx->watchdog_done = tx->done;
3836                 tx->watchdog_rx_pause = rx_pause;
3837         }
3838
3839         if (sc->need_media_probe)
3840                 mxge_media_probe(sc);
3841         return (err);
3842 }
3843
3844 static void
3845 mxge_update_stats(mxge_softc_t *sc)
3846 {
3847         struct mxge_slice_state *ss;
3848         u_long ipackets = 0;
3849         u_long opackets = 0;
3850 #ifdef IFNET_BUF_RING
3851         u_long obytes = 0;
3852         u_long omcasts = 0;
3853         u_long odrops = 0;
3854 #endif
3855         u_long oerrors = 0;
3856         int slice;
3857
3858         for (slice = 0; slice < sc->num_slices; slice++) {
3859                 ss = &sc->ss[slice];
3860                 ipackets += ss->ipackets;
3861                 opackets += ss->opackets;
3862 #ifdef IFNET_BUF_RING
3863                 obytes += ss->obytes;
3864                 omcasts += ss->omcasts;
3865                 odrops += ss->tx.br->br_drops;
3866 #endif
3867                 oerrors += ss->oerrors;
3868         }
3869         sc->ifp->if_ipackets = ipackets;
3870         sc->ifp->if_opackets = opackets;
3871 #ifdef IFNET_BUF_RING
3872         sc->ifp->if_obytes = obytes;
3873         sc->ifp->if_omcasts = omcasts;
3874         sc->ifp->if_snd.ifq_drops = odrops;
3875 #endif
3876         sc->ifp->if_oerrors = oerrors;
3877 }
3878
3879 static void
3880 mxge_tick(void *arg)
3881 {
3882         mxge_softc_t *sc = arg;
3883         int err = 0;
3884
3885         lwkt_serialize_enter(sc->ifp->if_serializer);
3886         /* aggregate stats from different slices */
3887         mxge_update_stats(sc);
3888         if (!sc->watchdog_countdown) {
3889                 err = mxge_watchdog(sc);
3890                 sc->watchdog_countdown = 4;
3891         }
3892         sc->watchdog_countdown--;
3893         if (err == 0)
3894                 callout_reset(&sc->co_hdl, mxge_ticks, mxge_tick, sc);
3895         lwkt_serialize_exit(sc->ifp->if_serializer);
3896 }
3897
3898 static int
3899 mxge_media_change(struct ifnet *ifp)
3900 {
3901         return EINVAL;
3902 }
3903
3904 static int
3905 mxge_change_mtu(mxge_softc_t *sc, int mtu)
3906 {
3907         struct ifnet *ifp = sc->ifp;
3908         int real_mtu, old_mtu;