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

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

VxWorks

开发平台：

C/C++

mb87030Lib.c：源码内容
  1. /* mb87030Lib.c - Fujitsu MB87030 SCSI Protocol Controller (SPC) library */
  3. /* Copyright 1989-1996 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01u,14dec94,jds  timeout too small in spcBusPhaseGet(); spr 3877 fixed
  10. 01t,26mar94,ccc  bus free race condition fix for spr 3197
  11. 01s,23feb93,jdi  documentation cleanup.
  12. 01r,11feb93,ccc  fixed error in comment for select timeout (spr 1901).
  13. 01q,26sep92,ccc  renamed spcShow() to mb87030Show() and added example.
  14. 01p,24sep92,ccc  made change in spcManBytesIn() to handle extended message.
  15.  spcShow() now returns OK or ERROR if SCSI not configured.
  16. 01o,07aug92,ccc  added DMA support.
  17. 01n,18jul92,smb  Changed errno.h to errnoLib.h.
  18. 01m,26may92,rrr  the tree shuffle
  19.   -changed includes to have absolute path from h/
  20. 01l,07oct91,rrr  some forward decls
  21. 01k,04oct91,rrr  passed through the ansification filter
  22.                   -changed functions to ansi style
  23.   -changed includes to have absolute path from h/
  24.   -changed VOID to void
  25.   -changed copyright notice
  26. 01j,05apr91,jdi  documentation -- removed header parens and x-ref numbers;
  27.  doc review by jcc.
  28. 01i,29feb91,jaa  documentation.
  29. 01h,09oct90,jcc  lint.
  30. 01g,03oct90,jcc  changed leastSigAdrsBit to regOffset in mb87030CtrlCreate();
  31.  eliminated busFreeDelay parameter to mb87030CtrlInit().
  32. 01f,02oct90,jcc  UTINY became UINT8; changes in sem{Give, Take}() calls
  33.  since SEM_ID's became SEMAPHORE's in various structures;
  34.  malloc() became calloc() in wd33c93CtrlCreate(); miscellaneous.
  35. 01e,10aug90,dnw  added forward declarations for void functions.
  36. 01d,18jul90,jcc  made semTake() calls 5.0 compatible; clean-up.
  37. 01c,08jun90,jcc  fixed bug in handling of incoming messages. documentation.
  38. 01b,23mar90,jcc  removed DMA and disconnect options from mb87030CtrlInit().
  39.  lint.
  40. 01a,19jan90,jcc  formerly the device specific part of spcScsiDrv.c.
  41. */
  43. /*
  44. DESCRIPTION
  45. This is the I/O driver for the Fujitsu MB87030 SCSI Protocol Controller
  46. (SPC) chip.  It is designed to work in conjunction with scsiLib.
  48. USER-CALLABLE ROUTINES
  49. Most of the routines in this driver are accessible only through the I/O
  50. system.  Two routines, however, must be called directly:  mb87030CtrlCreate()
  51. to create a controller structure, and mb87030CtrlInit() to initialize
  52. the controller structure.
  54. INCLUDE FILES
  55. mb87030.h
  57. SEE ALSO: scsiLib,
  58. .I "Fujitsu Small Computer Systems Interface MB87030 Synchronous/Asynchronous Protocol Controller Users Manual,"
  59. .pG "I/O System"
  60. */
  62. #include "vxWorks.h"
  63. #include "drv/scsi/mb87030.h"
  64. #include "memLib.h"
  65. #include "errnoLib.h"
  66. #include "logLib.h"
  67. #include "scsiLib.h"
  68. #include "stdlib.h"
  69. #include "stdio.h"
  70. #include "sysLib.h"
  72. /* defines */
  74. #define SPC_MAX_XFER_LENGTH   (UINT) (0x00800000) /* max data xfer length */
  75. #define SPC_DEF_BUS_FREE_DELAY  3 /* nominal value for bus free delay */
  77. /* macros */
  78. #define SPC_BUS_PHASE_SET(pSpc, busPhase) spcPctlSet (pSpc, -1, (UINT8)busPhase)
  80. typedef MB_87030_SCSI_CTRL SPC;
  82. IMPORT BOOL scsiDebug;
  83. IMPORT BOOL scsiIntsDebug;
  85. void spcCommand (SPC *pSpc, UINT8 cmdCode);
  86. STATUS spcProgBytesOut (SCSI_PHYS_DEV *pScsiPhysDev, UINT8 *pBuffer,
  87.      int bufLength, int scsiPhase);
  88. STATUS spcProgBytesIn (SCSI_PHYS_DEV *pScsiPhysDev, UINT8 *pBuffer,
  89.      int bufLength, int scsiPhase);
  90. STATUS spcXferCountSet (SPC *pSpc, int count);
  92. /* forward static functions */
  94. static STATUS spcDevSelect (SCSI_PHYS_DEV *pScsiPhysDev, SCSI_TRANSACTION
  95. *pScsiXaction);
  96. static STATUS spcMsgInAck (SCSI_CTRL *pScsiCtrl, BOOL expectDisconn);
  97. static STATUS spcBytesOut (SCSI_PHYS_DEV *pScsiPhysDev, char *pBuffer, int
  98. bufLength, int scsiPhase);
  99. static STATUS spcBytesIn (SCSI_PHYS_DEV *pScsiPhysDev, char *pBuffer, int
  100. bufLength, int scsiPhase);
  101. static STATUS spcBusPhaseGet (SCSI_CTRL *pScsiCtrl, int timeOutInUsec, int
  102. *pBusPhase);
  103. static int byteParityGet (UINT8 byte);
  104. static void spcSelTimeOutCvt (SCSI_CTRL *pScsiCtrl, UINT timeOutInUsec, UINT
  105. *pTimeOutSetting);
  106. static STATUS spcBusIdGet (SPC *pSpc, int *pBusId);
  107. static void spcIntsEnable (SPC *pSpc);
  108. static void spcIntsDisable (SPC *pSpc);
  109. static void spcScmdSet (SPC *pSpc, UINT8 cmdCode, int resetOutBit, int
  110. interceptXferBit, int prgXferBit, int termModeBit);
  111. static void spcTmodSet (SPC *pSpc, BOOL syncXfer, int maxOffset, int
  112. minPerMinusOne);
  113. static void spcPctlSet (SPC *pSpc, int busFreeIntEnblBit, UINT8 xferPhase);
  114. static void spcScsiBusReset (SPC *pSpc);
  115. static void spcHwInit (SPC *pSpc);
  118. /*******************************************************************************
  119. *
  120. * mb87030CtrlCreate - create a control structure for an MB87030 SPC
  121. *
  122. * This routine creates a data structure that must exist before the SPC chip can
  123. * be used.  This routine should be called once and only once for a specified 
  124. * SPC.  It should be the first routine called, since it allocates memory for
  125. * a structure needed by all other routines in the library.
  126. *
  127. * After calling this routine, at least one call to mb87030CtrlInit() should
  128. * be made before any SCSI transaction is initiated using the SPC chip.
  129. *
  130. * A detailed description of the input parameters follows:
  131. * .iP <spcBaseAdrs> 4
  132. * the address at which the CPU would access the lowest 
  133. * register of the SPC.
  134. * .iP <regOffset>
  135. * the address offset (bytes) to access consecutive registers.
  136. * (This must be a power of 2, for example, 1, 2, 4, etc.)
  137. * .iP <clkPeriod>
  138. * the period in nanoseconds of the signal to the SPC clock input (only
  139. * used for select command timeouts).
  140. * .iP <spcDataParity>
  141. * the parity bit must be defined by one of the following constants,
  142. * according to whether the input to SPC DP is GND, +5V, or a valid
  143. * parity signal, respectively:
  144. * .nf
  145. *     SPC_DATA_PARITY_LOW
  146. *     SPC_DATA_PARITY_HIGH
  147. *     SPC_DATA_PARITY_VALID
  148. * .fi
  149. * .iP "<spcDmaBytesIn> and <spcDmaBytesOut>"
  150. * pointers to board-specific routines to handle DMA input and output.  
  151. * If these are NULL (0), SPC program transfer mode is used.
  152. * DMA is possible only during SCSI data in/out phases.
  153. * The interface to these DMA routines must be of the form:
  154. * .CS
  155. *     STATUS xxDmaBytes{In, Out}
  156. *         (
  157. *         SCSI_PHYS_DEV  *pScsiPhysDev,  /@ ptr to phys dev info    @/
  158. *         UINT8          *pBuffer,       /@ ptr to the data buffer  @/
  159. *         int            bufLength       /@ number of bytes to xfer @/
  160. *         )
  161. * .CE
  162. *
  163. * RETURNS: A pointer to the SPC control structure, or NULL if memory 
  164. * is insufficient or parameters are invalid.
  165. */
  167. MB_87030_SCSI_CTRL *mb87030CtrlCreate
  168.     (
  169.     FAST UINT8 *spcBaseAdrs,    /* base address of SPC */
  170.     int regOffset,              /* addr offset between consecutive regs. */
  171.     UINT clkPeriod,             /* period of controller clock (nsec) */
  172.     int spcDataParity,          /* type of input to SPC DP (data parity) */
  173.     FUNCPTR spcDMABytesIn,      /* SCSI DMA input function */
  174.     FUNCPTR spcDMABytesOut      /* SCSI DMA output function */
  175.     )
  176.     {
  177.     FAST SPC *pSpc; /* ptr to SPC info */
  179.     /* verify parameters */
  181.     if (regOffset == 0)
  182. return ((SPC *) NULL);
  184.     if ((spcDataParity < SPC_DATA_PARITY_LOW) ||
  185. (spcDataParity > SPC_DATA_PARITY_VALID))
  186. return ((SPC *) NULL);
  188.     /* malloc the controller info structure; return ERROR if unable */
  190.     pSpc = (SPC *) malloc (sizeof (SPC));
  192.     if (pSpc == (SPC *) NULL)
  193.         return ((SPC *) NULL);
  195.     /* fill in generic SCSI info for this controller */
  197.     scsiCtrlInit (&pSpc->scsiCtrl);
  199.     /* fill in SPC specific data for this controller */
  201.     pSpc->pBdidReg = spcBaseAdrs;
  202.     pSpc->pSctlReg = spcBaseAdrs + (0x1 * regOffset);
  203.     pSpc->pScmdReg = spcBaseAdrs + (0x2 * regOffset);
  204.     pSpc->pTmodReg = spcBaseAdrs + (0x3 * regOffset);
  205.     pSpc->pIntsReg = spcBaseAdrs + (0x4 * regOffset);
  206.     pSpc->pPsnsReg = spcBaseAdrs + (0x5 * regOffset);
  207.     pSpc->pSdgcReg = spcBaseAdrs + (0x5 * regOffset);
  208.     pSpc->pSstsReg = spcBaseAdrs + (0x6 * regOffset);
  209.     pSpc->pSerrReg = spcBaseAdrs + (0x7 * regOffset);
  210.     pSpc->pPctlReg = spcBaseAdrs + (0x8 * regOffset);
  211.     pSpc->pMbcReg  = spcBaseAdrs + (0x9 * regOffset);
  212.     pSpc->pDregReg = spcBaseAdrs + (0xa * regOffset);
  213.     pSpc->pTempReg = spcBaseAdrs + (0xb * regOffset);
  214.     pSpc->pTchReg  = spcBaseAdrs + (0xc * regOffset);
  215.     pSpc->pTcmReg  = spcBaseAdrs + (0xd * regOffset);
  216.     pSpc->pTclReg  = spcBaseAdrs + (0xe * regOffset);
  217.     pSpc->pExbfReg = spcBaseAdrs + (0xf * regOffset);
  219.     pSpc->spcDataParity = spcDataParity;
  221.     pSpc->scsiCtrl.clkPeriod = clkPeriod;
  222.     pSpc->scsiCtrl.maxBytesPerXfer = SPC_MAX_XFER_LENGTH;
  224.     pSpc->scsiCtrl.scsiBusReset      = spcScsiBusReset;
  226.     pSpc->scsiCtrl.scsiTransact      = scsiTransact;
  227.     pSpc->scsiCtrl.scsiDevSelect     = spcDevSelect;
  228.     pSpc->scsiCtrl.scsiBytesIn       = spcBytesIn;
  229.     pSpc->scsiCtrl.scsiBytesOut      = spcBytesOut;
  230.     pSpc->scsiCtrl.scsiDmaBytesIn    = spcDMABytesIn;
  231.     pSpc->scsiCtrl.scsiDmaBytesOut   = spcDMABytesOut;
  232.     pSpc->scsiCtrl.scsiBusPhaseGet   = spcBusPhaseGet;
  233.     pSpc->scsiCtrl.scsiMsgInAck      = spcMsgInAck;
  234.     pSpc->scsiCtrl.scsiSelTimeOutCvt = spcSelTimeOutCvt;
  236.     pSpc->pDevToSelect = (SCSI_PHYS_DEV *) NULL;
  238.     return (pSpc);
  239.     }
  241. /*******************************************************************************
  242. *
  243. * mb87030CtrlInit - initialize a control structure for an MB87030 SPC
  244. *
  245. * This routine initializes an SPC control structure created by
  246. * mb87030CtrlCreate().  It must be called before the SPC is used.  This
  247. * routine can be called more than once; however, it should be
  248. * called only while there is no activity on the SCSI interface.
  249. *
  250. * Before returning, this routine pulses RST (reset) on the SCSI bus, thus
  251. * resetting all attached devices.
  252. *
  253. * The input parameters are as follows:
  254. * .iP <pSpc> 4
  255. * a pointer to the MB_87030_SCSI_CTRL structure created with
  256. * mb87030CtrlCreate().
  257. * .iP <scsiCtrlBusId>
  258. * the SCSI bus ID of the SIOP, in the range 0 - 7.  The ID is somewhat 
  259. * arbitrary; the value 7, or highest priority, is conventional.
  260. * .iP <defaultSelTimeOut>
  261. * the timeout, in microseconds, for selecting a SCSI device
  262. * attached to this controller.  The recommended value 0
  263. * specifies SCSI_DEF_SELECT_TIMEOUT (250 milliseconds).
  264. * The maximum timeout possible is approximately 3 seconds.
  265. * Values exceeding this revert to the maximum.
  266. * .iP <scsiPriority>
  267. * the priority to which a task is set when performing a SCSI
  268. * transaction.  Valid priorities range from 0 to 255.  Alternatively, 
  269. * the value -1 specifies that the priority should not be
  270. * altered during SCSI transactions.
  271. *
  272. * RETURNS: OK, or ERROR if parameters are out of range.
  273. */
  275. STATUS mb87030CtrlInit
  276.     (
  277.     FAST MB_87030_SCSI_CTRL *pSpc, /* ptr to SPC struct */
  278.     FAST int scsiCtrlBusId,        /* SCSI bus ID of this SPC */
  279.     FAST UINT defaultSelTimeOut,   /* default dev sel timeout (microsec) */
  280.     int scsiPriority               /* priority of task doing SCSI I/O */
  281.     )
  282.     {
  283.     UINT tempSelTimeOut; /* temp. value of select time-out (no units) */
  284.     int busFreeDelay = SPC_DEF_BUS_FREE_DELAY;
  285.     int busFreeDelayParity; /* parity of busFreeDelay parameter */
  287.     /* verify scsiCtrlBusId and enter legal value in SPC structure */
  289.     if (scsiCtrlBusId < SCSI_MIN_BUS_ID || scsiCtrlBusId > SCSI_MAX_BUS_ID)
  290. return (ERROR);
  292.     pSpc->scsiCtrl.scsiCtrlBusId = (UINT8) scsiCtrlBusId;
  294.     /* verify scsiPriority and enter legal value in SPC structure */
  296.     if (scsiPriority < NONE || scsiPriority > 0xff)
  297. return (ERROR);
  299.    pSpc->scsiCtrl.scsiPriority = scsiPriority;
  301.     /* adjust busFreeDelay parity, and enter value in SPC structure */
  303.     if (pSpc->spcDataParity != SPC_DATA_PARITY_VALID)
  304.         {
  305.         busFreeDelayParity = byteParityGet ((UINT8) busFreeDelay);
  307.         if (busFreeDelayParity == pSpc->spcDataParity)
  308.             busFreeDelay ^= 0x1;
  309.         }
  311.     pSpc->busFreeDelay = busFreeDelay;
  313.     /* verify defaultSelTimeOut, convert it from usec to SPC register values,
  314.      * and enter value in SPC structure
  315.      */
  317.     spcSelTimeOutCvt (&pSpc->scsiCtrl, defaultSelTimeOut, &tempSelTimeOut);
  318.     pSpc->defaultSelTimeOut = (UINT16) tempSelTimeOut;
  320.     /* disconnect not supported for now */
  322.     pSpc->scsiCtrl.disconnect = (TBOOL) FALSE;
  324.     spcHwInit (pSpc);  /* initialize the SPC hardware */
  326.     return (OK);
  327.     }
  329. /*******************************************************************************
  330. *
  331. * spcDevSelect - attempt to select a SCSI physical device
  332. *
  333. * This routine is intended to be called from scsiLib, not directly.
  334. *
  335. * RETURNS: OK if device was successfully selected, otherwise ERROR.
  336. */
  338. LOCAL STATUS spcDevSelect
  339.     (
  340.     FAST SCSI_PHYS_DEV *pScsiPhysDev,   /* ptr to SCSI physical device info */
  341.     SCSI_TRANSACTION *pScsiXaction      /* ptr to SCSI transaction info */
  342.     )
  343.     {
  344.     FAST SPC *pSpc; /* ptr to SPC info */
  345.     int spcBusId;               /* SCSI bus ID of the SPC */
  346.     UINT8 identMsg; /* for construction of the IDENTIFY message */
  347.     STATUS status; /* placeholder for status */
  348.     int scsiPhase; /* SCSI bus phase following the select */
  350.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  352.     if (spcBusIdGet (pSpc, &spcBusId) == ERROR)
  353.         return (ERROR);
  355.     if (spcBusId == pScsiPhysDev->scsiDevBusId)
  356.         return (ERROR);
  358.     pSpc->selectTempReg = (UINT8) ((1 << spcBusId) |
  359.    (1 << pScsiPhysDev->scsiDevBusId));
  361.     pSpc->pDevToSelect  = pScsiPhysDev;
  362.     pScsiPhysDev->devStatus = SELECT_REQUESTED;
  363.     *pSpc->pPctlReg |= SPC_PCTL_BF_INT_ENBL;
  365.     semTake (&pScsiPhysDev->devSyncSem, WAIT_FOREVER);
  367.     if (pScsiPhysDev->devStatus == SELECT_SUCCESSFUL)
  368. {
  369. if (pScsiPhysDev->useIdentify)  /* send an identify message */
  370.          {
  371.     if ((spcBusPhaseGet (&pSpc->scsiCtrl, 0,
  372.  &scsiPhase) == ERROR) ||
  373. (scsiPhase != SCSI_MSG_OUT_PHASE))
  374. {
  375. SCSI_DEBUG_MSG ("scsiPhase = %xn", scsiPhase,
  376. 0, 0, 0, 0, 0);
  377. return (ERROR);
  378. }
  380.             identMsg = SCSI_MSG_IDENTIFY |
  381.        (pSpc->scsiCtrl.disconnect ?
  382. SCSI_MSG_IDENT_DISCONNECT : 0) |
  383.        (UINT8) pScsiPhysDev->scsiDevLUN;
  385.     status = spcProgBytesOut (pScsiPhysDev, &identMsg,
  386.       sizeof (identMsg), scsiPhase);
  388.     if (status == ERROR)
  389. return (ERROR);
  390.             }
  391.         return (OK);
  392. }
  394.     if (pScsiPhysDev->devStatus == SELECT_TIMEOUT)
  395. errnoSet (S_scsiLib_SELECT_TIMEOUT);
  397.     return (ERROR);
  398.     }
  400. /*******************************************************************************
  401. *
  402. * spcManBytesOut - output byte(s) to SCSI using manual transfer
  403. *
  404. * RETURNS: OK.
  405. *
  406. * NOMANUAL
  407. */
  409. STATUS spcManBytesOut
  410.     (
  411.     FAST SPC *pSpc,             /* ptr to SPC info */
  412.     FAST UINT8 *pBuffer,        /* ptr to the output buffer */
  413.     FAST int bufLength,         /* length of the output buffer */
  414.     BOOL atnReset               /* whether ATN should be reset on last byte */
  415.     )
  416.     {
  417.     FAST int ix;
  419.     for (ix = 0; ix < bufLength; ix++)
  420. {
  421.         while (!(*pSpc->pPsnsReg & SPC_PSNS_REQ))
  422.             ;
  424.         if (atnReset && (ix == bufLength - 1))
  425.             spcCommand (pSpc, SPC_SCMD_RESET_ATN);
  427.         *pSpc->pTempReg = *pBuffer++;
  428.         spcCommand (pSpc, SPC_SCMD_SET_ACK_REQ);
  430.         while (*pSpc->pPsnsReg & SPC_PSNS_REQ)
  431.             ;
  433.         spcCommand (pSpc, SPC_SCMD_RESET_ACK_REQ);
  434. }
  436.     return (OK);
  437.     }
  439. /*******************************************************************************
  440. *
  441. * spcManBytesIn - input byte(s) from SCSI using manual transfer
  442. *
  443. * RETURNS: OK.
  444. *
  445. * NOMANUAL
  446. */
  448. STATUS spcManBytesIn
  449.     (
  450.     FAST SPC *pSpc,             /* ptr to SPC info */
  451.     FAST UINT8 *pBuffer,        /* ptr to the input buffer */
  452.     FAST int bufLength          /* length of the input buffer */
  453.     )
  454.     {
  455.     FAST int ix;
  457.     for (ix = 0; ix < bufLength; ix++)
  458. {
  459.         while (!(*pSpc->pPsnsReg & SPC_PSNS_REQ))
  460.             ;
  462.         spcCommand (pSpc, SPC_SCMD_SET_ACK_REQ);
  464.         while (*pSpc->pPsnsReg & SPC_PSNS_REQ)
  465.             ;
  467.         *pBuffer++ = *pSpc->pTempReg;
  469. spcCommand (pSpc, SPC_SCMD_RESET_ACK_REQ);
  470. }
  472.     semGive (&pSpc->scsiCtrl.ctrlSyncSem);
  473.     return (OK);
  474.     }
  476. /*******************************************************************************
  477. *
  478. * spcMsgInAck - de-assert the ACK line to accept message
  479. *
  480. * This routine should be called when an incoming message has been read and
  481. * accepted.  If the incoming message did not imply an impending disconnect,
  482. * give the synchronization semaphore, so that subsequent phase can be
  483. * detected.
  484. *
  485. * RETURNS: OK.
  486. */
  488. LOCAL STATUS spcMsgInAck
  489.     (
  490.     FAST SCSI_CTRL *pScsiCtrl,  /* ptr to SPC info */
  491.     BOOL expectDisconn          /* whether a disconnect is expected */
  492.     )
  493.     {
  494.     spcCommand ((SPC *) pScsiCtrl, SPC_SCMD_RESET_ACK_REQ);
  496.     if (!expectDisconn)
  497. semGive (&pScsiCtrl->ctrlSyncSem);
  499.     return (OK);
  500.     }
  502. /*******************************************************************************
  503. *
  504. * spcProgBytesOut - output bytes to SCSI using 'program' transfer
  505. *
  506. * RETURNS: OK if successful, otherwise ERROR.
  507. *
  508. * INTERNAL
  509. * Error handling is inadequate.
  510. *
  511. * NOMANUAL
  512. */
  514. STATUS spcProgBytesOut
  515.     (
  516.     SCSI_PHYS_DEV *pScsiPhysDev, /* ptr to physical device info */
  517.     FAST UINT8 *pBuffer,         /* ptr to the data buffer */
  518.     FAST int bufLength,          /* number of bytes to be transferred */
  519.     int scsiPhase                /* phase of the transfer */
  520.     )
  521.     {
  522.     FAST SPC *pSpc; /* ptr to SPC info */
  524.     SCSI_DEBUG_MSG ("spcProgBytesOut: bufLength = %d, scsiPhase = %dn",
  525.     bufLength, scsiPhase, 0, 0, 0, 0);
  527.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  529.     spcIntsDisable (pSpc);
  531.     if (spcXferCountSet (pSpc, bufLength) == ERROR)
  532. return (ERROR);
  534.     SPC_BUS_PHASE_SET(pSpc, scsiPhase);
  536.     if (scsiPhase == SCSI_COMMAND_PHASE)
  537.         spcTmodSet (pSpc, pScsiPhysDev->syncXfer, 0, 0);
  539.     spcScmdSet (pSpc, SPC_SCMD_XFER, 0, 0, 1, 0);
  541.     while (!(*pSpc->pSstsReg & SPC_SSTS_XFER))
  542.         ;
  544.     while (bufLength >= 8)
  545. {
  546.         while (!(*pSpc->pSstsReg & SPC_SSTS_DREG_EMPTY))
  547.             ;
  548.         *pSpc->pDregReg = *pBuffer++;
  549.         *pSpc->pDregReg = *pBuffer++;
  550.         *pSpc->pDregReg = *pBuffer++;
  551.         *pSpc->pDregReg = *pBuffer++;
  552.         *pSpc->pDregReg = *pBuffer++;
  553.         *pSpc->pDregReg = *pBuffer++;
  554.         *pSpc->pDregReg = *pBuffer++;
  555.         *pSpc->pDregReg = *pBuffer++;
  556. bufLength -= 8;
  557.         }
  559.     while (!(*pSpc->pSstsReg & SPC_SSTS_DREG_EMPTY))
  560.         ;
  562.     while (bufLength > 0)
  563.         {
  564.         *pSpc->pDregReg = *pBuffer++;
  565. bufLength--;
  566.         }
  568.     spcIntsEnable (pSpc);
  570.     return (OK);
  571.     }
  573. /*******************************************************************************
  574. *
  575. * spcProgBytesIn - input bytes from SCSI using 'program' transfer
  576. *
  577. * RETURNS: OK if successful, otherwise ERROR.
  578. *
  579. * INTERNAL
  580. * Error handling is inadequate.
  581. *
  582. * NOMANUAL
  583. */
  585. STATUS spcProgBytesIn
  586.     (
  587.     SCSI_PHYS_DEV *pScsiPhysDev,        /* ptr to physical device info */
  588.     FAST UINT8 *pBuffer,                /* ptr to the data buffer */
  589.     FAST int bufLength,                 /* number of bytes to be transferred */
  590.     int scsiPhase                       /* phase of the transfer */
  591.     )
  592.     {
  593.     FAST SPC *pSpc; /* ptr to SPC info */
  595.     SCSI_DEBUG_MSG ("spcProgBytesIn: bufLength = %d, scsiPhase = %dn",
  596.     bufLength, scsiPhase, 0, 0, 0, 0);
  598.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  600.     spcIntsDisable (pSpc);
  602.     if (spcXferCountSet (pSpc, bufLength) == ERROR)
  603. return (ERROR);
  605.     SPC_BUS_PHASE_SET(pSpc, scsiPhase);
  606.     spcScmdSet (pSpc, SPC_SCMD_XFER, 0, 0, 1, 0);
  608.     while (!(*pSpc->pSstsReg & SPC_SSTS_XFER))
  609.         ;
  611.     while (bufLength >= 8)
  612. {
  613.         while (!(*pSpc->pSstsReg & SPC_SSTS_DREG_FULL))
  614.             ;
  615.         *pBuffer++ = *pSpc->pDregReg;
  616.         *pBuffer++ = *pSpc->pDregReg;
  617.         *pBuffer++ = *pSpc->pDregReg;
  618.         *pBuffer++ = *pSpc->pDregReg;
  619.         *pBuffer++ = *pSpc->pDregReg;
  620.         *pBuffer++ = *pSpc->pDregReg;
  621.         *pBuffer++ = *pSpc->pDregReg;
  622.         *pBuffer++ = *pSpc->pDregReg;
  623. bufLength -= 8;
  624.         }
  626.     while (bufLength > 0)
  627.         {
  628.         while (*pSpc->pSstsReg & SPC_SSTS_DREG_EMPTY)
  629.             ;
  630.         *pBuffer++ = *pSpc->pDregReg;
  631. bufLength--;
  632.         }
  634.     spcIntsEnable (pSpc);
  636.     return (OK);
  637.     }
  639. /******************************************************************************
  640. *
  641. * spcDmaBytesOut - Setup DMA transfer on the device
  642. *
  643. * RETURNS: OK, or ERROR if the count is not set properly.
  644. */
  646. LOCAL STATUS spcDmaBytesOut
  647.     (
  648.     SCSI_PHYS_DEV *pScsiPhysDev,        /* ptr to phys dev info    */
  649.     UINT8 *pBuffer,                     /* prt to the data buffer  */
  650.     int    bufLength,                   /* nubmer of bytes to xfer */
  651.     int    scsiPhase
  652.     )
  653.     {
  654.     FAST SPC *pSpc;             /* ptr to SPC info */
  656.     SCSI_DEBUG_MSG ("spcDmaBytesOut: bufLength = %d, Address = %08xn",
  657.                     bufLength, (int) &pBuffer, 0, 0, 0, 0);
  659.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  661.     spcIntsDisable (pSpc);
  663.     if (spcXferCountSet (pSpc, bufLength) == ERROR)
  664.         return (ERROR);
  666.     SPC_BUS_PHASE_SET(pSpc, scsiPhase);
  667.     if (scsiPhase == SCSI_COMMAND_PHASE)
  668.         spcTmodSet (pSpc, pScsiPhysDev->syncXfer, 0, 0);
  670.     spcScmdSet (pSpc, SPC_SCMD_XFER, 0, 0, 0, 0);
  672.     return ((pSpc->scsiCtrl.scsiDmaBytesOut)
  673.             (pScsiPhysDev, (UINT8 *) pBuffer, bufLength));
  674.     }
  675.  
  676. /*******************************************************************************
  677. *
  678. * spcBytesOut - branch to the appropriate output routine dependent on SCSI phase
  679. *
  680. * RETURNS: OK if specified bytes were output successfully, otherwise ERROR.
  681. */
  683. LOCAL STATUS spcBytesOut
  684.     (
  685.     FAST SCSI_PHYS_DEV *pScsiPhysDev,   /* ptr to SCSI physical dev info */
  686.     FAST char *pBuffer,                 /* ptr to byte buffer for output */
  687.     int bufLength,                      /* number of bytes to be transferred */
  688.     int scsiPhase                       /* SCSI bus phase of the transfer */
  689.     )
  690.     {
  691.     FAST SPC *pSpc; /* ptr to SPC info */
  693.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  695.     if ((scsiPhase != SCSI_DATA_OUT_PHASE) ||
  696. (pSpc->scsiCtrl.scsiDmaBytesOut == NULL) ||
  697. (bufLength < 10))
  698. return (spcProgBytesOut (pScsiPhysDev, (UINT8 *) pBuffer,
  699.  bufLength, scsiPhase));
  700.     else
  701. return ((spcDmaBytesOut)
  702. (pScsiPhysDev, (UINT8 *) pBuffer, bufLength, scsiPhase));
  703.     }
  705. /******************************************************************************
  706. *
  707. * spcDmaBytesIn - Setup DMA transfer on the device
  708. *
  709. * RETURNS: OK, or ERROR if the count is not set properly.
  710. */
  712. LOCAL STATUS spcDmaBytesIn
  713.     (
  714.     SCSI_PHYS_DEV *pScsiPhysDev,        /* ptr to phys dev info    */
  715.     UINT8 *pBuffer,                     /* prt to the data buffer  */
  716.     int    bufLength,                   /* nubmer of bytes to xfer */
  717.     int    scsiPhase
  718.     )
  719.     {
  720.     FAST SPC *pSpc;             /* ptr to SPC info */
  722.     SCSI_DEBUG_MSG ("spcDmaBytesIn: bufLength = %d, Addr = %08xn",
  723.                     bufLength, (int) &pBuffer, 0, 0, 0, 0);
  724.  
  725.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  727.     spcIntsDisable (pSpc);
  729.     if (spcXferCountSet (pSpc, bufLength) == ERROR)
  730.         return (ERROR);
  732.     SPC_BUS_PHASE_SET(pSpc, scsiPhase);
  733.     spcScmdSet (pSpc, SPC_SCMD_XFER, 0, 0, 0, 0);
  735.     return ((pSpc->scsiCtrl.scsiDmaBytesIn)
  736.             (pScsiPhysDev, (UINT8 *) pBuffer, bufLength));
  737.     }
  739. /*******************************************************************************
  740. *
  741. * spcBytesIn - branch to the appropriate input routine dependent on SCSI phase
  742. *
  743. * RETURNS: OK if requested bytes were input successfully, otherwise ERROR.
  744. */
  746. LOCAL STATUS spcBytesIn
  747.     (
  748.     FAST SCSI_PHYS_DEV *pScsiPhysDev,   /* ptr to SCSI physical dev info */
  749.     FAST char *pBuffer,                 /* ptr to byte buffer for output */
  750.     int bufLength,                      /* number of bytes to be transferred */
  751.     int scsiPhase                       /* SCSI bus phase of the transfer */
  752.     )
  753.     {
  754.     FAST SPC *pSpc; /* ptr to SPC info */
  756.     pSpc = (SPC *) pScsiPhysDev->pScsiCtrl;
  758.     switch (scsiPhase)
  759. {
  760. case SCSI_DATA_IN_PHASE:
  761.     if ((pSpc->scsiCtrl.scsiDmaBytesIn == NULL) ||
  762. (bufLength < 10))
  763. return (spcProgBytesIn (pScsiPhysDev, (UINT8 *) pBuffer,
  764.         bufLength, scsiPhase));
  765.     else
  766. return (spcDmaBytesIn (pScsiPhysDev, (UINT8 *) pBuffer,
  767.      bufLength, scsiPhase));
  769. case SCSI_STATUS_PHASE:
  770.     return (spcProgBytesIn (pScsiPhysDev, (UINT8 *) pBuffer,
  771.     bufLength, scsiPhase));
  772. case SCSI_MSG_IN_PHASE:
  773.     return (spcManBytesIn (pSpc, (UINT8 *) pBuffer, bufLength));
  774. }
  776.     return (ERROR);
  777.     }
  779. #define CYCLES_PER_USEC  1
  781. /*******************************************************************************
  782. *
  783. * spcBusPhaseGet - return the current SCSI bus phase in *pBusPhase
  784. *
  785. * INTERNAL
  786. * Should do an errnoSet.
  787. */
  789. LOCAL STATUS spcBusPhaseGet
  790.     (
  791.     FAST SCSI_CTRL *pScsiCtrl,  /* ptr to SCSI controller info */
  792.     int timeOutInUsec,          /* timeout in usec (0 == infinity) */
  793.     int *pBusPhase              /* ptr to returned bus phase */
  794.     )
  795.     {
  796.     FAST int ix = 0; /* loop index */
  797.     FAST SPC *pSpc; /* ptr to SPC info */
  798.     FAST int maxCycles; /* maximum cycles to wait for REQ signal */
  800.     pSpc = (SPC *) pScsiCtrl;
  802.     maxCycles = timeOutInUsec * CYCLES_PER_USEC;
  804.     if (semTake (&pScsiCtrl->ctrlSyncSem, sysClkRateGet() * 5) == ERROR)
  805. {
  806. spcScsiBusReset (pSpc); /* the bus is hung(?), reset it */
  807. return (ERROR);
  808. }
  810.     while (!(*pSpc->pPsnsReg & SPC_PSNS_REQ) &&
  811.    (pScsiCtrl->scsiBusPhase != SCSI_BUS_FREE_PHASE))
  812. {
  813. if ((maxCycles > 0) && (ix++ == maxCycles))
  814.     {
  815.     if (scsiDebug)
  816.         logMsg ("spcBusPhaseGet: timed-out waiting for REQn",
  817. 0, 0, 0, 0, 0, 0);
  818.     spcScsiBusReset (pSpc); /* the bus is hung(?), reset it */
  819.     return (ERROR);
  820.     }
  821. }
  823.     if (pScsiCtrl->scsiBusPhase == SCSI_BUS_FREE_PHASE)
  824.         {
  825.         *pBusPhase = SCSI_BUS_FREE_PHASE;
  826.         pScsiCtrl->scsiBusPhase = NONE;
  827.         return (OK);
  828.         }
  830.     *pBusPhase = pScsiCtrl->scsiBusPhase =
  831. (int) (*pSpc->pPsnsReg & SPC_PSNS_PHASE_MASK);
  833.     SCSI_DEBUG_MSG ("scsiPhase = %xn", *pBusPhase, 0, 0, 0, 0, 0);
  835.     return (OK);
  836.     }
  838. /*******************************************************************************
  839. *
  840. * byteParityGet - return the parity of a given byte
  841. *
  842. * RETURNS: 1 for odd parity, 0 for even parity.
  843. */
  845. LOCAL int byteParityGet
  846.     (
  847.     FAST UINT8 byte             /* byte for which to report parity */
  848.     )
  849.     {
  850.     FAST int result = 0; /* cumulative parity of byte */
  851.     FAST int ix; /* loop variable */
  853.     for (ix = 0; ix < 8; ix++)
  854. {
  855. if (byte & ((UINT8) (1 << ix)))
  856.     result ^= 0x1;
  857. }
  859.     return (result);
  860.     }
  862. /*******************************************************************************
  863. *
  864. * spcSelTimeOutCvt - convert a select time-out in microseconds to its
  865. *      equivalent SPC setting
  866. *
  867. * The conversion formula is given on p. 4-8 of the 1988 Fujitsu SCSI Product
  868. * Profiles manual.  The additive constant 15 has been omitted here since it is
  869. * trivial.  Note that 0 translates to the standard setting of 250 usec.  Also,
  870. * the SPC accepts up to a 16 bit time-out, so a maximum value of 0xffff is
  871. * returned in *pTimeOutSetting.
  872. */
  874. LOCAL void spcSelTimeOutCvt
  875.     (
  876.     FAST SCSI_CTRL *pScsiCtrl,          /* ptr to SCSI controller info */
  877.     FAST UINT timeOutInUsec,            /* time-out in microsecs */
  878.     FAST UINT *pTimeOutSetting          /* time-out equivalent setting */
  879.     )
  880.     {
  881.     FAST SPC *pSpc = (SPC *) pScsiCtrl; /* ptr to SPC info */
  882.     FAST UINT tempSelTimeOut; /* temp. select time-out setting */
  883.     int msbParity; /* parity of MSB of tempSelTimeOut */
  884.     int lsbParity; /* parity of LSB of tempSelTimeOut */
  886.     if (timeOutInUsec == 0)
  887. timeOutInUsec = SCSI_DEF_SELECT_TIMEOUT;
  889.     tempSelTimeOut = (((timeOutInUsec * 1000) >> 9) / pScsiCtrl->clkPeriod) + 1;
  890.     if (tempSelTimeOut > 0xffff)
  891. tempSelTimeOut = 0xffff;
  893.     if (pSpc->spcDataParity != SPC_DATA_PARITY_VALID)
  894. {
  895. msbParity = byteParityGet ((UINT8) MSB(tempSelTimeOut));
  896. lsbParity = byteParityGet ((UINT8) LSB(tempSelTimeOut));
  898. if (msbParity == pSpc->spcDataParity)
  899.     tempSelTimeOut ^= 0x100;
  901. if (lsbParity == pSpc->spcDataParity)
  902.     tempSelTimeOut ^= 0x1;
  903. }
  905.     *pTimeOutSetting = tempSelTimeOut;
  906.     }
  908. /*******************************************************************************
  909. *
  910. * spcBusIdGet - get the current SCSI bus ID of the SPC.
  911. *
  912. * Copies the bus ID to <pBusId>.
  913. *
  914. * RETURNS:
  915. * OK if Bus ID register holds a legal value, otherwise ERROR.
  916. */
  918. LOCAL STATUS spcBusIdGet
  919.     (
  920.     FAST SPC *pSpc,             /* ptr to SPC info */
  921.     FAST int *pBusId            /* ptr to returned bus ID */
  922.     )
  923.     {
  924.     FAST UINT8 tempReg;  /* local copy of bus device ID register */
  925.     FAST int ix; /* count index */
  927.     tempReg = *pSpc->pBdidReg;
  928.     for (ix = SCSI_MIN_BUS_ID; ix <= SCSI_MAX_BUS_ID; ix++)
  929. {
  930. if (tempReg == (UINT8) (1 << ix))
  931.     {
  932.     *pBusId = ix;
  933.     return (OK);
  934.     }
  935. }
  936.     *pBusId = NONE;
  937.     return (ERROR);
  938.     }
  940. /*******************************************************************************
  941. *
  942. * spcXferCountSet - load the SPC transfer counter with the specified count
  943. *
  944. * RETURNS:
  945. * OK if count is in range 0 - 0xffffff, otherwise ERROR.
  946. *
  947. * NOMANUAL
  948. */
  950. STATUS spcXferCountSet
  951.     (
  952.     FAST SPC *pSpc,     /* ptr to SPC info */
  953.     FAST int count      /* count value to load */
  954.     )
  955.     {
  956.     if (count < 0 || count > SPC_MAX_XFER_LENGTH)
  957.         return (ERROR);
  958.     else
  959.         {
  960.         *pSpc->pTchReg = (UINT8) ((count >> 16) & 0xff);
  961.         *pSpc->pTcmReg = (UINT8) ((count >>  8) & 0xff);
  962.         *pSpc->pTclReg = (UINT8)  (count   & 0xff);
  963.         return (OK);
  964.         }
  965.     }
  967. /*******************************************************************************
  968. *
  969. * spcXferCountGet - fetch the SPC transfer count
  970. *
  971. * RETURNS: The value of the transfer counter is returned in *pCount.
  972. *
  973. * NOMANUAL
  974. */
  976. void spcXferCountGet
  977.     (
  978.     FAST SPC *pSpc,             /* ptr to SPC info */
  979.     FAST int *pCount            /* ptr to returned value */
  980.     )
  981.     {
  982.     FAST UINT tempCount = 0;
  984.     tempCount |=  (UINT) *pSpc->pTclReg;
  985.     tempCount |= ((UINT) *pSpc->pTcmReg) << 8;
  986.     tempCount |= ((UINT) *pSpc->pTchReg) << 16;
  987.     *pCount = tempCount;
  988.     }
  990. /*******************************************************************************
  991. *
  992. * spcIntsEnable - enable the SPC to assert interrupts
  993. *
  994. * This routine sets the INT Enable bit in the SPC Control register.
  995. */
  997. LOCAL void spcIntsEnable
  998.     (
  999.     FAST SPC *pSpc      /* ptr to SPC info */
  1000.     )
  1001.     {
  1002.     *pSpc->pSctlReg |= SPC_SCTL_INT_ENBL;
  1003.     }
  1005. /*******************************************************************************
  1006. *
  1007. * spcIntsDisable - disable the SPC to assert interrupts
  1008. *
  1009. * This routine resets the INT Enable bit in the SPC Control register.
  1010. */
  1012. LOCAL void spcIntsDisable
  1013.     (
  1014.     FAST SPC *pSpc      /* ptr to SPC info */
  1015.     )
  1016.     {
  1017.     *pSpc->pSctlReg &= ~SPC_SCTL_INT_ENBL;
  1018.     }
  1020. /*******************************************************************************
  1021. *
  1022. * spcScmdSet - write to the SPC Command Register
  1023. *
  1024. * Provides maximum flexibility in controlling the options of the Command Reg.
  1025. * The passed parameter for each bit should be set to SPC_RESET_BIT (0),
  1026. * SPC_SET_BIT (1), or SPC_PRESERVE_BIT (-1).  In the case of the command code,
  1027. * either the desired command code or SPC_PRESERVE_FIELD (0xff) should be passed.
  1028. */
  1030. LOCAL void spcScmdSet
  1031.     (
  1032.     FAST SPC *pSpc,         /* ptr to SPC info */
  1033.     FAST UINT8 cmdCode,     /* new command code or SPC_PRESERVE_FIELD */
  1034.     int resetOutBit,        /* set, reset, or preserve "reset out" bit */
  1035.     int interceptXferBit,   /* set, reset, or preserve "intercept xfer" bit */
  1036.     int prgXferBit,         /* set, reset, or preserve "program transfer" bit */
  1037.     int termModeBit         /* set, reset, or preserve "termination mode" bit */
  1038.     )
  1039.     {
  1040.     FAST UINT8 tempScmd;    /* temporary copy of SPC Command register */
  1042.     tempScmd = *pSpc->pScmdReg;
  1043.     if (cmdCode != SPC_PRESERVE_FIELD)
  1044.         {
  1045.         tempScmd &= ~SPC_SCMD_CMD_MASK;     /* clear existing command code */
  1046.                                             /* fill in the desired command */
  1047.         tempScmd |= (cmdCode & SPC_SCMD_CMD_MASK);
  1048.         }
  1049.     switch (resetOutBit)
  1050.         {
  1051.         case SPC_PRESERVE_BIT:  break;
  1052.         case SPC_SET_BIT:       tempScmd |= SPC_SCMD_RESET_OUT; break;
  1053.         case SPC_RESET_BIT:     tempScmd &= ~SPC_SCMD_RESET_OUT; break;
  1054.         }
  1055.     switch (interceptXferBit)
  1056.         {
  1057.         case SPC_PRESERVE_BIT:  break;
  1058.         case SPC_SET_BIT:       tempScmd |= SPC_SCMD_INTERCEPT_XFER; break;
  1059.         case SPC_RESET_BIT:     tempScmd &= ~SPC_SCMD_INTERCEPT_XFER; break;
  1060.         }
  1061.     switch (prgXferBit)
  1062.         {
  1063.         case SPC_PRESERVE_BIT:  break;
  1064.         case SPC_SET_BIT:       tempScmd |= SPC_SCMD_PRG_XFER; break;
  1065.         case SPC_RESET_BIT:     tempScmd &= ~SPC_SCMD_PRG_XFER; break;
  1066.         }
  1067.     switch (termModeBit)
  1068.         {
  1069.         case SPC_PRESERVE_BIT:  break;
  1070.         case SPC_SET_BIT:       tempScmd |= SPC_SCMD_TERM_MODE; break;
  1071.         case SPC_RESET_BIT:     tempScmd &= ~SPC_SCMD_TERM_MODE; break;
  1072.         }
  1073.     *pSpc->pScmdReg = tempScmd;
  1074.     }
  1076. /*******************************************************************************
  1077. *
  1078. * spcCommand - write a command code to the SPC Command Register
  1079. *
  1080. * NOMANUAL
  1081. */
  1083. void spcCommand
  1084.     (
  1085.     FAST SPC *pSpc,     /* ptr to SPC info */
  1086.     FAST UINT8 cmdCode      /* new command code */
  1087.     )
  1088.     {
  1089.     FAST UINT8 tempScmd;    /* temporary copy of SPC Command register */
  1091.     tempScmd = *pSpc->pScmdReg;
  1092.     tempScmd &= ~SPC_SCMD_CMD_MASK;        /* clear existing command code */
  1093.     tempScmd |= (cmdCode & SPC_SCMD_CMD_MASK); /* fill in the desired command */
  1094.     *pSpc->pScmdReg = tempScmd;
  1095.     }
  1097. /*******************************************************************************
  1098. *
  1099. * spcTmodSet - write to the SPC Transfer Mode Register
  1100. *
  1101. * Used to set up SPC for synchronous or asynchronous data transfers. maxOffset
  1102. * and minPeriod parameters may be specified as legal values:
  1103. *           maxOffset:          1 - 8       (see Fujitsu documentation)
  1104. *           minPerMinusOne:     0 - 3       (see Fujitsu documentation)
  1105. * or as SPC_PRESERVE_FIELD (0xff).  They will be ignored if syncXfer is FALSE,
  1106. * since they are only relevant to synchronous transfer mode.  Illegal values
  1107. * will merely be masked into legality.
  1108. */
  1110. LOCAL void spcTmodSet
  1111.     (
  1112.     FAST SPC *pSpc,     /* ptr to SPC info */
  1113.     BOOL syncXfer,              /* TRUE for synch. xfer, FALSE for asynch. */
  1114.     FAST int maxOffset,         /* maximum transfer offset */
  1115.     FAST int minPerMinusOne     /* minimum transfer period minus one */
  1116.     )
  1117.     {
  1118.     FAST UINT8 tempTmod;    /* temporary copy of SPC Transfer Mode register */
  1120.     tempTmod = *pSpc->pTmodReg;
  1121.     if (syncXfer == FALSE)
  1122.         tempTmod &= ~SPC_TMOD_SYNC_XFER;
  1123.     else
  1124.         {
  1125.         tempTmod |= SPC_TMOD_SYNC_XFER;
  1126.         if (maxOffset != SPC_PRESERVE_FIELD)
  1127.             {
  1128.             tempTmod &= ~SPC_TMOD_MAX_OFFSET_MASK;  /* clear existing offset */
  1129.                                                     /* set the desired offset */
  1130.             tempTmod |= ((maxOffset << 4) & SPC_TMOD_MAX_OFFSET_MASK);
  1131.             }
  1132.         if (minPerMinusOne != SPC_PRESERVE_FIELD)
  1133.             {
  1134.             tempTmod &= ~SPC_TMOD_MIN_PERIOD_MASK;  /* clear existing period */
  1135.                                                     /* set the desired period */
  1136.             tempTmod |= ((minPerMinusOne << 2) & SPC_TMOD_MIN_PERIOD_MASK);
  1137.             }
  1138.         }
  1139.     *pSpc->pTmodReg = tempTmod;
  1140.     }
  1142. /*******************************************************************************
  1143. *
  1144. * spcPctlSet - write to the SPC Phase Control Register
  1145. *
  1146. * Provides flexibility in controlling the options of the Phase Control Reg.
  1147. * The passed parameter for the busFreeIntEnbl bit should be set to
  1148. * SPC_RESET_BIT (0), SPC_SET_BIT (1), or SPC_PRESERVE_BIT (-1).  In the case
  1149. * of the transfer phase, either the desired phase or SPC_PRESERVE_FIELD
  1150. * (0xff) should be passed.
  1151. */
  1153. LOCAL void spcPctlSet
  1154.     (
  1155.     FAST SPC *pSpc,         /* ptr to SPC info */
  1156.     int busFreeIntEnblBit,  /* set, reset, or preserve "bus free int." bit */
  1157.     FAST UINT8 xferPhase    /* new transfer phase or SPC_PRESERVE_FIELD */
  1158.     )
  1159.     {
  1160.     FAST UINT8 tempPctl;    /* temporary copy of SPC Pctl register */
  1162.     tempPctl = *pSpc->pPctlReg;
  1163.     switch (busFreeIntEnblBit)
  1164.         {
  1165.         case SPC_PRESERVE_BIT:  break;
  1166.         case SPC_SET_BIT:       tempPctl |= SPC_PCTL_BF_INT_ENBL; break;
  1167.         case SPC_RESET_BIT:     tempPctl &= ~SPC_PCTL_BF_INT_ENBL; break;
  1168.         }
  1169.     if (xferPhase != SPC_PRESERVE_FIELD)
  1170.         {
  1171.         tempPctl &= ~SPC_PCTL_PHASE_MASK;   /* clear existing xfer phase */
  1172.                                             /* fill in the new phase */
  1173.         tempPctl |= (xferPhase & SPC_PCTL_PHASE_MASK);
  1174.         }
  1175.     *pSpc->pPctlReg = tempPctl;
  1176.     }
  1178. /*******************************************************************************
  1179. *
  1180. * spcScsiBusReset - assert the RST line on the SCSI bus
  1181. *
  1182. * Asserts the RST line on SCSI which should cause all connected devices to
  1183. * return to a quiescent state.
  1184. * JCC Timing delays should be made prettier and more precise.
  1185. */
  1187. LOCAL void spcScsiBusReset
  1188.     (
  1189.     FAST SPC *pSpc      /* ptr to SPC info */
  1190.     )
  1191.     {
  1192.     int delayVar; /* delay loop counter */
  1194.     spcScmdSet (pSpc,
  1195.                 SPC_SCMD_BUS_RELEASE,
  1196.                 SPC_SET_BIT,
  1197.                 SPC_PRESERVE_BIT,
  1198.                 SPC_PRESERVE_BIT,
  1199.                 SPC_PRESERVE_BIT);
  1201.     for (delayVar = 0; delayVar < 0x1000; delayVar++)
  1202. ;
  1204.     spcScmdSet (pSpc,
  1205.                 SPC_PRESERVE_FIELD,
  1206.                 SPC_RESET_BIT,
  1207.                 SPC_PRESERVE_BIT,
  1208.                 SPC_PRESERVE_BIT,
  1209.                 SPC_PRESERVE_BIT);
  1211.     for (delayVar = 0; delayVar < 0x2000; delayVar++)
  1212. ;
  1213.     }
  1215. LOCAL BOOL spcHardErrPrint = FALSE;
  1216. LOCAL int hardErrors = 0;
  1218. /*******************************************************************************
  1219. *
  1220. * spcIntr - interrupt service routine for the SPC
  1221. *
  1222. * NOMANUAL
  1223. */
  1225. void spcIntr
  1226.     (
  1227.     SPC *pSpc          /* ptr to SPC info */
  1228.     )
  1229.     {
  1230.     FAST SCSI_PHYS_DEV *pDevToSelect;
  1231.     FAST UINT8 tempInts;
  1232.     FAST UINT8 tempSerr;
  1234.     tempInts = *pSpc->pIntsReg;
  1235.     tempSerr = *pSpc->pSerrReg;
  1237.     if (scsiIntsDebug)
  1238.         logMsg ("*** SPC INTERRUPT: Ints %08x, Serr %08x", tempInts, tempSerr,
  1239. 0, 0, 0, 0);
  1241.     if (tempInts & SPC_INTS_SELECTED)
  1242.         {
  1243. /* this is currently not supported */
  1244.         *pSpc->pIntsReg = SPC_INTS_SELECTED;
  1245. if (scsiIntsDebug)
  1246.             logMsg ("Selected ", 0, 0, 0, 0, 0, 0);
  1247.         }
  1249.     if (tempInts & SPC_INTS_RESELECTED)
  1250.         {
  1251.         *pSpc->pIntsReg = SPC_INTS_RESELECTED;
  1252. if (scsiIntsDebug)
  1253.             logMsg ("Reselected ", 0, 0, 0, 0, 0, 0);
  1254.      /* if a selection attempt has been made, report lost arbitration */
  1256. if (((pDevToSelect = pSpc->pDevToSelect) != (SCSI_PHYS_DEV *) NULL) &&
  1257.     (pDevToSelect->devStatus == SELECT_IN_PROGRESS))
  1258.     {
  1259.     pDevToSelect->devStatus = SELECT_LOST_ARBIT;
  1260.     pSpc->pDevToSelect = (SCSI_PHYS_DEV *) NULL;
  1261.     semGive (&pDevToSelect->devSyncSem);
  1262.     }
  1263.         }
  1265.     if (tempInts & SPC_INTS_COM_COMPLETE)
  1266.         {
  1267.         *pSpc->pIntsReg = SPC_INTS_COM_COMPLETE;
  1268. if (scsiIntsDebug)
  1269.             logMsg ("commComplete ", 0, 0, 0, 0, 0, 0);
  1271.      /* if a selection attempt has been made, report success */
  1273. if (((pDevToSelect = pSpc->pDevToSelect) != (SCSI_PHYS_DEV *) NULL) &&
  1274.     (pDevToSelect->devStatus == SELECT_IN_PROGRESS))
  1275.     {
  1276.     pDevToSelect->devStatus = SELECT_SUCCESSFUL;
  1277.     pSpc->pDevToSelect = (SCSI_PHYS_DEV *) NULL;
  1278.     semGive (&pDevToSelect->devSyncSem);
  1279.     }
  1281. semGive (&pSpc->scsiCtrl.ctrlSyncSem);
  1282.         }
  1284.     if (tempInts & SPC_INTS_TIMEOUT)
  1285.         {
  1286.         *pSpc->pIntsReg = SPC_INTS_TIMEOUT;
  1287. if (scsiIntsDebug)
  1288.             logMsg ("Timeout ", 0, 0, 0, 0, 0, 0);
  1289.      /* if a selection attempt has been made, report the time-out */
  1291. if (((pDevToSelect = pSpc->pDevToSelect) != (SCSI_PHYS_DEV *) NULL) &&
  1292.     (pDevToSelect->devStatus == SELECT_IN_PROGRESS))
  1293.     {
  1294.     pDevToSelect->devStatus = SELECT_TIMEOUT;
  1295.     pSpc->pDevToSelect = (SCSI_PHYS_DEV *) NULL;
  1296.     semGive (&pDevToSelect->devSyncSem);
  1297.     }
  1299.         }
  1301.     if (tempInts & SPC_INTS_DISCONNECT)
  1302.         {
  1303. spcPctlSet (pSpc, SPC_RESET_BIT, SPC_PCTL_SELECT);
  1304.         *pSpc->pIntsReg = SPC_INTS_DISCONNECT;
  1305. if (scsiIntsDebug)
  1306.             logMsg ("Disconnect ", 0, 0, 0, 0, 0, 0);
  1307.      /* if a device is to be selected, do so now */
  1309. if (((pDevToSelect = pSpc->pDevToSelect) != (SCSI_PHYS_DEV *) NULL) &&
  1310.          (pDevToSelect->devStatus == SELECT_REQUESTED))
  1311.     {
  1312.     if (pDevToSelect->useIdentify)
  1313. {
  1314.         spcCommand (pSpc, SPC_SCMD_SET_ATN);
  1315. }
  1316.     *pSpc->pTempReg = pSpc->selectTempReg;
  1317.     (void) spcXferCountSet (pSpc,
  1318.     (int) (pDevToSelect->selTimeOut << 8) |
  1319.       (pSpc->busFreeDelay));
  1320.     spcCommand (pSpc, SPC_SCMD_SELECT);
  1321.     pDevToSelect->devStatus = SELECT_IN_PROGRESS;
  1322.     }
  1323. else
  1324.     {
  1325.     pSpc->scsiCtrl.scsiBusPhase = SCSI_BUS_FREE_PHASE;
  1326.     semGive (&pSpc->scsiCtrl.ctrlSyncSem);
  1327.     }
  1328.         }
  1330.     if (tempInts & SPC_INTS_SERVICE_REQ)
  1331.         {
  1332.         *pSpc->pIntsReg = SPC_INTS_SERVICE_REQ;
  1333. if (scsiIntsDebug)
  1334.     {
  1335.             logMsg ("serviceReq (sstsReg = 0x%02x) ", *pSpc->pSstsReg,
  1336. 0, 0, 0, 0, 0);
  1337.     }
  1338.         }
  1340.     if (tempInts & SPC_INTS_HARD_ERROR)
  1341.         {
  1342.         *pSpc->pIntsReg = SPC_INTS_HARD_ERROR;
  1343. if (scsiIntsDebug)
  1344.     {
  1345.             hardErrors++;
  1346.             if (spcHardErrPrint)
  1347.                 {
  1348.                 logMsg ("hardError (serrReg = 0x%02x) ", tempSerr,
  1349. 0, 0, 0, 0, 0);
  1350.                 }
  1351.     }
  1352.         }
  1354.     /* the following condition should not attain under allowable SCSI
  1355.      * configurations (i.e., vxWorks target is the sole initiator)
  1356.      */
  1358.     if (tempInts & SPC_INTS_RESET_COND)
  1359.         {
  1360.         *pSpc->pIntsReg = SPC_INTS_RESET_COND;
  1361. if (scsiIntsDebug)
  1362.             logMsg ("Reset (unexpected, multiple intiators not supported)",
  1363. 0, 0, 0, 0, 0, 0);
  1364.         }
  1366.     if (scsiIntsDebug)
  1367. logMsg ("n", 0, 0, 0, 0, 0, 0);
  1368.     }
  1370. /*******************************************************************************
  1371. *
  1372. * spcHwInit - initialize the SPC chip to a known state
  1373. *
  1374. * This routine puts the SPC into a known quiescent state and issues a reset
  1375. * to the SCSI Bus if any signals are active, thus putting target devices in
  1376. * some presumably known state.  Currently the initial state is not configurable
  1377. * and does not enable reselection.
  1378. *
  1379. * INTERNAL
  1380. * Needs to handle parity enable
  1381. */
  1383. LOCAL void spcHwInit
  1384.     (
  1385.     SPC *pSpc          /* ptr to an SPC info structure */
  1386.     )
  1387.     {
  1388.     UINT8 tempSctl;
  1390.     tempSctl = SPC_SCTL_RESET_AND_DSBL | SPC_SCTL_INT_ENBL;
  1391.     if (pSpc->scsiCtrl.disconnect)
  1392. tempSctl |= (SPC_SCTL_ARBIT_ENBL | SPC_SCTL_RESELECT_ENBL);
  1393.     *pSpc->pSctlReg = tempSctl;
  1395.     /* set SCSI bus ID of controller */
  1397.     *pSpc->pBdidReg = pSpc->scsiCtrl.scsiCtrlBusId;
  1399.     *pSpc->pScmdReg = (UINT8) 0; /* set cmd to 'bus release' */
  1400.     *pSpc->pTmodReg = (UINT8) 0; /* asynch data transfer initially */
  1401.     *pSpc->pPctlReg = (UINT8) 0; /* bus free int disabled, no phase */
  1403.     (void) spcXferCountSet (pSpc, 0x00); /* clear xfer counter */
  1405.     *pSpc->pSctlReg &= ~SPC_SCTL_RESET_AND_DSBL;
  1407.     spcScsiBusReset (pSpc);
  1408.     }
  1410. /*******************************************************************************
  1411. *
  1412. * mb87030Show - display the values of all readable MB87030 SPC registers
  1413. *
  1414. * This routine displays the state of the SPC registers in a user-friendly 
  1415. * manner.  It is useful primarily for debugging.
  1416. *
  1417. * EXAMPLE:
  1418. * .CS
  1419. *     -> mb87030Show
  1420. *     SCSI Bus ID: 7    
  1421. *     SCTL (0x01): intsEnbl  
  1422. *     SCMD (0x00): busRlease 
  1423. *     TMOD (0x00): asyncMode 
  1424. *     INTS (0x00):            
  1425. *     PSNS (0x00): req0 ack0 atn0 sel0 bsy0 msg0 c_d0 i_o0 
  1426. *     SSTS (0x05): noConIdle xferCnt=0 dregEmpty 
  1427. *     SERR (0x00): noParErr  
  1428. *     PCTL (0x00): bfIntDsbl phDataOut 
  1429. *     MBC  (0x00): 0         
  1430. *     XFER COUNT : 0x000000 =         0
  1431. * .CE
  1432. *
  1433. * RETURNS: OK, or ERROR if <pScsiCtrl> and <pSysScsiCtrl> are both NULL.
  1434. */
  1436. STATUS mb87030Show
  1437.     (
  1438.     FAST SCSI_CTRL *pScsiCtrl /* ptr to SCSI controller info */
  1439.     )
  1440.     {
  1441.     int busId;
  1442.     FAST UINT8 tempReg;
  1443.     FAST SPC *pSpc; /* ptr to SPC info */
  1444.     int xferCount;
  1446.     if (pScsiCtrl == NULL)
  1447. {
  1448. if (pSysScsiCtrl == NULL)
  1449.     {
  1450.     printErr ("No SCSI controller specified.n");
  1451.     return (ERROR);
  1452.     }
  1454. pScsiCtrl = pSysScsiCtrl;
  1455. }
  1457.     pSpc = (MB_87030_SCSI_CTRL *) pScsiCtrl;
  1459.     /* Display current SCSI Bus ID */
  1461.     if (spcBusIdGet (pSpc, &busId) == OK)
  1462.         printf ("SCSI Bus ID: %-5dn", busId);
  1463.     else
  1464.         printf ("SCSI Bus ID: ERRORn");
  1466.     /* Display SPC Control Register */
  1467.     tempReg = *pSpc->pSctlReg;
  1468.     printf ("SCTL (0x%02x): ", (int) tempReg);
  1469.     printf ("%s", (tempReg & SPC_SCTL_RESET_AND_DSBL) ? "spcDisabl " : "");
  1470.     printf ("%s", (tempReg & SPC_SCTL_CTRL_RESET)     ? "ctrlReset " : "");
  1471.     printf ("%s", (tempReg & SPC_SCTL_DIAG_MODE)      ? "diagMode  " : "");
  1472.     printf ("%s", (tempReg & SPC_SCTL_ARBIT_ENBL)     ? "arbitEnbl " : "");
  1473.     printf ("%s", (tempReg & SPC_SCTL_PARITY_ENBL)    ? "paritEnbl " : "");
  1474.     printf ("%s", (tempReg & SPC_SCTL_SELECT_ENBL)    ? "selecEnbl " : "");
  1475.     printf ("%s", (tempReg & SPC_SCTL_RESELECT_ENBL)  ? "reselEnbl " : "");
  1476.     printf ("%s", (tempReg & SPC_SCTL_INT_ENBL)       ? "intsEnbl  " : "");
  1477.     printf ("n");
  1479.     /* Display Command Register */
  1480.     tempReg = *pSpc->pScmdReg;
  1481.     printf ("SCMD (0x%02x): ", (int) tempReg);
  1482.     switch (tempReg & SPC_SCMD_CMD_MASK)
  1483.         {
  1484.         case SPC_SCMD_BUS_RELEASE:   printf ("busRlease "); break;
  1485.         case SPC_SCMD_SELECT:        printf ("select    "); break;
  1486.         case SPC_SCMD_RESET_ATN:     printf ("resetAtn  "); break;
  1487.         case SPC_SCMD_SET_ATN:       printf ("setAtn    "); break;
  1488.         case SPC_SCMD_XFER:          printf ("transfer  "); break;
  1489.         case SPC_SCMD_XFER_PAUSE:    printf ("xferPause "); break;
  1490.         case SPC_SCMD_RESET_ACK_REQ: printf ("resAckReq "); break;
  1491.         case SPC_SCMD_SET_ACK_REQ:   printf ("setAckReq "); break;
  1492.         }
  1493.     printf ("%s", (tempReg & SPC_SCMD_RESET_OUT)       ? "resetOut  " : "");
  1494.     printf ("%s", (tempReg & SPC_SCMD_INTERCEPT_XFER)  ? "intcptXfr " : "");
  1495.     printf ("%s", (tempReg & SPC_SCMD_PRG_XFER)        ? "progXfer  " : "");
  1496.     printf ("%s", (tempReg & SPC_SCMD_TERM_MODE)       ? "termMode  " : "");
  1497.     printf ("n");
  1499.     /* Display Transfer Mode Register */
  1500.     tempReg = *pSpc->pTmodReg;
  1501.     printf ("TMOD (0x%02x): ", (int) tempReg);
  1502.     printf ("%s", (tempReg & SPC_TMOD_SYNC_XFER) ? "syncMode  " :
  1503.                                                    "asyncMode ");
  1504.     /* JCC Should display offset and period params also
  1505.     */
  1506.     printf ("n");
  1508.     /* Display Interrupt Sense Register */
  1509.     tempReg = *pSpc->pIntsReg;
  1510.     printf ("INTS (0x%02x): ", (int) tempReg);
  1511.     printf ("%s", (tempReg & SPC_INTS_SELECTED)     ? "selected  " : "");
  1512.     printf ("%s", (tempReg & SPC_INTS_RESELECTED)   ? "reselect  " : "");
  1513.     printf ("%s", (tempReg & SPC_INTS_DISCONNECT)   ? "disconnct " : "");
  1514.     printf ("%s", (tempReg & SPC_INTS_COM_COMPLETE) ? "comComplt " : "");
  1515.     printf ("%s", (tempReg & SPC_INTS_SERVICE_REQ)  ? "servReq   " : "");
  1516.     printf ("%s", (tempReg & SPC_INTS_TIMEOUT)      ? "timeout   " : "");
  1517.     printf ("%s", (tempReg & SPC_INTS_HARD_ERROR)   ? "hardError " : "");
  1518.     printf ("%s", (tempReg & SPC_INTS_RESET_COND)   ? "resetCond " : "");
  1519.     printf ("n");
  1521.     /* Display Phase Sense Register */
  1522.     tempReg = *pSpc->pPsnsReg;
  1523.     printf ("PSNS (0x%02x): ", (int) tempReg);
  1524.     printf ("%s", (tempReg & SPC_PSNS_REQ) ? "REQ1 " : "req0 ");
  1525.     printf ("%s", (tempReg & SPC_PSNS_ACK) ? "ACK1 " : "ack0 ");
  1526.     printf ("%s", (tempReg & SPC_PSNS_ATN) ? "ATN1 " : "atn0 ");
  1527.     printf ("%s", (tempReg & SPC_PSNS_SEL) ? "SEL1 " : "sel0 ");
  1528.     printf ("%s", (tempReg & SPC_PSNS_BSY) ? "BSY1 " : "bsy0 ");
  1529.     printf ("%s", (tempReg & SPC_PSNS_MSG) ? "MSG1 " : "msg0 ");
  1530.     printf ("%s", (tempReg & SPC_PSNS_C_D) ? "C_D1 " : "c_d0 ");
  1531.     printf ("%s", (tempReg & SPC_PSNS_I_O) ? "I_O1 " : "i_o0 ");
  1532.     printf ("n");
  1534.     /* Display SPC Status Register */
  1535.     tempReg = *pSpc->pSstsReg;
  1536.     printf ("SSTS (0x%02x): ", (int) tempReg);
  1537.     switch (tempReg & SPC_SSTS_OPER_STAT_MASK)
  1538.         {
  1539.         case SPC_SSTS_NO_CONNECT_IDLE:  printf ("noConIdle "); break;
  1540.         case SPC_SSTS_SELECT_WAIT:      printf ("waitSelec "); break;
  1541.         case SPC_SSTS_TARGET_MANUAL:    printf ("trgManual "); break;
  1542.         case SPC_SSTS_RESELECT_EXEC:    printf ("reselExec "); break;
  1543.         case SPC_SSTS_TARGET_XFER:      printf ("targXfer  "); break;
  1544.         case SPC_SSTS_INITIATOR_MANUAL: printf ("iniManual "); break;
  1545.         case SPC_SSTS_INITIATOR_WAIT:   printf ("iniWait   "); break;
  1546.         case SPC_SSTS_SELECT_EXEC:      printf ("selecExec "); break;
  1547.         case SPC_SSTS_INITIATOR_XFER:   printf ("iniXfer   "); break;
  1548.         default:                        printf ("operUndef "); break;
  1549.         }
  1550.     printf ("%s", (tempReg & SPC_SSTS_SCSI_RESET) ? "scsiReset " : "");
  1551.     printf ("%s", (tempReg & SPC_SSTS_TC_0)       ? "xferCnt=0 " : "");
  1552.     switch (tempReg & SPC_SSTS_DREG_STAT_MASK)
  1553.         {
  1554.         case SPC_SSTS_DREG_EMPTY:   printf ("dregEmpty "); break;
  1555.         case SPC_SSTS_DREG_PARTIAL: printf ("dregPartl "); break;
  1556.         case SPC_SSTS_DREG_FULL:    printf ("dregFull  "); break;
  1557.         default:                    printf ("dregUndef "); break;
  1558.         }
  1559.     printf ("n");
  1561.     /* Display SPC Error Status Register */
  1562.     tempReg = *pSpc->pSerrReg;
  1563.     printf ("SERR (0x%02x): ", (int) tempReg);
  1564.     switch (tempReg & SPC_SERR_PAR_ERROR_MASK)
  1565.         {
  1566.         case SPC_SERR_NO_PAR_ERROR:  printf ("noParErr  "); break;
  1567.         case SPC_SERR_PAR_ERROR_OUT: printf ("outParErr "); break;
  1568.         case SPC_SERR_PAR_ERROR_IN:  printf ("inpParErr "); break;
  1569.         default:                      printf ("pErrUndef "); break;
  1570.         }
  1571.     printf ("%s", (tempReg & SPC_SERR_TC_PARITY)    ? "tcParErr  " : "");
  1572.     printf ("%s", (tempReg & SPC_SERR_PHASE_ERROR)  ? "phaseErr  " : "");
  1573.     printf ("%s", (tempReg & SPC_SERR_SHORT_PERIOD) ? "shortPeri " : "");
  1574.     printf ("%s", (tempReg & SPC_SERR_OFFSET_ERROR) ? "offsetErr " : "");
  1575.     printf ("n");
  1577.     /* Display Phase Control Register */
  1578.     tempReg = *pSpc->pPctlReg;
  1579.     printf ("PCTL (0x%02x): ", (int) tempReg);
  1580.     printf ("%s", (tempReg & SPC_PCTL_BF_INT_ENBL) ? "bfIntEnbl " :
  1581.                                                      "bfIntDsbl ");
  1582.     switch (tempReg & SPC_PCTL_PHASE_MASK)
  1583.         {
  1584.         case SPC_PCTL_DATA_OUT:  printf ("phDataOut "); break;
  1585.         case SPC_PCTL_DATA_IN:   printf ("phDataIn  "); break;
  1586.         case SPC_PCTL_COMMAND:   printf ("phCommand "); break;
  1587.         case SPC_PCTL_STATUS:    printf ("phStatus  "); break;
  1588.         case SPC_PCTL_UNUSED_0:  printf ("phUnused0 "); break;
  1589.         case SPC_PCTL_UNUSED_1:  printf ("phUnused1 "); break;
  1590.         case SPC_PCTL_MESS_OUT:  printf ("phMessOut "); break;
  1591.         case SPC_PCTL_MESS_IN:   printf ("phMessIn  "); break;
  1592.         }
  1593.     printf ("n");
  1595.     /* Display Modified Byte Counter */
  1596.     tempReg = *pSpc->pMbcReg;
  1597.     printf ("MBC  (0x%02x): ", (int) tempReg);
  1598.     printf ("%-10d", (int) tempReg);
  1599.     printf ("n");
  1601.     /* Display Transfer Counter */
  1602.     spcXferCountGet (pSpc, &xferCount);
  1603.     printf ("XFER COUNT : ");
  1604.     printf ("0x%06x =%10d", xferCount, xferCount);
  1605.     printf ("n");
  1607.     return (OK);
  1608.     }