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

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

VxWorks

开发平台：

C/C++

pkLib.c：源码内容
  1. /* pkLib.c - BSP PortKit Validation Suite support routines */
  3. /* Copyright 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02c,20jun02,jtp  evaluate config.h macros at runtime (SPR #78881).
  10. 02b,24jan02,pmr  using volatile declarations for for-loop-generated delays.
  11. 02a,22jan02,pmr  fixed non-ANSI compliant code in pkTimestampTestLong();
  12.  corrected use of NULL; fixed warnings.
  13. 01z,12dec01,pch  Don't use strncmp on binary data; make NvRam buffers global
  14.  to assist debugging.
  15. 01y,16oct99,sbs  corrected documentation.
  16. 01x,30sep99,sbs  changed pkUdpEchoT function arguments (SPR #27842).
  17.                  added pkCatastrophicTest and pkCatastrophicClean to fix
  18.                  problems with error2 test and wtxtcl (SPR #27822).
  19. 01w,23feb99,sbs  added pkPrintTest1 and made some changes to make
  20.                  VTS compatible with Tornado 2.0 (SPR #22425).
  21. 01v,22jul98,sbs  added htons() for port assignment in pkUdpEchoT().
  22.                  (SPR #20680)
  23. 01u,27may98,dat  removed ARM specific changes 01s and 01t.
  24. 01t,27apr98,cdp  make ARM pkTestNvRam buffers static to avoid stack overflow.
  25. 01s,09apr98,cdp  fix buffer alignment for ARM in pkTestNvRam.
  26. 01r,21oct97,db   fixed retrial of UDP packets in pkUdpEchoT().
  27. 01q,04sep97,sbs  added pkPrintSerialOutput, pkSerialTestInit, pkSerialTest
  28.                  and pkSerChanOutput.
  29. 01p,28aug97,sbs  addded pkBusErrorTest for error1 test and changed scsi
  30.                  routines to handle a larger buffer size.
  31. 01o,21aug97,db   renamed pkUdpEchoTest to pkUdpEchoT. added error handling.
  32. 01n,31jul97,db   included pingLib.h.
  33. 01m,19jul97,db   added pkTimestampTestShort and pkTimestampTestLong(timestamp
  34.  test), pkUdpEchoTest and pkPing (network test) and pkIntGet
  35.  and pkIntSet(busTas test). Removed conditional includes of
  36.  header files and macros.
  37. 01l,24jun97,sbs  added pkPrintTest() and pkDivideZeroTest() for serial line
  38.                  testing and divide by zero testing respectively.
  39. 01k,02jun97,sbs  changed sp() in pkLoopbackTest to taskSpawn().
  40. 01j,02aug96,mas  added support for BSP-specific TAS clear routine in busTas.
  41. 01i,15jun96,dat  changed calc of # scsi blks to avoid overflow.
  42. 01h,15feb96,dat  limited pkRead to less than 512K cycles.
  43.  Changed pkGetMacroValue to do a table walk.
  44. 01h,02dec93,dzb  added pkTimestampTest().
  45. 01g,05may93,dzb  combined pkGet<macro>()'s into pkGetMacroValue().
  46.                  integrated serial loopback and network udp echo tests.
  47.  added multiple serial loopback test.  ANSIfied.
  48.  added serial console echo test.  removed pkTasInit().
  49.  removed cache coherency code from busTas test.
  50.            +caf  wrote sequential serial loopback test.
  51.    +rfs  wrote pkUdpEchod().
  52. 01f,19feb93,dzb  doc fixes.  included additional header files.
  53.  added support for non-writeable nvram. fixed ANSI warnings.
  54.  added check for existing physical SCSI device.
  55.            +caf  changed VOID to void. changed READ to VX_READ. changed WRITE
  56.  to VX_WRITE. changed copyright notice. fixed ANSI warnings.
  57.  changed bitBucket from char to long in pkRead().
  58. 01d,30apr92,caf  added pkTestNvRam().
  59. 01c,07apr92,caf  don't #include header files when building documentation.
  60. 01b,31mar92,caf  added pkGet...() routines to read macros compiled into BSP.
  61.                  changed copyright notice. changed void to VOID.
  62.                  added routines for SCSI write/read/verify test.
  63.                  added routines for sysBusTas() test.
  64. 01a,01mar92,caf  written.
  65. */
  67. /*
  68. DESCRIPTION
  69. This library contains support routines for the BSP Developer's kit
  70. Validation Test Suite.
  72. This module should be copied in the BSP directory (with sysLib.c,
  73. config.h, etc.) and compiled by simply typing:
  75.     % make pkLib.o
  77. Alternatively, this module may be linked in with the VxWorks image during
  78. compilation.  This can be done by either adding "pkLib.o" to the MACH_EXTRA
  79. macro in the makefiles, or by including "ADDED_MODULES=pkLib.o" on the command
  80. line when building the VxWorks image.  This approach is necessary when using
  81. standalone ROMS without network initialization, as pkLib.o cannot be
  82. downloaded to the target during the tests.
  84. The object module will have a couple of unresolved references, which
  85. will be resolved by linking with VxWorks running on the target, or
  86. rebuilding the VxWorks image on the host to include this module.
  88. The routines contained in this library are called by the Expect scripts
  89. during the BSP tests.  They contain operations that cannot be executed
  90. directly from the shell by the scripts.
  91. */
  93. /* includes */
  95. #ifndef DOC
  97. #include "vxWorks.h"
  98. #include "vxLib.h"
  99. #include "ioLib.h"
  100. #include "taskLib.h"
  101. #include "sysLib.h"
  102. #include "cacheLib.h"
  103. #include "string.h"
  104. #include "stdio.h"
  105. #include "config.h"
  106. #include "usrLib.h"
  107. #include "sockLib.h"
  108. #include "logLib.h"
  109. #include "in.h"
  110. #include "intLib.h"
  111. #include "tickLib.h"
  112. #include "semLib.h"
  113. #include "wdLib.h"
  114. #include "pingLib.h"
  115. #include "selectLib.h"
  117. #include <sys/types.h>
  118. #include <sys/socket.h>
  119. #include <netinet/in.h>
  120. #include <time.h>
  121. #include <signal.h>
  123. /* header files used by timestamp test */
  125. #include "drv/timer/timestampDev.h"
  126. #include "intLib.h"
  127. #include "tickLib.h"
  129. /* header file used by scsi test */
  131. #include "scsiLib.h"
  133. #ifdef INCLUDE_SM_NET
  134. IMPORT VOIDFUNCPTR smUtilTasClearRtn;
  135. #endif /* INCLUDE_SM_NET */
  137. #endif /* DOC */
  139. /* defines */
  141. #define PK_LOOP_PAT_LEN (255) /* length of loopback ASCII pattern */
  142. #define PK_LOOP_OUT_LEN (300) /* length of loopback output buffer */
  143. #define PK_LOOP_TASK_NUM (4) /* num of multiple loopback tasks */
  144. #define PK_READ_MAX_TESTS (128*1024) /* max number of pkRead tests */
  145. #define PK_TS_ERR               1.0      /* acceptable timestamp % error */
  146. #define MIN(X,Y) (((X) < (Y)) ? (X) : (Y))
  148. #define PK_MAX_SER_STR          20      /* max strings to receive(serial test)*/
  149. #define PK_MAX_STR              20      /* max string length */
  151. #define PATTERN_INC_LAW 0
  153. /* values used to prefill RW_TEST_UNIT */
  155. #define DEF_BUF_SIZE  (64 * 1024) /* default buffer size (64K) */
  156. #define DEF_LAW PATTERN_INC_LAW /* incremental law */
  157. #define ST_PATTERN 0xa5a5a5a5 /* start pattern */
  158. #define DEF_NB_BUF 1 /* write one buffer */
  160. /* get field from SCSI_BLK_DEV to SCSI_PHYS_DEV */
  162. #define BLK_TO_PHYS(p,tag) (((SCSI_BLK_DEV*)p)->pScsiPhysDev->tag)
  164. /* check for bad buffer size */
  166. #define  IF_BAD_BUFSIZE(pBlkDev,size) 
  167.          if ((size % ((SCSI_BLK_DEV*)pBlkDev)->pScsiPhysDev->blockSize) != 0)
  169. typedef union /* equivalence int char[] */
  170.     {
  171.     int ival;
  172.     UINT8 uint8val[4];
  173.     } EQUI_INT_UINT8;
  175. typedef struct /* structure used to start a RW test */
  176.     {
  177.     /* value to initialize to start the test */
  179.     BLK_DEV *pBlk; /* pointer to the block device to test */
  180.     UINT8 *ptR; /* pointer to the read Buffer */
  181.     UINT8 *ptW; /* pointer to the write Buffer */
  182.     UINT32 size; /* buffer size to use */
  183.     int nbBuf; /* # of buffer to write/Read */
  184.     int law; /* law use to fill the patterns */
  185.     int stBlk; /* # of the first block to start */
  186.     int nbLoop; /* # of loop for the test */
  187.     int startPattern; /* value for the first pattern */
  189.     /* local value use by the routine useful for post checking */
  191.     TBOOL abort; /* flag to abort the test */
  192.     TBOOL abortOnError; /* stop at the first error */
  193.     int countErr; /* error counter */
  194.     int curStartPattern; /* first pattern to fill buffers */
  195.     int curPattern; /* current pattern  used */
  196.     int curCycle; /* # of Current cycle executed */
  197.     int curBuf; /* # of Current buffer tested */
  198.     int curBlk; /* # of the current block device */
  199.     } RW_TEST_UNIT;
  201. /* defines used by pkUdpEchoT */
  203. #define MAX_PKT         4096            /* largest packet used */
  204. #define N_SIZES         16              /* number of different packet sizes */
  205. #define RESEND 1 /* times to resend before error */
  207. #ifndef IPPORT_ECHO
  208. #define IPPORT_ECHO 7 /* standard UDP echo port */
  209. #endif
  212. /* globals */
  214. int pkLoopbackAbort = 0; /* non-zero for loopback task exit */
  215. int pkMultiLoopCount [NUM_TTY][PK_LOOP_TASK_NUM]; /* multi loopback data */
  216. int pkSeqLoopCount [NUM_TTY][2]; /* seq loopback data */
  217. int pkLoopFd [NUM_TTY]; /* array of loopback serial dev desc */
  218. int pkLoopTask [NUM_TTY]; /* count of multi loopback tasks */
  219. int pkLoopInit = 0; /* init loopback data arrays ? */
  220. SEM_ID  tsTmoSem;                       /* ID of timestamp timeout semaphore */
  221. WDOG_ID tsTmoWd;                        /* ID of timestamp timeout watchdog */
  222. int tsInit=FALSE; /* TRUE if tsTmoSem and tsTmoWd exist */
  223. char    pkSerChanInput[PK_MAX_SER_STR][PK_MAX_STR]; /* serial I/O string array */
  224. int     pkSerChanAbort=0;               /* non-zero for serial I/O task exit */
  225. int     pkConsoleEchoAbort = 0 ;
  229. RW_TEST_UNIT testUnit; /* accessible from VxWorks shell */
  230. RW_TEST_UNIT *pTestUnit = &testUnit;    /* pointer to testUnit */
  232. /* Globals for udpEchod */
  234. int flagInitUdp = FALSE;
  235. int     skt1 = -1;                  /* socket descriptor */
  236. struct  sockaddr_in sin;
  237. struct  sockaddr_in from;
  238. static  char buf [MAX_PKT];           /* pkt buffer */
  240. /* Globals for udpEchoTest */
  242. int    resendCnt = 0; /* times a single packet was resent */
  243. int    resendTotal = 0; /* total number of packets resent */
  244. int    packetTMO; /* packet timeout before resending */
  245. int    packetNum; /* current packet number being sent */
  246. int    curPktSiz;                       /* current packet size sent/received */
  247. int    skt;                             /* socket descriptor */
  248. int    sktAddrLen;                      /* length of socket addr */
  249. struct sockaddr_in serv_addr;           /* target socket data */
  250. char   dataOut [MAX_PKT];               /* outgoing pkt buf */
  251. char   dataIn  [MAX_PKT];               /* incoming pkt buf */
  253. int    pktSizes [N_SIZES] =
  254.     {
  255.     128, 256, 512, 768,
  256.     1024, 1280, 1536, 1792,
  257.     2048, 2304, 2560, 2816,
  258.     3072, 3328, 3584, 3840
  259.     };                                  /* various packet sizes */
  262. /* locals */
  264. LOCAL int loopState [NUM_TTY]; /* current state of seq loopback input */
  266. /* forward declarations */
  268. STATUS pkRead();
  269. void pkIncrement();
  270. int     pkGetMacroValue();
  271. void    pkTasTest();
  272. STATUS  pkTestRamByte();
  273. STATUS pkConsoleEcho();
  274. LOCAL BOOL pkMultiLoopHook();
  275. LOCAL BOOL pkSeqLoopHook();
  276. STATUS pkLoopbackTest();
  277. STATUS pkSeqLoopShow();
  278. STATUS pkMultiLoopShow();
  279. STATUS pkUdpEchod();
  280. void pkUdpInit();
  281.         STATUS  pkTimestampTest();
  282. STATUS  pkTimestampTestShort();
  283. void    pkTimestampTestLong();
  284.         STATUS  pkTimestampTestInit();
  285.         void    pkPrintTest();
  286.         void    pkDivideZeroTest();
  287. int pkIntGet();
  288. void pkIntSet();
  289. STATUS pkTestNvRam();
  290. STATUS pkBufFillPattern();
  291. STATUS pkBlkWrite();
  292. STATUS pkBlkRead();
  293. STATUS pkTestUnit();
  294. STATUS pkTestOneUnit();
  295.         void    pkSerialTest();
  296.         void    pkSerChanOutput();
  299. /*******************************************************************************
  300. *
  301. * pkRead - probe memory from start to end <length> bytes at a time
  302. *
  303. * This routine probes memory from the start address to the end address
  304. * using vxMemProbe(), <length> bytes at a time.  As soon as an error is
  305. * detected, the routine returns an ERROR.
  306. *
  307. * RETURNS: OK, or ERROR if <startAdrs> through (<endAdrs> - 1) not readable.
  308. */
  310. STATUS pkRead
  311.     (
  312.     char *startAdrs, /* start of range to test */
  313.     char *endAdrs, /* end of range to test   */
  314.     int length /* 1, 2, or 4 bytes       */
  315.     )
  316.     {
  317.     char * loopAdrs;
  318.     long bitBucket;
  319.     STATUS retValue = OK;
  320.     int increment = 1;
  321.     int size;
  323.     size = ((UINT)endAdrs - (UINT)startAdrs) / length;
  325.     /* limit the number of test cycles */
  326.     if (size >= (UINT)PK_READ_MAX_TESTS)
  327. increment = (size / (UINT)PK_READ_MAX_TESTS) * 2;
  329.     for (loopAdrs = startAdrs;
  330. loopAdrs < endAdrs;
  331. loopAdrs += (length * increment))
  332. {
  333. if (vxMemProbe (loopAdrs, VX_READ, length, (char *) &bitBucket)
  334.     == ERROR)
  335.     {
  336.     /* probe caused a bus error or address misalignment */
  337.     retValue = ERROR;
  338.     break;
  339.     }
  340. }
  342.     return retValue;
  343.     }
  345. /*******************************************************************************
  346. *
  347. * pkIncrement - increment a counter
  348. *
  349. * This routine adds one to the integer pointed to by <pCount>.
  350. *
  351. * RETURNS: N/A
  352. */
  354. void pkIncrement
  355.     (
  356.     int *pCount /* address to increment */
  357.     )
  358.     {
  359.     ++ *pCount;
  360.     }
  362. /*******************************************************************************
  363. *
  364. * pkGetMacroValue - read a macro value
  365. *
  366. * This routine returns the value of the macro associated with <macroName>,
  367. * else the value -1 (ERROR) is returned.
  368. *
  369. * RETURNS: Value associated with macroName, or ERROR (-1).
  370. */
  372. int pkGetMacroValue
  373.     (
  374.     char *macroName /* name of desired macro */
  375.     )
  376.     {
  377.     /*
  378.      * Note: since the config macros may contain an expression that does
  379.      * not have a constant integer value, it is important to evaluate
  380.      * them inline here, rather than place them in a static array
  381.      * initializer, which would be evaluated only at compile time.
  382.      */
  384. #ifdef LOCAL_MEM_LOCAL_ADRS
  385.     if (strcmp (macroName, "LOCAL_MEM_LOCAL_ADRS") == 0)
  386. return (int)LOCAL_MEM_LOCAL_ADRS;
  387. #endif
  388. #ifdef ROM_BASE_ADRS
  389.     if (strcmp (macroName, "ROM_BASE_ADRS") == 0)
  390. return (int)ROM_BASE_ADRS;
  391. #endif
  392. #ifdef ROM_SIZE
  393.     if (strcmp (macroName, "ROM_SIZE") == 0)
  394. return (int)ROM_SIZE;
  395. #endif
  396. #ifdef NV_RAM_SIZE
  397.     if (strcmp (macroName, "NV_RAM_SIZE") == 0)
  398. return (int)NV_RAM_SIZE;
  399. #endif
  400. #ifdef CONSOLE_TTY
  401.     if (strcmp (macroName, "CONSOLE_TTY") == 0)
  402. return (int)CONSOLE_TTY;
  403. #endif
  404. #ifdef SLIP_TTY
  405.     if (strcmp (macroName, "SLIP_TTY") == 0)
  406. return (int)SLIP_TTY;
  407. #endif
  408. #ifdef SYS_CLK_RATE_MIN
  409.     if (strcmp (macroName, "SYS_CLK_RATE_MIN") == 0)
  410. return (int)SYS_CLK_RATE_MIN;
  411. #endif
  412. #ifdef SYS_CLK_RATE_MAX
  413.     if (strcmp (macroName, "SYS_CLK_RATE_MAX") == 0)
  414. return (int)SYS_CLK_RATE_MAX;
  415. #endif
  416. #ifdef AUX_CLK_RATE_MIN
  417.     if (strcmp (macroName, "AUX_CLK_RATE_MIN") == 0)
  418. return (int)AUX_CLK_RATE_MIN;
  419. #endif
  420. #ifdef AUX_CLK_RATE_MAX
  421.     if (strcmp (macroName, "AUX_CLK_RATE_MAX") == 0)
  422. return (int)AUX_CLK_RATE_MAX;
  423. #endif
  424. #ifdef EXC_MSG_ADRS
  425.     if (strcmp (macroName, "EXC_MSG_ADRS") == 0)
  426. return (int)EXC_MSG_ADRS;
  427. #endif
  428. #ifdef PK_LOOP_TASK_NUM
  429.     if (strcmp (macroName, "PK_LOOP_TASK_NUM") == 0)
  430. return (int)PK_LOOP_TASK_NUM;
  431. #endif
  433.     return (int)ERROR;
  434.     }
  436. /*******************************************************************************
  437. *
  438. * pkTasTest - test-and-set test
  439. *
  440. * This routine, in conjunction with another pkTasTest() task, tests the
  441. * test-and-set mechanism.  Both tasks (each on a separate target board)
  442. * spin on the semaphore pointed to by <semaphore> using sysBusTas() for
  443. * mutual exclusion.  When this routine gets the semaphore, it increments
  444. * the <count> if it matches <odd>.  It then enters a busy-wait loop
  445. * <delay> times, giving the other task a chance to take the semaphore.
  446. * It may be necessary to tune this task by increasing or decreasing <delay
  447. * if one task (board) is much faster than the other.
  448. *
  449. * RETURNS: N/A (does not return)
  450. */
  452. void pkTasTest
  453.     (
  454.     char *semaphore, /* semaphore to spin on */
  455.     UINT32 *count, /* counter address */
  456.     BOOL odd, /* odd/even assignment */
  457.     UINT32 delay /* delay so other task gets time */
  458.     )
  459.     {
  460.     volatile UINT32 busyWait;
  462.     taskDelay (sysClkRateGet ()); /* wait 1 second */
  464.     FOREVER
  465. if (sysBusTas (semaphore))
  466.     {
  467.     /* check <odd> and bump counter if matches */
  469.     if ((((* count) & 1) && odd) || ((!((* count) & 1)) && !odd))
  470. (* count) ++;
  472. #ifdef INCLUDE_SM_NET
  473.     /* use the utility routine, if available */
  475.     if (smUtilTasClearRtn != NULL)
  476. (smUtilTasClearRtn)(semaphore);
  477.     else
  478. #endif /* INCLUDE_SM_NET */
  480.     * semaphore = 0;
  482.     /* enter busy-wait loop to give other task a chance */
  484.     for (busyWait = 0; busyWait < delay; busyWait ++)
  485. ; /* wait */
  486.     }
  487.     }
  489. /*******************************************************************************
  490. *
  491. * pkTestRamByte - test read and write access to one byte of RAM
  492. *
  493. * This routine uses vxMemProbe() to check that <adrs> may be written to
  494. * and read from.
  495. *
  496. * RETURNS: OK, or ERROR if <adrs> is not both readable and writable.
  497. */
  498. STATUS pkTestRamByte
  499.     (
  500.     char *adrs /* address to test */
  501.     )
  502.     {
  503.     char testR; /* scratchpad for read */
  504.     char write1; /* 1st value to write  */
  505.     char write2; /* 2nd value to write  */
  507.     (void) vxMemProbe (adrs, VX_READ, 1, &write2); /* save current value  */
  508.     write1 = (write2 == 3) ? 1 : 3; /* write1 != write2    */
  510.     return ((vxMemProbe (adrs, VX_WRITE, 1, &write1) != OK) ||
  511.     (vxMemProbe (adrs, VX_READ, 1, &testR) != OK)   ||
  512.     (testR != write1)                               ||
  513.     (vxMemProbe (adrs, VX_WRITE, 1, &write2) != OK) ||
  514.     (vxMemProbe (adrs, VX_READ, 1, &testR) != OK)   ||
  515.     (testR != write2)) ? ERROR : OK;
  516.     }
  518. #ifdef NV_RAM_SIZE
  520. char vtsOrigBootLine [NV_RAM_SIZE + 2]; /* original boot line */
  521. unsigned char vtsNvRamBuf1 [NV_RAM_SIZE + 2]; /* scratch buffer 1   */
  522. unsigned char vtsNvRamBuf2 [NV_RAM_SIZE + 2]; /* scratch buffer 2   */
  524. /*******************************************************************************
  525. *
  526. * pkTestNvRam - collection of non-volatile RAM tests
  527. *
  528. * This routine contains several tests to check the board's non-volatile
  529. * RAM.  The parameter <testNum> indicates which test will be run.
  530. *
  531. * If the macro NV_RAM_SIZE_WRITEABLE is defined, only that number of bytes
  532. * is used for tests which write to nvram.
  533. *
  534. * The tests in this routine write and read various patterns to and from nvram,
  535. * making sure no errors are detected.  Additionally, parameter checking is
  536. * performed on the sysNvRamGet() and sysNvRamSet() routines.
  537. *
  538. * RETURNS: OK, or ERROR if <testNum> is invalid or the test fails.
  539. */
  541. STATUS pkTestNvRam
  542.     (
  543.     int testNum /* test number (1-8) */
  544.     )
  545.     {
  546.     static int          writeableSize; /* writeable nvram sz */
  547.     FAST int ii; /* scratch loop index */
  548.     STATUS retValue = ERROR; /* return value       */
  549.     int offset = -NV_BOOT_OFFSET; /* offset to nv start */
  551. #ifdef NV_RAM_SIZE_WRITEABLE
  552.     writeableSize=NV_RAM_SIZE_WRITEABLE;
  553. #else /* NV_RAM_SIZE_WRITEABLE */
  554.     writeableSize=NV_RAM_SIZE;
  555. #endif /* NV_RAM_SIZE_WRITEABLE */
  557.     if (writeableSize > NV_RAM_SIZE)
  558.         return(retValue);
  559.     switch (testNum)
  560. {
  561. case 1: /* sysNvRamGet() of boot line */
  562.     {
  563.     if (sysNvRamGet((char *)vtsNvRamBuf1, NV_RAM_SIZE, offset) == ERROR)
  564. break;
  566.             /* store the original bootline */
  568.     bcopy ((char *) vtsNvRamBuf1, (char *) vtsNvRamBuf2, NV_RAM_SIZE);
  569.     bcopy ((char *) vtsNvRamBuf1, vtsOrigBootLine, NV_RAM_SIZE);
  571.             for (ii = 0; ii < NV_RAM_SIZE; ii ++) /* complement string */
  572.                 vtsNvRamBuf1 [ii] ^= 0xff;
  574.     (void) sysNvRamGet ((char *) vtsNvRamBuf1, NV_RAM_SIZE, offset);
  576.     if (memcmp((char *)vtsNvRamBuf1, (char *)vtsNvRamBuf2, NV_RAM_SIZE)
  577. == 0)
  578. retValue = OK;
  580.     break;
  581.     }
  583. case 2: /* sysNvRamSet() and sysNvRamGet() of complemented boot line  */
  584.     {
  585.     if (sysNvRamGet((char *)vtsNvRamBuf1, NV_RAM_SIZE, offset) == ERROR)
  586. break;
  588.             for (ii = 0; ii < NV_RAM_SIZE; ii ++) /* complement string */
  589.                 vtsNvRamBuf1 [ii] ^= 0xff;
  591.     if (sysNvRamSet((char *)vtsNvRamBuf1, writeableSize, offset)
  592. == ERROR)
  593. break;
  595.     (void) sysNvRamGet ((char *) vtsNvRamBuf2, NV_RAM_SIZE, offset);
  597.     if (memcmp((char *)vtsNvRamBuf1,(char *)vtsNvRamBuf2, writeableSize)
  598. == 0)
  599. retValue = OK;
  601.     break;
  602.     }
  604. case 3: /* sysNvRamGet() with length zero */
  605.     {
  606.     if (NV_RAM_SIZE < 3)
  607. break;
  609.     vtsNvRamBuf1 [0] = '1';
  610.     vtsNvRamBuf1 [1] = '2';
  611.     vtsNvRamBuf1 [2] = '3';
  613.     if (sysNvRamGet ((char *) (vtsNvRamBuf1 + 1), 0, offset) == ERROR)
  614. break;
  616.     /* verify a zero in vtsNvRamBuf [1], while vtsNvRamBuf [0] and vtsNvRamBuf [2] unchanged  */
  618.     if ((vtsNvRamBuf1 [0] == '1') && (vtsNvRamBuf1 [1] == 0)
  619. && (vtsNvRamBuf1 [2] == '3'))
  620. retValue = OK;
  622.     break;
  623.     }
  625. case 4: /* sysNvRamSet() parameter checking */
  626.     {
  627.     if ((sysNvRamSet((char *)vtsNvRamBuf1, -1, offset)    == ERROR) &&
  628. (sysNvRamSet((char *)vtsNvRamBuf1, 0, offset - 1) == ERROR) &&
  629. (sysNvRamSet((char *)vtsNvRamBuf1, writeableSize + 1, offset)
  630.   == ERROR) &&
  631. (sysNvRamSet((char *)vtsNvRamBuf1,0, offset + writeableSize + 1)
  632.   == ERROR) &&
  633. (sysNvRamSet((char *)vtsNvRamBuf1, writeableSize / 2 + 1,
  634.       offset + (writeableSize / 2) + 1)   == ERROR))
  635. {
  636. retValue = OK;
  637. }
  638.     break;
  639.     }
  641. case 5: /* sysNvRamGet() parameter checking */
  642.     {
  643.     if ((sysNvRamGet((char *)vtsNvRamBuf1, -1, offset)    == ERROR) &&
  644. (sysNvRamGet((char *)vtsNvRamBuf1, 0, offset - 1) == ERROR) &&
  645. (sysNvRamGet((char *)vtsNvRamBuf1, NV_RAM_SIZE + 1, offset)
  646.   == ERROR) &&
  647. (sysNvRamGet((char *)vtsNvRamBuf1, 0, offset + NV_RAM_SIZE + 1)
  648.   == ERROR) &&
  649. (sysNvRamGet((char *)vtsNvRamBuf1, NV_RAM_SIZE / 2 + 1,
  650.       offset + (NV_RAM_SIZE / 2) + 1)   == ERROR))
  651. {
  652. retValue = OK;
  653. }
  654.     break;
  655.     }
  657. case 6: /* sysNvRamSet() and sysNvRamGet() of 0xff data */
  658.     {
  659.     if (writeableSize < 4)
  660. break;
  662.     vtsNvRamBuf1 [0] = vtsNvRamBuf1 [1]
  663.     = vtsNvRamBuf1 [2] = vtsNvRamBuf1 [3] = 0xff;
  664.     vtsNvRamBuf2 [0] = vtsNvRamBuf2 [1]
  665.     = vtsNvRamBuf2 [2] = vtsNvRamBuf2 [3] = 0x55;
  667.     if (sysNvRamSet ((char *) vtsNvRamBuf1, 4, offset) == ERROR)
  668. break;
  670.     if (sysNvRamGet ((char *) vtsNvRamBuf2, 3, offset) == ERROR)
  671. break;
  673.     if ((vtsNvRamBuf2 [0] == 0xff) && (vtsNvRamBuf2 [1] == 0xff) &&
  674. (vtsNvRamBuf2 [2] == 0xff) && (vtsNvRamBuf2 [3] == 0x00))
  675. {
  676. retValue = OK;
  677. }
  678.     break;
  679.     }
  681. case 7: /* sysNvRamSet() and sysNvRamGet() of 0x00 data */
  682.     {
  683.     if (writeableSize < 4)
  684. break;
  686.     vtsNvRamBuf1 [0] = vtsNvRamBuf1 [1]
  687.     = vtsNvRamBuf1 [2] = vtsNvRamBuf1 [3] = 0x00;
  688.     vtsNvRamBuf2 [0] = vtsNvRamBuf2 [1]
  689.     = vtsNvRamBuf2 [2] = vtsNvRamBuf2 [3] = 0xff;
  691.     if (sysNvRamSet ((char *) vtsNvRamBuf1, 4, offset) == ERROR)
  692. break;
  694.     if (sysNvRamGet ((char *) vtsNvRamBuf2, 3, offset) == ERROR)
  695. break;
  697.     if ((vtsNvRamBuf2 [0] == 0x00) && (vtsNvRamBuf2 [1] == 0x00) &&
  698. (vtsNvRamBuf2 [2] == 0x00) && (vtsNvRamBuf2 [3] == 0x00))
  699. {
  700. retValue = OK;
  701. }
  702.     break;
  703.     }
  705. case 8: /* sysNvRamSet() and sysNvRamGet() of boot line */
  706.     {
  707.     if (sysNvRamSet (vtsOrigBootLine, writeableSize, offset) == ERROR)
  708. break;
  710.     if (sysNvRamGet((char *)vtsNvRamBuf1, NV_RAM_SIZE, offset) == ERROR)
  711. break;
  713.     if (memcmp(vtsOrigBootLine, (char *)vtsNvRamBuf1, writeableSize)
  714. == 0)
  715. retValue = OK;
  717.     break;
  718.     }
  720. default:
  721.     {
  722.     break;
  723.     }
  724. }
  725.     return (retValue);
  726.     }
  728. #endif /* NV_RAM_SIZE */
  730. /*******************************************************************************
  731. *
  732. * pkConsoleEcho - routine to put console into echo mode
  733. *
  734. * This routine puts the serial console in raw mode, then turns on the character
  735. * echo mode bit.  The console will remain in echo mode until <numToEcho>
  736. * characters have been echoed, or an "eof" (ASCII 0x04) is received.  If
  737. * <numToEcho> is zero, the only way to exit echo mode is to send an "eof".
  738. *
  739. * RETURNS: OK or ERROR.
  740. */
  742. STATUS pkConsoleEcho
  743.     (
  744.     int numToEcho /* number of characters to echo (0 means infinite) */
  745.     )
  746.     {
  747.     if (numToEcho < 0)
  748. {
  749. printf ("pkConsoleEcho: invalid parametern");
  750. return (ERROR);
  751. }
  753.     /* set the serial console to echo chars */
  755.     (void) ioctl (0, FIOSETOPTIONS, OPT_RAW);
  756.     (void) ioctl (1, FIOSETOPTIONS, OPT_RAW);
  757.     (void) ioctl (0, FIOSETOPTIONS, OPT_ECHO);
  759.     /* continue to echo until <numToEcho> exhausted or "eof" received  */
  761.       while ( ! pkConsoleEchoAbort)
  762. {
  763.         getc(stdin) ;
  764. if (numToEcho)
  765.     if (-- numToEcho == 0)
  766. break;
  767.         }
  769.     /* reset the console back to terminal mode */
  771.     (void) ioctl (0, FIOSETOPTIONS, OPT_TERMINAL);
  772.     (void) ioctl (1, FIOSETOPTIONS, OPT_TERMINAL);
  774.     return (OK);
  775.     }
  777. /*******************************************************************************
  778. *
  779. * pkSeqLoopHook - sequential serial loopback test input hook routine
  780. *
  781. * This routine monitors serial inputs for the sequential serial loopback test.
  782. * Whenever a character is written to serial port <channel>, this routine is
  783. * called.  It updates the count of characters written to <channel> and checks
  784. * that <inChar> matches the expected character from the sequential pattern
  785. * being sent in pkLoopbackTest(0,X,X,X).
  786. *
  787. * RETURNS: TRUE.
  788. */
  790. LOCAL BOOL pkSeqLoopHook
  791.     (
  792.     int channel, /* channel number */
  793.     int inChar /* input character */
  794.     )
  795.     {
  796.     char matchChar; /* expected input character */
  798.     if ((channel >= 0) && (channel < NUM_TTY))
  799. {
  800. ++ pkSeqLoopCount [channel][0]; /* bump character counter */
  802. /* find next character in pattern, and bump state counter */
  804. if (loopState [channel] < PK_LOOP_OUT_LEN - 1)
  805.     matchChar = 0x00 + ((loopState [channel] ++) % PK_LOOP_PAT_LEN);
  806. else
  807.     {
  808.     /* output buffer turned over */
  810.     matchChar = '0' + (channel % 10); /* '0' ... '9' */
  811.     loopState [channel] = 0;
  812.     }
  814. if (inChar != matchChar) /* mismatch? */
  815.     {
  816.     ++ pkSeqLoopCount [channel][1]; /* bump error counter */
  817.             loopState [channel]++; /* compensate for dropped char */
  818.             }
  819. }
  820.     return (TRUE); /* no further processing of the character */
  821.     }
  823. /*******************************************************************************
  824. *
  825. * pkMultiLoopHook - multiple loopback test input hook routine
  826. *
  827. * This routine monitors serial inputs for the multiple serial loopback test.
  828. * Whenever a character is written to serial port <channel>, this routine is
  829. * called.  It updates the count of characters written to <channel> from the
  830. * task (pkLoopbackTest(1,X,X,X)) associated with <inChar>.
  831. *
  832. * RETURNS: TRUE.
  833. */
  835. LOCAL BOOL pkMultiLoopHook
  836.     (
  837.     int channel, /* channel number */
  838.     int inChar /* input character */
  839.     )
  840.     {
  841.     int offset; /* offset to access correct data location */
  843.     if ((channel >= 0) && (channel < NUM_TTY))
  844. {
  845. offset = inChar - 'A';
  846. ++ pkMultiLoopCount [channel][offset]; /* bump character counter */
  847. }
  849.     return (TRUE); /* no further processing of the character */
  850.     }
  852. /*******************************************************************************
  853. *
  854. * pkLoopbackTest - loopback test routine
  855. *
  856. * This routine is called to perform either one of two tests, based upon
  857. * the value of <mTest>.
  858. *
  859. * If <mTest> is 0, the sequential serial loopback test is run.  This test will
  860. * write a sequential pattern of characters over and over, until <numToSend>
  861. * chars are sent. If <numToSend>=0, then an infinite number of chars are sent.
  862. * Characters are sent at <baud> baud rate to serial port <channel>.
  863. *
  864. * Else, if <mTest> is 1, the multiple serial test is started.  This test will
  865. * recursively call pkLoopbackTest() until PK_LOOP_TASK_NUM number of calls
  866. * have taken place.  Each call results in a task that will write <numToSend>
  867. * unique characters to serial port <channel> at baud rate <baud>.
  868. * If <numToSend>=0, then an infinite number of chars are sent.  The initial
  869. * pkLoopbackTest opens the file descriptor to the serial port, makes the
  870. * recursive calls, waits for the other tasks to end, and then closes the file
  871. * descriptor.
  872. *
  873. * NOTE: Transmission will abort if the global variable <pkLoopbackAbort> is
  874. * set to a non-zero value.
  875. *
  876. * RETURNS: OK or ERROR.
  877. */
  879. STATUS pkLoopbackTest
  880.     (
  881.     int mTest, /* 0 = sequential test, 1 = multiple task test */
  882.     int channel, /* channel number to test */
  883.     int baud, /* baud rate for test */
  884.     int numToSend /* number of chars to send (0 means infinite) */
  885.     )
  886.     {
  887.     char loopName [10]; /* more than enough chars for "tyCo/NN" */
  888.     char inBuf;         /* one character input buffer */
  889.     char letterL = 'L'; /* one character output buffer */
  890.     char outBuf [PK_LOOP_OUT_LEN]; /* loopback pattern output buffer */
  891.     int  call=0; /* number of tasks open in multiple test */
  892.     int  loopFd; /* file descriptor for <channel> */
  893.     int  mule; /* scratch */
  894.     int  numSent=0; /* characters sent so far in loop */
  896.     /* check for valid parameters */
  898.     if ((channel == CONSOLE_TTY) || (channel < 0) || (channel >= NUM_TTY) ||
  899.         (baud == 0) || (numToSend < 0) || ((mTest != 0) && (mTest != 1)))
  900. {
  901. printf ("pkLoopbackTest: Error: invalid parametern");
  902. return (ERROR);
  903. }
  905.     /* if running multiple loopback test, initialize data structures (once) */
  907.     if (mTest == 1)
  908. {
  909.         if (pkLoopInit == 0)
  910.             {
  911.     pkLoopInit = 1;
  912.       for (mule = 0; mule < NUM_TTY; mule ++)
  913.           pkLoopTask [mule] = 0;
  914.             }
  915. #if (PK_LOOP_TASK_NUM < 1)
  916. printf ("pkLoopbackTest: Error: set for too few tasksn");
  917. return (ERROR);
  918. #else /* PK_LOOP_TASK_NUM */
  920.         /* increment number of multiple loopback tasks open */
  922.         call = pkLoopTask [channel] ++;
  923. #endif /* PK_LOOP_TASK_NUM */
  924.   }
  926.     /* on first call of multiple - always on sequential */
  928.     if (call == 0)
  929. {
  930. /* open file descriptor for the loopback device */
  932.         sprintf (loopName,"/tyCo/%d",channel);
  933.         pkLoopFd [channel] = open (loopName, O_RDWR, 0);
  934. loopFd = pkLoopFd [channel];
  935.         if (loopFd == ERROR)
  936.     {
  937.     printf ("pkLoopbackTest: Error: failed to open %sn", loopName);
  938.     return (ERROR);
  939.     }
  941.         /* set baud and mode, flush the buffers */
  943.         (void) ioctl (loopFd, FIOBAUDRATE, baud);
  944.         (void) ioctl (loopFd, FIOSETOPTIONS, OPT_RAW);
  945.         (void) ioctl (loopFd, FIOFLUSH, 0);
  947.         /* verify loopback operation (one character not counted in <numSent>) */
  949.         inBuf = ~letterL; /* inBuf differs from outBuf */
  950.         (void) write (loopFd, &letterL, 1); /* send a char */
  951.         taskDelay (sysClkRateGet() / 4); /* allow time for loopback */
  953.         (void) ioctl (loopFd, FIONREAD, (int) (&mule)); /* any character? */
  954.         if (mule == 1)
  955.     (void) read (loopFd, &inBuf, 1); /* read it */
  957.         if (inBuf != letterL) /* mismatch? */
  958.     {
  959.     printf ("pkLoopbackTest: Error: loopback connection failedn");
  960.     (void) close (loopFd);
  961.     return (ERROR);
  962.     }
  964.        /* declare argument to be passed to protocol hook - the channel # */
  966.         (void) ioctl (loopFd, FIOPROTOARG, channel);
  968.         /* clear input counters for this channel (in case we've run before) */
  970. if (mTest == 0)
  971.     {
  972.     /* attach hook for receiving chars */
  974.             (void) ioctl (loopFd, FIOPROTOHOOK, (int) pkSeqLoopHook);
  975.     pkSeqLoopCount [channel][0] = 0;
  976.     pkSeqLoopCount [channel][1] = 0;
  977.     }
  978.         else
  979.     {
  980.     /* attach hook for receiving chars */
  982.             (void) ioctl (loopFd, FIOPROTOHOOK, (int) pkMultiLoopHook);
  983.     for (mule = 0; mule < PK_LOOP_TASK_NUM; mule ++)
  984.         pkMultiLoopCount [channel][mule] = 0;
  985.     }
  987.         loopState [channel] = 0;
  988.         }
  989.     else
  990.        loopFd = pkLoopFd [channel];
  992.     /* initialize output buffer */
  994.     if (mTest == 0)
  995.         {
  996.         for (mule = 0; mule < PK_LOOP_OUT_LEN - 1; mule ++)
  997.             outBuf [mule] = 0x00 + (mule % PK_LOOP_PAT_LEN); /* 'A' ... 'Z' */
  998.         outBuf [mule] = '0' + (channel % 10);               /* '0' ... '9' */
  999.         }
  1000.     else
  1001. {
  1002.         for (mule = 0; mule < PK_LOOP_OUT_LEN; mule ++)
  1003.             outBuf [mule] = 'A' + call; /* 'A' ... 'Z' */
  1005.         /* start another loopback task for multiple loopback test */
  1007.         if (call < (PK_LOOP_TASK_NUM - 1))
  1008.               taskSpawn (NULL, 100, VX_FP_TASK, 20000, pkLoopbackTest, 1,
  1009.                (int) channel, (int) baud, (int) numToSend, (int) NULL,
  1010.                (int) NULL, (int) NULL, (int) NULL, (int) NULL, (int) NULL);
  1011. }
  1013.     /* write the characters out */
  1015.     while ((numSent < numToSend) || (numToSend == 0))
  1016. {
  1017. /* check abort flag */
  1019. if (pkLoopbackAbort)
  1020.     break;
  1022. /* write the output buffer */
  1024. if (numToSend)
  1025.     mule = MIN (PK_LOOP_OUT_LEN, numToSend - numSent);/* # bytes? */
  1026.         else
  1027.     mule = PK_LOOP_OUT_LEN;
  1028. (void) write (loopFd, outBuf, mule);
  1029. numSent += mule;
  1030. }
  1032.     /* wait for i/o to complete */
  1034.     if (mTest == 1)
  1035. pkLoopTask [channel] --;
  1037.     if (call == 0)
  1038.         {
  1039.         do
  1040.             {
  1041.             taskDelay (sysClkRateGet() / 4);
  1042.             (void) ioctl (loopFd, FIONWRITE, (int) (&mule)); /* wait for out */
  1043.             } while (mule != 0);
  1044.         taskDelay (sysClkRateGet());
  1046.         /* the first multiple task waits for all other multiple tasks to end */
  1048.         if (mTest == 1)
  1049.             while (pkLoopTask [channel] != 0)
  1050.                 taskDelay (sysClkRateGet());
  1052.         (void) ioctl (loopFd, FIOPROTOHOOK, 0);
  1053.         (void) close (loopFd);
  1054.         }
  1056.     return (OK);
  1057.     }
  1059. /*******************************************************************************
  1060. *
  1061. * pkSeqLoopShow - display results of sequential loopback test
  1062. *
  1063. * This routine displays the data generated from running the sequential serial
  1064. * loopback test (pkLoopbackTest(0,X,X,X)).  The output consists of a count
  1065. * of characters written to serial port <channel> during the test.  Included is
  1066. * a count of errors encountered (an error was recorded any time a character
  1067. * was received out of order).
  1068. *
  1069. * RETURNS: OK or ERROR.
  1070. */
  1072. STATUS pkSeqLoopShow
  1073.     (
  1074.     int channel /* serial channel */
  1075.     )
  1076.     {
  1077.     if ((channel == CONSOLE_TTY) || (channel < 0) || (channel >= NUM_TTY))
  1078. {
  1079. printf ("pkSeqLoopShow: Error: invalid parametern");
  1080. return (ERROR);
  1081. }
  1082.     printf ("characters = %dn", pkSeqLoopCount [channel][0]);
  1083.     printf ("errors = %dn", pkSeqLoopCount [channel][1]);
  1084.     printf ("OKn");
  1085.     return (OK);
  1086.     }
  1088. /*******************************************************************************
  1089. *
  1090. * pkMultiLoopShow - display results of multiple loopback test
  1091. *
  1092. * This routine displays the data generated from running the multiple serial
  1093. * loopback test (pkLoopbackTest(1,X,X,X)).  The output consists of a list
  1094. * of tasks and the number of characters each task has written to the
  1095. * serial port specified by <channel>.
  1096. *
  1097. * RETURNS: OK or ERROR.
  1098. */
  1100. STATUS pkMultiLoopShow
  1101.     (
  1102.     int channel /* serial channel */
  1103.     )
  1104.     {
  1105.     int mule; /* task counter */
  1107.     if ((channel == CONSOLE_TTY) || (channel < 0) || (channel >= NUM_TTY))
  1108. {
  1109. printf ("pkMultiLoopShow: Error: invalid parametern");
  1110. return (ERROR);
  1111. }
  1112.     else
  1113.         {
  1114.         for (mule = 0; mule < PK_LOOP_TASK_NUM; mule ++)
  1115.             {
  1116.             printf ("task = %d    ", mule + 1);
  1117.     printf ("count = %dn", pkMultiLoopCount [channel][mule]);
  1118.     }
  1119.         printf ("OKn");
  1120.         }
  1122.     return (OK);
  1123.     }
  1125. /*******************************************************************************
  1126. *
  1127. * pkUdpEchod - echo daemon for UDP packets
  1128. *
  1129. * This routine is an echo daemon for UDP/IP networking packets.  Packets
  1130. * up to 4096 bytes are read in from port 7 (the standard UDP echo port) and
  1131. * then are written back to port 7.
  1132. *
  1133. * The function pkUdpInit() is called to create a socket and bind it.
  1134. *
  1135. * RETURNS: does not return unless error (error number given)
  1136. */
  1138. int pkUdpEchod (void)
  1139.     {
  1140.     int cnt;                     /* size of packet received */
  1141.     int fromLen;                 /* size of host sock structure */
  1143.     fromLen = sizeof(from);
  1145.     if (!flagInitUdp)
  1146.      {
  1147.      pkUdpInit();
  1148.      }
  1150.     /* loop, reading from socket, and echoing */
  1152.     while (1)
  1153.         {
  1154.         cnt = recvfrom (skt1, (char *) buf, sizeof (buf), 0,
  1155. (struct sockaddr *) &from, &fromLen);
  1156.         if (cnt > 0)
  1157.             sendto (skt1, (char *) buf, cnt, 0, (struct sockaddr *) &from,
  1158.     sizeof (from));
  1159.         }
  1160.     }
  1163. /*******************************************************************************
  1164. *
  1165. * pkUdpInit - initialize socket for UDP test
  1166. *
  1167. * This routine opens a socket and binds it to port 7.
  1168. *
  1169. * RETURNS: N/A
  1170. */
  1172. void pkUdpInit (void)
  1173.     {
  1174.     int sktBufSiz;               /* size of largest packet */
  1175.     int fromLen;                 /* size of host sock structure */
  1177.     bzero ((char *) &sin, sizeof (sin));        /* clr sock addrs */
  1178.     bzero ((char *) &from, sizeof (from));
  1180.     skt1 = socket (AF_INET, SOCK_DGRAM, 0);      /* open socket */
  1182.     if (skt1 < 0)
  1183.         {
  1184.         logMsg ("pkUdpEchod: socket errorn",0,0,0,0,0,0);
  1185.         exit (1);
  1186.         }
  1188.     sin.sin_family = AF_INET;                   /* fill in our sock addr */
  1189.     sin.sin_port = htons (IPPORT_ECHO);                   /* the ECHO port */
  1191.     /* bind our sock addr */
  1193.     if (bind (skt1, (struct sockaddr *) &sin, sizeof (sin)) < 0)
  1194.         {
  1195.         logMsg ("pkUdpEchod: bind errorn",0,0,0,0,0,0);
  1196.         close (skt1);
  1197.         exit (2);
  1198.         }
  1200.     fromLen = sizeof (from);                    /* get size of sock addr */
  1202.     sktBufSiz = sizeof (buf);         /* increase size of socket buffers */
  1204.     if (setsockopt (skt1, SOL_SOCKET, SO_SNDBUF, (char *) &sktBufSiz,
  1205.         sizeof (sktBufSiz)) < 0)
  1206.         {
  1207.         close (skt1);
  1208.         logMsg ("pkUdpEchod: setsockopt errorn",0,0,0,0,0,0);
  1209.         exit (3);
  1210.         }
  1212.     if (setsockopt (skt1, SOL_SOCKET, SO_RCVBUF, (char *) &sktBufSiz,
  1213.         sizeof (sktBufSiz)) < 0)
  1214.         {
  1215.         close (skt1);
  1216.         logMsg ("pkUdpEchod: setsockopt errorn",0,0,0,0,0,0);
  1217.         exit (4);
  1218.         }
  1219.     flagInitUdp = TRUE;
  1221.     }
  1223. #ifdef INCLUDE_TIMESTAMP
  1225. /*******************************************************************************
  1226. *
  1227. * pkTimestamp - tests sysTimestamp() and sysTimestampLock()
  1228. *
  1229. * This routine calls the function sysTimestamp() or sysTimestampLock()(after
  1230. * locking interrupts) depending on the boolean parameter locked.
  1231. *
  1232. * RETURNS: tick counter value
  1233. */
  1235. UINT32 pkTimestamp
  1236.     (
  1237.     BOOL locked
  1238.     )
  1239.     {
  1240.     int lockKey;
  1241.     UINT32 tickRet;
  1243.     if (!locked)
  1244.         return (sysTimestampLock ());
  1246.     lockKey = intLock ();
  1247.     tickRet = sysTimestamp ();
  1248.     intUnlock (lockKey);
  1250.     return (tickRet);
  1251.     }
  1253. /*******************************************************************************
  1254. *
  1255. * pkTimestampRoll - returns a counter value or the current tick
  1256. *
  1257. * This routine reads the location pointed to by tickCounter if non null, or
  1258. * returns the current system clock tick.
  1259. *
  1260. * RETURNS: counter value or clock tick
  1261. */
  1263. UINT32 pkTimestampRoll
  1264.     (
  1265.     UINT *tickCounter
  1266.     )
  1267.     {
  1268.     if (tickCounter == 0)
  1269. return (tickGet());
  1270.     else
  1271. return (*tickCounter);
  1272.     }
  1275. /*******************************************************************************
  1276. *
  1277. * pkTimestampTestShort - short-term test of timestamp timer
  1278. *
  1279. * This routine performs a short-term test of the timestamp timer. It reads
  1280. * values with a delay in-between. The test is repeated up to 16 times. If
  1281. * the counter is always increasing the test is successful.
  1282. *
  1283. * RETURNS: OK if success, ERROR otherwise.
  1284. */
  1286. STATUS pkTimestampTestShort
  1287.     (
  1288.     UINT *tickCounter,
  1289.     BOOL locked
  1290.     )
  1291.     {
  1292.     UINT countVal [2];
  1293.     UINT32 tickVal [2];
  1294.     STATUS retValue = OK;
  1295.     int ix;
  1296.     volatile int iy;
  1298.     /* short term test: make sure timestamp is incrementing */
  1300.     for (ix = 0; (ix < 0x10) && (retValue == OK); ix++)
  1301.      {
  1302.         countVal [0] = pkTimestampRoll (tickCounter);
  1303.         tickVal [0]  = pkTimestamp (locked);
  1305. for (iy = 0; iy < 1000; iy++)
  1306. ;
  1308.         tickVal [1]  = pkTimestamp (locked);
  1309.         countVal [1] = pkTimestampRoll (tickCounter);
  1310. if ((tickVal [0] >= tickVal [1]) && (countVal [0] >= countVal [1]))
  1311. retValue = ERROR;
  1312. }
  1314.         return (retValue);
  1315.     }
  1318. /*******************************************************************************
  1319. *
  1320. * pkTimestampTestInit - initialize timestamp test
  1321. *
  1322. * This routine creates a semahore and a watchdog timer for the timestamp
  1323. * test. The ids are stored in two global variables and a flag is set if
  1324. * the two are created successfuly.
  1325. *
  1326. * RETURNS: OK if success, ERROR otherwise.
  1327. */
  1329. STATUS pkTimestampTestInit()
  1330.     {
  1332.     tsTmoSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
  1333.     tsTmoWd  = wdCreate ();
  1335.     if ((tsTmoSem == NULL) || (tsTmoWd == NULL))
  1336.         {
  1337.         tsInit = FALSE;
  1338.         return ERROR;
  1339.         }
  1340.     else
  1341.         {
  1342.         tsInit = TRUE;
  1343.         return OK;
  1344.         }
  1345.     }
  1349. /*******************************************************************************
  1350. *
  1351. * pkTimestampTestLong - long-term timestamp test
  1352. *
  1353. * This routine performs a long-term timestamp test.
  1354. *
  1355. * RETURNS: OK, or ERROR.
  1356. */
  1358. void pkTimestampTestLong
  1359.     (
  1360.     UINT *tickCounter,
  1361.     int timeout,
  1362.     BOOL locked,
  1363.     int nslices
  1364.     )
  1365.     {
  1366.     UINT * pCountVal = malloc (nslices * 2 * sizeof (UINT));
  1367.     UINT32 * pTickVal = malloc (nslices * 2 * sizeof (UINT32));
  1368.     UINT * pCountPtr = pCountVal;
  1369.     UINT32 * pTickPtr = pTickVal;
  1370.     UINT32 calcTicks;
  1371.     volatile UINT32 tsBucket;
  1372.     float errorVal;
  1373.     int second;
  1374.     int delay;
  1375.     int ix;
  1376.     STATUS retValue = OK;
  1378.     second = timeout / nslices;
  1379.     delay = second * sysClkRateGet();
  1380.     calcTicks = second * sysTimestampFreq();
  1382.     if (tsInit == FALSE)
  1383.         {
  1384.         if (pkTimestampTestInit() == ERROR)
  1385.          {
  1386.          printf("FAIL long-term timestamp testn");
  1387.     goto pkTimestampTestLongExit;
  1388.     }
  1389.          }
  1391.     printf ("nStarting long-term timestamp test.n");
  1392.     printf ("This test will run for approximately %.1f minute(s).nn",
  1393. (float) timeout/60);
  1395.     for (ix = 0; ix < nslices; ix++)
  1396. {
  1397.         if (wdStart (tsTmoWd, delay, semGive, (int) tsTmoSem) == ERROR)
  1398.          {
  1399.      printf("FAIL long-term timestamp testn");
  1400.         goto pkTimestampTestLongExit;
  1401. }
  1403.         *pCountPtr++ = pkTimestampRoll (tickCounter);
  1404.         *pTickPtr++ = pkTimestamp (locked);
  1406.         while ((semTake (tsTmoSem, NO_WAIT)) != OK)
  1407.     {
  1408.             taskDelay (2);
  1409.     tsBucket = pkTimestamp (locked);
  1410.     }
  1412.         *pCountPtr++ = pkTimestampRoll (tickCounter);
  1413.         *pTickPtr++ = pkTimestamp (locked);
  1415. printf ("pkTimestampTest: %d/%d through testn", (ix + 1), nslices);
  1416. }
  1418.     /* convert to total ticks */
  1420.     for (pTickPtr = pTickVal, pCountPtr = pCountVal, ix = 0; 
  1421.  ix < (nslices << 1); ix++, pTickPtr++, pCountPtr++)
  1422. {
  1423. *pTickPtr += *pCountPtr * sysTimestampPeriod();
  1424. }
  1426.     /* convert to relative ticks and compute percent error */
  1428.     printf ("ncalculated ticks: %un", calcTicks);
  1430.     pTickPtr = pTickVal;
  1432.     for (ix = 0, pCountPtr = pCountVal; ix < nslices; ix++, pCountPtr++)
  1433. {
  1435. /* the following two lines put the difference between two consecutive
  1436.  * entries in the pTickVal array into the appropriate slot in the 
  1437.  * pCountVal array.
  1438.  */
  1440. *pCountPtr = *pTickPtr++;
  1441. *pCountPtr = *pTickPtr++ - *pCountPtr;
  1443. /* calculate *percent* error */
  1444. errorVal = 100 * ((float) calcTicks - (float) *pCountPtr) /
  1445.   (float) calcTicks;
  1447. printf ("Period %d:  measured ticks: %u,  percent error: %fn",
  1448.     (ix + 1), *pCountPtr, errorVal);
  1450.         if (errorVal < 0)
  1451.     errorVal *= -1;
  1452.         if (errorVal > (float) PK_TS_ERR)
  1453.     retValue = ERROR;
  1454.         }
  1456.     if (retValue == ERROR)
  1457.      printf("FAIL: long-term timestamp testn");
  1458.     else
  1459.      printf("PASS: long-term timestamp testn");
  1461. pkTimestampTestLongExit:
  1462.     free (pCountVal);
  1463.     free (pTickVal);
  1464.     }
  1466. #endif /* INCLUDE_TIMESTAMP */
  1468. #ifdef INCLUDE_SCSI
  1470. /* the following are for testing SCSI */
  1472. /*******************************************************************************
  1473. *
  1474. * pkBufFillPattern - write a pattern to a memory buffer
  1475. *
  1476. * This routine write a pattern in a memory buffer.  <startPattern> indicates
  1477. * the
  1478. * pattern and the buffer will be fill with data0, data0+inc,....,datan+inc
  1479. * according to the filling law chosen.
  1480. *
  1481. * INTERNAL:
  1482. * Only the law with the increment 0x01010101 is implemented.
  1483. * A another law should be to write:
  1484. * data0, ~data0,data0+inc,~data0+inc, ...,datan+inc,~datan+inc.
  1485. *
  1486. * RETURNS: OK or ERROR.
  1487. */
  1489. STATUS pkBufFillPattern
  1490.     (
  1491.     UINT8 *pBuffer, /* pointer to the buffer              */
  1492.     UINT32 size, /* size in bytes of the buf to fill   */
  1493.     int law, /* rules to fill the buffer           */
  1494.     int *startPattern, /* value of the start pattern         */
  1495.     int *endPattern /* where return the end value pattern */
  1496.     )
  1497.     {
  1498.     EQUI_INT_UINT8  pattern;
  1499.     int  ix;
  1500.     int  iy;
  1501.     int  firstBlock;
  1502.     int  lastBlock;
  1503.     int * pt = (int *)pBuffer;
  1504.     UCHAR * upt;
  1506.     if (pBuffer == NULL)
  1507. return (ERROR);
  1508.     if (size < sizeof (pattern.ival))
  1509. return (ERROR);
  1510.     switch (law)
  1511. {
  1512. case PATTERN_INC_LAW:
  1513.     {
  1514.     /* incremental law */
  1516.     iy = 0;
  1517.     pattern.ival = *startPattern;
  1518.     firstBlock = size / sizeof (pattern.ival);
  1519.     lastBlock = size % sizeof (pattern.ival);
  1521.     for (ix = 0; ix <= (firstBlock-1); ix ++)
  1522. {
  1523. *pt = pattern.ival;
  1524. pattern.ival = pattern.ival + (int) 0x01010101;
  1525. pt ++;
  1526. }
  1528.     /* fill last block in byte mode if the remain modulo exist */
  1530.     ix = (ix * 4) - 1;
  1532.     upt = (UCHAR *) pt;
  1534.     while (lastBlock != 0)
  1535. {
  1536.  *upt = pattern.uint8val[ix % 4];
  1538. if ((iy % 4) == 3)
  1539.     pattern.ival = pattern.ival + 0x01010101;
  1540. ix ++;
  1541. iy ++;
  1542. upt ++;
  1544. lastBlock --;
  1545. }
  1546.     break;
  1547.     }
  1548. default:
  1549.     {
  1550.     printErr ("pkBufFillPattern: law not implemented : ERRORn");
  1551.     return (ERROR);
  1552.     }
  1553. }
  1555.     *endPattern = pattern.ival;
  1556.     return (OK);
  1557.     }
  1559. /*******************************************************************************
  1560. *
  1561. * pkBlkWrite - write blocks to a SCSI device
  1562. *
  1563. * Write a buffer to a SCSI device.  The buffer size must be a multiple
  1564. * of the block size of the device.  <blockNumber> is used both to describe
  1565. * the writing position and next free position when the function returns.
  1566. *
  1567. * RETURNS: OK, or ERROR if parameters don't match or the write failed.
  1568. */
  1570. STATUS pkBlkWrite
  1571.     (
  1572.     SCSI_BLK_DEV *pBlkDev, /* pointer to the block device     */
  1573.     char *pBuffer, /* pointer to the buffer Read      */
  1574.     UINT32 size, /* size of the pBuffer area        */
  1575.     int *blockNumber /* logical # of the block to write */
  1576.     )
  1577.     {
  1578.     int numSects;
  1579.     int secSize = BLK_TO_PHYS(pBlkDev,blockSize);
  1581.     /* check pBlkDev */
  1583.     if  (pBlkDev == (SCSI_BLK_DEV *)NULL)
  1584. {
  1585. printErr ("pkBlkWrite: pBlkDev is NULL : ERRORn");
  1586. return (ERROR);
  1587. }
  1589.     /* check for range block */
  1591.     if (((* blockNumber) > ((SCSI_BLK_DEV *) pBlkDev)->blkDev.bd_nBlocks) ||
  1592.         ((* blockNumber) < ((SCSI_BLK_DEV *) pBlkDev)->blockOffset))
  1593. {
  1594. printErr ("scsiWriteBlocks: blockNumber out of range : ERRORn");
  1595. return (ERROR);
  1596. }
  1598.     /* check if size ok */
  1600.     if (size == (int) NULL)
  1601. {
  1602.         printErr ("scsiWriteBlocks: buffer size is NULL : ERRORn");
  1603. return (ERROR);
  1604. }
  1606.     /* check if buffer size fits sector size */
  1608.     IF_BAD_BUFSIZE (pBlkDev,size)
  1609. {
  1610.         printErr ("scsiWriteBlocks: buffer size invalid : ERRORn");
  1611. return (ERROR);
  1612. }
  1614.     numSects = size / secSize;
  1616.     if (scsiWrtSecs (pBlkDev,*blockNumber,numSects, pBuffer) == ERROR)
  1617. {
  1618. printErr ("pkBlkWrite: returned ERRORn");
  1619. return (ERROR);
  1620. }
  1621.     *blockNumber = *blockNumber + numSects;
  1622.     return (OK);
  1623.     }
  1625. /*******************************************************************************
  1626. *
  1627. * pkBlkRead - read blocks from a SCSI device
  1628. *
  1629. * Read a buffer from a SCSI device.  The buffer size must be a multiple
  1630. * of the block size of the device.  <blockNumber> is used both to describe
  1631. * the reading position and next free position when the function returns.
  1632. *
  1633. * RETURNS: OK, or ERROR if parameters don't match or the read failed.
  1634. */
  1636. STATUS pkBlkRead
  1637.     (
  1638.     SCSI_BLK_DEV *pBlkDev, /* pointer to the block device     */
  1639.     char *pBuffer, /* pointer to the buffer Read      */
  1640.     UINT32 size, /* size of the pBuffer area        */
  1641.     int *blockNumber /* logical # of the block to write */
  1642.     )
  1643.     {
  1644.     int numSects;
  1645.     int secSize = BLK_TO_PHYS(pBlkDev,blockSize);
  1647.     /* check pBlkDev */
  1649.     if  (pBlkDev == (SCSI_BLK_DEV *) NULL)
  1650. {
  1651. printErr ("pkBlkRead: pBlkDev is NULL : ERRORn");
  1652. return (ERROR);
  1653. }
  1655.     /* check for range block */
  1657.     if (((* blockNumber) > ((SCSI_BLK_DEV *) pBlkDev)->blkDev.bd_nBlocks) ||
  1658.         ((* blockNumber) < ((SCSI_BLK_DEV *) pBlkDev)->blockOffset))
  1659. {
  1660. printErr ("pkBlkRead: blockNumber out of range : ERRORn");
  1661. }
  1663.     /* check if size ok */
  1665.     if (size == 0)
  1666.         {
  1667.         printErr ("pkBlkRead: buffer size is 0 : ERRORn");
  1668.         return (ERROR);
  1669.         }
  1671.     /* make sure the buffer size fits the sector size */
  1673.     IF_BAD_BUFSIZE (pBlkDev,size)
  1674. {
  1675.         printErr ("pkBlkRead: buffer size not a multiple of block size : ERRORn");
  1676. return (ERROR);
  1677. }
  1679.     /* use previous IF_BAD_BUFSIZE to get an integer sector count */
  1681.     numSects = size / secSize;
  1683.     if (scsiRdSecs (pBlkDev,*blockNumber,numSects, pBuffer) == ERROR)
  1684. {
  1685. printErr ("pkBlkRead: returning ERRORn");
  1686. return (ERROR);
  1687. }
  1689.     *blockNumber = *blockNumber + numSects;
  1690.     return (OK);
  1691.     }
  1693. /*******************************************************************************
  1694. *
  1695. * pkTestUnit - test a SCSI device by writing, reading and verifying data
  1696. *
  1697. * This routine tests write and read operation to a SCSI device.
  1698. * The unique parameter is pointer to a structure info.  First it writes
  1699. * a pattern to a range of blocks on the device.  Then it reads the range
  1700. * of blocks and verifies the pattern.  The pattern is generated by
  1701. * pkBufFillPattern().
  1702. *
  1703. * RETURNS: OK, or ERROR if the parameters are bad or the test fails.
  1704. *
  1705. * SEE ALSO: pkBufFillPattern()
  1706. */
  1708. STATUS pkTestUnit
  1709.     (
  1710.     RW_TEST_UNIT *pTestInfo  /* structure describes test to run */
  1711.     )
  1712.     {
  1713.     FAST RW_TEST_UNIT * p = pTestInfo;
  1714.     FAST SCSI_BLK_DEV * pB = (SCSI_BLK_DEV *) (p->pBlk);
  1715.     int iWrite;
  1716.     int iRead;
  1717.     int iLoop;
  1718.     int temp;
  1719.     int curEndPattern;
  1721.     /* check parameters */
  1723.     if (pB == (SCSI_BLK_DEV *) NULL)
  1724. {
  1725.         printErr ("pkTestUnit: pBlkDev is NULL : ERRORn");
  1726.         return (ERROR);
  1727. }
  1729.     if (p->nbLoop == 0)
  1730. {
  1731.         printErr ("pkTestUnit: nbLoop is 0 : ERRORn");
  1732.         return (ERROR);
  1733. }
  1735.     if (p->size == 0)
  1736. {
  1737.         printErr ("pkTestUnit: bufSize is 0 : ERRORn");
  1738.         return (ERROR);
  1739. }
  1741.     if (p->nbBuf == 0)
  1742. {
  1743.         printErr ("pkTestUnit: nbBufWrite is 0 : ERRORn");
  1744.         return (ERROR);
  1745. }
  1747.     IF_BAD_BUFSIZE(pB, p->size)
  1748. {
  1749.         printErr ("pkTestUnit: bufSize not a multiple of block size : ERRORn");
  1750. return (ERROR);
  1751. }
  1753.     /* check if enough place on the device for a cycle */
  1755.     temp = ((p->size / BLK_TO_PHYS(pB, blockSize)) *  p->nbBuf);
  1757.     if ((temp > (pB->blkDev.bd_nBlocks)) ||
  1758. ((temp + p->stBlk) > (pB->blkDev.bd_nBlocks + pB->blockOffset)))
  1759. {
  1760.         printErr ("pkTestUnit: not enough room for a cycle : ERRORn");
  1761. return (ERROR);
  1762. }
  1764.     /* allocate buffers */
  1766.     if ((p->ptR = (UINT8 *) malloc(p->size)) == NULL)
  1767. {
  1768.         printErr ("pkTestUnit: ptRead allocation failed : ERRORn");
  1769. return (ERROR);
  1770. }
  1772.     if ((p->ptW = (UINT8 *) malloc(p->size)) == NULL)
  1773. {
  1774.         printErr ("pkTestUnit: ptWrite allocation failed : ERRORn");
  1775.         free (p->ptR);
  1776. return (ERROR);
  1777. }
  1779.     /* main loop on nbLoop */
  1781.     p->curStartPattern = p->startPattern;
  1782.     p->countErr = 0;
  1784.     for (iLoop = 0; iLoop < p->nbLoop; iLoop ++)
  1785. {
  1786. p->curBlk = p->stBlk;
  1787. p->curPattern = p->curStartPattern;
  1789. /* refresh curCycle for spy */
  1791.         p->curCycle = iLoop;
  1793. /* check for abort */
  1795. if (p->abort == TRUE)
  1796.    return (OK);
  1798. /* write loop */
  1800.         for (iWrite = 0; iWrite < p->nbBuf; iWrite ++)
  1801.     {
  1802.     if (iWrite == 0)
  1803. {
  1804. printf ("pkTestUnit: beginning write loopn");
  1805. }
  1806.     if (iWrite == p->nbBuf / 2)
  1807. {
  1808. printf ("pkTestUnit: half way through write loopn");
  1809. }
  1811.     /* check for abort */
  1813.     if (p->abort == TRUE)
  1814.                return (OK);
  1816.     /* fill the buffer with pattern according to the law */
  1818.     if ((pkBufFillPattern (p->ptW, p->size, p->law,
  1819.                      &p->curPattern,
  1820.              &curEndPattern)) == ERROR)
  1821.                 {
  1822. printErr ("pkTestUnit: fatal fill buffer error : ERRORn");
  1823. return (ERROR);
  1824. }
  1826.     if (pkBlkWrite (pB, (char *) p->ptW, p->size, &p->curBlk) == ERROR)
  1827.                 {
  1828. printErr ("pkTestUnit: fatal write error : ERRORn");
  1829. return (ERROR);
  1830. }
  1832.             (p->curPattern) ++;
  1833.             }
  1835. p->curBlk = p->stBlk;
  1836. p->curPattern = p->curStartPattern;
  1838. /* read loop */
  1840.         for (iRead = 0; iRead < p->nbBuf; iRead ++)
  1841.     {
  1842.     if (iRead == 0)
  1843. {
  1844. printf ("pkTestUnit: beginning read loopn");
  1845. }
  1846.     if (iRead == p->nbBuf / 2)
  1847. {
  1848. printf ("pkTestUnit: half way through read loopn");
  1849. }
  1851.     /* check for abort */
  1853.     if (p->abort == TRUE)
  1854. {
  1855. return (OK);
  1856. }
  1858.     if ((pkBufFillPattern (p->ptW, p->size, p->law,
  1859.              &p->curPattern, &curEndPattern)) == ERROR)
  1860.                 {
  1861. printErr ("pkTestUnit: fatal fill buffer error : ERRORn");
  1862. return (ERROR);
  1863. }
  1865.     if (pkBlkRead (pB, (char *) p->ptR , p->size, &p->curBlk) == ERROR)
  1866.                 {
  1867. printErr ("pkTestUnit: fatal read error : ERRORn");
  1868. return (ERROR);
  1869. }
  1871.            /* compare buffers */
  1873.    if (bcmp ((char *) p->ptR,(char *) p->ptW, p->size) != 0)
  1874.        {
  1875.        (p->countErr) ++;
  1877.        printErr ("    Loop  :0x%08xn", iLoop);
  1878.        printErr ("    Buffer:0x%08xn", iRead);
  1879.                printErr ("pkTestUnit: buffer compare error : ERRORn");
  1881.        /* check for abort on Error */
  1883.        if (p->abortOnError == TRUE)
  1884.    return (OK);
  1885.        }
  1887.             p->curPattern ++;
  1889.             } /* nbBufRead */
  1891.         /* inc start pattern for the next cycle */
  1893. p->curStartPattern ++;
  1895.         } /* nbLoop */
  1897.     /* release resources */
  1899.     free (p->ptR);
  1900.     free (p->ptW);
  1902.     return (p->countErr);
  1903.     }
  1905. /*******************************************************************************
  1906. *
  1907. * pkTestOneUnit - test one SCSI unit
  1908. *
  1909. * This routine creates a SCSI device as specified by <devId> and <devLun> then
  1910. * calls pkTestUnit() to perform a read/write test on the device.
  1911. * Because it uses a global RW_TEST_UNIT structure it is not reentrant.
  1912. *
  1913. * If <bufSize> = 0, use default of DEF_BUF_SIZE.
  1914. * If <nbBuf>   = 0, use default of DEF_NB_BUF.
  1915. * If <nbLoop>  = 0, write/read entire device.
  1916. *
  1917. * NOTE:
  1918. * Warning!  This routine calls scsiPhysDevCreate() and scsiBlkDevCreate().
  1919. * All data on the file system will be erased.
  1920. *
  1921. * RETURNS: OK, or ERROR if test fails.
  1922. *
  1923. * SEE ALSO: pkTestUnit()
  1924. */
  1926. STATUS pkTestOneUnit
  1927.     (
  1928.     int devId, /* scsi id of the device */
  1929.     int devLun, /* lun id of the devicer */
  1930.     UINT32 bufSize, /* buffer size to use */
  1931.     int nbBuf, /* number of buffers to write */
  1932.     int nbLoop /* number of loops to perform */
  1933.     )
  1934.     {
  1935.     SCSI_PHYS_DEV *pPhysDev;
  1936.     BLK_DEV *pBlkDev;
  1937.     STATUS status;
  1939.     /* create physical SCSI device */
  1941.     if ((pPhysDev=scsiPhysDevIdGet(0,devId,devLun))==(SCSI_PHYS_DEV *)NULL)
  1942.         if ((pPhysDev=scsiPhysDevCreate(pSysScsiCtrl,devId,devLun,0,NONE,0,0,0))         == (SCSI_PHYS_DEV *) NULL)
  1943.             {
  1944.     printErr ("pkTestOneUnit: scsiPhysDevCreate() failed : ERRORn");
  1945.     return (ERROR);
  1946.     }
  1948.     /* create logical SCSI device */
  1950.     if ((pBlkDev = scsiBlkDevCreate (pPhysDev, 0, 0)) == NULL)
  1951. {
  1952.         printErr ("pkTestOneUnit: scsiBlkDevCreate() failed : ERRORn");
  1953. return (ERROR);
  1954.         }
  1956.     /* fill in the RW_TEST_UNIT information */
  1958.     pTestUnit->pBlk = pBlkDev;
  1959.     pTestUnit->size = (bufSize == 0) ? DEF_BUF_SIZE : bufSize;
  1960.     pTestUnit->nbBuf = (nbBuf == 0) ? DEF_NB_BUF : nbBuf;
  1961.     if (nbLoop == 0)
  1962.         {
  1963.         /* entire device */
  1965.         UINT32 nbblock       = ((SCSI_BLK_DEV *) pBlkDev)->blkDev.bd_nBlocks;
  1966.         UINT32 blsize        = BLK_TO_PHYS (pBlkDev, blockSize);
  1967.         pTestUnit->nbBuf  = nbblock / (pTestUnit->size / blsize);
  1968.         pTestUnit->nbLoop = 1;
  1969.         }
  1970.     else
  1971.         pTestUnit->nbLoop = nbLoop;
  1973.     pTestUnit->startPattern = ST_PATTERN; /* start pattern */
  1974.     pTestUnit->law          = DEF_LAW; /* fill law */
  1975.     pTestUnit->abortOnError = TRUE; /* set abort on data error */
  1976.     pTestUnit->abort        = FALSE; /* disable abort flag */
  1978.     /* call pkTestUnit() */
  1980.     status = (pkTestUnit (pTestUnit) || pTestUnit->countErr) ? ERROR : OK;
  1982.     /* releases resources and return */
  1984.     scsiPhysDevDelete (pPhysDev);
  1986.     if (status == OK)
  1987.         printf("PASSn");
  1988.     else
  1989.         printf("ERRORn");
  1991.     return (status);
  1992.     }
  1994. #endif /* INCLUDE_SCSI */
  1996. /*******************************************************************************
  1997. *
  1998. * pkPrintTest - print the given string to the console.
  1999. *
  2000. * This routine prints the given string.
  2001. *
  2002. * RETURNS: N/A
  2003. */
  2005. void pkPrintTest
  2006.     (
  2007.     char *mesg, /* message to be printed */
  2008.     int delayTime /* task delay if required */
  2009.     )
  2010.     {
  2011.     taskDelay(delayTime);
  2012.     printf("%sn",mesg);
  2013.     }
  2016. /*******************************************************************************
  2017. *
  2018. * pkPrintTest1 - print the given string to the console.
  2019. *
  2020. * This routine prints the given string.
  2021. *
  2022. * RETURNS: N/A
  2023. */
  2025. void pkPrintTest1
  2026.     (
  2027.     int fd,
  2028.     char *mesg, /* message to be printed */
  2029.     int delayTime /* task delay if required */
  2030.     )
  2031.     {
  2032.     taskDelay(delayTime);
  2033.     write(fd, mesg, strlen(mesg));
  2034.     }
  2036. /*******************************************************************************
  2037. *
  2038. * pkDivideZeroTest - used to check for divide by zero exception.
  2039. *
  2040. *
  2041. * RETURNS: N/A
  2042. */
  2044. void  pkDivideZeroTest (void)
  2045.       {
  2046.       int a;
  2047.       int b=5;
  2048.       int c=0;
  2050.       taskDelay(200);
  2051.       a=b/c;
  2053.       printf("The value of a is %dn", a);
  2054.       }
  2056. /******************************************************************************
  2057. *
  2058. * pkUdpEchoT - main routine to open sockets, send and receive packets
  2059. *
  2060. * This routine opens an internet socket with a remote target, which is assumed
  2061. * to be running a UDP echo server.  Once connected, a loop is entered where
  2062. * UDP packets of differing sizes are sent to, and received from, the target.
  2063. * Each returning packet is checked for the correct size and content.  A
  2064. * packet sent, but not received back within the timeout may be resent by
  2065. * alarm_handler().  The test passes, exiting with value 0, if all packets
  2066. * were sent and received, regardless of how many individual packets
  2067. * needed to be resent. The IP address of the remote target has to be supplied
  2068. * with all individual bytes as seperate arguments.
  2069. *
  2070. * RETURNS: exit status: 0 if OK
  2071. */
  2073. void pkUdpEchoT
  2074.     (
  2075.     int addr1,  /* first byte in the IP address */
  2076.     int addr2,
  2077.     int addr3,
  2078.     int addr4,  /* last byte in the IP address */
  2079.     int     packetsToSend,
  2080.     int     timeout
  2081.     )
  2082.     {
  2083.     int    div; /* divisor for status messages */
  2084.     int    tenth = 0; /* status message counter */
  2085.     int    ix, iy;                      /* loop counters */
  2086.     int    cnt; /* count of bytes sent/received */
  2087.     int    prevPktSiz = -99; /* packet size just sent */
  2088.     int    localSktAddrLen; /* local copy of sktAddrLen */
  2089.     short  *pShort;                     /* counter to form output buffer */
  2090.     struct sockaddr_in cli_addr;        /* host socket data */
  2091.     int    sktBufSiz;
  2092.     struct fd_set readFs;
  2093.     int    ret;
  2094.     struct timeval pktTimeout;
  2095.     u_long  inetAdrs;
  2096.     char inetDotAdrs[60];
  2098.     sprintf(inetDotAdrs, "%d.%d.%d.%d", addr1, addr2, addr3, addr4);
  2100.     inetAdrs = inet_addr(inetDotAdrs);
  2102.     /* convert command line args */
  2104.     if (packetsToSend < 1)
  2105. {
  2106. printf ("Error: no packets to sendn");
  2107. fflush (stdout);
  2108. exit (9);
  2109. }
  2111.     /* check if inet address is non-null */
  2113.     if (inetAdrs == 0)
  2114.         {
  2115.         printf ("Error: illegal inet addressn");
  2116.         exit (9);
  2117.         }
  2119.     /* turn off timer if bad arg */
  2121.     packetTMO = timeout;
  2122.     if (packetTMO < 0)
  2123. packetTMO = 0;
  2125.     pktTimeout.tv_sec  = 0;
  2126.     pktTimeout.tv_usec = packetTMO * 1000;
  2128.     /* open the socket */
  2130.     skt = socket (AF_INET, SOCK_DGRAM, 0);
  2131.     if (skt < 0)
  2132.         {
  2133.         printf ("Error: socket() failuren");
  2134. fflush (stdout);
  2135.         exit (2);
  2136.         }
  2138.     /* prepare our sock addr */
  2140.     sktAddrLen = sizeof (struct sockaddr_in);
  2141.     (void) memset (&cli_addr, 0, sktAddrLen);           /* clr it */
  2142.     cli_addr.sin_family = AF_INET;                      /* fill in family */
  2143.     cli_addr.sin_port = 0;                              /* port */
  2146.     /* bind our addr to the socket */
  2148.     if (bind (skt, (struct sockaddr *) &cli_addr, sktAddrLen) < 0)
  2149.         {
  2150.         printf ("Error: bind() failuren");
  2151. fflush (stdout);
  2152.         close (skt);
  2153.         exit (3);
  2154.         }
  2156.     /* specify max buffer size on send/receive */
  2158.     sktBufSiz = sizeof (buf);         /* increase size of socket buffers */
  2160.     if (setsockopt (skt, SOL_SOCKET, SO_SNDBUF, (char *) &sktBufSiz,
  2161.         sizeof (sktBufSiz)) < 0)
  2162.         {
  2163.         close (skt);
  2164.         printf ("Error: setsockopt() failuren");
  2165. fflush (stdout);
  2166.         exit (3);
  2167.         }
  2169.     if (setsockopt (skt, SOL_SOCKET, SO_RCVBUF, (char *) &sktBufSiz,
  2170.         sizeof (sktBufSiz)) < 0)
  2171.         {
  2172.         close (skt);
  2173.         printf ("Error: setsockopt() failuren");
  2174. fflush (stdout);
  2175.         exit (4);
  2176.         }
  2178.     /* prepare server's sock addr */
  2180.     (void) memset (&serv_addr, 0, sktAddrLen);          /* clr it */
  2181.     serv_addr.sin_family = AF_INET;                     /* fill in family */
  2182.     serv_addr.sin_addr.s_addr = inetAdrs;    /* get IP addr */
  2183.     serv_addr.sin_port = htons(IPPORT_ECHO);            /* the ECHO port */
  2185.     /*
  2186.      * Prepare the outgoing data.
  2187.      * The buffer is treated as an array of short integers,
  2188.      * each is sequentially numbered, starting from zero.
  2189.      */
  2191.     pShort = (short *) dataOut;
  2192.     for (ix = 0; ix < (MAX_PKT/sizeof (short)); ix++)
  2193.         *pShort++ = ix;
  2195.     /* Main loop.  Send a packet and wait for it to come back */
  2197.     div=packetsToSend/10;
  2198.     printf("Sending %d packetsn", packetsToSend);
  2199.     fflush (stdout);
  2202.     for (packetNum = 0; packetNum < packetsToSend; packetNum++)
  2203.         {
  2204.         /* print status message */
  2206.         if (div > 0)
  2207.     if ((packetNum % div) == (div -1))
  2208.         printf ("%d/10 through UDP echo testn", ++tenth);
  2209. fflush (stdout);
  2211.         curPktSiz = pktSizes [packetNum % N_SIZES];
  2213.         /* send a packet */
  2215.         cnt = sendto (skt, dataOut, curPktSiz, 0,
  2216.       (struct sockaddr *) &serv_addr, sktAddrLen);
  2218.         /* check that entire packet was sent */
  2220.         if (cnt != curPktSiz)
  2221.             {
  2222.             printf ("Error: could not send packet #%d, size %dn",
  2223.     packetNum, curPktSiz);
  2224.     fflush (stdout);
  2225.             exit (4);
  2226.             }
  2228.         /* expect it back - clear out previously resent packets */
  2230.         do {
  2232.             FD_ZERO (&readFs);
  2233.             FD_SET (skt, &readFs);
  2235.             ret = select (skt +1, &readFs, NULL, NULL, &pktTimeout);
  2236.             if (ret == 0)
  2237.                {
  2238.             if (resendCnt++ == RESEND)
  2239.            {
  2240.            /* already resent specified times - fail */
  2242.                    close (skt);
  2243.            printf ("Error: timed out waiting for packet #%dn",
  2244.                     packetNum);
  2245.                    printf ("UDP echo test failedn");
  2246.                    fflush (stdout);
  2247.            exit (7);
  2248.            }
  2249.                else
  2250.                    {
  2251.            resendTotal ++;   /* bump counter */
  2252.                    printf("Timed out Resending packet:%d trial:%dn",
  2253.                              packetNum, resendCnt);
  2254.                    fflush (stdout);
  2255.                    cnt = sendto (skt, dataOut, curPktSiz, 0,
  2256.                 (struct sockaddr *) &serv_addr, sktAddrLen);
  2258.                    /* check that entire packet was sent */
  2260.                    if (cnt != curPktSiz)
  2261.                       {
  2262.                       printf ("Error: could not send packet #%d, size %dn",
  2263.                packetNum, curPktSiz);
  2264.               fflush (stdout);
  2265.                       exit (4);
  2266.                       }
  2267.                    }
  2268.                }
  2269.             else if (ret == ERROR)
  2270.                {
  2271.                printf ("Error: select failedn");
  2272.                close (skt);
  2273.                exit(9);
  2274.                }
  2275.             else
  2276.                {
  2277.                localSktAddrLen = sktAddrLen;
  2278.                cnt = recvfrom (skt, dataIn, curPktSiz, 0,
  2279.     (struct sockaddr *) &serv_addr, &localSktAddrLen);
  2280.        }
  2282. } while ((cnt == prevPktSiz) || (cnt == -1));
  2284.         resendCnt = 0;
  2286. /* check that packet received is correct size */
  2288.         if (cnt != curPktSiz)
  2289.             {
  2290.             printf ("Error: remote host echoed wrong size in packet #%dn",
  2291.     packetNum);
  2292.     fflush (stdout);
  2293.     close (skt);
  2294.             exit (5);
  2295.             }
  2297.         /* verify the received data */
  2299.         for (iy = curPktSiz; iy--;)
  2300.             {
  2301.             if (dataIn [iy] != dataOut [iy])
  2302.                 {
  2303.                 printf ("Error: echoed data does not match in packet #%dn",
  2304. packetNum);
  2305. close (skt);
  2306.         fflush (stdout);
  2307.                 exit (6);
  2308.                 }
  2309.             }
  2311.         prevPktSiz = curPktSiz;
  2312.         }
  2314.     /* print exit messages - test passed */
  2316.     printf ("nnTotal packets resent: %dn", resendTotal);
  2317.     printf ("UDP echo test passedn");
  2318.     printf ("END OF UDP TESTn");
  2319.     fflush (stdout);
  2320.     close (skt);
  2321.     exit (0);
  2322.     }
  2324. /*******************************************************************************
  2325. *
  2326. * pkIntGet - read an int at a given address
  2327. *
  2328. * RETURNS: content of address.
  2329. *
  2330. * SEE ALSO: pkTestSet()
  2331. */
  2332. int pkIntGet
  2333.    (
  2334.    int *pMem
  2335.    )
  2336.    {
  2337.    return *pMem;
  2338.    }
  2340. /*******************************************************************************
  2341. *
  2342. * pkIntSet - store an int at a given address
  2343. *
  2344. * RETURNS: N/A
  2345. *
  2346. * SEE ALSO: pkTestGet()
  2347. */
  2348. void pkIntSet
  2349.    (
  2350.    int *pMem,
  2351.    int val
  2352.    )
  2353.    {
  2354.    *pMem = val;
  2355.    }
  2357. /*******************************************************************************
  2358. *
  2359. * pkPing - perform a call to ping()
  2360. *
  2361. *
  2362. * RETURNS: N/A
  2363. *
  2364. */
  2365. void pkPing
  2366.    (
  2367.    int addrByte0, /* most significant byte of IP address */
  2368.    int  addrByte1,
  2369.    int  addrByte2,
  2370.    int  addrByte3, /* least sigificant byte of IP address */
  2371.    int  numPkts, /* number of packets to send */
  2372.    int options
  2373.    )
  2374.    {
  2375.    char  buffer[60];
  2377.    sprintf(buffer, "%d.%d.%d.%d", addrByte0, addrByte1, addrByte2, addrByte3);
  2378.    ping(buffer, numPkts, options);
  2379.    }
  2381. /*******************************************************************************
  2382. *
  2383. * pkBusErrorTest - performs a string comparison with an invalid address to cause
  2384. *                  bus error exception
  2385. *
  2386. *
  2387. * RETURNS: returns 0 or 1 depending on string compare result otherwise should
  2388. *           cause a bus error
  2389. *
  2390. */
  2393. int pkBusErrorTest
  2394.     (
  2395.     char * str2
  2396.     )
  2397.     {
  2398.     char * str1 = "This is a sample string" ;
  2400.     for(; *str1 == *str2 ; str1++ , str2++)
  2401.         if (*str1 == '')
  2402.         return 0 ;
  2404.     return 1 ;
  2406.     }
  2408. /*****************************************************************************
  2409. *
  2410. * pkPrintSerialOutput - calls pkPrintTest() given the count.
  2411. *
  2412. *
  2413. * RETURNS: N/A
  2414. *
  2415. */
  2417. void pkPrintSerialOutput
  2418.     (
  2419.     int count
  2420.     )
  2421.     {
  2422.     int i;
  2424.     for(i=0; i<count; i++)
  2425.         {
  2426.         pkPrintTest("abcdefghijklmnopqrstuvwxyz" , 1) ;
  2427.         }
  2428.     }
  2430. /*****************************************************************************
  2431. *
  2432. * pkSerialTestInit - initializes the console settings.
  2433. *
  2434. *
  2435. * RETURNS: N/A
  2436. *
  2437. */
  2439. void pkSerialTestInit()
  2440.     {
  2441.     int term1, term2;
  2443.     term1 = ioGlobalStdGet(0);
  2444.     term2 = ioGlobalStdGet(1);
  2445.     (void) ioctl (term1, FIOSETOPTIONS, OPT_TERMINAL);
  2446.     (void) ioctl (term2, FIOSETOPTIONS, OPT_TERMINAL);
  2447.     }
  2449. /*****************************************************************************
  2450. *
  2451. * pkSerialTest - scans console for input strings and stores them in a global
  2452. *                array
  2453. *
  2454. *
  2455. * RETURNS: N/A
  2456. *
  2457. */
  2459. void pkSerialTest()
  2460.     {
  2462.     int i=0;
  2464.     while (i < 15)
  2465.         {
  2466.         if (pkSerChanAbort)
  2467.             break ;
  2468.         scanf("%s",pkSerChanInput[i]) ;
  2469.         i++ ;
  2470.         }
  2472.     }
  2474. /*****************************************************************************
  2475. *
  2476. * pkSerChanOutput - prints the contents of the global array received by
  2477. *                   pkSerialTest()
  2478. *
  2479. *
  2480. * RETURNS: N/A
  2481. *
  2482. */
  2485. void pkSerChanOutput
  2486.     (
  2487.     int index
  2488.     )
  2489.     {
  2490.     int term;
  2492.     term = ioGlobalStdGet(1);
  2494.     if (index < 15)
  2495.         {
  2496. write(term, pkSerChanInput[index], strlen(pkSerChanInput[index]));
  2497. }
  2498.     }
  2500. /*****************************************************************************
  2501. *
  2502. * pkCatastrophicTest - performs catastrophic test given an error address.
  2503. *
  2504. * This functions connects 'strcmp' routine to the system clock interrupt
  2505. * with an invalid address as the argument. This should cause a catastrophic
  2506. * error on the target and the target should reboot with an exception.
  2507. *
  2508. * RETURNS: ERROR if no exception is generated.
  2509. *
  2510. */
  2513. STATUS pkCatastrophicTest
  2514.     (
  2515.     UINT32 obErrAdrs
  2516.     )
  2517.     {
  2519.     sysClkDisable();
  2520.     if ((sysClkConnect((FUNCPTR) strcmp, obErrAdrs) == ERROR))
  2521.         return(ERROR);
  2523.     sysClkEnable();
  2525.     return(ERROR);
  2526.     }
  2529. /******************************************************************************
  2530. *
  2531. * pkCatastrophicClean - clean-up for pkCatastrophicTest() routine.
  2532. *
  2533. * This functions does clean-up if pkCatastrophicTest() function fails and
  2534. * ensures proper operation of system clock.
  2535. *
  2536. * RETURNS: N/A
  2537. *
  2538. */
  2540. VOID pkCatastrophicClean ()
  2541.     {
  2542.     sysClkDisable();
  2543.     sysClkConnect((FUNCPTR) tickAnnounce, 0);
  2544.     sysClkEnable();
  2545.     }