开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
if_es.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：38k
源码类别：

VxWorks

开发平台：

C/C++

if_es.c：源码内容
  1. /* if_es.c - ETHERSTAR ethernet network interface for the DLAN */
  3. /* Copyright 1984-1998 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01i,06oct98,jmp  doc: cleanup.
  10. 01h,19aug98,fle  doc : added routine description for esattach
  11. 01g,15jul97,spm  removed driver initialization from ioctl support (SPR #8831)
  12. 01f,19may97,spm  eliminated all compiler warnings
  13. 01e,15may97,spm  reverted to bcopy routines for mbufs in BSD 4.4
  14. 01d,07apr97,spm  code cleanup, corrected statistics, and upgraded to BSD 4.4
  15. 01c,26may93,ccc  updated for 5.1.
  16. 01b,03aug92,dyn  modified by Dynatem to support their new version.
  17. 01a,01apr91,ccc  written based on other drivers (if_xx) & ESTAR documentation.
  18. */
  20. /*
  21. DESCRIPTION
  22. The only user callable routine is:
  24.     esattach (unit, devAdrs, ivec, ilevel, memAdrs, memSize, memWidth)
  26. To enable the use of the Dynatem DLAN board the following needs to be
  27. added to the target's config.h file:
  29. .CS
  30. /@ Device controller I/O addresses: @/
  32.   #define INCLUDE_ES
  33.   #define INT_VEC_ES              0xc0 /@ interrupt vector @/
  34.   #define INT_LVL_ES              5 /@ VMEbus interrupt level @/
  35.   #define IO_ADRS_ES              ((char *) 0x70008000) /@ short I/O address @/
  36. .CE
  38.  LANCE defines 
  40. .CS
  41.   #define ES_POOL_ADRS            NONE    /@ malloc the pool @/
  42.   #define ES_POOL_SIZE            NONE    /@ pool will be default size @/
  43.   #define ES_DATA_WIDTH           NONE    /@ all data widths supported @/
  44.   #define ES_PADDING              FALSE   /@ no padding for RAP @/
  45.   #define ES_RING_BUF_SIZE        0       /@ use the default size @/
  47.   #define INCLUDE_IF_USR
  48.   #define IF_USR_NAME     "es"
  49.   #define IF_USR_ATTACH   esattach
  50.   #define IF_USR_ARG1     IO_ADRS_ES
  51.   #define IF_USR_ARG2     INT_VEC_ES
  52.   #define IF_USR_ARG3     INT_LVL_ES
  53.   #define IF_USR_ARG4     ES_POOL_ADRS
  54.   #define IF_USR_ARG5     ES_POOL_SIZE
  55.   #define IF_USR_ARG6     ES_DATA_WIDTH
  56.   #define IF_USR_ARG7     ES_PADDING
  57.   #define IF_USR_ARG8     ES_RING_BUF_SIZE
  58. .CE
  60. The following needs to be added to sysLib.c under global definitions:
  62. .CS
  63.   char  esEnetAddr [6];
  64. .CE
  66. SEE ALSO: ifLib
  67. */
  69. #include "vxWorks.h"
  70. #include "stdlib.h"
  71. #include "netLib.h"
  72. #include "iv.h"
  73. #include "memLib.h"
  74. #include "ioctl.h"
  75. #include "etherLib.h"
  76. #include "logLib.h"
  77. #include "intLib.h"
  78. #include "sysLib.h"
  80. #ifndef DOC /* don't include when building documentation */
  81. #include "net/mbuf.h"
  82. #endif /* DOC */
  84. #include "net/protosw.h"
  85. #include "net/unixLib.h"
  86. #include "socket.h"
  87. #include "errno.h"
  89. #include "net/if.h"
  90. #include "net/route.h"
  92. #include "netinet/in.h"
  93. #include "netinet/in_systm.h"
  94. #include "netinet/in_var.h"
  95. #include "netinet/ip.h"
  96. #include "netinet/if_ether.h"
  97. #include "net/if_subr.h"
  99. #include "drv/netif/if_es.h"
  101. struct dlanptr {
  102. u_char *dlcr0;
  103. u_char *dlcr1;
  104. u_char *dlcr2;
  105. u_char *dlcr3;
  106. u_char *dlcr4;
  107. u_char *dlcr5;
  108. u_char *dlcr6;
  109. u_char *dlcr7;
  110. u_char *dlcr8;
  111. u_char *dlcr9;
  112. u_char *dlcr10;
  113. u_char *dlcr11;
  114. u_char *dlcr12;
  115. u_char *dlcr13;
  116. u_char *dlcr14;
  117. u_char *dlcr15;
  118. } dlan;
  120. IMPORT VOID ether_attach ();
  122. #define MAX_ES 1 /* max number of ESTAR chips on board */
  124. #define ItoKval(p,type,base)    ((type)((ULONG)(p) + (ULONG)(base)))
  125. #define ItoK(p,type,base)       ((p) = ItoKval(p,type,base))
  127. #define ES_RMD_GIVE_TO_ESTAR(pRmd) 
  128.     { 
  129.     pRmd->rbuf_rmd1 &= 0xff; 
  130.     pRmd->rbuf_mcnt = 0; 
  131.     pRmd->es_rmd1.es_rmd1b |= esrmd1_OWN;
  132.     }
  134. IMPORT unsigned char esEnetAddr []; /* ethernet address to load into lance */
  136. /* globals */
  138. int esLogCount = 0;
  140. int dbg_read = 0;
  141. int dbg_output = 0;
  142. int recIndex = 0;
  143. u_short newdlan;
  145. /* locals */
  147. LOCAL int esTsize = ES_TMD_TLEN; /* deflt xmit ring size as power of 2 */
  148. LOCAL int esRsize = ES_RMD_RLEN; /* deflt recv ring size as power of 2 */
  150. LOCAL struct ls_softc  *ls_softc [MAX_ES];
  152. /* forward declarations */
  154. LOCAL VOID esInt ();
  155. LOCAL VOID esHandleRecvInt ();
  157. LOCAL int esInit ();
  158. #ifdef BSD43_DRIVER
  159. LOCAL int esOutput ();
  160. #endif
  161. LOCAL int esIoctl ();
  162. LOCAL VOID esReset ();
  163. #ifdef BSD43_DRIVER
  164. LOCAL VOID esStartOutput ();
  165. #else
  166. LOCAL VOID esStartOutput (struct ls_softc *ls);
  167. #endif
  169. LOCAL es_tmd        *esGetFreeTMD ();
  170. LOCAL es_rmd        *esGetFullRMD ();
  172. LOCAL VOID esRmdFree ();
  174. LOCAL VOID esConfig ();
  175. LOCAL VOID esChipReset ();
  176. LOCAL VOID esChipInit ();
  177. LOCAL STATUS esRecv ();
  178. LOCAL u_short  esReadBmpr0 ();
  180. /*******************************************************************************
  181. *
  182. * esattach - attaches an EtherStar target
  183. *
  184. * Interface exists: make available by filling in network interface
  185. * record.  System will initialize the interface when it is ready
  186. * to accept packets.
  187. * The memory pool will be malloced if NONE is specified.  The memWidth
  188. * determines the data port width (in bytes) of the memory pool.
  189. *
  190. * BUGS:
  191. * Currently uses bzero to zero lance data structures, which ignores the
  192. * specification of memWidth and may use any size data access to write to memory.
  193. *
  194. */
  196. STATUS esattach
  197.     (
  198.     int       unit, /* unit number */
  199.     char     *devAdrs, /* ESTAR i/o address */
  200.     int       ivec, /* interrupt vector */
  201.     int       ilevel, /* interrupt level */
  202.     char     *memAdrs, /* address of memory pool (-1 == malloc it) */
  203.     ULONG     memSize, /* only used if memory pool is NOT malloced */
  204.     int       memWidth, /* byte-width of data (-1 == any width)     */
  205.     BOOL      usePadding, /* use padding when accessing RAP? */
  206.     int       bufSize /* size of a buffer in the ESTAR ring */
  207.     )
  208.     {
  209.     FAST struct ls_softc  *ls;
  210.     FAST struct ifnet   *ifp;
  211.     FAST unsigned int    sz; /* temporary size holder */
  212.     FAST ES_DEVICE   *dv;
  213.     char    *memPool; /* start of the ESTAR memory pool */
  215.     if (bufSize == 0)
  216.         bufSize = ES_BUFSIZE;
  218.     if ((int) memAdrs != NONE) /* specified memory pool */
  219. {
  220. /*
  221.  * With a specified memory pool we want to maximize
  222.  * esRsize and esTsize
  223.  */
  225. sz = (memSize - (sizeof (es_rmd) + sizeof (es_tmd) + sizeof (es_ib)))
  226.        / ((2 * bufSize) + sizeof (es_rmd) + sizeof (es_tmd));
  228. sz >>= 1; /* adjust for roundoff */
  230. for (esRsize = 0; sz != 0; esRsize++, sz >>= 1)
  231.     ;
  233. esTsize = esRsize; /* esTsize = esRsize for convenience */
  234. }
  236.     /* limit ring sizes to reasonable values */
  238.     if (esRsize < 2)
  239.         esRsize = 2; /* 4 buffers is reasonable min */
  241.     if (esRsize > 7)
  242.         esRsize = 7; /* 128 buffers is max for chip */
  244.     /* limit ring sizes to reasonable values */
  246.     if (esTsize < 2)
  247.         esTsize = 2; /* 4 buffers is reasonable min */
  249.     if (esTsize > 7)
  250.         esTsize = 7; /* 128 buffers is max for chip */
  253.     /* calculate the total size of ESTAR memory pool.  (basic softc structure
  254.      * is just allocated from free memory pool since ESTAR never references).
  255.      */
  256.     sz = ((sizeof (es_ib))        + (((1 << esRsize) + 1) * sizeof (es_rmd)) +
  257.   (bufSize << esRsize) + (((1 << esTsize) + 1) * sizeof (es_tmd)) +
  258.   (bufSize << esTsize));
  260.     if ((int) memAdrs == NONE) /* if -1 then allocate memPool from free pool */
  261. {
  262. memPool = (char *) malloc (sz); /* allocate memory */
  264. if ((int)memPool == NULL)
  265.     return (ERROR); /* bail out if we don't get memory */
  266. }
  267.     else
  268. {
  269. if (memSize < sz)
  270.     return (ERROR); /* bail out if memSize specified is too small */
  272. memPool = memAdrs; /* set the beginning of pool */
  273. }
  275.     /*                        memPool partitioning
  276.      *                        --------------------
  277.      *
  278.      *                                                 LOW MEMORY
  279.      *
  280.      *    memPool,ls->ib |-------------------------------------|
  281.      * |       |
  282.      * |         (sizeof (es_ib))       |
  283.      * |       |
  284.      *      ls->ls_rring  |-------------------------------------|
  285.      * |       |
  286.      *  | ((1 << esRsize) + 1)*sizeof (es_rmd)|
  287.      * |       |
  288.      *       ls->rmd_ring.r_bufs |-------------------------------------|
  289.      * |       |
  290.      *  |       (bufSize << esRsize)          |
  291.      * |       |
  292.      *     ls->ls_tring |-------------------------------------|
  293.      * |       |
  294.      * | ((1 << esTsize) + 1)*sizeof (es_tmd)|
  295.      * |       |
  296.      *       ls->tmd_ring.t_bufs |-------------------------------------|
  297.      * |       |
  298.      *  |       (bufSize << esTsize)          |
  299.      * |       |
  300.      *           |-------------------------------------|
  301.      *
  302.      *                                                HIGH MEMORY
  303.      */
  305.     /* allocate basic softc structure */
  307.     ls = (struct ls_softc *)malloc (sizeof (struct ls_softc));
  308.     if (ls == NULL)
  309. {
  310. if ((int) memAdrs == NONE) /* if we malloced memPool */
  311.     (void) free (memPool); /* free the memPool */
  312. return (ERROR);
  313. }
  315.     /* zero out entire softc structure */
  316.     bzero ((char *)ls, sizeof (struct ls_softc));
  318.     /* fill in high byte of memory base (A24:A31) and data port width */
  320.     ls->memBase  = (char *) ((ULONG)memPool & 0xff000000);
  321.     ls->memWidth = memWidth;
  323.     if ((int) memAdrs == NONE)
  324.         ls->ls_flags |= LS_MEM_ALLOC_FLAG;
  325.    
  326.     if (usePadding == TRUE) /* Is CSR padding necessary? */
  327. ls->ls_flags |= LS_PAD_USED_FLAG;
  328.     else
  329.         ls->ls_flags &= ~LS_PAD_USED_FLAG;
  331.     ls->bufSize = bufSize;
  333.     /* if memWidth is NONE (we can copy any byte size/boundaries) and
  334.      * bufSize is big enough to hold the biggest ethernet frame
  335.      * we can loan out rmds.  On systems that cannot afford to have
  336.      * big enough RMD's, ESTAR will use data-chaining on receive
  337.      * buffers.  Our current implementation of RMD loans does not work
  338.      * with receive side data-chains.
  339.      */
  341.     if (ls->memWidth == NONE && ls->bufSize == ES_BUFSIZE)
  342. {
  343. int ix;
  344. char *pBuf;
  346.         ls->canLoanRmds = TRUE;
  347. ls->nFree = ES_NUM_RESERVES;
  349. if ((pBuf = (char *) malloc ((u_int) (ES_NUM_RESERVES * bufSize))) == NULL)
  350.     {
  351.     (void) free (memPool);
  352.     (void) free ((char *) ls);
  353.     return (ERROR);
  354.     }
  356. for (ix = 0; ix < ES_NUM_RESERVES; ix++)
  357.     ls->freeBufs [ix] = (char *) ((int) pBuf + (bufSize * ix));
  358. }
  359.     else
  360.         ls->canLoanRmds = FALSE;
  362.     /* allocate initialization block */
  364.     ls->ib = (es_ib *)memPool;
  365.     sz = sizeof (es_ib); /* size of initialization block */
  366.     bzero ((char *)ls->ib, (int) sz); /* zero out entire ib */
  368.     /* allocate receive message descriptor (RMD) ring structure */
  370.     ls->ls_rpo2 = esRsize; /* remember for esConfig */
  371.     ls->ls_rsize = (1 << esRsize); /* receive msg descriptor ring size */
  373.     /* leave room to adjust low three bits */
  375.     ls->ls_rring = (es_rmd *) ((int)ls->ib + sz);   /* of pointer to be 000 */
  376.     sz = ((1 << esRsize) + 1) * sizeof (es_rmd);
  377.     bzero ((char *)ls->ls_rring, (int)sz); /* zero out entire RMD ring */
  379.     /* allocate receive buffer space */
  381.     ls->rmd_ring.r_bufs = (char *)((int)ls->ls_rring + sz);
  382.     sz = (bufSize << esRsize);  /* room for all the receive buffers */
  383.     bzero (ls->rmd_ring.r_bufs, (int)sz);/* zero out entire rbuf area */
  385.     /* allocate transmit message descriptor (TMD) ring structure */
  387.     ls->ls_tpo2 = esTsize; /* remember for esConfig */
  388.     ls->ls_tsize = (1 << esTsize); /* transmit msg descriptor ring size */
  390.     ls->ls_tring = (es_tmd *) ((int)ls->rmd_ring.r_bufs + sz);
  391.     sz = ((1 << esTsize) + 1) * sizeof (es_tmd);
  392.     bzero ((char *)ls->ls_tring, (int)sz); /* zero out entire TMD ring */
  394.     /* allocate transmit buffer space */
  396.     ls->tmd_ring.t_bufs = (char *)((int)ls->ls_tring + sz);
  397.     sz = (bufSize << esTsize); /* room for all the transmit buffers */
  399.     bzero (ls->tmd_ring.t_bufs, (int)sz); /* zero out entire tbuf area */
  401.     ls_softc [unit] = ls; /* remember address for this unit */
  403.     /* initialize device structure */
  405.     ls->ivec     = ivec; /* interrupt vector */
  406.     ls->ilevel = ilevel; /* interrupt level */
  407.     ls->devAdrs = (ES_DEVICE *)devAdrs; /* ESTAR i/o address */
  409.     /* copy the enet address into the softc */
  411.     dv = ls->devAdrs;
  412.     esEnetAddr[0] = dv->ROM_IDf;
  413.     esEnetAddr[1] = dv->ROM_IDe;
  414.     esEnetAddr[2] = dv->ROM_IDd;
  415.     esEnetAddr[3] = dv->ROM_IDc;
  416.     esEnetAddr[4] = dv->ROM_IDb;
  417.     esEnetAddr[5] = dv->ROM_IDa;
  418.     if (esEnetAddr[3]) {
  419. newdlan = TRUE;
  420. dlan.dlcr0 = &(dv->dlcr0);
  421. dlan.dlcr1 = &(dv->dlcr1);
  422. dlan.dlcr2 = &(dv->dlcr2);
  423. dlan.dlcr3 = &(dv->dlcr3);
  424.   dlan.dlcr4 = &(dv->dlcr4);
  425. dlan.dlcr5 = &(dv->dlcr5);
  426. dlan.dlcr6 = &(dv->dlcr6);
  427. dlan.dlcr7 = &(dv->dlcr7);
  428. dlan.dlcr8 = &(dv->dlcr8);
  429. dlan.dlcr9 = &(dv->dlcr9);
  430. dlan.dlcr10 = &(dv->dlcr10);
  431. dlan.dlcr11 = &(dv->dlcr11);
  432. dlan.dlcr12 = &(dv->dlcr12);
  433. dlan.dlcr13 = &(dv->dlcr13);
  434. dlan.dlcr14 = &(dv->dlcr14);
  435. dlan.dlcr15 = &(dv->dlcr15);
  436.     }
  437.     else {
  438. newdlan = FALSE;
  439. dlan.dlcr0 = &(dv->dlcr1);
  440. dlan.dlcr1 = &(dv->dlcr0);
  441. dlan.dlcr2 = &(dv->dlcr3);
  442. dlan.dlcr3 = &(dv->dlcr2);
  443.   dlan.dlcr4 = &(dv->dlcr5);
  444. dlan.dlcr5 = &(dv->dlcr4);
  445. dlan.dlcr6 = &(dv->dlcr7);
  446. dlan.dlcr7 = &(dv->dlcr6);
  447. dlan.dlcr8 = &(dv->dlcr9);
  448. dlan.dlcr9 = &(dv->dlcr8);
  449. dlan.dlcr10 = &(dv->dlcr11);
  450. dlan.dlcr11 = &(dv->dlcr10);
  451. dlan.dlcr12 = &(dv->dlcr13);
  452. dlan.dlcr13 = &(dv->dlcr12);
  453. dlan.dlcr14 = &(dv->dlcr15);
  454. dlan.dlcr15 = &(dv->dlcr14);
  455.     }
  457.     bcopy ((char *) esEnetAddr, (char *)ls->ls_enaddr, sizeof (ls->ls_enaddr));
  459.     ifp = &ls->ls_if;
  461.     /* attach and enable the ESTAR interrupt service routine to vector */
  463.     esChipReset (ls); /* reset ESTAR */
  465.     (void) intConnect (INUM_TO_IVEC (ivec), esInt, (int)ls);
  467. #ifdef BSD43_DRIVER
  468.     ether_attach (ifp, unit, "es", (FUNCPTR) esInit, (FUNCPTR) esIoctl,
  469.  (FUNCPTR) esOutput, (FUNCPTR) esReset);
  470. #else
  471.     ether_attach (
  472.                  &ls->ls_ac.ac_if, 
  473.                  unit, 
  474.                  "es", 
  475.                  (FUNCPTR) esInit, 
  476.                  (FUNCPTR) esIoctl,
  477.  (FUNCPTR) ether_output,
  478.                  (FUNCPTR) esReset
  479.                  );
  480.     ifp->if_start = (FUNCPTR)esStartOutput;
  481. #endif
  483.     sysIntEnable (ilevel);
  485.     esInit (unit);
  487.     return (OK);
  488.     }
  490. /*******************************************************************************
  491. *
  492. * esReset - reset the interface
  493. *
  494. * Mark interface as inactive & reset the chip
  495. */
  497. LOCAL VOID esReset
  498.     (
  499.     int unit
  500.     )
  501.     {
  502.     FAST struct ls_softc  *ls = ls_softc [unit];
  503.     ls->ls_if.if_flags &= ~IFF_RUNNING;
  504.     esChipReset (ls); /* reset ESTAR */
  505.     }
  506. /*******************************************************************************
  507. *
  508. * esInit - initializes EtherStar connection
  509. *
  510. * Initialization of interface; clear recorded pending operations.
  511. * Called at boot time (with interrupts disabled?),
  512. * and at ifconfig time via esIoctl, with interrupts disabled.
  513. */
  515. LOCAL int esInit
  516.     (
  517.     int unit
  518.     )
  519.     {
  520.     FAST struct ls_softc  *ls = ls_softc [unit];
  521.     FAST struct ifnet   *ifp = &ls->ls_if;
  523.     ifp->if_flags &= ~(IFF_UP | IFF_RUNNING | IFF_PROMISC);
  525.     esChipReset (ls); /* disable chip during init */
  526.     esConfig (ls); /* reset all ring structures */
  528.     ifp->if_flags |= (IFF_UP | IFF_RUNNING);
  530.     if (ls->ls_flags & LS_PROMISCUOUS_FLAG)
  531. ifp->if_flags |= (IFF_PROMISC);
  533.     esChipInit (ls); /* on return ESTAR is running */
  535. #ifdef BSD43_DRIVER
  536.     esStartOutput (ls->ls_if.if_unit); /* tell chip about any pending output */
  537. #else
  538.     esStartOutput (ls);
  539. #endif
  541.     return (0);
  542.     }
  543. /*******************************************************************************
  544. *
  545. * esConfig - fill in initialization block with mode information.
  546. *
  547. * Fill in all fields in the Initialization Block with relevant values.
  548. * In addition, fill in all fields in Transmit Message Descriptor ring
  549. * and Receive Message Descriptor ring.
  550. */
  552. LOCAL VOID esConfig
  553.     (
  554.     FAST struct ls_softc  *ls
  555.     )
  556.     {
  557.     FAST es_rmd   *rmd;
  558.     FAST es_tmd   *tmd;
  559.     FAST char   *buf;
  560.     FAST es_ib   *ib;
  561.     int    i;
  563.     rmd = ls->ls_rring; /* receive message descriptor ring */
  564.     rmd = (es_rmd *)(((int)rmd + 7) & ~7); /* low 3 bits must be 000 */
  565.     ls->ls_rring = rmd; /* fix softc as well */
  566.     buf = ls->rmd_ring.r_bufs;
  567.     for (i = 0; i < ls->ls_rsize; i++)
  568.         {
  569. rmd->rbuf_ladr = (u_short)((int)buf); /* bits 15:00 of buffer address */
  570. rmd->rbuf_rmd1 = (u_short)((int)buf >> 16) & 0xff;
  571. /* bits 23:16 of buffer address */
  573. rmd->rbuf_bcnt = -(ls->bufSize);/* neg of buffer byte count */
  574. rmd->rbuf_mcnt = 0; /* no message byte count yet */
  575. rmd->es_rmd1.es_rmd1b |= esrmd1_OWN; /* buffer now owned by ESTAR */
  576. rmd++; /* step to next message descriptor */
  577. buf += (ls->bufSize); /* step to start of next buffer */
  579. ls->loanRefCnt [i] = (u_char) 0;
  580. }
  582.     ls->ls_rindex = 0; /* ESTAR will use at start of ring */
  584.     tmd = ls->ls_tring; /* transmit message descriptor ring */
  585.     tmd = (es_tmd *)(((int)tmd + 7) & ~7); /* low 3 bits must be 000 */
  586.     ls->ls_tring = tmd; /* fix softc as well */
  587.     buf = ls->tmd_ring.t_bufs;
  589.     for (i = 0; i < ls->ls_tsize; i++)
  590.         {
  591. tmd->tbuf_ladr = (u_short)((int)buf); /* bits 15:00 of buffer address */
  592. tmd->tbuf_tmd1 = (u_short)((int)buf >> 16) & 0xff;
  593. /* bits 23:16 of buffer address */
  594. tmd->tbuf_bcnt = 0; /* no message byte count yet */
  595. tmd->tbuf_tmd3 = 0; /* no error status yet */
  596. tmd->es_tmd1.es_tmd1b |= estmd1_ENP; /* buffer is end of packet */
  597. tmd->es_tmd1.es_tmd1b |= estmd1_STP; /* buffer is start of packet */
  598. tmd++; /* step to next message descriptor */
  599. buf += (ls->bufSize); /* step to start of next buffer */
  600. }
  602.     ls->ls_tindex = 0; /* ESTAR */
  603.     ls->ls_dindex = 0; /* buffer disposal will lag tindex */
  605.     ib = ls->ib;
  606.     if (ls->ls_flags & LS_PROMISCUOUS_FLAG)
  607.         ib->esIBMode = 0x8000; /* chip will be in promiscuous receive mode */
  608.     else
  609.         ib->esIBMode = 0; /* chip will be in normal receive mode */
  611.     swab ((char *)ls->ls_enaddr, ib->esIBPadr, 6);
  613.     ib->esIBRdraLow = (u_short)((int)ls->ls_rring);
  614.     ib->esIBRdraHigh = (u_short)(((int)ls->ls_rring >> 16) & 0xff)
  615.         | (ls->ls_rpo2 << 13);
  617.     ib->esIBTdraLow = (u_short)((int)ls->ls_tring);
  618.     ib->esIBTdraHigh = (u_short)(((int)ls->ls_tring >> 16) & 0xff)
  619.         | (ls->ls_tpo2 << 13);
  620.     }
  621. /*******************************************************************************
  622. *
  623. * esInt - handle controller interrupt
  624. *
  625. * This routine is called at interrupt level in response to an interrupt from
  626. * the controller.
  627. */
  629. LOCAL VOID esInt
  630.     (
  631.     FAST struct ls_softc  *ls
  632.     )
  633.     {
  634.     FAST ES_DEVICE *dv;
  635.     FAST es_rmd *rmd;
  636.     FAST es_tmd *tmd;
  637.     FAST int  *pDindex;
  638.     FAST int *pTindex;
  639.     FAST int *pTsize;
  640.     FAST es_tmd *pTring;
  641.     FAST u_short w, temp;
  642.     FAST int i;
  643.     FAST char *buf;
  645.     
  646.     dv = ls->devAdrs;
  647.     *dlan.dlcr1 = 0x00; /* clear transmit masks */
  648.     *dlan.dlcr3 = 0x00; /* clear receive masks */
  650.     /* read any receive packets */
  652.     while (!(*dlan.dlcr5 & 0x40))
  653.     {
  654. *dlan.dlcr2 = 0x80; /* clear pkt_rdy */
  655. rmd = ls->ls_rring + recIndex;
  656. recIndex = (recIndex + 1) & (ls->ls_rsize - 1);
  657. rmd->es_rmd1.es_rmd1b &= ~esrmd1_OWN;  /* rbuf_own = 0; */
  659. buf = (char *) ((u_int) ls->rmd_ring.r_bufs +
  660.       (u_int) ((((u_int)rmd - (u_int)ls->ls_rring) / sizeof(es_rmd))
  661.       * ls->bufSize));
  663. temp = esReadBmpr0 (dv); /* read status */
  665. if (newdlan == TRUE) {
  666. temp = esReadBmpr0 (dv); /* and count */
  667. i = (temp>>8 | temp<<8) & 0xffff;
  668. rmd->rbuf_mcnt = i; /* save count */
  669. rmd->es_rmd1.es_rmd1b |= esrmd1_STP;  /* rbuf_stp = 1; */
  670. rmd->es_rmd1.es_rmd1b |= esrmd1_ENP;  /* rbuf_enp = 1; */
  671. while (i > 0)
  672. {
  673.     w = esReadBmpr0 (dv);
  674.     *(u_short *)buf = w;
  675.     buf +=2;
  676.     i -= 2; /* count down */
  677. }
  678. }
  679. else {
  680. i = esReadBmpr0 (dv); /* and count */
  681. rmd->rbuf_mcnt = i; /* save count */
  682. rmd->es_rmd1.es_rmd1b |= esrmd1_STP;  /* rbuf_stp = 1; */
  683. rmd->es_rmd1.es_rmd1b |= esrmd1_ENP;  /* rbuf_enp = 1; */
  684. while (i > 0)
  685. {
  686.     w = esReadBmpr0 (dv);
  687.     *(u_short *)buf = (w>>8 | w<<8);
  688.     buf +=2;
  689.     i -= 2; /* count down */
  690. }
  691. }
  692.     }
  693.     if (*dlan.dlcr2 & es_bus_rd_err)
  694. *dlan.dlcr2 = es_bus_rd_err;
  696.     if ((rmd = esGetFullRMD (ls)) != NULL)
  697. {
  698. if ((ls->ls_flags & LS_RCV_HANDLING_FLAG) == 0)
  699.     {
  700.     ls->ls_flags |= LS_RCV_HANDLING_FLAG;
  701.     (void) netJobAdd ((FUNCPTR) esHandleRecvInt, (int) ls, 0, 0, 0, 0);
  702.     }
  703. }
  705.     /* Did etherstar update any of the TMD's? */
  707.     if (!(*dlan.dlcr0 & ES_TMT_MASK))
  708. {
  709. *dlan.dlcr3 = ES_RCV_MASK;
  710. return;
  711. }
  713.     *dlan.dlcr1 = 0x00; /* clear transmit mask */
  714.     *dlan.dlcr0 = 0x0f; /* reset error conditions */
  715.     *dlan.dlcr2 = 0x4f; /* reset packet ready */
  717.     pDindex = &ls->ls_dindex;
  718.     pTindex = &ls->ls_tindex;
  719.     pTsize  = &ls->ls_tsize;
  720.     pTring  = ls->ls_tring;
  722.     while (*pDindex != *pTindex)
  723.         {
  724. /* disposal has not caught up */
  726. tmd = pTring + *pDindex;
  728. /* if the buffer is still owned by ESTAR, don't touch it */
  730. if (tmd->tbuf_tmd1 & TMD_OWN)
  731.     {
  732.     break;
  733.     }
  735. /*
  736.  * tbuf_err (TMD1.ERR) is an "OR" of LCOL, LCAR, UFLO or RTRY.
  737.  * Note that BUFF is not indicated in TMD1.ERR.
  738.  * We should therefore check both tbuf_err and tbuf_buff
  739.  * here for error conditions.
  740.  */
  742. if ((tmd->tbuf_tmd1 & TMD_ERR) || (tmd->tbuf_tmd3 & TMD_BUFF))
  743.     {
  744.     ls->ls_if.if_oerrors++; /* output error */
  745.     ls->ls_if.if_opackets--;
  747.     /* check for no carrier */
  749.     if (tmd->tbuf_tmd3 & TMD_LCAR)
  750. logMsg ("es%d: no carriern", ls->ls_if.if_unit, 0, 0, 0, 0, 0);
  752.     /* every esLogCount errors show other interesting bits of tmd3 */
  754.     if ((tmd->tbuf_tmd3 & 0xfc00) && esLogCount &&
  755. (ls->ls_if.if_oerrors % esLogCount) == 0)
  756. logMsg ("es%d: xmit error, status(tmd3)=0x%x, err count=%dn",
  757. ls->ls_if.if_unit, tmd->tbuf_tmd3 & 0xfc00,
  758. ls->ls_if.if_oerrors, 0, 0, 0);
  760.     /* restart chip on fatal errors */
  762.     if ((tmd->tbuf_tmd3 & TMD_BUFF) || (tmd->tbuf_tmd3 & TMD_UFLO))
  763. {
  764. (void) netJobAdd ((FUNCPTR) esInit,
  765.   ls->ls_if.if_unit, 0, 0, 0, 0);
  766. break;
  767. }
  768.     }
  770. tmd->tbuf_tmd1 &= 0xff; /* clear high byte */
  771. tmd->tbuf_tmd3 = 0; /* clear all error & stat stuff */
  773. /* now bump the tmd disposal index pointer around the ring */
  775. *pDindex = (*pDindex + 1) & (*pTsize - 1);
  776. }
  778.     if (ls->ls_if.if_snd.ifq_head != NULL &&
  779. (ls->ls_flags & LS_START_OUTPUT_FLAG) == 0)
  780. {
  781. ls->ls_flags |= LS_START_OUTPUT_FLAG;
  782. #ifdef BSD43_DRIVER
  783.         (void) netJobAdd ( (FUNCPTR) esStartOutput,
  784.                            ls->ls_if.if_unit, 0, 0, 0, 0);
  785. #else
  786.         (void) netJobAdd ( (FUNCPTR) esStartOutput, (int)ls, 0, 0, 0, 0);
  787. #endif
  788. }
  789.     *dlan.dlcr3 = ES_RCV_MASK;
  790.     }
  791. /*******************************************************************************
  792. *
  793. * esReadBmpr0 - prevents optimizer from stripping required accesses to device
  794. *
  795. * prevents optimizer from stripping required accesses to the device
  796. */
  797. LOCAL u_short esReadBmpr0
  798.     (
  799.     FAST ES_DEVICE *dv
  800.     )
  801.     {
  802.     return ( dv->bmpr0);
  803.     }
  805. /*******************************************************************************
  806. *
  807. * esHandleRecvInt - task level interrupt service for input packets
  808. *
  809. * This routine is called at task level indirectly by the interrupt
  810. * service routine to do any message received processing.
  811. */
  813. LOCAL VOID esHandleRecvInt
  814.     (
  815.     FAST struct ls_softc *ls
  816.     )
  817.     {
  818.     FAST es_rmd *rmd;
  819.     FAST int  oldIndex;
  821.     do
  822. {
  823. ls->ls_flags |= LS_RCV_HANDLING_FLAG;
  825. while ((rmd = esGetFullRMD (ls)) != NULL)
  826.     {
  827.     /* RMD available */
  829.     oldIndex = ls->ls_rindex;
  830.     if (esRecv (ls, rmd) == OK)
  831. for (; oldIndex != ls->ls_rindex; 
  832.      oldIndex = (oldIndex + 1) & (ls->ls_rsize - 1))
  833.     {
  834.     rmd = ls->ls_rring + oldIndex;
  835.     ES_RMD_GIVE_TO_ESTAR (rmd);
  836.     }
  837.     else
  838.         break;
  839.     }
  841. /*
  842.  * There is a RACE right here.  The ISR could add a receive packet
  843.  * and check the boolean below, and decide to exit.  Thus the
  844.  * packet could be dropped if we don't double check before we
  845.  * return.
  846.  */
  848. ls->ls_flags &= ~LS_RCV_HANDLING_FLAG;
  849. }
  850.   while (esGetFullRMD (ls) != NULL); /* this double check solves the RACE */
  851. {
  852. }
  853.     *dlan.dlcr3 = ES_RCV_MASK;
  854.     }
  856. /*******************************************************************************
  857. *
  858. * esRecv - process Ethernet receive completion
  859. *
  860. * Process Ethernet receive completion:
  861. * If input error just drop packet.
  862. * Otherwise purge input buffered data path and examine 
  863. * packet to determine type.  If can't determine length
  864. * from type, then have to drop packet.  Otherwise decapsulate
  865. * packet based on type and pass to type-specific higher-level
  866. * input routine.
  867. *
  868. * RETURNS: ERROR if RMD shouldn't be returned back to ESTAR yet.
  869. *          Otherwise, returns OK to return the RMD back to ESTAR.
  870. */
  872. LOCAL STATUS esRecv
  873.     (
  874.     struct ls_softc    *ls,
  875.     FAST es_rmd    *rmd
  876.     )
  877.     {
  878.     FAST struct ether_header *eh;
  879.     FAST struct mbuf *m;
  880.     FAST u_char *pData;
  881.     int len;
  882.     int off;
  883. #ifdef BSD43_DRIVER
  884.     u_short ether_type;
  885. #endif
  887.     /*
  888.      * If both STP and ENP are set, ESTAR didn't try to
  889.      * use data chaining.
  890.      */
  892.     if (((rmd->es_rmd1.es_rmd1b & esrmd1_STP) == esrmd1_STP) &&
  893. ((rmd->es_rmd1.es_rmd1b & esrmd1_ENP) == esrmd1_ENP))
  894. {
  895. len = rmd->rbuf_mcnt;
  896. ls->ls_rindex = (ls->ls_rindex + 1) & (ls->ls_rsize - 1);
  897. }
  900.     else
  901. {
  902. ls->ls_rindex = (ls->ls_rindex + 1) & (ls->ls_rsize - 1);
  904. ++ls->ls_if.if_ierrors;
  906. if (esLogCount && (ls->ls_if.if_ierrors % esLogCount) == 0)
  907.     logMsg ("es%d: receive error, stp %d enp %dn",
  908.     ls->ls_if.if_unit,
  909.     (rmd->es_rmd1.es_rmd1b & esrmd1_STP) >> 9,
  910.     (rmd->es_rmd1.es_rmd1b & esrmd1_ENP) >> 8, 0, 0, 0);
  912. return (OK); /* intentional */
  913. }
  915.     /*
  916.     eh = (struct ether_header *)(rmd->rbuf_ladr | (rmd->rbuf_hadr << 16));
  917.     ItoK (eh, struct ether_header *, ls->memBase);
  918.     */
  920.     ++ls->ls_if.if_ipackets;    /* bump statistic */
  922.     eh =(struct ether_header *) ((u_int) ls->rmd_ring.r_bufs +
  923. (u_int) ((((u_int)rmd - (u_int)ls->ls_rring) / sizeof(es_rmd))
  924. * ls->bufSize));
  926.     /* call input hook if any */
  928.     if ((etherInputHookRtn != NULL) &&
  929. (* etherInputHookRtn) (&ls->ls_if, (char *)eh, len))
  930. return (OK);
  932. #ifdef BSD43_DRIVER
  934.     /* This legacy code is not correct for the BSD 4.4 stack. It would
  935.      * also treat multicast addresses like alien packets, and not send
  936.      * them up the stack. The higher-level protocols in the new stack
  937.      * can handle these addresses, and will discard them if they do not
  938.      * match an existing multicast group.
  939.      */
  941.     /* do software filter if controller is in promiscuous mode */
  943.     if (ls->ls_flags & LS_PROMISCUOUS_FLAG)
  944. if ( (bcmp ( (char *)eh->ether_dhost, /* not our adrs? */
  945.      (char *)ls->ls_enaddr,
  946.     sizeof (eh->ether_dhost)) != 0) &&
  947.      (bcmp ( (char *)eh->ether_dhost, /* not broadcast? */
  948.                      (char *)etherbroadcastaddr,
  949.     sizeof (eh->ether_dhost)) != 0))
  950.             return (OK);
  951. #endif
  953.     if (len >= sizeof (struct ether_header))
  954.         len -= sizeof (struct ether_header);
  955.     else
  956.         len = 0;
  958.     pData = ((u_char *) eh) + (sizeof (struct ether_header));
  960. #ifdef BSD43_DRIVER
  961.     check_trailer (eh, pData, &len, &off, &ls->ls_if);
  963.     if (len == 0)
  964. return (OK);
  966.     ether_type = eh->ether_type;
  967. #endif
  969.     m = NULL;
  971.     /* we can loan out receive buffers from ESTAR receive ring if:
  972.      *
  973.      * 1) canLoanRmd is TRUE.  canLoanRmd is set to TRUE if memWidth
  974.      *    is NONE (no special restriction in copying data in terms of
  975.      *    size and boundary conditions) and each of the buffers in the
  976.      *    ESTAR ring is big enough to hold the maximum sized ethernet
  977.      *    frame (data-chaining is not being used for the input).
  978.      * 2) trailer protocol is not being used for the given input ethernet frame.
  979.      * 3) there is available free buffers that can be used to replace the
  980.      *    rbuf to be loaned out in the free list 'freeBufs'.
  981.      * 4) size of the input ethernet frame is large enough to be used with
  982.      *    clustering.
  983.      */
  984.     
  985.     if (ls->canLoanRmds && off == 0 && ls->nFree > 0 && USE_CLUSTER (len))
  986. {
  987.         m = build_cluster (pData, len, &ls->ls_if, MC_LANCE,
  988.    &(ls->loanRefCnt [ls->ls_rindex]),
  989.    (FUNCPTR)esRmdFree, (int) ls, (int) eh, NULL);
  991. if (m != NULL)
  992.     {
  993.     FAST char *pBuf;
  994.     
  995.     /* get a free buffer from the free list to replace the
  996.      * rbuf loaned out.  replace the rbuf pointers in the RMD
  997.      * to point to the new buffer.
  998.      */
  999.     
  1000.     pBuf = ls->freeBufs [--ls->nFree];
  1001.     
  1002.     rmd->rbuf_ladr = (u_short) ((int) pBuf & 0xff);
  1003.     rmd->es_rmd1.es_rmd1b = (rmd->es_rmd1.es_rmd1b & ~esrmd1_HADR)
  1004.     | (((int) pBuf >> 16) & esrmd1_HADR);
  1005.     }
  1006. }
  1008.     if (m == NULL)
  1009. #ifdef BSD43_DRIVER
  1010. /* Instead of calling copy_to_mbufs (), we call bcopy_to_mbufs ()
  1011.  * with ls->memWidth as an addtional argument to specify unit of a
  1012.  * copy op.
  1013.  *
  1014.  * Most drivers would use macro copy_to_mbufs (), which will in turn
  1015.  * call bcopy_to_mbufs () telling it to use the normal bcopy ().  Some
  1016.  * of the on-board ESTAR hardware implementations require that you
  1017.  * copy the data by certain number of bytes from dedicated memory
  1018.  * to system memory, so ESTAR driver has a es_bcopy () routine that
  1019.  * conforms to this requirement.
  1020.  */
  1022. m = bcopy_to_mbufs (pData, len, off, (struct ifnet *) &ls->ls_if,
  1023.     ls->memWidth);
  1024. #else
  1025.         m = bcopy_to_mbufs (pData, len, 0, &ls->ls_if, ls->memWidth);
  1026. #endif
  1028.     if (m == NULL)
  1029.         ++ls->ls_if.if_ierrors;    /* bump error counter */
  1030.     else
  1031. #ifdef BSD43_DRIVER
  1032.         do_protocol_with_type (ether_type, m, &ls->ls_ac, len);
  1033. #else
  1034.         do_protocol (eh, m, &ls->ls_ac, len);
  1035. #endif
  1037.     return (OK);
  1038.     }
  1040. #ifdef BSD43_DRIVER
  1041. /*******************************************************************************
  1042. *
  1043. * esOutput - Ethernet output routine
  1044. *
  1045. * Ethernet output routine.
  1046. * Encapsulate a packet of type family for the local net.
  1047. * Use trailer local net encapsulation if enough data in first
  1048. * packet leaves a multiple of 512 bytes of data in remainder.
  1049. */
  1051. LOCAL int esOutput
  1052.     (
  1053.     FAST struct ifnet *ifp,
  1054.     FAST struct mbuf *m0,
  1055.     struct sockaddr *dst
  1056.     )
  1057.     {
  1058.     return (ether_output (ifp, m0, dst, (FUNCPTR) esStartOutput, 
  1059.   &ls_softc [ifp->if_unit]->ls_ac));
  1060.     }
  1061. #endif
  1063. /*******************************************************************************
  1064. *
  1065. * esStartOutput - start pending output
  1066. *
  1067. * Start output to ESTAR.
  1068. * Queue up all pending datagrams for which transmit buffers are available.
  1069. * Kick start the transmitter to avoid the polling interval latency.
  1070. * This routine is called by esInit (). With BSD 4.3 drivers, it is also called
  1071. * by esOutput (). BSD 4.4 drivers use a slightly different model in which it
  1072. * is called directly from the generic ether_output() routine.
  1073. * It is very important that this routine be executed with splimp set.
  1074. * If this is not done, another task could allocate the same tmd!
  1075. */
  1077. #ifdef BSD43_DRIVER
  1078. LOCAL VOID esStartOutput
  1079.     (
  1080.     int unit
  1081.     )
  1082.     {
  1083.     FAST struct ls_softc *ls = ls_softc [unit];
  1084. #else
  1085. LOCAL VOID esStartOutput
  1086.     (
  1087.     struct ls_softc *  ls
  1088.     )
  1089.     {
  1090. #endif
  1092.     FAST struct mbuf *m;
  1093.     FAST es_tmd *tmd;
  1094.     char *buf, *buf0;
  1095.     u_short *temp, temp1;
  1096.     FAST int len, i;
  1097.     FAST int sx;
  1098.     FAST int oldLevel;
  1099.     ES_DEVICE *dv;
  1101.     sx = splimp ();
  1103.     dv = ls->devAdrs;
  1105.     ls->ls_flags |= LS_START_OUTPUT_FLAG;
  1107.     /* Loop placing message buffers in output ring until no more or no room */
  1109.     while (ls->ls_if.if_snd.ifq_head != NULL)
  1110.         {
  1111. /* there is something to send */
  1113. if ((tmd = esGetFreeTMD (ls)) == NULL) /* get a transmit buffer */
  1114.     break;
  1116. IF_DEQUEUE (&ls->ls_if.if_snd, m); /* get head of next mbuf chain */
  1118. buf = (char *) ( (u_int) ls->tmd_ring.t_bufs +
  1119.                          (u_int) ( ( ( (u_int)tmd - (u_int)ls->ls_tring) / 
  1120.                                     sizeof (es_tmd)) * 
  1121.                          ls->bufSize));
  1122. buf0 = buf;
  1124. /* copy packet to write buffer */
  1126. temp = (u_short *)buf;
  1128. #ifdef BSD43_DRIVER
  1129. bcopy_from_mbufs (buf, m, len, ls->memWidth);
  1130. #else
  1131.         bcopy_from_mbufs (buf, m, len, ls->memWidth);
  1132. #endif
  1134. len = max (ETHERSMALL, len);
  1135. buf += len;
  1137. /* call output hook if any */
  1138.     
  1139. if ((etherOutputHookRtn != NULL) &&
  1140.     (* etherOutputHookRtn) (&ls->ls_if, buf, len))
  1141.     continue;
  1143. /* place a transmit request */
  1144.     
  1145. oldLevel = intLock (); /* disable ints during update */
  1147. tmd->tbuf_tmd3 = 0; /* clear buffer error status */
  1148. tmd->tbuf_bcnt = -len; /* negative message byte count */
  1149. tmd->es_tmd1.es_tmd1b |= estmd1_ENP; /* buffer is end of packet */
  1150. tmd->es_tmd1.es_tmd1b |= estmd1_STP; /* buffer is start of packet */
  1151. tmd->es_tmd1.es_tmd1b &= ~estmd1_DEF; /* clear status bit */
  1152. tmd->es_tmd1.es_tmd1b &= ~estmd1_MORE;
  1153. tmd->es_tmd1.es_tmd1b &= ~estmd1_ERR;
  1155. /* try to output here */
  1156. *dlan.dlcr1 = 0; /* disable ints during update */
  1157. i=0; /* extract the buffer */
  1159. if (newdlan == TRUE) 
  1160.             {
  1161.             while (i*2 < len)
  1162.                 {
  1163.                 if (i*2 < (buf - buf0))
  1164.                     dv->bmpr0 = *temp++;
  1165.                 else 
  1166.                     dv->bmpr0 = 0;
  1167.                 i += 1;
  1168. }
  1169.             temp1 = (u_short)((len>>8) | (len<<8) | 0x80); /* set TMST */
  1170.             dv->bmpr2 = temp1;
  1171.             }
  1172.         else 
  1173.             {
  1174.             while (i*2 < len)
  1175.                 {
  1176.                 if (i*2 < (buf - buf0))
  1177.                     {
  1178.                     dv->bmpr0 = (*temp>>8 | *temp<<8);
  1179.                     temp++;
  1180.                     }
  1181.                 else 
  1182.                     dv->bmpr0 = 0;
  1183.                 i += 1;
  1184.                 }
  1185.             dv->bmpr2 = (u_short)(len | 0x8000); /* set TMST */
  1186.             }
  1188. while ( (*dlan.dlcr0 & es_tmt_ok) == es_tmt_ok)
  1189.             ;
  1191. intUnlock (oldLevel); /* now esInt won't get confused */
  1193. ls->ls_tindex = (ls->ls_tindex + 1) & (ls->ls_tsize - 1);
  1195. #ifndef BSD43_DRIVER    /* BSD 4.4 ether_output() doesn't bump statistic. */
  1196.         ls->ls_if.if_opackets++;
  1197. #endif
  1198.         }
  1200.     ls->ls_flags &= ~LS_START_OUTPUT_FLAG;
  1202.     *dlan.dlcr1 = ES_TMT_MASK; /* set transmit interrupt mask */
  1204.     splx (sx);
  1205.     }
  1207. /*******************************************************************************
  1208. *
  1209. * esIoctl - Process an ioctl request
  1210. *
  1211. * Process an ioctl request.
  1212. */
  1214. LOCAL int esIoctl
  1215.     (
  1216.     FAST struct ifnet *ifp,
  1217.     int  cmd,
  1218.     caddr_t  data
  1219.     )
  1220.     {
  1221.     int    unit = ifp->if_unit;
  1222.     FAST struct ls_softc  *ls = ls_softc [unit];
  1223.     int    s = splimp ();
  1224.     int    error = 0;
  1226.     switch (cmd)
  1227. {
  1228. case SIOCSIFADDR:
  1229.             ((struct arpcom *)ifp)->ac_ipaddr = IA_SIN (data)->sin_addr;
  1230.             arpwhohas (ifp, &IA_SIN (data)->sin_addr);
  1231.     break;
  1233. case SIOCGIFADDR:
  1234.     bcopy((caddr_t) ls->ls_enaddr,
  1235.   (caddr_t) ((struct ifreq *)data)->ifr_addr.sa_data, 6);
  1236.     break;
  1238. case SIOCGIFFLAGS:
  1239.     *(short *)data = ifp->if_flags;
  1240.     break;
  1242. case SIOCSIFFLAGS:
  1243.     ls->ls_if.if_flags = ifp->if_flags;
  1245.     if (ifp->if_flags & IFF_PROMISC)
  1246.         ls->ls_flags |= LS_PROMISCUOUS_FLAG;
  1247.     else
  1248.         ls->ls_flags &= ~LS_PROMISCUOUS_FLAG;
  1250.     if (ifp->if_flags & IFF_UP)
  1251. ls->ls_if.if_flags |= (IFF_UP|IFF_RUNNING);
  1252.     else
  1253.         ls->ls_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
  1254.     break;
  1256. default:
  1257.     error = EINVAL;
  1258. }
  1260.     splx (s);
  1261.     return (error);
  1262.     }
  1263. /*******************************************************************************
  1264. *
  1265. * esChipReset - hardware reset of chip (stop it)
  1266. */
  1268. LOCAL VOID esChipReset
  1269.     (
  1270.     struct ls_softc  *ls
  1271.     )
  1272.     {
  1273.     *dlan.dlcr1 = 0; /* reset transmit interrupt mask */
  1274.     *dlan.dlcr3 = 0; /* reset receive interrupt mask  */
  1275.     *dlan.dlcr6 = es_ena_dlc; /* stop the etherstar            */
  1276.     *dlan.dlcr2 = 0xcf; /* clear interrupts */
  1277.     *dlan.dlcr0 = 0x0f;
  1278.     }
  1279. /*******************************************************************************
  1280. *
  1281. * esChipInit - hardware init of chip (init & start it)
  1282. */
  1284. LOCAL VOID esChipInit
  1285.     (
  1286.     FAST struct ls_softc  *ls
  1287.     )
  1288.     {
  1289.     u_short temp;
  1290.     FAST ES_DEVICE *dv = ls->devAdrs;
  1292.     /* setup vector */
  1293.     dv->eth_vector =  ls->ivec;
  1294.  
  1295.     *dlan.dlcr6 = es_ena_dlc; /* stop the etherstar */
  1296.     *dlan.dlcr2 = 0xcf; /* clear all receive errors */
  1297.     *dlan.dlcr3 = 0x8f; /* reset receive interrupt mask */
  1298.     *dlan.dlcr0 = 0x0f; /* clear all transmit errors  */
  1299.     *dlan.dlcr1 = 0x00; /* reset transmit interrupt mask */
  1301.     /* flush the receive buffer memory of the etherstar */
  1302.     temp = esReadBmpr0 (dv);
  1303.     while ( !(*dlan.dlcr5 & 0x40) ) temp = esReadBmpr0 (dv);
  1304.     temp = esReadBmpr0 (dv);
  1305.     temp = esReadBmpr0 (dv);
  1307.     /* configure etherstar in normal mode */
  1308.     *dlan.dlcr4 = es_lbc; /* loopback disabled, byte swap enabled */
  1309.     *dlan.dlcr5 = 0x02; /* physical, multicast and broadcast  */
  1311.     /* copy the enet address into the softc */
  1313.     *dlan.dlcr8 = esEnetAddr[0];
  1314.     *dlan.dlcr9 = esEnetAddr[1]; /* setting these registers is only */
  1315.     *dlan.dlcr10 = esEnetAddr[2]; /* possible when etherstar is stopped */
  1316.     *dlan.dlcr11 = esEnetAddr[3];
  1317.     *dlan.dlcr12 = esEnetAddr[4];
  1318.     *dlan.dlcr13 = esEnetAddr[5];
  1320.     for ( temp = 20000; temp > 0; temp-- );
  1322.     /* start chip */
  1323.     *dlan.dlcr6 = 0x00; /* start the etherstar */
  1324.     *dlan.dlcr1 = ES_TMT_MASK; /* set transmit interrupt mask */
  1325.     *dlan.dlcr3 = ES_RCV_MASK; /* set receive interrupt mask */
  1326.     }
  1327. /*******************************************************************************
  1328. *
  1329. * esGetFreeTMD - get next available TMD
  1330. */
  1332. LOCAL es_tmd *esGetFreeTMD
  1333.     (
  1334.     FAST struct ls_softc  *ls
  1335.     )
  1336.     {
  1337.     FAST es_tmd   *tmd;
  1339.     /* check if buffer is available (owned by host) */
  1340.     /* also check for tindex overrun onto dindex */
  1342.     tmd = ls->ls_tring + ls->ls_tindex;
  1344.     if (((tmd->es_tmd1.es_tmd1b & estmd1_OWN) != 0)
  1345. || (((ls->ls_tindex + 1) & (ls->ls_tsize - 1)) == ls->ls_dindex))
  1346.         tmd = (es_tmd *) NULL;
  1348.     return (tmd);
  1349.     }
  1350. /*******************************************************************************
  1351. *
  1352. * esGetFullRMD - get next received message RMD
  1353. */
  1355. LOCAL es_rmd *esGetFullRMD
  1356.     (
  1357.     FAST struct ls_softc  *ls
  1358.     )
  1359.     {
  1360.     FAST es_rmd   *rmd;
  1362.     /* check if buffer is full (owned by host) */
  1364.     rmd = ls->ls_rring + ls->ls_rindex;
  1365.     if ((rmd->es_rmd1.es_rmd1b & esrmd1_OWN) == 0)
  1366. return (rmd);
  1367.     else
  1368. return ((es_rmd *) NULL);
  1369.     }
  1370. /*******************************************************************************
  1371. *
  1372. * esRmdFree - called when loaned out rbuf is freed by MCLFREE.
  1373. *
  1374. * Puts the loaned out rbuf into free list to be reused as loan replacements.
  1375. */
  1377. LOCAL VOID esRmdFree
  1378.     (
  1379.     FAST struct ls_softc *ls,
  1380.     FAST char  *pBuf
  1381.     )
  1382.     {
  1383.     ls->freeBufs [ls->nFree++] = pBuf;
  1384.     }