ne2000end.c

BSP for S3C2410

LOCAL int ne2000PacketGet
    (
    NE2000END_DEVICE	*pDrvCtrl,
    char		*pData
    )
    {
    UINT        packetSize;
    UCHAR	uppByteCnt;
    UINT8       tempPage;              
    UINT8       pageCount;             
    UINT        packetLen = 0;
    NE2000_HEADER  h;
	char tmpData[2048];
	int tmpDataLen = 0;

	ENDLOGMSG (("into ne2000PacketGet.\n", 0, 0, 0, 0, 0, 0));
	
    if (pDrvCtrl->nextPacket == pDrvCtrl->current)
		return (0);

	#ifdef _USE_RECV_DMA_
	memcpy(&h , pDrvCtrl->recvMapBuf[pDrvCtrl->nextMapPage] , sizeof (NE2000_HEADER));
	#else    
	ne2000DataIn (pDrvCtrl,
		  (((UINT)pDrvCtrl->nextPacket << 8) & 0x0000ffff),
		  sizeof (NE2000_HEADER), (char *) &h);	
	#endif

    if (h.next > pDrvCtrl->nextPacket)
	uppByteCnt = (UCHAR) (h.next - pDrvCtrl->nextPacket);
    else
	uppByteCnt = (UCHAR) ((NE2000_PSTOP - pDrvCtrl->nextPacket)
			      + (h.next - NE2000_PSTART));
    if (h.lowByteCnt > 0xfc)
	uppByteCnt -= 2;
    else
	uppByteCnt -= 1;
    h.uppByteCnt = uppByteCnt;


    packetSize = (((UINT)h.uppByteCnt << 8) + h.lowByteCnt) - 4;

    pageCount = (UCHAR) ((packetSize + 4 + sizeof (NE2000_HEADER)
			  + (ENE_PAGESIZE - 1)) / ENE_PAGESIZE);
    tempPage = (UCHAR) (pDrvCtrl->nextPacket + pageCount);
    if (tempPage >= NE2000_PSTOP)
	tempPage -= (NE2000_PSTOP - NE2000_PSTART);
    if ((h.next != tempPage) ||
	(h.next < NE2000_PSTART) || (h.next >= NE2000_PSTOP))
	{
	pDrvCtrl->stats.badPacket++;
	pDrvCtrl->stats.rerror++;
	if (!(pDrvCtrl->flags & (END_OVERWRITE|END_OVERWRITE2)))
	    ne2000Config (pDrvCtrl, TRUE);
	return (-1);
	}

    if (packetSize < 60)
	{
	pDrvCtrl->stats.shortPacket++;
	goto doneGet;
	}

    if (packetSize > NE2000_BUFSIZ)
	goto doneGet;

    if (h.rstat & RSTAT_PRX)
	{
	if (h.rstat & (RSTAT_DFR | RSTAT_DIS))
	    {
	    pDrvCtrl->stats.badPacket++;
	    pDrvCtrl->stats.rerror++;
	    goto doneGet;
	    }
	pDrvCtrl->stats.rnoerror++;
	}
    else
	{
	if (h.rstat & RSTAT_DFR)
	    pDrvCtrl->stats.jabber++;
	pDrvCtrl->stats.rerror++;
	goto doneGet;
	}

    packetLen = packetSize;

	#ifdef _USE_RECV_DMA_
	memcpy(pData , pDrvCtrl->recvMapBuf[pDrvCtrl->nextMapPage]+sizeof (NE2000_HEADER) , packetLen);
	#else
	tmpDataLen = ((packetLen+sizeof(NE2000_HEADER))/256+1)*256-sizeof(NE2000_HEADER);
    ne2000DataIn (pDrvCtrl,
		  ((UINT)pDrvCtrl->nextPacket << 8) + sizeof (NE2000_HEADER),
		  tmpDataLen,
		  tmpData);
	memcpy(pData , tmpData , packetLen);

	ENDLOGMSG (("into ne2000PacketGet.nextMapPage = %d:len = %d:tmplen = %d.\n", pDrvCtrl->nextPacket
			, tmpDataLen , packetLen, 0, 0, 0));
	#endif


doneGet:
	#ifdef _USE_RECV_DMA_	
	if( pDrvCtrl->nextPacket<= h.next)
	{
		pDrvCtrl->nextMapPage += (h.next-pDrvCtrl->nextPacket);
	}
	else
	{
		pDrvCtrl->nextMapPage += ((NE2000_PSTOP-pDrvCtrl->nextPacket)+
				(h.next-NE2000_PSTART));
	}
	#endif
    pDrvCtrl->nextPacket = h.next;
    SYS_OUT_CHAR (pDrvCtrl, ENE_BOUND,
		  (pDrvCtrl->nextPacket != NE2000_PSTART ?
		   pDrvCtrl->nextPacket - 1 : NE2000_PSTOP - 1));

    return (packetLen);
    }


/******************************************************************************
*
* device.
*/

LOCAL STATUS ne2000PollRecv
    (
    void*	pCookie,	
    M_BLK_ID	pMblk
    )
    {
    int len;
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

	ENDLOGMSG (("into ne2000PollRecv.\n", 0, 0, 0, 0, 0, 0));

    pDrvCtrl->current = ne2000GetCurr (pDrvCtrl);
    if (pDrvCtrl->nextPacket == pDrvCtrl->current)
        return ((STATUS) (EAGAIN));

    if ((pMblk->mBlkHdr.mLen < NE2000_BUFSIZ)
	|| !(pMblk->mBlkHdr.mFlags & M_EXT))
	{
        return ((STATUS) (EAGAIN));
	}

    ENDLOGMSG (("ne2000PollRecv: enter: imask=%02x\n",
		pDrvCtrl->imask, 0, 0, 0, 0, 0));

    len = ne2000PacketGet (pDrvCtrl, pMblk->mBlkHdr.mData + pDrvCtrl->offset);
    if (len <= 0)
        return ((STATUS) (EAGAIN));
    pMblk->mBlkHdr.mFlags |= M_PKTHDR;
    pMblk->mBlkHdr.mLen   = len;
    pMblk->mBlkPktHdr.len = len;
    pMblk->mBlkHdr.mData += pDrvCtrl->offset;

    ENDLOGMSG (("ne2000PollRecv: done: imask=%02x\n",
		pDrvCtrl->imask, 0, 0, 0, 0, 0));
    return (OK);
    }

/*******************************************************************************
*
* device.
*/

static STATUS ne2000PollSend
    (
    void*	pCookie,	
    M_BLK_ID	pMblk
    )
    {
    char *	pBuf;
    UCHAR	cmdStat;
    int		len;
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

    ENDLOGMSG (("ne2000PollSend: enter: imask=%x flags=%x\n",
		pDrvCtrl->imask, pDrvCtrl->flags, 0, 0, 0, 0));

    SYS_IN_CHAR (pDrvCtrl, ENE_CMD, &cmdStat);
    while (cmdStat & CMD_TXP)
	SYS_IN_CHAR (pDrvCtrl, ENE_DATA, &cmdStat);


	#ifdef	_USE_SND_DMA_
    pBuf = pDrvCtrl->packetBuf[0];
	#else
	pBuf = pDrvCtrl->packetBuf;
	#endif
    len = netMblkToBufCopy (pMblk, pBuf, NULL);
    len = max (len, ETHERSMALL);

	#ifdef _USE_SND_DMA_
	ne2000DataOut (pDrvCtrl, pDrvCtrl->packetBuf[0], len, (NE2000_TSTART << 8));
	#else
	ne2000DataOut (pDrvCtrl, pDrvCtrl->packetBuf, len, (NE2000_TSTART << 8));
	#endif

    CACHE_PIPE_FLUSH ();


    SYS_OUT_CHAR (pDrvCtrl, ENE_TSTART, NE2000_TSTART);
    SYS_OUT_CHAR (pDrvCtrl, ENE_TCNTH, len >> 8);
    SYS_OUT_CHAR (pDrvCtrl, ENE_TCNTL, len & 0xff);
    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_TXP | CMD_START);


    END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);


    CACHE_PIPE_FLUSH ();


    SYS_IN_CHAR (pDrvCtrl, ENE_CMD, &cmdStat);
    while (cmdStat & CMD_TXP)
	SYS_IN_CHAR (pDrvCtrl, ENE_CMD, &cmdStat);

    ENDLOGMSG (("ne2000PollSend: done: imask=%x flags=%x\n",
		pDrvCtrl->imask, pDrvCtrl->flags, 0, 0, 0, 0));

    return (OK);
    }

/*******************************************************************************
*
* ne2000PollStart - start polled mode operations
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS ne2000PollStart
    (
    NE2000END_DEVICE* pDrvCtrl
    )
    {
    int oldLevel;

    oldLevel = intLock ();
    ENDLOGMSG (("ne2000PollStart: imask=%x flags=%x\n",
		pDrvCtrl->imask, pDrvCtrl->flags, 0, 0, 0, 0));
    pDrvCtrl->flags |= END_POLLING;
    pDrvCtrl->imask = 0;
    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);
    intUnlock (oldLevel);

    return (OK);
    }

/*******************************************************************************
*
* ne2000PollStop - stop polled mode operations
*
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS ne2000PollStop
    (
    NE2000END_DEVICE* pDrvCtrl
    )
    {
    int oldLevel;

    oldLevel = intLock ();
    pDrvCtrl->flags &= ~END_POLLING;
    pDrvCtrl->imask = NE2000_ALL_INTS;
    if (pDrvCtrl->flags & END_RECV_HANDLING_FLAG)
	pDrvCtrl->imask &= ~IM_PRXE;
    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);

    ENDLOGMSG (("ne2000PollStop: imask=%x flags=%x\n",
		pDrvCtrl->imask, pDrvCtrl->flags, 0, 0, 0, 0));
    intUnlock (oldLevel);
    return (OK);
    }

/******************************************************************************
*
* ne2000AddrFilterSet - set the address filter for multicast addresses
*
*
* NOMANUAL
*/
LOCAL void ne2000AddrFilterSet
    (
    NE2000END_DEVICE *pDrvCtrl
    )
    {
    int i;
    int eAddr;
    u_char enetChar;
    u_char *pCp;
    u_long crc;
    ETHER_MULTI* pCurr;

    ENDLOGMSG (("ne2000AddrFilterSet\n", 0, 0, 0, 0, 0, 0));

   
    for (i = 0; i < 8; ++i)
	pDrvCtrl->mcastFilter[i] = 0;

    for (pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->endObj);
	 pCurr != NULL;
	 pCurr = END_MULTI_LST_NEXT(pCurr))
	{
	pCp = (unsigned char *)&pCurr->addr;

	crc = 0xffffffff; 


	for (eAddr = 0; eAddr < 6; eAddr++)
	    {
	    enetChar = *pCp++;
            crc = ne2000CrcWork (enetChar, crc);
	    }


	crc >>= 26;
	crc &= 0x3f;



	pDrvCtrl->mcastFilter[crc >> 3] |= (1 << (crc & 7));
	}
    }

/*****************************************************************************
*
* ne2000CrcWork - return CRC using a 32 bit polynomial
*
*
* NOMANUAL
*
*/

LOCAL UINT32 ne2000CrcWork
    (
    UINT8 inChar,
    UINT32 inCrc
    )
    {
    UINT8 work = 0;
    UINT8 wrap;
    int i;
     ENDLOGMSG (("into ne2000CrcWork.\n", 0, 0, 0, 0, 0, 0));

    for (i = 0; i < 8; i++)
        {
        wrap = (inCrc >> 31);
        inCrc <<= 1;
        work  = ((work << 1) | wrap) ^ inChar;
        if (work & 1)
            {
            inCrc ^= CRC32_POLYNOMIAL;
            }
         work >>= 1;
         inChar >>= 1;
         }
     return (inCrc);
     }


/*****************************************************************************
*
* ne2000MCastAdd - add a multicast address for the device
*
*/

LOCAL STATUS ne2000MCastAdd
    (
    void*	pCookie,	/* device ptr */
    char*	pAddress
    )
    {
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

    ENDLOGMSG (("ne2000MCastAdd - %02x:%02x:%02x:%02x:%02x:%02x\n",
		pAddress[0]&0xff, pAddress[1]&0xff, pAddress[2]&0xff,
		pAddress[3]&0xff, pAddress[4]&0xff, pAddress[5]&0xff));

    if (etherMultiAdd (&pDrvCtrl->endObj.multiList, pAddress) == ENETRESET)
	{
	}

    return (OK);
    }

/*****************************************************************************
*
* ne2000MCastDel - delete a multicast address for the device
*
*/

LOCAL STATUS ne2000MCastDel
    (
    void*	pCookie,	/* device ptr */
    char*	pAddress
    )
    {
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

    ENDLOGMSG (("ne2000MCastDel - %02x:%02x:%02x:%02x:%02x:%02x\n",
		pAddress[0]&0xff, pAddress[1]&0xff, pAddress[2]&0xff,
		pAddress[3]&0xff, pAddress[4]&0xff, pAddress[5]&0xff));

    if (etherMultiDel (&pDrvCtrl->endObj.multiList,
		       (char *)pAddress) == ENETRESET)
	{
	}

    return (OK);
    }

/*****************************************************************************
*
* ne2000MCastGet - get the multicast address list for the device
*
*/

LOCAL STATUS ne2000MCastGet
    (
    void*		pCookie,	/* device ptr */
    MULTI_TABLE*	pTable
    )
    {
    int error;
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

    ENDLOGMSG (("ne2000MCastGet\n", 0, 0, 0, 0, 0, 0));
    error = etherMultiGet (&pDrvCtrl->endObj.multiList, pTable);

    return (error);
    }

/******************************************************************************
*
* ne2000Stop - stop the device
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS ne2000Stop
    (
    void *pCookie
    )
    {
    STATUS result = OK;
    NE2000END_DEVICE* pDrvCtrl;

	ENDLOGMSG (("into ne2000Stop.\n", 0, 0, 0, 0, 0, 0));

    pDrvCtrl = (NE2000END_DEVICE *) pCookie;


    END_FLAGS_CLR (&pDrvCtrl->endObj, IFF_UP | IFF_RUNNING);


    pDrvCtrl->imask = 0;

    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);


    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE0 | CMD_STOP);

    ENDLOGMSG (("ne2000Stop\n", 0, 0, 0, 0, 0, 0));

    SYS_INT_DISCONNECT (pDrvCtrl, ne2000Int, (int)pDrvCtrl, &result);

    if (result == ERROR)
	ENDLOGMSG (("Could not disconnect interrupt!\n", 1, 2, 3, 4, 5, 6));

    return (result);
    }

/******************************************************************************
*
* ne2000Unload - unload a driver from the system
*
*/

LOCAL STATUS ne2000Unload
    (
    void *pCookie
    )
    {
    NE2000END_DEVICE* pDrvCtrl = (NE2000END_DEVICE *) pCookie;

    ENDLOGMSG (("ne2000Unload\n", 0, 0, 0, 0, 0, 0));

    END_OBJECT_UNLOAD (&pDrvCtrl->endObj); /* generic end unload functions */

    return (OK);
    }

/******************************************************************************
*
* ne2000EnetAddrGet - get enet address
*
* NOMANUAL
*/

LOCAL void ne2000EnetAddrGet
    (
    NE2000END_DEVICE* pDrvCtrl
    )
    {
    int i;

	ENDLOGMSG (("into ne2000EnetAddrGet.\n", 0, 0, 0, 0, 0, 0));

	    
	bcopyBytes ((char *) (0x7e000), &(MAC_INFO),sizeof(MAC_INFO));
	if ((MAC_INFO.macshowinfo[0] !=0)||(MAC_INFO.macshowinfo[1] !=0)||(MAC_INFO.macshowinfo[2] !=0)||(MAC_INFO.macshowinfo[3] !=0)||(MAC_INFO.macshowinfo[4] !=0)||(MAC_INFO.macshowinfo[5] !=0))
	{
	for (i = 0; i < 6; ++i)
		ne2000EnetAddr[i] = MAC_INFO.macshowinfo[i];
	}
	else
	{
			for (i = 0; i < 6; ++i)
						MAC_INFO.macshowinfo[i] = ne2000EnetAddr[i];
			SST39VF160_ChipProg(0x3F000,&(MAC_INFO),sizeof(MAC_INFO));
	}	


    if (pDrvCtrl->usePromEnetAddr)
	{
	SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE0 | CMD_START);
	SYS_OUT_CHAR (pDrvCtrl, ENE_RSAR0, NE2000_EADDR_LOC);
	SYS_OUT_CHAR (pDrvCtrl, ENE_RSAR1, NE2000_CONFIG_PAGE);
	SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR0, (EADDR_LEN * 2) & 0xff);
	SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR1, (EADDR_LEN * 2) >> 8);
	SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_RREAD | CMD_START);

	for (i = 0; i < 6; ++i)
	    {
	    char ch;

	    SYS_IN_CHAR (pDrvCtrl, ENE_DATA, &pDrvCtrl->enetAddr[i]);
	    if (pDrvCtrl->byteAccess)
		SYS_IN_CHAR (pDrvCtrl, ENE_DATA, &ch);
	    }

	for (i = 0; i < 6; ++i)
	    if (pDrvCtrl->enetAddr[i])
		return;
	}

    for (i = 0; i < 6; ++i)
	pDrvCtrl->enetAddr[i] = ne2000EnetAddr[i];

    }

/******************************************************************************
*
* ne2000GetCurr - get current page
*
* RETURNS: current page that ENE is working on
*
* NOMANUAL
*/

LOCAL UCHAR ne2000GetCurr
    (
    NE2000END_DEVICE* pDrvCtrl
    )
    {
    UCHAR curr;

	ENDLOGMSG (("into ne2000GetCurr.\n", 0, 0, 0, 0, 0, 0));

    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_PAGE1);
    SYS_IN_CHAR (pDrvCtrl, ENE_CURR, &curr);
    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_PAGE0);

    return (curr);
    }