Attachment #26135 for bug #44572

View | Details | Raw Unified | Return to bug 44572
Collapse All | Expand All




		 */
		if (rxstat & VR_RXSTAT_RXERR) {
			ifp->if_ierrors++;
			printf("vr%d: rx error (%02x):",
			       sc->vr_unit, rxstat & 0x000000ff);
			if (rxstat & VR_RXSTAT_CRCERR)
				printf(" crc error");
			if (rxstat & VR_RXSTAT_FRAMEALIGNERR)
				printf(" frame alignment error\n");
			if (rxstat & VR_RXSTAT_FIFOOFLOW)
				printf(" FIFO overflow");
			if (rxstat & VR_RXSTAT_GIANT)
				printf(" received giant packet");
			if (rxstat & VR_RXSTAT_RUNT)
				printf(" received runt packet");
			if (rxstat & VR_RXSTAT_BUSERR)
				printf(" system bus error");
			if (rxstat & VR_RXSTAT_BUFFERR)
				printf("rx buffer error");
			printf("\n");
			case VR_RXSTAT_BUSERR:
				printf("system bus error\n");
				break;
			case VR_RXSTAT_BUFFERR:
				printf("rx buffer error\n");
				break;
			default:
				printf("unknown rx error\n");
				break;
			}
			vr_newbuf(sc, cur_rx, m);
			continue;
		}

void vr_rxeoc(sc)
	struct vr_softc		*sc;
{
	struct ifnet		*ifp;
	int			i;

	ifp = &sc->arpcom.ac_if;

	ifp->if_ierrors++;

	VR_CLRBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);	
        DELAY(10000);

	for (i = 0x400;
	     i && (CSR_READ_2(sc, VR_COMMAND) & VR_CMD_RX_ON);
	     i--)
		;	/* Wait for receiver to stop */

	if (!i) {
		printf("vr%d: rx shutdown error!\n", sc->vr_unit);
		sc->vr_flags |= VR_F_RESTART;
		return;
		}

	vr_rxeof(sc);

	CSR_WRITE_4(sc, VR_RXADDR, vtophys(sc->vr_cdata.vr_rx_head->vr_ptr));
	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);
	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_GO);

	 */
	while(sc->vr_cdata.vr_tx_head->vr_mbuf != NULL) {
		u_int32_t		txstat;
		int			i;

		cur_tx = sc->vr_cdata.vr_tx_head;
		txstat = cur_tx->vr_ptr->vr_status;

		if ((txstat & VR_TXSTAT_ABRT) ||
		    (txstat & VR_TXSTAT_UDF)) {
			for (i = 0x400;
			     i && (CSR_READ_2(sc, VR_COMMAND) & VR_CMD_TX_ON);
			     i--)
				;	/* Wait for chip to shutdown */
			if (!i) {
				printf("vr%d: tx shutdown timeout\n", sc->vr_unit);
				sc->vr_flags |= VR_F_RESTART;
				break;
			}
			VR_TXOWN(cur_tx) = VR_TXSTAT_OWN;
			CSR_WRITE_4(sc, VR_TXADDR, vtophys(cur_tx->vr_ptr));
			break;

	s = splimp();

	sc = xsc;
	if (sc->vr_flags & VR_F_RESTART) {
		printf("vr%d: restarting\n", sc->vr_unit);
		vr_stop(sc);
		vr_reset(sc);
		vr_init(sc);
		sc->vr_flags &= ~VR_F_RESTART;
		}

	mii = device_get_softc(sc->vr_miibus);
	mii_tick(mii);


		if (status & VR_ISR_RX_OK)
			vr_rxeof(sc);

		if (status & VR_ISR_RX_DROPPED) {
			printf("vr%d: rx packet lost\n", sc->vr_unit);
			ifp->if_ierrors++;
			}

		if ((status & VR_ISR_RX_ERR) || (status & VR_ISR_RX_NOBUF) ||
		    (status & VR_ISR_RX_NOBUF) || (status & VR_ISR_RX_OFLOW)) {
			printf("vr%d: receive error (%04x)",
			       sc->vr_unit, status);
			if (status & VR_ISR_RX_NOBUF)
				printf(" no buffers");
			if (status & VR_ISR_RX_OFLOW)
				printf(" overflow");
			if (status & VR_ISR_RX_DROPPED)
				printf(" packet lost");
			printf("\n");
			vr_rxeoc(sc);
		}


	 * so we must set both.
	 */
	VR_CLRBIT(sc, VR_BCR0, VR_BCR0_RX_THRESH);
	VR_SETBIT(sc, VR_BCR0, VR_BCR0_RXTHRESH128BYTES);

	VR_CLRBIT(sc, VR_BCR1, VR_BCR1_TX_THRESH);
	VR_SETBIT(sc, VR_BCR1, VR_BCR1_TXTHRESHSTORENFWD);

	VR_CLRBIT(sc, VR_RXCFG, VR_RXCFG_RX_THRESH);
	VR_SETBIT(sc, VR_RXCFG, VR_RXTHRESH_128BYTES);

	VR_CLRBIT(sc, VR_TXCFG, VR_TXCFG_TX_THRESH);
	VR_SETBIT(sc, VR_TXCFG, VR_TXTHRESH_STORENFWD);

Lines 464-473 Link Here

(-)if_vrreg.h (+3 lines)
464	u_int8_t vr_unit; /* interface number */	464	u_int8_t vr_unit; /* interface number */
465	u_int8_t vr_type;	465	u_int8_t vr_type;
466	u_int8_t vr_revid; /* Rhine chip revision */	466	u_int8_t vr_revid; /* Rhine chip revision */
		467	u_int8_t vr_flags; /* See VR_F_* below */
467	struct vr_list_data *vr_ldata;	468	struct vr_list_data *vr_ldata;
468	struct vr_chain_data vr_cdata;	469	struct vr_chain_data vr_cdata;
469	struct callout_handle vr_stat_ch;	470	struct callout_handle vr_stat_ch;
470	};	471	};
		472
		473	#define VR_F_RESTART 0x01 /* Restart unit on next tick */
471		474
472	/*	475	/*
473	* register space access macros	476	* register space access macros

Return to bug 44572

Lines 991-1023 Link Here

(-)if_vr.c (-34 / +72 lines)
991	*/	991	*/
992	if (rxstat & VR_RXSTAT_RXERR) {	992	if (rxstat & VR_RXSTAT_RXERR) {
993	ifp->if_ierrors++;	993	ifp->if_ierrors++;
994	printf("vr%d: rx error: ", sc->vr_unit);	994	printf("vr%d: rx error (%02x):",
995	switch(rxstat & 0x000000FF) {	995	sc->vr_unit, rxstat & 0x000000ff);
996	case VR_RXSTAT_CRCERR:	996	if (rxstat & VR_RXSTAT_CRCERR)
997	printf("crc error\n");	997	printf(" crc error");
998	break;	998	if (rxstat & VR_RXSTAT_FRAMEALIGNERR)
999	case VR_RXSTAT_FRAMEALIGNERR:	999	printf(" frame alignment error\n");
1000	printf("frame alignment error\n");	1000	if (rxstat & VR_RXSTAT_FIFOOFLOW)
1001	break;	1001	printf(" FIFO overflow");
1002	case VR_RXSTAT_FIFOOFLOW:	1002	if (rxstat & VR_RXSTAT_GIANT)
1003	printf("FIFO overflow\n");	1003	printf(" received giant packet");
1004	break;	1004	if (rxstat & VR_RXSTAT_RUNT)
1005	case VR_RXSTAT_GIANT:	1005	printf(" received runt packet");
1006	printf("received giant packet\n");	1006	if (rxstat & VR_RXSTAT_BUSERR)
1007	break;	1007	printf(" system bus error");
1008	case VR_RXSTAT_RUNT:	1008	if (rxstat & VR_RXSTAT_BUFFERR)
1009	printf("received runt packet\n");	1009	printf("rx buffer error");
1010	break;	1010	printf("\n");
1011	case VR_RXSTAT_BUSERR:
1012	printf("system bus error\n");
1013	break;
1014	case VR_RXSTAT_BUFFERR:
1015	printf("rx buffer error\n");
1016	break;
1017	default:
1018	printf("unknown rx error\n");
1019	break;
1020	}
1021	vr_newbuf(sc, cur_rx, m);	1011	vr_newbuf(sc, cur_rx, m);
1022	continue;	1012	continue;
1023	}	1013	}
Lines 1058-1066 Link Here
1058	void vr_rxeoc(sc)	1048	void vr_rxeoc(sc)
1059	struct vr_softc *sc;	1049	struct vr_softc *sc;
1060	{	1050	{
		1051	struct ifnet *ifp;
		1052	int i;
		1053
		1054	ifp = &sc->arpcom.ac_if;
		1055
		1056	ifp->if_ierrors++;
		1057
		1058	VR_CLRBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);
		1059	DELAY(10000);
		1060
		1061	for (i = 0x400;
		1062	i && (CSR_READ_2(sc, VR_COMMAND) & VR_CMD_RX_ON);
		1063	i--)
		1064	; /* Wait for receiver to stop */
		1065
		1066	if (!i) {
		1067	printf("vr%d: rx shutdown error!\n", sc->vr_unit);
		1068	sc->vr_flags \|= VR_F_RESTART;
		1069	return;
		1070	}
1061		1071
1062	vr_rxeof(sc);	1072	vr_rxeof(sc);
1063	VR_CLRBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);	1073
1064	CSR_WRITE_4(sc, VR_RXADDR, vtophys(sc->vr_cdata.vr_rx_head->vr_ptr));	1074	CSR_WRITE_4(sc, VR_RXADDR, vtophys(sc->vr_cdata.vr_rx_head->vr_ptr));
1065	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);	1075	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_ON);
1066	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_GO);	1076	VR_SETBIT16(sc, VR_COMMAND, VR_CMD_RX_GO);
Lines 1094-1107 Link Here
1094	*/	1104	*/
1095	while(sc->vr_cdata.vr_tx_head->vr_mbuf != NULL) {	1105	while(sc->vr_cdata.vr_tx_head->vr_mbuf != NULL) {
1096	u_int32_t txstat;	1106	u_int32_t txstat;
		1107	int i;
1097		1108
1098	cur_tx = sc->vr_cdata.vr_tx_head;	1109	cur_tx = sc->vr_cdata.vr_tx_head;
1099	txstat = cur_tx->vr_ptr->vr_status;	1110	txstat = cur_tx->vr_ptr->vr_status;
1100		1111
1101	if ((txstat & VR_TXSTAT_ABRT) \|\|	1112	if ((txstat & VR_TXSTAT_ABRT) \|\|
1102	(txstat & VR_TXSTAT_UDF)) {	1113	(txstat & VR_TXSTAT_UDF)) {
1103	while (CSR_READ_2(sc, VR_COMMAND) & VR_CMD_TX_ON)	1114	for (i = 0x400;
		1115	i && (CSR_READ_2(sc, VR_COMMAND) & VR_CMD_TX_ON);
		1116	i--)
1104	; /* Wait for chip to shutdown */	1117	; /* Wait for chip to shutdown */
		1118	if (!i) {
		1119	printf("vr%d: tx shutdown timeout\n", sc->vr_unit);
		1120	sc->vr_flags \|= VR_F_RESTART;
		1121	break;
		1122	}
1105	VR_TXOWN(cur_tx) = VR_TXSTAT_OWN;	1123	VR_TXOWN(cur_tx) = VR_TXSTAT_OWN;
1106	CSR_WRITE_4(sc, VR_TXADDR, vtophys(cur_tx->vr_ptr));	1124	CSR_WRITE_4(sc, VR_TXADDR, vtophys(cur_tx->vr_ptr));
1107	break;	1125	break;
Lines 1167-1172 Link Here
1167	s = splimp();	1185	s = splimp();
1168		1186
1169	sc = xsc;	1187	sc = xsc;
		1188	if (sc->vr_flags & VR_F_RESTART) {
		1189	printf("vr%d: restarting\n", sc->vr_unit);
		1190	vr_stop(sc);
		1191	vr_reset(sc);
		1192	vr_init(sc);
		1193	sc->vr_flags &= ~VR_F_RESTART;
		1194	}
		1195
1170	mii = device_get_softc(sc->vr_miibus);	1196	mii = device_get_softc(sc->vr_miibus);
1171	mii_tick(mii);	1197	mii_tick(mii);
1172		1198
Lines 1208-1217 Link Here
1208	if (status & VR_ISR_RX_OK)	1234	if (status & VR_ISR_RX_OK)
1209	vr_rxeof(sc);	1235	vr_rxeof(sc);
1210		1236
		1237	if (status & VR_ISR_RX_DROPPED) {
		1238	printf("vr%d: rx packet lost\n", sc->vr_unit);
		1239	ifp->if_ierrors++;
		1240	}
		1241
1211	if ((status & VR_ISR_RX_ERR) \|\| (status & VR_ISR_RX_NOBUF) \|\|	1242	if ((status & VR_ISR_RX_ERR) \|\| (status & VR_ISR_RX_NOBUF) \|\|
1212	(status & VR_ISR_RX_NOBUF) \|\| (status & VR_ISR_RX_OFLOW) \|\|	1243	(status & VR_ISR_RX_NOBUF) \|\| (status & VR_ISR_RX_OFLOW)) {
1213	(status & VR_ISR_RX_DROPPED)) {	1244	printf("vr%d: receive error (%04x)",
1214	vr_rxeof(sc);	1245	sc->vr_unit, status);
		1246	if (status & VR_ISR_RX_NOBUF)
		1247	printf(" no buffers");
		1248	if (status & VR_ISR_RX_OFLOW)
		1249	printf(" overflow");
		1250	if (status & VR_ISR_RX_DROPPED)
		1251	printf(" packet lost");
		1252	printf("\n");
1215	vr_rxeoc(sc);	1253	vr_rxeoc(sc);
1216	}	1254	}
1217		1255
Lines 1430-1442 Link Here
1430	* so we must set both.	1468	* so we must set both.
1431	*/	1469	*/
1432	VR_CLRBIT(sc, VR_BCR0, VR_BCR0_RX_THRESH);	1470	VR_CLRBIT(sc, VR_BCR0, VR_BCR0_RX_THRESH);
1433	VR_SETBIT(sc, VR_BCR0, VR_BCR0_RXTHRESHSTORENFWD);	1471	VR_SETBIT(sc, VR_BCR0, VR_BCR0_RXTHRESH128BYTES);
1434		1472
1435	VR_CLRBIT(sc, VR_BCR1, VR_BCR1_TX_THRESH);	1473	VR_CLRBIT(sc, VR_BCR1, VR_BCR1_TX_THRESH);
1436	VR_SETBIT(sc, VR_BCR1, VR_BCR1_TXTHRESHSTORENFWD);	1474	VR_SETBIT(sc, VR_BCR1, VR_BCR1_TXTHRESHSTORENFWD);
1437		1475
1438	VR_CLRBIT(sc, VR_RXCFG, VR_RXCFG_RX_THRESH);	1476	VR_CLRBIT(sc, VR_RXCFG, VR_RXCFG_RX_THRESH);
1439	VR_SETBIT(sc, VR_RXCFG, VR_RXTHRESH_STORENFWD);	1477	VR_SETBIT(sc, VR_RXCFG, VR_RXTHRESH_128BYTES);
1440		1478
1441	VR_CLRBIT(sc, VR_TXCFG, VR_TXCFG_TX_THRESH);	1479	VR_CLRBIT(sc, VR_TXCFG, VR_TXCFG_TX_THRESH);
1442	VR_SETBIT(sc, VR_TXCFG, VR_TXTHRESH_STORENFWD);	1480	VR_SETBIT(sc, VR_TXCFG, VR_TXTHRESH_STORENFWD);