From 87d8fcc80e5c6bb3f11858d9866d3c83b1df896d Mon Sep 17 00:00:00 2001 From: "Pedro F. Giffuni" Date: Tue, 12 Apr 2016 17:23:03 +0000 Subject: Replace 0 with NULL for pointers in misc. device drivers. Found with devel/coccinelle. --- sys/dev/mn/if_mn.c | 14 +++++++------- sys/dev/mpt/mpt_raid.c | 2 +- sys/dev/mrsas/mrsas_ioctl.c | 2 +- sys/dev/mvs/mvs_pci.c | 2 +- sys/dev/mvs/mvs_soc.c | 2 +- sys/dev/nxge/xgehal/xgehal-device.c | 2 +- sys/dev/sound/isa/ad1816.c | 8 ++++---- sys/dev/sound/isa/ess.c | 8 ++++---- sys/dev/sound/isa/mss.c | 14 +++++++------- sys/dev/sound/isa/sb16.c | 8 ++++---- sys/dev/sound/isa/sb8.c | 6 +++--- sys/dev/sound/midi/midi.c | 2 +- sys/dev/sound/pci/als4000.c | 10 +++++----- sys/dev/sound/pci/aureal.c | 6 ++++-- sys/dev/sound/pci/cmi.c | 6 +++--- sys/dev/sound/pci/emu10k1.c | 2 +- sys/dev/sound/pci/emu10kx.c | 2 +- sys/dev/sound/pci/fm801.c | 5 +++-- sys/dev/sound/pci/neomagic.c | 2 +- sys/dev/sound/pci/solo.c | 12 ++++++------ sys/dev/sound/pci/t4dwave.c | 2 +- sys/dev/sound/pci/via8233.c | 2 +- sys/dev/sound/pci/via82c686.c | 4 ++-- sys/dev/vxge/vxgehal/vxgehal-fifo.c | 6 +++--- sys/dev/vxge/vxgehal/vxgehal-mrpcim.c | 2 +- 25 files changed, 67 insertions(+), 64 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/mn/if_mn.c b/sys/dev/mn/if_mn.c index 2f1ea5f40425..0356f53e42a2 100644 --- a/sys/dev/mn/if_mn.c +++ b/sys/dev/mn/if_mn.c @@ -617,7 +617,7 @@ ngmn_rcvdata(hook_p hook, item_p item) mn_free_desc(dp); dp = dp2; } - sc->ch[chan]->xl->vnext = 0; + sc->ch[chan]->xl->vnext = NULL; break; } dp->data = vtophys(m2->m_data); @@ -625,7 +625,7 @@ ngmn_rcvdata(hook_p hook, item_p item) dp->flags += 1; len -= m2->m_len; dp->next = vtophys(dp); - dp->vnext = 0; + dp->vnext = NULL; sc->ch[chan]->xl->next = vtophys(dp); sc->ch[chan]->xl->vnext = dp; sc->ch[chan]->xl = dp; @@ -634,7 +634,7 @@ ngmn_rcvdata(hook_p hook, item_p item) dp->flags |= 0xc0000000; dp2->flags &= ~0x40000000; } else { - dp->m = 0; + dp->m = NULL; m2 = m2->m_next; } } @@ -698,7 +698,7 @@ ngmn_connect(hook_p hook) dp->m = m; dp->flags = 0xc0000000 + (1 << 16); dp->next = vtophys(dp); - dp->vnext = 0; + dp->vnext = NULL; dp->data = vtophys(sc->name); sc->m32_mem.cs[chan].tdesc = vtophys(dp); sc->ch[chan]->x1 = dp; @@ -715,7 +715,7 @@ ngmn_connect(hook_p hook) dp->flags = 0x40000000; dp->flags += 1600 << 16; dp->next = vtophys(dp); - dp->vnext = 0; + dp->vnext = NULL; sc->ch[chan]->rl = dp; for (i = 0; i < (nts + 10); i++) { @@ -1127,7 +1127,7 @@ mn_rx_intr(struct mn_softc *sc, u_int32_t vector) if (vtophys(dp) == sc->m32_mem.crxd[chan]) return; m = dp->m; - dp->m = 0; + dp->m = NULL; m->m_pkthdr.len = m->m_len = (dp->status >> 16) & 0x1fff; err = (dp->status >> 8) & 0xff; if (!err) { @@ -1176,7 +1176,7 @@ mn_rx_intr(struct mn_softc *sc, u_int32_t vector) dp->flags = 0x40000000; dp->flags += 1600 << 16; dp->next = vtophys(dp); - dp->vnext = 0; + dp->vnext = NULL; sc->ch[chan]->rl->next = vtophys(dp); sc->ch[chan]->rl->vnext = dp; sc->ch[chan]->rl->flags &= ~0x40000000; diff --git a/sys/dev/mpt/mpt_raid.c b/sys/dev/mpt/mpt_raid.c index 6b45b5421378..ac65e2f39d9d 100644 --- a/sys/dev/mpt/mpt_raid.c +++ b/sys/dev/mpt/mpt_raid.c @@ -595,7 +595,7 @@ mpt_issue_raid_req(struct mpt_softc *mpt, struct mpt_raid_volume *vol, rap->Function = MPI_FUNCTION_RAID_ACTION; rap->VolumeID = vol->config_page->VolumeID; rap->VolumeBus = vol->config_page->VolumeBus; - if (disk != 0) + if (disk != NULL) rap->PhysDiskNum = disk->config_page.PhysDiskNum; else rap->PhysDiskNum = 0xFF; diff --git a/sys/dev/mrsas/mrsas_ioctl.c b/sys/dev/mrsas/mrsas_ioctl.c index 3c4dbf917cad..6258e634b6e0 100644 --- a/sys/dev/mrsas/mrsas_ioctl.c +++ b/sys/dev/mrsas/mrsas_ioctl.c @@ -86,7 +86,7 @@ mrsas_passthru(struct mrsas_softc *sc, void *arg, u_long ioctlCmd) bus_addr_t ioctl_data_phys_addr[MAX_IOCTL_SGE]; bus_dma_tag_t ioctl_sense_tag = 0; bus_dmamap_t ioctl_sense_dmamap = 0; - void *ioctl_sense_mem = 0; + void *ioctl_sense_mem = NULL; bus_addr_t ioctl_sense_phys_addr = 0; int i, ioctl_data_size = 0, ioctl_sense_size, ret = 0; struct mrsas_sge32 *kern_sge32; diff --git a/sys/dev/mvs/mvs_pci.c b/sys/dev/mvs/mvs_pci.c index b3262f8e3634..798f10794d5c 100644 --- a/sys/dev/mvs/mvs_pci.c +++ b/sys/dev/mvs/mvs_pci.c @@ -316,7 +316,7 @@ mvs_setup_interrupt(device_t dev) device_printf(dev, "unable to setup interrupt\n"); bus_release_resource(dev, SYS_RES_IRQ, ctlr->irq.r_irq_rid, ctlr->irq.r_irq); - ctlr->irq.r_irq = 0; + ctlr->irq.r_irq = NULL; return (ENXIO); } return (0); diff --git a/sys/dev/mvs/mvs_soc.c b/sys/dev/mvs/mvs_soc.c index b34df30b1508..31cdefdfd87d 100644 --- a/sys/dev/mvs/mvs_soc.c +++ b/sys/dev/mvs/mvs_soc.c @@ -287,7 +287,7 @@ mvs_setup_interrupt(device_t dev) device_printf(dev, "unable to setup interrupt\n"); bus_release_resource(dev, SYS_RES_IRQ, ctlr->irq.r_irq_rid, ctlr->irq.r_irq); - ctlr->irq.r_irq = 0; + ctlr->irq.r_irq = NULL; return (ENXIO); } return (0); diff --git a/sys/dev/nxge/xgehal/xgehal-device.c b/sys/dev/nxge/xgehal/xgehal-device.c index 2f52a7e7d74b..10cd5f31041a 100644 --- a/sys/dev/nxge/xgehal/xgehal-device.c +++ b/sys/dev/nxge/xgehal/xgehal-device.c @@ -5571,7 +5571,7 @@ __hal_device_get_vpd_data(xge_hal_device_t *hldev) xge_os_strcpy((char *) hldev->vpd_data.serial_num, "not available"); vpd_data = ( u8*) xge_os_malloc(hldev->pdev, XGE_HAL_VPD_BUFFER_SIZE + 16); - if ( vpd_data == 0 ) + if ( vpd_data == NULL ) return; for (index = 0; index < XGE_HAL_VPD_BUFFER_SIZE; index +=4 ) { diff --git a/sys/dev/sound/isa/ad1816.c b/sys/dev/sound/isa/ad1816.c index 2ae39cf07628..32a7d47779c7 100644 --- a/sys/dev/sound/isa/ad1816.c +++ b/sys/dev/sound/isa/ad1816.c @@ -490,21 +490,21 @@ ad1816_release_resources(struct ad1816_info *ad1816, device_t dev) if (ad1816->ih) bus_teardown_intr(dev, ad1816->irq, ad1816->ih); bus_release_resource(dev, SYS_RES_IRQ, ad1816->irq_rid, ad1816->irq); - ad1816->irq = 0; + ad1816->irq = NULL; } if (ad1816->drq1) { isa_dma_release(rman_get_start(ad1816->drq1)); bus_release_resource(dev, SYS_RES_DRQ, ad1816->drq1_rid, ad1816->drq1); - ad1816->drq1 = 0; + ad1816->drq1 = NULL; } if (ad1816->drq2) { isa_dma_release(rman_get_start(ad1816->drq2)); bus_release_resource(dev, SYS_RES_DRQ, ad1816->drq2_rid, ad1816->drq2); - ad1816->drq2 = 0; + ad1816->drq2 = NULL; } if (ad1816->io_base) { bus_release_resource(dev, SYS_RES_IOPORT, ad1816->io_rid, ad1816->io_base); - ad1816->io_base = 0; + ad1816->io_base = NULL; } if (ad1816->parent_dmat) { bus_dma_tag_destroy(ad1816->parent_dmat); diff --git a/sys/dev/sound/isa/ess.c b/sys/dev/sound/isa/ess.c index e4032de40924..7c1ae3091eab 100644 --- a/sys/dev/sound/isa/ess.c +++ b/sys/dev/sound/isa/ess.c @@ -291,21 +291,21 @@ ess_release_resources(struct ess_info *sc, device_t dev) if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih); bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq); - sc->irq = 0; + sc->irq = NULL; } if (sc->drq1) { isa_dma_release(rman_get_start(sc->drq1)); bus_release_resource(dev, SYS_RES_DRQ, 0, sc->drq1); - sc->drq1 = 0; + sc->drq1 = NULL; } if (sc->drq2) { isa_dma_release(rman_get_start(sc->drq2)); bus_release_resource(dev, SYS_RES_DRQ, 1, sc->drq2); - sc->drq2 = 0; + sc->drq2 = NULL; } if (sc->io_base) { bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->io_base); - sc->io_base = 0; + sc->io_base = NULL; } if (sc->parent_dmat) { bus_dma_tag_destroy(sc->parent_dmat); diff --git a/sys/dev/sound/isa/mss.c b/sys/dev/sound/isa/mss.c index 62f66176425c..4f5548e91ff5 100644 --- a/sys/dev/sound/isa/mss.c +++ b/sys/dev/sound/isa/mss.c @@ -277,7 +277,7 @@ mss_release_resources(struct mss_info *mss, device_t dev) bus_teardown_intr(dev, mss->irq, mss->ih); bus_release_resource(dev, SYS_RES_IRQ, mss->irq_rid, mss->irq); - mss->irq = 0; + mss->irq = NULL; } if (mss->drq2) { if (mss->drq2 != mss->drq1) { @@ -285,28 +285,28 @@ mss_release_resources(struct mss_info *mss, device_t dev) bus_release_resource(dev, SYS_RES_DRQ, mss->drq2_rid, mss->drq2); } - mss->drq2 = 0; + mss->drq2 = NULL; } if (mss->drq1) { isa_dma_release(rman_get_start(mss->drq1)); bus_release_resource(dev, SYS_RES_DRQ, mss->drq1_rid, mss->drq1); - mss->drq1 = 0; + mss->drq1 = NULL; } if (mss->io_base) { bus_release_resource(dev, SYS_RES_IOPORT, mss->io_rid, mss->io_base); - mss->io_base = 0; + mss->io_base = NULL; } if (mss->conf_base) { bus_release_resource(dev, SYS_RES_IOPORT, mss->conf_rid, mss->conf_base); - mss->conf_base = 0; + mss->conf_base = NULL; } if (mss->indir) { bus_release_resource(dev, SYS_RES_IOPORT, mss->indir_rid, mss->indir); - mss->indir = 0; + mss->indir = NULL; } if (mss->parent_dmat) { bus_dma_tag_destroy(mss->parent_dmat); @@ -1686,7 +1686,7 @@ ymf_test(device_t dev, struct mss_info *mss) /* PC98 need this. I don't know reason why. */ bus_delete_resource(dev, SYS_RES_IOPORT, mss->conf_rid); #endif - mss->conf_base = 0; + mss->conf_base = NULL; continue; } version = conf_rd(mss, OPL3SAx_MISC) & 0x07; diff --git a/sys/dev/sound/isa/sb16.c b/sys/dev/sound/isa/sb16.c index 946c6bf5130d..141ea0171750 100644 --- a/sys/dev/sound/isa/sb16.c +++ b/sys/dev/sound/isa/sb16.c @@ -435,23 +435,23 @@ sb16_release_resources(struct sb_info *sb, device_t dev) if (sb->ih) bus_teardown_intr(dev, sb->irq, sb->ih); bus_release_resource(dev, SYS_RES_IRQ, 0, sb->irq); - sb->irq = 0; + sb->irq = NULL; } if (sb->drq2) { if (sb->drq2 != sb->drq1) { isa_dma_release(rman_get_start(sb->drq2)); bus_release_resource(dev, SYS_RES_DRQ, 1, sb->drq2); } - sb->drq2 = 0; + sb->drq2 = NULL; } if (sb->drq1) { isa_dma_release(rman_get_start(sb->drq1)); bus_release_resource(dev, SYS_RES_DRQ, 0, sb->drq1); - sb->drq1 = 0; + sb->drq1 = NULL; } if (sb->io_base) { bus_release_resource(dev, SYS_RES_IOPORT, 0, sb->io_base); - sb->io_base = 0; + sb->io_base = NULL; } if (sb->parent_dmat) { bus_dma_tag_destroy(sb->parent_dmat); diff --git a/sys/dev/sound/isa/sb8.c b/sys/dev/sound/isa/sb8.c index c9ed746e3f41..047e11d255da 100644 --- a/sys/dev/sound/isa/sb8.c +++ b/sys/dev/sound/isa/sb8.c @@ -265,16 +265,16 @@ sb_release_resources(struct sb_info *sb, device_t dev) if (sb->ih) bus_teardown_intr(dev, sb->irq, sb->ih); bus_release_resource(dev, SYS_RES_IRQ, 0, sb->irq); - sb->irq = 0; + sb->irq = NULL; } if (sb->drq) { isa_dma_release(rman_get_start(sb->drq)); bus_release_resource(dev, SYS_RES_DRQ, 0, sb->drq); - sb->drq = 0; + sb->drq = NULL; } if (sb->io_base) { bus_release_resource(dev, SYS_RES_IOPORT, 0, sb->io_base); - sb->io_base = 0; + sb->io_base = NULL; } if (sb->parent_dmat) { bus_dma_tag_destroy(sb->parent_dmat); diff --git a/sys/dev/sound/midi/midi.c b/sys/dev/sound/midi/midi.c index 71f7772e4033..daa34ed3b5dc 100644 --- a/sys/dev/sound/midi/midi.c +++ b/sys/dev/sound/midi/midi.c @@ -1489,7 +1489,7 @@ midi_modevent(module_t mod, int type, void *data) kobj_t midimapper_addseq(void *arg1, int *unit, void **cookie) { - unit = 0; + unit = NULL; return (kobj_t)arg1; } diff --git a/sys/dev/sound/pci/als4000.c b/sys/dev/sound/pci/als4000.c index bb38749aa000..de5952283cdc 100644 --- a/sys/dev/sound/pci/als4000.c +++ b/sys/dev/sound/pci/als4000.c @@ -736,15 +736,15 @@ als_resource_free(device_t dev, struct sc_info *sc) { if (sc->reg) { bus_release_resource(dev, SYS_RES_IOPORT, sc->regid, sc->reg); - sc->reg = 0; + sc->reg = NULL; } if (sc->ih) { bus_teardown_intr(dev, sc->irq, sc->ih); - sc->ih = 0; + sc->ih = NULL; } if (sc->irq) { bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq); - sc->irq = 0; + sc->irq = NULL; } if (sc->parent_dmat) { bus_dma_tag_destroy(sc->parent_dmat); @@ -762,7 +762,7 @@ als_resource_grab(device_t dev, struct sc_info *sc) sc->regid = PCIR_BAR(0); sc->reg = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &sc->regid, RF_ACTIVE); - if (sc->reg == 0) { + if (sc->reg == NULL) { device_printf(dev, "unable to allocate register space\n"); goto bad; } @@ -771,7 +771,7 @@ als_resource_grab(device_t dev, struct sc_info *sc) sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid, RF_ACTIVE | RF_SHAREABLE); - if (sc->irq == 0) { + if (sc->irq == NULL) { device_printf(dev, "unable to allocate interrupt\n"); goto bad; } diff --git a/sys/dev/sound/pci/aureal.c b/sys/dev/sound/pci/aureal.c index f990f4340ecf..f38ba12dacee 100644 --- a/sys/dev/sound/pci/aureal.c +++ b/sys/dev/sound/pci/aureal.c @@ -556,8 +556,8 @@ au_pci_attach(device_t dev) struct resource *reg[10]; int i, j, mapped = 0; int irqid; - struct resource *irq = 0; - void *ih = 0; + struct resource *irq; + void *ih; struct ac97_info *codec; char status[SND_STATUSLEN]; @@ -566,6 +566,8 @@ au_pci_attach(device_t dev) pci_enable_busmaster(dev); + irq = NULL; + ih = NULL; j=0; /* XXX dfr: is this strictly necessary? */ for (i=0; ilock); - sc->mpu_intr = 0; - sc->mpu = 0; + sc->mpu_intr = NULL; + sc->mpu = NULL; snd_mtxunlock(sc->lock); return 0; @@ -902,7 +902,7 @@ cmi_uninit(struct sc_info *sc) cmi_clr4(sc, CMPCI_REG_FUNC_1, CMPCI_REG_UART_ENABLE); if( sc->mpu ) - sc->mpu_intr = 0; + sc->mpu_intr = NULL; } /* ------------------------------------------------------------------------- */ diff --git a/sys/dev/sound/pci/emu10k1.c b/sys/dev/sound/pci/emu10k1.c index f1d77eebd88b..e03127cbddb3 100644 --- a/sys/dev/sound/pci/emu10k1.c +++ b/sys/dev/sound/pci/emu10k1.c @@ -1178,7 +1178,7 @@ emu_muninit(struct mpu401 *arg, void *cookie) struct sc_info *sc = cookie; snd_mtxlock(sc->lock); - sc->mpu_intr = 0; + sc->mpu_intr = NULL; snd_mtxunlock(sc->lock); return 0; diff --git a/sys/dev/sound/pci/emu10kx.c b/sys/dev/sound/pci/emu10kx.c index bd97ab848cff..cb441bbb0b31 100644 --- a/sys/dev/sound/pci/emu10kx.c +++ b/sys/dev/sound/pci/emu10kx.c @@ -2351,7 +2351,7 @@ emu10kx_dev_uninit(struct emu_sc_info *sc) } if (sc->cdev) destroy_dev(sc->cdev); - sc->cdev = 0; + sc->cdev = NULL; mtx_destroy(&sc->emu10kx_lock); return (0); diff --git a/sys/dev/sound/pci/fm801.c b/sys/dev/sound/pci/fm801.c index 252e71482500..c1b6393cd754 100644 --- a/sys/dev/sound/pci/fm801.c +++ b/sys/dev/sound/pci/fm801.c @@ -573,7 +573,7 @@ fm801_init(struct fm801_info *fm801) static int fm801_pci_attach(device_t dev) { - struct ac97_info *codec = 0; + struct ac97_info *codec = NULL; struct fm801_info *fm801; int i; int mapped = 0; @@ -622,7 +622,8 @@ fm801_pci_attach(device_t dev) fm801->irqid = 0; fm801->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &fm801->irqid, RF_ACTIVE | RF_SHAREABLE); - if (!fm801->irq || snd_setup_intr(dev, fm801->irq, 0, fm801_intr, fm801, &fm801->ih)) { + if (!fm801->irq || + snd_setup_intr(dev, fm801->irq, 0, fm801_intr, fm801, &fm801->ih)) { device_printf(dev, "unable to map interrupt\n"); goto oops; } diff --git a/sys/dev/sound/pci/neomagic.c b/sys/dev/sound/pci/neomagic.c index 8a78bf7653f8..e2db543be3a6 100644 --- a/sys/dev/sound/pci/neomagic.c +++ b/sys/dev/sound/pci/neomagic.c @@ -664,7 +664,7 @@ static int nm_pci_attach(device_t dev) { struct sc_info *sc; - struct ac97_info *codec = 0; + struct ac97_info *codec = NULL; char status[SND_STATUSLEN]; sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); diff --git a/sys/dev/sound/pci/solo.c b/sys/dev/sound/pci/solo.c index dc46ac862258..75d1ad41ff47 100644 --- a/sys/dev/sound/pci/solo.c +++ b/sys/dev/sound/pci/solo.c @@ -836,31 +836,31 @@ ess_release_resources(struct ess_info *sc, device_t dev) if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih); bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq); - sc->irq = 0; + sc->irq = NULL; } if (sc->io) { bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->io); - sc->io = 0; + sc->io = NULL; } if (sc->sb) { bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(1), sc->sb); - sc->sb = 0; + sc->sb = NULL; } if (sc->vc) { bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(2), sc->vc); - sc->vc = 0; + sc->vc = NULL; } if (sc->mpu) { bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(3), sc->mpu); - sc->mpu = 0; + sc->mpu = NULL; } if (sc->gp) { bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(4), sc->gp); - sc->gp = 0; + sc->gp = NULL; } if (sc->parent_dmat) { diff --git a/sys/dev/sound/pci/t4dwave.c b/sys/dev/sound/pci/t4dwave.c index 32ddd00b9f01..6530b5b685fa 100644 --- a/sys/dev/sound/pci/t4dwave.c +++ b/sys/dev/sound/pci/t4dwave.c @@ -823,7 +823,7 @@ static int tr_pci_attach(device_t dev) { struct tr_info *tr; - struct ac97_info *codec = 0; + struct ac97_info *codec = NULL; bus_addr_t lowaddr; int i, dacn; char status[SND_STATUSLEN]; diff --git a/sys/dev/sound/pci/via8233.c b/sys/dev/sound/pci/via8233.c index 45fe175ac67d..2bd54e4cb296 100644 --- a/sys/dev/sound/pci/via8233.c +++ b/sys/dev/sound/pci/via8233.c @@ -1164,7 +1164,7 @@ via_chip_init(device_t dev) static int via_attach(device_t dev) { - struct via_info *via = 0; + struct via_info *via = NULL; char status[SND_STATUSLEN]; int i, via_dxs_disabled, via_dxs_src, via_dxs_chnum, via_sgd_chnum; int nsegs; diff --git a/sys/dev/sound/pci/via82c686.c b/sys/dev/sound/pci/via82c686.c index 4484d6e51fca..4c4a4120dd06 100644 --- a/sys/dev/sound/pci/via82c686.c +++ b/sys/dev/sound/pci/via82c686.c @@ -477,7 +477,7 @@ dma_cb(void *p, bus_dma_segment_t *bds, int a, int b) static int via_attach(device_t dev) { - struct via_info *via = 0; + struct via_info *via = NULL; char status[SND_STATUSLEN]; u_int32_t data, cnt; @@ -618,7 +618,7 @@ static int via_detach(device_t dev) { int r; - struct via_info *via = 0; + struct via_info *via = NULL; r = pcm_unregister(dev); if (r) diff --git a/sys/dev/vxge/vxgehal/vxgehal-fifo.c b/sys/dev/vxge/vxgehal/vxgehal-fifo.c index e5f6c7815fff..771f88079978 100644 --- a/sys/dev/vxge/vxgehal/vxgehal-fifo.c +++ b/sys/dev/vxge/vxgehal/vxgehal-fifo.c @@ -1030,7 +1030,7 @@ vxge_hal_fifo_txdl_buffer_set_aligned( ptrdiff_t prev_boff; vxge_assert((vpath_handle != NULL) && (txdlh != NULL) && - (vaddr != 0) && (dma_pointer != 0) && + (vaddr != NULL) && (dma_pointer != 0) && (size != 0) && (misaligned_size != 0)); hldev = vp->vpath->hldev; @@ -1145,8 +1145,8 @@ vxge_hal_fifo_txdl_buffer_append( __hal_fifo_txdl_priv_t *txdl_priv; ptrdiff_t used; - vxge_assert((vpath_handle != NULL) && (txdlh != NULL) && (vaddr != 0) && - (size == 0)); + vxge_assert((vpath_handle != NULL) && (txdlh != NULL) && + (vaddr != NULL) && (size == 0)); hldev = vp->vpath->hldev; diff --git a/sys/dev/vxge/vxgehal/vxgehal-mrpcim.c b/sys/dev/vxge/vxgehal/vxgehal-mrpcim.c index 94337c012479..38527637eb03 100644 --- a/sys/dev/vxge/vxgehal/vxgehal-mrpcim.c +++ b/sys/dev/vxge/vxgehal/vxgehal-mrpcim.c @@ -5613,7 +5613,7 @@ __hal_mrpcim_get_vpd_data(__hal_device_t *hldev) } vpd_data = (u8 *) vxge_os_malloc(hldev->header.pdev, VXGE_HAL_VPD_BUFFER_SIZE + 16); - if (vpd_data == 0) + if (vpd_data == NULL) return; for (i = 0; i < VXGE_HAL_VPD_BUFFER_SIZE; i += 4) { -- cgit v1.3 From b3b4ccc70ae739fa522c908aea868a602d80fd6b Mon Sep 17 00:00:00 2001 From: John Baldwin Date: Tue, 12 Apr 2016 17:44:34 +0000 Subject: Rename the 'M_B' macro in t4_regs.h to 'CXGBE_M_B'. This fixes a conflict with the M_B macro in powerpc's exposed by the recent addition of DDB commands to the cxgbe driver. Discussed with: np Reported by: bz Sponsored by: Chelsio Communications --- sys/dev/cxgbe/common/t4_regs.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/cxgbe/common/t4_regs.h b/sys/dev/cxgbe/common/t4_regs.h index 0525424ebce2..56793b245575 100644 --- a/sys/dev/cxgbe/common/t4_regs.h +++ b/sys/dev/cxgbe/common/t4_regs.h @@ -47301,9 +47301,9 @@ #define A_MAC_PORT_PTP_OFFSET_ADJUST_FINE 0x9a4 #define S_B 16 -#define M_B 0xffffU +#define CXGBE_M_B 0xffffU #define V_B(x) ((x) << S_B) -#define G_B(x) (((x) >> S_B) & M_B) +#define G_B(x) (((x) >> S_B) & CXGBE_M_B) #define S_A 0 #define M_A 0xffffU -- cgit v1.3 From 15219357379b3638caa9f5f539b6768ce24ca63f Mon Sep 17 00:00:00 2001 From: Alexander Motin Date: Tue, 12 Apr 2016 18:50:37 +0000 Subject: Make all CT Pass-Through (name server requests) asynchronous. Previously we had to do it synchronously because we could not drop the lock due to potential scratch memory use conflicts. Previous commits fixed that collision, so here it goes -- slower and less reliable external requests are executed asynchronously without spinning in tight loop and with more safe timeout handling. --- sys/dev/isp/isp.c | 135 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 78 insertions(+), 57 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/isp/isp.c b/sys/dev/isp/isp.c index 88ea7de5ea83..2664d13cf5f3 100644 --- a/sys/dev/isp/isp.c +++ b/sys/dev/isp/isp.c @@ -3078,20 +3078,31 @@ isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay) fcp->isp_fabric_params = mbs.param[7]; fcp->isp_sns_hdl = NPH_SNS_ID; r = isp_register_fc4_type_24xx(isp, chan); - if (r == 0) - isp_register_fc4_features_24xx(isp, chan); - isp_register_port_name_24xx(isp, chan); + if (fcp->isp_loopstate < LOOP_TESTING_LINK) + goto abort; + if (r != 0) + goto not_on_fabric; + r = isp_register_fc4_features_24xx(isp, chan); + if (fcp->isp_loopstate < LOOP_TESTING_LINK) + goto abort; + if (r != 0) + goto not_on_fabric; + r = isp_register_port_name_24xx(isp, chan); + if (fcp->isp_loopstate < LOOP_TESTING_LINK) + goto abort; + if (r != 0) + goto not_on_fabric; isp_register_node_name_24xx(isp, chan); + if (fcp->isp_loopstate < LOOP_TESTING_LINK) + goto abort; } else { fcp->isp_sns_hdl = SNS_ID; r = isp_register_fc4_type(isp, chan); - if (r == 0 && fcp->role == ISP_ROLE_TARGET) + if (r != 0) + goto not_on_fabric; + if (fcp->role == ISP_ROLE_TARGET) isp_send_change_request(isp, chan); } - if (r) { - isp_prt(isp, ISP_LOGWARN|ISP_LOG_SANCFG, "%s: register fc4 type failed", __func__); - return (-1); - } } not_on_fabric: @@ -3505,65 +3516,66 @@ isp_gid_ft_sns(ispsoftc_t *isp, int chan) static int isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt) { - mbreg_t mbs; fcparam *fcp = FCPARAM(isp, chan); - union { - isp_ct_pt_t plocal; - uint8_t q[QENTRY_LEN]; - } un; - isp_ct_pt_t *pt; - uint8_t *scp = fcp->isp_scratch; + isp_ct_pt_t pt; + void *reqp; + uint8_t resp[QENTRY_LEN]; /* * Build a Passthrough IOCB in memory. */ - pt = &un.plocal; - ISP_MEMZERO(un.q, QENTRY_LEN); - pt->ctp_header.rqs_entry_count = 1; - pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU; - pt->ctp_handle = 0xffffffff; - pt->ctp_nphdl = fcp->isp_sns_hdl; - pt->ctp_cmd_cnt = 1; - pt->ctp_vpidx = ISP_GET_VPIDX(isp, chan); - pt->ctp_time = 10; - pt->ctp_rsp_cnt = 1; - pt->ctp_rsp_bcnt = rsp_bcnt; - pt->ctp_cmd_bcnt = cmd_bcnt; - pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF); - pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF); - pt->ctp_dataseg[0].ds_count = cmd_bcnt; - pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma); - pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma); - pt->ctp_dataseg[1].ds_count = rsp_bcnt; - isp_put_ct_pt(isp, pt, (isp_ct_pt_t *)&scp[CTXOFF]); - if (isp->isp_dblev & ISP_LOGDEBUG1) - isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, &scp[CTXOFF]); + ISP_MEMZERO(&pt, sizeof(pt)); + pt.ctp_header.rqs_entry_count = 1; + pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU; + pt.ctp_nphdl = fcp->isp_sns_hdl; + pt.ctp_cmd_cnt = 1; + pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan); + pt.ctp_time = 10; + pt.ctp_rsp_cnt = 1; + pt.ctp_rsp_bcnt = rsp_bcnt; + pt.ctp_cmd_bcnt = cmd_bcnt; + pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF); + pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF); + pt.ctp_dataseg[0].ds_count = cmd_bcnt; + pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma); + pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma); + pt.ctp_dataseg[1].ds_count = rsp_bcnt; - /* - * Execute the Passthrough IOCB. - */ - ISP_MEMZERO(&scp[ZTXOFF], QENTRY_LEN); - MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, - MBCMD_DEFAULT_TIMEOUT + pt->ctp_time * 1000000); - mbs.param[1] = QENTRY_LEN; - mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF); - mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF); - mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF); - mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF); - MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN, chan); - isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + /* Prepare space for response in memory */ + memset(resp, 0xff, sizeof(resp)); + pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL); + if (pt.ctp_handle == 0) { + isp_prt(isp, ISP_LOGERR, + "%s: CTP of Chan %d out of handles", __func__, chan); return (-1); } - MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan); + + /* Send request and wait for response. */ + reqp = isp_getrqentry(isp); + if (reqp == NULL) { + isp_prt(isp, ISP_LOGERR, + "%s: CTP of Chan %d out of rqent", __func__, chan); + isp_destroy_handle(isp, pt.ctp_handle); + return (-1); + } + isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp); if (isp->isp_dblev & ISP_LOGDEBUG1) - isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, &scp[ZTXOFF]); - pt = &un.plocal; - isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt); - if (pt->ctp_status && pt->ctp_status != RQCS_DATA_UNDERRUN) { + isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp); + ISP_SYNC_REQUEST(isp); + if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) { + isp_prt(isp, ISP_LOGERR, + "%s: CTP of Chan %d timed out", __func__, chan); + isp_destroy_handle(isp, pt.ctp_handle); + return (-1); + } + if (isp->isp_dblev & ISP_LOGDEBUG1) + isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp); + + isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt); + if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) { isp_prt(isp, ISP_LOGWARN, "Chan %d GID_FT CT Passthrough returned 0x%x", - chan, pt->ctp_status); + chan, pt.ctp_status); return (-1); } @@ -3931,7 +3943,13 @@ isp_send_change_request(ispsoftc_t *isp, int chan) mbs.param[1] = 0x03; mbs.param[9] = chan; isp_mboxcmd(isp, &mbs); - return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : -1); + if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { + return (0); + } else { + isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x", + chan, mbs.param[0]); + return (-1); + } } static int @@ -3970,6 +3988,8 @@ isp_register_fc4_type(ispsoftc_t *isp, int chan) if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { return (0); } else { + isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", + chan, mbs.param[0]); return (-1); } } @@ -6140,6 +6160,7 @@ isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *opt } } return (1); + case RQSTYPE_CT_PASSTHRU: case RQSTYPE_VP_MODIFY: case RQSTYPE_VP_CTRL: case RQSTYPE_LOGIN: -- cgit v1.3 From b1d459028341bbc5b2f7548f20354a539fc2014b Mon Sep 17 00:00:00 2001 From: David C Somayajulu Date: Tue, 12 Apr 2016 21:00:38 +0000 Subject: 1. Process tx completions in bxe_periodic_callout_func() and restart transmissions if possible. 2. For SIOCSIFFLAGS call bxe_init_locked() only if !BXE_STATE_DISABLED 3. remove code not needed in bxe_init_internal_common() Submitted by:vaishali.kulkarni@qlogic.com;venkata.bhavaraju@qlogic.com Approved by:davidcs@freebsd.org MFC after:5 days --- sys/dev/bxe/bxe.c | 80 +++++++++++++++++++++++++++++++++++-------------- sys/dev/bxe/bxe_stats.h | 6 ++++ 2 files changed, 63 insertions(+), 23 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c index 91a5bf3226d0..2a26ac8593fd 100644 --- a/sys/dev/bxe/bxe.c +++ b/sys/dev/bxe/bxe.c @@ -487,7 +487,9 @@ static const struct { { STATS_OFFSET32(mbuf_alloc_sge), 4, STATS_FLAGS_FUNC, "mbuf_alloc_sge"}, { STATS_OFFSET32(mbuf_alloc_tpa), - 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"} + 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"}, + { STATS_OFFSET32(tx_queue_full_return), + 4, STATS_FLAGS_FUNC, "tx_queue_full_return"} }; static const struct { @@ -598,7 +600,9 @@ static const struct { { Q_STATS_OFFSET32(mbuf_alloc_sge), 4, "mbuf_alloc_sge"}, { Q_STATS_OFFSET32(mbuf_alloc_tpa), - 4, "mbuf_alloc_tpa"} + 4, "mbuf_alloc_tpa"}, + { Q_STATS_OFFSET32(tx_queue_full_return), + 4, "tx_queue_full_return"} }; #define BXE_NUM_ETH_STATS ARRAY_SIZE(bxe_eth_stats_arr) @@ -4619,7 +4623,7 @@ bxe_ioctl(if_t ifp, if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) { /* set the receive mode flags */ bxe_set_rx_mode(sc); - } else { + } else if(sc->state != BXE_STATE_DISABLED) { bxe_init_locked(sc); } } else { @@ -5723,11 +5727,6 @@ bxe_tx_start(if_t ifp) return; } - if (if_getdrvflags(ifp) & IFF_DRV_OACTIVE) { - BLOGW(sc, "Interface TX queue is full, ignoring transmit request\n"); - return; - } - if (!sc->link_vars.link_up) { BLOGW(sc, "Interface link is down, ignoring transmit request\n"); return; @@ -5735,6 +5734,11 @@ bxe_tx_start(if_t ifp) fp = &sc->fp[0]; + if (ifp->if_drv_flags & IFF_DRV_OACTIVE) { + fp->eth_q_stats.tx_queue_full_return++; + return; + } + BXE_FP_TX_LOCK(fp); bxe_tx_start_locked(sc, ifp, fp); BXE_FP_TX_UNLOCK(fp); @@ -9936,21 +9940,6 @@ bxe_init_internal_common(struct bxe_softc *sc) { int i; - if (IS_MF_SI(sc)) { - /* - * In switch independent mode, the TSTORM needs to accept - * packets that failed classification, since approximate match - * mac addresses aren't written to NIG LLH. - */ - REG_WR8(sc, - (BAR_TSTRORM_INTMEM + TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET), - 2); - } else if (!CHIP_IS_E1(sc)) { /* 57710 doesn't support MF */ - REG_WR8(sc, - (BAR_TSTRORM_INTMEM + TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET), - 0); - } - /* * Zero this manually as its initialization is currently missing * in the initTool. @@ -12269,6 +12258,8 @@ static void bxe_periodic_callout_func(void *xsc) { struct bxe_softc *sc = (struct bxe_softc *)xsc; + struct bxe_fastpath *fp; + uint16_t tx_bd_avail; int i; if (!BXE_CORE_TRYLOCK(sc)) { @@ -12291,6 +12282,48 @@ bxe_periodic_callout_func(void *xsc) return; } +#if __FreeBSD_version >= 800000 + + FOR_EACH_QUEUE(sc, i) { + fp = &sc->fp[i]; + + if (BXE_FP_TX_TRYLOCK(fp)) { + if_t ifp = sc->ifp; + /* + * If interface was stopped due to unavailable + * bds, try to process some tx completions + */ + (void) bxe_txeof(sc, fp); + + tx_bd_avail = bxe_tx_avail(sc, fp); + if (tx_bd_avail >= BXE_TX_CLEANUP_THRESHOLD) { + bxe_tx_mq_start_locked(sc, ifp, fp, NULL); + } + BXE_FP_TX_UNLOCK(fp); + } + } + +#else + + fp = &sc->fp[0]; + if (BXE_FP_TX_TRYLOCK(fp)) { + struct ifnet *ifp = sc->ifnet; + /* + * If interface was stopped due to unavailable + * bds, try to process some tx completions + */ + (void) bxe_txeof(sc, fp); + + tx_bd_avail = bxe_tx_avail(sc, fp); + if (tx_bd_avail >= BXE_TX_CLEANUP_THRESHOLD) { + bxe_tx_start_locked(sc, ifp, fp); + } + + BXE_FP_TX_UNLOCK(fp); + } + +#endif /* #if __FreeBSD_version >= 800000 */ + /* Check for TX timeouts on any fastpath. */ FOR_EACH_QUEUE(sc, i) { if (bxe_watchdog(sc, &sc->fp[i]) != 0) { @@ -16137,6 +16170,7 @@ bxe_detach(device_t dev) if (sc->state != BXE_STATE_CLOSED) { BXE_CORE_LOCK(sc); bxe_nic_unload(sc, UNLOAD_CLOSE, TRUE); + sc->state = BXE_STATE_DISABLED; BXE_CORE_UNLOCK(sc); } diff --git a/sys/dev/bxe/bxe_stats.h b/sys/dev/bxe/bxe_stats.h index a4cd152aedaf..75f0248b5e16 100644 --- a/sys/dev/bxe/bxe_stats.h +++ b/sys/dev/bxe/bxe_stats.h @@ -263,6 +263,9 @@ struct bxe_eth_stats { uint32_t mbuf_alloc_rx; uint32_t mbuf_alloc_sge; uint32_t mbuf_alloc_tpa; + + /* num. of times tx queue full occured */ + uint32_t tx_queue_full_return; }; @@ -366,6 +369,9 @@ struct bxe_eth_q_stats { uint32_t mbuf_alloc_rx; uint32_t mbuf_alloc_sge; uint32_t mbuf_alloc_tpa; + + /* num. of times tx queue full occured */ + uint32_t tx_queue_full_return; }; struct bxe_eth_stats_old { -- cgit v1.3 From fdb562a960df06dfc8a4ba8c151c5a8d60e04082 Mon Sep 17 00:00:00 2001 From: Navdeep Parhar Date: Tue, 12 Apr 2016 21:17:19 +0000 Subject: cxgbe(4): Always read the entire mailbox into the reply buffer. The size of the reply can be different from the size of the command in case a debug firmware asserts. fw_asrt() needs the entire reply in order to decode the location of the assert. Sponsored by: Chelsio Communications --- sys/dev/cxgbe/common/t4_hw.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sys/dev') diff --git a/sys/dev/cxgbe/common/t4_hw.c b/sys/dev/cxgbe/common/t4_hw.c index 588f6fda0303..89735510b44d 100644 --- a/sys/dev/cxgbe/common/t4_hw.c +++ b/sys/dev/cxgbe/common/t4_hw.c @@ -381,7 +381,7 @@ int t4_wr_mbox_meat_timeout(struct adapter *adap, int mbox, const void *cmd, /* * Retrieve the command reply and release the mailbox. */ - get_mbox_rpl(adap, cmd_rpl, size/8, data_reg); + get_mbox_rpl(adap, cmd_rpl, MBOX_LEN/8, data_reg); t4_write_reg(adap, ctl_reg, V_MBOWNER(X_MBOWNER_NONE)); CH_DUMP_MBOX(adap, mbox, data_reg); -- cgit v1.3 From cda2ab0e7a9edc0dcea7e2d949ca40f6b8989aee Mon Sep 17 00:00:00 2001 From: Navdeep Parhar Date: Tue, 12 Apr 2016 22:11:29 +0000 Subject: cxgbe(4): Always dispatch all work requests that have been written to the descriptor ring before leaving drain_wrq_wr_list. --- sys/dev/cxgbe/t4_sge.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/cxgbe/t4_sge.c b/sys/dev/cxgbe/t4_sge.c index daf3b8a23644..fd4f291b6f55 100644 --- a/sys/dev/cxgbe/t4_sge.c +++ b/sys/dev/cxgbe/t4_sge.c @@ -1726,7 +1726,8 @@ drain_wrq_wr_list(struct adapter *sc, struct sge_wrq *wrq) MPASS(TAILQ_EMPTY(&wrq->incomplete_wrs)); wr = STAILQ_FIRST(&wrq->wr_list); MPASS(wr != NULL); /* Must be called with something useful to do */ - dbdiff = IDXDIFF(eq->pidx, eq->dbidx, eq->sidx); + MPASS(eq->pidx == eq->dbidx); + dbdiff = 0; do { eq->cidx = read_hw_cidx(eq); @@ -1738,7 +1739,7 @@ drain_wrq_wr_list(struct adapter *sc, struct sge_wrq *wrq) MPASS(wr->wrq == wrq); n = howmany(wr->wr_len, EQ_ESIZE); if (available < n) - return; + break; dst = (void *)&eq->desc[eq->pidx]; if (__predict_true(eq->sidx - eq->pidx > n)) { -- cgit v1.3 From 6ba5a1d9ee0ce5bee9f44a2630d88fb4de4e2367 Mon Sep 17 00:00:00 2001 From: David C Somayajulu Date: Tue, 12 Apr 2016 22:31:48 +0000 Subject: Add support for Flash Update Submitted by:nrapendra.singh@qlogic.com;vaishali.kulkarni@qlogic.com;davidcs@freebsd.org Approved by:davidcs@freebsd.org MFC after:5 days --- sys/dev/bxe/bxe.c | 266 +++++++++++++++++++++++++++++++++++++++++++++++- sys/dev/bxe/bxe.h | 23 +++++ sys/dev/bxe/bxe_ioctl.h | 116 +++++++++++++++++++++ 3 files changed, 400 insertions(+), 5 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c index 2a26ac8593fd..c9e8188b43c3 100644 --- a/sys/dev/bxe/bxe.c +++ b/sys/dev/bxe/bxe.c @@ -13653,49 +13653,60 @@ bxe_get_tunable_params(struct bxe_softc *sc) sc->udp_rss); } -static void +static int bxe_media_detect(struct bxe_softc *sc) { + int port_type; uint32_t phy_idx = bxe_get_cur_phy_idx(sc); + switch (sc->link_params.phy[phy_idx].media_type) { case ELINK_ETH_PHY_SFPP_10G_FIBER: case ELINK_ETH_PHY_XFP_FIBER: BLOGI(sc, "Found 10Gb Fiber media.\n"); sc->media = IFM_10G_SR; + port_type = PORT_FIBRE; break; case ELINK_ETH_PHY_SFP_1G_FIBER: BLOGI(sc, "Found 1Gb Fiber media.\n"); sc->media = IFM_1000_SX; + port_type = PORT_FIBRE; break; case ELINK_ETH_PHY_KR: case ELINK_ETH_PHY_CX4: BLOGI(sc, "Found 10GBase-CX4 media.\n"); sc->media = IFM_10G_CX4; + port_type = PORT_FIBRE; break; case ELINK_ETH_PHY_DA_TWINAX: BLOGI(sc, "Found 10Gb Twinax media.\n"); sc->media = IFM_10G_TWINAX; + port_type = PORT_DA; break; case ELINK_ETH_PHY_BASE_T: if (sc->link_params.speed_cap_mask[0] & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) { BLOGI(sc, "Found 10GBase-T media.\n"); sc->media = IFM_10G_T; + port_type = PORT_TP; } else { BLOGI(sc, "Found 1000Base-T media.\n"); sc->media = IFM_1000_T; + port_type = PORT_TP; } break; case ELINK_ETH_PHY_NOT_PRESENT: BLOGI(sc, "Media not present.\n"); sc->media = 0; + port_type = PORT_OTHER; break; case ELINK_ETH_PHY_UNSPECIFIED: default: BLOGI(sc, "Unknown media!\n"); sc->media = 0; + port_type = PORT_OTHER; break; } + return port_type; } #define GET_FIELD(value, fname) \ @@ -18714,6 +18725,14 @@ bxe_add_cdev(struct bxe_softc *sc) if (sc->grc_dump == NULL) return (-1); + sc->eeprom = malloc(BXE_EEPROM_MAX_DATA_LEN, M_DEVBUF, M_NOWAIT); + + if (sc->eeprom == NULL) { + BLOGW(sc, "Unable to alloc for eeprom size buffer\n"); + free(sc->grc_dump, M_DEVBUF); sc->grc_dump = NULL; + return (-1); + } + sc->ioctl_dev = make_dev(&bxe_cdevsw, sc->ifp->if_dunit, UID_ROOT, @@ -18725,6 +18744,8 @@ bxe_add_cdev(struct bxe_softc *sc) if (sc->ioctl_dev == NULL) { free(sc->grc_dump, M_DEVBUF); + free(sc->eeprom, M_DEVBUF); + sc->eeprom = NULL; return (-1); } @@ -18740,12 +18761,152 @@ bxe_del_cdev(struct bxe_softc *sc) if (sc->ioctl_dev != NULL) destroy_dev(sc->ioctl_dev); - if (sc->grc_dump == NULL) + if (sc->grc_dump != NULL) free(sc->grc_dump, M_DEVBUF); + if (sc->eeprom != NULL) { + free(sc->eeprom, M_DEVBUF); + sc->eeprom = NULL; + } + return; } +static bool bxe_is_nvram_accessible(struct bxe_softc *sc) +{ + + if ((if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) == 0) + return FALSE; + + return TRUE; +} + + +static int +bxe_wr_eeprom(struct bxe_softc *sc, void *data, uint32_t offset, uint32_t len) +{ + int rval = 0; + + if(!bxe_is_nvram_accessible(sc)) { + BLOGW(sc, "Cannot access eeprom when interface is down\n"); + return (-EAGAIN); + } + rval = bxe_nvram_write(sc, offset, (uint8_t *)data, len); + + + return (rval); +} + +static int +bxe_rd_eeprom(struct bxe_softc *sc, void *data, uint32_t offset, uint32_t len) +{ + int rval = 0; + + if(!bxe_is_nvram_accessible(sc)) { + BLOGW(sc, "Cannot access eeprom when interface is down\n"); + return (-EAGAIN); + } + rval = bxe_nvram_read(sc, offset, (uint8_t *)data, len); + + return (rval); +} + +static int +bxe_eeprom_rd_wr(struct bxe_softc *sc, bxe_eeprom_t *eeprom) +{ + int rval = 0; + + switch (eeprom->eeprom_cmd) { + + case BXE_EEPROM_CMD_SET_EEPROM: + + rval = copyin(eeprom->eeprom_data, sc->eeprom, + eeprom->eeprom_data_len); + + if (rval) + break; + + rval = bxe_wr_eeprom(sc, sc->eeprom, eeprom->eeprom_offset, + eeprom->eeprom_data_len); + break; + + case BXE_EEPROM_CMD_GET_EEPROM: + + rval = bxe_rd_eeprom(sc, sc->eeprom, eeprom->eeprom_offset, + eeprom->eeprom_data_len); + + if (rval) { + break; + } + + rval = copyout(sc->eeprom, eeprom->eeprom_data, + eeprom->eeprom_data_len); + break; + + default: + rval = EINVAL; + break; + } + + if (rval) { + BLOGW(sc, "ioctl cmd %d failed rval %d\n", eeprom->eeprom_cmd, rval); + } + + return (rval); +} + +static int +bxe_get_settings(struct bxe_softc *sc, bxe_dev_setting_t *dev_p) +{ + uint32_t ext_phy_config; + int port = SC_PORT(sc); + int cfg_idx = bxe_get_link_cfg_idx(sc); + + dev_p->supported = sc->port.supported[cfg_idx] | + (sc->port.supported[cfg_idx ^ 1] & + (ELINK_SUPPORTED_TP | ELINK_SUPPORTED_FIBRE)); + dev_p->advertising = sc->port.advertising[cfg_idx]; + if(sc->link_params.phy[bxe_get_cur_phy_idx(sc)].media_type == + ELINK_ETH_PHY_SFP_1G_FIBER) { + dev_p->supported = ~(ELINK_SUPPORTED_10000baseT_Full); + dev_p->advertising &= ~(ADVERTISED_10000baseT_Full); + } + if ((sc->state == BXE_STATE_OPEN) && sc->link_vars.link_up && + !(sc->flags & BXE_MF_FUNC_DIS)) { + dev_p->duplex = sc->link_vars.duplex; + if (IS_MF(sc) && !BXE_NOMCP(sc)) + dev_p->speed = bxe_get_mf_speed(sc); + else + dev_p->speed = sc->link_vars.line_speed; + } else { + dev_p->duplex = DUPLEX_UNKNOWN; + dev_p->speed = SPEED_UNKNOWN; + } + + dev_p->port = bxe_media_detect(sc); + + ext_phy_config = SHMEM_RD(sc, + dev_info.port_hw_config[port].external_phy_config); + if((ext_phy_config & PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK) == + PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) + dev_p->phy_address = sc->port.phy_addr; + else if(((ext_phy_config & PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK) != + PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) && + ((ext_phy_config & PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK) != + PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN)) + dev_p->phy_address = ELINK_XGXS_EXT_PHY_ADDR(ext_phy_config); + else + dev_p->phy_address = 0; + + if(sc->link_params.req_line_speed[cfg_idx] == ELINK_SPEED_AUTO_NEG) + dev_p->autoneg = AUTONEG_ENABLE; + else + dev_p->autoneg = AUTONEG_DISABLE; + + + return 0; +} + static int bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td) @@ -18755,6 +18916,14 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, device_t pci_dev; bxe_grcdump_t *dump = NULL; int grc_dump_size; + bxe_drvinfo_t *drv_infop = NULL; + bxe_dev_setting_t *dev_p; + bxe_dev_setting_t dev_set; + bxe_get_regs_t *reg_p; + bxe_reg_rdw_t *reg_rdw_p; + bxe_pcicfg_rdw_t *cfg_rdw_p; + bxe_perm_mac_addr_t *mac_addr_p; + if ((sc = (struct bxe_softc *)dev->si_drv1) == NULL) return ENXIO; @@ -18767,14 +18936,15 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, case BXE_GRC_DUMP_SIZE: dump->pci_func = sc->pcie_func; - dump->grcdump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + - sizeof(struct dump_header); + dump->grcdump_size = + (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + + sizeof(struct dump_header); break; case BXE_GRC_DUMP: grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + - sizeof(struct dump_header); + sizeof(struct dump_header); if ((sc->grc_dump == NULL) || (dump->grcdump == NULL) || (dump->grcdump_size < grc_dump_size) || (!sc->grcdump_done)) { @@ -18787,6 +18957,92 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, break; + case BXE_DRV_INFO: + drv_infop = (bxe_drvinfo_t *)data; + snprintf(drv_infop->drv_name, BXE_DRV_NAME_LENGTH, "%s", "bxe"); + snprintf(drv_infop->drv_version, BXE_DRV_VERSION_LENGTH, "v:%s", + BXE_DRIVER_VERSION); + snprintf(drv_infop->mfw_version, BXE_MFW_VERSION_LENGTH, "%s", + sc->devinfo.bc_ver_str); + snprintf(drv_infop->stormfw_version, BXE_STORMFW_VERSION_LENGTH, + "%s", sc->fw_ver_str); + drv_infop->eeprom_dump_len = sc->devinfo.flash_size; + drv_infop->reg_dump_len = + (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + + sizeof(struct dump_header); + snprintf(drv_infop->bus_info, BXE_BUS_INFO_LENGTH, "%d:%d:%d", + sc->pcie_bus, sc->pcie_device, sc->pcie_func); + break; + case BXE_DEV_SETTING: + dev_p = (bxe_dev_setting_t *)data; + bxe_get_settings(sc, &dev_set); + dev_p->supported = dev_set.supported; + dev_p->advertising = dev_set.advertising; + dev_p->speed = dev_set.speed; + dev_p->duplex = dev_set.duplex; + dev_p->port = dev_set.port; + dev_p->phy_address = dev_set.phy_address; + dev_p->autoneg = dev_set.autoneg; + + break; + + case BXE_GET_REGS: + + reg_p = (bxe_get_regs_t *)data; + grc_dump_size = reg_p->reg_buf_len; + + if (sc->grc_dump == NULL) { + rval = EINVAL; + break; + } + + if(!sc->grcdump_done) { + bxe_grc_dump(sc); + } + if(sc->grcdump_done) { + rval = copyout(sc->grc_dump, reg_p->reg_buf, grc_dump_size); + sc->grcdump_done = 0; + } + + break; + case BXE_RDW_REG: + reg_rdw_p = (bxe_reg_rdw_t *)data; + if((reg_rdw_p->reg_cmd == BXE_READ_REG_CMD) && + (reg_rdw_p->reg_access_type == BXE_REG_ACCESS_DIRECT)) + reg_rdw_p->reg_val = REG_RD(sc, reg_rdw_p->reg_id); + + if((reg_rdw_p->reg_cmd == BXE_WRITE_REG_CMD) && + (reg_rdw_p->reg_access_type == BXE_REG_ACCESS_DIRECT)) + REG_WR(sc, reg_rdw_p->reg_id, reg_rdw_p->reg_val); + + break; + + case BXE_RDW_PCICFG: + cfg_rdw_p = (bxe_pcicfg_rdw_t *)data; + if(cfg_rdw_p->cfg_cmd == BXE_READ_PCICFG) { + + cfg_rdw_p->cfg_val = pci_read_config(sc->dev, cfg_rdw_p->cfg_id, + cfg_rdw_p->cfg_width); + + } else if(cfg_rdw_p->cfg_cmd == BXE_WRITE_PCICFG) { + pci_write_config(sc->dev, cfg_rdw_p->cfg_id, cfg_rdw_p->cfg_val, + cfg_rdw_p->cfg_width); + } else { + BLOGW(sc, "BXE_RDW_PCICFG ioctl wrong cmd passed\n"); + } + break; + + case BXE_MAC_ADDR: + mac_addr_p = (bxe_perm_mac_addr_t *)data; + snprintf(mac_addr_p->mac_addr_str, sizeof(sc->mac_addr_str), "%s", + sc->mac_addr_str); + break; + + case BXE_EEPROM: + rval = bxe_eeprom_rd_wr(sc, (bxe_eeprom_t *)data); + break; + + default: break; } diff --git a/sys/dev/bxe/bxe.h b/sys/dev/bxe/bxe.h index 73f72ce80631..e2dbae289847 100644 --- a/sys/dev/bxe/bxe.h +++ b/sys/dev/bxe/bxe.h @@ -1788,6 +1788,7 @@ struct bxe_softc { struct cdev *ioctl_dev; void *grc_dump; int grcdump_done; + void *eeprom; }; /* struct bxe_softc */ /* IOCTL sub-commands for edebug and firmware upgrade */ @@ -2109,6 +2110,28 @@ static const uint32_t dmae_reg_go_c[] = { #define PCI_PM_D0 1 #define PCI_PM_D3hot 2 +#ifndef DUPLEX_UNKNOWN +#define DUPLEX_UNKNOWN (0xff) +#endif + +#ifndef SPEED_UNKNOWN +#define SPEED_UNKNOWN (-1) +#endif + +/* Enable or disable autonegotiation. */ +#define AUTONEG_DISABLE 0x00 +#define AUTONEG_ENABLE 0x01 + +/* Which connector port. */ +#define PORT_TP 0x00 +#define PORT_AUI 0x01 +#define PORT_MII 0x02 +#define PORT_FIBRE 0x03 +#define PORT_BNC 0x04 +#define PORT_DA 0x05 +#define PORT_NONE 0xef +#define PORT_OTHER 0xff + int bxe_test_bit(int nr, volatile unsigned long * addr); void bxe_set_bit(unsigned int nr, volatile unsigned long * addr); void bxe_clear_bit(int nr, volatile unsigned long * addr); diff --git a/sys/dev/bxe/bxe_ioctl.h b/sys/dev/bxe/bxe_ioctl.h index 2504982fb505..a0f847801009 100644 --- a/sys/dev/bxe/bxe_ioctl.h +++ b/sys/dev/bxe/bxe_ioctl.h @@ -42,6 +42,86 @@ struct bxe_grcdump { }; typedef struct bxe_grcdump bxe_grcdump_t; +#define BXE_DRV_NAME_LENGTH 32 +#define BXE_DRV_VERSION_LENGTH 32 +#define BXE_MFW_VERSION_LENGTH 32 +#define BXE_STORMFW_VERSION_LENGTH 32 +#define BXE_BUS_INFO_LENGTH 32 + +struct bxe_drvinfo { + char drv_name[BXE_DRV_NAME_LENGTH]; + char drv_version[BXE_DRV_VERSION_LENGTH]; + char mfw_version[BXE_MFW_VERSION_LENGTH]; + char stormfw_version[BXE_STORMFW_VERSION_LENGTH]; + uint32_t eeprom_dump_len; /* in bytes */ + uint32_t reg_dump_len; /* in bytes */ + char bus_info[BXE_BUS_INFO_LENGTH]; +}; +typedef struct bxe_drvinfo bxe_drvinfo_t; + +struct bxe_dev_setting { + + uint32_t supported; /* Features this interface supports */ + uint32_t advertising;/* Features this interface advertises */ + uint32_t speed; /* The forced speed, 10Mb, 100Mb, gigabit */ + uint32_t duplex; /* Duplex, half or full */ + uint32_t port; /* Which connector port */ + uint32_t phy_address;/* port number*/ + uint32_t autoneg; /* Enable or disable autonegotiation */ +}; +typedef struct bxe_dev_setting bxe_dev_setting_t; + +struct bxe_get_regs { + void *reg_buf; + uint32_t reg_buf_len; +}; +typedef struct bxe_get_regs bxe_get_regs_t; + +#define BXE_EEPROM_MAX_DATA_LEN 524288 + +struct bxe_eeprom { + uint32_t eeprom_cmd; +#define BXE_EEPROM_CMD_SET_EEPROM 0x01 +#define BXE_EEPROM_CMD_GET_EEPROM 0x02 + + void *eeprom_data; + uint32_t eeprom_offset; + uint32_t eeprom_data_len; + uint32_t eeprom_magic; +}; +typedef struct bxe_eeprom bxe_eeprom_t; + +struct bxe_reg_rdw { + uint32_t reg_cmd; +#define BXE_READ_REG_CMD 0x01 +#define BXE_WRITE_REG_CMD 0x02 + + uint32_t reg_id; + uint32_t reg_val; + uint32_t reg_access_type; +#define BXE_REG_ACCESS_DIRECT 0x01 +#define BXE_REG_ACCESS_INDIRECT 0x02 +}; + +typedef struct bxe_reg_rdw bxe_reg_rdw_t; + +struct bxe_pcicfg_rdw { + uint32_t cfg_cmd; +#define BXE_READ_PCICFG 0x01 +#define BXE_WRITE_PCICFG 0x01 + uint32_t cfg_id; + uint32_t cfg_val; + uint32_t cfg_width; +}; + +typedef struct bxe_pcicfg_rdw bxe_pcicfg_rdw_t; + +struct bxe_perm_mac_addr { + char mac_addr_str[32]; +}; + +typedef struct bxe_perm_mac_addr bxe_perm_mac_addr_t; + /* * Read grcdump size @@ -53,5 +133,41 @@ typedef struct bxe_grcdump bxe_grcdump_t; */ #define BXE_GRC_DUMP _IOWR('e', 2, bxe_grcdump_t) +/* + * Read driver info + */ +#define BXE_DRV_INFO _IOR('e', 3, bxe_drvinfo_t) + +/* + * Read Device Setting + */ +#define BXE_DEV_SETTING _IOR('e', 4, bxe_dev_setting_t) + +/* + * Get Registers + */ +#define BXE_GET_REGS _IOR('e', 5, bxe_get_regs_t) + +/* + * Get/Set EEPROM + */ +#define BXE_EEPROM _IOWR('e', 6, bxe_eeprom_t) + +/* + * read/write a register + */ +#define BXE_RDW_REG _IOWR('e', 7, bxe_reg_rdw_t) + +/* + * read/write PCIcfg + */ +#define BXE_RDW_PCICFG _IOWR('e', 8, bxe_reg_rdw_t) + +/* + * get permanent mac address + */ + +#define BXE_MAC_ADDR _IOWR('e', 9, bxe_perm_mac_addr_t) + #endif /* #ifndef _QLNX_IOCTL_H_ */ -- cgit v1.3 From 6dbd80fa74da1603f589522731017631eb3d2844 Mon Sep 17 00:00:00 2001 From: David C Somayajulu Date: Wed, 13 Apr 2016 00:53:04 +0000 Subject: 1. modify fwdump (a.k.a grcdump) memory is allocated and freed on as needed basis. 2. grcdump can be taken at failure points by invoking bxe_grc_dump() when trigger_grcdump sysctl flag is set. When grcdump is taken grcdump_done sysctl flag is set. 3. grcdump_done can be monitored by the user to retrieve the grcdump. Submitted by:vaishali.kulkarni@qlogic.com Approved by:davidcs@freebsd.org MFC after:5 days --- sys/dev/bxe/bxe.c | 213 ++++++++++++++++++++++++++++++++++-------------- sys/dev/bxe/bxe.h | 8 +- sys/dev/bxe/bxe_stats.c | 12 ++- 3 files changed, 166 insertions(+), 67 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c index c9e8188b43c3..acc11fa5ddba 100644 --- a/sys/dev/bxe/bxe.c +++ b/sys/dev/bxe/bxe.c @@ -672,7 +672,6 @@ static void bxe_handle_fp_tq(void *context, int pending); static int bxe_add_cdev(struct bxe_softc *sc); static void bxe_del_cdev(struct bxe_softc *sc); -static int bxe_grc_dump(struct bxe_softc *sc); static int bxe_alloc_buf_rings(struct bxe_softc *sc); static void bxe_free_buf_rings(struct bxe_softc *sc); @@ -3449,6 +3448,10 @@ bxe_watchdog(struct bxe_softc *sc, } BLOGE(sc, "TX watchdog timeout on fp[%02d], resetting!\n", fp->index); + if(sc->trigger_grcdump) { + /* taking grcdump */ + bxe_grc_dump(sc); + } BXE_FP_TX_UNLOCK(fp); @@ -15636,30 +15639,6 @@ bxe_sysctl_state(SYSCTL_HANDLER_ARGS) return (error); } -static int -bxe_sysctl_trigger_grcdump(SYSCTL_HANDLER_ARGS) -{ - struct bxe_softc *sc; - int error, result; - - result = 0; - error = sysctl_handle_int(oidp, &result, 0, req); - - if (error || !req->newptr) { - return (error); - } - - if (result == 1) { - sc = (struct bxe_softc *)arg1; - - BLOGI(sc, "... grcdump start ...\n"); - bxe_grc_dump(sc); - BLOGI(sc, "... grcdump done ...\n"); - } - - return (error); -} - static int bxe_sysctl_eth_stat(SYSCTL_HANDLER_ARGS) { @@ -15811,14 +15790,16 @@ bxe_add_sysctls(struct bxe_softc *sc) "debug logging mode"); #endif /* #if __FreeBSD_version >= 900000 */ - SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "trigger_grcdump", - CTLTYPE_UINT | CTLFLAG_RW, sc, 0, - bxe_sysctl_trigger_grcdump, "IU", - "set by driver when a grcdump is needed"); + sc->trigger_grcdump = 0; + SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "trigger_grcdump", + CTLFLAG_RW, &sc->trigger_grcdump, 0, + "trigger grcdump should be invoked" + " before collecting grcdump"); + sc->grcdump_started = 0; sc->grcdump_done = 0; SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "grcdump_done", - CTLFLAG_RW, &sc->grcdump_done, 0, + CTLFLAG_RD, &sc->grcdump_done, 0, "set by driver when grcdump is done"); sc->rx_budget = bxe_rx_budget; @@ -18650,7 +18631,7 @@ bxe_get_preset_regs(struct bxe_softc *sc, uint32_t *p, uint32_t preset) return 0; } -static int +int bxe_grc_dump(struct bxe_softc *sc) { int rval = 0; @@ -18658,12 +18639,53 @@ bxe_grc_dump(struct bxe_softc *sc) uint8_t *buf; uint32_t size; struct dump_header *d_hdr; + uint32_t i; + uint32_t reg_val; + uint32_t reg_addr; + uint32_t cmd_offset; + int context_size; + int allocated; + struct ecore_ilt *ilt = SC_ILT(sc); + struct bxe_fastpath *fp; + struct ilt_client_info *ilt_cli; + int grc_dump_size; + - if (sc->grcdump_done) + if (sc->grcdump_done || sc->grcdump_started) return (rval); + sc->grcdump_started = 1; + BLOGI(sc, "Started collecting grcdump\n"); + + grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + + sizeof(struct dump_header); + + sc->grc_dump = malloc(grc_dump_size, M_DEVBUF, M_NOWAIT); + + if (sc->grc_dump == NULL) { + BLOGW(sc, "Unable to allocate memory for grcdump collection\n"); + return(ENOMEM); + } + + + + /* Disable parity attentions as long as following dump may + * cause false alarms by reading never written registers. We + * will re-enable parity attentions right after the dump. + */ + + /* Disable parity on path 0 */ + bxe_pretend_func(sc, 0); + + ecore_disable_blocks_parity(sc); + + /* Disable parity on path 1 */ + bxe_pretend_func(sc, 1); ecore_disable_blocks_parity(sc); + /* Return to current function */ + bxe_pretend_func(sc, SC_ABS_FUNC(sc)); + buf = sc->grc_dump; d_hdr = sc->grc_dump; @@ -18695,7 +18717,7 @@ bxe_grc_dump(struct bxe_softc *sc) (preset_idx == 11)) continue; - rval = bxe_get_preset_regs(sc, sc->grc_dump, preset_idx); + rval = bxe_get_preset_regs(sc, (uint32_t *)buf, preset_idx); if (rval) break; @@ -18705,9 +18727,78 @@ bxe_grc_dump(struct bxe_softc *sc) buf += size; } + bxe_pretend_func(sc, 0); + ecore_clear_blocks_parity(sc); + ecore_enable_blocks_parity(sc); + + bxe_pretend_func(sc, 1); ecore_clear_blocks_parity(sc); ecore_enable_blocks_parity(sc); + /* Return to current function */ + bxe_pretend_func(sc, SC_ABS_FUNC(sc)); + + + context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc)); + for (i = 0, allocated = 0; allocated < context_size; i++) { + + BLOGI(sc, "cdu_context i %d paddr %#jx vaddr %p size 0x%zx\n", i, + sc->context[i].vcxt_dma.paddr, sc->context[i].vcxt_dma.vaddr, + sc->context[i].size); + allocated += sc->context[i].size; + } + BLOGI(sc, "fw stats start_paddr %#jx end_paddr %#jx vaddr %p size 0x%x\n", + (uintmax_t)sc->fw_stats_req_mapping, + (uintmax_t)sc->fw_stats_data_mapping, + sc->fw_stats_req, (sc->fw_stats_req_size + sc->fw_stats_data_size)); + BLOGI(sc, "def_status_block paddr %p vaddr %p size 0x%lx\n", + (void *)sc->def_sb_dma.paddr, sc->def_sb, + sizeof(struct host_sp_status_block)); + BLOGI(sc, "event_queue paddr %#jx vaddr %p size 0x%x\n", + sc->eq_dma.paddr, sc->eq_dma.vaddr, BCM_PAGE_SIZE); + BLOGI(sc, "slow path paddr %#jx vaddr %p size 0x%lx\n", + sc->sp_dma.paddr, sc->sp_dma.vaddr, sizeof(struct bxe_slowpath)); + BLOGI(sc, "slow path queue paddr %#jx vaddr %p size 0x%x\n", + sc->spq_dma.paddr, sc->spq_dma.vaddr, BCM_PAGE_SIZE); + BLOGI(sc, "fw_buf paddr %#jx vaddr %p size 0x%x\n", + sc->gz_buf_dma.paddr, sc->gz_buf_dma.vaddr, FW_BUF_SIZE); + for (i = 0; i < sc->num_queues; i++) { + fp = &sc->fp[i]; + BLOGI(sc, "FP status block fp %d paddr %#jx vaddr %p size 0x%lx\n", i, + fp->sb_dma.paddr, fp->sb_dma.vaddr, + sizeof(union bxe_host_hc_status_block)); + BLOGI(sc, "TX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i, + fp->tx_dma.paddr, fp->tx_dma.vaddr, + (BCM_PAGE_SIZE * TX_BD_NUM_PAGES)); + BLOGI(sc, "RX BD CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i, + fp->rx_dma.paddr, fp->rx_dma.vaddr, + (BCM_PAGE_SIZE * RX_BD_NUM_PAGES)); + BLOGI(sc, "RX RCQ CHAIN fp %d paddr %#jx vaddr %p size 0x%lx\n", i, + fp->rcq_dma.paddr, fp->rcq_dma.vaddr, + (BCM_PAGE_SIZE * RCQ_NUM_PAGES)); + BLOGI(sc, "RX SGE CHAIN fp %d paddr %#jx vaddr %p size 0x%x\n", i, + fp->rx_sge_dma.paddr, fp->rx_sge_dma.vaddr, + (BCM_PAGE_SIZE * RX_SGE_NUM_PAGES)); + } + + ilt_cli = &ilt->clients[1]; + for (i = ilt_cli->start; i <= ilt_cli->end; i++) { + BLOGI(sc, "ECORE_ILT paddr %#jx vaddr %p size 0x%x\n", + ((struct bxe_dma *)((&ilt->lines[i])->page))->paddr, + ((struct bxe_dma *)((&ilt->lines[i])->page))->vaddr, BCM_PAGE_SIZE); + } + + + cmd_offset = DMAE_REG_CMD_MEM; + for (i = 0; i < 224; i++) { + reg_addr = (cmd_offset +(i * 4)); + reg_val = REG_RD(sc, reg_addr); + BLOGI(sc, "DMAE_REG_CMD_MEM i=%d reg_addr 0x%x reg_val 0x%08x\n",i, + reg_addr, reg_val); + } + + + BLOGI(sc, "Collection of grcdump done\n"); sc->grcdump_done = 1; return(rval); } @@ -18715,21 +18806,10 @@ bxe_grc_dump(struct bxe_softc *sc) static int bxe_add_cdev(struct bxe_softc *sc) { - int grc_dump_size; - - grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + - sizeof(struct dump_header); - - sc->grc_dump = malloc(grc_dump_size, M_DEVBUF, M_NOWAIT); - - if (sc->grc_dump == NULL) - return (-1); - sc->eeprom = malloc(BXE_EEPROM_MAX_DATA_LEN, M_DEVBUF, M_NOWAIT); if (sc->eeprom == NULL) { BLOGW(sc, "Unable to alloc for eeprom size buffer\n"); - free(sc->grc_dump, M_DEVBUF); sc->grc_dump = NULL; return (-1); } @@ -18742,11 +18822,8 @@ bxe_add_cdev(struct bxe_softc *sc) if_name(sc->ifp)); if (sc->ioctl_dev == NULL) { - - free(sc->grc_dump, M_DEVBUF); free(sc->eeprom, M_DEVBUF); sc->eeprom = NULL; - return (-1); } @@ -18761,13 +18838,11 @@ bxe_del_cdev(struct bxe_softc *sc) if (sc->ioctl_dev != NULL) destroy_dev(sc->ioctl_dev); - if (sc->grc_dump != NULL) - free(sc->grc_dump, M_DEVBUF); - if (sc->eeprom != NULL) { free(sc->eeprom, M_DEVBUF); sc->eeprom = NULL; } + sc->ioctl_dev = NULL; return; } @@ -18945,15 +19020,26 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) + sizeof(struct dump_header); - - if ((sc->grc_dump == NULL) || (dump->grcdump == NULL) || - (dump->grcdump_size < grc_dump_size) || (!sc->grcdump_done)) { + if ((!sc->trigger_grcdump) || (dump->grcdump == NULL) || + (dump->grcdump_size < grc_dump_size)) { rval = EINVAL; break; } - dump->grcdump_dwords = grc_dump_size >> 2; - rval = copyout(sc->grc_dump, dump->grcdump, grc_dump_size); - sc->grcdump_done = 0; + + if((sc->trigger_grcdump) && (!sc->grcdump_done) && + (!sc->grcdump_started)) { + rval = bxe_grc_dump(sc); + } + + if((!rval) && (sc->grcdump_done) && (sc->grcdump_started) && + (sc->grc_dump != NULL)) { + dump->grcdump_dwords = grc_dump_size >> 2; + rval = copyout(sc->grc_dump, dump->grcdump, grc_dump_size); + free(sc->grc_dump, M_DEVBUF); + sc->grc_dump = NULL; + sc->grcdump_started = 0; + sc->grcdump_done = 0; + } break; @@ -18973,6 +19059,7 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, snprintf(drv_infop->bus_info, BXE_BUS_INFO_LENGTH, "%d:%d:%d", sc->pcie_bus, sc->pcie_device, sc->pcie_func); break; + case BXE_DEV_SETTING: dev_p = (bxe_dev_setting_t *)data; bxe_get_settings(sc, &dev_set); @@ -18991,20 +19078,20 @@ bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, reg_p = (bxe_get_regs_t *)data; grc_dump_size = reg_p->reg_buf_len; - if (sc->grc_dump == NULL) { - rval = EINVAL; - break; - } - - if(!sc->grcdump_done) { + if((!sc->grcdump_done) && (!sc->grcdump_started)) { bxe_grc_dump(sc); } - if(sc->grcdump_done) { + if((sc->grcdump_done) && (sc->grcdump_started) && + (sc->grc_dump != NULL)) { rval = copyout(sc->grc_dump, reg_p->reg_buf, grc_dump_size); + free(sc->grc_dump, M_DEVBUF); + sc->grc_dump = NULL; + sc->grcdump_started = 0; sc->grcdump_done = 0; } break; + case BXE_RDW_REG: reg_rdw_p = (bxe_reg_rdw_t *)data; if((reg_rdw_p->reg_cmd == BXE_READ_REG_CMD) && diff --git a/sys/dev/bxe/bxe.h b/sys/dev/bxe/bxe.h index e2dbae289847..40c9a36d93e7 100644 --- a/sys/dev/bxe/bxe.h +++ b/sys/dev/bxe/bxe.h @@ -1786,8 +1786,12 @@ struct bxe_softc { int panic; struct cdev *ioctl_dev; + void *grc_dump; - int grcdump_done; + unsigned int trigger_grcdump; + unsigned int grcdump_done; + unsigned int grcdump_started; + void *eeprom; }; /* struct bxe_softc */ @@ -2293,7 +2297,7 @@ void bxe_dump_mem(struct bxe_softc *sc, char *tag, uint8_t *mem, uint32_t len); void bxe_dump_mbuf_data(struct bxe_softc *sc, char *pTag, struct mbuf *m, uint8_t contents); - +extern int bxe_grc_dump(struct bxe_softc *sc); #if __FreeBSD_version >= 800000 #if __FreeBSD_version >= 1000000 diff --git a/sys/dev/bxe/bxe_stats.c b/sys/dev/bxe/bxe_stats.c index 2ec5f2d8cc16..03e643c0b6d4 100644 --- a/sys/dev/bxe/bxe_stats.c +++ b/sys/dev/bxe/bxe_stats.c @@ -234,6 +234,10 @@ bxe_stats_comp(struct bxe_softc *sc) while (*stats_comp != DMAE_COMP_VAL) { if (!cnt) { BLOGE(sc, "Timeout waiting for stats finished\n"); + if(sc->trigger_grcdump) { + /* taking grcdump */ + bxe_grc_dump(sc); + } break; } @@ -1310,8 +1314,12 @@ bxe_stats_update(struct bxe_softc *sc) if (bxe_storm_stats_update(sc)) { if (sc->stats_pending++ == 3) { if (if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) { - atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT); - taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task); + if(sc->trigger_grcdump) { + /* taking grcdump */ + bxe_grc_dump(sc); + } + atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT); + taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task); } } return; -- cgit v1.3