Deleted Added
sdiff udiff text old ( 175389 ) new ( 176472 )
full compact
cxgb_main.c (175389) cxgb_main.c (176472)
1/**************************************************************************
2
3Copyright (c) 2007, Chelsio Inc.
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are met:
8

--- 14 unchanged lines hidden (view full) ---

23INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26POSSIBILITY OF SUCH DAMAGE.
27
28***************************************************************************/
29
30#include <sys/cdefs.h>
1/**************************************************************************
2
3Copyright (c) 2007, Chelsio Inc.
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are met:
8

--- 14 unchanged lines hidden (view full) ---

23INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26POSSIBILITY OF SUCH DAMAGE.
27
28***************************************************************************/
29
30#include <sys/cdefs.h>
31__FBSDID("$FreeBSD: head/sys/dev/cxgb/cxgb_main.c 175389 2008-01-16 21:33:34Z kmacy $");
31__FBSDID("$FreeBSD: head/sys/dev/cxgb/cxgb_main.c 176472 2008-02-23 01:06:17Z kmacy $");
32
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/bus.h>
37#include <sys/module.h>
38#include <sys/pciio.h>
39#include <sys/conf.h>
40#include <machine/bus.h>
41#include <machine/resource.h>
42#include <sys/bus_dma.h>
32
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/bus.h>
37#include <sys/module.h>
38#include <sys/pciio.h>
39#include <sys/conf.h>
40#include <machine/bus.h>
41#include <machine/resource.h>
42#include <sys/bus_dma.h>
43#include <sys/ktr.h>
43#include <sys/rman.h>
44#include <sys/ioccom.h>
45#include <sys/mbuf.h>
46#include <sys/linker.h>
47#include <sys/firmware.h>
48#include <sys/socket.h>
49#include <sys/sockio.h>
50#include <sys/smp.h>

--- 63 unchanged lines hidden (view full) ---

114static void cxgb_free(struct adapter *);
115static __inline void reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start,
116 unsigned int end);
117static void cxgb_get_regs(adapter_t *sc, struct ifconf_regs *regs, uint8_t *buf);
118static int cxgb_get_regs_len(void);
119static int offload_open(struct port_info *pi);
120static void touch_bars(device_t dev);
121static int offload_close(struct t3cdev *tdev);
44#include <sys/rman.h>
45#include <sys/ioccom.h>
46#include <sys/mbuf.h>
47#include <sys/linker.h>
48#include <sys/firmware.h>
49#include <sys/socket.h>
50#include <sys/sockio.h>
51#include <sys/smp.h>

--- 63 unchanged lines hidden (view full) ---

115static void cxgb_free(struct adapter *);
116static __inline void reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start,
117 unsigned int end);
118static void cxgb_get_regs(adapter_t *sc, struct ifconf_regs *regs, uint8_t *buf);
119static int cxgb_get_regs_len(void);
120static int offload_open(struct port_info *pi);
121static void touch_bars(device_t dev);
122static int offload_close(struct t3cdev *tdev);
123static void cxgb_link_start(struct port_info *p);
122
123static device_method_t cxgb_controller_methods[] = {
124 DEVMETHOD(device_probe, cxgb_controller_probe),
125 DEVMETHOD(device_attach, cxgb_controller_attach),
126 DEVMETHOD(device_detach, cxgb_controller_detach),
127
128 /* bus interface */
129 DEVMETHOD(bus_print_child, bus_generic_print_child),

--- 146 unchanged lines hidden (view full) ---

276 {PCI_VENDOR_ID_CHELSIO, 0x0031, 3, "T3B20"},
277 {PCI_VENDOR_ID_CHELSIO, 0x0032, 1, "T3B02"},
278 {PCI_VENDOR_ID_CHELSIO, 0x0033, 4, "T3B04"},
279 {0, 0, 0, NULL}
280};
281
282static int set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset);
283
124
125static device_method_t cxgb_controller_methods[] = {
126 DEVMETHOD(device_probe, cxgb_controller_probe),
127 DEVMETHOD(device_attach, cxgb_controller_attach),
128 DEVMETHOD(device_detach, cxgb_controller_detach),
129
130 /* bus interface */
131 DEVMETHOD(bus_print_child, bus_generic_print_child),

--- 146 unchanged lines hidden (view full) ---

278 {PCI_VENDOR_ID_CHELSIO, 0x0031, 3, "T3B20"},
279 {PCI_VENDOR_ID_CHELSIO, 0x0032, 1, "T3B02"},
280 {PCI_VENDOR_ID_CHELSIO, 0x0033, 4, "T3B04"},
281 {0, 0, 0, NULL}
282};
283
284static int set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset);
285
286
287void
288cxgb_log_tcb(struct adapter *sc, unsigned int tid)
289{
290 char buf[TCB_SIZE];
291 uint64_t *tcb = (uint64_t *)buf;
292 int i, error;
293 struct mc7 *mem = &sc->cm;
294
295 error = t3_mc7_bd_read(mem, tid*TCB_SIZE/8, TCB_SIZE/8, tcb);
296 if (error)
297 printf("cxgb_tcb_log failed\n");
298
299 CTR1(KTR_CXGB, "TCB tid=%u", tid);
300 for (i = 0; i < TCB_SIZE / 32; i++) {
301 CTR5(KTR_CXGB, "%1d: %08x %08x %08x %08x",
302 i, (uint32_t)tcb[1], (uint32_t)(tcb[1] >> 32),
303 (uint32_t)tcb[0], (uint32_t)(tcb[0] >> 32));
304 tcb += 2;
305 CTR4(KTR_CXGB, " %08x %08x %08x %08x",
306 (uint32_t)tcb[1], (uint32_t)(tcb[1] >> 32),
307 (uint32_t)tcb[0], (uint32_t)(tcb[0] >> 32));
308 tcb += 2;
309 }
310}
311
284static __inline char
285t3rev2char(struct adapter *adapter)
286{
287 char rev = 'z';
288
289 switch(adapter->params.rev) {
290 case T3_REV_A:
291 rev = 'a';

--- 100 unchanged lines hidden (view full) ---

392 device_t child;
393 const struct adapter_info *ai;
394 struct adapter *sc;
395 int i, error = 0;
396 uint32_t vers;
397 int port_qsets = 1;
398#ifdef MSI_SUPPORTED
399 int msi_needed, reg;
312static __inline char
313t3rev2char(struct adapter *adapter)
314{
315 char rev = 'z';
316
317 switch(adapter->params.rev) {
318 case T3_REV_A:
319 rev = 'a';

--- 100 unchanged lines hidden (view full) ---

420 device_t child;
421 const struct adapter_info *ai;
422 struct adapter *sc;
423 int i, error = 0;
424 uint32_t vers;
425 int port_qsets = 1;
426#ifdef MSI_SUPPORTED
427 int msi_needed, reg;
400#endif
428#endif
429 int must_load = 0;
401 sc = device_get_softc(dev);
402 sc->dev = dev;
403 sc->msi_count = 0;
404 ai = cxgb_get_adapter_info(dev);
405
406 /*
407 * XXX not really related but a recent addition
408 */

--- 20 unchanged lines hidden (view full) ---

429 pci_enable_busmaster(dev);
430 /*
431 * Allocate the registers and make them available to the driver.
432 * The registers that we care about for NIC mode are in BAR 0
433 */
434 sc->regs_rid = PCIR_BAR(0);
435 if ((sc->regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
436 &sc->regs_rid, RF_ACTIVE)) == NULL) {
430 sc = device_get_softc(dev);
431 sc->dev = dev;
432 sc->msi_count = 0;
433 ai = cxgb_get_adapter_info(dev);
434
435 /*
436 * XXX not really related but a recent addition
437 */

--- 20 unchanged lines hidden (view full) ---

458 pci_enable_busmaster(dev);
459 /*
460 * Allocate the registers and make them available to the driver.
461 * The registers that we care about for NIC mode are in BAR 0
462 */
463 sc->regs_rid = PCIR_BAR(0);
464 if ((sc->regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
465 &sc->regs_rid, RF_ACTIVE)) == NULL) {
437 device_printf(dev, "Cannot allocate BAR\n");
466 device_printf(dev, "Cannot allocate BAR region 0\n");
438 return (ENXIO);
439 }
467 return (ENXIO);
468 }
469 sc->udbs_rid = PCIR_BAR(2);
470 if ((sc->udbs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
471 &sc->udbs_rid, RF_ACTIVE)) == NULL) {
472 device_printf(dev, "Cannot allocate BAR region 1\n");
473 error = ENXIO;
474 goto out;
475 }
440
441 snprintf(sc->lockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb controller lock %d",
442 device_get_unit(dev));
443 ADAPTER_LOCK_INIT(sc, sc->lockbuf);
444
445 snprintf(sc->reglockbuf, ADAPTER_LOCK_NAME_LEN, "SGE reg lock %d",
446 device_get_unit(dev));
447 snprintf(sc->mdiolockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb mdio lock %d",
448 device_get_unit(dev));
449 snprintf(sc->elmerlockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb elmer lock %d",
450 device_get_unit(dev));
451
476
477 snprintf(sc->lockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb controller lock %d",
478 device_get_unit(dev));
479 ADAPTER_LOCK_INIT(sc, sc->lockbuf);
480
481 snprintf(sc->reglockbuf, ADAPTER_LOCK_NAME_LEN, "SGE reg lock %d",
482 device_get_unit(dev));
483 snprintf(sc->mdiolockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb mdio lock %d",
484 device_get_unit(dev));
485 snprintf(sc->elmerlockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb elmer lock %d",
486 device_get_unit(dev));
487
452 MTX_INIT(&sc->sge.reg_lock, sc->reglockbuf, NULL, MTX_DEF);
488 MTX_INIT(&sc->sge.reg_lock, sc->reglockbuf, NULL, MTX_SPIN);
453 MTX_INIT(&sc->mdio_lock, sc->mdiolockbuf, NULL, MTX_DEF);
454 MTX_INIT(&sc->elmer_lock, sc->elmerlockbuf, NULL, MTX_DEF);
455
456 sc->bt = rman_get_bustag(sc->regs_res);
457 sc->bh = rman_get_bushandle(sc->regs_res);
458 sc->mmio_len = rman_get_size(sc->regs_res);
459
460 if (t3_prep_adapter(sc, ai, 1) < 0) {

--- 68 unchanged lines hidden (view full) ---

529 device_get_nameunit(dev));
530 TASK_INIT(&sc->ext_intr_task, 0, cxgb_ext_intr_handler, sc);
531 TASK_INIT(&sc->tick_task, 0, cxgb_tick_handler, sc);
532
533
534 /* Create a periodic callout for checking adapter status */
535 callout_init(&sc->cxgb_tick_ch, TRUE);
536
489 MTX_INIT(&sc->mdio_lock, sc->mdiolockbuf, NULL, MTX_DEF);
490 MTX_INIT(&sc->elmer_lock, sc->elmerlockbuf, NULL, MTX_DEF);
491
492 sc->bt = rman_get_bustag(sc->regs_res);
493 sc->bh = rman_get_bushandle(sc->regs_res);
494 sc->mmio_len = rman_get_size(sc->regs_res);
495
496 if (t3_prep_adapter(sc, ai, 1) < 0) {

--- 68 unchanged lines hidden (view full) ---

565 device_get_nameunit(dev));
566 TASK_INIT(&sc->ext_intr_task, 0, cxgb_ext_intr_handler, sc);
567 TASK_INIT(&sc->tick_task, 0, cxgb_tick_handler, sc);
568
569
570 /* Create a periodic callout for checking adapter status */
571 callout_init(&sc->cxgb_tick_ch, TRUE);
572
537 if (t3_check_fw_version(sc) != 0) {
573 if (t3_check_fw_version(sc, &must_load) != 0 && must_load) {
538 /*
539 * Warn user that a firmware update will be attempted in init.
540 */
541 device_printf(dev, "firmware needs to be updated to version %d.%d.%d\n",
542 FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO);
543 sc->flags &= ~FW_UPTODATE;
544 } else {
545 sc->flags |= FW_UPTODATE;
546 }
547
574 /*
575 * Warn user that a firmware update will be attempted in init.
576 */
577 device_printf(dev, "firmware needs to be updated to version %d.%d.%d\n",
578 FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO);
579 sc->flags &= ~FW_UPTODATE;
580 } else {
581 sc->flags |= FW_UPTODATE;
582 }
583
548 if (t3_check_tpsram_version(sc) != 0) {
584 if (t3_check_tpsram_version(sc, &must_load) != 0 && must_load) {
549 /*
550 * Warn user that a firmware update will be attempted in init.
551 */
552 device_printf(dev, "SRAM needs to be updated to version %c-%d.%d.%d\n",
553 t3rev2char(sc), TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
554 sc->flags &= ~TPS_UPTODATE;
555 } else {
556 sc->flags |= TPS_UPTODATE;

--- 47 unchanged lines hidden (view full) ---

604 error = t3_get_fw_version(sc, &vers);
605 if (error)
606 goto out;
607
608 snprintf(&sc->fw_version[0], sizeof(sc->fw_version), "%d.%d.%d",
609 G_FW_VERSION_MAJOR(vers), G_FW_VERSION_MINOR(vers),
610 G_FW_VERSION_MICRO(vers));
611
585 /*
586 * Warn user that a firmware update will be attempted in init.
587 */
588 device_printf(dev, "SRAM needs to be updated to version %c-%d.%d.%d\n",
589 t3rev2char(sc), TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
590 sc->flags &= ~TPS_UPTODATE;
591 } else {
592 sc->flags |= TPS_UPTODATE;

--- 47 unchanged lines hidden (view full) ---

640 error = t3_get_fw_version(sc, &vers);
641 if (error)
642 goto out;
643
644 snprintf(&sc->fw_version[0], sizeof(sc->fw_version), "%d.%d.%d",
645 G_FW_VERSION_MAJOR(vers), G_FW_VERSION_MINOR(vers),
646 G_FW_VERSION_MICRO(vers));
647
648 device_printf(sc->dev, "Firmware Version %s\n", &sc->fw_version[0]);
649 callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc);
612 t3_add_attach_sysctls(sc);
613out:
614 if (error)
615 cxgb_free(sc);
616
617 return (error);
618}
619

--- 9 unchanged lines hidden (view full) ---

629 return (0);
630}
631
632static void
633cxgb_free(struct adapter *sc)
634{
635 int i;
636
650 t3_add_attach_sysctls(sc);
651out:
652 if (error)
653 cxgb_free(sc);
654
655 return (error);
656}
657

--- 9 unchanged lines hidden (view full) ---

667 return (0);
668}
669
670static void
671cxgb_free(struct adapter *sc)
672{
673 int i;
674
637
675 ADAPTER_LOCK(sc);
676 sc->flags |= CXGB_SHUTDOWN;
677 ADAPTER_UNLOCK(sc);
638 cxgb_pcpu_shutdown_threads(sc);
639 ADAPTER_LOCK(sc);
678 cxgb_pcpu_shutdown_threads(sc);
679 ADAPTER_LOCK(sc);
680
640/*
641 * drops the lock
642 */
643 cxgb_down_locked(sc);
644
645#ifdef MSI_SUPPORTED
646 if (sc->flags & (USING_MSI | USING_MSIX)) {
647 device_printf(sc->dev, "releasing msi message(s)\n");
648 pci_release_msi(sc->dev);
649 } else {
650 device_printf(sc->dev, "no msi message to release\n");
651 }
652#endif
653 if (sc->msix_regs_res != NULL) {
654 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->msix_regs_rid,
655 sc->msix_regs_res);
656 }
681/*
682 * drops the lock
683 */
684 cxgb_down_locked(sc);
685
686#ifdef MSI_SUPPORTED
687 if (sc->flags & (USING_MSI | USING_MSIX)) {
688 device_printf(sc->dev, "releasing msi message(s)\n");
689 pci_release_msi(sc->dev);
690 } else {
691 device_printf(sc->dev, "no msi message to release\n");
692 }
693#endif
694 if (sc->msix_regs_res != NULL) {
695 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->msix_regs_rid,
696 sc->msix_regs_res);
697 }
657
658 if (sc->tq != NULL) {
659 taskqueue_drain(sc->tq, &sc->ext_intr_task);
660 taskqueue_drain(sc->tq, &sc->tick_task);
661 }
698
662 t3_sge_deinit_sw(sc);
663 /*
664 * Wait for last callout
665 */
666
667 DELAY(hz*100);
668
669 for (i = 0; i < (sc)->params.nports; ++i) {
670 if (sc->portdev[i] != NULL)
671 device_delete_child(sc->dev, sc->portdev[i]);
672 }
673
674 bus_generic_detach(sc->dev);
699 t3_sge_deinit_sw(sc);
700 /*
701 * Wait for last callout
702 */
703
704 DELAY(hz*100);
705
706 for (i = 0; i < (sc)->params.nports; ++i) {
707 if (sc->portdev[i] != NULL)
708 device_delete_child(sc->dev, sc->portdev[i]);
709 }
710
711 bus_generic_detach(sc->dev);
675 if (sc->tq != NULL)
712 if (sc->tq != NULL) {
676 taskqueue_free(sc->tq);
713 taskqueue_free(sc->tq);
714 sc->tq = NULL;
715 }
716
677 if (is_offload(sc)) {
678 cxgb_adapter_unofld(sc);
679 if (isset(&sc->open_device_map, OFFLOAD_DEVMAP_BIT))
680 offload_close(&sc->tdev);
681 else
682 printf("cxgb_free: DEVMAP_BIT not set\n");
683 } else
684 printf("not offloading set\n");
717 if (is_offload(sc)) {
718 cxgb_adapter_unofld(sc);
719 if (isset(&sc->open_device_map, OFFLOAD_DEVMAP_BIT))
720 offload_close(&sc->tdev);
721 else
722 printf("cxgb_free: DEVMAP_BIT not set\n");
723 } else
724 printf("not offloading set\n");
725
726 if (sc->flags & CXGB_OFLD_INIT)
727 cxgb_offload_deactivate(sc);
685 free(sc->filters, M_DEVBUF);
686 t3_sge_free(sc);
687
688 cxgb_offload_exit();
728 free(sc->filters, M_DEVBUF);
729 t3_sge_free(sc);
730
731 cxgb_offload_exit();
689
732
733 if (sc->udbs_res != NULL)
734 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->udbs_rid,
735 sc->udbs_res);
736
690 if (sc->regs_res != NULL)
691 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->regs_rid,
692 sc->regs_res);
693
694 MTX_DESTROY(&sc->mdio_lock);
695 MTX_DESTROY(&sc->sge.reg_lock);
696 MTX_DESTROY(&sc->elmer_lock);
697 ADAPTER_LOCK_DEINIT(sc);

--- 94 unchanged lines hidden (view full) ---

792 if ((sc->msix_irq_res[k] = bus_alloc_resource_any(
793 sc->dev, SYS_RES_IRQ, &rid,
794 RF_SHAREABLE | RF_ACTIVE)) == NULL) {
795 device_printf(sc->dev, "Cannot allocate "
796 "interrupt for message %d\n", rid);
797 return (EINVAL);
798 }
799 sc->msix_irq_rid[k] = rid;
737 if (sc->regs_res != NULL)
738 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->regs_rid,
739 sc->regs_res);
740
741 MTX_DESTROY(&sc->mdio_lock);
742 MTX_DESTROY(&sc->sge.reg_lock);
743 MTX_DESTROY(&sc->elmer_lock);
744 ADAPTER_LOCK_DEINIT(sc);

--- 94 unchanged lines hidden (view full) ---

839 if ((sc->msix_irq_res[k] = bus_alloc_resource_any(
840 sc->dev, SYS_RES_IRQ, &rid,
841 RF_SHAREABLE | RF_ACTIVE)) == NULL) {
842 device_printf(sc->dev, "Cannot allocate "
843 "interrupt for message %d\n", rid);
844 return (EINVAL);
845 }
846 sc->msix_irq_rid[k] = rid;
800 printf("setting up interrupt for port=%d\n",
801 qs->port->port_id);
802 if (bus_setup_intr(sc->dev, sc->msix_irq_res[k],
803 INTR_MPSAFE|INTR_TYPE_NET,
804#ifdef INTR_FILTERS
805 NULL,
806#endif
807 t3_intr_msix, qs, &sc->msix_intr_tag[k])) {
808 device_printf(sc->dev, "Cannot set up "
809 "interrupt for message %d\n", rid);

--- 13 unchanged lines hidden (view full) ---

823 return (0);
824}
825
826static int
827cxgb_port_probe(device_t dev)
828{
829 struct port_info *p;
830 char buf[80];
847 if (bus_setup_intr(sc->dev, sc->msix_irq_res[k],
848 INTR_MPSAFE|INTR_TYPE_NET,
849#ifdef INTR_FILTERS
850 NULL,
851#endif
852 t3_intr_msix, qs, &sc->msix_intr_tag[k])) {
853 device_printf(sc->dev, "Cannot set up "
854 "interrupt for message %d\n", rid);

--- 13 unchanged lines hidden (view full) ---

868 return (0);
869}
870
871static int
872cxgb_port_probe(device_t dev)
873{
874 struct port_info *p;
875 char buf[80];
831
876 const char *desc;
877
832 p = device_get_softc(dev);
878 p = device_get_softc(dev);
833
834 snprintf(buf, sizeof(buf), "Port %d %s", p->port_id, p->port_type->desc);
879 desc = p->phy.desc;
880 snprintf(buf, sizeof(buf), "Port %d %s", p->port_id, desc);
835 device_set_desc_copy(dev, buf);
836 return (0);
837}
838
839
840static int
841cxgb_makedev(struct port_info *pi)
842{

--- 25 unchanged lines hidden (view full) ---

868
869
870static int
871cxgb_port_attach(device_t dev)
872{
873 struct port_info *p;
874 struct ifnet *ifp;
875 int err, media_flags;
881 device_set_desc_copy(dev, buf);
882 return (0);
883}
884
885
886static int
887cxgb_makedev(struct port_info *pi)
888{

--- 25 unchanged lines hidden (view full) ---

914
915
916static int
917cxgb_port_attach(device_t dev)
918{
919 struct port_info *p;
920 struct ifnet *ifp;
921 int err, media_flags;
922 struct adapter *sc;
876
923
924
877 p = device_get_softc(dev);
925 p = device_get_softc(dev);
878
926 sc = p->adapter;
879 snprintf(p->lockbuf, PORT_NAME_LEN, "cxgb port lock %d:%d",
880 device_get_unit(device_get_parent(dev)), p->port_id);
881 PORT_LOCK_INIT(p, p->lockbuf);
882
883 /* Allocate an ifnet object and set it up */
884 ifp = p->ifp = if_alloc(IFT_ETHER);
885 if (ifp == NULL) {
886 device_printf(dev, "Cannot allocate ifnet\n");

--- 5 unchanged lines hidden (view full) ---

892 */
893 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
894 ifp->if_init = cxgb_init;
895 ifp->if_softc = p;
896 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
897 ifp->if_ioctl = cxgb_ioctl;
898 ifp->if_start = cxgb_start;
899
927 snprintf(p->lockbuf, PORT_NAME_LEN, "cxgb port lock %d:%d",
928 device_get_unit(device_get_parent(dev)), p->port_id);
929 PORT_LOCK_INIT(p, p->lockbuf);
930
931 /* Allocate an ifnet object and set it up */
932 ifp = p->ifp = if_alloc(IFT_ETHER);
933 if (ifp == NULL) {
934 device_printf(dev, "Cannot allocate ifnet\n");

--- 5 unchanged lines hidden (view full) ---

940 */
941 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
942 ifp->if_init = cxgb_init;
943 ifp->if_softc = p;
944 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
945 ifp->if_ioctl = cxgb_ioctl;
946 ifp->if_start = cxgb_start;
947
948#if 0
900#ifdef IFNET_MULTIQUEUE
901 ifp->if_flags |= IFF_MULTIQ;
902 ifp->if_mq_start = cxgb_pcpu_start;
903#endif
949#ifdef IFNET_MULTIQUEUE
950 ifp->if_flags |= IFF_MULTIQ;
951 ifp->if_mq_start = cxgb_pcpu_start;
952#endif
904
953#endif
905 ifp->if_timer = 0; /* Disable ifnet watchdog */
906 ifp->if_watchdog = NULL;
907
908 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
909 IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen);
910 IFQ_SET_READY(&ifp->if_snd);
911
912 ifp->if_hwassist = ifp->if_capabilities = ifp->if_capenable = 0;

--- 16 unchanged lines hidden (view full) ---

929 if (p->adapter->params.nports <= 2)
930 ifp->if_mtu = 9000;
931 if ((err = cxgb_makedev(p)) != 0) {
932 printf("makedev failed %d\n", err);
933 return (err);
934 }
935 ifmedia_init(&p->media, IFM_IMASK, cxgb_media_change,
936 cxgb_media_status);
954 ifp->if_timer = 0; /* Disable ifnet watchdog */
955 ifp->if_watchdog = NULL;
956
957 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
958 IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen);
959 IFQ_SET_READY(&ifp->if_snd);
960
961 ifp->if_hwassist = ifp->if_capabilities = ifp->if_capenable = 0;

--- 16 unchanged lines hidden (view full) ---

978 if (p->adapter->params.nports <= 2)
979 ifp->if_mtu = 9000;
980 if ((err = cxgb_makedev(p)) != 0) {
981 printf("makedev failed %d\n", err);
982 return (err);
983 }
984 ifmedia_init(&p->media, IFM_IMASK, cxgb_media_change,
985 cxgb_media_status);
937
938 if (!strcmp(p->port_type->desc, "10GBASE-CX4")) {
986
987 if (!strcmp(p->phy.desc, "10GBASE-CX4")) {
939 media_flags = IFM_ETHER | IFM_10G_CX4 | IFM_FDX;
988 media_flags = IFM_ETHER | IFM_10G_CX4 | IFM_FDX;
940 } else if (!strcmp(p->port_type->desc, "10GBASE-SR")) {
989 } else if (!strcmp(p->phy.desc, "10GBASE-SR")) {
941 media_flags = IFM_ETHER | IFM_10G_SR | IFM_FDX;
990 media_flags = IFM_ETHER | IFM_10G_SR | IFM_FDX;
942 } else if (!strcmp(p->port_type->desc, "10GBASE-XR")) {
991 } else if (!strcmp(p->phy.desc, "10GBASE-XR")) {
943 media_flags = IFM_ETHER | IFM_10G_LR | IFM_FDX;
992 media_flags = IFM_ETHER | IFM_10G_LR | IFM_FDX;
944 } else if (!strcmp(p->port_type->desc, "10/100/1000BASE-T")) {
993 } else if (!strcmp(p->phy.desc, "10/100/1000BASE-T")) {
945 ifmedia_add(&p->media, IFM_ETHER | IFM_10_T, 0, NULL);
946 ifmedia_add(&p->media, IFM_ETHER | IFM_10_T | IFM_FDX,
947 0, NULL);
948 ifmedia_add(&p->media, IFM_ETHER | IFM_100_TX,
949 0, NULL);
950 ifmedia_add(&p->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
951 0, NULL);
952 ifmedia_add(&p->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
953 0, NULL);
954 media_flags = 0;
955 } else {
994 ifmedia_add(&p->media, IFM_ETHER | IFM_10_T, 0, NULL);
995 ifmedia_add(&p->media, IFM_ETHER | IFM_10_T | IFM_FDX,
996 0, NULL);
997 ifmedia_add(&p->media, IFM_ETHER | IFM_100_TX,
998 0, NULL);
999 ifmedia_add(&p->media, IFM_ETHER | IFM_100_TX | IFM_FDX,
1000 0, NULL);
1001 ifmedia_add(&p->media, IFM_ETHER | IFM_1000_T | IFM_FDX,
1002 0, NULL);
1003 media_flags = 0;
1004 } else {
956 printf("unsupported media type %s\n", p->port_type->desc);
1005 printf("unsupported media type %s\n", p->phy.desc);
957 return (ENXIO);
958 }
959 if (media_flags) {
960 ifmedia_add(&p->media, media_flags, 0, NULL);
961 ifmedia_set(&p->media, media_flags);
962 } else {
963 ifmedia_add(&p->media, IFM_ETHER | IFM_AUTO, 0, NULL);
964 ifmedia_set(&p->media, IFM_ETHER | IFM_AUTO);

--- 6 unchanged lines hidden (view full) ---

971 p->tq = taskqueue_create(p->taskqbuf, M_NOWAIT,
972 taskqueue_thread_enqueue, &p->tq);
973#else
974 /* Create a port for handling TX without starvation */
975 p->tq = taskqueue_create_fast(p->taskqbuf, M_NOWAIT,
976 taskqueue_thread_enqueue, &p->tq);
977#endif
978 t3_sge_init_port(p);
1006 return (ENXIO);
1007 }
1008 if (media_flags) {
1009 ifmedia_add(&p->media, media_flags, 0, NULL);
1010 ifmedia_set(&p->media, media_flags);
1011 } else {
1012 ifmedia_add(&p->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1013 ifmedia_set(&p->media, IFM_ETHER | IFM_AUTO);

--- 6 unchanged lines hidden (view full) ---

1020 p->tq = taskqueue_create(p->taskqbuf, M_NOWAIT,
1021 taskqueue_thread_enqueue, &p->tq);
1022#else
1023 /* Create a port for handling TX without starvation */
1024 p->tq = taskqueue_create_fast(p->taskqbuf, M_NOWAIT,
1025 taskqueue_thread_enqueue, &p->tq);
1026#endif
1027 t3_sge_init_port(p);
979
1028 cxgb_link_start(p);
1029 t3_link_changed(sc, p->port_id);
980 return (0);
981}
982
983static int
984cxgb_port_detach(device_t dev)
985{
986 struct port_info *p;
987

--- 126 unchanged lines hidden (view full) ---

1114 */
1115void
1116t3_os_link_changed(adapter_t *adapter, int port_id, int link_status, int speed,
1117 int duplex, int fc)
1118{
1119 struct port_info *pi = &adapter->port[port_id];
1120 struct cmac *mac = &adapter->port[port_id].mac;
1121
1030 return (0);
1031}
1032
1033static int
1034cxgb_port_detach(device_t dev)
1035{
1036 struct port_info *p;
1037

--- 126 unchanged lines hidden (view full) ---

1164 */
1165void
1166t3_os_link_changed(adapter_t *adapter, int port_id, int link_status, int speed,
1167 int duplex, int fc)
1168{
1169 struct port_info *pi = &adapter->port[port_id];
1170 struct cmac *mac = &adapter->port[port_id].mac;
1171
1122 if ((pi->ifp->if_flags & IFF_UP) == 0)
1123 return;
1124
1125 if (link_status) {
1126 t3_mac_enable(mac, MAC_DIRECTION_RX);
1127 if_link_state_change(pi->ifp, LINK_STATE_UP);
1128 } else {
1172 if (link_status) {
1173 t3_mac_enable(mac, MAC_DIRECTION_RX);
1174 if_link_state_change(pi->ifp, LINK_STATE_UP);
1175 } else {
1129 if_link_state_change(pi->ifp, LINK_STATE_DOWN);
1130 pi->phy.ops->power_down(&pi->phy, 1);
1131 t3_mac_disable(mac, MAC_DIRECTION_RX);
1132 t3_link_start(&pi->phy, mac, &pi->link_config);
1176 pi->phy.ops->power_down(&pi->phy, 1);
1177 t3_mac_disable(mac, MAC_DIRECTION_RX);
1178 t3_link_start(&pi->phy, mac, &pi->link_config);
1179 if_link_state_change(pi->ifp, LINK_STATE_DOWN);
1133 }
1134}
1135
1136/*
1137 * Interrupt-context handler for external (PHY) interrupts.
1138 */
1139void
1140t3_os_ext_intr_handler(adapter_t *sc)

--- 49 unchanged lines hidden (view full) ---

1190 t3_mac_reset(mac);
1191 t3_mac_set_mtu(mac, ifp->if_mtu + ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
1192 t3_mac_set_address(mac, 0, p->hw_addr);
1193 t3_mac_set_rx_mode(mac, &rm);
1194 t3_link_start(&p->phy, mac, &p->link_config);
1195 t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX);
1196}
1197
1180 }
1181}
1182
1183/*
1184 * Interrupt-context handler for external (PHY) interrupts.
1185 */
1186void
1187t3_os_ext_intr_handler(adapter_t *sc)

--- 49 unchanged lines hidden (view full) ---

1237 t3_mac_reset(mac);
1238 t3_mac_set_mtu(mac, ifp->if_mtu + ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
1239 t3_mac_set_address(mac, 0, p->hw_addr);
1240 t3_mac_set_rx_mode(mac, &rm);
1241 t3_link_start(&p->phy, mac, &p->link_config);
1242 t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX);
1243}
1244
1245
1246static int
1247await_mgmt_replies(struct adapter *adap, unsigned long init_cnt,
1248 unsigned long n)
1249{
1250 int attempts = 5;
1251
1252 while (adap->sge.qs[0].rspq.offload_pkts < init_cnt + n) {
1253 if (!--attempts)
1254 return (ETIMEDOUT);
1255 t3_os_sleep(10);
1256 }
1257 return 0;
1258}
1259
1260static int
1261init_tp_parity(struct adapter *adap)
1262{
1263 int i;
1264 struct mbuf *m;
1265 struct cpl_set_tcb_field *greq;
1266 unsigned long cnt = adap->sge.qs[0].rspq.offload_pkts;
1267
1268 t3_tp_set_offload_mode(adap, 1);
1269
1270 for (i = 0; i < 16; i++) {
1271 struct cpl_smt_write_req *req;
1272
1273 m = m_gethdr(M_WAITOK, MT_DATA);
1274 req = mtod(m, struct cpl_smt_write_req *);
1275 m->m_len = m->m_pkthdr.len = sizeof(*req);
1276 memset(req, 0, sizeof(*req));
1277 req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1278 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SMT_WRITE_REQ, i));
1279 req->iff = i;
1280 t3_mgmt_tx(adap, m);
1281 }
1282
1283 for (i = 0; i < 2048; i++) {
1284 struct cpl_l2t_write_req *req;
1285
1286 m = m_gethdr(M_WAITOK, MT_DATA);
1287 req = mtod(m, struct cpl_l2t_write_req *);
1288 m->m_len = m->m_pkthdr.len = sizeof(*req);
1289 memset(req, 0, sizeof(*req));
1290 req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1291 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ, i));
1292 req->params = htonl(V_L2T_W_IDX(i));
1293 t3_mgmt_tx(adap, m);
1294 }
1295
1296 for (i = 0; i < 2048; i++) {
1297 struct cpl_rte_write_req *req;
1298
1299 m = m_gethdr(M_WAITOK, MT_DATA);
1300 req = mtod(m, struct cpl_rte_write_req *);
1301 m->m_len = m->m_pkthdr.len = sizeof(*req);
1302 memset(req, 0, sizeof(*req));
1303 req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1304 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_RTE_WRITE_REQ, i));
1305 req->l2t_idx = htonl(V_L2T_W_IDX(i));
1306 t3_mgmt_tx(adap, m);
1307 }
1308
1309 m = m_gethdr(M_WAITOK, MT_DATA);
1310 greq = mtod(m, struct cpl_set_tcb_field *);
1311 m->m_len = m->m_pkthdr.len = sizeof(*greq);
1312 memset(greq, 0, sizeof(*greq));
1313 greq->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1314 OPCODE_TID(greq) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, 0));
1315 greq->mask = htobe64(1);
1316 t3_mgmt_tx(adap, m);
1317
1318 i = await_mgmt_replies(adap, cnt, 16 + 2048 + 2048 + 1);
1319 t3_tp_set_offload_mode(adap, 0);
1320 return (i);
1321}
1322
1198/**
1199 * setup_rss - configure Receive Side Steering (per-queue connection demux)
1200 * @adap: the adapter
1201 *
1202 * Sets up RSS to distribute packets to multiple receive queues. We
1203 * configure the RSS CPU lookup table to distribute to the number of HW
1204 * receive queues, and the response queue lookup table to narrow that
1205 * down to the response queues actually configured for each port.

--- 13 unchanged lines hidden (view full) ---

1219 cpus[SGE_QSETS] = 0xff;
1220
1221 nq[0] = nq[1] = 0;
1222 for_each_port(adap, i) {
1223 const struct port_info *pi = adap2pinfo(adap, i);
1224
1225 nq[pi->tx_chan] += pi->nqsets;
1226 }
1323/**
1324 * setup_rss - configure Receive Side Steering (per-queue connection demux)
1325 * @adap: the adapter
1326 *
1327 * Sets up RSS to distribute packets to multiple receive queues. We
1328 * configure the RSS CPU lookup table to distribute to the number of HW
1329 * receive queues, and the response queue lookup table to narrow that
1330 * down to the response queues actually configured for each port.

--- 13 unchanged lines hidden (view full) ---

1344 cpus[SGE_QSETS] = 0xff;
1345
1346 nq[0] = nq[1] = 0;
1347 for_each_port(adap, i) {
1348 const struct port_info *pi = adap2pinfo(adap, i);
1349
1350 nq[pi->tx_chan] += pi->nqsets;
1351 }
1227 nq[0] = max(nq[0], 1U);
1228 nq[1] = max(nq[1], 1U);
1229 for (i = 0; i < RSS_TABLE_SIZE / 2; ++i) {
1352 for (i = 0; i < RSS_TABLE_SIZE / 2; ++i) {
1230 rspq_map[i] = i % nq[0];
1231 rspq_map[i + RSS_TABLE_SIZE / 2] = (i % nq[1]) + nq[0];
1353 rspq_map[i] = nq[0] ? i % nq[0] : 0;
1354 rspq_map[i + RSS_TABLE_SIZE / 2] = nq[1] ? i % nq[1] + nq[0] : 0;
1232 }
1233 /* Calculate the reverse RSS map table */
1234 for (i = 0; i < RSS_TABLE_SIZE; ++i)
1235 if (adap->rrss_map[rspq_map[i]] == 0xff)
1236 adap->rrss_map[rspq_map[i]] = i;
1237
1238 t3_config_rss(adap, F_RQFEEDBACKENABLE | F_TNLLKPEN | F_TNLMAPEN |
1239 F_TNLPRTEN | F_TNL2TUPEN | F_TNL4TUPEN | F_OFDMAPEN |
1355 }
1356 /* Calculate the reverse RSS map table */
1357 for (i = 0; i < RSS_TABLE_SIZE; ++i)
1358 if (adap->rrss_map[rspq_map[i]] == 0xff)
1359 adap->rrss_map[rspq_map[i]] = i;
1360
1361 t3_config_rss(adap, F_RQFEEDBACKENABLE | F_TNLLKPEN | F_TNLMAPEN |
1362 F_TNLPRTEN | F_TNL2TUPEN | F_TNL4TUPEN | F_OFDMAPEN |
1240 V_RRCPLCPUSIZE(6), cpus, rspq_map);
1363 F_RRCPLMAPEN | V_RRCPLCPUSIZE(6) | F_HASHTOEPLITZ,
1364 cpus, rspq_map);
1241
1242}
1243
1244/*
1245 * Sends an mbuf to an offload queue driver
1246 * after dealing with any active network taps.
1247 */
1248static inline int

--- 216 unchanged lines hidden (view full) ---

1465 goto out;
1466 if ((sc->flags & TPS_UPTODATE) == 0)
1467 if ((err = update_tpsram(sc)))
1468 goto out;
1469 err = t3_init_hw(sc, 0);
1470 if (err)
1471 goto out;
1472
1365
1366}
1367
1368/*
1369 * Sends an mbuf to an offload queue driver
1370 * after dealing with any active network taps.
1371 */
1372static inline int

--- 216 unchanged lines hidden (view full) ---

1589 goto out;
1590 if ((sc->flags & TPS_UPTODATE) == 0)
1591 if ((err = update_tpsram(sc)))
1592 goto out;
1593 err = t3_init_hw(sc, 0);
1594 if (err)
1595 goto out;
1596
1597 t3_set_reg_field(sc, A_TP_PARA_REG5, 0, F_RXDDPOFFINIT);
1473 t3_write_reg(sc, A_ULPRX_TDDP_PSZ, V_HPZ0(PAGE_SHIFT - 12));
1474
1475 err = setup_sge_qsets(sc);
1476 if (err)
1477 goto out;
1478
1479 setup_rss(sc);
1480 t3_add_configured_sysctls(sc);

--- 24 unchanged lines hidden (view full) ---

1505 }
1506 } else {
1507 cxgb_setup_msix(sc, sc->msi_count);
1508 }
1509
1510 t3_sge_start(sc);
1511 t3_intr_enable(sc);
1512
1598 t3_write_reg(sc, A_ULPRX_TDDP_PSZ, V_HPZ0(PAGE_SHIFT - 12));
1599
1600 err = setup_sge_qsets(sc);
1601 if (err)
1602 goto out;
1603
1604 setup_rss(sc);
1605 t3_add_configured_sysctls(sc);

--- 24 unchanged lines hidden (view full) ---

1630 }
1631 } else {
1632 cxgb_setup_msix(sc, sc->msi_count);
1633 }
1634
1635 t3_sge_start(sc);
1636 t3_intr_enable(sc);
1637
1638 if (sc->params.rev >= T3_REV_C && !(sc->flags & TP_PARITY_INIT) &&
1639 is_offload(sc) && init_tp_parity(sc) == 0)
1640 sc->flags |= TP_PARITY_INIT;
1641
1642 if (sc->flags & TP_PARITY_INIT) {
1643 t3_write_reg(sc, A_TP_INT_CAUSE,
1644 F_CMCACHEPERR | F_ARPLUTPERR);
1645 t3_write_reg(sc, A_TP_INT_ENABLE, 0x7fbfffff);
1646 }
1647
1648
1513 if (!(sc->flags & QUEUES_BOUND)) {
1649 if (!(sc->flags & QUEUES_BOUND)) {
1514 printf("bind qsets\n");
1515 bind_qsets(sc);
1516 sc->flags |= QUEUES_BOUND;
1517 }
1518out:
1519 return (err);
1520irq_err:
1521 CH_ERR(sc, "request_irq failed, err %d\n", err);
1522 goto out;
1523}
1524
1525
1526/*
1527 * Release resources when all the ports and offloading have been stopped.
1528 */
1529static void
1530cxgb_down_locked(struct adapter *sc)
1531{
1650 bind_qsets(sc);
1651 sc->flags |= QUEUES_BOUND;
1652 }
1653out:
1654 return (err);
1655irq_err:
1656 CH_ERR(sc, "request_irq failed, err %d\n", err);
1657 goto out;
1658}
1659
1660
1661/*
1662 * Release resources when all the ports and offloading have been stopped.
1663 */
1664static void
1665cxgb_down_locked(struct adapter *sc)
1666{
1532 int i;
1533
1534 t3_sge_stop(sc);
1535 t3_intr_disable(sc);
1536
1537 if (sc->intr_tag != NULL) {
1538 bus_teardown_intr(sc->dev, sc->irq_res, sc->intr_tag);
1539 sc->intr_tag = NULL;
1540 }
1541 if (sc->irq_res != NULL) {
1542 device_printf(sc->dev, "de-allocating interrupt irq_rid=%d irq_res=%p\n",
1543 sc->irq_rid, sc->irq_res);
1544 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid,
1545 sc->irq_res);
1546 sc->irq_res = NULL;
1547 }
1548
1667
1668 t3_sge_stop(sc);
1669 t3_intr_disable(sc);
1670
1671 if (sc->intr_tag != NULL) {
1672 bus_teardown_intr(sc->dev, sc->irq_res, sc->intr_tag);
1673 sc->intr_tag = NULL;
1674 }
1675 if (sc->irq_res != NULL) {
1676 device_printf(sc->dev, "de-allocating interrupt irq_rid=%d irq_res=%p\n",
1677 sc->irq_rid, sc->irq_res);
1678 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid,
1679 sc->irq_res);
1680 sc->irq_res = NULL;
1681 }
1682
1549 if (sc->flags & USING_MSIX)
1683 if (sc->flags & USING_MSIX)
1550 cxgb_teardown_msix(sc);
1684 cxgb_teardown_msix(sc);
1551 ADAPTER_UNLOCK(sc);
1552
1685
1553 callout_stop(&sc->cxgb_tick_ch);
1554 callout_stop(&sc->sge_timer_ch);
1555 callout_drain(&sc->cxgb_tick_ch);
1556 callout_drain(&sc->sge_timer_ch);
1557
1558 if (sc->tq != NULL) {
1686 callout_stop(&sc->cxgb_tick_ch);
1687 callout_stop(&sc->sge_timer_ch);
1688 callout_drain(&sc->cxgb_tick_ch);
1689 callout_drain(&sc->sge_timer_ch);
1690
1691 if (sc->tq != NULL) {
1692 printf("draining slow intr\n");
1693
1559 taskqueue_drain(sc->tq, &sc->slow_intr_task);
1694 taskqueue_drain(sc->tq, &sc->slow_intr_task);
1560 for (i = 0; i < sc->params.nports; i++)
1561 taskqueue_drain(sc->tq, &sc->port[i].timer_reclaim_task);
1695 printf("draining ext intr\n");
1696 taskqueue_drain(sc->tq, &sc->ext_intr_task);
1697 printf("draining tick task\n");
1698 taskqueue_drain(sc->tq, &sc->tick_task);
1562 }
1699 }
1700 ADAPTER_UNLOCK(sc);
1563}
1564
1565static int
1566offload_open(struct port_info *pi)
1567{
1568 struct adapter *adapter = pi->adapter;
1569 struct t3cdev *tdev = &adapter->tdev;
1570#ifdef notyet
1571 T3CDEV(pi->ifp);
1572#endif
1573 int adap_up = adapter->open_device_map & PORT_MASK;
1574 int err = 0;
1575
1701}
1702
1703static int
1704offload_open(struct port_info *pi)
1705{
1706 struct adapter *adapter = pi->adapter;
1707 struct t3cdev *tdev = &adapter->tdev;
1708#ifdef notyet
1709 T3CDEV(pi->ifp);
1710#endif
1711 int adap_up = adapter->open_device_map & PORT_MASK;
1712 int err = 0;
1713
1576 printf("device_map=0x%x\n", adapter->open_device_map);
1714 CTR1(KTR_CXGB, "device_map=0x%x", adapter->open_device_map);
1577 if (atomic_cmpset_int(&adapter->open_device_map,
1578 (adapter->open_device_map & ~(1<<OFFLOAD_DEVMAP_BIT)),
1579 (adapter->open_device_map | (1<<OFFLOAD_DEVMAP_BIT))) == 0)
1580 return (0);
1581
1582
1583 if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT))
1584 printf("offload_open: DEVMAP_BIT did not get set 0x%x\n", adapter->open_device_map);

--- 30 unchanged lines hidden (view full) ---

1615 return (err);
1616}
1617
1618static int
1619offload_close(struct t3cdev *tdev)
1620{
1621 struct adapter *adapter = tdev2adap(tdev);
1622
1715 if (atomic_cmpset_int(&adapter->open_device_map,
1716 (adapter->open_device_map & ~(1<<OFFLOAD_DEVMAP_BIT)),
1717 (adapter->open_device_map | (1<<OFFLOAD_DEVMAP_BIT))) == 0)
1718 return (0);
1719
1720
1721 if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT))
1722 printf("offload_open: DEVMAP_BIT did not get set 0x%x\n", adapter->open_device_map);

--- 30 unchanged lines hidden (view full) ---

1753 return (err);
1754}
1755
1756static int
1757offload_close(struct t3cdev *tdev)
1758{
1759 struct adapter *adapter = tdev2adap(tdev);
1760
1623 if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT)) {
1624 printf("offload_close: DEVMAP_BIT not set\n");
1625
1761 if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT))
1626 return (0);
1762 return (0);
1627 }
1628
1629 /* Call back all registered clients */
1630 cxgb_remove_clients(tdev);
1631 tdev->lldev = NULL;
1632 cxgb_set_dummy_ops(tdev);
1633 t3_tp_set_offload_mode(adapter, 0);
1634 clrbit(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT);
1635
1636 ADAPTER_LOCK(adapter);
1637 if (!adapter->open_device_map)
1638 cxgb_down_locked(adapter);
1639 else
1640 ADAPTER_UNLOCK(adapter);
1763
1764 /* Call back all registered clients */
1765 cxgb_remove_clients(tdev);
1766 tdev->lldev = NULL;
1767 cxgb_set_dummy_ops(tdev);
1768 t3_tp_set_offload_mode(adapter, 0);
1769 clrbit(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT);
1770
1771 ADAPTER_LOCK(adapter);
1772 if (!adapter->open_device_map)
1773 cxgb_down_locked(adapter);
1774 else
1775 ADAPTER_UNLOCK(adapter);
1641 cxgb_offload_deactivate(adapter);
1642 return (0);
1643}
1644
1645
1646static void
1647cxgb_init(void *arg)
1648{
1649 struct port_info *p = arg;

--- 25 unchanged lines hidden (view full) ---

1675 setbit(&p->adapter->open_device_map, p->port_id);
1676 ADAPTER_UNLOCK(p->adapter);
1677
1678 if (is_offload(sc) && !ofld_disable) {
1679 err = offload_open(p);
1680 if (err)
1681 log(LOG_WARNING,
1682 "Could not initialize offload capabilities\n");
1776 return (0);
1777}
1778
1779
1780static void
1781cxgb_init(void *arg)
1782{
1783 struct port_info *p = arg;

--- 25 unchanged lines hidden (view full) ---

1809 setbit(&p->adapter->open_device_map, p->port_id);
1810 ADAPTER_UNLOCK(p->adapter);
1811
1812 if (is_offload(sc) && !ofld_disable) {
1813 err = offload_open(p);
1814 if (err)
1815 log(LOG_WARNING,
1816 "Could not initialize offload capabilities\n");
1683 else
1684 printf("offload opened\n");
1685 }
1817 }
1686 cxgb_link_start(p);
1687 t3_link_changed(sc, p->port_id);
1688 ifp->if_baudrate = p->link_config.speed * 1000000;
1689
1690 device_printf(sc->dev, "enabling interrupts on port=%d\n", p->port_id);
1691 t3_port_intr_enable(sc, p->port_id);
1692
1818 ifp->if_baudrate = p->link_config.speed * 1000000;
1819
1820 device_printf(sc->dev, "enabling interrupts on port=%d\n", p->port_id);
1821 t3_port_intr_enable(sc, p->port_id);
1822
1693 callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc);
1694 t3_sge_reset_adapter(sc);
1695
1696 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1697 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1698}
1699
1700static void
1701cxgb_set_rxmode(struct port_info *p)
1702{
1703 struct t3_rx_mode rm;
1704 struct cmac *mac = &p->mac;
1705
1823 t3_sge_reset_adapter(sc);
1824
1825 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1826 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1827}
1828
1829static void
1830cxgb_set_rxmode(struct port_info *p)
1831{
1832 struct t3_rx_mode rm;
1833 struct cmac *mac = &p->mac;
1834
1706 PORT_LOCK_ASSERT_OWNED(p);
1707
1708 t3_init_rx_mode(&rm, p);
1835 t3_init_rx_mode(&rm, p);
1836 mtx_lock(&p->adapter->mdio_lock);
1709 t3_mac_set_rx_mode(mac, &rm);
1837 t3_mac_set_rx_mode(mac, &rm);
1838 mtx_unlock(&p->adapter->mdio_lock);
1710}
1711
1712static void
1713cxgb_stop_locked(struct port_info *p)
1714{
1715 struct ifnet *ifp;
1716
1717 PORT_LOCK_ASSERT_OWNED(p);

--- 22 unchanged lines hidden (view full) ---

1740 int error = 0;
1741
1742 if ((mtu < ETHERMIN) || (mtu > ETHER_MAX_LEN_JUMBO))
1743 error = EINVAL;
1744 else if (ifp->if_mtu != mtu) {
1745 PORT_LOCK(p);
1746 ifp->if_mtu = mtu;
1747 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1839}
1840
1841static void
1842cxgb_stop_locked(struct port_info *p)
1843{
1844 struct ifnet *ifp;
1845
1846 PORT_LOCK_ASSERT_OWNED(p);

--- 22 unchanged lines hidden (view full) ---

1869 int error = 0;
1870
1871 if ((mtu < ETHERMIN) || (mtu > ETHER_MAX_LEN_JUMBO))
1872 error = EINVAL;
1873 else if (ifp->if_mtu != mtu) {
1874 PORT_LOCK(p);
1875 ifp->if_mtu = mtu;
1876 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1748 callout_stop(&p->adapter->cxgb_tick_ch);
1749 cxgb_stop_locked(p);
1750 cxgb_init_locked(p);
1751 }
1752 PORT_UNLOCK(p);
1753 }
1754 return (error);
1755}
1756

--- 9 unchanged lines hidden (view full) ---

1766 /*
1767 * XXX need to check that we aren't in the middle of an unload
1768 */
1769 switch (command) {
1770 case SIOCSIFMTU:
1771 error = cxgb_set_mtu(p, ifr->ifr_mtu);
1772 break;
1773 case SIOCSIFADDR:
1877 cxgb_stop_locked(p);
1878 cxgb_init_locked(p);
1879 }
1880 PORT_UNLOCK(p);
1881 }
1882 return (error);
1883}
1884

--- 9 unchanged lines hidden (view full) ---

1894 /*
1895 * XXX need to check that we aren't in the middle of an unload
1896 */
1897 switch (command) {
1898 case SIOCSIFMTU:
1899 error = cxgb_set_mtu(p, ifr->ifr_mtu);
1900 break;
1901 case SIOCSIFADDR:
1774 case SIOCGIFADDR:
1775 if (ifa->ifa_addr->sa_family == AF_INET) {
1902 if (ifa->ifa_addr->sa_family == AF_INET) {
1776 PORT_LOCK(p);
1777 ifp->if_flags |= IFF_UP;
1903 ifp->if_flags |= IFF_UP;
1778 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1904 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1905 PORT_LOCK(p);
1779 cxgb_init_locked(p);
1906 cxgb_init_locked(p);
1907 PORT_UNLOCK(p);
1908 }
1780 arp_ifinit(ifp, ifa);
1909 arp_ifinit(ifp, ifa);
1781 PORT_UNLOCK(p);
1782 } else
1783 error = ether_ioctl(ifp, command, data);
1784 break;
1785 case SIOCSIFFLAGS:
1910 } else
1911 error = ether_ioctl(ifp, command, data);
1912 break;
1913 case SIOCSIFFLAGS:
1786 callout_drain(&p->adapter->cxgb_tick_ch);
1787 PORT_LOCK(p);
1788 if (ifp->if_flags & IFF_UP) {
1789 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1790 flags = p->if_flags;
1791 if (((ifp->if_flags ^ flags) & IFF_PROMISC) ||
1792 ((ifp->if_flags ^ flags) & IFF_ALLMULTI))
1793 cxgb_set_rxmode(p);
1794 } else
1795 cxgb_init_locked(p);
1796 p->if_flags = ifp->if_flags;
1797 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1798 cxgb_stop_locked(p);
1799
1914 PORT_LOCK(p);
1915 if (ifp->if_flags & IFF_UP) {
1916 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1917 flags = p->if_flags;
1918 if (((ifp->if_flags ^ flags) & IFF_PROMISC) ||
1919 ((ifp->if_flags ^ flags) & IFF_ALLMULTI))
1920 cxgb_set_rxmode(p);
1921 } else
1922 cxgb_init_locked(p);
1923 p->if_flags = ifp->if_flags;
1924 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1925 cxgb_stop_locked(p);
1926
1927 PORT_UNLOCK(p);
1928 break;
1929 case SIOCADDMULTI:
1930 case SIOCDELMULTI:
1800 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1931 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1801 adapter_t *sc = p->adapter;
1802 callout_reset(&sc->cxgb_tick_ch, hz,
1803 cxgb_tick, sc);
1932 cxgb_set_rxmode(p);
1804 }
1933 }
1805 PORT_UNLOCK(p);
1806 break;
1807 case SIOCSIFMEDIA:
1808 case SIOCGIFMEDIA:
1809 error = ifmedia_ioctl(ifp, ifr, &p->media, command);
1810 break;
1811 case SIOCSIFCAP:
1812 PORT_LOCK(p);
1813 mask = ifr->ifr_reqcap ^ ifp->if_capenable;

--- 110 unchanged lines hidden (view full) ---

1924static void
1925check_link_status(adapter_t *sc)
1926{
1927 int i;
1928
1929 for (i = 0; i < (sc)->params.nports; ++i) {
1930 struct port_info *p = &sc->port[i];
1931
1934 break;
1935 case SIOCSIFMEDIA:
1936 case SIOCGIFMEDIA:
1937 error = ifmedia_ioctl(ifp, ifr, &p->media, command);
1938 break;
1939 case SIOCSIFCAP:
1940 PORT_LOCK(p);
1941 mask = ifr->ifr_reqcap ^ ifp->if_capenable;

--- 110 unchanged lines hidden (view full) ---

2052static void
2053check_link_status(adapter_t *sc)
2054{
2055 int i;
2056
2057 for (i = 0; i < (sc)->params.nports; ++i) {
2058 struct port_info *p = &sc->port[i];
2059
1932 if (!(p->port_type->caps & SUPPORTED_IRQ))
2060 if (!(p->phy.caps & SUPPORTED_IRQ))
1933 t3_link_changed(sc, i);
1934 p->ifp->if_baudrate = p->link_config.speed * 1000000;
1935 }
1936}
1937
1938static void
1939check_t3b2_mac(struct adapter *adapter)
1940{
1941 int i;
1942
2061 t3_link_changed(sc, i);
2062 p->ifp->if_baudrate = p->link_config.speed * 1000000;
2063 }
2064}
2065
2066static void
2067check_t3b2_mac(struct adapter *adapter)
2068{
2069 int i;
2070
2071 if(adapter->flags & CXGB_SHUTDOWN)
2072 return;
2073
1943 for_each_port(adapter, i) {
1944 struct port_info *p = &adapter->port[i];
1945 struct ifnet *ifp = p->ifp;
1946 int status;
2074 for_each_port(adapter, i) {
2075 struct port_info *p = &adapter->port[i];
2076 struct ifnet *ifp = p->ifp;
2077 int status;
1947
2078
2079 if(adapter->flags & CXGB_SHUTDOWN)
2080 return;
2081
1948 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1949 continue;
1950
1951 status = 0;
1952 PORT_LOCK(p);
1953 if ((ifp->if_drv_flags & IFF_DRV_RUNNING))
1954 status = t3b2_mac_watchdog_task(&p->mac);
1955 if (status == 1)

--- 13 unchanged lines hidden (view full) ---

1969 PORT_UNLOCK(p);
1970 }
1971}
1972
1973static void
1974cxgb_tick(void *arg)
1975{
1976 adapter_t *sc = (adapter_t *)arg;
2082 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
2083 continue;
2084
2085 status = 0;
2086 PORT_LOCK(p);
2087 if ((ifp->if_drv_flags & IFF_DRV_RUNNING))
2088 status = t3b2_mac_watchdog_task(&p->mac);
2089 if (status == 1)

--- 13 unchanged lines hidden (view full) ---

2103 PORT_UNLOCK(p);
2104 }
2105}
2106
2107static void
2108cxgb_tick(void *arg)
2109{
2110 adapter_t *sc = (adapter_t *)arg;
1977 int i, running = 0;
1978
1979 for_each_port(sc, i) {
1980
1981 struct port_info *p = &sc->port[i];
1982 struct ifnet *ifp = p->ifp;
1983 PORT_LOCK(p);
1984
2111
1985 if ((ifp->if_drv_flags & IFF_DRV_RUNNING))
1986 running = 1;
1987 PORT_UNLOCK(p);
1988 }
1989
1990 if (running == 0)
2112 if(sc->flags & CXGB_SHUTDOWN)
1991 return;
2113 return;
1992
2114
1993 taskqueue_enqueue(sc->tq, &sc->tick_task);
2115 taskqueue_enqueue(sc->tq, &sc->tick_task);
1994
1995 if (sc->open_device_map != 0)
1996 callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc);
2116 callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc);
1997}
1998
1999static void
2000cxgb_tick_handler(void *arg, int count)
2001{
2002 adapter_t *sc = (adapter_t *)arg;
2003 const struct adapter_params *p = &sc->params;
2004
2117}
2118
2119static void
2120cxgb_tick_handler(void *arg, int count)
2121{
2122 adapter_t *sc = (adapter_t *)arg;
2123 const struct adapter_params *p = &sc->params;
2124
2125 if(sc->flags & CXGB_SHUTDOWN)
2126 return;
2127
2005 ADAPTER_LOCK(sc);
2006 if (p->linkpoll_period)
2007 check_link_status(sc);
2008
2009 /*
2128 ADAPTER_LOCK(sc);
2129 if (p->linkpoll_period)
2130 check_link_status(sc);
2131
2132 /*
2010 * adapter lock can currently only be acquire after the
2133 * adapter lock can currently only be acquired after the
2011 * port lock
2012 */
2013 ADAPTER_UNLOCK(sc);
2014
2134 * port lock
2135 */
2136 ADAPTER_UNLOCK(sc);
2137
2015 if (p->rev == T3_REV_B2 && p->nports < 4)
2138 if (p->rev == T3_REV_B2 && p->nports < 4 && sc->open_device_map)
2016 check_t3b2_mac(sc);
2017}
2018
2019static void
2020touch_bars(device_t dev)
2021{
2022 /*
2023 * Don't enable yet

--- 151 unchanged lines hidden (view full) ---

2175 struct ch_reg *edata = (struct ch_reg *)data;
2176 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len)
2177 return (EFAULT);
2178 edata->val = t3_read_reg(sc, edata->addr);
2179 break;
2180 }
2181 case CHELSIO_GET_SGE_CONTEXT: {
2182 struct ch_cntxt *ecntxt = (struct ch_cntxt *)data;
2139 check_t3b2_mac(sc);
2140}
2141
2142static void
2143touch_bars(device_t dev)
2144{
2145 /*
2146 * Don't enable yet

--- 151 unchanged lines hidden (view full) ---

2298 struct ch_reg *edata = (struct ch_reg *)data;
2299 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len)
2300 return (EFAULT);
2301 edata->val = t3_read_reg(sc, edata->addr);
2302 break;
2303 }
2304 case CHELSIO_GET_SGE_CONTEXT: {
2305 struct ch_cntxt *ecntxt = (struct ch_cntxt *)data;
2183 mtx_lock(&sc->sge.reg_lock);
2306 mtx_lock_spin(&sc->sge.reg_lock);
2184 switch (ecntxt->cntxt_type) {
2185 case CNTXT_TYPE_EGRESS:
2186 error = t3_sge_read_ecntxt(sc, ecntxt->cntxt_id,
2187 ecntxt->data);
2188 break;
2189 case CNTXT_TYPE_FL:
2190 error = t3_sge_read_fl(sc, ecntxt->cntxt_id,
2191 ecntxt->data);

--- 5 unchanged lines hidden (view full) ---

2197 case CNTXT_TYPE_CQ:
2198 error = t3_sge_read_cq(sc, ecntxt->cntxt_id,
2199 ecntxt->data);
2200 break;
2201 default:
2202 error = EINVAL;
2203 break;
2204 }
2307 switch (ecntxt->cntxt_type) {
2308 case CNTXT_TYPE_EGRESS:
2309 error = t3_sge_read_ecntxt(sc, ecntxt->cntxt_id,
2310 ecntxt->data);
2311 break;
2312 case CNTXT_TYPE_FL:
2313 error = t3_sge_read_fl(sc, ecntxt->cntxt_id,
2314 ecntxt->data);

--- 5 unchanged lines hidden (view full) ---

2320 case CNTXT_TYPE_CQ:
2321 error = t3_sge_read_cq(sc, ecntxt->cntxt_id,
2322 ecntxt->data);
2323 break;
2324 default:
2325 error = EINVAL;
2326 break;
2327 }
2205 mtx_unlock(&sc->sge.reg_lock);
2328 mtx_unlock_spin(&sc->sge.reg_lock);
2206 break;
2207 }
2208 case CHELSIO_GET_SGE_DESC: {
2209 struct ch_desc *edesc = (struct ch_desc *)data;
2210 int ret;
2211 if (edesc->queue_num >= SGE_QSETS * 6)
2212 return (EINVAL);
2213 ret = t3_get_desc(&sc->sge.qs[edesc->queue_num / 6],
2214 edesc->queue_num % 6, edesc->idx, edesc->data);
2215 if (ret < 0)
2216 return (EINVAL);
2217 edesc->size = ret;
2218 break;
2219 }
2220 case CHELSIO_SET_QSET_PARAMS: {
2221 struct qset_params *q;
2222 struct ch_qset_params *t = (struct ch_qset_params *)data;
2329 break;
2330 }
2331 case CHELSIO_GET_SGE_DESC: {
2332 struct ch_desc *edesc = (struct ch_desc *)data;
2333 int ret;
2334 if (edesc->queue_num >= SGE_QSETS * 6)
2335 return (EINVAL);
2336 ret = t3_get_desc(&sc->sge.qs[edesc->queue_num / 6],
2337 edesc->queue_num % 6, edesc->idx, edesc->data);
2338 if (ret < 0)
2339 return (EINVAL);
2340 edesc->size = ret;
2341 break;
2342 }
2343 case CHELSIO_SET_QSET_PARAMS: {
2344 struct qset_params *q;
2345 struct ch_qset_params *t = (struct ch_qset_params *)data;
2223
2346 int i;
2347
2224 if (t->qset_idx >= SGE_QSETS)
2225 return (EINVAL);
2226 if (!in_range(t->intr_lat, 0, M_NEWTIMER) ||
2227 !in_range(t->cong_thres, 0, 255) ||
2228 !in_range(t->txq_size[0], MIN_TXQ_ENTRIES,
2229 MAX_TXQ_ENTRIES) ||
2230 !in_range(t->txq_size[1], MIN_TXQ_ENTRIES,
2231 MAX_TXQ_ENTRIES) ||
2232 !in_range(t->txq_size[2], MIN_CTRL_TXQ_ENTRIES,
2233 MAX_CTRL_TXQ_ENTRIES) ||
2234 !in_range(t->fl_size[0], MIN_FL_ENTRIES, MAX_RX_BUFFERS) ||
2235 !in_range(t->fl_size[1], MIN_FL_ENTRIES,
2236 MAX_RX_JUMBO_BUFFERS) ||
2237 !in_range(t->rspq_size, MIN_RSPQ_ENTRIES, MAX_RSPQ_ENTRIES))
2238 return (EINVAL);
2348 if (t->qset_idx >= SGE_QSETS)
2349 return (EINVAL);
2350 if (!in_range(t->intr_lat, 0, M_NEWTIMER) ||
2351 !in_range(t->cong_thres, 0, 255) ||
2352 !in_range(t->txq_size[0], MIN_TXQ_ENTRIES,
2353 MAX_TXQ_ENTRIES) ||
2354 !in_range(t->txq_size[1], MIN_TXQ_ENTRIES,
2355 MAX_TXQ_ENTRIES) ||
2356 !in_range(t->txq_size[2], MIN_CTRL_TXQ_ENTRIES,
2357 MAX_CTRL_TXQ_ENTRIES) ||
2358 !in_range(t->fl_size[0], MIN_FL_ENTRIES, MAX_RX_BUFFERS) ||
2359 !in_range(t->fl_size[1], MIN_FL_ENTRIES,
2360 MAX_RX_JUMBO_BUFFERS) ||
2361 !in_range(t->rspq_size, MIN_RSPQ_ENTRIES, MAX_RSPQ_ENTRIES))
2362 return (EINVAL);
2363
2364 if ((sc->flags & FULL_INIT_DONE) && t->lro > 0)
2365 for_each_port(sc, i) {
2366 pi = adap2pinfo(sc, i);
2367 if (t->qset_idx >= pi->first_qset &&
2368 t->qset_idx < pi->first_qset + pi->nqsets
2369#if 0
2370 && !pi->rx_csum_offload
2371#endif
2372 )
2373 return -EINVAL;
2374 }
2239 if ((sc->flags & FULL_INIT_DONE) &&
2240 (t->rspq_size >= 0 || t->fl_size[0] >= 0 ||
2241 t->fl_size[1] >= 0 || t->txq_size[0] >= 0 ||
2242 t->txq_size[1] >= 0 || t->txq_size[2] >= 0 ||
2243 t->polling >= 0 || t->cong_thres >= 0))
2244 return (EBUSY);
2245
2246 q = &sc->params.sge.qset[t->qset_idx];

--- 300 unchanged lines hidden --- 		2375 if ((sc->flags & FULL_INIT_DONE) &&
2376 (t->rspq_size >= 0 || t->fl_size[0] >= 0 ||
2377 t->fl_size[1] >= 0 || t->txq_size[0] >= 0 ||
2378 t->txq_size[1] >= 0 || t->txq_size[2] >= 0 ||
2379 t->polling >= 0 || t->cong_thres >= 0))
2380 return (EBUSY);
2381
2382 q = &sc->params.sge.qset[t->qset_idx];

--- 300 unchanged lines hidden ---