Lines Matching defs:dnetp
123 static void write_gpr(struct dnetinstance *dnetp, uint32_t val);
176 static void dnet_parse_srom(struct dnetinstance *dnetp, SROM_FORMAT *sr,
178 static void parse_controller_leaf(struct dnetinstance *dnetp, LEAF_FORMAT *leaf,
180 static uchar_t *parse_media_block(struct dnetinstance *dnetp,
201 uint32_t dnet_usecelapsed(struct dnetinstance *dnetp);
508 struct dnetinstance *dnetp; /* Our private device info */
524 dnetp = ddi_get_driver_private(devinfo);
526 mutex_enter(&dnetp->intrlock);
527 mutex_enter(&dnetp->txlock);
528 dnet_reset_board(dnetp);
529 dnet_init_board(dnetp);
530 dnetp->suspended = B_FALSE;
532 if (dnetp->running) {
533 dnetp->need_tx_update = B_FALSE;
534 mutex_exit(&dnetp->txlock);
535 (void) dnet_start(dnetp);
536 mutex_exit(&dnetp->intrlock);
537 mac_tx_update(dnetp->mac_handle);
539 mutex_exit(&dnetp->txlock);
540 mutex_exit(&dnetp->intrlock);
576 dnetp = kmem_zalloc(sizeof (struct dnetinstance), KM_SLEEP);
577 ddi_set_driver_private(devinfo, dnetp);
580 if (ddi_regs_map_setup(devinfo, DNET_PCI_RNUMBER, &dnetp->io_reg,
581 0, 0, &accattr, &dnetp->io_handle) != DDI_SUCCESS) {
582 kmem_free(dnetp, sizeof (struct dnetinstance));
586 dnetp->devinfo = devinfo;
587 dnetp->board_type = deviceid;
592 if (ddi_get_iblock_cookie(devinfo, 0, &dnetp->icookie)
604 mutex_init(&dnetp->txlock, NULL, MUTEX_DRIVER, dnetp->icookie);
605 mutex_init(&dnetp->intrlock, NULL, MUTEX_DRIVER, dnetp->icookie);
610 dnetp->bnc_indicator =
619 dnetp->speed =
622 dnetp->full_duplex =
626 if (dnetp->speed == 100) {
627 dnetp->disallowed_media |= (1UL<<MEDIA_TP) | (1UL<<MEDIA_TP_FD);
628 } else if (dnetp->speed == 10) {
629 dnetp->disallowed_media |=
633 if (dnetp->full_duplex == 1) {
634 dnetp->disallowed_media |=
636 } else if (dnetp->full_duplex == 0) {
637 dnetp->disallowed_media |=
641 if (dnetp->bnc_indicator == 0) /* Disable BNC and AUI media */
642 dnetp->disallowed_media |= (1UL<<MEDIA_BNC) | (1UL<<MEDIA_AUI);
643 else if (dnetp->bnc_indicator == 1) /* Force BNC only */
644 dnetp->disallowed_media = (uint32_t)~(1U<<MEDIA_BNC);
645 else if (dnetp->bnc_indicator == 2) /* Force AUI only */
646 dnetp->disallowed_media = (uint32_t)~(1U<<MEDIA_AUI);
648 dnet_reset_board(dnetp);
650 secondary = dnet_read_srom(devinfo, dnetp->board_type, dnetp->io_handle,
651 dnetp->io_reg, vendor_info, sizeof (vendor_info));
656 dnet_parse_srom(dnetp, &dnetp->sr, vendor_info);
660 dnet_print_srom(&dnetp->sr);
662 dnetp->sr.netaddr[ETHERADDRL-1] += secondary; /* unique ether addr */
664 BCOPY((caddr_t)dnetp->sr.netaddr,
665 (caddr_t)dnetp->vendor_addr, ETHERADDRL);
667 BCOPY((caddr_t)dnetp->sr.netaddr,
668 (caddr_t)dnetp->curr_macaddr, ETHERADDRL);
674 dnetp->overrun_workaround =
675 ((dnetp->board_type == DEVICE_ID_21140 && revid >= 0x20) ||
676 (dnetp->board_type == DEVICE_ID_21143 && revid <= 0x30)) ? 1 : 0;
678 dnetp->overrun_workaround =
680 ofloprob_propname, dnetp->overrun_workaround);
686 if (!dnet_hack_interrupts(dnetp, secondary)) {
688 NULL, dnet_intr, (caddr_t)dnetp);
691 dnetp->max_tx_desc = max_tx_desc;
692 dnetp->max_rx_desc = max_rx_desc_21040;
693 if (dnetp->board_type != DEVICE_ID_21040 &&
694 dnetp->board_type != DEVICE_ID_21041 &&
695 dnetp->speed != 10)
696 dnetp->max_rx_desc = max_rx_desc_21140;
699 if (dnet_alloc_bufs(dnetp) == FAILURE) {
711 macp->m_driver = dnetp;
713 macp->m_src_addr = dnetp->curr_macaddr;
719 if (mac_register(macp, &dnetp->mac_handle) == 0) {
722 mutex_enter(&dnetp->intrlock);
724 dnetp->phyaddr = -1;
725 if (dnetp->board_type == DEVICE_ID_21140 ||
726 dnetp->board_type == DEVICE_ID_21143)
727 do_phy(dnetp); /* Initialize the PHY, if any */
728 find_active_media(dnetp);
731 if (dnetp->selected_media_block->media_code != MEDIA_MII &&
732 dnetp->mii != NULL) {
733 mii_destroy(dnetp->mii);
734 dnetp->mii = NULL;
735 dnetp->phyaddr = -1;
741 media_str[dnetp->selected_media_block->media_code]);
743 bzero(dnetp->setup_buf_vaddr, SETUPBUF_SIZE);
745 dnet_reset_board(dnetp);
746 dnet_init_board(dnetp);
748 mutex_exit(&dnetp->intrlock);
750 (void) dnet_m_unicst(dnetp, dnetp->curr_macaddr);
751 (void) dnet_m_multicst(dnetp, B_TRUE, dnet_broadcastaddr);
764 dnet_free_bufs(dnetp);
766 mutex_destroy(&dnetp->txlock);
767 mutex_destroy(&dnetp->intrlock);
769 ddi_regs_map_free(&dnetp->io_handle);
770 kmem_free(dnetp, sizeof (struct dnetinstance));
781 struct dnetinstance *dnetp; /* Our private device info */
785 dnetp = ddi_get_driver_private(devinfo);
793 * NB: dnetp->suspended can only be modified (marked true)
797 mutex_enter(&dnetp->intrlock);
798 mutex_enter(&dnetp->txlock);
799 dnetp->suspended = B_TRUE;
800 dnet_reset_board(dnetp);
801 mutex_exit(&dnetp->txlock);
802 mutex_exit(&dnetp->intrlock);
812 if (mac_unregister(dnetp->mac_handle) != 0)
816 dnet_reset_board(dnetp);
821 if (dnetp->mii != NULL)
822 mii_destroy(dnetp->mii);
825 set_leaf(&dnetp->sr, NULL);
827 ddi_regs_map_free(&dnetp->io_handle);
828 dnet_free_bufs(dnetp);
829 mutex_destroy(&dnetp->txlock);
830 mutex_destroy(&dnetp->intrlock);
831 kmem_free(dnetp, sizeof (struct dnetinstance));
860 struct dnetinstance *dnetp = ddi_get_driver_private(dip);
865 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, INT_MASK_REG), 0);
866 ddi_put32(dnetp->io_handle,
867 REG32(dnetp->io_reg, BUS_MODE_REG), SW_RESET);
873 dnet_reset_board(struct dnetinstance *dnetp)
880 val = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG));
881 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG),
887 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, INT_MASK_REG), 0);
888 ddi_put32(dnetp->io_handle,
889 REG32(dnetp->io_reg, BUS_MODE_REG), SW_RESET);
899 dnet_init_board(struct dnetinstance *dnetp)
901 set_opr(dnetp);
902 set_gpr(dnetp);
903 set_sia(dnetp);
904 dnet_chip_init(dnetp);
909 dnet_chip_init(struct dnetinstance *dnetp)
911 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, BUS_MODE_REG),
917 dnet_init_txrx_bufs(dnetp);
922 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, RX_BASE_ADDR_REG),
923 dnetp->rx_desc_paddr);
928 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, TX_BASE_ADDR_REG),
929 dnetp->tx_desc_paddr);
931 dnetp->tx_current_desc = dnetp->rx_current_desc = 0;
932 dnetp->transmitted_desc = 0;
933 dnetp->free_desc = dnetp->max_tx_desc;
934 enable_interrupts(dnetp);
942 dnet_start(struct dnetinstance *dnetp)
946 ASSERT(MUTEX_HELD(&dnetp->intrlock));
950 val = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG));
951 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG),
953 (void) dnet_set_addr(dnetp);
954 val = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG));
955 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG),
957 enable_interrupts(dnetp);
964 struct dnetinstance *dnetp = arg;
966 mutex_enter(&dnetp->intrlock);
967 dnetp->running = B_TRUE;
971 if (!dnetp->suspended)
972 (void) dnet_start(dnetp);
973 mutex_exit(&dnetp->intrlock);
980 struct dnetinstance *dnetp = arg;
986 mutex_enter(&dnetp->intrlock);
987 if (!dnetp->suspended) {
988 val = ddi_get32(dnetp->io_handle,
989 REG32(dnetp->io_reg, OPN_MODE_REG));
990 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG),
993 mac_link_update(dnetp->mac_handle, LINK_STATE_UNKNOWN);
994 dnetp->running = B_FALSE;
995 mutex_exit(&dnetp->intrlock);
1003 dnet_set_addr(struct dnetinstance *dnetp)
1009 ASSERT(MUTEX_HELD(&dnetp->intrlock));
1011 val = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG));
1015 current_desc = dnetp->tx_current_desc;
1016 desc = &dnetp->tx_desc[current_desc];
1018 mutex_enter(&dnetp->txlock);
1019 dnetp->need_saddr = 0;
1020 mutex_exit(&dnetp->txlock);
1022 if ((alloc_descriptor(dnetp)) == FAILURE) {
1023 mutex_enter(&dnetp->txlock);
1024 dnetp->need_saddr = 1;
1025 mutex_exit(&dnetp->txlock);
1033 desc->buffer1 = dnetp->setup_buf_paddr;
1045 ddi_put8(dnetp->io_handle, REG8(dnetp->io_reg, TX_POLL_REG),
1053 struct dnetinstance *dnetp = arg;
1057 mutex_enter(&dnetp->intrlock);
1059 bcopy(macaddr, dnetp->curr_macaddr, ETHERADDRL);
1078 hashp = (uint32_t *)dnetp->setup_buf_vaddr;
1082 index = hashindex((uint8_t *)dnetp->curr_macaddr);
1085 if (!dnetp->suspended)
1086 (void) dnet_set_addr(dnetp);
1087 mutex_exit(&dnetp->intrlock);
1094 struct dnetinstance *dnetp = arg;
1099 mutex_enter(&dnetp->intrlock);
1101 hashp = (uint32_t *)dnetp->setup_buf_vaddr;
1103 if (dnetp->multicast_cnt[index]++) {
1104 mutex_exit(&dnetp->intrlock);
1109 if (--dnetp->multicast_cnt[index]) {
1110 mutex_exit(&dnetp->intrlock);
1115 if (!dnetp->suspended)
1116 retval = dnet_set_addr(dnetp);
1119 mutex_exit(&dnetp->intrlock);
1161 struct dnetinstance *dnetp = arg;
1164 mutex_enter(&dnetp->intrlock);
1165 if (dnetp->promisc == on) {
1166 mutex_exit(&dnetp->intrlock);
1169 dnetp->promisc = on;
1171 if (!dnetp->suspended) {
1172 val = ddi_get32(dnetp->io_handle,
1173 REG32(dnetp->io_reg, OPN_MODE_REG));
1175 ddi_put32(dnetp->io_handle,
1176 REG32(dnetp->io_reg, OPN_MODE_REG),
1179 ddi_put32(dnetp->io_handle,
1180 REG32(dnetp->io_reg, OPN_MODE_REG),
1183 mutex_exit(&dnetp->intrlock);
1190 struct dnetinstance *dnetp = arg;
1194 if (!dnetp->running) {
1197 *val = (dnetp->mii_up ?
1198 dnetp->mii_speed : dnetp->speed) * 1000000;
1203 *val = dnetp->stat_norcvbuf;
1207 *val = dnetp->stat_errrcv;
1211 *val = dnetp->stat_errxmt;
1215 *val = dnetp->stat_collisions;
1219 *val = dnetp->stat_defer;
1223 *val = dnetp->stat_nocarrier;
1227 *val = dnetp->stat_short;
1231 if (!dnetp->running) {
1234 } else if (dnetp->mii_up) {
1235 *val = dnetp->mii_duplex ?
1238 *val = dnetp->full_duplex ?
1244 *val = dnetp->stat_xmtlatecoll;
1248 *val = dnetp->stat_excoll;
1252 *val = dnetp->stat_overflow;
1256 *val = dnetp->stat_underflow;
1266 #define NextTXIndex(index) (((index)+1) % dnetp->max_tx_desc)
1267 #define PrevTXIndex(index) (((index)-1) < 0 ? dnetp->max_tx_desc - 1: (index)-1)
1272 struct dnetinstance *dnetp = arg;
1274 mutex_enter(&dnetp->txlock);
1277 if (dnetp->suspended) {
1278 mutex_exit(&dnetp->txlock);
1283 if (dnetp->need_saddr) {
1285 mutex_exit(&dnetp->txlock);
1286 mutex_enter(&dnetp->intrlock);
1287 (void) dnet_set_addr(dnetp);
1288 mutex_exit(&dnetp->intrlock);
1289 mutex_enter(&dnetp->txlock);
1293 if (!dnet_send(dnetp, mp)) {
1294 mutex_exit(&dnetp->txlock);
1300 mutex_exit(&dnetp->txlock);
1306 mutex_enter(&dnetp->intrlock);
1308 enable_interrupts(dnetp);
1313 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, TX_POLL_REG),
1316 mutex_exit(&dnetp->intrlock);
1322 dnet_send(struct dnetinstance *dnetp, mblk_t *mp)
1324 struct tx_desc_type *ring = dnetp->tx_desc;
1333 ASSERT(MUTEX_HELD(&dnetp->txlock));
1336 dnet_reclaim_Tx_desc(dnetp);
1346 index = start_index = dnetp->tx_current_desc;
1347 avail = dnetp->free_desc;
1359 retval = ddi_dma_addr_bind_handle(dnetp->dma_handle_tx, NULL,
1384 if (((ncookies + 1) >> 1) > dnetp->free_desc) {
1385 (void) ddi_dma_unbind_handle(dnetp->dma_handle_tx);
1410 dnetp->free_desc--;
1411 ASSERT(dnetp->free_desc >= 0);
1416 ddi_dma_nextcookie(dnetp->dma_handle_tx,
1419 (void) ddi_dma_unbind_handle(dnetp->dma_handle_tx);
1424 dnetp->stat_defer++;
1425 dnetp->free_desc = avail;
1426 dnetp->need_tx_update = B_TRUE;
1429 dnetp->free_desc = avail;
1436 dnetp->free_desc = avail;
1445 dnetp->tx_msgbufp[end_index] = mp;
1460 dnetp->tx_current_desc = NextTXIndex(end_index);
1465 ASSERT(ring[dnetp->max_tx_desc-1].desc1.end_of_ring != 0);
1477 struct dnetinstance *dnetp = (struct dnetinstance *)arg;
1480 mutex_enter(&dnetp->intrlock);
1482 if (dnetp->suspended) {
1483 mutex_exit(&dnetp->intrlock);
1487 int_status = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg,
1494 mutex_exit(&dnetp->intrlock);
1498 dnetp->stat_intr++;
1501 ddi_put32(dnetp->io_handle,
1502 REG32(dnetp->io_reg, STATUS_REG), GPTIMER_INTR);
1503 if (dnetp->timer.cb)
1504 dnetp->timer.cb(dnetp);
1510 ddi_put32(dnetp->io_handle,
1511 REG32(dnetp->io_reg, STATUS_REG), TX_INTR);
1512 mutex_enter(&dnetp->txlock);
1513 if (dnetp->need_tx_update) {
1514 mutex_exit(&dnetp->txlock);
1515 mutex_exit(&dnetp->intrlock);
1516 mac_tx_update(dnetp->mac_handle);
1517 mutex_enter(&dnetp->intrlock);
1518 mutex_enter(&dnetp->txlock);
1519 dnetp->need_tx_update = B_FALSE;
1522 dnet_reclaim_Tx_desc(dnetp);
1523 mutex_exit(&dnetp->txlock);
1530 ddi_put32(dnetp->io_handle,
1531 REG32(dnetp->io_reg, STATUS_REG),
1533 dnet_getp(dnetp);
1565 dnet_reset_board(dnetp);
1566 dnet_init_board(dnetp);
1568 (void) dnet_start(dnetp);
1576 enable_interrupts(dnetp);
1577 mutex_exit(&dnetp->intrlock);
1582 dnet_getp(struct dnetinstance *dnetp)
1587 struct rx_desc_type *desc = dnetp->rx_desc;
1588 int marker = dnetp->rx_current_desc;
1591 if (!dnetp->overrun_workaround) {
1596 misses = ddi_get32(dnetp->io_handle,
1597 REG32(dnetp->io_reg, MISSED_FRAME_REG));
1598 dnetp->stat_missed += (misses & MISSED_FRAME_MASK);
1602 while (!(desc[dnetp->rx_current_desc].desc0.own)) {
1607 index = dnetp->rx_current_desc;
1614 if (dnetp->overrun_workaround &&
1615 marker == dnetp->rx_current_desc) {
1618 marker = (marker+1) % dnetp->max_rx_desc;
1619 } while (!(dnetp->rx_desc[marker].desc0.own) &&
1622 misses = ddi_get32(dnetp->io_handle,
1623 REG32(dnetp->io_reg, MISSED_FRAME_REG));
1624 dnetp->stat_missed +=
1631 opn = ddi_get32(dnetp->io_handle,
1632 REG32(dnetp->io_reg, OPN_MODE_REG));
1633 ddi_put32(dnetp->io_handle,
1634 REG32(dnetp->io_reg, OPN_MODE_REG),
1639 } while ((ddi_get32(dnetp->io_handle,
1640 REG32(dnetp->io_reg, STATUS_REG)) &
1647 while (!(dnetp->rx_desc[index].desc0.own)) {
1648 dnetp->rx_desc[index].desc0.own = 1;
1649 index = (index+1) % dnetp->max_rx_desc;
1650 dnetp->stat_missed++;
1654 opn = ddi_get32(dnetp->io_handle,
1655 REG32(dnetp->io_reg, OPN_MODE_REG));
1656 ddi_put32(dnetp->io_handle,
1657 REG32(dnetp->io_reg, OPN_MODE_REG),
1659 marker = dnetp->rx_current_desc = index;
1673 index = (index + 1) % dnetp->max_rx_desc;
1677 while (dnetp->rx_current_desc != index) {
1678 desc[dnetp->rx_current_desc].desc0.own = 1;
1679 dnetp->rx_current_desc =
1680 (dnetp->rx_current_desc + 1) % dnetp->max_rx_desc;
1698 dnetp->rx_buf_vaddr[index];
1722 rp = dnet_rbuf_alloc(dnetp->devinfo, 0);
1754 update_rx_stats(dnetp, index);
1756 dnetp->stat_norcvbuf++;
1762 dnetp->rx_current_desc =
1763 (dnetp->rx_current_desc+1) % dnetp->max_rx_desc;
1766 ddi_put32(dnetp->io_handle,
1767 REG32(dnetp->io_reg, RX_POLL_REG), RX_POLL_DEMAND);
1775 dnetp->rx_buf_vaddr[index] = newbuf;
1776 dnetp->rx_buf_paddr[index] = rp->rbuf_paddr;
1781 if ((desc[index].buffer1 & ~dnetp->pgmask) !=
1782 (end_paddr & ~dnetp->pgmask)) {
1784 desc[index].buffer2 = end_paddr&~dnetp->pgmask;
1786 (end_paddr & dnetp->pgmask) + 1;
1798 desc[dnetp->rx_current_desc].desc0.own = 1;
1804 dnetp->rx_current_desc =
1805 (dnetp->rx_current_desc+1) % dnetp->max_rx_desc;
1808 ddi_put32(dnetp->io_handle,
1809 REG32(dnetp->io_reg, RX_POLL_REG), RX_POLL_DEMAND);
1812 mutex_exit(&dnetp->intrlock);
1813 mac_rx(dnetp->mac_handle, NULL, mp);
1814 mutex_enter(&dnetp->intrlock);
1821 update_rx_stats(struct dnetinstance *dnetp, int index)
1823 struct rx_desc_type *descp = &(dnetp->rx_desc[index]);
1828 dnetp->stat_errrcv++;
1832 dnetp->stat_overflow++;
1843 dnetp->stat_crc++;
1848 dnetp->stat_short++;
1858 dnetp->stat_frame++;
1866 update_tx_stats(struct dnetinstance *dnetp, int index)
1868 struct tx_desc_type *descp = &(dnetp->tx_desc[index]);
1870 media_block_t *block = dnetp->selected_media_block;
1874 dnetp->stat_errxmt++;
1877 if (dnetp->mii_up) {
1878 fd = dnetp->mii_duplex;
1886 dnetp->stat_collisions += descp->desc0.collision_count;
1890 dnetp->stat_xmtlatecoll++;
1894 dnetp->stat_excoll++;
1898 dnetp->stat_underflow++;
1908 dnetp->stat_nocarrier++;
1912 dnetp->stat_nocarrier++;
1922 write_gpr(struct dnetinstance *dnetp, uint32_t val)
1928 switch (dnetp->board_type) {
1934 dnetp->gprsia = (dnetp->gprsia & 0xffff) | (val << 16);
1935 ddi_put32(dnetp->io_handle,
1936 REG32(dnetp->io_reg, SIA_GENERAL_REG), dnetp->gprsia);
1942 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, GP_REG), val);
1948 read_gpr(struct dnetinstance *dnetp)
1950 switch (dnetp->board_type) {
1953 return (ddi_get32(dnetp->io_handle,
1954 REG32(dnetp->io_reg, SIA_GENERAL_REG)) >> 16);
1956 return (ddi_get32(dnetp->io_handle,
1957 REG32(dnetp->io_reg, GP_REG)));
1962 set_gpr(struct dnetinstance *dnetp)
1966 LEAF_FORMAT *leaf = &dnetp->sr.leaf[dnetp->leaf];
1967 media_block_t *block = dnetp->selected_media_block;
1970 if (ddi_getlongprop(DDI_DEV_T_ANY, dnetp->devinfo,
1974 write_gpr(dnetp, sequence[i]);
1983 write_gpr(dnetp, block->rstseq[i]);
1991 write_gpr(dnetp, leaf->gpr | GPR_CONTROL_WRITE);
1995 write_gpr(dnetp, block->gprseq[i]);
1999 if (dnetp->phyaddr != -1)
2001 (void) mii_sync(dnetp->mii, dnetp->phyaddr);
2008 set_opr(struct dnetinstance *dnetp)
2014 media_block_t *block = dnetp->selected_media_block;
2020 if (ddi_prop_op(DDI_DEV_T_ANY, dnetp->devinfo,
2026 if (dnetp->board_type != DEVICE_ID_21040 &&
2027 dnetp->board_type != DEVICE_ID_21041) {
2036 ddi_put32(dnetp->io_handle,
2037 REG32(dnetp->io_reg, OPN_MODE_REG), val);
2038 dnet_reset_board(dnetp);
2039 ddi_put32(dnetp->io_handle,
2040 REG32(dnetp->io_reg, OPN_MODE_REG), val);
2052 val |= dnetp->promisc ? PROM_MODE : 0;
2055 val |= ((block->command & CMD_SCR) && !dnetp->disable_scrambler) ?
2059 if (dnetp->mii_up) {
2060 fd = dnetp->mii_duplex;
2078 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG), val);
2079 dnet_reset_board(dnetp);
2080 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, OPN_MODE_REG), val);
2084 set_sia(struct dnetinstance *dnetp)
2086 media_block_t *block = dnetp->selected_media_block;
2088 ASSERT(MUTEX_HELD(&dnetp->intrlock));
2099 sia_delay = ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
2102 ddi_put32(dnetp->io_handle,
2103 REG32(dnetp->io_reg, SIA_CONNECT_REG), 0);
2105 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, SIA_TXRX_REG),
2112 dnetp->gprsia = (dnetp->gprsia&0xffff0000)|block->un.sia.csr15;
2113 ddi_put32(dnetp->io_handle,
2114 REG32(dnetp->io_reg, SIA_GENERAL_REG),
2115 dnetp->gprsia);
2117 ddi_put32(dnetp->io_handle,
2118 REG32(dnetp->io_reg, SIA_CONNECT_REG),
2123 } else if (dnetp->board_type != DEVICE_ID_21140) {
2124 ddi_put32(dnetp->io_handle,
2125 REG32(dnetp->io_reg, SIA_CONNECT_REG), 0);
2126 ddi_put32(dnetp->io_handle,
2127 REG32(dnetp->io_reg, SIA_TXRX_REG), 0);
2138 dnet_alloc_bufs(struct dnetinstance *dnetp)
2152 if ((dnetp->tx_desc != NULL) &&
2153 (dnetp->nxmit_desc != dnetp->max_tx_desc))
2156 if ((dnetp->rx_desc != NULL) &&
2157 (dnetp->nrecv_desc != dnetp->max_rx_desc))
2162 nrecv_desc_old = dnetp->nrecv_desc;
2163 dnet_free_bufs(dnetp); /* free the old buffers */
2166 if (dnetp->dma_handle == NULL)
2167 if (ddi_dma_alloc_handle(dnetp->devinfo, &dma_attr,
2168 DDI_DMA_SLEEP, 0, &dnetp->dma_handle) != DDI_SUCCESS)
2171 if (dnetp->dma_handle_tx == NULL)
2172 if (ddi_dma_alloc_handle(dnetp->devinfo, &dma_attr_tx,
2173 DDI_DMA_SLEEP, 0, &dnetp->dma_handle_tx) != DDI_SUCCESS)
2176 if (dnetp->dma_handle_txdesc == NULL)
2177 if (ddi_dma_alloc_handle(dnetp->devinfo, &dma_attr,
2178 DDI_DMA_SLEEP, 0, &dnetp->dma_handle_txdesc) != DDI_SUCCESS)
2181 if (dnetp->dma_handle_setbuf == NULL)
2182 if (ddi_dma_alloc_handle(dnetp->devinfo, &dma_attr,
2183 DDI_DMA_SLEEP, 0, &dnetp->dma_handle_setbuf) != DDI_SUCCESS)
2186 page_size = ddi_ptob(dnetp->devinfo, 1);
2188 dnetp->pgmask = page_size - 1;
2191 if (dnetp->setup_buf_vaddr == NULL) {
2192 if (ddi_dma_mem_alloc(dnetp->dma_handle_setbuf,
2194 DDI_DMA_DONTWAIT, 0, (caddr_t *)&dnetp->setup_buf_vaddr,
2195 &len, &dnetp->setup_buf_acchdl) != DDI_SUCCESS)
2198 if (ddi_dma_addr_bind_handle(dnetp->dma_handle_setbuf,
2199 NULL, dnetp->setup_buf_vaddr, SETUPBUF_SIZE,
2204 dnetp->setup_buf_paddr = cookie.dmac_address;
2205 bzero(dnetp->setup_buf_vaddr, len);
2208 /* allocate xmit descriptor array of size dnetp->max_tx_desc */
2209 if (dnetp->tx_desc == NULL) {
2210 if (ddi_dma_mem_alloc(dnetp->dma_handle_txdesc,
2211 sizeof (struct tx_desc_type) * dnetp->max_tx_desc,
2213 (caddr_t *)&dnetp->tx_desc, &len,
2214 &dnetp->tx_desc_acchdl) != DDI_SUCCESS)
2217 if (ddi_dma_addr_bind_handle(dnetp->dma_handle_txdesc,
2218 NULL, (caddr_t)dnetp->tx_desc,
2219 sizeof (struct tx_desc_type) * dnetp->max_tx_desc,
2223 dnetp->tx_desc_paddr = cookie.dmac_address;
2224 bzero(dnetp->tx_desc, len);
2225 dnetp->nxmit_desc = dnetp->max_tx_desc;
2227 dnetp->tx_msgbufp =
2228 kmem_zalloc(dnetp->max_tx_desc * sizeof (mblk_t **),
2232 /* allocate receive descriptor array of size dnetp->max_rx_desc */
2233 if (dnetp->rx_desc == NULL) {
2236 if (ddi_dma_mem_alloc(dnetp->dma_handle,
2237 sizeof (struct rx_desc_type) * dnetp->max_rx_desc,
2239 (caddr_t *)&dnetp->rx_desc, &len,
2240 &dnetp->rx_desc_acchdl) != DDI_SUCCESS)
2243 if (ddi_dma_addr_bind_handle(dnetp->dma_handle,
2244 NULL, (caddr_t)dnetp->rx_desc,
2245 sizeof (struct rx_desc_type) * dnetp->max_rx_desc,
2250 dnetp->rx_desc_paddr = cookie.dmac_address;
2251 bzero(dnetp->rx_desc, len);
2252 dnetp->nrecv_desc = dnetp->max_rx_desc;
2254 dnetp->rx_buf_vaddr =
2255 kmem_zalloc(dnetp->max_rx_desc * sizeof (caddr_t),
2257 dnetp->rx_buf_paddr =
2258 kmem_zalloc(dnetp->max_rx_desc * sizeof (uint32_t),
2280 ndesc = dnetp->max_rx_desc - nrecv_desc_old;
2282 (dnet_rbuf_init(dnetp->devinfo, ndesc * 2) != 0))
2285 for (i = 0; i < dnetp->max_rx_desc; i++) {
2288 rp = dnet_rbuf_alloc(dnetp->devinfo, 1);
2291 dnetp->rx_buf_vaddr[i] = rp->rbuf_vaddr;
2292 dnetp->rx_buf_paddr[i] = rp->rbuf_paddr;
2303 dnet_free_bufs(struct dnetinstance *dnetp)
2307 if (dnetp->tx_desc != NULL) {
2308 ddi_dma_mem_free(&dnetp->tx_desc_acchdl);
2309 dnetp->tx_desc = NULL;
2311 if (dnetp->tx_msgbufp != NULL) {
2313 for (i = 0; i < dnetp->nxmit_desc; i++) {
2314 if (dnetp->tx_msgbufp[i] != NULL) {
2315 freemsg(dnetp->tx_msgbufp[i]);
2318 kmem_free(dnetp->tx_msgbufp,
2319 dnetp->nxmit_desc * sizeof (mblk_t **));
2320 dnetp->tx_msgbufp = NULL;
2322 dnetp->nxmit_desc = 0;
2326 if (dnetp->rx_desc != NULL) {
2327 ddi_dma_mem_free(&dnetp->rx_desc_acchdl);
2328 dnetp->rx_desc = NULL;
2329 if (dnetp->rx_buf_vaddr != NULL) {
2331 for (i = 0; i < dnetp->nrecv_desc; i++) {
2332 if (dnetp->rx_buf_vaddr[i])
2334 (caddr_t)dnetp->rx_buf_vaddr[i]);
2336 kmem_free(dnetp->rx_buf_vaddr,
2337 dnetp->nrecv_desc * sizeof (caddr_t));
2338 kmem_free(dnetp->rx_buf_paddr,
2339 dnetp->nrecv_desc * sizeof (uint32_t));
2340 dnetp->rx_buf_vaddr = NULL;
2341 dnetp->rx_buf_paddr = NULL;
2343 dnetp->nrecv_desc = 0;
2346 if (dnetp->setup_buf_vaddr != NULL) {
2347 ddi_dma_mem_free(&dnetp->setup_buf_acchdl);
2348 dnetp->setup_buf_vaddr = NULL;
2351 if (dnetp->dma_handle != NULL) {
2352 (void) ddi_dma_unbind_handle(dnetp->dma_handle);
2353 ddi_dma_free_handle(&dnetp->dma_handle);
2354 dnetp->dma_handle = NULL;
2357 if (dnetp->dma_handle_tx != NULL) {
2358 (void) ddi_dma_unbind_handle(dnetp->dma_handle_tx);
2359 ddi_dma_free_handle(&dnetp->dma_handle_tx);
2360 dnetp->dma_handle_tx = NULL;
2363 if (dnetp->dma_handle_txdesc != NULL) {
2364 (void) ddi_dma_unbind_handle(dnetp->dma_handle_txdesc);
2365 ddi_dma_free_handle(&dnetp->dma_handle_txdesc);
2366 dnetp->dma_handle_txdesc = NULL;
2369 if (dnetp->dma_handle_setbuf != NULL) {
2370 (void) ddi_dma_unbind_handle(dnetp->dma_handle_setbuf);
2371 ddi_dma_free_handle(&dnetp->dma_handle_setbuf);
2372 dnetp->dma_handle_setbuf = NULL;
2381 dnet_init_txrx_bufs(struct dnetinstance *dnetp)
2388 for (i = 0; i < dnetp->nxmit_desc; i++) {
2393 if (dnetp->tx_msgbufp[i] != NULL) {
2394 freemsg(dnetp->tx_msgbufp[i]);
2395 dnetp->tx_msgbufp[i] = NULL;
2397 *(uint32_t *)&dnetp->tx_desc[i].desc0 = 0;
2398 *(uint32_t *)&dnetp->tx_desc[i].desc1 = 0;
2399 dnetp->tx_desc[i].buffer1 = 0;
2400 dnetp->tx_desc[i].buffer2 = 0;
2402 dnetp->tx_desc[i - 1].desc1.end_of_ring = 1;
2407 for (i = 0; i < dnetp->nrecv_desc; i++) {
2409 *(uint32_t *)&dnetp->rx_desc[i].desc0 = 0;
2410 *(uint32_t *)&dnetp->rx_desc[i].desc1 = 0;
2411 dnetp->rx_desc[i].desc0.own = 1;
2412 dnetp->rx_desc[i].desc1.buffer_size1 = rx_buf_size;
2413 dnetp->rx_desc[i].buffer1 = dnetp->rx_buf_paddr[i];
2414 dnetp->rx_desc[i].buffer2 = 0;
2415 end_paddr = dnetp->rx_buf_paddr[i]+rx_buf_size-1;
2417 if ((dnetp->rx_desc[i].buffer1 & ~dnetp->pgmask) !=
2418 (end_paddr & ~dnetp->pgmask)) {
2420 dnetp->rx_desc[i].buffer2 = end_paddr&~dnetp->pgmask;
2421 dnetp->rx_desc[i].desc1.buffer_size2 =
2422 (end_paddr & dnetp->pgmask) + 1;
2423 dnetp->rx_desc[i].desc1.buffer_size1 =
2424 rx_buf_size-dnetp->rx_desc[i].desc1.buffer_size2;
2427 dnetp->rx_desc[i - 1].desc1.end_of_ring = 1;
2431 alloc_descriptor(struct dnetinstance *dnetp)
2434 struct tx_desc_type *ring = dnetp->tx_desc;
2436 ASSERT(MUTEX_HELD(&dnetp->intrlock));
2438 mutex_enter(&dnetp->txlock);
2439 index = dnetp->tx_current_desc;
2441 dnet_reclaim_Tx_desc(dnetp);
2444 if (dnetp->free_desc <= 0) {
2449 mutex_exit(&dnetp->txlock);
2460 mutex_exit(&dnetp->txlock);
2463 if (dnetp->need_saddr) {
2464 mutex_exit(&dnetp->txlock);
2466 if (!dnetp->suspended)
2467 (void) dnet_set_addr(dnetp);
2475 dnetp->free_desc--;
2478 dnetp->tx_current_desc = NextTXIndex(index);
2482 dnetp->free_desc, dnetp->transmitted_desc, dnetp->tx_current_desc);
2484 mutex_exit(&dnetp->txlock);
2492 dnet_reclaim_Tx_desc(struct dnetinstance *dnetp)
2494 struct tx_desc_type *desc = dnetp->tx_desc;
2497 ASSERT(MUTEX_HELD(&dnetp->txlock));
2499 index = dnetp->transmitted_desc;
2500 while (((dnetp->free_desc == 0) || (index != dnetp->tx_current_desc)) &&
2509 update_tx_stats(dnetp, index);
2515 if (dnetp->tx_msgbufp[index] != NULL) {
2516 freemsg(dnetp->tx_msgbufp[index]);
2517 dnetp->tx_msgbufp[index] = NULL;
2519 dnetp->free_desc++;
2520 index = (index+1) % dnetp->max_tx_desc;
2523 dnetp->transmitted_desc = index;
3148 find_active_media(struct dnetinstance *dnetp)
3155 LEAF_FORMAT *leaf = &dnetp->sr.leaf[dnetp->leaf];
3158 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3160 dnetp->selected_media_block = leaf->default_block;
3162 if (dnetp->phyaddr != -1) {
3163 dnetp->selected_media_block = leaf->mii_block;
3164 setup_block(dnetp);
3166 if (ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3169 (void) mii_start_portmon(dnetp->mii, dnet_mii_link_cb,
3170 &dnetp->intrlock);
3176 if (dnetp->mii_up) {
3201 if (dnetp->disallowed_media & (1UL<<media))
3213 dnetp->selected_media_block = block;
3217 setup_block(dnetp);
3218 if (send_test_packet(dnetp)) {
3232 send_test_packet(dnetp)) ||
3233 dnet_link_sense(dnetp))
3244 dnetp->selected_media_block ==
3259 setup_block(dnetp);
3287 setup_block(dnetp);
3289 if (mii_linkup(dnetp->mii, dnetp->phyaddr)) {
3291 (void) mii_getspeed(dnetp->mii,
3292 dnetp->phyaddr,
3293 &dnetp->mii_speed,
3294 &dnetp->mii_duplex);
3295 dnetp->mii_up = 1;
3303 dnetp->mii_up = 0;
3308 dnetp->selected_media_block = hd_found;
3310 dnetp->selected_media_block = fd_found;
3314 dnetp->selected_media_block = best_allowed;
3317 setup_block(dnetp);
3325 setup_block(struct dnetinstance *dnetp)
3327 dnet_reset_board(dnetp);
3328 dnet_init_board(dnetp);
3330 (void) dnet_start(dnetp);
3335 dnet_link_sense(struct dnetinstance *dnetp)
3343 media_block_t *block = dnetp->selected_media_block;
3349 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3354 dnetp->sr.leaf[dnetp->leaf].default_block = block;
3358 delay_100 = ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3361 delay_10 = ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3368 dnetp->disable_scrambler = 1;
3369 setup_block(dnetp);
3370 dnetp->disable_scrambler = 0;
3385 status = read_gpr(dnetp);
3405 send_test_packet(struct dnetinstance *dnetp)
3410 int media_code = dnetp->selected_media_block->media_code;
3413 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3425 packet_delay = ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3428 packet_delay = ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3433 desc = dnetp->tx_desc;
3435 bufindex = dnetp->tx_current_desc;
3436 if (alloc_descriptor(dnetp) == FAILURE) {
3447 ASSERT(dnetp->setup_buf_vaddr != NULL);
3449 BCOPY((caddr_t)dnetp->curr_macaddr,
3450 (caddr_t)dnetp->setup_buf_vaddr, ETHERADDRL);
3451 BCOPY((caddr_t)dnetp->curr_macaddr,
3452 (caddr_t)dnetp->setup_buf_vaddr+ETHERADDRL, ETHERADDRL);
3454 desc[bufindex].buffer1 = dnetp->setup_buf_paddr;
3462 ddi_put8(dnetp->io_handle, REG8(dnetp->io_reg, TX_POLL_REG),
3498 enable_interrupts(struct dnetinstance *dnetp)
3500 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3502 if (dnetp->interrupts_disabled)
3504 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, INT_MASK_REG),
3506 (dnetp->timer.cb ? GPTIMER_INTR : 0) |
3518 * of dnetp structures for each device, and the new interrupt routine
3532 dnet_hack_interrupts(struct dnetinstance *dnetp, int secondary)
3536 dev_info_t *devinfo = dnetp->devinfo;
3544 oui = (oui << 8) | dnetp->vendor_addr[i];
3551 if (dnetp->board_type != DEVICE_ID_21040)
3589 dnetp->hackintr_inf = hackintr_inf =
3594 hackintr_inf->dnetps[0] = dnetp;
3604 (uchar_t *)&dnetp->hackintr_inf,
3610 if (ddi_add_intr(devinfo, 0, &dnetp->icookie, NULL,
3625 dnetp->icookie);
3631 /* Add the dnetp for this secondary device to the table */
3649 hackintr_inf->dnetps[i] = dnetp;
3702 struct dnetinstance *altdnetp, *dnetp =
3715 ddi_remove_intr(devinfo, 0, dnetp->icookie);
3722 if (hackintr_inf->dnetps[i] == dnetp) {
3748 ddi_remove_intr(devinfo, 0, dnetp->icookie);
3759 do_phy(struct dnetinstance *dnetp)
3762 LEAF_FORMAT *leaf = dnetp->sr.leaf + dnetp->leaf;
3766 dip = dnetp->devinfo;
3787 dnetp->selected_media_block = leaf->mii_block ?
3790 setup_block(dnetp);
3792 (void) mii_create(dip, dnet_mii_write, dnet_mii_read, &dnetp->mii);
3798 if (mii_probe_phy(dnetp->mii, phy % 32) == MII_SUCCESS &&
3799 mii_init_phy(dnetp->mii, phy % 32) == MII_SUCCESS) {
3805 dnetp->phyaddr = phy % 32;
3808 set_leaf(&dnetp->sr, &leaf_phylegacy);
3821 struct dnetinstance *dnetp;
3830 dnetp = ddi_get_driver_private(dip);
3832 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3834 write_mii(dnetp, MII_PRE, 2*bits_in_ushort);
3841 write_mii(dnetp, command_word, bits_in_ushort-2);
3843 mii_tristate(dnetp);
3846 tmp = ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, ETHER_ROM_REG));
3852 ddi_put32(dnetp->io_handle,
3853 REG32(dnetp->io_reg, ETHER_ROM_REG), MII_READ);
3855 ddi_put32(dnetp->io_handle,
3856 REG32(dnetp->io_reg, ETHER_ROM_REG), MII_READ | MII_CLOCK);
3858 tmp = ddi_get32(dnetp->io_handle,
3859 REG32(dnetp->io_reg, ETHER_ROM_REG));
3864 mii_tristate(dnetp);
3871 struct dnetinstance *dnetp;
3875 dnetp = ddi_get_driver_private(dip);
3877 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3878 write_mii(dnetp, MII_PRE, 2*bits_in_ushort);
3885 write_mii(dnetp, command_word, 2*bits_in_ushort);
3886 mii_tristate(dnetp);
3893 write_mii(struct dnetinstance *dnetp, uint32_t mii_data, int data_size)
3898 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3902 ddi_put32(dnetp->io_handle,
3903 REG32(dnetp->io_reg, ETHER_ROM_REG),
3906 ddi_put32(dnetp->io_handle,
3907 REG32(dnetp->io_reg, ETHER_ROM_REG),
3919 mii_tristate(struct dnetinstance *dnetp)
3921 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3922 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, ETHER_ROM_REG),
3925 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, ETHER_ROM_REG),
3948 struct dnetinstance *dnetp = ddi_get_driver_private(dip);
3951 ASSERT(MUTEX_HELD(&dnetp->intrlock));
3953 leaf = dnetp->sr.leaf + dnetp->leaf;
3955 dnetp->mii_up = 1;
3957 (void) mii_getspeed(dnetp->mii, dnetp->phyaddr,
3958 &dnetp->mii_speed, &dnetp->mii_duplex);
3960 dnetp->selected_media_block = leaf->mii_block;
3961 setup_block(dnetp);
3964 dnetp->mii_up = 0;
3967 dnetp->selected_media_block = leaf->default_block;
3968 setup_block(dnetp);
3971 if (dnetp->running) {
3972 mac_link_update(dnetp->mac_handle,
3973 (dnetp->mii_up ? LINK_STATE_UP : LINK_STATE_DOWN));
3987 dnet_parse_srom(struct dnetinstance *dnetp, SROM_FORMAT *sr, uchar_t *vi)
3993 if (!ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
3995 dnetp->sr.init_from_srom = check_srom_valid(vi);
3997 if (dnetp->sr.init_from_srom && dnetp->board_type != DEVICE_ID_21040) {
4013 parse_controller_leaf(dnetp, sr->leaf+i, vi+offset);
4038 DDI_DEV_T_NONE, dnetp->devinfo,
4050 uchar_t *mac = vi + ddi_getprop(DDI_DEV_T_ANY, dnetp->devinfo,
4056 if (dnetp->board_type == DEVICE_ID_21140) {
4062 dnetp->vendor_21140 = ASANTE_TYPE;
4063 dnetp->vendor_revision = 0;
4070 dnetp->vendor_21140 = COGENT_EM_TYPE;
4071 dnetp->vendor_revision =
4078 dnetp->vendor_21140 = DEFAULT_TYPE;
4079 dnetp->vendor_revision = 0;
4084 } else if (dnetp->board_type == DEVICE_ID_21041) {
4086 } else if (dnetp->board_type == DEVICE_ID_21040) {
4094 parse_controller_leaf(struct dnetinstance *dnetp, LEAF_FORMAT *leaf,
4102 if (dnetp->board_type == DEVICE_ID_21140) /* Sect. 4.3 */
4112 vi = parse_media_block(dnetp, leaf->block + i, vi);
4123 parse_media_block(struct dnetinstance *dnetp, media_block_t *block, uchar_t *vi)
4134 if (dnetp->board_type == DEVICE_ID_21041) {
4594 dnet_usectimeout(struct dnetinstance *dnetp, uint32_t usecs, int contin,
4597 mutex_enter(&dnetp->intrlock);
4598 dnetp->timer.start_ticks = (usecs * 100) / 8192;
4599 dnetp->timer.cb = cback;
4600 ddi_put32(dnetp->io_handle, REG32(dnetp->io_reg, GP_TIMER_REG),
4601 dnetp->timer.start_ticks | (contin ? GPTIMER_CONT : 0));
4602 if (dnetp->timer.cb)
4603 enable_interrupts(dnetp);
4604 mutex_exit(&dnetp->intrlock);
4608 dnet_usecelapsed(struct dnetinstance *dnetp)
4610 uint32_t ticks = dnetp->timer.start_ticks -
4611 (ddi_get32(dnetp->io_handle, REG32(dnetp->io_reg, GP_TIMER_REG)) &
4618 dnet_timestamp(struct dnetinstance *dnetp, char *buf)
4620 uint32_t elapsed = dnet_usecelapsed(dnetp);
4648 dnet_usectimeout(dnetp, 1000000, 0, 0);