📄 rtl81x9.c
字号:
)
{
STATUS result;
int rxcfg;
unsigned short data;
int i;
pDrvCtrl->txBlocked = FALSE;
SYS_INT_CONNECT (pDrvCtrl, rtl81x9Int, (int)pDrvCtrl, &result);
if (result == ERROR)
return ERROR;
SYS_INT_ENABLE (pDrvCtrl);
/* Init the RX buffer pointer register. */
/*convert to physical address*/
rtl81x9CsrWriteLong(pDrvCtrl, RTL_REGS_RX_BUF, MMU_OFFSET((ULONG)(pDrvCtrl->ptrRxBufSpace)), RTL_WIN_0);
/*DRV_LOG (DRV_DEBUG_ALL, "rxbuffer start- %x: \n",(ULONG) pDrvCtrl->ptrRxBufSpace , 2, 3, 4, 5, 6);*/
/* Enable Tx and RX */
rtl81x9CsrWriteByte(pDrvCtrl, RTL_REGS_CHIP_CMD, RTL_CMD_RX_ENB + RTL_CMD_TX_ENB, RTL_WIN_0);
/*
* Set the initial TX and RX configuration.
* Set the buffer size and set the wrap register
*/
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_TX_CONFIG, RTL_TXCFG_CONFIG, RTL_WIN_0);
/* DRV_LOG (DRV_DEBUG_ALL, "rtl81x9-TXCFG - %x: \n",RTL_TXCFG_CONFIG , 2, 3, 4, 5, 6);*/
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_RX_CONFIG, RTL_RXCFG_CONFIG, RTL_WIN_0);
rxcfg = rtl81x9CsrReadLong(pDrvCtrl, RTL_REGS_RX_CONFIG, RTL_WIN_0);
/* Set the Early Threshold bits depending on flags read */ /*vicadd*/
/* from initialisation string */
rxcfg |= ((pDrvCtrl->flags >> 16) << 24);
/* Set the individual bit to receive frames for this host only. */
rxcfg |= RTL_RXCG_APM;
/* If we want promiscuous mode, set the allframes bit. */
if (pDrvCtrl->ib->rtlIBMode == 0x8000)
{
rxcfg |= RTL_RXCG_AAP;
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_RX_CONFIG, rxcfg, RTL_WIN_0);
}
else
{
rxcfg &= ~RTL_RXCG_AAP;
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_RX_CONFIG, rxcfg, RTL_WIN_0);
}
/*
* Set capture broadcast bit to capture broadcast frames.
*/
/*vicadd*/
rxcfg |= RTL_RXCG_AB|RTL_RXCG_AM;
/* DRV_LOG (DRV_DEBUG_ALL, "rtl81x9-RCR - %x: \n", rxcfg, 2, 3, 4, 5, 6);*/
pDrvCtrl->reg_rcr =rxcfg;/* save it */
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_RX_CONFIG, rxcfg, RTL_WIN_0);
/* We now need to update the Multicast Registers */
/* These values need to be finalised and written */
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_MAR0, 0xffff, RTL_WIN_0);
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_MAR0 + 4, 0xffff, RTL_WIN_0);
/* Enable Controller Interrupts */
rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_MASK, RTL_VALID_INTERRUPTS, NONE);
/* DRV_LOG (DRV_DEBUG_ALL, "rtl81x9-IMR - %x: \n",RTL_VALID_INTERRUPTS , 2, 3, 4, 5, 6);*/
data = rtl81x9CsrReadWord (pDrvCtrl, RTL_REGS_INTR_STATUS, NONE);
DRV_LOG(DRV_DEBUG_ALL, "rtl81x9-INTR_STATUS - %x: \n", data, 2, 3, 4, 5, 6);
rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_STATUS, 0xffff, NONE);
/* Start RX/TX process. */
rtl81x9CsrWriteLong (pDrvCtrl, RTL_REGS_RX_MISSED, 0, RTL_WIN_0);
/* Enable Tx and RX */
rtl81x9CsrWriteByte(pDrvCtrl, RTL_REGS_CHIP_CMD, RTL_CMD_RX_ENB + RTL_CMD_TX_ENB, RTL_WIN_0);
/*rtlRegisterShow(pDrvCtrl);*/
/*rtlDrvCtrlShow(pDrvCtrl); */
/*
for(i=0;i<256;i++)
rtlDataToSend[i]=i;
*/
return (OK);
}
/*******************************************************************************
*
* rtl81x9Int - handle controller interrupt
*
* This routine is called at interrupt level in response to an interrupt from
* the controller.
*
* RETURNS: N/A.
*/
LOCAL void rtl81x9Int
(
RTL81X9END_DEVICE *pDrvCtrl
)
{
u_short stat;
DRV_LOG (DRV_DEBUG_INT, "Got a interrupt \n", 0,0,0,0,0,0);
/* Disable controller interrupts. */
rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_MASK, 0x00, NONE);
for (;;)
{
/* Read the interrupt status register */
stat = rtl81x9CsrReadWord (pDrvCtrl, RTL_REGS_INTR_STATUS, NONE);
/* DRV_LOG (DRV_DEBUG_INT, "ISR status :%x ", stat,0,0,0,0,0); */
/* clear interrupts, */
if (stat)
rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_STATUS, stat, NONE);
/* Check if a valid Interrupt has been set */
if ((stat & RTL_VALID_INTERRUPTS) == 0)
break;
if (stat & RTL_IPT_PCI_ERR)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_PCI_ERR - Reset and Re initialise\n", 0,0,0,0,0,0);
rtl81x9Reset (pDrvCtrl);
rtl81x9Restart (pDrvCtrl);
}
if (stat & RTL_IPT_PCS_TIMEOUT)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_PCS_TIMEOUT\n", 0, 0, 0, 0, 0, 0);
}
if (stat & RTL_IPT_CABLE_LEN_CHG)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_CABLE_LEN_CHG\n", 0, 0, 0, 0, 0, 0);
}
if (stat & RTL_IPT_RX_FIFO_OVER)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_RX_FIFO_OVER\n", 0, 0, 0, 0, 0, 0);
}
if (stat & RTL_IPT_RX_UNDERUN)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_RX_UNDERUN\n", 0, 0, 0, 0, 0, 0);
/*vicadd*/ rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_STATUS, RTL_IPT_RX_OK|RTL_IPT_RX_OVERFLOW|RTL_IPT_RX_FIFO_OVER, NONE);
/*rxcfg=rtl81x9CsrReadLong (pDrvCtrl, RTL_REGS_RX_CONFIG, RTL_WIN_0);
DRV_LOG (DRV_DEBUG_ALL, "rtl81x9-RCR - %x: \n", rxcfg, 2, 3, 4, 5, 6);
*/
}
if (stat & RTL_IPT_RX_OVERFLOW)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_RX_OVERFLOW\n", 0, 0, 0, 0, 0, 0);
}
if (stat & RTL_IPT_TX_ERR)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_TX_ERR\n", 0, 0, 0, 0, 0, 0);
rtl81x9HandleTxInt (pDrvCtrl);
}
if (stat & RTL_IPT_RX_ERR)
{
DRV_LOG (DRV_DEBUG_INT, "RTL_IPT_RX_ERR\n", 0, 0, 0, 0, 0, 0);
if (netJobAdd ((FUNCPTR)rtl81x9HandleRecvInt, (int) pDrvCtrl,
0, 0, 0, 0) != OK)
DRV_LOG (DRV_DEBUG_INT, "xl: netJobAdd (rtl81x9HandleRecvInt) failed\n", 0, 0, 0, 0, 0, 0);
}
/* Check for transmit Interrupt */
if (stat & RTL_IPT_TX_OK)
{
rtl81x9HandleTxInt (pDrvCtrl);
}
if (stat & RTL_IPT_RX_OK)
{
if (netJobAdd ((FUNCPTR)rtl81x9HandleRecvInt, (int) pDrvCtrl,
0, 0, 0, 0) != OK)
DRV_LOG (DRV_DEBUG_INT, "xl: netJobAdd (rtl81x9HandleRecvInt) failed\n", 0, 0, 0, 0, 0, 0);
}
}
rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_MASK, RTL_VALID_INTERRUPTS, NONE);
}
/*******************************************************************************
*
* rtl81x9HandleTxInt - task level interrupt service for tx packets
*
* This routine is called by the interrupt service routine to do any
* message transmission processing.
*
* RETURNS: N/A.
*/
LOCAL void rtl81x9HandleTxInt
(
RTL81X9END_DEVICE *pDrvCtrl
)
{
int txDesc;
int i;
DRV_LOG (DRV_DEBUG_TX, "enter rtl81x9HandleTxInt\r\n", 0, 0, 0, 0, 0, 0);
for (txDesc=0; txDesc < RTL_NUM_TX_DESC; txDesc++)
{
u_long txstatus;
u_long txAddress;
txstatus = rtl81x9CsrReadLong (pDrvCtrl,
RTL_REGS_TX_STATUS0 + (txDesc*4), NONE);
txAddress = rtl81x9CsrReadLong (pDrvCtrl,
RTL_REGS_TX_ADDR0 + (txDesc*4), NONE);
DRV_LOG (DRV_DEBUG_TX, "********txstatus=0x%x*******\r\n", txstatus, 0, 0, 0, 0, 0);
if (txstatus & RTL_TX_STATUS_OK)
{
/* Has the packet been sent previously */
if ((txstatus & RTL_TX_HOST_OWNS) && (pDrvCtrl->pDescMem[txDesc] != NULL))
{
/* Clear the buffer that was registered to the Descriptor */
/* netClFree (pDrvCtrl->end.pNetPool, pDrvCtrl->pDescMem[txDesc]); */
pDrvCtrl->pDescMem[txDesc] = NULL;
pDrvCtrl->freeDesc++;
if (pDrvCtrl->freeDesc > RTL_NUM_TX_DESC)
pDrvCtrl->freeDesc = RTL_NUM_TX_DESC;
}
}
/* else if (txstatus & (RTL_TX_UNDERRUN |
RTL_TX_OUT_OF_WINDOW |
RTL_TX_ABORTED))*/
else if (txstatus & (RTL_TX_UNDERRUN |
RTL_TX_OUT_OF_WINDOW |
RTL_TX_ABORTED|
RTL_TX_CARRIER_LOST))
{
/* Clear the buffer that was registered to the Descriptor */
if (txstatus&RTL_TX_UNDERRUN) return;
/* netClFree (pDrvCtrl->end.pNetPool, pDrvCtrl->pDescMem[txDesc]); */
/* pDrvCtrl->pDescMem[txDesc] = NULL; */
rtl81x9CsrWriteLong (pDrvCtrl,
RTL_REGS_TX_STATUS0 + (txDesc*4), RTL_TX_HOST_OWNS, NONE);
}
}
}
/*******************************************************************************
*
* rtl81x9HandleRecvInt - task level interrupt service for input packets
*
* This routine is called by the interrupt service routine to do any
* message received processing.
*
* RETURNS: N/A.
*/
LOCAL void rtl81x9HandleRecvInt
(
RTL81X9END_DEVICE *pDrvCtrl
)
{
int len, wrapSize;
M_BLK_ID pMblk;
char* pNewCluster;
CL_BLK_ID pClBlk;
RTL_RX_DATA *rxData;
USHORT cur_rx;
USHORT limit,max_bytes = 0;
USHORT rx_bytes = 0;
int i;
char *readPtr;
unsigned char * pkt;
unsigned char rxStatus;
/* DRV_LOG (DRV_DEBUG_RX, "rtl81x9HandleRecvInt", 0, 0, 0, 0, 0, 0); */
/* Disable interrupts by clearing the interrupt mask. */
/*vicadd rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_MASK, 0x00, NONE); */
cur_rx = ((rtl81x9CsrReadWord (pDrvCtrl, RTL_REGS_RX_BUF_PTR, NONE)
+ 16) % RTL_RXBUFLEN);
/* DRV_LOG (DRV_DEBUG_RX, "In rtl81x9HandleRecvInt, cur_rx=%d\r\n", cur_rx, 0, 0, 0, 0, 0); */
/* Enable interrupts by setting the interrupt mask. */
/*vicadd rtl81x9CsrWriteWord (pDrvCtrl, RTL_REGS_INTR_MASK, RTL_VALID_INTERRUPTS, NONE);*/
/* limit = (rtl81x9CsrReadWord (pDrvCtrl, RTL_REGS_RX_BUF_ADDR, NONE) % RTL_RXBUFLEN);
if (limit < cur_rx)
max_bytes = (RTL_RXBUFLEN - cur_rx) + limit;
else
max_bytes = limit - cur_rx;
*/
while ((rtl81x9CsrReadByte (pDrvCtrl, RTL_REGS_CHIP_CMD, NONE) &
RTL_CMD_RX_BUF_EMPTY) == 0)
{
readPtr = (pDrvCtrl->ptrRxBufSpace + cur_rx);
rxData = (RTL_RX_DATA *) readPtr;
rxData->rxStatusFlags = PCI_WORD_SWAP(rxData->rxStatusFlags);
rxData->rxPktLen = PCI_WORD_SWAP(rxData->rxPktLen);
/* DRV_LOG (DRV_DEBUG_RX, "In rtl81x9HandleRecvInt, readPtr=0x%08x\r\n", readPtr, 0, 0, 0, 0, 0); */
DRV_LOG (DRV_DEBUG_ALL, "In rtl81x9HandleRecvInt, RTL recevie flag :0x%04x\r\n ", rxData->rxStatusFlags, 2, 3, 4, 5, 6);
DRV_LOG (DRV_DEBUG_ALL, "In rtl81x9HandleRecvInt, RTL recevie length :0x%04x\r\n ", rxData->rxPktLen, 2, 3, 4, 5, 6);
/* RTLPRINT("In rtl81x9HandleRecvInt, readPtr=0x%08x\r\n", readPtr);
RTLPRINT("In rtl81x9HandleRecvInt, RTL recevie flag :0x%04x\r\n ", rxData->rxStatusFlags);
RTLPRINT("In rtl81x9HandleRecvInt, RTL recevie length :0x%04x\r\n ", rxData->rxPktLen);
RTLPRINT("In rtl81x9HandleRecvInt, rxData->pktData=0x%08x\r\n", rxData->pktData);
rxStatus = rtl81x9CsrReadByte(pDrvCtrl, 0x36, 0);
RTLPRINT("In rtl81x9HandleRecvInt, realtek Rx Status Register:0x%02x\r\n",rxStatus);
*/
pkt = (unsigned char*)rxData;
pkt = pkt + 4;
#if 0
{
unsigned long * p;
p = (unsigned long*)pkt+30;
/* printf("test\n");*/
/* if((*p == 0xef)&&(*(p+1) == 0x0)&&(*(p+2) == 0x0)&&(*(p+3) == 0x1))
printf("in rtl81x9,got a packet from 0x%x\n",*p); */
}
#endif
#if 0
/* printf("HandleRecvInt, packet length %d ,mac header:\r\n",rxData->rxPktLen); */
if((*pkt == 0x01) && (*(pkt+1) == 0x0)&&(*(pkt+2) == 0x5e))
{
for(i=0; i < 14; i++)
printf("%02x ", *(pkt+i));
printf("\ndest ip:%02x.%02x.%02x.%02x ", *(pkt+30),*(pkt+31),*(pkt+32),*(pkt+33));
printf("\r\n***************************************\r\n");
}
/* DRV_LOG (DRV_DEBUG_RX, "HandleRecvInt, packet header:%02x\r\n", *(rxData->pktData+i), 2, 3, 4, 5, 6);*/
#endif
if ((rxData->rxPktLen >> 16) == RTL_RX_UNFINISHED)
{
DRV_LOG (DRV_DEBUG_ALL, "RxHandError 0fff0: ", 1, 2, 3, 4, 5, 6);
break;
}
if (!(rxData->rxStatusFlags & RTL_RX_STATUS_OK))
{
/* DRV_LOG (DRV_DEBUG_ALL, "In rtl81x9HandleRecvInt, RTL recevie not OK!\r\n ", 1, 2, 3, 4, 5, 6);*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -