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

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

VxWorks

开发平台：

C/C++

ultraEnd.c：源码内容
  1. /* ultraEnd.c - SMC Ultra Elite END network interface driver */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01h,14jan02,dat  (more) Removing warnings from Diab compiler
  10. 01g,21sep01,dat  Removing ANSI errors for diab compiler
  11. 01f,28aug00,stv  corrected the handling of EIOCSFLAGS ioctl (SPR# 29423).
  12. 01e,02aug00,stv  removed netMblkClChainFree() in Pollsend routine (SPR# 32885).
  13. 01d,11jun00,ham  removed reference to etherLib.
  14. 01c,27jan00,dat  fixed use of NULL, removed warnings
  15. 01b,09mar99,sbs  changed SYS_INT_ENABLE and SYS_INT_DISABLE to use
  16.                  device specific BSP routines. 
  17. 01a,06jan99,dra  written.
  18. */
  20. /*
  21. DESCRIPTION
  22. This module implements the SMC Elite Ultra Ethernt network interface driver.
  24. This driver supports single transmission and multiple reception.  The
  25. Current register is a write pointer to the ring.  The Bound register
  26. is a read pointer from the ring.  This driver gets the Current
  27. register at the interrupt level and sets the Bound register at the
  28. task level.  The interrupt is only masked during configuration or in
  29. polled mode.
  31. CONFIGURATION
  32. The W1 jumper should be set in the position of "Software Configuration".
  33. The defined I/O address in config.h must match the one stored in EEROM. 
  34. The RAM address, the RAM size, and the IRQ level are defined in config.h. 
  35. IRQ levels 2,3,5,7,10,11,15 are supported.
  37. EXTERNAL SUPPORT REQUIREMENTS
  38. This driver requires several external support functions, defined as macros:
  39. .CS
  40.     SYS_INT_CONNECT(pDrvCtrl, routine, arg)
  41.     SYS_INT_DISCONNECT (pDrvCtrl, routine, arg)
  42.     SYS_INT_ENABLE(pDrvCtrl)
  43.     SYS_INT_DISABLE(pDrvCtrl)
  44.     SYS_IN_BYTE(pDrvCtrl, reg, pData)
  45.     SYS_OUT_BYTE(pDrvCtrl, reg, pData)
  46. .CE
  48. These macros allow the driver to be customized for BSPs that use
  49. special versions of these routines.
  51. The macro SYS_INT_CONNECT is used to connect the interrupt handler to
  52. the appropriate vector.  By default it is the routine intConnect().
  54. The macro SYS_INT_DISCONNECT is used to disconnect the interrupt handler prior
  55. to unloading the module.  By default this is a dummy routine that
  56. returns OK.
  58. The macro SYS_INT_ENABLE is used to enable the interrupt level for the
  59. end device.  It is called once during initialization. It calls an
  60. external board level routine sysUltraIntEnable().
  62. The macro SYS_INT_DISABLE is used to disable the interrupt level for the
  63. end device.  It is called once during shutdown. It calls an
  64. external board level routine sysUltraIntDisable().
  66. The macros SYS_IN_BYTE and SYS_OUT_BYTE are used for accessing the
  67. ultra device.  The default macros map these operations onto
  68. sysInByte() and sysOutByte().
  70. INCLUDES:
  71. end.h endLib.h etherMultiLib.h
  73. SEE ALSO: muxLib, endLib
  74. .I "Writing an Enhanced Network Driver"
  75. */
  77. /* includes */
  79. #include "vxWorks.h"
  80. #include "stdlib.h"
  81. #include "cacheLib.h"
  82. #include "intLib.h"
  83. #include "end.h" /* Common END structures. */
  84. #include "endLib.h"
  85. #include "lstLib.h" /* Needed to maintain protocol list. */
  86. #include "wdLib.h"
  87. #include "iv.h"
  88. #include "semLib.h"
  89. #include "logLib.h"
  90. #include "netLib.h"
  91. #include "stdio.h"
  92. #include "sysLib.h"
  93. #include "errno.h"
  94. #include "errnoLib.h"
  95. #include "memLib.h"
  96. #include "iosLib.h"
  97. #undef ETHER_MAP_IP_MULTICAST
  98. #include "etherMultiLib.h" /* multicast stuff. */
  100. #include "net/mbuf.h"
  101. #include "net/unixLib.h"
  102. #include "net/protosw.h"
  103. #include "net/systm.h"
  104. #include "net/if_subr.h"
  105. #include "net/route.h"
  107. #include "sys/socket.h"
  108. #include "sys/ioctl.h"
  109. #include "sys/times.h"
  110. #include "drv/end/ultraEnd.h"
  112. /* defines */
  114. /* Configuration items */
  116. #define ULTRA_SPEED_10M 10000000 /* 10Mbs */
  117. #define ULTRA_SPEED ULTRA_SPEED_10M
  119. /* Definitions for the flags field */
  121. #define ULTRA_POLLING 0x01
  122. #define ULTRA_TX_IN_PROGRESS 0x02
  123. #define ULTRA_TX_BLOCKED 0x04
  124. #define ULTRA_RCV_HANDLING_FLAG 0x08
  126. /* Debug macros */
  128. #undef DRV_DEBUG
  129. #ifdef DRV_DEBUG
  130. #define DRV_DEBUG_OFF 0x0000
  131. #define DRV_DEBUG_RX 0x0001
  132. #define DRV_DEBUG_TX 0x0002
  133. #define DRV_DEBUG_INT 0x0004
  134. #define DRV_DEBUG_POLL (DRV_DEBUG_POLL_RX | DRV_DEBUG_POLL_TX)
  135. #define DRV_DEBUG_POLL_RX 0x0008
  136. #define DRV_DEBUG_POLL_TX 0x0010
  137. #define DRV_DEBUG_LOAD 0x0020
  138. #define DRV_DEBUG_IOCTL 0x0040
  139. #define DRV_DEBUG_ERR 0x0080
  141. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
  142.     do
  143.         {
  144. if (ultraDebug & (FLG))
  145.     logMsg (X0, X1, X2, X3, X4, X5, X6);
  146. }
  147.     while (0)
  149. #define DRV_PRINT(FLG, X)
  150.     do
  151.         {
  152. if (ultraDebug & (FLG))
  153.     printf X;
  154. }
  155.     while (0)
  157. #else /* DRV_DEBUG */
  159. #define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6) do {} while (0)
  160. #define DRV_PRINT(FLG, X) do {} while (0)
  162. #endif /* DRV_DEBUG */
  164. /* Cache macros */
  166. #define ULTRA_CACHE_INVALIDATE(address, len) 
  167.         CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))
  169. /*
  170.  * Default macro definitions for BSP interface.  These macros can be
  171.  * redefined in a wrapper file, to generate a new module with an
  172.  * optimized interface.
  173.  */
  175. /* Macro to connect interrupt handler to vector */
  177. #ifndef SYS_INT_CONNECT
  178. #define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult) 
  179.     { 
  180.     IMPORT STATUS sysIntConnect(); 
  181.     *(pResult) = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC ((pDrvCtrl)->ivec), 
  182.    rtn, (int)(arg)); 
  183.     }
  184. #endif
  186. /* Macro to disconnect interrupt handler from vector */
  188. LOCAL VOID dummyIsr (void) { }
  190. #ifndef SYS_INT_DISCONNECT
  191. #define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult) 
  192.     { 
  193.     IMPORT STATUS intConnect(); 
  194.     *(pResult) = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC ((pDrvCtrl)->ivec), 
  195.      dummyIsr, (int)(arg)); 
  196.     }
  197. #endif
  199. /* Macro to enable the appropriate interrupt level */
  201. #ifndef SYS_INT_ENABLE
  202. #define SYS_INT_ENABLE(pDrvCtrl) 
  203. { 
  204.         IMPORT void sysUltraIntEnable(); 
  205. sysUltraIntEnable ((pDrvCtrl)->intLevel); 
  206. }
  207. #endif
  209. /* Macro to disable the appropriate interrupt level */
  211. #ifndef SYS_INT_DISABLE
  212. #define SYS_INT_DISABLE(pDrvCtrl) 
  213. { 
  214.         IMPORT void sysUltraIntDisable(); 
  215. sysUltraIntDisable ((pDrvCtrl)->intLevel); 
  216. }
  217. #endif
  219. /*
  220.  * Macros to do a byte access to the chip.  Default assumes an
  221.  * I/O mapped device accessed in the x86 fashion.
  222.  */
  224. #ifndef SYS_OUT_BYTE
  225. #define SYS_OUT_BYTE(pDrvCtrl, addr, value) 
  226.  (sysOutByte ((pDrvCtrl)->ioAddr+(addr), value))
  227. #endif
  229. #ifndef SYS_IN_BYTE
  230. #define SYS_IN_BYTE(pDrvCtrl, addr, pData) 
  231.  (*(pData) = sysInByte ((pDrvCtrl)->ioAddr+(addr)))
  232. #endif
  234. /* A shortcut for getting the hardware address from the MIB II stuff. */
  236. #define END_HADDR(pEnd)
  237. ((pEnd)->mib2Tbl.ifPhysAddress.phyAddress)
  239. #define END_HADDR_LEN(pEnd) 
  240. ((pEnd)->mib2Tbl.ifPhysAddress.addrLength)
  242. /* typedefs */
  244. /* The definition of the driver control structure */
  246. typedef struct ultra_device
  247.     {
  248.     END_OBJ     endObj; /* The class we inherit from. */
  249.     END_ERR lastError; /* Last error passed to muxError */
  250.     int unit; /* unit number */
  251.     int         ivec;                   /* interrupt vector */
  252.     int         ilevel; /* interrupt level */
  253.     int ioAddr; /* address of ultra's shared memory */
  254.     int memAddr; /* address of ultra's shared memory */
  255.     int memSize; /* size of ultra's shared memory */
  256.     int config; /* device config (TP, BNC) */
  257.     int offset; /* packet data offset */
  258.     UINT transmitPage[2]; /* start of TX packets */
  259.     UINT transmitCnt; /* number of TX packets sent */
  260.     UCHAR current; /* location of current RX packet */
  261.     UCHAR nextPacket; /* location of next RX packet */
  262.     UCHAR istat; /* current interrupt status */
  263.     UCHAR tstat; /* current TX status */
  264.     UCHAR rstat; /* current RX status */
  265.     UCHAR uppByteCnt; /* last upper byte count */
  266.     UCHAR intLevel; /* interrupt level from table */
  267.     ULONG flags; /* Our local flags. */
  268.     UCHAR enetAddr[6]; /* ethernet address */
  269.     UCHAR mcastFilter[8]; /* multicast address mask */
  270.     CACHE_FUNCS cacheFuncs;             /* cache function pointers */
  271.     CL_POOL_ID clPoolId; /* cluster pool */
  272.     } ULTRA_DEVICE;
  274. /* globals */
  276. #ifdef DRV_DEBUG
  277. int ultraDebug = 0x00;
  278. #endif /* DRV_DEBUG */
  280. /* locals */
  282. LOCAL IRQ_TABLE irqTable [] = 
  283.     {
  284.     { 2, 0x15},    { 2, 0x15},    { 2, 0x15},    { 3, 0x19},
  285.     { 3, 0x19},    { 5, 0x1d},    { 5, 0x1d},    { 7, 0x51},
  286.     { 7, 0x51},    { 7, 0x51},    {10, 0x55},    {11, 0x59},
  287.     {11, 0x59},    {11, 0x59},    {11, 0x59},    {15, 0x5d}
  288.     };
  290. /* forward declarations */
  292. IMPORT int endMultiLstCnt (END_OBJ* pEnd);
  294. LOCAL void ultraInt (ULTRA_DEVICE *pDrvCtrl);
  295. LOCAL STATUS ultraRecv (ULTRA_DEVICE *pDrvCtrl);
  296. LOCAL void ultraConfig (ULTRA_DEVICE *pDrvCtrl);
  297. LOCAL int ultraPacketGet  (ULTRA_DEVICE *pDrvCtrl, char *pDst);
  298. LOCAL void ultraAddrFilterSet (ULTRA_DEVICE *pDrvCtrl);
  299. LOCAL void ultraHandleRcvInt  (ULTRA_DEVICE *pDrvCtrl);
  301. LOCAL STATUS ultraParse (ULTRA_DEVICE* pDrvCtrl, char* initString);
  302. LOCAL STATUS ultraMemInit (ULTRA_DEVICE* pDrvCtrl, int clNum);
  303. LOCAL STATUS ultraPollStart (ULTRA_DEVICE* pDrvCtrl);
  304. LOCAL STATUS ultraPollStop (ULTRA_DEVICE* pDrvCtrl);
  305. LOCAL void ultraReset (ULTRA_DEVICE* pDrvCtrl);
  307. /* Ultra Specific interfaces. */
  309. LOCAL STATUS ultraStart (void* pObj);
  310. LOCAL STATUS ultraStop (void* pObj);
  311. LOCAL STATUS ultraUnload (void* pObj);
  312. LOCAL int ultraIoctl (void* pObj, int cmd, caddr_t data);
  313. LOCAL STATUS ultraSend (void* pObj, M_BLK_ID pBuf);
  314.   
  315. LOCAL STATUS ultraMCastAdd (void* pObj, char* pAddress);
  316. LOCAL STATUS ultraMCastDel (void* pObj, char* pAddress);
  317. LOCAL STATUS ultraMCastGet (void* pObj, MULTI_TABLE* pTable);
  318. LOCAL STATUS ultraPollSend (void* pObj, M_BLK_ID pBuf);
  319. LOCAL STATUS ultraPollRcv (void* pObj, M_BLK_ID pBuf);
  321. /* This is the only externally visible interface. */
  323. END_OBJ*  ultraLoad (char* initString);
  325. /*
  326.  * Declare our function table.  This is static across all driver
  327.  * instances.
  328.  */
  330. LOCAL NET_FUNCS ultraFuncTable =
  331.     {
  332.     (FUNCPTR)ultraStart, /* Function to start the device. */
  333.     (FUNCPTR)ultraStop, /* Function to stop the device. */
  334.     (FUNCPTR)ultraUnload, /* Unloading function for the driver. */
  335.     (FUNCPTR)ultraIoctl, /* Ioctl function for the driver. */
  336.     (FUNCPTR)ultraSend, /* Send function for the driver. */
  337.     (FUNCPTR)ultraMCastAdd, /* Multicast add function for the driver */
  338.     (FUNCPTR)ultraMCastDel, /* Multicast delete function for the driver */
  339.     (FUNCPTR)ultraMCastGet, /* Multicast get function for the driver */
  340.     (FUNCPTR)ultraPollSend, /* Polling send function */
  341.     (FUNCPTR)ultraPollRcv, /* Polling receive function */
  342.     endEtherAddressForm, /* put address info into a NET_BUFFER */
  343.     endEtherPacketDataGet,  /* get pointer to data in NET_BUFFER */
  344.     endEtherPacketAddrGet  /* Get packet addresses. */
  345.     };
  347. /*******************************************************************************
  348. *
  349. * ultraLoad - initialize the driver and device
  350. *
  351. * This routine initializes the driver and the device to the operational state.
  352. * All of the device-specific parameters are passed in <initString>, which
  353. * expects a string of the following format:
  354. *
  355. * <unit>:<ioAddr>:<memAddr>:<vecNum>:<intLvl>:<config>:<offset>"
  356. *
  357. * This routine can be called in two modes. If it is called with an empty but
  358. * allocated string, it places the name of this device (that is, "ultra") into 
  359. * the <initString> and returns 0.
  360. *
  361. * If the string is allocated and not empty, the routine attempts to load
  362. * the driver using the values specified in the string.
  363. *
  364. * RETURNS: An END object pointer, or NULL on error, or 0 and the name of the
  365. * device if the <initString> was NULL.
  366. */
  368. END_OBJ* ultraLoad
  369.     (
  370.     char * initString /* String to be parsed by the driver. */
  371.     )
  372.     {
  373.     ULTRA_DEVICE * pDrvCtrl;
  374.     
  375.     if (initString == NULL)
  376.         return (NULL);
  377.     
  378.     if (initString[0] == EOS)
  379.         {
  380.         bcopy ((char *)DEV_NAME, initString, DEV_NAME_LEN);
  381.         return (NULL);
  382.         }
  383.     
  384.     DRV_LOG (DRV_DEBUG_LOAD, "ultraLoad: loadingn",
  385.      (int) DEV_NAME, 2, 3, 4, 5, 6);
  387.     /* allocate the device structure */
  388.             
  389.     pDrvCtrl = (ULTRA_DEVICE *)calloc (sizeof (ULTRA_DEVICE), 1);
  390.     if (pDrvCtrl == NULL)
  391. goto errorExit;
  393.     /* parse the init string, filling in the device structure */
  395.     if (ultraParse (pDrvCtrl, initString) == ERROR)
  396. {
  397. logMsg ("ultraLoad: bad initialization stringn",
  398. 1, 2, 3, 4, 5, 6);
  399. goto errorExit;
  400. }
  402.     DRV_LOG (DRV_DEBUG_LOAD,
  403.      "ultraLoad: unit=%d ivec=%x ilevel=%x ioAddr=%x memAddr=%x config=%xn",
  404.      pDrvCtrl->unit,
  405.      pDrvCtrl->ivec, pDrvCtrl->ilevel,
  406.      pDrvCtrl->ioAddr,  pDrvCtrl->memAddr,
  407.      pDrvCtrl->config);
  409.     /* Setup the rest of pDrvCtrl */
  411.     pDrvCtrl->intLevel = irqTable [pDrvCtrl->ilevel].irq;
  412.     pDrvCtrl->transmitPage[0] = ULTRA_TSTART0;
  413.     pDrvCtrl->transmitPage[1] = ULTRA_TSTART1;
  414.     pDrvCtrl->transmitCnt = 0;
  415.     pDrvCtrl->memSize = ULTRA_RAMSIZE;
  416.     pDrvCtrl->cacheFuncs = cacheDmaFuncs;
  418.     /* Reset the device */
  420.     ultraReset (pDrvCtrl);
  422.     /* Get ethernet address from card */
  424.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS0 | CMD_STP);
  425.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN0, &pDrvCtrl->enetAddr[0]);
  426.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN1, &pDrvCtrl->enetAddr[1]);
  427.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN2, &pDrvCtrl->enetAddr[2]);
  428.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN3, &pDrvCtrl->enetAddr[3]);
  429.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN4, &pDrvCtrl->enetAddr[4]);
  430.     SYS_IN_BYTE (pDrvCtrl, CTRL_LAN5, &pDrvCtrl->enetAddr[5]);
  431.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  433.     /* initialize the END and MIB2 parts of the structure */
  435.     if (END_OBJ_INIT (&pDrvCtrl->endObj, (DEV_OBJ *)pDrvCtrl, "ultra",
  436.                       pDrvCtrl->unit, &ultraFuncTable,
  437.                       "SMC Ultra Elite Enhanced Network Driver.") == ERROR)
  438. goto errorExit;
  440.     if (END_MIB_INIT (&pDrvCtrl->endObj, M2_ifType_ethernet_csmacd,
  441.                       &pDrvCtrl->enetAddr[0], 6, ETHERMTU,
  442.       ULTRA_SPEED) == ERROR)
  443. goto errorExit;
  445.     /* Perform memory allocation */
  447.     if (ultraMemInit (pDrvCtrl, 128) == ERROR)
  448. {
  449. #if (CPU_FAMILY==I80X86)
  450. /* Probably the bootrom case, try to get by with fewer clusters. */
  451. if (ultraMemInit (pDrvCtrl, 8) == ERROR)
  452.     goto errorExit;
  453. #else /* (CPU_FAMILY==I80X86) */
  454. goto errorExit;
  455. #endif /* (CPU_FAMILY==I80X86) */
  456. }
  458.     /* Reconfigure the device */
  460.     ultraConfig (pDrvCtrl);
  462.     DRV_LOG (DRV_DEBUG_LOAD, "ultraLoad: donen",
  463.      1, 2, 3, 4, 5, 6);
  465.     /* Set the flags to indicate readiness */
  467.     END_OBJ_READY (&pDrvCtrl->endObj,
  468.     IFF_UP | IFF_RUNNING | IFF_NOTRAILERS | IFF_BROADCAST
  469.     | IFF_MULTICAST | IFF_SIMPLEX);
  470.     
  471.     return (&pDrvCtrl->endObj);
  473. errorExit:
  474.     DRV_LOG (DRV_DEBUG_LOAD, "ultraLoad: errorExitn",
  475.      1, 2, 3, 4, 5, 6);
  477.     if (pDrvCtrl != NULL)
  478. free ((char *)pDrvCtrl);
  480.     return (NULL);
  481.     }
  482.    
  483. /*******************************************************************************
  484. *
  485. * ultraParse - parse the init string
  486. *
  487. * Parse the input string.  Fill in values in the driver control structure.
  488. * The initialization string format is:
  489. * <unit>:<ioAddr>:<memAddr>:<vecNum>:<intLvl>:<config>:<offset>"
  490. *
  491. * .IP <unit>
  492. * Device unit number, a small integer.
  493. * .IP <ioAddr>
  494. * I/O address
  495. * .IP <memAddr>
  496. * Memory address, assumed to be 16k bytes in length.
  497. * .IP <vecNum>
  498. * Interrupt vector number (used with sysIntConnect()).
  499. * .IP <intLvl>
  500. * Interrupt level.
  501. * .IP <config>
  502. * Ultra config (0: RJ45 + AUI(Thick)  1: RJ45 + BNC(Thin)).
  503. * .IP <offset>
  504. * Memory offset for alignment.
  505. *
  506. * RETURNS: OK, or ERROR if any arguments are invalid.
  507. */
  509. LOCAL STATUS ultraParse
  510.     (
  511.     ULTRA_DEVICE * pDrvCtrl, /* device pointer */
  512.     char * initString /* information string */
  513.     )
  514.     {
  515.     char * tok;
  516.     char * pHolder = NULL;
  517.     
  518.     /* Parse the initString */
  520.     /* Unit number. */
  522.     tok = strtok_r (initString, ":", &pHolder);
  523.     if (tok == NULL)
  524. return (ERROR);
  525.     pDrvCtrl->unit = atoi (tok);
  527.     /* I/O address. */
  528.     
  529.     tok = strtok_r (NULL, ":", &pHolder);
  530.     if (tok == NULL)
  531. return (ERROR);
  532.     pDrvCtrl->ioAddr = strtoul (tok, NULL, 16);
  534.     /* Memory address. */
  535.     
  536.     tok = strtok_r (NULL, ":", &pHolder);
  537.     if (tok == NULL)
  538. return (ERROR);
  539.     pDrvCtrl->memAddr = strtoul (tok, NULL, 16);
  541.     /* Interrupt vector. */
  543.     tok = strtok_r (NULL, ":", &pHolder);
  544.     if (tok == NULL)
  545. return (ERROR);
  546.     pDrvCtrl->ivec = strtoul (tok, NULL, 16);
  548.     /* Interrupt level. */
  550.     tok = strtok_r (NULL, ":", &pHolder);
  551.     if (tok == NULL)
  552. return (ERROR);
  553.     pDrvCtrl->ilevel = strtoul (tok, NULL, 16);
  555.     /* config */
  556.     
  557.     tok = strtok_r (NULL, ":", &pHolder);
  558.     if (tok == NULL)
  559. return (ERROR);
  560.     pDrvCtrl->config = strtoul (tok, NULL, 16);
  562.     /* offset */
  563.     
  564.     tok = strtok_r (NULL, ":", &pHolder);
  565.     if (tok == NULL)
  566. return (ERROR);
  567.     pDrvCtrl->offset = strtoul (tok, NULL, 16);
  568.     
  569.     return (OK);
  570.     }
  572. /*******************************************************************************
  573. *
  574. * ultraMemInit - initialize memory for the chip
  575. *
  576. * Using data in the control structure, setup and initialize the memory
  577. * areas needed.  If the memory address is not already specified, then allocate
  578. * cache safe memory.
  579. *
  580. * RETURNS: OK or ERROR.
  581. */
  583. LOCAL STATUS ultraMemInit
  584.     (
  585.     ULTRA_DEVICE * pDrvCtrl, /* device to be initialized */
  586.     int clNum /* number of clusters to allocate */
  587.     )
  588.     {
  589.     CL_DESC clDesc;                      /* cluster description */
  590.     M_CL_CONFIG ultraMclBlkConfig;
  592.     bzero ((char *)&ultraMclBlkConfig, sizeof(ultraMclBlkConfig));
  593.     bzero ((char *)&clDesc, sizeof(clDesc));
  594.     
  595.     pDrvCtrl->endObj.pNetPool = (NET_POOL_ID) malloc (sizeof(NET_POOL));
  596.     if (pDrvCtrl->endObj.pNetPool == NULL)
  597.         return (ERROR);
  599.     clDesc.clNum   = clNum;
  600.     clDesc.clSize  = MEM_ROUND_UP(ULTRA_BUFSIZ + pDrvCtrl->offset);
  601.     clDesc.memSize = ((clDesc.clNum * (clDesc.clSize + 4)) + 4);
  603.     ultraMclBlkConfig.mBlkNum = clDesc.clNum * 2;
  604.     ultraMclBlkConfig.clBlkNum = clDesc.clNum;
  606.     /*
  607.      * mBlk and cluster configuration memory size initialization
  608.      * memory size adjusted to hold the netPool pointer at the head.
  609.      */
  610.     ultraMclBlkConfig.memSize =
  611.       (ultraMclBlkConfig.mBlkNum * (M_BLK_SZ + sizeof (long)))
  612.       + (ultraMclBlkConfig.clBlkNum * (CL_BLK_SZ + sizeof (long)));
  613.     ultraMclBlkConfig.memArea = (char *) memalign(sizeof (long),
  614.   ultraMclBlkConfig.memSize);
  615.     if (ultraMclBlkConfig.memArea == NULL)
  616. {
  617. free (pDrvCtrl->endObj.pNetPool);
  618. pDrvCtrl->endObj.pNetPool = NULL;
  619. return (ERROR);
  620. }
  621.     
  622.     clDesc.memArea = (char *) malloc (clDesc.memSize);
  623.     if (clDesc.memArea == NULL)
  624. {
  625. free (ultraMclBlkConfig.memArea);
  626. free (pDrvCtrl->endObj.pNetPool);
  627. pDrvCtrl->endObj.pNetPool = NULL;
  628. return (ERROR);
  629. }
  631.     /* Initialize the net buffer pool with transmit buffers */
  632.     if (netPoolInit (pDrvCtrl->endObj.pNetPool, &ultraMclBlkConfig,
  633.      &clDesc, 1, NULL) == ERROR)
  634. {
  635. free (clDesc.memArea);
  636. free (ultraMclBlkConfig.memArea);
  637. free (pDrvCtrl->endObj.pNetPool);
  638. pDrvCtrl->endObj.pNetPool = NULL;
  639. return (ERROR);
  640. }
  642.     pDrvCtrl->clPoolId = clPoolIdGet (pDrvCtrl->endObj.pNetPool,
  643.       ULTRA_BUFSIZ + pDrvCtrl->offset, FALSE);
  644.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraMemInit: %d clustersn",
  645.      (int) DEV_NAME, pDrvCtrl->unit, clNum, 4, 5, 6);
  647.     return (OK);
  648.     }
  650. /******************************************************************************
  651. *
  652. * ultraReset - reset the ultra device
  653. *
  654. * Stop and reset the Ultra chip.
  655. *
  656. * RETURNS: N/A
  657. */
  659. LOCAL void ultraReset
  660.     (
  661.     ULTRA_DEVICE * pDrvCtrl
  662.     )
  663.     {     
  664.     int tmp;
  666.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraResetn",
  667.      (int)DEV_NAME, pDrvCtrl->unit,
  668.      3, 4, 5, 6);
  670.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  672.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  673.     do
  674. SYS_IN_BYTE (pDrvCtrl, LAN_INTSTAT, &tmp);
  675.     while ((tmp & ISTAT_RST) != ISTAT_RST);
  677.     SYS_OUT_BYTE (pDrvCtrl, CTRL_CON, CON_RESET);
  678.     SYS_OUT_BYTE (pDrvCtrl, CTRL_CON, 0x00);
  679.     SYS_OUT_BYTE (pDrvCtrl, CTRL_HARD, 0x08);
  680.     taskDelay (sysClkRateGet () >> 2);
  681.     SYS_OUT_BYTE (pDrvCtrl, CTRL_CON, CON_MENABLE);
  683.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTSTAT, 0xff);
  685.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraReset donen",
  686.      (int)DEV_NAME, pDrvCtrl->unit,
  687.      3, 4, 5, 6);
  688.     }
  690. /******************************************************************************
  691. *
  692. * ultraStart - start the device
  693. *
  694. * This function calls BSP functions to connect interrupts and start the
  695. * device running in interrupt mode.
  696. *
  697. * RETURNS: OK or ERROR
  698. *
  699. */
  701. LOCAL STATUS ultraStart
  702.     (
  703.     void * pObj /* device ID */
  704.     )
  705.     {
  706.     STATUS result;
  707.     ULTRA_DEVICE * pDrvCtrl = pObj;
  708.     
  709.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraStartn",
  710.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  711.     
  712.     SYS_INT_CONNECT (pDrvCtrl, ultraInt, (int)pDrvCtrl, &result);
  713.     if (result == ERROR)
  714. {
  715. DRV_LOG (DRV_DEBUG_LOAD,
  716.  "%s%d: ultraStart: could not attach interruptn",
  717.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  718. return (ERROR);
  719. }
  721.     SYS_INT_ENABLE (pDrvCtrl);
  723.     /* start the device */
  725.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STA);
  727.     /* initialize Transmit Configuration Register */
  729.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCON, 0x00);
  731.     /* enable interrupts */
  732.       
  733.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  734.     SYS_OUT_BYTE (pDrvCtrl, CTRL_INT, INT_ENABLE);
  735.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK,
  736.   IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  737.     return (OK);
  738.     }
  740. /******************************************************************************
  741. *
  742. * ultraStop - stop the device
  743. *
  744. * This function calls BSP functions to disconnect interrupts and stop
  745. * the device from operating in interrupt mode.
  746. *
  747. * RETURNS: OK or ERROR.
  748. */
  750. LOCAL STATUS ultraStop
  751.     (
  752.     void * pObj /* device to be stopped */
  753.     )
  754.     {     
  755.     int tmp;
  756.     int oldLevel;
  757.     STATUS result = OK;
  758.     ULTRA_DEVICE * pDrvCtrl = pObj;
  760.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraStopn",
  761.      (int)DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  763.     /* Stop/disable the device. */
  765.     oldLevel = intLock ();
  766.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  768.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  769.     do
  770. SYS_IN_BYTE (pDrvCtrl, LAN_INTSTAT, &tmp);
  771.     while ((tmp & ISTAT_RST) != ISTAT_RST);
  773.     SYS_OUT_BYTE (pDrvCtrl, LAN_RCON, 0x00);
  774.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCON, TCON_LB1);
  776.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTSTAT, 0xff);
  778.     SYS_INT_DISABLE (pDrvCtrl);
  780.     intUnlock (oldLevel);
  781.     
  782.     /* Remove the ISR */
  783.     
  784.     SYS_INT_DISCONNECT (pDrvCtrl, ultraInt, (int)pDrvCtrl, &result);
  786.     if (result == ERROR)
  787. {
  788. DRV_LOG (DRV_DEBUG_LOAD, "Could not disconnect interrupt!n",
  789. 1, 2, 3, 4, 5, 6);
  790. }
  792.     return (result);
  793.     }
  795. /******************************************************************************
  796. *
  797. * ultraConfig - reconfigure the interface under us.
  798. *
  799. * Reconfigure the interface setting promiscuous mode, and changing the
  800. * multicast interface list.
  801. *
  802. * RETURNS: N/A.
  803. */
  805. LOCAL void ultraConfig
  806.     (
  807.     ULTRA_DEVICE * pDrvCtrl /* device to be re-configured */
  808.     )
  809.     {
  810.     int i;
  811.     int tmp;
  812.     UCHAR rcon;
  813.     UCHAR memAddr;
  814.     UCHAR intLevel;
  815.     UCHAR ioAddr;
  816.     UCHAR eeromGcon;
  818.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraConfig: flags=%xn",
  819.      (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->flags, 4, 5, 6);
  820.       
  821.     /* Mask interrupts */
  823.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  825.     /* program Command Register for page 0, stop device */
  826.     
  827.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  828.     do
  829. SYS_IN_BYTE (pDrvCtrl, LAN_INTSTAT, &tmp);
  830.     while ((tmp & ISTAT_RST) != ISTAT_RST);
  831.     
  832.     /* get values set by EEROM */
  834.     SYS_OUT_BYTE (pDrvCtrl, CTRL_HARD, 0x80);
  835.     SYS_IN_BYTE (pDrvCtrl, CTRL_GCON, &eeromGcon);
  837.     /* IO address, Memory address, Interrupt request */
  839.     memAddr = (((pDrvCtrl->memAddr & 0x1e000) >> 13)
  840.        | ((pDrvCtrl->memAddr & 0x20000) >> 10));
  841.     intLevel = (((pDrvCtrl->intLevel & 0x03) << 2)
  842. | ((pDrvCtrl->intLevel & 0x04) << 6));
  843.     ioAddr = (((pDrvCtrl->ioAddr & 0xe000) >> 8)
  844.       | ((pDrvCtrl->ioAddr & 0x01e0) >> 4));
  845.     SYS_OUT_BYTE (pDrvCtrl, CTRL_HARD, 0x80);
  846.     SYS_OUT_BYTE (pDrvCtrl, CTRL_IOADDR, ioAddr);
  847.     SYS_OUT_BYTE (pDrvCtrl, CTRL_MEMADDR, memAddr | 0x10);
  848.     if (pDrvCtrl->config == 1)
  849.         SYS_OUT_BYTE (pDrvCtrl, CTRL_GCON,
  850.       irqTable [pDrvCtrl->intLevel].reg | (eeromGcon & 0x20));
  851.     else if (pDrvCtrl->config == 2)
  852.         SYS_OUT_BYTE (pDrvCtrl, CTRL_GCON,
  853.       (irqTable [pDrvCtrl->intLevel].reg | 0x02
  854.        | (eeromGcon & 0x20)));
  855.     else
  856.         SYS_OUT_BYTE (pDrvCtrl, CTRL_GCON,
  857.       irqTable [pDrvCtrl->intLevel].reg | (eeromGcon & 0x22));
  859.     /* set FINE16 bit in BIO register to get finer res for M16CS decode */
  861.     SYS_IN_BYTE (pDrvCtrl, CTRL_BIO, &tmp); 
  862.     SYS_OUT_BYTE (pDrvCtrl, CTRL_BIO, tmp | BIO_FINE16);
  863.     SYS_OUT_BYTE (pDrvCtrl, CTRL_HARD, 0x00);
  865.     /* 16 bit enable */
  867.     SYS_OUT_BYTE (pDrvCtrl, CTRL_BIOS, BIOS_M16EN);
  869.     /* initialize Data Configuration Register */
  871.     SYS_OUT_BYTE (pDrvCtrl, LAN_DCON, DCON_BSIZE1 | DCON_BUS16);
  873.     /* initialize Receive Configuration Register */
  874.    
  875.     ultraAddrFilterSet (pDrvCtrl);
  877.     /* always accept broadcast packets */
  878.     rcon = RCON_BROAD;
  879.     if (END_MULTI_LST_CNT(&pDrvCtrl->endObj) > 0)
  880. rcon |= RCON_GROUP;
  881.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_PROMISC)
  882. rcon |= (RCON_PROM | RCON_GROUP);
  883.     if (END_FLAGS_GET(&pDrvCtrl->endObj) & (IFF_PROMISC|IFF_ALLMULTI))
  884. {
  885. /* receive all multicast packets */
  886. rcon |= RCON_GROUP;
  887. /* Set multicast hashing array to all 1's */
  888. for (i = 0; i < 8; ++i)
  889.     pDrvCtrl->mcastFilter[i] = 0xff;
  890. }
  891.     SYS_OUT_BYTE (pDrvCtrl, LAN_RCON, rcon);
  893.     if (rcon & RCON_GROUP)
  894. DRV_LOG (DRV_DEBUG_IOCTL, "%s%d: Setting multicast mode on!n",
  895.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  896.     if (rcon & RCON_PROM)
  897. DRV_LOG (DRV_DEBUG_IOCTL, "%s%d: Setting promiscuous mode on!n",
  898.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  900.     /* place the Ultra in external LOOPBACK mode */
  902.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCON, TCON_LB1);
  904.     /* initialize Receive Buffer Ring */
  906.     SYS_OUT_BYTE (pDrvCtrl, LAN_RSTART, ULTRA_PSTART);
  907.     SYS_OUT_BYTE (pDrvCtrl, LAN_RSTOP, ULTRA_PSTOP);
  908.     SYS_OUT_BYTE (pDrvCtrl, LAN_BOUND, ULTRA_PSTART);
  910.     /* clear Interrupt Status Register */
  911.  
  912.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTSTAT, 0xff);
  914.     /* initialize Interrupt Mask Register */
  916.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  918.     /* Set command register for page 1 */
  920.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS0 | CMD_STP);
  922.     /* Program ethernet address (page 1) */
  924.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA0, pDrvCtrl->enetAddr[0]);
  925.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA1, pDrvCtrl->enetAddr[1]);
  926.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA2, pDrvCtrl->enetAddr[2]);
  927.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA3, pDrvCtrl->enetAddr[3]);
  928.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA4, pDrvCtrl->enetAddr[4]);
  929.     SYS_OUT_BYTE (pDrvCtrl, LAN_STA5, pDrvCtrl->enetAddr[5]);
  931.     /* Program multicast mask (page 1) */
  933.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR0, pDrvCtrl->mcastFilter[0]);
  934.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR1, pDrvCtrl->mcastFilter[1]);
  935.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR2, pDrvCtrl->mcastFilter[2]);
  936.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR3, pDrvCtrl->mcastFilter[3]);
  937.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR4, pDrvCtrl->mcastFilter[4]);
  938.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR5, pDrvCtrl->mcastFilter[5]);
  939.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR6, pDrvCtrl->mcastFilter[6]);
  940.     SYS_OUT_BYTE (pDrvCtrl, LAN_MAR7, pDrvCtrl->mcastFilter[7]);
  942.     /* Initialize current page pointer (page 1) */
  944.     SYS_OUT_BYTE (pDrvCtrl, LAN_CURR, ULTRA_PSTART + 1);
  945.     pDrvCtrl->nextPacket = ULTRA_PSTART + 1;
  947.     /* Switch to page 2 registers */
  949.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS1 | CMD_STP);
  951.     /* Program wait states (0) */
  953.     SYS_OUT_BYTE (pDrvCtrl, LAN_ENH, 0x00);
  955.     /* put the Ultra in START mode */
  957.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STA);
  959.     /* Take interface out of loopback */
  961.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCON, 0x00);
  963.     if (!(pDrvCtrl->flags & ULTRA_POLLING))
  964. {
  965. SYS_OUT_BYTE (pDrvCtrl, CTRL_INT, INT_ENABLE);
  966. SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK,
  967.       IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  968. }
  969.     }
  971. /******************************************************************************
  972. *
  973. * ultraInt - handle controller interrupt
  974. *
  975. * This routine is called at interrupt level in response to an interrupt from
  976. * the controller.
  977. *
  978. * RETURNS: N/A.
  979. */
  981. LOCAL void ultraInt
  982.     (
  983.     ULTRA_DEVICE * pDrvCtrl /* interrupting device */
  984.     )
  985.     {
  986.     UCHAR istat;
  987.     
  988.     /* Acknowledge interrupt, get Transmit/Receive status */
  990.     pDrvCtrl->istat = 0;
  991.     do
  992. {
  993. SYS_IN_BYTE (pDrvCtrl, LAN_INTSTAT, &istat);
  994. SYS_OUT_BYTE (pDrvCtrl, LAN_INTSTAT, istat);
  995. pDrvCtrl->istat |= istat;
  996. }
  997.     while (istat != 0);
  998.     SYS_IN_BYTE (pDrvCtrl, LAN_TSTAT, &pDrvCtrl->tstat);
  999.     SYS_IN_BYTE (pDrvCtrl, LAN_RSTAT, &pDrvCtrl->rstat);
  1001.     DRV_LOG (DRV_DEBUG_INT,
  1002.      "%s%d: istat %x tstat %x rstat %x flags %xn",
  1003.      (int) DEV_NAME, pDrvCtrl->unit,
  1004.      pDrvCtrl->istat, pDrvCtrl->tstat,
  1005.      pDrvCtrl->rstat, pDrvCtrl->flags);
  1007.     /* Receive-error */
  1009.     if (pDrvCtrl->istat & ISTAT_RXE)
  1010. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1012.     /* Receive, Overwrite */
  1014.     if (pDrvCtrl->istat & (ISTAT_PRX | ISTAT_OVW))
  1015. {
  1016. if (pDrvCtrl->istat & ISTAT_OVW)
  1017.     {
  1018.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1019.     DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_INT | DRV_DEBUG_ERR,
  1020.      "%s%d: overwrite errorn",
  1021.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1022.     }
  1023. if (!(pDrvCtrl->flags & ULTRA_RCV_HANDLING_FLAG))
  1024.     {
  1025.     if (netJobAdd ((FUNCPTR) ultraHandleRcvInt,
  1026.    (int) pDrvCtrl, 0, 0, 0, 0) == ERROR)
  1027. {
  1028. /* Error - will have to wait until next RX interrupt recv'd */
  1029. logMsg ("%s%d: failed to queue ultraHandleRcvIntn",
  1030. (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1031. /* failed netJobAdd causes panic, stop device */
  1032. SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  1033. return;
  1034. }
  1035.     pDrvCtrl->flags |= ULTRA_RCV_HANDLING_FLAG;
  1036.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS0);
  1037.     SYS_IN_BYTE (pDrvCtrl, LAN_CURR, &pDrvCtrl->current);
  1038.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, 0);
  1039.     DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_INT,
  1040.      "%s%d: queued ultraHandleRcvInt: curr=%x next=%xn",
  1041.      (int) DEV_NAME, pDrvCtrl->unit,
  1042.      pDrvCtrl->current, pDrvCtrl->nextPacket, 5, 6);
  1043.     }
  1044. }
  1046.     /* Transmit-error, Transmit */
  1048.     if (pDrvCtrl->istat & (ISTAT_TXE | ISTAT_PTX))
  1049. {
  1050. if (pDrvCtrl->istat & ISTAT_TXE)
  1051.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, -1);
  1052. if ((pDrvCtrl->istat & ISTAT_TXE)
  1053.     || (pDrvCtrl->tstat & (TSTAT_ABORT | TSTAT_UNDER | TSTAT_CDH
  1054.    | TSTAT_OWC | TSTAT_PTX)))
  1055.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);
  1056. pDrvCtrl->flags &= ~ULTRA_TX_IN_PROGRESS;
  1057. if (pDrvCtrl->flags & ULTRA_TX_BLOCKED)
  1058.     {
  1059.     DRV_LOG (DRV_DEBUG_TX | DRV_DEBUG_INT,
  1060.      "%s%d: queuing muxTxRestartn",
  1061.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1062.     if (netJobAdd ((FUNCPTR)muxTxRestart,
  1063.    (int) &pDrvCtrl->endObj, 0, 0, 0, 0) == ERROR)
  1064. {
  1065. /* Error - can't queue, transmitter is hung. */
  1066. logMsg ("%s%d: failed to queue muxTxRestartn",
  1067. (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1068. /* failed netJobAdd causes panic, stop device */
  1069. SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_STP);
  1070. return;
  1071. }
  1072.     pDrvCtrl->flags &= ~ULTRA_TX_BLOCKED;
  1073.     }
  1074. }
  1075.     }
  1077. /******************************************************************************
  1078. *
  1079. * ultraPacketGet - get next received message
  1080. *
  1081. * Get next received packet into the supplied buffer.
  1082. *
  1083. * RETURNS: length of the next packet, or a negative number if none available.
  1084. */
  1086. LOCAL int ultraPacketGet
  1087.     (
  1088.     ULTRA_DEVICE * pDrvCtrl,
  1089.     char * pDst
  1090.     )
  1091.     {
  1092.     int len;
  1093.     char * pSrc;
  1094.     int wrapSize = 0;
  1095.     UINT packetSize;
  1096.     int oldLevel;
  1097.     ULTRA_HEADER * pH;
  1099.     if (pDrvCtrl->nextPacket == pDrvCtrl->current)
  1100. return (0);
  1102.     /* Invalidate cache and get pointer to header */
  1104.     ULTRA_CACHE_INVALIDATE ((UCHAR *)(pDrvCtrl->memAddr + (ULTRA_PSTART << 8)),
  1105.     (pDrvCtrl->memSize - (ULTRA_PSTART << 8)));
  1106.     pH = (ULTRA_HEADER *)(pDrvCtrl->memAddr + (pDrvCtrl->nextPacket << 8));
  1108.     DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraPacketGet: %02x/%d/%02x/%02xn",
  1109.      (int) DEV_NAME, pDrvCtrl->unit,
  1110.      pH->next, (((UINT)pH->uppByteCnt << 8) + pH->lowByteCnt),
  1111.      pDrvCtrl->nextPacket, pDrvCtrl->uppByteCnt);
  1113.     if ((pH->next < ULTRA_PSTART) || (pH->next >= ULTRA_PSTOP))
  1114. {
  1115. pH->next = pDrvCtrl->nextPacket + pDrvCtrl->uppByteCnt + 1;
  1116. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERR,
  1117.  "%s%d: ultraPacketGet: fix pH->next (%x)n",
  1118.  (int) DEV_NAME, pDrvCtrl->unit, pH->next, 4, 5, 6);
  1119. if (pH->next >= ULTRA_PSTOP)
  1120.     pH->next = ULTRA_PSTART + (pH->next - ULTRA_PSTOP);
  1121. }
  1123.     if (pH->rstat & RSTAT_PRX)
  1124. {
  1125. /* 3Com says this status marks a packet bit-shifted in memory;
  1126.  * the data cannot be trusted but the NIC header is OK.
  1127.  */
  1128. if (pH->rstat & (RSTAT_DFR | RSTAT_DIS))
  1129.     {
  1130.     DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERR,
  1131.      "%s%d: ultraPacketGet: bit-shifted packetn",
  1132.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1133.     packetSize = -2;
  1134.     goto doneGet;
  1135.     }
  1136. }
  1137.     else
  1138. {
  1139. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERR,
  1140.  "%s%d: ultraPacketGet: corrupted packetn",
  1141.  (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1142. packetSize = -2;
  1143. goto doneGet;
  1144. }
  1146.     /* Compute packet size, excluding Ultra header */
  1148.     pSrc = ((char *)pH) + sizeof(ULTRA_HEADER);
  1149.     packetSize = (((UINT)pH->uppByteCnt << 8) + pH->lowByteCnt
  1150.   - sizeof(ULTRA_HEADER));
  1151.     if ((packetSize < ULTRA_MIN_SIZE) || (packetSize > ULTRA_MAX_SIZE))
  1152. {
  1153. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1154. DRV_LOG (DRV_DEBUG_RX | DRV_DEBUG_ERR,
  1155.  "%s%d: ultraPacketGet: bad size packet %dn",
  1156.  (int) DEV_NAME, pDrvCtrl->unit, packetSize, 4, 5, 6);
  1157. packetSize = -2;
  1158. goto doneGet;
  1159. }
  1161.     /* copy separated frame to network buffer */
  1163.     len = packetSize;
  1164.     if ((pSrc+packetSize) > (char *)(pDrvCtrl->memAddr + (ULTRA_PSTOP << 8)))
  1165. {
  1166. wrapSize = (char *)(pDrvCtrl->memAddr + (ULTRA_PSTOP << 8)) - pSrc;
  1167. bcopy (pSrc, pDst, wrapSize);
  1168. len -= wrapSize;
  1169. pSrc = (char *) (pDrvCtrl->memAddr + (ULTRA_PSTART << 8));
  1170. pDst += wrapSize;
  1171. }
  1172.     bcopy (pSrc, pDst, len);
  1173.     
  1174.     DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraPacketGet: c/n=%x/%x len/next=%d/%xn",
  1175.      (int) DEV_NAME, pDrvCtrl->unit,
  1176.      pDrvCtrl->current, pDrvCtrl->nextPacket,
  1177.      (((UINT)pH->uppByteCnt << 8) + pH->lowByteCnt), pH->next);
  1178.  
  1179. doneGet:
  1180.     /* Mark packet as received. */
  1182.     oldLevel = intLock ();
  1183.     pDrvCtrl->nextPacket = pH->next;
  1184.     pDrvCtrl->uppByteCnt = pH->uppByteCnt;
  1186.     if (pDrvCtrl->nextPacket != ULTRA_PSTART)
  1187. SYS_OUT_BYTE (pDrvCtrl, LAN_BOUND, pDrvCtrl->nextPacket - 1);
  1188.     else
  1189. SYS_OUT_BYTE (pDrvCtrl, LAN_BOUND, ULTRA_PSTOP - 1);
  1190.     intUnlock (oldLevel);
  1192.     return (packetSize);
  1193.     }
  1195. /******************************************************************************
  1196. *
  1197. * ultraRecv - process the next incoming packet.
  1198. *
  1199. * Handle one incoming packet.  The packet is checked for errors.
  1200. *
  1201. * RETURNS: OK or ERROR.
  1202. */
  1204. LOCAL STATUS ultraRecv
  1205.     (
  1206.     ULTRA_DEVICE * pDrvCtrl /* interrupting device */
  1207.     )
  1208.     {
  1209.     int len;
  1210.     char * pBuf;
  1211.     CL_BLK_ID pClBlk;
  1212.     M_BLK_ID pMblk;      /* MBLK to send upstream */
  1214.     /* Allocate an MBLK, and a replacement buffer */
  1215.     pBuf = netClusterGet (pDrvCtrl->endObj.pNetPool, pDrvCtrl->clPoolId);
  1216.     if (!pBuf)
  1217. {
  1218. DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraRecv: Out of clusters!n",
  1219.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1220. pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1221. pDrvCtrl->lastError.pMesg = "out of clusters";
  1222. muxError (&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1223. return (ERROR);
  1224. }
  1226.     /* Read in offset packet so IP header is long-aligned */
  1228.     len = ultraPacketGet (pDrvCtrl, pBuf + pDrvCtrl->offset);
  1229.     if (len <= 0)
  1230. {
  1231. DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraRecv: bad packet (%d)n",
  1232.  (int) DEV_NAME, pDrvCtrl->unit, len, 0, 0, 0);
  1233. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1234. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *) pBuf);
  1235. return (OK);
  1236. }
  1238.     pMblk = mBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA);
  1239.     if (!pMblk)
  1240. {
  1241. DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraRecv: out of M blocksn",
  1242.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1243. pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1244. pDrvCtrl->lastError.pMesg = "out of M blocks.";
  1245. muxError (&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1246. END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);
  1247. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *) pBuf);
  1248. return (OK);
  1249. }
  1250.     pClBlk = netClBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT);
  1251.     if (!pClBlk)
  1252. {
  1253. DRV_LOG (DRV_DEBUG_RX, "%s%d: ultraRecv: out of CL blocksn",
  1254.  (int) DEV_NAME, pDrvCtrl->unit, 0, 0, 0, 0);
  1255. pDrvCtrl->lastError.errCode = END_ERR_WARN;
  1256. pDrvCtrl->lastError.pMesg = "out of CL blocks.";
  1257. muxError (&pDrvCtrl->endObj, &pDrvCtrl->lastError);
  1258. netMblkFree (pDrvCtrl->endObj.pNetPool, (M_BLK_ID)pMblk);
  1259. netClFree (pDrvCtrl->endObj.pNetPool, (UCHAR *) pBuf);
  1260. return (OK);
  1261. }
  1263.     /* Associate the data pointer with the MBLK */
  1264.     netClBlkJoin (pClBlk, pBuf, ULTRA_BUFSIZ, NULL, 0, 0, 0);
  1265.     
  1266.     /* Associate the data pointer with the MBLK */
  1267.     netMblkClJoin (pMblk, pClBlk);
  1269.     pMblk->mBlkHdr.mFlags |= M_PKTHDR;
  1270.     pMblk->mBlkHdr.mLen    = len;
  1271.     pMblk->mBlkPktHdr.len  = len;
  1272.     pMblk->mBlkHdr.mData  += pDrvCtrl->offset; /* match ultraPacketGet */
  1274.     /* Call the upper layer's receive routine. */
  1276.     END_RCV_RTN_CALL (&pDrvCtrl->endObj, pMblk);
  1278.     /* Record received packet */
  1280.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_UCAST, +1);
  1282.     return (OK);
  1283.     }
  1285. /******************************************************************************
  1286. *
  1287. * ultraHandleRcvInt - task level interrupt service for input packets
  1288. *
  1289. * This routine is called at task level indirectly by the interrupt
  1290. * service routine to do any message received processing.
  1291. *
  1292. * RETURNS: N/A.
  1293. */
  1295. LOCAL void ultraHandleRcvInt
  1296.     (
  1297.     ULTRA_DEVICE * pDrvCtrl /* interrupting device */
  1298.     )
  1299.     {
  1300.     DRV_LOG (DRV_DEBUG_RX,
  1301.      "%s%d: ultraHandleRcvInt: begin, flags=%x curr=%x next=%xn",
  1302.      (int) DEV_NAME, pDrvCtrl->unit,
  1303.      pDrvCtrl->flags, pDrvCtrl->current, pDrvCtrl->nextPacket, 6);
  1305.     while (TRUE)
  1306. {
  1307. int oldLevel;
  1308.     
  1309. /* Refresh the current pointer, and check if done. */
  1311. oldLevel = intLock ();
  1312. SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS0);
  1313. SYS_IN_BYTE (pDrvCtrl, LAN_CURR, &pDrvCtrl->current);
  1314. SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, 0);
  1315. if (pDrvCtrl->nextPacket == pDrvCtrl->current)
  1316.     {
  1317.     /* all packets consumed. */
  1318.     pDrvCtrl->flags &= ~ULTRA_RCV_HANDLING_FLAG;
  1319.     intUnlock (oldLevel);
  1320.     break;
  1321.     }
  1322. intUnlock (oldLevel);
  1323. if (ultraRecv (pDrvCtrl) == ERROR)
  1324.     {
  1325.     /*
  1326.      * ultraRecv only errors if out of clusters or the like.  We
  1327.      * need to exit this loop and let the netTask run for a bit
  1328.      * in order for it to clean up its memory.
  1329.      */
  1330.     oldLevel = intLock ();
  1331.     pDrvCtrl->flags &= ~ULTRA_RCV_HANDLING_FLAG;
  1332.     intUnlock (oldLevel);
  1333.     break;
  1334.     }
  1335. }
  1337.     DRV_LOG (DRV_DEBUG_RX,
  1338.      "%s%d: ultraHandleRcvInt: done, flags=%x curr=%x next=%xn",
  1339.      (int) DEV_NAME, pDrvCtrl->unit,
  1340.      pDrvCtrl->flags, pDrvCtrl->current, pDrvCtrl->nextPacket, 6);
  1341.     }
  1343. /******************************************************************************
  1344. *
  1345. * ultraSend - the driver send routine
  1346. *
  1347. * This routine takes a M_BLK_ID sends off the data in the M_BLK_ID.
  1348. * The buffer must already have the addressing information properly installed
  1349. * in it.  This is done by a higher layer.  The last arguments are a free
  1350. * routine to be called when the device is done with the buffer and a pointer
  1351. * to the argument to pass to the free routine.  
  1352. *
  1353. * RETURNS: OK or ERROR.
  1354. */
  1356. LOCAL STATUS ultraSend
  1357.     (
  1358.     void * pObj, /* device ptr */
  1359.     M_BLK_ID pMblk /* data to send */
  1360.     )
  1361.     {
  1362.     int oldLevel;
  1363.     int len;
  1364.     UINT transmitPage;
  1365.     char * pBuf;
  1366.     ULTRA_DEVICE * pDrvCtrl = (ULTRA_DEVICE *) pObj;
  1367.        
  1368.     /*
  1369.      * Obtain exclusive access to transmitter.  This is necessary because
  1370.      * we might have more than one stack transmitting at once.
  1371.      */
  1373.     if (!(pDrvCtrl->flags & ULTRA_POLLING))
  1374. END_TX_SEM_TAKE (&pDrvCtrl->endObj, WAIT_FOREVER);
  1376.     if (pDrvCtrl->flags & ULTRA_TX_IN_PROGRESS)
  1377. {
  1378. int cnt;
  1380. /*
  1381.  * Wait up to 1 second. Testing on a slow 486 pc platform this
  1382.  * loop never waited more than 2 ticks at 60/sec.
  1383.  */
  1384. cnt = sysClkRateGet ();
  1385. while ((pDrvCtrl->flags & ULTRA_TX_IN_PROGRESS) && (cnt-- > 0))
  1386.     taskDelay (1);
  1387. DRV_LOG (DRV_DEBUG_TX,
  1388.  "%s%d: ultraSend: TX_IN_PROGRESS: waited %d ticksn",
  1389.  (int) DEV_NAME, pDrvCtrl->unit,
  1390.  sysClkRateGet() - cnt, 0, 0, 0);
  1391. }
  1393.     /* If TX still in progress, note blocked and return ERROR */
  1394.     oldLevel = intLock ();
  1395.     if (pDrvCtrl->flags & ULTRA_TX_IN_PROGRESS)
  1396. {
  1397. DRV_LOG (DRV_DEBUG_TX, "%s%d: ultraSend: TX_IN_PROGRESS (flags=%x)n",
  1398.  (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->flags, 4, 5, 6);
  1399. pDrvCtrl->flags |= ULTRA_TX_BLOCKED;
  1400. if (!(pDrvCtrl->flags & ULTRA_POLLING))
  1401.     END_TX_SEM_GIVE (&pDrvCtrl->endObj);
  1402. intUnlock (oldLevel);
  1403.         return (END_ERR_BLOCK);
  1404. }
  1405.     intUnlock (oldLevel);
  1407.     /* Copy and free the MBLK */
  1409.     transmitPage = pDrvCtrl->transmitPage [pDrvCtrl->transmitCnt & 1];
  1410.     pBuf = (char *)(pDrvCtrl->memAddr + (transmitPage << 8));
  1412.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1413.     len = max (len, ETHERSMALL);
  1414.     netMblkClChainFree (pMblk);
  1416.     DRV_LOG (DRV_DEBUG_TX, "%s%d: ultraSend, packet %d, len=%dn",
  1417.      (int) DEV_NAME, pDrvCtrl->unit, pDrvCtrl->transmitCnt, len, 5, 6);
  1418.     
  1419.     /* Flush the write pipe */
  1421.     CACHE_PIPE_FLUSH ();
  1422.    
  1423.     /* Transfer to the device and mark TX in progress. */
  1425.     oldLevel = intLock ();
  1426.     SYS_OUT_BYTE (pDrvCtrl, LAN_TSTART, transmitPage);
  1427.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCNTH, len >> 8);
  1428.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCNTL, len & 0xff);
  1429.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_TXP);
  1430.     pDrvCtrl->transmitCnt++;
  1431.     pDrvCtrl->flags |= ULTRA_TX_IN_PROGRESS;
  1432.     intUnlock (oldLevel);
  1434.     /* update statistics */
  1436.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1438.     /* Release semaphore */
  1440.     if (!(pDrvCtrl->flags & ULTRA_POLLING))
  1441. END_TX_SEM_GIVE (&pDrvCtrl->endObj);
  1443.     return (OK);
  1444.     }
  1445.   
  1446. /******************************************************************************
  1447. *
  1448. * ultraIoctl - the driver I/O control routine
  1449. *
  1450. * Process an ioctl request.
  1451. *
  1452. * RETURNS: A command specific response, usually OK or ERROR.
  1453. */
  1455. LOCAL int ultraIoctl
  1456.     (
  1457.     void * pObj, /* device receiving command */
  1458.     int cmd, /* ioctl command code */
  1459.     caddr_t data /* command argument */
  1460.     )
  1461.     {
  1462.     long value;
  1463.     int error = 0;
  1464.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device receiving command */
  1465.     
  1466.     switch ((UINT)cmd)
  1467.          {
  1468.         case EIOCSADDR:
  1469.     if (data == NULL)
  1470. return (EINVAL);
  1471.             bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->endObj),
  1472.    END_HADDR_LEN(&pDrvCtrl->endObj));
  1473.             break;
  1475.         case EIOCGADDR:
  1476.     if (data == NULL)
  1477. return (EINVAL);
  1478.             bcopy ((char *)END_HADDR(&pDrvCtrl->endObj), (char *)data,
  1479.    END_HADDR_LEN(&pDrvCtrl->endObj));
  1480.             break;
  1482.         case EIOCSFLAGS:
  1483.     value = (long)data;
  1484.     if (value < 0)
  1485. {
  1486. value = -value;
  1487. value--;
  1488. END_FLAGS_CLR (&pDrvCtrl->endObj, value);
  1489. }
  1490.     else
  1491. {
  1492. END_FLAGS_SET (&pDrvCtrl->endObj, value);
  1493. }
  1494.     ultraConfig (pDrvCtrl);
  1495.             break;
  1497.         case EIOCGFLAGS:
  1498.     *(int *)data = END_FLAGS_GET(&pDrvCtrl->endObj);
  1499.             break;
  1501. case EIOCPOLLSTART: /* Begin polled operation */
  1502.     ultraPollStart (pDrvCtrl);
  1503.     break;
  1505. case EIOCPOLLSTOP: /* Ultra polled operation */
  1506.     ultraPollStop (pDrvCtrl);
  1507.     break;
  1509.         case EIOCGMIB2: /* return MIB information */
  1510.             if (data == NULL)
  1511.                 return (EINVAL);
  1512.             bcopy ((char *)&pDrvCtrl->endObj.mib2Tbl, (char *)data,
  1513.    sizeof(pDrvCtrl->endObj.mib2Tbl));
  1514.             break;
  1516.         case EIOCGFBUF: /* return minimum First Buffer for chaining */
  1517.             if (data == NULL)
  1518.                 return (EINVAL);
  1519.             *(int *)data = ULTRA_MIN_FBUF;
  1520.     break;
  1522.         case EIOCGHDRLEN:
  1523.             if (data == NULL)
  1524.                 return (EINVAL);
  1525.             *(int *)data = SIZEOF_ETHERHEADER;
  1526.             break;
  1528.         default:
  1529.             error = EINVAL;
  1530.         }
  1532.     return (error);
  1533.     }
  1535. /******************************************************************************
  1536. *
  1537. * ultraAddrFilterSet - set the address filter for multicast addresses
  1538. *
  1539. * This routine goes through all of the multicast addresses on the list
  1540. * of addresses (added with the ultraMCastAdd() routine) and sets the
  1541. * device's filter correctly.
  1542. *
  1543. * RETURNS: N/A.
  1544. */
  1546. LOCAL void ultraAddrFilterSet
  1547.     (
  1548.     ULTRA_DEVICE * pDrvCtrl /* device pointer */
  1549.     )
  1550.     {          
  1551.     int len;
  1552.     int count;
  1553.     u_char c;
  1554.     u_char * pCp;
  1555.     u_long crc;
  1556.     ETHER_MULTI * pCurr;
  1558.     pDrvCtrl->mcastFilter[0] = 0x00;
  1559.     pDrvCtrl->mcastFilter[1] = 0x00;
  1560.     pDrvCtrl->mcastFilter[2] = 0x00;
  1561.     pDrvCtrl->mcastFilter[3] = 0x00;
  1562.     pDrvCtrl->mcastFilter[4] = 0x00;
  1563.     pDrvCtrl->mcastFilter[5] = 0x00;
  1564.     pDrvCtrl->mcastFilter[6] = 0x00;
  1565.     pDrvCtrl->mcastFilter[7] = 0x00;
  1567.     for (pCurr = END_MULTI_LST_FIRST (&pDrvCtrl->endObj);
  1568.  pCurr != NULL;
  1569.  pCurr = END_MULTI_LST_NEXT(pCurr))
  1570. {
  1571. /*
  1572.  * AUTODIN-II, adapted for ethernet (bit reversed),
  1573.  * taken from the ln7990End.c driver
  1574.  */
  1575. pCp = (unsigned char *)&pCurr->addr;
  1576. crc = 0xffffffff;
  1577. for (len = 6; --len >= 0;)
  1578.     {
  1579.     c = *pCp++;
  1580.     for (count = 0; count < 8; count++)
  1581. {
  1582. if ((c & 0x01) ^ (crc & 0x01))
  1583.     {
  1584.     crc >>= 1;
  1585.     crc = crc ^ 0xedb88320;
  1586.     }
  1587. else
  1588.     {
  1589.     crc >>= 1;
  1590.     }
  1591. c >>= 1;
  1592. }
  1593.     }
  1595. /* Just want the 6 most significant bits. */
  1596. crc = crc >> 26;
  1598. /* Turn on the corresponding bit in the filter. */
  1599. pDrvCtrl->mcastFilter [crc >> 3] |= (1 << (crc & 0x07));
  1600. }
  1601.     }
  1603. /*****************************************************************************
  1604. *
  1605. * ultraMCastAdd - add a multicast address for the device
  1606. *
  1607. * This routine adds a multicast address to whatever the driver
  1608. * is already listening for.  It then resets the address filter.
  1609. *
  1610. * RETURNS: OK or ERROR.
  1611. */
  1613. LOCAL STATUS ultraMCastAdd
  1614.     (
  1615.     void * pObj, /* device pointer */
  1616.     char * pAddress /* new address to add */
  1617.     )
  1618.     {     
  1619.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device pointer */
  1621.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraMCastAddn",
  1622.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1624.     if (etherMultiAdd (&pDrvCtrl->endObj.multiList, pAddress) == ENETRESET)
  1625. ultraConfig (pDrvCtrl);
  1627.     return (OK);
  1628.     }
  1630. /*****************************************************************************
  1631. *
  1632. * ultraMCastDel - delete a multicast address for the device
  1633. *
  1634. * This routine removes a multicast address from whatever the driver
  1635. * is listening for.  It then resets the address filter.
  1636. *
  1637. * RETURNS: OK or ERROR.
  1638. */
  1640. LOCAL STATUS ultraMCastDel
  1641.     (
  1642.     void * pObj, /* device pointer */
  1643.     char * pAddress /* address to be deleted */
  1644.     )
  1645.     {
  1646.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device pointer */
  1648.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraMCastDeln",
  1649.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1651.     if (etherMultiDel (&pDrvCtrl->endObj.multiList, pAddress) == ENETRESET)
  1652. ultraConfig (pDrvCtrl);
  1654.     return (OK);
  1655.     }
  1657. /*****************************************************************************
  1658. *
  1659. * ultraMCastGet - get the multicast address list for the device
  1660. *
  1661. * This routine gets the multicast list of whatever the driver
  1662. * is already listening for.
  1663. *
  1664. * RETURNS: OK or ERROR.
  1665. */
  1667. LOCAL STATUS ultraMCastGet
  1668.     (
  1669.     void * pObj, /* device pointer */
  1670.     MULTI_TABLE * pTable /* address table to be filled in */
  1671.     )
  1672.     {     
  1673.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device pointer */
  1675.     return (etherMultiGet (&pDrvCtrl->endObj.multiList, pTable));
  1676.     }
  1678. /******************************************************************************
  1679. *
  1680. * ultraUnload - unload a driver from the system
  1681. *
  1682. * This function first brings down the device, and then frees any
  1683. * stuff that was allocated by the driver in the load function.
  1684. *
  1685. * RETURNS: OK or ERROR.
  1686. */
  1688. LOCAL STATUS ultraUnload
  1689.     (
  1690.     void * pObj /* device to be unloaded */
  1691.     )
  1692.     {     
  1693.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device to be unloaded */
  1695.     DRV_LOG (DRV_DEBUG_LOAD, "%s%d: ultraUnloadn",
  1696.      (int) DEV_NAME, pDrvCtrl->unit,
  1697.      3, 4, 5, 6);
  1699.     END_OBJECT_UNLOAD (&pDrvCtrl->endObj);
  1701.     return (OK);
  1702.     }
  1705. /******************************************************************************
  1706. *
  1707. * ultraPollStart - start polled mode operations
  1708. *
  1709. * RETURNS: OK or ERROR.
  1710. */
  1712. LOCAL STATUS ultraPollStart
  1713.     (
  1714.     ULTRA_DEVICE * pDrvCtrl
  1715.     )
  1716.     {     
  1717.     int oldLevel;
  1719.     DRV_LOG (DRV_DEBUG_POLL, "%s%d: ultraPollStartn",
  1720.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1722.     oldLevel = intLock ();
  1723.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK, 0x00);
  1724.     pDrvCtrl->flags |= ULTRA_POLLING;
  1725.     intUnlock (oldLevel);
  1727.     return (OK);
  1728.     }
  1730. /******************************************************************************
  1731. *
  1732. * ultraPollStop - stop polled mode operations
  1733. *
  1734. * This function terminates polled mode operation.  The device returns to
  1735. * interrupt mode.
  1736. *
  1737. * The device interrupts are enabled, the current mode flag is switched
  1738. * to indicate interrupt mode and the device is then reconfigured for
  1739. * interrupt operation.
  1740. *
  1741. * RETURNS: OK or ERROR.
  1742. */
  1744. LOCAL STATUS ultraPollStop
  1745.     (
  1746.     ULTRA_DEVICE * pDrvCtrl
  1747.     )
  1748.     {     
  1749.     int oldLevel;
  1751.     DRV_LOG (DRV_DEBUG_POLL, "%s%d: ultraPollStopn",
  1752.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1754.     oldLevel = intLock ();
  1755.     SYS_OUT_BYTE (pDrvCtrl, LAN_INTMASK,
  1756.   IM_OVWE | IM_TXEE | IM_PTXE | IM_PRXE);
  1757.     pDrvCtrl->flags &= ~ULTRA_POLLING;
  1758.     intUnlock (oldLevel);
  1760.     return (OK);
  1761.     }
  1763. /******************************************************************************
  1764. *
  1765. * ultraPollRcv - routine to receive a packet in polled mode.
  1766. *
  1767. * This routine is called by a user to try and get a packet from the
  1768. * device.
  1769. *
  1770. * RETURNS: OK upon success.  EAGAIN is returned when no packet is available.
  1771. */
  1773. LOCAL STATUS ultraPollRcv
  1774.     (
  1775.     void * pObj, /* device to be polled */
  1776.     M_BLK_ID pMblk /* ptr to buffer */
  1777.     )
  1778.     {
  1779.     int len;
  1780.     ULTRA_DEVICE * pDrvCtrl = pObj; /* device to be polled */
  1782.     /* Don't call DRV_LOG until past the busy-wait */
  1784.     /* If no packet is available, return immediately */
  1786.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_PS0);
  1787.     SYS_IN_BYTE (pDrvCtrl, LAN_CURR, &pDrvCtrl->current);
  1788.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, 0);
  1789.     if (pDrvCtrl->nextPacket == pDrvCtrl->current)
  1790.         return (EAGAIN);
  1792.     DRV_LOG (DRV_DEBUG_POLL_RX, "%s%d: ultraPollRcvn",
  1793.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1795.     /* Upper layer must provide a valid buffer. */
  1797.     if ((pMblk->mBlkHdr.mLen < ULTRA_MAX_SIZE)
  1798. || !(pMblk->mBlkHdr.mFlags & M_EXT))
  1799. {
  1800.         DRV_LOG (DRV_DEBUG_POLL_RX,
  1801.  "%s%d: ultraPollRecv: bad mblk, mLen=%d mFlags=%xn",
  1802.  (int) DEV_NAME, pDrvCtrl->unit,
  1803.  pMblk->mBlkHdr.mLen, pMblk->mBlkHdr.mFlags, 5, 6);
  1804. return (EAGAIN);
  1805. }
  1807.     /* Process device packet into net buffer */
  1809.     pMblk->mBlkHdr.mData += pDrvCtrl->offset;
  1810.     len = ultraPacketGet (pDrvCtrl, pMblk->mBlkHdr.mData);
  1812.     pMblk->mBlkHdr.mFlags |= M_PKTHDR; /* set the packet header */
  1813.     pMblk->mBlkHdr.mLen = len; /* set the data len */
  1814.     pMblk->mBlkPktHdr.len = len; /* set the total len */
  1816.     DRV_LOG (DRV_DEBUG_POLL_RX, "%s%d: ultraPollRcv done, len=%dn",
  1817.      (int) DEV_NAME, pDrvCtrl->unit, len, 4, 5, 6);
  1819.     return (OK);
  1820.     }
  1822. /******************************************************************************
  1823. *
  1824. * ultraPollSend - routine to send a packet in polled mode.
  1825. *
  1826. * This routine is called by a user to try and send a packet on the
  1827. * device.  As this is a single-transmit device, we actually wait
  1828. * for the previous transmit to complete, otherwise parts of the
  1829. * packet may be dropped.
  1830. *
  1831. * RETURNS: OK upon success.  EAGAIN if device is busy.
  1832. */
  1834. LOCAL STATUS ultraPollSend
  1835.     (
  1836.     void * pObj, /* device to be polled */
  1837.     M_BLK_ID pMblk /* packet to send */
  1838.     )
  1839.     {
  1840.     UCHAR cmdStat;
  1841.     int len;
  1842.     UINT transmitPage;
  1843.     char * pBuf;
  1844.     ULTRA_DEVICE * pDrvCtrl = pObj;
  1846.     DRV_LOG (DRV_DEBUG_POLL_TX, "%s%d: ultraPollSendn",
  1847.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1849.     /* Wait for the last transmit to complete */
  1851.     do
  1852. SYS_IN_BYTE (pDrvCtrl, LAN_CMD, &cmdStat);
  1853.     while (cmdStat & CMD_TXP);
  1855.     /* Process the net buffer into a device transmit packet */
  1857.     transmitPage = pDrvCtrl->transmitPage [pDrvCtrl->transmitCnt & 1];
  1858.     pBuf = (char *)(pDrvCtrl->memAddr + (transmitPage << 8));
  1859.     len = netMblkToBufCopy (pMblk, pBuf, NULL);
  1860.     len = max (len, ETHERSMALL);
  1862.     DRV_LOG (DRV_DEBUG_POLL_TX, "%s%d: ultraPollSend: len=%dn",
  1863.      (int) DEV_NAME, pDrvCtrl->unit, len, 4, 5, 6);
  1865.     /* Flush the write pipe */
  1867.     CACHE_PIPE_FLUSH ();
  1868.    
  1869.     /* Transfer to the device */
  1871.     SYS_OUT_BYTE (pDrvCtrl, LAN_TSTART, transmitPage);
  1872.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCNTH, len >> 8);
  1873.     SYS_OUT_BYTE (pDrvCtrl, LAN_TCNTL, len & 0xff);
  1874.     SYS_OUT_BYTE (pDrvCtrl, LAN_CMD, CMD_TXP);
  1875.     pDrvCtrl->transmitCnt++;
  1877.     /* Bump the statistic counter. */
  1879.     END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1);
  1881.     DRV_LOG (DRV_DEBUG_POLL_TX, "%s%d: ultraPollSend: donen",
  1882.      (int) DEV_NAME, pDrvCtrl->unit, 3, 4, 5, 6);
  1884.     return (OK);
  1885.     }