Lines Matching refs:bgep
303 bge_reinit_rings(bge_t *bgep) in bge_reinit_rings() argument
307 ASSERT(mutex_owned(bgep->genlock)); in bge_reinit_rings()
312 for (ring = 0; ring < bgep->chipid.tx_rings; ++ring) in bge_reinit_rings()
313 bge_reinit_send_ring(&bgep->send[ring]); in bge_reinit_rings()
318 for (ring = 0; ring < bgep->chipid.rx_rings; ++ring) in bge_reinit_rings()
319 bge_reinit_recv_ring(&bgep->recv[ring]); in bge_reinit_rings()
325 bge_reinit_buff_ring(&bgep->buff[ring], ring); in bge_reinit_rings()
347 bge_reset(bge_t *bgep, uint_t asf_mode) in bge_reset() argument
349 bge_reset(bge_t *bgep) in bge_reset()
355 BGE_TRACE(("bge_reset($%p)", (void *)bgep)); in bge_reset()
357 ASSERT(mutex_owned(bgep->genlock)); in bge_reset()
364 mutex_enter(bgep->recv[ring].rx_lock); in bge_reset()
366 mutex_enter(bgep->buff[ring].rf_lock); in bge_reset()
367 rw_enter(bgep->errlock, RW_WRITER); in bge_reset()
369 mutex_enter(bgep->send[ring].tx_lock); in bge_reset()
371 mutex_enter(bgep->send[ring].tc_lock); in bge_reset()
374 retval = bge_chip_reset(bgep, B_TRUE, asf_mode); in bge_reset()
376 retval = bge_chip_reset(bgep, B_TRUE); in bge_reset()
378 bge_reinit_rings(bgep); in bge_reset()
384 mutex_exit(bgep->send[ring].tc_lock); in bge_reset()
386 mutex_exit(bgep->send[ring].tx_lock); in bge_reset()
387 rw_exit(bgep->errlock); in bge_reset()
389 mutex_exit(bgep->buff[ring].rf_lock); in bge_reset()
391 mutex_exit(bgep->recv[ring].rx_lock); in bge_reset()
393 BGE_DEBUG(("bge_reset($%p) done", (void *)bgep)); in bge_reset()
401 bge_stop(bge_t *bgep) in bge_stop() argument
403 BGE_TRACE(("bge_stop($%p)", (void *)bgep)); in bge_stop()
405 ASSERT(mutex_owned(bgep->genlock)); in bge_stop()
408 if (bgep->asf_enabled) { in bge_stop()
409 bgep->asf_pseudostop = B_TRUE; in bge_stop()
412 bge_chip_stop(bgep, B_FALSE); in bge_stop()
417 BGE_DEBUG(("bge_stop($%p) done", (void *)bgep)); in bge_stop()
424 bge_start(bge_t *bgep, boolean_t reset_phys) in bge_start() argument
428 BGE_TRACE(("bge_start($%p, %d)", (void *)bgep, reset_phys)); in bge_start()
430 ASSERT(mutex_owned(bgep->genlock)); in bge_start()
435 retval = bge_chip_start(bgep, reset_phys); in bge_start()
437 BGE_DEBUG(("bge_start($%p, %d) done", (void *)bgep, reset_phys)); in bge_start()
445 bge_restart(bge_t *bgep, boolean_t reset_phys) in bge_restart() argument
448 ASSERT(mutex_owned(bgep->genlock)); in bge_restart()
451 if (bgep->asf_enabled) { in bge_restart()
452 if (bge_reset(bgep, ASF_MODE_POST_INIT) != DDI_SUCCESS) in bge_restart()
455 if (bge_reset(bgep, ASF_MODE_NONE) != DDI_SUCCESS) in bge_restart()
458 if (bge_reset(bgep) != DDI_SUCCESS) in bge_restart()
461 if (bgep->bge_mac_state == BGE_MAC_STARTED) { in bge_restart()
462 if (bge_start(bgep, reset_phys) != DDI_SUCCESS) in bge_restart()
464 bgep->watchdog = 0; in bge_restart()
465 ddi_trigger_softintr(bgep->drain_id); in bge_restart()
468 BGE_DEBUG(("bge_restart($%p, %d) done", (void *)bgep, reset_phys)); in bge_restart()
486 bge_t *bgep = arg; /* private device info */ in bge_m_stop() local
495 mutex_enter(bgep->genlock); in bge_m_stop()
496 if (!(bgep->progress & PROGRESS_INTR)) { in bge_m_stop()
498 bgep->bge_chip_state = BGE_CHIP_STOPPED; in bge_m_stop()
500 bge_stop(bgep); in bge_m_stop()
502 bgep->link_state = LINK_STATE_UNKNOWN; in bge_m_stop()
503 mac_link_update(bgep->mh, bgep->link_state); in bge_m_stop()
509 if (!bgep->asf_pseudostop) in bge_m_stop()
512 rw_enter(bgep->errlock, RW_WRITER); in bge_m_stop()
513 for (ring = 0; ring < bgep->chipid.tx_rings; ++ring) { in bge_m_stop()
514 srp = &bgep->send[ring]; in bge_m_stop()
520 rw_exit(bgep->errlock); in bge_m_stop()
522 bgep->bge_mac_state = BGE_MAC_STOPPED; in bge_m_stop()
524 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) in bge_m_stop()
525 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_UNAFFECTED); in bge_m_stop()
526 mutex_exit(bgep->genlock); in bge_m_stop()
535 bge_t *bgep = arg; /* private device info */ local
542 mutex_enter(bgep->genlock);
543 if (!(bgep->progress & PROGRESS_INTR)) {
545 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
546 mutex_exit(bgep->genlock);
550 if (bgep->asf_enabled) {
551 if ((bgep->asf_status == ASF_STAT_RUN) &&
552 (bgep->asf_pseudostop)) {
553 bgep->bge_mac_state = BGE_MAC_STARTED;
555 bge_phys_check(bgep);
556 bgep->link_state = (bgep->param_link_up) ? LINK_STATE_UP :
558 mac_link_update(bgep->mh, bgep->link_state);
559 mutex_exit(bgep->genlock);
563 if (bge_reset(bgep, ASF_MODE_INIT) != DDI_SUCCESS) {
565 if (bge_reset(bgep) != DDI_SUCCESS) {
567 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
568 (void) bge_check_acc_handle(bgep, bgep->io_handle);
569 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
570 mutex_exit(bgep->genlock);
573 if (bge_start(bgep, B_TRUE) != DDI_SUCCESS) {
574 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
575 (void) bge_check_acc_handle(bgep, bgep->io_handle);
576 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
577 mutex_exit(bgep->genlock);
580 bgep->watchdog = 0;
581 bgep->bge_mac_state = BGE_MAC_STARTED;
584 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
585 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
586 mutex_exit(bgep->genlock);
589 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
590 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
591 mutex_exit(bgep->genlock);
595 if (bgep->asf_enabled) {
596 if (bgep->asf_status != ASF_STAT_RUN) {
598 bgep->asf_timeout_id = timeout(bge_asf_heartbeat,
599 (void *)bgep,
601 bgep->asf_status = ASF_STAT_RUN;
605 mutex_exit(bgep->genlock);
616 bge_t *bgep = arg; /* private device info */ local
624 mutex_enter(bgep->genlock);
625 if (!(bgep->progress & PROGRESS_INTR)) {
627 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
628 mutex_exit(bgep->genlock);
631 ethaddr_copy(macaddr, bgep->curr_addr[slot].addr);
633 if (bge_chip_sync(bgep, B_FALSE) == DDI_FAILURE) {
635 if (bge_chip_sync(bgep) == DDI_FAILURE) {
637 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
638 (void) bge_check_acc_handle(bgep, bgep->io_handle);
639 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
640 mutex_exit(bgep->genlock);
644 if (bgep->asf_enabled) {
650 if (bgep->asf_status == ASF_STAT_RUN) {
656 bge_asf_update_status(bgep);
657 bge_asf_stop_timer(bgep);
658 bgep->asf_status = ASF_STAT_STOP;
660 bge_asf_pre_reset_operations(bgep, BGE_INIT_RESET);
662 bge_chip_stop(bgep, B_FALSE);
664 if (bge_restart(bgep, B_FALSE) == DDI_FAILURE) {
665 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
666 (void) bge_check_acc_handle(bgep, bgep->io_handle);
667 ddi_fm_service_impact(bgep->devinfo,
669 mutex_exit(bgep->genlock);
676 if (bgep->asf_status != ASF_STAT_RUN) {
678 bgep->asf_timeout_id = timeout(bge_asf_heartbeat,
679 (void *)bgep,
681 bgep->asf_status = ASF_STAT_RUN;
686 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
687 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
688 mutex_exit(bgep->genlock);
691 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
692 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
693 mutex_exit(bgep->genlock);
696 mutex_exit(bgep->genlock);
736 bge_t *bgep = barg; local
741 mutex_enter(bgep->genlock);
742 if (bgep->param_loop_mode != BGE_LOOP_NONE &&
748 mutex_exit(bgep->genlock);
751 if ((bgep->chipid.flags & CHIP_FLAG_SERDES) &&
760 mutex_exit(bgep->genlock);
763 if (DEVICE_5906_SERIES_CHIPSETS(bgep) &&
766 mutex_exit(bgep->genlock);
772 bgep->param_en_1000fdx = *(uint8_t *)pr_val;
773 bgep->param_adv_1000fdx = *(uint8_t *)pr_val;
776 bgep->param_en_1000hdx = *(uint8_t *)pr_val;
777 bgep->param_adv_1000hdx = *(uint8_t *)pr_val;
780 bgep->param_en_100fdx = *(uint8_t *)pr_val;
781 bgep->param_adv_100fdx = *(uint8_t *)pr_val;
784 bgep->param_en_100hdx = *(uint8_t *)pr_val;
785 bgep->param_adv_100hdx = *(uint8_t *)pr_val;
788 bgep->param_en_10fdx = *(uint8_t *)pr_val;
789 bgep->param_adv_10fdx = *(uint8_t *)pr_val;
792 bgep->param_en_10hdx = *(uint8_t *)pr_val;
793 bgep->param_adv_10hdx = *(uint8_t *)pr_val;
795 if (err == 0 && bge_reprogram(bgep) == IOC_INVAL)
811 bgep->param_adv_autoneg = *(uint8_t *)pr_val;
812 if (bge_reprogram(bgep) == IOC_INVAL)
816 cur_mtu = bgep->chipid.default_mtu;
829 (bgep->chipid.flags & CHIP_FLAG_NO_JUMBO)) {
833 if (bgep->bge_mac_state == BGE_MAC_STARTED) {
837 bgep->chipid.default_mtu = new_mtu;
838 if (bge_chip_id_init(bgep)) {
842 bgep->bge_dma_error = B_TRUE;
843 bgep->manual_reset = B_TRUE;
844 bge_chip_stop(bgep, B_TRUE);
845 bge_wake_factotum(bgep);
855 bgep->param_adv_pause = 0;
856 bgep->param_adv_asym_pause = 0;
858 bgep->param_link_rx_pause = B_FALSE;
859 bgep->param_link_tx_pause = B_FALSE;
862 bgep->param_adv_pause = 1;
863 bgep->param_adv_asym_pause = 1;
865 bgep->param_link_rx_pause = B_TRUE;
866 bgep->param_link_tx_pause = B_FALSE;
869 bgep->param_adv_pause = 0;
870 bgep->param_adv_asym_pause = 1;
872 bgep->param_link_rx_pause = B_FALSE;
873 bgep->param_link_tx_pause = B_TRUE;
876 bgep->param_adv_pause = 1;
877 bgep->param_adv_asym_pause = 0;
879 bgep->param_link_rx_pause = B_TRUE;
880 bgep->param_link_tx_pause = B_TRUE;
885 if (bge_reprogram(bgep) == IOC_INVAL)
891 err = bge_set_priv_prop(bgep, pr_name, pr_valsize,
898 mutex_exit(bgep->genlock);
907 bge_t *bgep = barg; local
913 bcopy(&bgep->param_link_duplex, pr_val,
917 uint64_t speed = bgep->param_link_speed * 1000000ull;
925 bcopy(&bgep->link_state, pr_val,
932 media = bge_phys_media(bgep);
937 *(uint8_t *)pr_val = bgep->param_adv_autoneg;
944 if (bgep->param_link_rx_pause &&
945 !bgep->param_link_tx_pause)
948 if (!bgep->param_link_rx_pause &&
949 !bgep->param_link_tx_pause)
952 if (!bgep->param_link_rx_pause &&
953 bgep->param_link_tx_pause)
956 if (bgep->param_link_rx_pause &&
957 bgep->param_link_tx_pause)
963 *(uint8_t *)pr_val = bgep->param_adv_1000fdx;
966 *(uint8_t *)pr_val = bgep->param_en_1000fdx;
969 *(uint8_t *)pr_val = bgep->param_adv_1000hdx;
972 *(uint8_t *)pr_val = bgep->param_en_1000hdx;
975 *(uint8_t *)pr_val = bgep->param_adv_100fdx;
978 *(uint8_t *)pr_val = bgep->param_en_100fdx;
981 *(uint8_t *)pr_val = bgep->param_adv_100hdx;
984 *(uint8_t *)pr_val = bgep->param_en_100hdx;
987 *(uint8_t *)pr_val = bgep->param_adv_10fdx;
990 *(uint8_t *)pr_val = bgep->param_en_10fdx;
993 *(uint8_t *)pr_val = bgep->param_adv_10hdx;
996 *(uint8_t *)pr_val = bgep->param_en_10hdx;
1003 err = bge_get_priv_prop(bgep, pr_name,
1016 bge_t *bgep = barg; local
1017 int flags = bgep->chipid.flags;
1041 if (DEVICE_5906_SERIES_CHIPSETS(bgep))
1075 mutex_enter(bgep->genlock);
1076 if ((bgep->param_loop_mode != BGE_LOOP_NONE &&
1078 ((bgep->chipid.flags & CHIP_FLAG_SERDES) &&
1083 (DEVICE_5906_SERIES_CHIPSETS(bgep) &&
1087 mutex_exit(bgep->genlock);
1092 bge_set_priv_prop(bge_t *bgep, const char *pr_name, uint_t pr_valsize, argument
1103 bgep->param_adv_pause = (uint32_t)result;
1104 if (bge_reprogram(bgep) == IOC_INVAL)
1114 bgep->param_adv_asym_pause = (uint32_t)result;
1115 if (bge_reprogram(bgep) == IOC_INVAL)
1139 bgep->param_drain_max = (uint32_t)result;
1140 if (bge_reprogram(bgep) == IOC_INVAL)
1155 bgep->param_msi_cnt = (uint32_t)result;
1156 if (bge_reprogram(bgep) == IOC_INVAL)
1167 bgep->chipid.rx_ticks_norm = (uint32_t)result;
1168 bge_chip_coalesce_update(bgep);
1180 bgep->chipid.rx_count_norm = (uint32_t)result;
1181 bge_chip_coalesce_update(bgep);
1191 bgep->chipid.tx_ticks_norm = (uint32_t)result;
1192 bge_chip_coalesce_update(bgep);
1204 bgep->chipid.tx_count_norm = (uint32_t)result;
1205 bge_chip_coalesce_update(bgep);
1291 bge_t *bgep = arg; /* private device info */ local
1308 refp = &bgep->mcast_refs[index];
1320 mutex_enter(bgep->genlock);
1321 if (!(bgep->progress & PROGRESS_INTR)) {
1323 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1324 mutex_exit(bgep->genlock);
1329 bgep->mcast_hash[word] |= bit;
1331 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1333 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1335 (void) bge_check_acc_handle(bgep,
1336 bgep->cfg_handle);
1337 (void) bge_check_acc_handle(bgep,
1338 bgep->io_handle);
1339 ddi_fm_service_impact(bgep->devinfo,
1341 mutex_exit(bgep->genlock);
1347 bgep->mcast_hash[word] &= ~bit;
1349 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1351 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1353 (void) bge_check_acc_handle(bgep,
1354 bgep->cfg_handle);
1355 (void) bge_check_acc_handle(bgep,
1356 bgep->io_handle);
1357 ddi_fm_service_impact(bgep->devinfo,
1359 mutex_exit(bgep->genlock);
1365 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
1366 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1367 mutex_exit(bgep->genlock);
1370 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
1371 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1372 mutex_exit(bgep->genlock);
1375 mutex_exit(bgep->genlock);
1389 bge_t *bgep = arg; local
1396 mutex_enter(bgep->genlock);
1397 if (!(bgep->progress & PROGRESS_INTR)) {
1399 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1400 mutex_exit(bgep->genlock);
1403 bgep->promisc = on;
1405 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1407 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1409 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
1410 (void) bge_check_acc_handle(bgep, bgep->io_handle);
1411 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1412 mutex_exit(bgep->genlock);
1416 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
1417 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1418 mutex_exit(bgep->genlock);
1421 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
1422 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1423 mutex_exit(bgep->genlock);
1426 mutex_exit(bgep->genlock);
1434 bge_unicst_find(bge_t *bgep, const uint8_t *mac_addr) argument
1438 ASSERT(mutex_owned(bgep->genlock));
1440 for (slot = 0; slot < bgep->unicst_addr_total; slot++) {
1441 if (bcmp(bgep->curr_addr[slot].addr, mac_addr, ETHERADDRL) == 0)
1497 bge_t *bgep = rrp->bgep; local
1498 bge_recv_rule_t *rulep = bgep->recv_rules;
1500 uint8_t ring = (uint8_t)(rrp - bgep->recv) + 1;
1507 mutex_enter(bgep->genlock);
1508 if (bgep->unicst_addr_avail == 0) {
1509 mutex_exit(bgep->genlock);
1519 slot = bge_unicst_find(bgep, mac_addr);
1521 mutex_exit(bgep->genlock);
1532 mutex_exit(bgep->genlock);
1536 for (slot = 0; slot < bgep->unicst_addr_total; slot++) {
1537 if (!bgep->curr_addr[slot].set) {
1538 bgep->curr_addr[slot].set = B_TRUE;
1543 VERIFY3S(slot, <, bgep->unicst_addr_total);
1544 bgep->unicst_addr_avail--;
1545 mutex_exit(bgep->genlock);
1547 if ((err = bge_unicst_set(bgep, mac_addr, slot)) != 0)
1574 bge_reg_put32(bgep, RECV_RULE_MASK_REG(i), rulep[i].mask_value);
1575 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(i), rulep[i].control);
1580 bge_reg_put32(bgep, RECV_RULE_MASK_REG(i+1), rulep[i+1].mask_value);
1581 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(i+1), rulep[i+1].control);
1592 (void) bge_unicst_set(bgep, zero_addr, slot);
1593 mutex_enter(bgep->genlock);
1594 bgep->curr_addr[slot].set = B_FALSE;
1595 bgep->unicst_addr_avail++;
1596 mutex_exit(bgep->genlock);
1608 bge_t *bgep = rrp->bgep; local
1609 bge_recv_rule_t *rulep = bgep->recv_rules;
1618 mutex_enter(bgep->genlock);
1619 slot = bge_unicst_find(bgep, mac_addr);
1621 mutex_exit(bgep->genlock);
1625 ASSERT(bgep->curr_addr[slot].set);
1626 mutex_exit(bgep->genlock);
1628 if ((err = bge_unicst_set(bgep, zero_addr, slot)) != 0)
1637 bge_reg_put32(bgep, RECV_RULE_MASK_REG(start), rulep[start].mask_value);
1638 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(start), rulep[start].control);
1642 bge_reg_put32(bgep, RECV_RULE_MASK_REG(start), rulep[start].mask_value);
1643 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(start), rulep[start].control);
1649 mutex_enter(bgep->genlock);
1650 bgep->curr_addr[slot].set = B_FALSE;
1651 bgep->unicst_addr_avail++;
1652 mutex_exit(bgep->genlock);
1662 bge_t *bgep = rrp->bgep; local
1664 mutex_enter(bgep->genlock);
1666 mutex_exit(bgep->genlock);
1675 bge_t *bgep = rrp->bgep; local
1677 mutex_enter(bgep->genlock);
1679 mutex_exit(bgep->genlock);
1705 bge_t *bgep = arg; local
1711 ASSERT(rg_index >= 0 && rg_index < MIN(bgep->chipid.rx_rings,
1714 rx_ring = &bgep->recv[rg_index];
1747 bge_t *bgep = arg; local
1753 ASSERT(rg_index >= 0 && rg_index < MIN(bgep->chipid.rx_rings,
1755 rx_ring = &bgep->recv[rg_index];
1778 bge_t *bgep = arg; local
1799 MIN(bgep->chipid.rx_rings, MAC_ADDRESS_REGS_MAX);
1826 bge_set_loop_mode(bge_t *bgep, uint32_t mode) argument
1831 if (mode == bgep->param_loop_mode)
1856 bgep->param_loop_mode = mode;
1861 bge_loop_ioctl(bge_t *bgep, queue_t *wq, mblk_t *mp, struct iocblk *iocp) argument
1880 bge_error(bgep, "bge_loop_ioctl: invalid cmd 0x%x", cmd);
1901 *lbmp = bgep->param_loop_mode;
1908 return (bge_set_loop_mode(bgep, *lbmp));
1920 bge_t *bgep = arg; local
1976 mutex_enter(bgep->genlock);
1977 if (!(bgep->progress & PROGRESS_INTR)) {
1979 mutex_exit(bgep->genlock);
2002 status = bge_chip_ioctl(bgep, wq, mp, iocp);
2010 status = bge_loop_ioctl(bgep, wq, mp, iocp);
2026 if (bge_reprogram(bgep) == IOC_INVAL)
2031 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
2032 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
2035 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
2036 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
2039 mutex_exit(bgep->genlock);
2090 bge_alloc_dma_mem(bge_t *bgep, size_t memsize, ddi_device_acc_attr_t *attr_p, argument
2097 (void *)bgep, memsize, attr_p, dma_flags, dma_p));
2102 err = ddi_dma_alloc_handle(bgep->devinfo, &dma_attr,
2192 bge_init_buff_ring(bge_t *bgep, uint64_t ring) argument
2220 (void *)bgep, ring));
2222 brp = &bgep->buff[ring];
2242 brp->bgep = bgep;
2243 bsp = DMA_VPTR(bgep->status_block);
2247 DDI_INTR_PRI(bgep->intr_pri));
2270 bge_fini_buff_ring(bge_t *bgep, uint64_t ring) argument
2276 (void *)bgep, ring));
2278 brp = &bgep->buff[ring];
2292 bge_init_recv_ring(bge_t *bgep, uint64_t ring) argument
2299 (void *)bgep, ring));
2305 rrp = &bgep->recv[ring];
2321 rrp->bgep = bgep;
2322 bsp = DMA_VPTR(bgep->status_block);
2326 DDI_INTR_PRI(bgep->intr_pri));
2334 bge_fini_recv_ring(bge_t *bgep, uint64_t ring) argument
2339 (void *)bgep, ring));
2341 rrp = &bgep->recv[ring];
2353 bge_init_send_ring(bge_t *bgep, uint64_t ring) argument
2366 (void *)bgep, ring));
2372 srp = &bgep->send[ring];
2387 srp->bgep = bgep;
2388 bsp = DMA_VPTR(bgep->status_block);
2392 DDI_INTR_PRI(bgep->intr_pri));
2394 DDI_INTR_PRI(bgep->intr_pri));
2396 DDI_INTR_PRI(bgep->intr_pri));
2398 DDI_INTR_PRI(bgep->intr_pri));
2414 if (bgep->chipid.snd_buff_size > BGE_SEND_BUFF_SIZE_DEFAULT)
2437 bgep->chipid.snd_buff_size);
2448 bge_fini_send_ring(bge_t *bgep, uint64_t ring) argument
2456 (void *)bgep, ring));
2458 srp = &bgep->send[ring];
2484 bge_init_rings(bge_t *bgep) argument
2488 BGE_TRACE(("bge_init_rings($%p)", (void *)bgep));
2494 bge_init_send_ring(bgep, ring);
2496 bge_init_recv_ring(bgep, ring);
2498 bge_init_buff_ring(bgep, ring);
2505 bge_fini_rings(bge_t *bgep) argument
2509 BGE_TRACE(("bge_fini_rings($%p)", (void *)bgep));
2512 bge_fini_buff_ring(bgep, ring);
2514 bge_fini_recv_ring(bgep, ring);
2516 bge_fini_send_ring(bgep, ring);
2552 bge_alloc_txbuf_array(bge_t *bgep, send_ring_t *srp) argument
2575 txbuffsize = BGE_SEND_BUF_NUM*bgep->chipid.snd_buff_size;
2578 err = bge_alloc_dma_mem(bgep, txbuffsize/BGE_SPLIT,
2598 bgep->chipid.snd_buff_size);
2638 bge_alloc_bufs(bge_t *bgep) argument
2647 uint32_t rx_rings = bgep->chipid.rx_rings;
2648 uint32_t tx_rings = bgep->chipid.tx_rings;
2653 (void *)bgep));
2655 rxbuffsize = BGE_STD_SLOTS_USED*bgep->chipid.std_buf_size;
2656 rxbuffsize += bgep->chipid.jumbo_slots*bgep->chipid.recv_jumbo_size;
2659 txbuffsize = BGE_SEND_BUF_NUM*bgep->chipid.snd_buff_size;
2662 rxdescsize = rx_rings*bgep->chipid.recv_slots;
2666 rxbuffdescsize += bgep->chipid.jumbo_slots;
2679 if (!(DEVICE_5717_SERIES_CHIPSETS(bgep) ||
2680 DEVICE_5725_SERIES_CHIPSETS(bgep) ||
2681 DEVICE_57765_SERIES_CHIPSETS(bgep))) {
2691 err = bge_alloc_dma_mem(bgep, rxbuffsize/BGE_SPLIT,
2693 &bgep->rx_buff[split]);
2706 err = bge_alloc_dma_mem(bgep, txbuffsize/BGE_SPLIT,
2708 &bgep->tx_buff[split]);
2716 if (!(DEVICE_5717_SERIES_CHIPSETS(bgep) ||
2717 DEVICE_5725_SERIES_CHIPSETS(bgep) ||
2718 DEVICE_57765_SERIES_CHIPSETS(bgep))) {
2728 err = bge_alloc_dma_mem(bgep, rxdescsize/rx_rings,
2730 &bgep->rx_desc[split]);
2743 err = bge_alloc_dma_mem(bgep, rxbuffdescsize, &bge_desc_accattr,
2744 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, &bgep->rx_desc[split]);
2754 err = bge_alloc_dma_mem(bgep, txdescsize, &bge_desc_accattr,
2755 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, &bgep->tx_desc);
2767 area = bgep->rx_buff[split];
2777 bge_slice_chunk(&bgep->buff[BGE_STD_BUFF_RING].buf[split],
2779 bgep->chipid.std_buf_size);
2783 bgep->buff[BGE_STD_BUFF_RING].buf[split].mem_va,
2784 bgep->buff[BGE_STD_BUFF_RING].buf[split].alength,
2785 bgep->buff[BGE_STD_BUFF_RING].buf[split].offset,
2786 bgep->buff[BGE_STD_BUFF_RING].buf[split].cookie.dmac_laddress,
2787 bgep->buff[BGE_STD_BUFF_RING].buf[split].cookie.dmac_size,
2789 bgep->chipid.std_buf_size));
2791 bge_slice_chunk(&bgep->buff[BGE_JUMBO_BUFF_RING].buf[split],
2792 &area, bgep->chipid.jumbo_slots/BGE_SPLIT,
2793 bgep->chipid.recv_jumbo_size);
2795 if ((bgep->chipid.jumbo_slots / BGE_SPLIT) > 0)
2799 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].mem_va,
2800 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].alength,
2801 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].offset,
2802 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].cookie.dmac_laddress,
2803 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].cookie.dmac_size,
2804 bgep->chipid.jumbo_slots/BGE_SPLIT,
2805 bgep->chipid.recv_jumbo_size));
2808 bge_slice_chunk(&bgep->buff[BGE_MINI_BUFF_RING].buf[split],
2816 bgep->buff[BGE_MINI_BUFF_RING].buf[split].mem_va,
2817 bgep->buff[BGE_MINI_BUFF_RING].buf[split].alength,
2818 bgep->buff[BGE_MINI_BUFF_RING].buf[split].offset,
2819 bgep->buff[BGE_MINI_BUFF_RING].buf[split].cookie.dmac_laddress,
2820 bgep->buff[BGE_MINI_BUFF_RING].buf[split].cookie.dmac_size,
2836 area = bgep->tx_buff[split];
2847 bge_slice_chunk(&bgep->send[ring].buf[0][split],
2849 bgep->chipid.snd_buff_size);
2853 bgep->send[ring].buf[0][split].mem_va,
2854 bgep->send[ring].buf[0][split].alength,
2855 bgep->send[ring].buf[0][split].offset,
2856 bgep->send[ring].buf[0][split].cookie.dmac_laddress,
2857 bgep->send[ring].buf[0][split].cookie.dmac_size,
2859 bgep->chipid.snd_buff_size));
2863 bge_slice_chunk(&bgep->send[ring].buf[0][split],
2864 &area, 0, bgep->chipid.snd_buff_size);
2877 bge_slice_chunk(&bgep->recv[ring].desc, &bgep->rx_desc[ring],
2878 bgep->chipid.recv_slots, sizeof (bge_rbd_t));
2882 bgep->recv[ring].desc.mem_va,
2883 bgep->recv[ring].desc.alength,
2884 bgep->recv[ring].desc.offset,
2885 bgep->recv[ring].desc.cookie.dmac_laddress,
2886 bgep->recv[ring].desc.cookie.dmac_size,
2887 bgep->chipid.recv_slots,
2892 area = bgep->rx_desc[rx_rings]; /* note rx_rings = one beyond rings */
2895 bge_slice_chunk(&bgep->recv[ring].desc, &area,
2905 bge_slice_chunk(&bgep->buff[BGE_STD_BUFF_RING].desc, &area,
2908 bgep->buff[BGE_STD_BUFF_RING].desc.mem_va,
2909 bgep->buff[BGE_STD_BUFF_RING].desc.alength,
2910 bgep->buff[BGE_STD_BUFF_RING].desc.offset,
2911 bgep->buff[BGE_STD_BUFF_RING].desc.cookie.dmac_laddress,
2912 bgep->buff[BGE_STD_BUFF_RING].desc.cookie.dmac_size,
2916 bge_slice_chunk(&bgep->buff[BGE_JUMBO_BUFF_RING].desc, &area,
2917 bgep->chipid.jumbo_slots, sizeof (bge_rbd_t));
2919 bgep->buff[BGE_JUMBO_BUFF_RING].desc.mem_va,
2920 bgep->buff[BGE_JUMBO_BUFF_RING].desc.alength,
2921 bgep->buff[BGE_JUMBO_BUFF_RING].desc.offset,
2922 bgep->buff[BGE_JUMBO_BUFF_RING].desc.cookie.dmac_laddress,
2923 bgep->buff[BGE_JUMBO_BUFF_RING].desc.cookie.dmac_size,
2924 bgep->chipid.jumbo_slots,
2927 bge_slice_chunk(&bgep->buff[BGE_MINI_BUFF_RING].desc, &area,
2930 bgep->buff[BGE_MINI_BUFF_RING].desc.mem_va,
2931 bgep->buff[BGE_MINI_BUFF_RING].desc.alength,
2932 bgep->buff[BGE_MINI_BUFF_RING].desc.offset,
2933 bgep->buff[BGE_MINI_BUFF_RING].desc.cookie.dmac_laddress,
2934 bgep->buff[BGE_MINI_BUFF_RING].desc.cookie.dmac_size,
2947 area = bgep->tx_desc;
2957 bge_slice_chunk(&bgep->send[ring].desc, &area,
2962 bgep->send[ring].desc.mem_va,
2963 bgep->send[ring].desc.alength,
2964 bgep->send[ring].desc.offset,
2965 bgep->send[ring].desc.cookie.dmac_laddress,
2966 bgep->send[ring].desc.cookie.dmac_size,
2972 bge_slice_chunk(&bgep->send[ring].desc, &area,
2975 bge_slice_chunk(&bgep->statistics, &area, 1, sizeof (bge_statistics_t));
2977 bgep->statistics.mem_va,
2978 bgep->statistics.alength,
2979 bgep->statistics.offset,
2980 bgep->statistics.cookie.dmac_laddress,
2981 bgep->statistics.cookie.dmac_size,
2985 bge_slice_chunk(&bgep->status_block, &area, 1, sizeof (bge_status_t));
2987 bgep->status_block.mem_va,
2988 bgep->status_block.alength,
2989 bgep->status_block.offset,
2990 bgep->status_block.cookie.dmac_laddress,
2991 bgep->status_block.cookie.dmac_size,
3004 DMA_ZERO(bgep->status_block);
3017 bge_free_bufs(bge_t *bgep) argument
3022 (void *)bgep));
3024 bge_free_dma_mem(&bgep->tx_desc);
3026 bge_free_dma_mem(&bgep->rx_desc[split]);
3028 bge_free_dma_mem(&bgep->tx_buff[split]);
3030 bge_free_dma_mem(&bgep->rx_buff[split]);
3038 bge_find_mac_address(bge_t *bgep, chip_id_t *cidp) argument
3048 (void *)bgep));
3070 err = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, bgep->devinfo,
3081 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, bgep->devinfo,
3107 err = ddi_getlongprop_buf(DDI_DEV_T_ANY, bgep->devinfo,
3132 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, bgep->devinfo,
3150 bge_check_acc_handle(bge_t *bgep, ddi_acc_handle_t handle) argument
3161 bge_check_dma_handle(bge_t *bgep, ddi_dma_handle_t handle) argument
3165 ASSERT(bgep->progress & PROGRESS_BUFS);
3186 bge_fm_init(bge_t *bgep) argument
3191 if (bgep->fm_capabilities) {
3196 ddi_fm_init(bgep->devinfo, &bgep->fm_capabilities, &iblk);
3201 if (DDI_FM_EREPORT_CAP(bgep->fm_capabilities) ||
3202 DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3203 pci_ereport_setup(bgep->devinfo);
3208 if (DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3209 ddi_fm_handler_register(bgep->devinfo,
3210 bge_fm_error_cb, (void*) bgep);
3222 bge_fm_fini(bge_t *bgep) argument
3225 if (bgep->fm_capabilities) {
3230 if (DDI_FM_EREPORT_CAP(bgep->fm_capabilities) ||
3231 DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3232 pci_ereport_teardown(bgep->devinfo);
3237 if (DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3238 ddi_fm_handler_unregister(bgep->devinfo);
3241 ddi_fm_fini(bgep->devinfo);
3247 bge_unattach(bge_t *bgep, uint_t asf_mode) argument
3249 bge_unattach(bge_t *bgep)
3253 (void *)bgep));
3258 bgep->progress &= ~PROGRESS_READY;
3264 if (bgep->periodic_id != NULL) {
3265 ddi_periodic_delete(bgep->periodic_id);
3266 bgep->periodic_id = NULL;
3269 if (bgep->progress & PROGRESS_KSTATS)
3270 bge_fini_kstats(bgep);
3271 if (bgep->progress & PROGRESS_PHY)
3272 bge_phys_reset(bgep);
3273 if (bgep->progress & PROGRESS_HWINT) {
3274 mutex_enter(bgep->genlock);
3276 if (bge_chip_reset(bgep, B_FALSE, asf_mode) != DDI_SUCCESS)
3278 if (bge_chip_reset(bgep, B_FALSE) != DDI_SUCCESS)
3280 ddi_fm_service_impact(bgep->devinfo,
3283 if (bgep->asf_enabled) {
3288 bge_nic_put32(bgep, BGE_NIC_DATA_SIG_ADDR,
3292 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK)
3293 ddi_fm_service_impact(bgep->devinfo,
3295 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK)
3296 ddi_fm_service_impact(bgep->devinfo,
3298 mutex_exit(bgep->genlock);
3300 if (bgep->progress & PROGRESS_INTR) {
3301 bge_intr_disable(bgep);
3302 bge_fini_rings(bgep);
3304 if (bgep->progress & PROGRESS_HWINT) {
3305 bge_rem_intrs(bgep);
3306 rw_destroy(bgep->errlock);
3307 mutex_destroy(bgep->softintrlock);
3308 mutex_destroy(bgep->genlock);
3310 if (bgep->progress & PROGRESS_FACTOTUM)
3311 ddi_remove_softintr(bgep->factotum_id);
3312 if (bgep->progress & PROGRESS_RESCHED)
3313 ddi_remove_softintr(bgep->drain_id);
3314 if (bgep->progress & PROGRESS_BUFS)
3315 bge_free_bufs(bgep);
3316 if (bgep->progress & PROGRESS_REGS) {
3317 ddi_regs_map_free(&bgep->io_handle);
3318 if (bgep->ape_enabled)
3319 ddi_regs_map_free(&bgep->ape_handle);
3321 if (bgep->progress & PROGRESS_CFG)
3322 pci_config_teardown(&bgep->cfg_handle);
3324 bge_fm_fini(bgep);
3326 ddi_remove_minor_node(bgep->devinfo, NULL);
3327 kmem_free(bgep->pstats, sizeof (bge_statistics_reg_t));
3328 kmem_free(bgep, sizeof (*bgep));
3334 bge_t *bgep; /* Our private data */ local
3338 bgep = ddi_get_driver_private(devinfo);
3339 if (bgep == NULL)
3345 if (bgep->devinfo != devinfo)
3361 cidp = &bgep->chipid;
3362 mutex_enter(bgep->genlock);
3363 bge_chip_cfg_init(bgep, &chipid, B_FALSE);
3364 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3365 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3366 mutex_exit(bgep->genlock);
3369 mutex_exit(bgep->genlock);
3382 mutex_enter(bgep->genlock);
3383 if (bge_restart(bgep, B_TRUE) != DDI_SUCCESS) {
3384 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
3385 (void) bge_check_acc_handle(bgep, bgep->io_handle);
3386 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3387 mutex_exit(bgep->genlock);
3390 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3391 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3392 mutex_exit(bgep->genlock);
3395 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
3396 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3397 mutex_exit(bgep->genlock);
3400 mutex_exit(bgep->genlock);
3405 bge_fw_img_is_valid(bge_t *bgep, uint32_t offset) argument
3409 if (bge_nvmem_read32(bgep, offset, &val) ||
3411 bge_nvmem_read32(bgep, offset + 4, &val) ||
3419 bge_read_mgmtfw_ver(bge_t *bgep) argument
3429 if (bge_nvmem_read32(bgep, offset, &val))
3439 if (bge_nvmem_read32(bgep, offset - 4, &start))
3442 if (bge_nvmem_read32(bgep, offset + 4, &offset) ||
3443 !bge_fw_img_is_valid(bgep, offset) ||
3444 bge_nvmem_read32(bgep, offset + 8, &val))
3449 vlen = strlen(bgep->fw_version);
3451 bgep->fw_version[vlen++] = ',';
3452 bgep->fw_version[vlen++] = ' ';
3457 if (bge_nvmem_read32(bgep, offset, &v))
3465 memcpy(&bgep->fw_version[vlen], &v, BGE_FW_VER_SIZE - vlen);
3469 memcpy(&bgep->fw_version[vlen], &v, sizeof(v));
3475 bge_read_dash_ver(bge_t *bgep) argument
3481 if (!bgep->ape_enabled || !bgep->asf_enabled)
3484 apedata = bge_ape_get32(bgep, BGE_APE_SEG_SIG);
3488 apedata = bge_ape_get32(bgep, BGE_APE_FW_STATUS);
3492 apedata = bge_ape_get32(bgep, BGE_APE_FW_VERSION);
3494 if (bge_ape_get32(bgep, BGE_APE_FW_FEATURES) &
3496 bgep->ape_has_ncsi = B_TRUE;
3498 } else if ((bgep->chipid.device == DEVICE_ID_5725) ||
3499 (bgep->chipid.device == DEVICE_ID_5727)) {
3505 vlen = strlen(bgep->fw_version);
3507 snprintf(&bgep->fw_version[vlen], BGE_FW_VER_SIZE - vlen,
3516 bge_read_bc_ver(bge_t *bgep) argument
3527 if (bge_nvmem_read32(bgep, 0xc, &offset) ||
3528 bge_nvmem_read32(bgep, 0x4, &start))
3531 if (bge_nvmem_read32(bgep, offset, &val))
3535 if (bge_nvmem_read32(bgep, offset + 4, &val))
3542 dst_off = strlen(bgep->fw_version);
3546 bge_nvmem_read32(bgep, offset + 8, &ver_offset))
3551 if (bge_nvmem_read32(bgep, offset + i, &val))
3554 memcpy(bgep->fw_version + dst_off + i, &val,
3558 if (bge_nvmem_read32(bgep, NVM_PTREV_BCVER, &ver_offset))
3563 snprintf(&bgep->fw_version[dst_off], BGE_FW_VER_SIZE - dst_off,
3569 bge_read_fw_ver(bge_t *bgep) argument
3574 *bgep->fw_version = 0;
3576 if ((bgep->chipid.nvtype == BGE_NVTYPE_NONE) ||
3577 (bgep->chipid.nvtype == BGE_NVTYPE_UNKNOWN)) {
3578 snprintf(bgep->fw_version, sizeof(bgep->fw_version), "sb");
3582 mutex_enter(bgep->genlock);
3584 bge_nvmem_read32(bgep, 0, &magic);
3587 bge_read_bc_ver(bgep);
3590 mutex_exit(bgep->genlock);
3594 if (bgep->ape_enabled) {
3595 if (bgep->asf_enabled) {
3596 bge_read_dash_ver(bgep);
3598 } else if (bgep->asf_enabled) {
3599 bge_read_mgmtfw_ver(bgep);
3602 mutex_exit(bgep->genlock);
3604 bgep->fw_version[BGE_FW_VER_SIZE - 1] = 0; /* safety */
3615 bge_t *bgep; /* Our private data */ local
3653 bgep = kmem_zalloc(sizeof (*bgep), KM_SLEEP);
3654 bgep->pstats = kmem_zalloc(sizeof (bge_statistics_reg_t), KM_SLEEP);
3655 ddi_set_driver_private(devinfo, bgep);
3656 bgep->bge_guard = BGE_GUARD;
3657 bgep->devinfo = devinfo;
3658 bgep->param_drain_max = 64;
3659 bgep->param_msi_cnt = 0;
3660 bgep->param_loop_mode = 0;
3665 bgep->debug = ddi_prop_get_int(DDI_DEV_T_ANY, devinfo,
3667 (void) snprintf(bgep->ifname, sizeof (bgep->ifname), "%s%d",
3673 bgep->fm_capabilities = ddi_prop_get_int(DDI_DEV_T_ANY, devinfo,
3677 BGE_DEBUG(("bgep->fm_capabilities = %d", bgep->fm_capabilities));
3678 bge_fm_init(bgep);
3687 bgep->pagemask = dvma_pagesize(devinfo);
3688 ASSERT(ddi_ffs(bgep->pagemask) == ddi_fls(bgep->pagemask));
3689 bgep->pagemask = -bgep->pagemask;
3702 err = pci_config_setup(devinfo, &bgep->cfg_handle);
3704 bgep->ape_enabled = B_FALSE;
3705 bgep->ape_regs = NULL;
3707 cidp = &bgep->chipid;
3708 cidp->device = pci_config_get16(bgep->cfg_handle, PCI_CONF_DEVID);
3709 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3710 DEVICE_5725_SERIES_CHIPSETS(bgep)) {
3712 ®s, 0, 0, &bge_reg_accattr, &bgep->ape_handle);
3714 ddi_regs_map_free(&bgep->io_handle);
3715 bge_problem(bgep, "ddi_regs_map_setup() failed");
3718 bgep->ape_regs = regs;
3719 bgep->ape_enabled = B_TRUE;
3726 pci_state_reg = pci_config_get32(bgep->cfg_handle,
3730 pci_config_put32(bgep->cfg_handle,
3732 bge_ape_lock_init(bgep);
3742 value16 = pci_config_get16(bgep->cfg_handle, PCI_CONF_COMM);
3744 pci_config_put16(bgep->cfg_handle, PCI_CONF_COMM, value16);
3757 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3758 DEVICE_5725_SERIES_CHIPSETS(bgep) ||
3759 DEVICE_57765_SERIES_CHIPSETS(bgep))
3760 pci_config_put32(bgep->cfg_handle, PCI_CONF_BGE_MHCR, 0);
3768 pci_config_put32(bgep->cfg_handle, PCI_CONF_BGE_MHCR, mhcrValue);
3769 bge_ind_put32(bgep, MEMORY_ARBITER_MODE_REG,
3770 bge_ind_get32(bgep, MEMORY_ARBITER_MODE_REG) |
3773 bgep->asf_wordswapped = B_TRUE;
3775 bgep->asf_wordswapped = B_FALSE;
3777 bge_asf_get_config(bgep);
3780 bge_problem(bgep, "pci_config_setup() failed");
3783 bgep->progress |= PROGRESS_CFG;
3784 bge_chip_cfg_init(bgep, cidp, B_FALSE);
3785 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3786 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3791 if (DEVICE_5721_SERIES_CHIPSETS(bgep) ||
3792 DEVICE_5714_SERIES_CHIPSETS(bgep)) {
3793 bgep->asf_newhandshake = B_TRUE;
3795 bgep->asf_newhandshake = B_FALSE;
3830 ®s, 0, 0, &bge_reg_accattr, &bgep->io_handle);
3832 bge_problem(bgep, "ddi_regs_map_setup() failed");
3835 bgep->io_regs = regs;
3837 bgep->progress |= PROGRESS_REGS;
3843 if (bge_chip_id_init(bgep) == EIO) {
3844 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3848 err = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, bgep->devinfo,
3851 bgep->pci_bus = PCI_REG_BUS_G(props[0]);
3852 bgep->pci_dev = PCI_REG_DEV_G(props[0]);
3853 bgep->pci_func = PCI_REG_FUNC_G(props[0]);
3857 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3858 DEVICE_5725_SERIES_CHIPSETS(bgep)) {
3859 regval = bge_reg_get32(bgep, CPMU_STATUS_REG);
3860 if ((bgep->chipid.device == DEVICE_ID_5719) ||
3861 (bgep->chipid.device == DEVICE_ID_5720)) {
3862 bgep->pci_func =
3866 bgep->pci_func = ((regval & CPMU_STATUS_FUNC_NUM) >>
3871 err = bge_alloc_bufs(bgep);
3873 bge_problem(bgep, "DMA buffer allocation failed");
3876 bgep->progress |= PROGRESS_BUFS;
3900 err = ddi_add_softintr(devinfo, DDI_SOFTINT_LOW, &bgep->drain_id,
3901 NULL, NULL, bge_send_drain, (caddr_t)bgep);
3903 bge_problem(bgep, "ddi_add_softintr() failed");
3906 bgep->progress |= PROGRESS_RESCHED;
3907 err = ddi_add_softintr(devinfo, DDI_SOFTINT_LOW, &bgep->factotum_id,
3908 NULL, NULL, bge_chip_factotum, (caddr_t)bgep);
3910 bge_problem(bgep, "ddi_add_softintr() failed");
3913 bgep->progress |= PROGRESS_FACTOTUM;
3917 bge_error(bgep, "ddi_intr_get_supported_types failed\n");
3923 bgep->ifname, intr_types));
3925 if ((intr_types & DDI_INTR_TYPE_MSI) && bgep->chipid.msi_enabled) {
3926 if (bge_add_intrs(bgep, DDI_INTR_TYPE_MSI) != DDI_SUCCESS) {
3927 bge_error(bgep, "MSI registration failed, "
3931 bgep->ifname));
3932 bgep->intr_type = DDI_INTR_TYPE_MSI;
3933 bgep->progress |= PROGRESS_HWINT;
3937 if (!(bgep->progress & PROGRESS_HWINT) &&
3939 if (bge_add_intrs(bgep, DDI_INTR_TYPE_FIXED) != DDI_SUCCESS) {
3940 bge_error(bgep, "FIXED interrupt "
3945 BGE_DEBUG(("%s: Using FIXED interrupt type", bgep->ifname));
3947 bgep->intr_type = DDI_INTR_TYPE_FIXED;
3948 bgep->progress |= PROGRESS_HWINT;
3951 if (!(bgep->progress & PROGRESS_HWINT)) {
3952 bge_error(bgep, "No interrupts registered\n");
3960 mutex_init(bgep->genlock, NULL, MUTEX_DRIVER,
3961 DDI_INTR_PRI(bgep->intr_pri));
3962 mutex_init(bgep->softintrlock, NULL, MUTEX_DRIVER,
3963 DDI_INTR_PRI(bgep->intr_pri));
3964 rw_init(bgep->errlock, NULL, RW_DRIVER,
3965 DDI_INTR_PRI(bgep->intr_pri));
3970 bge_init_rings(bgep);
3975 bge_intr_enable(bgep);
3976 bgep->progress |= PROGRESS_INTR;
3983 bgep->link_state = LINK_STATE_UNKNOWN;
3985 mutex_enter(bgep->genlock);
3993 if (bge_reset(bgep, ASF_MODE_INIT) != DDI_SUCCESS) {
3995 if (bge_reset(bgep, ASF_MODE_SHUTDOWN) != DDI_SUCCESS) {
3998 if (bge_reset(bgep) != DDI_SUCCESS) {
4000 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
4001 (void) bge_check_acc_handle(bgep, bgep->io_handle);
4002 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4003 mutex_exit(bgep->genlock);
4008 if (bgep->asf_enabled) {
4009 bgep->asf_status = ASF_STAT_RUN_INIT;
4013 bzero(bgep->mcast_hash, sizeof (bgep->mcast_hash));
4014 bzero(bgep->mcast_refs, sizeof (bgep->mcast_refs));
4015 bgep->promisc = B_FALSE;
4016 bgep->param_loop_mode = BGE_LOOP_NONE;
4017 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
4018 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4019 mutex_exit(bgep->genlock);
4022 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
4023 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4024 mutex_exit(bgep->genlock);
4028 mutex_exit(bgep->genlock);
4030 if (bge_phys_init(bgep) == EIO) {
4031 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4034 bgep->progress |= PROGRESS_PHY;
4039 if (bge_nd_init(bgep)) {
4040 bge_problem(bgep, "bge_nd_init() failed");
4043 bgep->progress |= PROGRESS_NDD;
4048 bge_init_kstats(bgep, instance);
4049 bgep->progress |= PROGRESS_KSTATS;
4054 bge_find_mac_address(bgep, cidp);
4056 bge_read_fw_ver(bgep);
4058 bgep->unicst_addr_total = MAC_ADDRESS_REGS_MAX;
4059 bgep->unicst_addr_avail = MAC_ADDRESS_REGS_MAX;
4064 macp->m_driver = bgep;
4078 err = mac_register(macp, &bgep->mh);
4083 mac_link_update(bgep->mh, LINK_STATE_UNKNOWN);
4089 bgep->periodic_id = ddi_periodic_add(bge_chip_cyclic, bgep,
4092 bgep->progress |= PROGRESS_READY;
4093 ASSERT(bgep->bge_guard == BGE_GUARD);
4096 if (bgep->asf_enabled) {
4097 mutex_enter(bgep->genlock);
4098 retval = bge_chip_start(bgep, B_TRUE);
4099 mutex_exit(bgep->genlock);
4112 bge_unattach(bgep, ASF_MODE_SHUTDOWN);
4114 bge_unattach(bgep);
4123 bge_suspend(bge_t *bgep) argument
4128 mutex_enter(bgep->genlock);
4136 bge_stop(bgep);
4137 if (bge_phys_idle(bgep) != DDI_SUCCESS) {
4138 (void) bge_check_acc_handle(bgep, bgep->io_handle);
4139 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4140 mutex_exit(bgep->genlock);
4143 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
4144 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4145 mutex_exit(bgep->genlock);
4148 mutex_exit(bgep->genlock);
4169 bge_t *bgep = ddi_get_driver_private(devinfo); local
4171 if (bgep == NULL)
4174 if (bgep->intr_type == DDI_INTR_TYPE_FIXED) {
4175 bge_reg_set32(bgep, PCI_CONF_BGE_MHCR,
4178 bge_reg_clr32(bgep, MSI_MODE_REG, MSI_MSI_ENABLE);
4182 bge_chip_stop_nonblocking(bgep);
4194 bge_t *bgep; local
4202 bgep = ddi_get_driver_private(devinfo);
4209 return (bge_suspend(bgep));
4216 mutex_enter(bgep->genlock);
4217 if (bgep->asf_enabled && ((bgep->asf_status == ASF_STAT_RUN) ||
4218 (bgep->asf_status == ASF_STAT_RUN_INIT))) {
4220 bge_asf_update_status(bgep);
4221 if (bgep->asf_status == ASF_STAT_RUN) {
4222 bge_asf_stop_timer(bgep);
4224 bgep->asf_status = ASF_STAT_STOP;
4226 bge_asf_pre_reset_operations(bgep, BGE_SHUTDOWN_RESET);
4228 if (bgep->asf_pseudostop) {
4229 bge_chip_stop(bgep, B_FALSE);
4230 bgep->bge_mac_state = BGE_MAC_STOPPED;
4231 bgep->asf_pseudostop = B_FALSE;
4236 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK)
4237 ddi_fm_service_impact(bgep->devinfo,
4239 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK)
4240 ddi_fm_service_impact(bgep->devinfo,
4243 mutex_exit(bgep->genlock);
4252 if (mac_unregister(bgep->mh) != 0)
4259 bge_unattach(bgep, asf_mode);
4261 bge_unattach(bgep);
4337 bge_add_intrs(bge_t *bgep, int intr_type) argument
4339 dev_info_t *dip = bgep->devinfo;
4343 BGE_DEBUG(("bge_add_intrs($%p, 0x%x)", (void *)bgep, intr_type));
4348 bge_error(bgep, "ddi_intr_get_nintrs() failure, ret: %d, "
4357 bge_error(bgep, "ddi_intr_get_navail() failure, "
4365 bgep->ifname, count, avail));
4381 bgep->htable = kmem_alloc(intr_size, KM_SLEEP);
4384 ret = ddi_intr_alloc(dip, bgep->htable, intr_type, 0,
4388 bge_error(bgep, "ddi_intr_alloc() failed %d\n", ret);
4390 kmem_free(bgep->htable, intr_size);
4396 bgep->ifname, count, actual));
4399 bgep->intr_cnt = actual;
4404 if ((ret = ddi_intr_get_pri(bgep->htable[0], &bgep->intr_pri)) !=
4406 bge_error(bgep, "ddi_intr_get_pri() failed %d\n", ret);
4410 (void) ddi_intr_free(bgep->htable[i]);
4413 kmem_free(bgep->htable, intr_size);
4419 if ((ret = ddi_intr_add_handler(bgep->htable[i], bge_intr,
4420 (caddr_t)bgep, (caddr_t)(uintptr_t)i)) != DDI_SUCCESS) {
4421 bge_error(bgep, "ddi_intr_add_handler() "
4426 (void) ddi_intr_free(bgep->htable[i]);
4429 kmem_free(bgep->htable, intr_size);
4434 if ((ret = ddi_intr_get_cap(bgep->htable[0], &bgep->intr_cap))
4436 bge_error(bgep, "ddi_intr_get_cap() failed %d\n", ret);
4439 (void) ddi_intr_remove_handler(bgep->htable[i]);
4440 (void) ddi_intr_free(bgep->htable[i]);
4443 kmem_free(bgep->htable, intr_size);
4456 bge_rem_intrs(bge_t *bgep) argument
4460 BGE_DEBUG(("bge_rem_intrs($%p)", (void *)bgep));
4463 for (i = 0; i < bgep->intr_cnt; i++) {
4464 (void) ddi_intr_remove_handler(bgep->htable[i]);
4465 (void) ddi_intr_free(bgep->htable[i]);
4468 kmem_free(bgep->htable, bgep->intr_cnt * sizeof (ddi_intr_handle_t));
4473 bge_intr_enable(bge_t *bgep) argument
4477 if (bgep->intr_cap & DDI_INTR_FLAG_BLOCK) {
4479 (void) ddi_intr_block_enable(bgep->htable, bgep->intr_cnt);
4482 for (i = 0; i < bgep->intr_cnt; i++) {
4483 (void) ddi_intr_enable(bgep->htable[i]);
4490 bge_intr_disable(bge_t *bgep) argument
4494 if (bgep->intr_cap & DDI_INTR_FLAG_BLOCK) {
4496 (void) ddi_intr_block_disable(bgep->htable, bgep->intr_cnt);
4498 for (i = 0; i < bgep->intr_cnt; i++) {
4499 (void) ddi_intr_disable(bgep->htable[i]);
4505 bge_reprogram(bge_t *bgep) argument
4509 ASSERT(mutex_owned(bgep->genlock));
4511 if (bge_phys_update(bgep) != DDI_SUCCESS) {
4512 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4516 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
4518 if (bge_chip_sync(bgep) == DDI_FAILURE) {
4520 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4523 if (bgep->intr_type == DDI_INTR_TYPE_MSI)
4524 bge_chip_msi_trig(bgep);