Lines Matching defs:bgep
333 bge_reinit_rings(bge_t *bgep)
337 ASSERT(mutex_owned(bgep->genlock));
342 for (ring = 0; ring < bgep->chipid.tx_rings; ++ring)
343 bge_reinit_send_ring(&bgep->send[ring]);
348 for (ring = 0; ring < bgep->chipid.rx_rings; ++ring)
349 bge_reinit_recv_ring(&bgep->recv[ring]);
355 bge_reinit_buff_ring(&bgep->buff[ring], ring);
377 bge_reset(bge_t *bgep, uint_t asf_mode)
379 bge_reset(bge_t *bgep)
385 BGE_TRACE(("bge_reset($%p)", (void *)bgep));
387 ASSERT(mutex_owned(bgep->genlock));
394 mutex_enter(bgep->recv[ring].rx_lock);
396 mutex_enter(bgep->buff[ring].rf_lock);
397 rw_enter(bgep->errlock, RW_WRITER);
399 mutex_enter(bgep->send[ring].tx_lock);
401 mutex_enter(bgep->send[ring].tc_lock);
404 retval = bge_chip_reset(bgep, B_TRUE, asf_mode);
406 retval = bge_chip_reset(bgep, B_TRUE);
408 bge_reinit_rings(bgep);
414 mutex_exit(bgep->send[ring].tc_lock);
416 mutex_exit(bgep->send[ring].tx_lock);
417 rw_exit(bgep->errlock);
419 mutex_exit(bgep->buff[ring].rf_lock);
421 mutex_exit(bgep->recv[ring].rx_lock);
423 BGE_DEBUG(("bge_reset($%p) done", (void *)bgep));
431 bge_stop(bge_t *bgep)
433 BGE_TRACE(("bge_stop($%p)", (void *)bgep));
435 ASSERT(mutex_owned(bgep->genlock));
438 if (bgep->asf_enabled) {
439 bgep->asf_pseudostop = B_TRUE;
442 bge_chip_stop(bgep, B_FALSE);
447 BGE_DEBUG(("bge_stop($%p) done", (void *)bgep));
454 bge_start(bge_t *bgep, boolean_t reset_phys)
458 BGE_TRACE(("bge_start($%p, %d)", (void *)bgep, reset_phys));
460 ASSERT(mutex_owned(bgep->genlock));
465 retval = bge_chip_start(bgep, reset_phys);
467 BGE_DEBUG(("bge_start($%p, %d) done", (void *)bgep, reset_phys));
475 bge_restart(bge_t *bgep, boolean_t reset_phys)
478 ASSERT(mutex_owned(bgep->genlock));
481 if (bgep->asf_enabled) {
482 if (bge_reset(bgep, ASF_MODE_POST_INIT) != DDI_SUCCESS)
485 if (bge_reset(bgep, ASF_MODE_NONE) != DDI_SUCCESS)
488 if (bge_reset(bgep) != DDI_SUCCESS)
491 if (bgep->bge_mac_state == BGE_MAC_STARTED) {
492 if (bge_start(bgep, reset_phys) != DDI_SUCCESS)
494 bgep->watchdog = 0;
495 ddi_trigger_softintr(bgep->drain_id);
498 BGE_DEBUG(("bge_restart($%p, %d) done", (void *)bgep, reset_phys));
516 bge_t *bgep = arg; /* private device info */
525 mutex_enter(bgep->genlock);
526 if (!(bgep->progress & PROGRESS_INTR)) {
528 bgep->bge_chip_state = BGE_CHIP_STOPPED;
530 bge_stop(bgep);
532 bgep->link_state = LINK_STATE_UNKNOWN;
533 mac_link_update(bgep->mh, bgep->link_state);
539 if (!bgep->asf_pseudostop)
542 rw_enter(bgep->errlock, RW_WRITER);
543 for (ring = 0; ring < bgep->chipid.tx_rings; ++ring) {
544 srp = &bgep->send[ring];
550 rw_exit(bgep->errlock);
552 bgep->bge_mac_state = BGE_MAC_STOPPED;
554 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK)
555 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_UNAFFECTED);
556 mutex_exit(bgep->genlock);
565 bge_t *bgep = arg; /* private device info */
572 mutex_enter(bgep->genlock);
573 if (!(bgep->progress & PROGRESS_INTR)) {
575 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
576 mutex_exit(bgep->genlock);
580 if (bgep->asf_enabled) {
581 if ((bgep->asf_status == ASF_STAT_RUN) &&
582 (bgep->asf_pseudostop)) {
583 bgep->bge_mac_state = BGE_MAC_STARTED;
585 bge_phys_check(bgep);
586 bgep->link_state = (bgep->param_link_up) ? LINK_STATE_UP :
588 mac_link_update(bgep->mh, bgep->link_state);
589 mutex_exit(bgep->genlock);
593 if (bge_reset(bgep, ASF_MODE_INIT) != DDI_SUCCESS) {
595 if (bge_reset(bgep) != DDI_SUCCESS) {
597 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
598 (void) bge_check_acc_handle(bgep, bgep->io_handle);
599 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
600 mutex_exit(bgep->genlock);
603 if (bge_start(bgep, B_TRUE) != DDI_SUCCESS) {
604 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
605 (void) bge_check_acc_handle(bgep, bgep->io_handle);
606 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
607 mutex_exit(bgep->genlock);
610 bgep->watchdog = 0;
611 bgep->bge_mac_state = BGE_MAC_STARTED;
614 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
615 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
616 mutex_exit(bgep->genlock);
619 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
620 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
621 mutex_exit(bgep->genlock);
625 if (bgep->asf_enabled) {
626 if (bgep->asf_status != ASF_STAT_RUN) {
628 bgep->asf_timeout_id = timeout(bge_asf_heartbeat,
629 (void *)bgep,
631 bgep->asf_status = ASF_STAT_RUN;
635 mutex_exit(bgep->genlock);
646 bge_t *bgep = arg; /* private device info */
654 mutex_enter(bgep->genlock);
655 if (!(bgep->progress & PROGRESS_INTR)) {
657 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
658 mutex_exit(bgep->genlock);
661 ethaddr_copy(macaddr, bgep->curr_addr[slot].addr);
663 if (bge_chip_sync(bgep, B_FALSE) == DDI_FAILURE) {
665 if (bge_chip_sync(bgep) == DDI_FAILURE) {
667 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
668 (void) bge_check_acc_handle(bgep, bgep->io_handle);
669 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
670 mutex_exit(bgep->genlock);
674 if (bgep->asf_enabled) {
680 if (bgep->asf_status == ASF_STAT_RUN) {
686 bge_asf_update_status(bgep);
687 bge_asf_stop_timer(bgep);
688 bgep->asf_status = ASF_STAT_STOP;
690 bge_asf_pre_reset_operations(bgep, BGE_INIT_RESET);
692 bge_chip_stop(bgep, B_FALSE);
694 if (bge_restart(bgep, B_FALSE) == DDI_FAILURE) {
695 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
696 (void) bge_check_acc_handle(bgep, bgep->io_handle);
697 ddi_fm_service_impact(bgep->devinfo,
699 mutex_exit(bgep->genlock);
706 if (bgep->asf_status != ASF_STAT_RUN) {
708 bgep->asf_timeout_id = timeout(bge_asf_heartbeat,
709 (void *)bgep,
711 bgep->asf_status = ASF_STAT_RUN;
716 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
717 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
718 mutex_exit(bgep->genlock);
721 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
722 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
723 mutex_exit(bgep->genlock);
726 mutex_exit(bgep->genlock);
766 bge_t *bgep = barg;
771 mutex_enter(bgep->genlock);
772 if (bgep->param_loop_mode != BGE_LOOP_NONE &&
778 mutex_exit(bgep->genlock);
781 if ((bgep->chipid.flags & CHIP_FLAG_SERDES) &&
790 mutex_exit(bgep->genlock);
793 if (DEVICE_5906_SERIES_CHIPSETS(bgep) &&
796 mutex_exit(bgep->genlock);
802 bgep->param_en_1000fdx = *(uint8_t *)pr_val;
803 bgep->param_adv_1000fdx = *(uint8_t *)pr_val;
806 bgep->param_en_1000hdx = *(uint8_t *)pr_val;
807 bgep->param_adv_1000hdx = *(uint8_t *)pr_val;
810 bgep->param_en_100fdx = *(uint8_t *)pr_val;
811 bgep->param_adv_100fdx = *(uint8_t *)pr_val;
814 bgep->param_en_100hdx = *(uint8_t *)pr_val;
815 bgep->param_adv_100hdx = *(uint8_t *)pr_val;
818 bgep->param_en_10fdx = *(uint8_t *)pr_val;
819 bgep->param_adv_10fdx = *(uint8_t *)pr_val;
822 bgep->param_en_10hdx = *(uint8_t *)pr_val;
823 bgep->param_adv_10hdx = *(uint8_t *)pr_val;
825 if (err == 0 && bge_reprogram(bgep) == IOC_INVAL)
840 bgep->param_adv_autoneg = *(uint8_t *)pr_val;
841 if (bge_reprogram(bgep) == IOC_INVAL)
845 cur_mtu = bgep->chipid.default_mtu;
858 (bgep->chipid.flags & CHIP_FLAG_NO_JUMBO)) {
862 if (bgep->bge_mac_state == BGE_MAC_STARTED) {
866 bgep->chipid.default_mtu = new_mtu;
867 if (bge_chip_id_init(bgep)) {
871 bgep->bge_dma_error = B_TRUE;
872 bgep->manual_reset = B_TRUE;
873 bge_chip_stop(bgep, B_TRUE);
874 bge_wake_factotum(bgep);
884 bgep->param_adv_pause = 0;
885 bgep->param_adv_asym_pause = 0;
887 bgep->param_link_rx_pause = B_FALSE;
888 bgep->param_link_tx_pause = B_FALSE;
891 bgep->param_adv_pause = 1;
892 bgep->param_adv_asym_pause = 1;
894 bgep->param_link_rx_pause = B_TRUE;
895 bgep->param_link_tx_pause = B_FALSE;
898 bgep->param_adv_pause = 0;
899 bgep->param_adv_asym_pause = 1;
901 bgep->param_link_rx_pause = B_FALSE;
902 bgep->param_link_tx_pause = B_TRUE;
905 bgep->param_adv_pause = 1;
906 bgep->param_adv_asym_pause = 0;
908 bgep->param_link_rx_pause = B_TRUE;
909 bgep->param_link_tx_pause = B_TRUE;
914 if (bge_reprogram(bgep) == IOC_INVAL)
920 err = bge_set_priv_prop(bgep, pr_name, pr_valsize,
927 mutex_exit(bgep->genlock);
936 bge_t *bgep = barg;
942 bcopy(&bgep->param_link_duplex, pr_val,
946 uint64_t speed = bgep->param_link_speed * 1000000ull;
954 bcopy(&bgep->link_state, pr_val,
958 *(uint8_t *)pr_val = bgep->param_adv_autoneg;
965 if (bgep->param_link_rx_pause &&
966 !bgep->param_link_tx_pause)
969 if (!bgep->param_link_rx_pause &&
970 !bgep->param_link_tx_pause)
973 if (!bgep->param_link_rx_pause &&
974 bgep->param_link_tx_pause)
977 if (bgep->param_link_rx_pause &&
978 bgep->param_link_tx_pause)
984 *(uint8_t *)pr_val = bgep->param_adv_1000fdx;
987 *(uint8_t *)pr_val = bgep->param_en_1000fdx;
990 *(uint8_t *)pr_val = bgep->param_adv_1000hdx;
993 *(uint8_t *)pr_val = bgep->param_en_1000hdx;
996 *(uint8_t *)pr_val = bgep->param_adv_100fdx;
999 *(uint8_t *)pr_val = bgep->param_en_100fdx;
1002 *(uint8_t *)pr_val = bgep->param_adv_100hdx;
1005 *(uint8_t *)pr_val = bgep->param_en_100hdx;
1008 *(uint8_t *)pr_val = bgep->param_adv_10fdx;
1011 *(uint8_t *)pr_val = bgep->param_en_10fdx;
1014 *(uint8_t *)pr_val = bgep->param_adv_10hdx;
1017 *(uint8_t *)pr_val = bgep->param_en_10hdx;
1024 err = bge_get_priv_prop(bgep, pr_name,
1037 bge_t *bgep = barg;
1038 int flags = bgep->chipid.flags;
1062 if (DEVICE_5906_SERIES_CHIPSETS(bgep))
1096 mutex_enter(bgep->genlock);
1097 if ((bgep->param_loop_mode != BGE_LOOP_NONE &&
1099 ((bgep->chipid.flags & CHIP_FLAG_SERDES) &&
1104 (DEVICE_5906_SERIES_CHIPSETS(bgep) &&
1108 mutex_exit(bgep->genlock);
1113 bge_set_priv_prop(bge_t *bgep, const char *pr_name, uint_t pr_valsize,
1124 bgep->param_adv_pause = (uint32_t)result;
1125 if (bge_reprogram(bgep) == IOC_INVAL)
1135 bgep->param_adv_asym_pause = (uint32_t)result;
1136 if (bge_reprogram(bgep) == IOC_INVAL)
1160 bgep->param_drain_max = (uint32_t)result;
1161 if (bge_reprogram(bgep) == IOC_INVAL)
1176 bgep->param_msi_cnt = (uint32_t)result;
1177 if (bge_reprogram(bgep) == IOC_INVAL)
1188 bgep->chipid.rx_ticks_norm = (uint32_t)result;
1189 bge_chip_coalesce_update(bgep);
1201 bgep->chipid.rx_count_norm = (uint32_t)result;
1202 bge_chip_coalesce_update(bgep);
1212 bgep->chipid.tx_ticks_norm = (uint32_t)result;
1213 bge_chip_coalesce_update(bgep);
1225 bgep->chipid.tx_count_norm = (uint32_t)result;
1226 bge_chip_coalesce_update(bgep);
1295 bge_t *bgep = arg;
1299 for (i = 0; i < MIN(bgep->chipid.rx_rings, MAC_ADDRESS_REGS_MAX); i++)
1300 bge_addmac(&bgep->recv[i], mac_addr);
1327 bge_t *bgep = arg; /* private device info */
1344 refp = &bgep->mcast_refs[index];
1356 mutex_enter(bgep->genlock);
1357 if (!(bgep->progress & PROGRESS_INTR)) {
1359 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1360 mutex_exit(bgep->genlock);
1365 bgep->mcast_hash[word] |= bit;
1367 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1369 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1371 (void) bge_check_acc_handle(bgep,
1372 bgep->cfg_handle);
1373 (void) bge_check_acc_handle(bgep,
1374 bgep->io_handle);
1375 ddi_fm_service_impact(bgep->devinfo,
1377 mutex_exit(bgep->genlock);
1383 bgep->mcast_hash[word] &= ~bit;
1385 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1387 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1389 (void) bge_check_acc_handle(bgep,
1390 bgep->cfg_handle);
1391 (void) bge_check_acc_handle(bgep,
1392 bgep->io_handle);
1393 ddi_fm_service_impact(bgep->devinfo,
1395 mutex_exit(bgep->genlock);
1401 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
1402 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1403 mutex_exit(bgep->genlock);
1406 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
1407 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1408 mutex_exit(bgep->genlock);
1411 mutex_exit(bgep->genlock);
1425 bge_t *bgep = arg;
1432 mutex_enter(bgep->genlock);
1433 if (!(bgep->progress & PROGRESS_INTR)) {
1435 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1436 mutex_exit(bgep->genlock);
1439 bgep->promisc = on;
1441 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
1443 if (bge_chip_sync(bgep) == DDI_FAILURE) {
1445 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
1446 (void) bge_check_acc_handle(bgep, bgep->io_handle);
1447 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1448 mutex_exit(bgep->genlock);
1452 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
1453 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1454 mutex_exit(bgep->genlock);
1457 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
1458 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
1459 mutex_exit(bgep->genlock);
1462 mutex_exit(bgep->genlock);
1479 bge_t *bgep = arg;
1485 mrf.mrf_arg = (void *)bgep;
1490 bgep->macRxResourceHandles[i] =
1491 mac_resource_add(bgep->mh, (mac_resource_t *)&mrf);
1501 bge_unicst_find(bge_t *bgep, const uint8_t *mac_addr)
1505 ASSERT(mutex_owned(bgep->genlock));
1507 for (slot = 0; slot < bgep->unicst_addr_total; slot++) {
1508 if (bcmp(bgep->curr_addr[slot].addr, mac_addr, ETHERADDRL) == 0)
1523 bge_t *bgep = rrp->bgep;
1524 bge_recv_rule_t *rulep = bgep->recv_rules;
1526 uint8_t ring = (uint8_t)(rrp - bgep->recv) + 1;
1533 mutex_enter(bgep->genlock);
1534 if (bgep->unicst_addr_avail == 0) {
1535 mutex_exit(bgep->genlock);
1542 slot = bge_unicst_find(bgep, mac_addr);
1545 for (slot = 0; slot < bgep->unicst_addr_total; slot++) {
1546 if (!bgep->curr_addr[slot].set) {
1547 bgep->curr_addr[slot].set = B_TRUE;
1552 ASSERT(slot < bgep->unicst_addr_total);
1553 bgep->unicst_addr_avail--;
1554 mutex_exit(bgep->genlock);
1556 if ((err = bge_unicst_set(bgep, mac_addr, slot)) != 0)
1589 bge_reg_put32(bgep, RECV_RULE_MASK_REG(i), rulep[i].mask_value);
1590 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(i), rulep[i].control);
1595 bge_reg_put32(bgep, RECV_RULE_MASK_REG(i+1), rulep[i+1].mask_value);
1596 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(i+1), rulep[i+1].control);
1607 (void) bge_unicst_set(bgep, zero_addr, slot);
1608 mutex_enter(bgep->genlock);
1609 bgep->curr_addr[slot].set = B_FALSE;
1610 bgep->unicst_addr_avail++;
1611 mutex_exit(bgep->genlock);
1623 bge_t *bgep = rrp->bgep;
1624 bge_recv_rule_t *rulep = bgep->recv_rules;
1633 mutex_enter(bgep->genlock);
1634 slot = bge_unicst_find(bgep, mac_addr);
1636 mutex_exit(bgep->genlock);
1640 ASSERT(bgep->curr_addr[slot].set);
1641 mutex_exit(bgep->genlock);
1643 if ((err = bge_unicst_set(bgep, zero_addr, slot)) != 0)
1652 bge_reg_put32(bgep, RECV_RULE_MASK_REG(start), rulep[start].mask_value);
1653 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(start), rulep[start].control);
1657 bge_reg_put32(bgep, RECV_RULE_MASK_REG(start), rulep[start].mask_value);
1658 bge_reg_put32(bgep, RECV_RULE_CONTROL_REG(start), rulep[start].control);
1664 mutex_enter(bgep->genlock);
1665 bgep->curr_addr[slot].set = B_FALSE;
1666 bgep->unicst_addr_avail++;
1667 mutex_exit(bgep->genlock);
1677 bge_t *bgep = rrp->bgep;
1679 mutex_enter(bgep->genlock);
1681 mutex_exit(bgep->genlock);
1690 bge_t *bgep = rrp->bgep;
1692 mutex_enter(bgep->genlock);
1694 mutex_exit(bgep->genlock);
1720 bge_t *bgep = arg;
1726 ASSERT(rg_index >= 0 && rg_index < MIN(bgep->chipid.rx_rings,
1729 rx_ring = &bgep->recv[rg_index];
1761 bge_t *bgep = arg;
1767 ASSERT(rg_index >= 0 && rg_index < MIN(bgep->chipid.rx_rings,
1769 rx_ring = &bgep->recv[rg_index];
1792 bge_t *bgep = arg;
1813 MIN(bgep->chipid.rx_rings, MAC_ADDRESS_REGS_MAX);
1840 bge_set_loop_mode(bge_t *bgep, uint32_t mode)
1845 if (mode == bgep->param_loop_mode)
1870 bgep->param_loop_mode = mode;
1875 bge_loop_ioctl(bge_t *bgep, queue_t *wq, mblk_t *mp, struct iocblk *iocp)
1894 bge_error(bgep, "bge_loop_ioctl: invalid cmd 0x%x", cmd);
1915 *lbmp = bgep->param_loop_mode;
1922 return (bge_set_loop_mode(bgep, *lbmp));
1934 bge_t *bgep = arg;
1990 mutex_enter(bgep->genlock);
1991 if (!(bgep->progress & PROGRESS_INTR)) {
1993 mutex_exit(bgep->genlock);
2016 status = bge_chip_ioctl(bgep, wq, mp, iocp);
2024 status = bge_loop_ioctl(bgep, wq, mp, iocp);
2040 if (bge_reprogram(bgep) == IOC_INVAL)
2045 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
2046 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
2049 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
2050 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
2053 mutex_exit(bgep->genlock);
2104 bge_alloc_dma_mem(bge_t *bgep, size_t memsize, ddi_device_acc_attr_t *attr_p,
2111 (void *)bgep, memsize, attr_p, dma_flags, dma_p));
2116 err = ddi_dma_alloc_handle(bgep->devinfo, &dma_attr,
2206 bge_init_buff_ring(bge_t *bgep, uint64_t ring)
2234 (void *)bgep, ring));
2236 brp = &bgep->buff[ring];
2256 brp->bgep = bgep;
2257 bsp = DMA_VPTR(bgep->status_block);
2261 DDI_INTR_PRI(bgep->intr_pri));
2284 bge_fini_buff_ring(bge_t *bgep, uint64_t ring)
2290 (void *)bgep, ring));
2292 brp = &bgep->buff[ring];
2306 bge_init_recv_ring(bge_t *bgep, uint64_t ring)
2313 (void *)bgep, ring));
2319 rrp = &bgep->recv[ring];
2335 rrp->bgep = bgep;
2336 bsp = DMA_VPTR(bgep->status_block);
2340 DDI_INTR_PRI(bgep->intr_pri));
2348 bge_fini_recv_ring(bge_t *bgep, uint64_t ring)
2353 (void *)bgep, ring));
2355 rrp = &bgep->recv[ring];
2367 bge_init_send_ring(bge_t *bgep, uint64_t ring)
2380 (void *)bgep, ring));
2386 srp = &bgep->send[ring];
2401 srp->bgep = bgep;
2402 bsp = DMA_VPTR(bgep->status_block);
2406 DDI_INTR_PRI(bgep->intr_pri));
2408 DDI_INTR_PRI(bgep->intr_pri));
2410 DDI_INTR_PRI(bgep->intr_pri));
2412 DDI_INTR_PRI(bgep->intr_pri));
2428 if (bgep->chipid.snd_buff_size > BGE_SEND_BUFF_SIZE_DEFAULT)
2451 bgep->chipid.snd_buff_size);
2462 bge_fini_send_ring(bge_t *bgep, uint64_t ring)
2470 (void *)bgep, ring));
2472 srp = &bgep->send[ring];
2498 bge_init_rings(bge_t *bgep)
2502 BGE_TRACE(("bge_init_rings($%p)", (void *)bgep));
2508 bge_init_send_ring(bgep, ring);
2510 bge_init_recv_ring(bgep, ring);
2512 bge_init_buff_ring(bgep, ring);
2519 bge_fini_rings(bge_t *bgep)
2523 BGE_TRACE(("bge_fini_rings($%p)", (void *)bgep));
2526 bge_fini_buff_ring(bgep, ring);
2528 bge_fini_recv_ring(bgep, ring);
2530 bge_fini_send_ring(bgep, ring);
2566 bge_alloc_txbuf_array(bge_t *bgep, send_ring_t *srp)
2589 txbuffsize = BGE_SEND_BUF_NUM*bgep->chipid.snd_buff_size;
2592 err = bge_alloc_dma_mem(bgep, txbuffsize/BGE_SPLIT,
2612 bgep->chipid.snd_buff_size);
2652 bge_alloc_bufs(bge_t *bgep)
2661 uint32_t rx_rings = bgep->chipid.rx_rings;
2662 uint32_t tx_rings = bgep->chipid.tx_rings;
2667 (void *)bgep));
2669 rxbuffsize = BGE_STD_SLOTS_USED*bgep->chipid.std_buf_size;
2670 rxbuffsize += bgep->chipid.jumbo_slots*bgep->chipid.recv_jumbo_size;
2673 txbuffsize = BGE_SEND_BUF_NUM*bgep->chipid.snd_buff_size;
2676 rxdescsize = rx_rings*bgep->chipid.recv_slots;
2680 rxbuffdescsize += bgep->chipid.jumbo_slots;
2693 if (!(DEVICE_5717_SERIES_CHIPSETS(bgep) ||
2694 DEVICE_5725_SERIES_CHIPSETS(bgep))) {
2704 err = bge_alloc_dma_mem(bgep, rxbuffsize/BGE_SPLIT,
2706 &bgep->rx_buff[split]);
2719 err = bge_alloc_dma_mem(bgep, txbuffsize/BGE_SPLIT,
2721 &bgep->tx_buff[split]);
2729 if (!(DEVICE_5717_SERIES_CHIPSETS(bgep) ||
2730 DEVICE_5725_SERIES_CHIPSETS(bgep))) {
2740 err = bge_alloc_dma_mem(bgep, rxdescsize/rx_rings,
2742 &bgep->rx_desc[split]);
2755 err = bge_alloc_dma_mem(bgep, rxbuffdescsize, &bge_desc_accattr,
2756 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, &bgep->rx_desc[split]);
2766 err = bge_alloc_dma_mem(bgep, txdescsize, &bge_desc_accattr,
2767 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, &bgep->tx_desc);
2779 area = bgep->rx_buff[split];
2789 bge_slice_chunk(&bgep->buff[BGE_STD_BUFF_RING].buf[split],
2791 bgep->chipid.std_buf_size);
2795 bgep->buff[BGE_STD_BUFF_RING].buf[split].mem_va,
2796 bgep->buff[BGE_STD_BUFF_RING].buf[split].alength,
2797 bgep->buff[BGE_STD_BUFF_RING].buf[split].offset,
2798 bgep->buff[BGE_STD_BUFF_RING].buf[split].cookie.dmac_laddress,
2799 bgep->buff[BGE_STD_BUFF_RING].buf[split].cookie.dmac_size,
2801 bgep->chipid.std_buf_size));
2803 bge_slice_chunk(&bgep->buff[BGE_JUMBO_BUFF_RING].buf[split],
2804 &area, bgep->chipid.jumbo_slots/BGE_SPLIT,
2805 bgep->chipid.recv_jumbo_size);
2807 if ((bgep->chipid.jumbo_slots / BGE_SPLIT) > 0)
2811 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].mem_va,
2812 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].alength,
2813 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].offset,
2814 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].cookie.dmac_laddress,
2815 bgep->buff[BGE_JUMBO_BUFF_RING].buf[split].cookie.dmac_size,
2816 bgep->chipid.jumbo_slots/BGE_SPLIT,
2817 bgep->chipid.recv_jumbo_size));
2820 bge_slice_chunk(&bgep->buff[BGE_MINI_BUFF_RING].buf[split],
2828 bgep->buff[BGE_MINI_BUFF_RING].buf[split].mem_va,
2829 bgep->buff[BGE_MINI_BUFF_RING].buf[split].alength,
2830 bgep->buff[BGE_MINI_BUFF_RING].buf[split].offset,
2831 bgep->buff[BGE_MINI_BUFF_RING].buf[split].cookie.dmac_laddress,
2832 bgep->buff[BGE_MINI_BUFF_RING].buf[split].cookie.dmac_size,
2848 area = bgep->tx_buff[split];
2859 bge_slice_chunk(&bgep->send[ring].buf[0][split],
2861 bgep->chipid.snd_buff_size);
2865 bgep->send[ring].buf[0][split].mem_va,
2866 bgep->send[ring].buf[0][split].alength,
2867 bgep->send[ring].buf[0][split].offset,
2868 bgep->send[ring].buf[0][split].cookie.dmac_laddress,
2869 bgep->send[ring].buf[0][split].cookie.dmac_size,
2871 bgep->chipid.snd_buff_size));
2875 bge_slice_chunk(&bgep->send[ring].buf[0][split],
2876 &area, 0, bgep->chipid.snd_buff_size);
2889 bge_slice_chunk(&bgep->recv[ring].desc, &bgep->rx_desc[ring],
2890 bgep->chipid.recv_slots, sizeof (bge_rbd_t));
2894 bgep->recv[ring].desc.mem_va,
2895 bgep->recv[ring].desc.alength,
2896 bgep->recv[ring].desc.offset,
2897 bgep->recv[ring].desc.cookie.dmac_laddress,
2898 bgep->recv[ring].desc.cookie.dmac_size,
2899 bgep->chipid.recv_slots,
2903 /* dma alloc for rxbuffdescsize is located at bgep->rx_desc[#rings] */
2904 area = bgep->rx_desc[rx_rings]; /* note rx_rings = one beyond rings */
2907 bge_slice_chunk(&bgep->recv[ring].desc, &area,
2917 bge_slice_chunk(&bgep->buff[BGE_STD_BUFF_RING].desc, &area,
2920 bgep->buff[BGE_STD_BUFF_RING].desc.mem_va,
2921 bgep->buff[BGE_STD_BUFF_RING].desc.alength,
2922 bgep->buff[BGE_STD_BUFF_RING].desc.offset,
2923 bgep->buff[BGE_STD_BUFF_RING].desc.cookie.dmac_laddress,
2924 bgep->buff[BGE_STD_BUFF_RING].desc.cookie.dmac_size,
2928 bge_slice_chunk(&bgep->buff[BGE_JUMBO_BUFF_RING].desc, &area,
2929 bgep->chipid.jumbo_slots, sizeof (bge_rbd_t));
2931 bgep->buff[BGE_JUMBO_BUFF_RING].desc.mem_va,
2932 bgep->buff[BGE_JUMBO_BUFF_RING].desc.alength,
2933 bgep->buff[BGE_JUMBO_BUFF_RING].desc.offset,
2934 bgep->buff[BGE_JUMBO_BUFF_RING].desc.cookie.dmac_laddress,
2935 bgep->buff[BGE_JUMBO_BUFF_RING].desc.cookie.dmac_size,
2936 bgep->chipid.jumbo_slots,
2939 bge_slice_chunk(&bgep->buff[BGE_MINI_BUFF_RING].desc, &area,
2942 bgep->buff[BGE_MINI_BUFF_RING].desc.mem_va,
2943 bgep->buff[BGE_MINI_BUFF_RING].desc.alength,
2944 bgep->buff[BGE_MINI_BUFF_RING].desc.offset,
2945 bgep->buff[BGE_MINI_BUFF_RING].desc.cookie.dmac_laddress,
2946 bgep->buff[BGE_MINI_BUFF_RING].desc.cookie.dmac_size,
2959 area = bgep->tx_desc;
2969 bge_slice_chunk(&bgep->send[ring].desc, &area,
2974 bgep->send[ring].desc.mem_va,
2975 bgep->send[ring].desc.alength,
2976 bgep->send[ring].desc.offset,
2977 bgep->send[ring].desc.cookie.dmac_laddress,
2978 bgep->send[ring].desc.cookie.dmac_size,
2984 bge_slice_chunk(&bgep->send[ring].desc, &area,
2987 bge_slice_chunk(&bgep->statistics, &area, 1, sizeof (bge_statistics_t));
2989 bgep->statistics.mem_va,
2990 bgep->statistics.alength,
2991 bgep->statistics.offset,
2992 bgep->statistics.cookie.dmac_laddress,
2993 bgep->statistics.cookie.dmac_size,
2997 bge_slice_chunk(&bgep->status_block, &area, 1, sizeof (bge_status_t));
2999 bgep->status_block.mem_va,
3000 bgep->status_block.alength,
3001 bgep->status_block.offset,
3002 bgep->status_block.cookie.dmac_laddress,
3003 bgep->status_block.cookie.dmac_size,
3016 DMA_ZERO(bgep->status_block);
3029 bge_free_bufs(bge_t *bgep)
3034 (void *)bgep));
3036 bge_free_dma_mem(&bgep->tx_desc);
3038 bge_free_dma_mem(&bgep->rx_desc[split]);
3040 bge_free_dma_mem(&bgep->tx_buff[split]);
3042 bge_free_dma_mem(&bgep->rx_buff[split]);
3050 bge_find_mac_address(bge_t *bgep, chip_id_t *cidp)
3060 (void *)bgep));
3082 err = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, bgep->devinfo,
3093 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, bgep->devinfo,
3119 err = ddi_getlongprop_buf(DDI_DEV_T_ANY, bgep->devinfo,
3144 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, bgep->devinfo,
3162 bge_check_acc_handle(bge_t *bgep, ddi_acc_handle_t handle)
3173 bge_check_dma_handle(bge_t *bgep, ddi_dma_handle_t handle)
3177 ASSERT(bgep->progress & PROGRESS_BUFS);
3198 bge_fm_init(bge_t *bgep)
3203 if (bgep->fm_capabilities) {
3208 ddi_fm_init(bgep->devinfo, &bgep->fm_capabilities, &iblk);
3213 if (DDI_FM_EREPORT_CAP(bgep->fm_capabilities) ||
3214 DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3215 pci_ereport_setup(bgep->devinfo);
3220 if (DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3221 ddi_fm_handler_register(bgep->devinfo,
3222 bge_fm_error_cb, (void*) bgep);
3234 bge_fm_fini(bge_t *bgep)
3237 if (bgep->fm_capabilities) {
3242 if (DDI_FM_EREPORT_CAP(bgep->fm_capabilities) ||
3243 DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3244 pci_ereport_teardown(bgep->devinfo);
3249 if (DDI_FM_ERRCB_CAP(bgep->fm_capabilities))
3250 ddi_fm_handler_unregister(bgep->devinfo);
3253 ddi_fm_fini(bgep->devinfo);
3259 bge_unattach(bge_t *bgep, uint_t asf_mode)
3261 bge_unattach(bge_t *bgep)
3265 (void *)bgep));
3270 bgep->progress &= ~PROGRESS_READY;
3276 if (bgep->periodic_id != NULL) {
3277 ddi_periodic_delete(bgep->periodic_id);
3278 bgep->periodic_id = NULL;
3281 if (bgep->progress & PROGRESS_KSTATS)
3282 bge_fini_kstats(bgep);
3283 if (bgep->progress & PROGRESS_PHY)
3284 bge_phys_reset(bgep);
3285 if (bgep->progress & PROGRESS_HWINT) {
3286 mutex_enter(bgep->genlock);
3288 if (bge_chip_reset(bgep, B_FALSE, asf_mode) != DDI_SUCCESS)
3290 if (bge_chip_reset(bgep, B_FALSE) != DDI_SUCCESS)
3292 ddi_fm_service_impact(bgep->devinfo,
3295 if (bgep->asf_enabled) {
3300 bge_nic_put32(bgep, BGE_NIC_DATA_SIG_ADDR,
3304 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK)
3305 ddi_fm_service_impact(bgep->devinfo,
3307 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK)
3308 ddi_fm_service_impact(bgep->devinfo,
3310 mutex_exit(bgep->genlock);
3312 if (bgep->progress & PROGRESS_INTR) {
3313 bge_intr_disable(bgep);
3314 bge_fini_rings(bgep);
3316 if (bgep->progress & PROGRESS_HWINT) {
3317 bge_rem_intrs(bgep);
3318 rw_destroy(bgep->errlock);
3319 mutex_destroy(bgep->softintrlock);
3320 mutex_destroy(bgep->genlock);
3322 if (bgep->progress & PROGRESS_FACTOTUM)
3323 ddi_remove_softintr(bgep->factotum_id);
3324 if (bgep->progress & PROGRESS_RESCHED)
3325 ddi_remove_softintr(bgep->drain_id);
3326 if (bgep->progress & PROGRESS_BUFS)
3327 bge_free_bufs(bgep);
3328 if (bgep->progress & PROGRESS_REGS) {
3329 ddi_regs_map_free(&bgep->io_handle);
3330 if (bgep->ape_enabled)
3331 ddi_regs_map_free(&bgep->ape_handle);
3333 if (bgep->progress & PROGRESS_CFG)
3334 pci_config_teardown(&bgep->cfg_handle);
3336 bge_fm_fini(bgep);
3338 ddi_remove_minor_node(bgep->devinfo, NULL);
3339 kmem_free(bgep->pstats, sizeof (bge_statistics_reg_t));
3340 kmem_free(bgep, sizeof (*bgep));
3346 bge_t *bgep; /* Our private data */
3350 bgep = ddi_get_driver_private(devinfo);
3351 if (bgep == NULL)
3357 if (bgep->devinfo != devinfo)
3373 cidp = &bgep->chipid;
3374 mutex_enter(bgep->genlock);
3375 bge_chip_cfg_init(bgep, &chipid, B_FALSE);
3376 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3377 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3378 mutex_exit(bgep->genlock);
3381 mutex_exit(bgep->genlock);
3394 mutex_enter(bgep->genlock);
3395 if (bge_restart(bgep, B_TRUE) != DDI_SUCCESS) {
3396 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
3397 (void) bge_check_acc_handle(bgep, bgep->io_handle);
3398 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3399 mutex_exit(bgep->genlock);
3402 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3403 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3404 mutex_exit(bgep->genlock);
3407 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
3408 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3409 mutex_exit(bgep->genlock);
3412 mutex_exit(bgep->genlock);
3417 bge_fw_img_is_valid(bge_t *bgep, uint32_t offset)
3421 if (bge_nvmem_read32(bgep, offset, &val) ||
3423 bge_nvmem_read32(bgep, offset + 4, &val) ||
3431 bge_read_mgmtfw_ver(bge_t *bgep)
3441 if (bge_nvmem_read32(bgep, offset, &val))
3451 if (bge_nvmem_read32(bgep, offset - 4, &start))
3454 if (bge_nvmem_read32(bgep, offset + 4, &offset) ||
3455 !bge_fw_img_is_valid(bgep, offset) ||
3456 bge_nvmem_read32(bgep, offset + 8, &val))
3461 vlen = strlen(bgep->fw_version);
3463 bgep->fw_version[vlen++] = ',';
3464 bgep->fw_version[vlen++] = ' ';
3469 if (bge_nvmem_read32(bgep, offset, &v))
3477 memcpy(&bgep->fw_version[vlen], &v, BGE_FW_VER_SIZE - vlen);
3481 memcpy(&bgep->fw_version[vlen], &v, sizeof(v));
3487 bge_read_dash_ver(bge_t *bgep)
3493 if (!bgep->ape_enabled || !bgep->asf_enabled)
3496 apedata = bge_ape_get32(bgep, BGE_APE_SEG_SIG);
3500 apedata = bge_ape_get32(bgep, BGE_APE_FW_STATUS);
3504 apedata = bge_ape_get32(bgep, BGE_APE_FW_VERSION);
3506 if (bge_ape_get32(bgep, BGE_APE_FW_FEATURES) &
3508 bgep->ape_has_ncsi = B_TRUE;
3510 } else if ((bgep->chipid.device == DEVICE_ID_5725) ||
3511 (bgep->chipid.device == DEVICE_ID_5727)) {
3517 vlen = strlen(bgep->fw_version);
3519 snprintf(&bgep->fw_version[vlen], BGE_FW_VER_SIZE - vlen,
3528 bge_read_bc_ver(bge_t *bgep)
3539 if (bge_nvmem_read32(bgep, 0xc, &offset) ||
3540 bge_nvmem_read32(bgep, 0x4, &start))
3543 if (bge_nvmem_read32(bgep, offset, &val))
3547 if (bge_nvmem_read32(bgep, offset + 4, &val))
3554 dst_off = strlen(bgep->fw_version);
3558 bge_nvmem_read32(bgep, offset + 8, &ver_offset))
3563 if (bge_nvmem_read32(bgep, offset + i, &val))
3566 memcpy(bgep->fw_version + dst_off + i, &val,
3570 if (bge_nvmem_read32(bgep, NVM_PTREV_BCVER, &ver_offset))
3575 snprintf(&bgep->fw_version[dst_off], BGE_FW_VER_SIZE - dst_off,
3581 bge_read_fw_ver(bge_t *bgep)
3586 *bgep->fw_version = 0;
3588 if ((bgep->chipid.nvtype == BGE_NVTYPE_NONE) ||
3589 (bgep->chipid.nvtype == BGE_NVTYPE_UNKNOWN)) {
3590 snprintf(bgep->fw_version, sizeof(bgep->fw_version), "sb");
3594 mutex_enter(bgep->genlock);
3596 bge_nvmem_read32(bgep, 0, &magic);
3599 bge_read_bc_ver(bgep);
3602 mutex_exit(bgep->genlock);
3606 if (bgep->ape_enabled) {
3607 if (bgep->asf_enabled) {
3608 bge_read_dash_ver(bgep);
3610 } else if (bgep->asf_enabled) {
3611 bge_read_mgmtfw_ver(bgep);
3614 mutex_exit(bgep->genlock);
3616 bgep->fw_version[BGE_FW_VER_SIZE - 1] = 0; /* safety */
3627 bge_t *bgep; /* Our private data */
3665 bgep = kmem_zalloc(sizeof (*bgep), KM_SLEEP);
3666 bgep->pstats = kmem_zalloc(sizeof (bge_statistics_reg_t), KM_SLEEP);
3667 ddi_set_driver_private(devinfo, bgep);
3668 bgep->bge_guard = BGE_GUARD;
3669 bgep->devinfo = devinfo;
3670 bgep->param_drain_max = 64;
3671 bgep->param_msi_cnt = 0;
3672 bgep->param_loop_mode = 0;
3677 bgep->debug = ddi_prop_get_int(DDI_DEV_T_ANY, devinfo,
3679 (void) snprintf(bgep->ifname, sizeof (bgep->ifname), "%s%d",
3685 bgep->fm_capabilities = ddi_prop_get_int(DDI_DEV_T_ANY, devinfo,
3689 BGE_DEBUG(("bgep->fm_capabilities = %d", bgep->fm_capabilities));
3690 bge_fm_init(bgep);
3699 bgep->pagemask = dvma_pagesize(devinfo);
3700 ASSERT(ddi_ffs(bgep->pagemask) == ddi_fls(bgep->pagemask));
3701 bgep->pagemask = -bgep->pagemask;
3714 err = pci_config_setup(devinfo, &bgep->cfg_handle);
3716 bgep->ape_enabled = B_FALSE;
3717 bgep->ape_regs = NULL;
3719 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3720 DEVICE_5725_SERIES_CHIPSETS(bgep)) {
3722 ®s, 0, 0, &bge_reg_accattr, &bgep->ape_handle);
3724 ddi_regs_map_free(&bgep->io_handle);
3725 bge_problem(bgep, "ddi_regs_map_setup() failed");
3728 bgep->ape_regs = regs;
3729 bgep->ape_enabled = B_TRUE;
3736 pci_state_reg = pci_config_get32(bgep->cfg_handle,
3740 pci_config_put32(bgep->cfg_handle,
3742 bge_ape_lock_init(bgep);
3752 bgep->chipid.device = pci_config_get16(bgep->cfg_handle,
3754 value16 = pci_config_get16(bgep->cfg_handle, PCI_CONF_COMM);
3756 pci_config_put16(bgep->cfg_handle, PCI_CONF_COMM, value16);
3769 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3770 DEVICE_5725_SERIES_CHIPSETS(bgep))
3771 pci_config_put32(bgep->cfg_handle, PCI_CONF_BGE_MHCR, 0);
3779 pci_config_put32(bgep->cfg_handle, PCI_CONF_BGE_MHCR, mhcrValue);
3780 bge_ind_put32(bgep, MEMORY_ARBITER_MODE_REG,
3781 bge_ind_get32(bgep, MEMORY_ARBITER_MODE_REG) |
3784 bgep->asf_wordswapped = B_TRUE;
3786 bgep->asf_wordswapped = B_FALSE;
3788 bge_asf_get_config(bgep);
3791 bge_problem(bgep, "pci_config_setup() failed");
3794 bgep->progress |= PROGRESS_CFG;
3795 cidp = &bgep->chipid;
3797 bge_chip_cfg_init(bgep, cidp, B_FALSE);
3798 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
3799 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3804 if (DEVICE_5721_SERIES_CHIPSETS(bgep) ||
3805 DEVICE_5714_SERIES_CHIPSETS(bgep)) {
3806 bgep->asf_newhandshake = B_TRUE;
3808 bgep->asf_newhandshake = B_FALSE;
3843 ®s, 0, 0, &bge_reg_accattr, &bgep->io_handle);
3845 bge_problem(bgep, "ddi_regs_map_setup() failed");
3848 bgep->io_regs = regs;
3850 bgep->progress |= PROGRESS_REGS;
3856 if (bge_chip_id_init(bgep) == EIO) {
3857 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
3861 err = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, bgep->devinfo,
3864 bgep->pci_bus = PCI_REG_BUS_G(props[0]);
3865 bgep->pci_dev = PCI_REG_DEV_G(props[0]);
3866 bgep->pci_func = PCI_REG_FUNC_G(props[0]);
3870 if (DEVICE_5717_SERIES_CHIPSETS(bgep) ||
3871 DEVICE_5725_SERIES_CHIPSETS(bgep)) {
3872 regval = bge_reg_get32(bgep, CPMU_STATUS_REG);
3873 if ((bgep->chipid.device == DEVICE_ID_5719) ||
3874 (bgep->chipid.device == DEVICE_ID_5720)) {
3875 bgep->pci_func =
3879 bgep->pci_func = ((regval & CPMU_STATUS_FUNC_NUM) >>
3884 err = bge_alloc_bufs(bgep);
3886 bge_problem(bgep, "DMA buffer allocation failed");
3889 bgep->progress |= PROGRESS_BUFS;
3913 err = ddi_add_softintr(devinfo, DDI_SOFTINT_LOW, &bgep->drain_id,
3914 NULL, NULL, bge_send_drain, (caddr_t)bgep);
3916 bge_problem(bgep, "ddi_add_softintr() failed");
3919 bgep->progress |= PROGRESS_RESCHED;
3920 err = ddi_add_softintr(devinfo, DDI_SOFTINT_LOW, &bgep->factotum_id,
3921 NULL, NULL, bge_chip_factotum, (caddr_t)bgep);
3923 bge_problem(bgep, "ddi_add_softintr() failed");
3926 bgep->progress |= PROGRESS_FACTOTUM;
3930 bge_error(bgep, "ddi_intr_get_supported_types failed\n");
3936 bgep->ifname, intr_types));
3938 if ((intr_types & DDI_INTR_TYPE_MSI) && bgep->chipid.msi_enabled) {
3939 if (bge_add_intrs(bgep, DDI_INTR_TYPE_MSI) != DDI_SUCCESS) {
3940 bge_error(bgep, "MSI registration failed, "
3944 bgep->ifname));
3945 bgep->intr_type = DDI_INTR_TYPE_MSI;
3946 bgep->progress |= PROGRESS_HWINT;
3950 if (!(bgep->progress & PROGRESS_HWINT) &&
3952 if (bge_add_intrs(bgep, DDI_INTR_TYPE_FIXED) != DDI_SUCCESS) {
3953 bge_error(bgep, "FIXED interrupt "
3958 BGE_DEBUG(("%s: Using FIXED interrupt type", bgep->ifname));
3960 bgep->intr_type = DDI_INTR_TYPE_FIXED;
3961 bgep->progress |= PROGRESS_HWINT;
3964 if (!(bgep->progress & PROGRESS_HWINT)) {
3965 bge_error(bgep, "No interrupts registered\n");
3973 mutex_init(bgep->genlock, NULL, MUTEX_DRIVER,
3974 DDI_INTR_PRI(bgep->intr_pri));
3975 mutex_init(bgep->softintrlock, NULL, MUTEX_DRIVER,
3976 DDI_INTR_PRI(bgep->intr_pri));
3977 rw_init(bgep->errlock, NULL, RW_DRIVER,
3978 DDI_INTR_PRI(bgep->intr_pri));
3983 bge_init_rings(bgep);
3988 bge_intr_enable(bgep);
3989 bgep->progress |= PROGRESS_INTR;
3996 bgep->link_state = LINK_STATE_UNKNOWN;
3998 mutex_enter(bgep->genlock);
4006 if (bge_reset(bgep, ASF_MODE_INIT) != DDI_SUCCESS) {
4008 if (bge_reset(bgep, ASF_MODE_SHUTDOWN) != DDI_SUCCESS) {
4011 if (bge_reset(bgep) != DDI_SUCCESS) {
4013 (void) bge_check_acc_handle(bgep, bgep->cfg_handle);
4014 (void) bge_check_acc_handle(bgep, bgep->io_handle);
4015 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4016 mutex_exit(bgep->genlock);
4021 if (bgep->asf_enabled) {
4022 bgep->asf_status = ASF_STAT_RUN_INIT;
4026 bzero(bgep->mcast_hash, sizeof (bgep->mcast_hash));
4027 bzero(bgep->mcast_refs, sizeof (bgep->mcast_refs));
4028 bgep->promisc = B_FALSE;
4029 bgep->param_loop_mode = BGE_LOOP_NONE;
4030 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK) {
4031 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4032 mutex_exit(bgep->genlock);
4035 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
4036 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4037 mutex_exit(bgep->genlock);
4041 mutex_exit(bgep->genlock);
4043 if (bge_phys_init(bgep) == EIO) {
4044 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST);
4047 bgep->progress |= PROGRESS_PHY;
4052 if (bge_nd_init(bgep)) {
4053 bge_problem(bgep, "bge_nd_init() failed");
4056 bgep->progress |= PROGRESS_NDD;
4061 bge_init_kstats(bgep, instance);
4062 bgep->progress |= PROGRESS_KSTATS;
4067 bge_find_mac_address(bgep, cidp);
4072 bgep->curr_addr[slot].addr);
4073 bgep->curr_addr[slot].set = 1;
4077 bge_read_fw_ver(bgep);
4079 bgep->unicst_addr_total = MAC_ADDRESS_REGS_MAX;
4080 bgep->unicst_addr_avail = MAC_ADDRESS_REGS_MAX;
4085 macp->m_driver = bgep;
4095 bge_m_unicst(bgep, cidp->vendor_addr.addr);
4102 err = mac_register(macp, &bgep->mh);
4107 mac_link_update(bgep->mh, LINK_STATE_UNKNOWN);
4113 bgep->periodic_id = ddi_periodic_add(bge_chip_cyclic, bgep,
4116 bgep->progress |= PROGRESS_READY;
4117 ASSERT(bgep->bge_guard == BGE_GUARD);
4120 if (bgep->asf_enabled) {
4121 mutex_enter(bgep->genlock);
4122 retval = bge_chip_start(bgep, B_TRUE);
4123 mutex_exit(bgep->genlock);
4136 bge_unattach(bgep, ASF_MODE_SHUTDOWN);
4138 bge_unattach(bgep);
4147 bge_suspend(bge_t *bgep)
4152 mutex_enter(bgep->genlock);
4160 bge_stop(bgep);
4161 if (bge_phys_idle(bgep) != DDI_SUCCESS) {
4162 (void) bge_check_acc_handle(bgep, bgep->io_handle);
4163 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4164 mutex_exit(bgep->genlock);
4167 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK) {
4168 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4169 mutex_exit(bgep->genlock);
4172 mutex_exit(bgep->genlock);
4193 bge_t *bgep = ddi_get_driver_private(devinfo);
4195 if (bgep == NULL)
4198 if (bgep->intr_type == DDI_INTR_TYPE_FIXED) {
4199 bge_reg_set32(bgep, PCI_CONF_BGE_MHCR,
4202 bge_reg_clr32(bgep, MSI_MODE_REG, MSI_MSI_ENABLE);
4206 bge_chip_stop_nonblocking(bgep);
4218 bge_t *bgep;
4226 bgep = ddi_get_driver_private(devinfo);
4233 return (bge_suspend(bgep));
4240 mutex_enter(bgep->genlock);
4241 if (bgep->asf_enabled && ((bgep->asf_status == ASF_STAT_RUN) ||
4242 (bgep->asf_status == ASF_STAT_RUN_INIT))) {
4244 bge_asf_update_status(bgep);
4245 if (bgep->asf_status == ASF_STAT_RUN) {
4246 bge_asf_stop_timer(bgep);
4248 bgep->asf_status = ASF_STAT_STOP;
4250 bge_asf_pre_reset_operations(bgep, BGE_SHUTDOWN_RESET);
4252 if (bgep->asf_pseudostop) {
4253 bge_chip_stop(bgep, B_FALSE);
4254 bgep->bge_mac_state = BGE_MAC_STOPPED;
4255 bgep->asf_pseudostop = B_FALSE;
4260 if (bge_check_acc_handle(bgep, bgep->cfg_handle) != DDI_FM_OK)
4261 ddi_fm_service_impact(bgep->devinfo,
4263 if (bge_check_acc_handle(bgep, bgep->io_handle) != DDI_FM_OK)
4264 ddi_fm_service_impact(bgep->devinfo,
4267 mutex_exit(bgep->genlock);
4276 if (mac_unregister(bgep->mh) != 0)
4283 bge_unattach(bgep, asf_mode);
4285 bge_unattach(bgep);
4361 bge_add_intrs(bge_t *bgep, int intr_type)
4363 dev_info_t *dip = bgep->devinfo;
4367 BGE_DEBUG(("bge_add_intrs($%p, 0x%x)", (void *)bgep, intr_type));
4372 bge_error(bgep, "ddi_intr_get_nintrs() failure, ret: %d, "
4381 bge_error(bgep, "ddi_intr_get_navail() failure, "
4389 bgep->ifname, count, avail));
4405 bgep->htable = kmem_alloc(intr_size, KM_SLEEP);
4408 ret = ddi_intr_alloc(dip, bgep->htable, intr_type, 0,
4412 bge_error(bgep, "ddi_intr_alloc() failed %d\n", ret);
4414 kmem_free(bgep->htable, intr_size);
4420 bgep->ifname, count, actual));
4423 bgep->intr_cnt = actual;
4428 if ((ret = ddi_intr_get_pri(bgep->htable[0], &bgep->intr_pri)) !=
4430 bge_error(bgep, "ddi_intr_get_pri() failed %d\n", ret);
4434 (void) ddi_intr_free(bgep->htable[i]);
4437 kmem_free(bgep->htable, intr_size);
4443 if ((ret = ddi_intr_add_handler(bgep->htable[i], bge_intr,
4444 (caddr_t)bgep, (caddr_t)(uintptr_t)i)) != DDI_SUCCESS) {
4445 bge_error(bgep, "ddi_intr_add_handler() "
4450 (void) ddi_intr_free(bgep->htable[i]);
4453 kmem_free(bgep->htable, intr_size);
4458 if ((ret = ddi_intr_get_cap(bgep->htable[0], &bgep->intr_cap))
4460 bge_error(bgep, "ddi_intr_get_cap() failed %d\n", ret);
4463 (void) ddi_intr_remove_handler(bgep->htable[i]);
4464 (void) ddi_intr_free(bgep->htable[i]);
4467 kmem_free(bgep->htable, intr_size);
4480 bge_rem_intrs(bge_t *bgep)
4484 BGE_DEBUG(("bge_rem_intrs($%p)", (void *)bgep));
4487 for (i = 0; i < bgep->intr_cnt; i++) {
4488 (void) ddi_intr_remove_handler(bgep->htable[i]);
4489 (void) ddi_intr_free(bgep->htable[i]);
4492 kmem_free(bgep->htable, bgep->intr_cnt * sizeof (ddi_intr_handle_t));
4497 bge_intr_enable(bge_t *bgep)
4501 if (bgep->intr_cap & DDI_INTR_FLAG_BLOCK) {
4503 (void) ddi_intr_block_enable(bgep->htable, bgep->intr_cnt);
4506 for (i = 0; i < bgep->intr_cnt; i++) {
4507 (void) ddi_intr_enable(bgep->htable[i]);
4514 bge_intr_disable(bge_t *bgep)
4518 if (bgep->intr_cap & DDI_INTR_FLAG_BLOCK) {
4520 (void) ddi_intr_block_disable(bgep->htable, bgep->intr_cnt);
4522 for (i = 0; i < bgep->intr_cnt; i++) {
4523 (void) ddi_intr_disable(bgep->htable[i]);
4529 bge_reprogram(bge_t *bgep)
4533 ASSERT(mutex_owned(bgep->genlock));
4535 if (bge_phys_update(bgep) != DDI_SUCCESS) {
4536 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4540 if (bge_chip_sync(bgep, B_TRUE) == DDI_FAILURE) {
4542 if (bge_chip_sync(bgep) == DDI_FAILURE) {
4544 ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_DEGRADED);
4547 if (bgep->intr_type == DDI_INTR_TYPE_MSI)
4548 bge_chip_msi_trig(bgep);