if_lnisa.c

IXP425的BSP代码

    bcopy ( (char *) pIDR->ac_enaddr, (buf + 6), 6);
    /* added htons translation joes 12/9/96 */
    ((ENET_HDR *)buf)->type = htons(packetType);

    /* Copy packet from MBUFs to our transmit buffer.  MBUFs are
     * transparently freed.
     */

    bcopy_from_mbufs    (
                        (buf + ENET_HDR_REAL_SIZ),
                        pMbuf,
                        len,                            /* stuffed by macro */
                        pDrvCtrl->memWidth
                        );

    /* Ensure we send a legal size frame. */

    len += ENET_HDR_REAL_SIZ;
    len = max (ETHERSMALL, len);

    /* call output hook if any */

    hookAte = FALSE;
    if  (etherOutputHookRtn != NULL)
      {
        if  (
            (* etherOutputHookRtn)(&pDrvCtrl->idr.ac_if, buf, len)
            )
            hookAte = TRUE;
      }

    /* place a transmit request */
    if (hookAte == FALSE)
      {

	oldLevel = intLock ();          /* disable ints during update */

	tmd->tbuf_tmd3 = 0;                     /* clear buffer error status */

	/* negative message byte count */
	tmd->tbuf_tmd2 = (TMD2_BCNT_MSK & -len);
	tmd->tbuf_tmd2 |= TMD2_MBO;


	tmd->tbuf_tmd1 |= (TMD1_ENP|TMD1_STP); /* start and end of packet */
	/*tmd->tbuf_tmd1 |= TMD1_STP;  buffer is start of packet */
	tmd->tbuf_tmd1 &= ~(TMD1_DEF|TMD1_MORE|TMD1_ERR);/* clear status bit */
	/*	tmd->tbuf_tmd1 &= ~TMD1_MORE;
	tmd->tbuf_tmd1 &= ~TMD1_ERR;*/
	tmd->tbuf_tmd1 |= TMD1_OWN;

	/* Flush the write pipe */

	CACHE_PIPE_FLUSH ();

	intUnlock (oldLevel);   /* now lnInt won't get confused */

	/* Advance our management index */

	pDrvCtrl->tindex = (pDrvCtrl->tindex + 1) & (pDrvCtrl->tsize - 1);

	/* kick start the transmitter, if selected */

	if (lnKickStartTx)
	  lnCsrWrite (pDrvCtrl, 0, (CSR0_IENA | CSR0_TDMD));

	pDrvCtrl->flags &= ~LS_START_OUTPUT_FLAG;

	/* Bump the statistic counter. */

	pIDR->ac_if.if_opackets++;
      }
    outputDone:

    /* Release exclusive access. */

    semGive (pDrvCtrl->TxSem);

    return (OK);

    }

/*******************************************************************************
*
* lnIoctl - the driver I/O control routine
*
* Process an ioctl request.
*/

static int lnIoctl
    (
    IDR  *ifp,
    int            cmd,
    caddr_t        data
    )
    {
    int error = 0;

    switch (cmd)
        {
        case SIOCSIFADDR:
            ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
            break;

        case SIOCSIFFLAGS:
            /* No further work to be done */
            break;

        default:
            error = EINVAL;
        }

    return (error);
    }

/*******************************************************************************
*
* lnChipReset - hardware reset of chip (stop it)
*/

static int lnChipReset
    (
    DRV_CTRL  *pDrvCtrl
    )
    {

    lnCsrWrite (pDrvCtrl, CSR(0), CSR0_STOP);

    return (OK);
    }

/*******************************************************************************
*
* lnCsrWrite - select and write a CSR register
*
*/

void lnCsrWrite
    (
    DRV_CTRL * 	pDrvCtrl,		/* driver control */
    int 	reg,			/* register to select */
    USHORT 	value			/* value to write */
    )
    {
    int dv = (int)pDrvCtrl->devAdrs;

    /* select CSR */
    sysOutWord(dv+RAPOffset,reg);;

    /* write val to CSR */
    sysOutWord(dv+CSROffset,value);;

    }

/*******************************************************************************
*
* lnCsrRead - select and read a CSR register
*
*/

USHORT lnCsrRead
    (
    DRV_CTRL *	pDrvCtrl,		/* driver control */
    int		reg			/* register to select */
    )
    {
    int dv = (int)pDrvCtrl->devAdrs;

    /* select CSR */
    sysOutWord(dv+RAPOffset,reg);;

    /* get contents of CSR */
    return (sysInWord(dv+CSROffset));

    }

/*******************************************************************************
*
* lnIdpWrite - select and write a IDP register
*
*/

void lnIdpWrite
    (
    DRV_CTRL * 	pDrvCtrl,		/* driver control */
    int 	reg,			/* register to select */
    USHORT 	value			/* value to write */
    )
    {
    int dv = (int)pDrvCtrl->devAdrs;

    /* select IDP */
    sysOutWord(dv+RAPOffset,reg);;

    /* write val to IDP */
    sysOutWord(dv+IDPOffset,value);;

    }

/*******************************************************************************
*
* lnIdpRead - select and read a Idp register
*
*/

USHORT lnIdpRead
    (
    DRV_CTRL *	pDrvCtrl,		/* driver control */
    int		reg			/* register to select */
    )
    {
    int dv = (int)pDrvCtrl->devAdrs;

    /* select IDP register */
    sysOutWord(dv+RAPOffset,reg);;

    /* get contents of IDP register */
    return (sysInWord(dv+IDPOffset));

    }

/*******************************************************************************
*
* lnRestart - restart the device after a fatal error
*
* This routine takes care of all the messy details of a restart.  The device
* is reset and re-initialized.  The driver state is re-synchronized.
*/

static void lnRestart
    (
    int unit,
    int loc,
    int stat
    )
    {
    printf("ln: RESTART called, loc = %d, stat = %x\n",loc,stat);
    taskSuspend (0);
    }


#include "sys/socket.h"

/*******************************************************************************
*
* convertDestAddr - converts socket addr into enet addr and packet type
*
*/

static BOOL convertDestAddr
    (
    IDR *pIDR,                          /* ptr to i/f data record */
    SOCK *pDestSktAddr,                 /* ptr to a generic sock addr */
    char *pDestEnetAddr,                /* where to write enet addr */
    u_short *pPacketType,               /* where to write packet type */
    MBUF *pMbuf                         /* ptr to mbuf data */
    )
    {

    /***** Internet family *****/

    {
    struct in_addr destIPAddr;              /* not used */
    int trailers;                           /* not supported */

     if (pDestSktAddr->sa_family == AF_INET)
        {
        *pPacketType = ETHERTYPE_IP;            /* stuff packet type */
        destIPAddr = ((struct sockaddr_in *) pDestSktAddr)->sin_addr;

        if (!arpresolve (pIDR, pMbuf, &destIPAddr, pDestEnetAddr, &trailers))
            return (FALSE);     /* if not yet resolved */

        return (TRUE);
        }
    }


    /***** Generic family *****/

    {
    ENET_HDR *pEnetHdr;

    if (pDestSktAddr->sa_family == AF_UNSPEC)
        {
        pEnetHdr = (ENET_HDR *) pDestSktAddr->sa_data;      /* ptr to hdr */
        bcopy (pEnetHdr->dst, pDestEnetAddr, 6);            /* copy dst addr */
        *pPacketType = pEnetHdr->type;                      /* copy type */
        return (TRUE);
        }
    }


    /* Unsupported family */

    return (FALSE);

    } /* End of convertDestAddr() */

#ifdef LNISA_DEBUG

STATUS lnIsa_restart(DRV_CTRL     *pDrvCtrl)
{

    sysIntDisablePIC (pDrvCtrl->ilevel);        /* disable LANCE interrupts */
    pDrvCtrl->idr.ac_if.if_flags &= ~(IFF_UP | IFF_RUNNING);
    if (lnChipReset (pDrvCtrl) == ERROR)	/* reset lance device */
    	{
	printf ("Unable to Reset lnIsa%d\n",pDrvCtrl->idr.ac_if.if_unit);
	return (ERROR);
	}

    { /* Initialize all shared memory structures */

    ln_rmd  *rmd;
    ln_tmd  *tmd;
    char    *buf;
    ULONG    pTemp;
    int     loopy;

    /* Set up the Rx descriptors */

    rmd = pDrvCtrl->rring;                      /* receive ring */
    buf = pDrvCtrl->rmd_ring.r_bufs;
    for (loopy = 0; loopy < pDrvCtrl->rsize; loopy++)
    {
        pTemp = (ULONG)LN_CACHE_VIRT_TO_PHYS(buf);/* convert to physical addr */
      rmd->rbuf_adr = (USHORT)(pTemp & 0x0000ffff); /* bits 15:00 buf addr */
      rmd->rbuf_rmd1 = (USHORT)((pTemp & 0x00ff0000) >> 16); /* bits 7:0 */
      /* neg of buffer byte count */
      rmd->rbuf_bcnt = ((RMD2_BCNT_MSK & -(pDrvCtrl->bufSize)) | RMD2_MBO);
      rmd->rbuf_mcnt = 0;			/* no message byte count yet */
      rmd->rbuf_rmd1 |= RMD1_OWN;	/* buffer now owned by LANCE */
      rmd++;					/* step to next descriptor */
      buf += (pDrvCtrl->bufSize);		/* step to the next buffer */
    }

    pDrvCtrl->rindex = 0;

     /* Setup the Tx descriptors */

    tmd = pDrvCtrl->tring;                 /* transmit ring */
    buf = pDrvCtrl->tmd_ring.t_bufs;

    for (loopy = 0; loopy < pDrvCtrl->tsize; loopy++)
    {
      pTemp = (ULONG)LN_CACHE_VIRT_TO_PHYS(buf); /* convert to physical addr */
      tmd->tbuf_adr = (USHORT) (pTemp & 0x0000ffff); /* bits 15:00 of addr */
      tmd->tbuf_tmd1 = (USHORT)((pTemp & 0x00ff0000) >> 16); /* bits 7:0 */
      tmd->tbuf_tmd2 = 0;		/* no length of Tx Buf yet */
      tmd->tbuf_tmd3 = 0;		/* clear status bits */
      tmd->tbuf_tmd1 |= TMD1_ENP;	/* buffer is end of packet */
      tmd->tbuf_tmd1 |= TMD1_STP;	/* buffer is start of packet */
      tmd++;					/* step to next descriptor */
      buf += (pDrvCtrl->bufSize);		/* step to next buffer */
    }

    pDrvCtrl->tindex = pDrvCtrl->dindex = 0;

    /* Flush the write pipe */

    CACHE_PIPE_FLUSH ();
    }

    { /* Start the device */

    USHORT	stat = 0;
    ULONG	pTemp;
    int		timeoutCount = 0;

    lnCsrWrite (pDrvCtrl, 0, CSR0_STOP);	/* set the stop bit */

    /* Point the device to the initialization block */

    pTemp = (ULONG)LN_CACHE_VIRT_TO_PHYS ( pDrvCtrl->ib );
    lnCsrWrite (pDrvCtrl, 2, (USHORT)((pTemp >> 16) & 0x000000ff));
    lnCsrWrite (pDrvCtrl, 1, (USHORT)(pTemp & 0x0000ffff));
    lnCsrWrite (pDrvCtrl, 0, CSR0_INIT);            /* init chip (read IB) */

    while (((stat = lnCsrRead (pDrvCtrl, 0)) & (CSR0_IDON | CSR0_ERR)) == 0)
        {
        if (timeoutCount++ > 5) 
	  break;
        taskDelay(sysClkRateGet());
        }

    if ((stat & CSR0_ERR) == CSR0_ERR)
	{
	if ((stat & CSR0_MERR)  == CSR0_MERR)
	    {
	    printf ("Lance Memory error during initialization:\t0x%x\n",
		    stat);
	    }
	else
	    {
	    printf ("Lance Error during initialization:\t0x%x\n",
		    stat);
	    }
	}

    /* log chip initialization failure */

    if ( (stat & CSR0_ERR) || (timeoutCount >= 0x10000) )
        {
        printf ("lnIsa%d: Device initialization failed\n",
                    pDrvCtrl->idr.ac_if.if_unit);
        return (ERROR);
        }
    /* Device is initialized.  Start transmitter and receiver.  The device
     * RAP register is left selecting CSR 0.
     */

    lnCsrWrite(pDrvCtrl, 0, CSR0_IDON | CSR0_IENA | CSR0_STRT);

    sysIntEnablePIC (pDrvCtrl->ilevel);         /* enable LANCE interrupts */

    pDrvCtrl->idr.ac_if.if_flags |= (IFF_UP | IFF_RUNNING | IFF_NOTRAILERS);

    } /* Block end; device initialization */

    return (OK);
}

#endif /* LNISA_DEBUG */

BOOL outHook (struct ifnet *pIf,char *buf,int len)
{
  UINT8 *myHdr = (UINT8 *)buf;

  printf("\nSending Packet:\n");
  printf("Dest: %02x:%02x:%02x:%02x:%02x:%02x\n",myHdr[0],myHdr[1],
	 myHdr[2],myHdr[3],myHdr[4],myHdr[5]);
  printf("Src : %02x:%02x:%02x:%02x:%02x:%02x\n",myHdr[6],myHdr[7],
	 myHdr[8],myHdr[9],myHdr[10],myHdr[11]);
  printf("len = %d\n",len);
  printf("Data at %p\n",buf);
  return FALSE;
}

BOOL inHook (struct ifnet *pIf,char *buf,int len)
{
  UINT8 *myHdr = (UINT8 *)buf;

  printf("\nGot Packet:\n");
  printf("Dest: %02x:%02x:%02x:%02x:%02x:%02x\n",myHdr[0],myHdr[1],
	 myHdr[2],myHdr[3],myHdr[4],myHdr[5]);
  printf("Src : %02x:%02x:%02x:%02x:%02x:%02x\n",myHdr[6],myHdr[7],
	 myHdr[8],myHdr[9],myHdr[10],myHdr[11]);
  printf("len = %d\n",len);
  printf("Data at %p\n",buf);
  return FALSE;
}


/* END OF FILE */