Lines Matching defs:atgep
157 void atge_program_ether(atge_t *atgep);
225 void atge_tx_reclaim(atge_t *atgep, int cons);
425 atge_mac_config(atge_t *atgep)
432 reg = INL(atgep, ATGE_MAC_CFG);
436 switch (ATGE_MODEL(atgep)) {
438 switch (ATGE_DID(atgep)) {
448 speed = mii_get_speed(atgep->atge_mii);
459 ld = mii_get_duplex(atgep->atge_mii);
464 switch (ATGE_MODEL(atgep)) {
474 OUTL(atgep, ATGE_MAC_CFG, reg);
476 switch (ATGE_MODEL(atgep)) {
481 OUTL(atgep, ATGE_IM_TIMER, reg);
487 reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
488 reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
489 OUTL(atgep, ATGE_IM_TIMER, reg);
495 if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
497 if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
499 OUTL(atgep, ATGE_MASTER_CFG, reg);
504 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
510 atge_t *atgep = arg;
513 atgep->atge_name, __func__, atgep->atge_link_state, link));
515 mac_link_update(atgep->atge_mh, link);
520 mutex_enter(&atgep->atge_tx_lock);
522 atgep->atge_link_state = LINK_STATE_UP;
523 atge_mac_config(atgep);
524 atgep->atge_tx_resched = 0;
526 atgep->atge_link_state = LINK_STATE_DOWN;
527 atgep->atge_flags |= ATGE_MII_CHECK;
530 mutex_exit(&atgep->atge_tx_lock);
533 mac_tx_update(atgep->atge_mh);
537 atge_tx_reclaim(atge_t *atgep, int end)
540 atge_ring_t *r = atgep->atge_tx_ring;
544 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
556 atge_error(atgep->atge_dip,
560 atge_device_stop(atgep);
580 atgep->atge_tx_ring->r_consumer = start;
590 atge_add_intr_handler(atge_t *atgep, int intr_type)
599 err = ddi_intr_get_nintrs(atgep->atge_dip, intr_type, &count);
601 atge_error(atgep->atge_dip,
607 atgep->atge_name, __func__, count));
609 err = ddi_intr_get_navail(atgep->atge_dip, intr_type, &avail);
611 atge_error(atgep->atge_dip,
617 atge_error(atgep->atge_dip, "count :%d,"
631 atgep->atge_intr_size = avail * sizeof (ddi_intr_handle_t);
632 atgep->atge_intr_handle = kmem_zalloc(atgep->atge_intr_size, KM_SLEEP);
635 atgep->atge_name, __func__, avail, count,
638 err = ddi_intr_alloc(atgep->atge_dip, atgep->atge_intr_handle,
639 intr_type, 0, avail, &atgep->atge_intr_cnt, flag);
642 atge_error(atgep->atge_dip, "ddi_intr_alloc failed : %d", err);
643 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
648 " :%d, avail : %d", atgep->atge_name, count, avail));
650 err = ddi_intr_get_pri(atgep->atge_intr_handle[0],
651 &atgep->atge_intr_pri);
653 atge_error(atgep->atge_dip, "ddi_intr_get_pri failed:%d", err);
654 for (i = 0; i < atgep->atge_intr_cnt; i++) {
655 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
657 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
665 for (i = 0; i < atgep->atge_intr_cnt; i++) {
666 switch (ATGE_MODEL(atgep)) {
668 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
669 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
672 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
673 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
676 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
677 atge_l1c_interrupt, atgep, (caddr_t)(uintptr_t)i);
682 atge_error(atgep->atge_dip,
685 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
688 atgep->atge_intr_handle[i]);
690 atgep->atge_intr_handle[i]);
693 kmem_free(atgep->atge_intr_handle,
694 atgep->atge_intr_size);
700 err = ddi_intr_get_cap(atgep->atge_intr_handle[0],
701 &atgep->atge_intr_cap);
704 atge_error(atgep->atge_dip,
706 atge_remove_intr(atgep);
711 atgep->atge_flags |= ATGE_FIXED_TYPE;
713 atgep->atge_flags |= ATGE_MSI_TYPE;
715 atgep->atge_flags |= ATGE_MSIX_TYPE;
721 atge_remove_intr(atge_t *atgep)
726 if (atgep->atge_intr_handle == NULL)
729 if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
730 (void) ddi_intr_block_disable(atgep->atge_intr_handle,
731 atgep->atge_intr_cnt);
736 for (i = 0; i < atgep->atge_intr_cnt; i++) {
738 (void) ddi_intr_disable(atgep->atge_intr_handle[i]);
740 (void) ddi_intr_remove_handler(atgep->atge_intr_handle[i]);
741 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
744 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
748 atge_enable_intrs(atge_t *atgep)
753 if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
757 err = ddi_intr_block_enable(atgep->atge_intr_handle,
758 atgep->atge_intr_cnt);
761 atge_error(atgep->atge_dip,
771 for (i = 0; i < atgep->atge_intr_cnt; i++) {
772 err = ddi_intr_enable(atgep->atge_intr_handle[i]);
774 atge_error(atgep->atge_dip,
795 atge_add_intr(atge_t *atgep)
802 err = ddi_intr_get_supported_types(atgep->atge_dip,
803 &atgep->atge_intr_types);
805 atge_error(atgep->atge_dip,
811 atgep->atge_name, atgep->atge_intr_types));
814 if (atgep->atge_intr_types & DDI_INTR_TYPE_MSIX) {
815 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSIX);
818 atgep->atge_name));
823 if (atgep->atge_intr_types & DDI_INTR_TYPE_MSI) {
824 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSI);
827 atgep->atge_name));
833 if (atgep->atge_intr_types & DDI_INTR_TYPE_FIXED) {
834 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_FIXED);
837 atgep->atge_name));
846 atge_identify_hardware(atge_t *atgep)
851 vid = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_VENID);
852 did = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_DEVID);
854 atgep->atge_model = 0;
858 atgep->atge_model = atge_cards[i].model;
859 atgep->atge_vid = vid;
860 atgep->atge_did = did;
861 atgep->atge_revid =
862 pci_config_get8(atgep->atge_conf_handle,
864 atge_notice(atgep->atge_dip, "PCI-ID pci%x,%x,%x: %s",
865 vid, did, atgep->atge_revid,
868 atgep->atge_name, __func__, vid, did,
869 atgep->atge_model));
875 atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
881 atgep->atge_model = ATGE_CHIP_L1C;
882 atgep->atge_vid = vid;
883 atgep->atge_did = did;
884 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
894 atge_get_macaddr(atge_t *atgep)
898 reg = INL(atgep, ATGE_SPI_CTRL);
904 OUTL(atgep, ATGE_SPI_CTRL, reg);
906 ATGE_DB(("%s: %s called Get VPD", atgep->atge_name, __func__));
909 atgep->atge_ether_addr[5] = INB(atgep, ATGE_PAR0 + 0);
910 atgep->atge_ether_addr[4] = INB(atgep, ATGE_PAR0 + 1);
911 atgep->atge_ether_addr[3] = INB(atgep, ATGE_PAR0 + 2);
912 atgep->atge_ether_addr[2] = INB(atgep, ATGE_PAR0 + 3);
913 atgep->atge_ether_addr[1] = INB(atgep, ATGE_PAR1 + 0);
914 atgep->atge_ether_addr[0] = INB(atgep, ATGE_PAR1 + 1);
917 atgep->atge_name, __func__,
918 atgep->atge_ether_addr[0],
919 atgep->atge_ether_addr[1],
920 atgep->atge_ether_addr[2],
921 atgep->atge_ether_addr[3],
922 atgep->atge_ether_addr[4],
923 atgep->atge_ether_addr[5]));
925 bcopy(atgep->atge_ether_addr, atgep->atge_dev_addr, ETHERADDRL);
934 atge_device_reset(atge_t *atgep)
936 switch (ATGE_MODEL(atgep)) {
940 atge_device_reset_l1_l1e(atgep);
946 atge_device_reset_l1_l1e(atge_t *atgep)
950 switch (ATGE_MODEL(atgep)) {
952 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET | 0x40);
955 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
958 reg = INL(atgep, ATGE_MASTER_CFG);
961 reg = INL(atgep, ATGE_MASTER_CFG);
967 atge_error(atgep->atge_dip, " master reset timeout reg : %x",
972 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
979 atge_error(atgep->atge_dip, "device reset timeout reg : %x",
983 switch (ATGE_MODEL(atgep)) {
990 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
991 reg = INL(atgep, 0x1008) | 0x8000;
992 OUTL(atgep, 0x1008, reg);
1001 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
1004 ATGE_DB(("%s: %s reset successfully rev : %x", atgep->atge_name,
1005 __func__, atgep->atge_chip_rev));
1013 atge_alloc_dma(atge_t *atgep)
1017 switch (ATGE_MODEL(atgep)) {
1019 err = atge_l1e_alloc_dma(atgep);
1022 err = atge_l1_alloc_dma(atgep);
1025 err = atge_l1c_alloc_dma(atgep);
1033 atge_free_dma(atge_t *atgep)
1035 switch (ATGE_MODEL(atgep)) {
1037 atge_l1e_free_dma(atgep);
1040 atge_l1_free_dma(atgep);
1043 atge_l1c_free_dma(atgep);
1054 atge_t *atgep;
1076 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
1077 ddi_set_driver_private(devinfo, atgep);
1078 atgep->atge_dip = devinfo;
1084 (void) snprintf(atgep->atge_name, sizeof (atgep->atge_name), "%s%d",
1091 err = pci_config_setup(devinfo, &atgep->atge_conf_handle);
1097 (void) atge_identify_hardware(atgep);
1103 &atgep->atge_io_regs, 0, 0, &atge_dev_attr, &atgep->atge_io_handle);
1112 err = atge_add_intr(atgep);
1118 mutex_init(&atgep->atge_intr_lock, NULL, MUTEX_DRIVER,
1119 DDI_INTR_PRI(atgep->atge_intr_pri));
1121 mutex_init(&atgep->atge_tx_lock, NULL, MUTEX_DRIVER,
1122 DDI_INTR_PRI(atgep->atge_intr_pri));
1124 mutex_init(&atgep->atge_rx_lock, NULL, MUTEX_DRIVER,
1125 DDI_INTR_PRI(atgep->atge_intr_pri));
1127 mutex_init(&atgep->atge_mii_lock, NULL, MUTEX_DRIVER, NULL);
1133 mutex_init(&atgep->atge_mbox_lock, NULL, MUTEX_DRIVER,
1134 DDI_INTR_PRI(atgep->atge_intr_pri));
1136 atgep->atge_link_state = LINK_STATE_DOWN;
1137 atgep->atge_mtu = ETHERMTU;
1139 switch (ATGE_MODEL(atgep)) {
1141 if (atgep->atge_revid > 0xF0) {
1143 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1145 if ((INL(atgep, L1E_PHY_STATUS) &
1148 atgep->atge_flags |= ATGE_FLAG_JUMBO;
1151 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1172 switch (ATGE_DID(atgep)) {
1175 atgep->atge_flags |= ATGE_FLAG_APS |
1182 atgep->atge_flags |= ATGE_FLAG_APS |
1187 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1198 err = PCI_CAP_LOCATE(atgep->atge_conf_handle, PCI_CAP_ID_PCI_E,
1202 atgep->atge_dma_rd_burst = DMA_CFG_RD_BURST_128;
1203 atgep->atge_dma_wr_burst = DMA_CFG_WR_BURST_128;
1205 atgep->atge_flags |= ATGE_FLAG_PCIE;
1206 burst = pci_config_get16(atgep->atge_conf_handle,
1212 atgep->atge_dma_rd_burst = ((burst >> 12) & 0x07) <<
1218 atgep->atge_dma_wr_burst = ((burst >> 5) & 0x07) <<
1222 atgep->atge_name, __func__,
1228 switch (ATGE_MODEL(atgep)) {
1234 OUTL_AND(atgep, ATGE_PEX_UNC_ERR_SEV,
1236 OUTL_AND(atgep, ATGE_LTSSM_ID_CFG, ~LTSSM_ID_WRO_ENB);
1237 OUTL_OR(atgep, ATGE_PCIE_PHYMISC, PCIE_PHYMISC_FORCE_RCV_DET);
1244 err = atge_alloc_dma(atgep);
1253 (void) atge_get_macaddr(atgep);
1258 switch (ATGE_MODEL(atgep)) {
1270 if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1285 macreg->m_driver = atgep;
1288 macreg->m_src_addr = atgep->atge_ether_addr;
1291 macreg->m_max_sdu = atgep->atge_mtu;
1294 if ((err = mac_register(macreg, &atgep->atge_mh)) != 0) {
1303 atgep->atge_name, __func__));
1305 atge_device_reset(atgep);
1307 atgep->atge_chip_state = ATGE_CHIP_INITIALIZED;
1312 err = atge_enable_intrs(atgep);
1320 switch (ATGE_MODEL(atgep)) {
1322 atge_l1e_mii_reset(atgep);
1325 atge_l1_mii_reset(atgep);
1328 atge_l1c_mii_reset(atgep);
1335 mii_start(atgep->atge_mii);
1340 (void) mac_unregister(atgep->atge_mh);
1341 atge_device_stop(atgep);
1342 mii_stop(atgep->atge_mii);
1343 mii_free(atgep->atge_mii);
1345 atge_free_dma(atgep);
1346 mutex_destroy(&atgep->atge_intr_lock);
1347 mutex_destroy(&atgep->atge_tx_lock);
1348 mutex_destroy(&atgep->atge_rx_lock);
1349 atge_remove_intr(atgep);
1351 ddi_regs_map_free(&atgep->atge_io_handle);
1353 pci_config_teardown(&atgep->atge_conf_handle);
1355 if (atgep)
1356 kmem_free(atgep, sizeof (atge_t));
1364 atge_t *atgep;
1366 atgep = ddi_get_driver_private(dip);
1367 if (atgep == NULL) {
1378 if (mac_disable(atgep->atge_mh) != DDI_SUCCESS)
1381 mii_stop(atgep->atge_mii);
1383 mutex_enter(&atgep->atge_intr_lock);
1384 mutex_enter(&atgep->atge_tx_lock);
1385 atge_device_stop(atgep);
1386 mutex_exit(&atgep->atge_tx_lock);
1387 mutex_exit(&atgep->atge_intr_lock);
1389 mii_free(atgep->atge_mii);
1390 atge_free_dma(atgep);
1392 ddi_regs_map_free(&atgep->atge_io_handle);
1393 atge_remove_intr(atgep);
1394 pci_config_teardown(&atgep->atge_conf_handle);
1396 (void) mac_unregister(atgep->atge_mh);
1397 mutex_destroy(&atgep->atge_intr_lock);
1398 mutex_destroy(&atgep->atge_tx_lock);
1399 mutex_destroy(&atgep->atge_rx_lock);
1400 kmem_free(atgep, sizeof (atge_t));
1407 atgep->atge_name, __func__));
1412 mii_suspend(atgep->atge_mii);
1414 mutex_enter(&atgep->atge_intr_lock);
1415 mutex_enter(&atgep->atge_tx_lock);
1416 atgep->atge_chip_state |= ATGE_CHIP_SUSPENDED;
1417 atge_device_stop(atgep);
1418 mutex_exit(&atgep->atge_tx_lock);
1419 mutex_exit(&atgep->atge_intr_lock);
1472 atge_alloc_a_dma_blk(atge_t *atgep, ddi_dma_attr_t *attr, int size, int d)
1479 err = ddi_dma_alloc_handle(atgep->atge_dip, attr,
1483 atge_error(atgep->atge_dip, "%s() : failed"
1493 atge_error(atgep->atge_dip, "%s() : failed"
1504 atge_error(atgep->atge_dip, "%s() : failed"
1529 atge_buf_alloc(atge_t *atgep, size_t len, int f)
1536 err = ddi_dma_alloc_handle(atgep->atge_dip, &atge_dma_attr_buf,
1540 atge_error(atgep->atge_dip, "%s() : failed"
1550 atge_error(atgep->atge_dip, "%s() : failed"
1561 atge_error(atgep->atge_dip, "%s() : failed"
1593 atge_t *atgep;
1595 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1599 mutex_enter(&atgep->atge_intr_lock);
1600 mutex_enter(&atgep->atge_tx_lock);
1602 atgep->atge_chip_state &= ~ATGE_CHIP_SUSPENDED;
1604 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1605 atge_device_restart(atgep);
1607 atge_device_reset(atgep);
1610 mutex_exit(&atgep->atge_tx_lock);
1611 mutex_exit(&atgep->atge_intr_lock);
1616 switch (ATGE_MODEL(atgep)) {
1618 atge_l1e_mii_reset(atgep);
1626 mii_resume(atgep->atge_mii);
1629 mac_tx_update(atgep->atge_mh);
1637 atge_t *atgep;
1639 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1643 atge_device_stop(atgep);
1649 atge_add_multicst(atge_t *atgep, uint8_t *macaddr)
1654 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1655 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1658 atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1663 atgep->atge_mchash_ref_cnt[bit]++;
1664 atgep->atge_mchash |= (1ULL << (crc >> 26));
1668 atgep->atge_name, __func__, atgep->atge_mchash, bit,
1669 atgep->atge_mchash_ref_cnt[bit]));
1673 atge_remove_multicst(atge_t *atgep, uint8_t *macaddr)
1678 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1679 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1682 atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1687 atgep->atge_mchash_ref_cnt[bit]--;
1688 if (atgep->atge_mchash_ref_cnt[bit] == 0)
1689 atgep->atge_mchash &= ~(1ULL << (crc >> 26));
1693 atgep->atge_name, __func__, atgep->atge_mchash, bit,
1694 atgep->atge_mchash_ref_cnt[bit]));
1700 atge_t *atgep = arg;
1702 mutex_enter(&atgep->atge_intr_lock);
1703 mutex_enter(&atgep->atge_tx_lock);
1706 atge_add_multicst(atgep, (uint8_t *)macaddr);
1708 atge_remove_multicst(atgep, (uint8_t *)macaddr);
1711 atge_rxfilter(atgep);
1713 mutex_exit(&atgep->atge_tx_lock);
1714 mutex_exit(&atgep->atge_intr_lock);
1722 atge_t *atgep = arg;
1724 mutex_enter(&atgep->atge_intr_lock);
1725 mutex_enter(&atgep->atge_tx_lock);
1728 atgep->atge_filter_flags |= ATGE_PROMISC;
1730 atgep->atge_filter_flags &= ~ATGE_PROMISC;
1733 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1734 atge_rxfilter(atgep);
1737 mutex_exit(&atgep->atge_tx_lock);
1738 mutex_exit(&atgep->atge_intr_lock);
1746 atge_t *atgep = arg;
1748 mutex_enter(&atgep->atge_intr_lock);
1749 mutex_enter(&atgep->atge_tx_lock);
1750 bcopy(macaddr, atgep->atge_ether_addr, ETHERADDRL);
1751 atge_program_ether(atgep);
1752 atge_rxfilter(atgep);
1753 mutex_exit(&atgep->atge_tx_lock);
1754 mutex_exit(&atgep->atge_intr_lock);
1762 atge_t *atgep = arg;
1765 mutex_enter(&atgep->atge_tx_lock);
1770 if (!(atgep->atge_link_state & LINK_STATE_UP)) {
1771 atgep->atge_tx_resched = 1;
1773 mutex_exit(&atgep->atge_tx_lock);
1780 if ((atgep->atge_chip_state & ATGE_CHIP_RUNNING) == 0 ||
1781 atgep->atge_chip_state & ATGE_CHIP_SUSPENDED) {
1782 atgep->atge_carrier_errors++;
1783 atgep->atge_tx_resched = 1;
1785 mutex_exit(&atgep->atge_tx_lock);
1793 if (atge_send_a_packet(atgep, mp) == DDI_FAILURE) {
1801 mutex_exit(&atgep->atge_tx_lock);
1808 atge_t *atgep = arg;
1811 ASSERT(atgep != NULL);
1814 mii_stop(atgep->atge_mii);
1816 mutex_enter(&atgep->atge_intr_lock);
1817 mutex_enter(&atgep->atge_tx_lock);
1819 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
1820 atge_device_restart(atgep);
1824 mutex_exit(&atgep->atge_tx_lock);
1825 mutex_exit(&atgep->atge_intr_lock);
1827 mii_start(atgep->atge_mii);
1831 mac_tx_update(atgep->atge_mh);
1839 atge_t *atgep = arg;
1841 mii_stop(atgep->atge_mii);
1846 mutex_enter(&atgep->atge_intr_lock);
1847 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
1848 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED))
1849 atge_device_stop(atgep);
1850 mutex_exit(&atgep->atge_intr_lock);
1856 atge_t *atgep = arg;
1858 if (mii_m_getstat(atgep->atge_mii, stat, val) == 0) {
1864 *val = atgep->atge_multircv;
1868 *val = atgep->atge_brdcstrcv;
1872 *val = atgep->atge_multixmt;
1876 *val = atgep->atge_brdcstxmt;
1880 *val = atgep->atge_ipackets;
1884 *val = atgep->atge_rbytes;
1888 *val = atgep->atge_opackets;
1892 *val = atgep->atge_obytes;
1896 *val = atgep->atge_norcvbuf;
1904 *val = atgep->atge_collisions;
1908 *val = atgep->atge_errrcv;
1912 *val = atgep->atge_errxmt;
1916 *val = atgep->atge_align_errors;
1920 *val = atgep->atge_fcs_errors;
1924 *val = atgep->atge_sqe_errors;
1928 *val = atgep->atge_defer_xmts;
1932 *val = atgep->atge_first_collisions;
1936 *val = atgep->atge_multi_collisions;
1940 *val = atgep->atge_tx_late_collisions;
1944 *val = atgep->atge_ex_collisions;
1948 *val = atgep->atge_macxmt_errors;
1952 *val = atgep->atge_carrier_errors;
1956 *val = atgep->atge_toolong_errors;
1960 *val = atgep->atge_macrcv_errors;
1964 *val = atgep->atge_overflow;
1968 *val = atgep->atge_underflow;
1972 *val = atgep->atge_runt;
1976 *val = atgep->atge_jabber;
1990 atge_t *atgep = arg;
1992 return (mii_m_getprop(atgep->atge_mii, name, num, sz, val));
1999 atge_t *atgep = arg;
2002 r = mii_m_setprop(atgep->atge_mii, name, num, sz, val);
2005 mutex_enter(&atgep->atge_intr_lock);
2006 mutex_enter(&atgep->atge_tx_lock);
2008 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
2009 atge_device_restart(atgep);
2012 mutex_exit(&atgep->atge_tx_lock);
2013 mutex_exit(&atgep->atge_intr_lock);
2023 atge_t *atgep = arg;
2025 mii_m_propinfo(atgep->atge_mii, name, num, prh);
2029 atge_program_ether(atge_t *atgep)
2036 bcopy(atgep->atge_ether_addr, e, ETHERADDRL);
2037 OUTL(atgep, ATGE_PAR0,
2039 OUTL(atgep, ATGE_PAR1, (e[0] << 8) | e[1]);
2046 atge_device_start(atge_t *atgep)
2055 atge_program_ether(atgep);
2057 switch (ATGE_MODEL(atgep)) {
2059 atge_l1e_program_dma(atgep);
2062 atge_l1_program_dma(atgep);
2065 atge_l1c_program_dma(atgep);
2069 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
2072 switch (ATGE_MODEL(atgep)) {
2075 OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
2082 OUTL(atgep, ATGE_INTR_RETRIG_TIMER, ATGE_USECS(0));
2084 OUTL(atgep, ATGE_CMB_TX_TIMER, ATGE_USECS(0));
2091 OUTL(atgep, ATGE_SMB_STAT_TIMER, ATGE_USECS(0));
2093 atge_l1c_clear_stats(atgep);
2100 if (atgep->atge_mtu < ETHERMTU)
2101 atgep->atge_max_frame_size = ETHERMTU;
2103 atgep->atge_max_frame_size = atgep->atge_mtu;
2105 atgep->atge_max_frame_size += sizeof (struct ether_header) +
2107 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
2109 switch (ATGE_MODEL(atgep)) {
2116 OUTL(atgep, ATGE_HDS_CFG, 0);
2123 OUTL(atgep, ATGE_IPG_IFG_CFG,
2132 OUTL(atgep, ATGE_HDPX_CFG,
2145 switch (ATGE_MODEL(atgep)) {
2147 if (atgep->atge_flags & ATGE_FLAG_JUMBO) {
2149 if (atgep->atge_mtu < ETHERMTU)
2150 reg = atgep->atge_max_frame_size;
2151 else if (atgep->atge_mtu < 6 * 1024)
2152 reg = (atgep->atge_max_frame_size * 2) / 3;
2154 reg = atgep->atge_max_frame_size / 2;
2156 OUTL(atgep, L1E_TX_JUMBO_THRESH,
2162 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
2163 OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
2179 switch (ATGE_MODEL(atgep)) {
2182 if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
2186 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
2187 reg = INL(atgep, 0x1008);
2188 OUTL(atgep, 0x1008, reg | 0x8000);
2198 switch (ATGE_MODEL(atgep)) {
2200 reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
2204 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2211 switch (atgep->atge_chip_rev) {
2222 reg = INL(atgep, L1_SRAM_RX_FIFO_LEN);
2229 reg = INL(atgep, L1_SRAM_RRD_LEN);
2239 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2245 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
2252 switch (ATGE_DID(atgep)) {
2255 OUTL(atgep, ATGE_SERDES_LOCK,
2256 INL(atgep, ATGE_SERDES_LOCK) |
2267 reg = INL(atgep, L1C_SRAM_RX_FIFO_LEN);
2271 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2281 switch (ATGE_MODEL(atgep)) {
2286 OUTL(atgep, ATGE_RXQ_CFG, reg);
2291 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2299 OUTL(atgep, ATGE_TXQ_CFG, reg);
2301 OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2302 OUTL(atgep, L1E_RSS_CPU, 0);
2312 OUTL(atgep, ATGE_DMA_CFG,
2314 atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2323 OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2324 atge_l1e_clear_stats(atgep);
2338 OUTL(atgep, ATGE_RXQ_CFG, reg);
2352 OUTL(atgep, ATGE_TXQ_CFG, reg);
2354 OUTL(atgep, L1_TX_JUMBO_TPD_TH_IPG,
2362 OUTL(atgep, ATGE_DMA_CFG,
2364 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2365 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2368 OUTL(atgep, L1_CMB_WR_THRESH,
2377 OUTL(atgep, L1_CMB_WR_TIMER,
2384 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2385 OUTL(atgep, L1_CSMB_CTRL,
2393 if ((atgep->atge_flags & ATGE_FLAG_ASPM_MON) != 0)
2395 OUTL(atgep, ATGE_RXQ_CFG, reg);
2400 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2403 switch (ATGE_DID(atgep)) {
2415 OUTL(atgep, L1C_TXQ_CFG, reg);
2417 OUTL(atgep, L1C_RSS_IDT_TABLE0, 0xe4e4e4e4);
2418 OUTL(atgep, L1C_RSS_CPU, 0);
2422 OUTL(atgep, ATGE_DMA_CFG,
2428 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2429 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2439 OUTL(atgep, ATGE_WOL_CFG, 0);
2462 switch (ATGE_DID(atgep)) {
2470 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2472 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2475 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2477 switch (ATGE_MODEL(atgep)) {
2483 OUTL(atgep, ATGE_MAC_CFG, reg);
2485 atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2490 atge_rxfilter(atgep);
2495 switch (ATGE_MODEL(atgep)) {
2497 OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2498 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2499 OUTL(atgep, ATGE_INTR_STATUS, 0);
2503 OUTL(atgep, ATGE_INTR_STATUS, 0);
2504 OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2508 atge_mac_config(atgep);
2510 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2543 atge_rxfilter(atge_t *atgep)
2548 rxcfg = INL(atgep, ATGE_MAC_CFG);
2561 if (atgep->atge_filter_flags & (ATGE_PROMISC | ATGE_ALL_MULTICST)) {
2564 if (atgep->atge_filter_flags & ATGE_PROMISC)
2567 if (atgep->atge_filter_flags & ATGE_ALL_MULTICST)
2570 mchash = atgep->atge_mchash;
2573 atge_program_ether(atgep);
2575 OUTL(atgep, ATGE_MAR0, (uint32_t)mchash);
2576 OUTL(atgep, ATGE_MAR1, (uint32_t)(mchash >> 32));
2577 OUTL(atgep, ATGE_MAC_CFG, rxcfg);
2580 atgep->atge_name, __func__, rxcfg, mchash));
2584 atge_device_stop(atge_t *atgep)
2593 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
2594 atgep->atge_chip_state |= ATGE_CHIP_STOPPED;
2595 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
2601 switch (ATGE_MODEL(atgep)) {
2603 atge_l1e_gather_stats(atgep);
2613 atge_disable_intrs(atgep);
2615 switch (ATGE_MODEL(atgep)) {
2623 reg = INL(atgep, ATGE_TXQ_CFG);
2625 OUTL(atgep, ATGE_TXQ_CFG, reg);
2627 reg = INL(atgep, ATGE_RXQ_CFG);
2629 OUTL(atgep, ATGE_RXQ_CFG, reg);
2631 reg = INL(atgep, ATGE_DMA_CFG);
2633 OUTL(atgep, ATGE_DMA_CFG, reg);
2635 atge_l1e_stop_mac(atgep);
2636 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2640 OUTL(atgep, L1_CSMB_CTRL, 0);
2642 atge_l1_stop_tx_mac(atgep);
2643 atge_l1_stop_rx_mac(atgep);
2644 reg = INL(atgep, ATGE_DMA_CFG);
2646 OUTL(atgep, ATGE_DMA_CFG, reg);
2651 reg = INL(atgep, ATGE_TXQ_CFG);
2653 OUTL(atgep, ATGE_TXQ_CFG, reg);
2655 reg = INL(atgep, ATGE_RXQ_CFG);
2657 OUTL(atgep, ATGE_RXQ_CFG, reg);
2662 atge_l1c_stop_tx_mac(atgep);
2663 atge_l1c_stop_rx_mac(atgep);
2664 reg = INL(atgep, ATGE_DMA_CFG);
2666 OUTL(atgep, ATGE_DMA_CFG, reg);
2671 reg = INL(atgep, L1C_TXQ_CFG);
2673 OUTL(atgep, L1C_TXQ_CFG, reg);
2675 reg = INL(atgep, ATGE_RXQ_CFG);
2677 OUTL(atgep, ATGE_RXQ_CFG, reg);
2682 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2688 atge_error(atgep->atge_dip, "%s() stopping TX/RX MAC timeout",
2694 atge_disable_intrs(atge_t *atgep)
2696 OUTL(atgep, ATGE_INTR_MASK, 0);
2697 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2701 atge_device_init(atge_t *atgep)
2703 switch (ATGE_MODEL(atgep)) {
2705 atgep->atge_intrs = L1E_INTRS;
2706 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2708 atge_l1e_init_tx_ring(atgep);
2709 atge_l1e_init_rx_pages(atgep);
2712 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2714 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2716 atge_l1_init_tx_ring(atgep);
2717 atge_l1_init_rx_ring(atgep);
2718 atge_l1_init_rr_ring(atgep);
2719 atge_l1_init_cmb(atgep);
2720 atge_l1_init_smb(atgep);
2723 atgep->atge_intrs = L1C_INTRS | L1C_INTR_GPHY |
2725 atgep->atge_int_rx_mod = 400/2;
2726 atgep->atge_int_tx_mod = 2000/1;
2728 atge_l1c_init_tx_ring(atgep);
2729 atge_l1c_init_rx_ring(atgep);
2730 atge_l1c_init_rr_ring(atgep);
2731 atge_l1c_init_cmb(atgep);
2732 atge_l1c_init_smb(atgep);
2735 OUTL(atgep, ATGE_CLK_GATING_CFG, 0);
2741 atge_device_restart(atge_t *atgep)
2743 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
2744 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2749 atge_device_stop(atgep);
2754 atge_device_reset(atgep);
2759 atge_device_init(atgep);
2764 atge_device_start(atgep);
2769 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2778 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2782 if (pktlen > atgep->atge_tx_buf_len) {
2783 atgep->atge_macxmt_errors++;
2786 atgep->atge_name, __func__,
2787 pktlen, atgep->atge_rx_buf_len));
2793 r = atgep->atge_tx_ring;
2796 atgep->atge_noxmtbuf++;
2797 atgep->atge_tx_resched = 1;
2800 atgep->atge_name, __func__));
2820 switch (ATGE_MODEL(atgep)) {
2872 switch (ATGE_MODEL(atgep)) {
2888 "consumer : %d", atgep->atge_name, __func__, pktlen,