MFH

Sponsored by:	The FreeBSD Foundation

34 files changed, 767 insertions, 208 deletions

diff --git a/sys/dev/bxe/bxe.c b/sys/dev/bxe/bxe.c
index 91a5bf3226d0..acc11fa5ddba 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)
@@ -668,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);
 
@@ -3445,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);
 
@@ -4619,7 +4626,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 +5730,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 +5737,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 +9943,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 +12261,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 +12285,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) {
@@ -13620,49 +13656,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)                     \
@@ -15593,30 +15640,6 @@ bxe_sysctl_state(SYSCTL_HANDLER_ARGS)
 }
 
 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)
 {
     struct bxe_softc *sc = (struct bxe_softc *)arg1;
@@ -15767,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;
@@ -16137,6 +16162,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);
     }
 
@@ -18605,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;
@@ -18613,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;
 
@@ -18650,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;
@@ -18660,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);
 }
@@ -18670,15 +18806,12 @@ bxe_grc_dump(struct bxe_softc *sc)
 static int
 bxe_add_cdev(struct bxe_softc *sc)
 {
-    int grc_dump_size;
+    sc->eeprom = malloc(BXE_EEPROM_MAX_DATA_LEN, M_DEVBUF, M_NOWAIT);
 
-    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)
+    if (sc->eeprom == NULL) {
+        BLOGW(sc, "Unable to alloc for eeprom size buffer\n");
         return (-1);
+    }
 
     sc->ioctl_dev = make_dev(&bxe_cdevsw,
                             sc->ifp->if_dunit,
@@ -18689,9 +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);
     }
 
@@ -18706,12 +18838,150 @@ 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;
 }
 
+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)
@@ -18721,6 +18991,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;
@@ -18733,26 +19011,125 @@ 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);
-
-            if ((sc->grc_dump == NULL) || (dump->grcdump == NULL) ||
-                (dump->grcdump_size < grc_dump_size) || (!sc->grcdump_done)) {
+                                sizeof(struct  dump_header);
+            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;
 
+        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->grcdump_done) && (!sc->grcdump_started)) {
+                bxe_grc_dump(sc);
+            }
+            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) &&
+                (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..40c9a36d93e7 100644
--- a/sys/dev/bxe/bxe.h
+++ b/sys/dev/bxe/bxe.h
@@ -1786,8 +1786,13 @@ 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 */
 
 /* IOCTL sub-commands for edebug and firmware upgrade */
@@ -2109,6 +2114,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);
@@ -2270,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_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_ */
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;
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 {
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);
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
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)) {
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:
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; i<PCI_MAXMAPS_0; i++) {
diff --git a/sys/dev/sound/pci/cmi.c b/sys/dev/sound/pci/cmi.c
index 9e6265997cbf..3e4b048c5409 100644
--- a/sys/dev/sound/pci/cmi.c
+++ b/sys/dev/sound/pci/cmi.c
@@ -803,8 +803,8 @@ cmi_muninit(struct mpu401 *arg, void *cookie)
 	struct sc_info *sc = cookie;
 
 	snd_mtxlock(sc->lock);
-	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) {