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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
FlashPoint.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：308k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

FlashPoint.c：源码内容
  1. #endif /* (FW_TYPE==_UCB_MGR_)   */
  3. #ifndef NO_IOCTLS
  4. #if (FW_TYPE==_UCB_MGR_)
  5. void SccbMgr_unload_card(CARD_HANDLE pCurrCard)
  6. #else
  7. #if defined(DOS)
  8. void SccbMgr_unload_card(USHORT pCurrCard)
  9. #else
  10. void SccbMgr_unload_card(ULONG pCurrCard)
  11. #endif
  12. #endif
  13. {
  14. UCHAR i;
  15. #if defined(DOS)
  16. USHORT portBase;
  17. USHORT regOffset;
  18. #else
  19. ULONG portBase;
  20. ULONG regOffset;
  21. #endif
  22. ULONG scamData;
  23. #if defined(OS2)
  24. ULONG far *pScamTbl;
  25. #else
  26. ULONG *pScamTbl;
  27. #endif
  28. PNVRamInfo pCurrNvRam;
  30. pCurrNvRam = ((PSCCBcard)pCurrCard)->pNvRamInfo;
  32. if(pCurrNvRam){
  33. WrStack(pCurrNvRam->niBaseAddr, 0, pCurrNvRam->niModel);
  34. WrStack(pCurrNvRam->niBaseAddr, 1, pCurrNvRam->niSysConf);
  35. WrStack(pCurrNvRam->niBaseAddr, 2, pCurrNvRam->niScsiConf);
  36. WrStack(pCurrNvRam->niBaseAddr, 3, pCurrNvRam->niScamConf);
  37. WrStack(pCurrNvRam->niBaseAddr, 4, pCurrNvRam->niAdapId);
  39. for(i = 0; i < MAX_SCSI_TAR / 2; i++)
  40. WrStack(pCurrNvRam->niBaseAddr, (UCHAR)(i+5), pCurrNvRam->niSyncTbl[i]);
  42. portBase = pCurrNvRam->niBaseAddr;
  44. for(i = 0; i < MAX_SCSI_TAR; i++){
  45. regOffset = hp_aramBase + 64 + i*4;
  46. #if defined(OS2)
  47. pScamTbl = (ULONG far *) &pCurrNvRam->niScamTbl[i];
  48. #else
  49. pScamTbl = (ULONG *) &pCurrNvRam->niScamTbl[i];
  50. #endif
  51. scamData = *pScamTbl;
  52. WR_HARP32(portBase, regOffset, scamData);
  53. }
  55. }else{
  56. WrStack(((PSCCBcard)pCurrCard)->ioPort, 0, 0);
  57. }
  58. }
  59. #endif /* NO_IOCTLS */
  62. void RNVRamData(PNVRamInfo pNvRamInfo)
  63. {
  64. UCHAR i;
  65. #if defined(DOS)
  66. USHORT portBase;
  67. USHORT regOffset;
  68. #else
  69. ULONG portBase;
  70. ULONG regOffset;
  71. #endif
  72. ULONG scamData;
  73. #if defined (OS2)
  74. ULONG far *pScamTbl;
  75. #else
  76. ULONG *pScamTbl;
  77. #endif
  79. pNvRamInfo->niModel    = RdStack(pNvRamInfo->niBaseAddr, 0);
  80. pNvRamInfo->niSysConf  = RdStack(pNvRamInfo->niBaseAddr, 1);
  81. pNvRamInfo->niScsiConf = RdStack(pNvRamInfo->niBaseAddr, 2);
  82. pNvRamInfo->niScamConf = RdStack(pNvRamInfo->niBaseAddr, 3);
  83. pNvRamInfo->niAdapId   = RdStack(pNvRamInfo->niBaseAddr, 4);
  85. for(i = 0; i < MAX_SCSI_TAR / 2; i++)
  86. pNvRamInfo->niSyncTbl[i] = RdStack(pNvRamInfo->niBaseAddr, (UCHAR)(i+5));
  88. portBase = pNvRamInfo->niBaseAddr;
  90. for(i = 0; i < MAX_SCSI_TAR; i++){
  91. regOffset = hp_aramBase + 64 + i*4;
  92. RD_HARP32(portBase, regOffset, scamData);
  93. #if defined(OS2)
  94. pScamTbl = (ULONG far *) &pNvRamInfo->niScamTbl[i];
  95. #else
  96. pScamTbl = (ULONG *) &pNvRamInfo->niScamTbl[i];
  97. #endif
  98. *pScamTbl = scamData;
  99. }
  101. }
  103. #if defined(DOS)
  104. UCHAR RdStack(USHORT portBase, UCHAR index)
  105. #else
  106. UCHAR RdStack(ULONG portBase, UCHAR index)
  107. #endif
  108. {
  109. WR_HARPOON(portBase + hp_stack_addr, index);
  110. return(RD_HARPOON(portBase + hp_stack_data));
  111. }
  113. #if defined(DOS)
  114. void WrStack(USHORT portBase, UCHAR index, UCHAR data)
  115. #else
  116. void WrStack(ULONG portBase, UCHAR index, UCHAR data)
  117. #endif
  118. {
  119. WR_HARPOON(portBase + hp_stack_addr, index);
  120. WR_HARPOON(portBase + hp_stack_data, data);
  121. }
  124. #if (FW_TYPE==_UCB_MGR_)
  125. u08bits ChkIfChipInitialized(BASE_PORT ioPort)
  126. #else
  127. #if defined(DOS)
  128. UCHAR ChkIfChipInitialized(USHORT ioPort)
  129. #else
  130. UCHAR ChkIfChipInitialized(ULONG ioPort)
  131. #endif
  132. #endif
  133. {
  134. if((RD_HARPOON(ioPort + hp_arb_id) & 0x0f) != RdStack(ioPort, 4))
  135. return(FALSE);
  136. if((RD_HARPOON(ioPort + hp_clkctrl_0) & CLKCTRL_DEFAULT)
  137. != CLKCTRL_DEFAULT)
  138. return(FALSE);
  139. if((RD_HARPOON(ioPort + hp_seltimeout) == TO_250ms) ||
  140. (RD_HARPOON(ioPort + hp_seltimeout) == TO_290ms))
  141. return(TRUE);
  142. return(FALSE);
  144. }
  145. /*---------------------------------------------------------------------
  146.  *
  147.  * Function: SccbMgr_start_sccb
  148.  *
  149.  * Description: Start a command pointed to by p_Sccb. When the
  150.  *              command is completed it will be returned via the
  151.  *              callback function.
  152.  *
  153.  *---------------------------------------------------------------------*/
  154. #if (FW_TYPE==_UCB_MGR_)
  155. void SccbMgr_start_sccb(CARD_HANDLE pCurrCard, PUCB p_ucb)
  156. #else
  157. #if defined(DOS)
  158. void SccbMgr_start_sccb(USHORT pCurrCard, PSCCB p_Sccb)
  159. #else
  160. void SccbMgr_start_sccb(ULONG pCurrCard, PSCCB p_Sccb)
  161. #endif
  162. #endif
  163. {
  164. #if defined(DOS)
  165.    USHORT ioport;
  166. #else
  167.    ULONG ioport;
  168. #endif
  169.    UCHAR thisCard, lun;
  170. PSCCB pSaveSccb;
  171.    CALL_BK_FN callback;
  173. #if (FW_TYPE==_UCB_MGR_)
  174.    PSCCB p_Sccb;
  175. #endif
  177.    mOS_Lock((PSCCBcard)pCurrCard);
  178.    thisCard = ((PSCCBcard) pCurrCard)->cardIndex;
  179.    ioport = ((PSCCBcard) pCurrCard)->ioPort;
  181. #if (FW_TYPE==_UCB_MGR_)
  182.    p_Sccb = (PSCCB)p_ucb->UCB_MgrPrivatePtr;
  183. #endif
  185. if((p_Sccb->TargID > MAX_SCSI_TAR) || (p_Sccb->Lun > MAX_LUN))
  186. {
  188. #if (FW_TYPE==_UCB_MGR_)
  189. p_ucb->UCB_hbastat = SCCB_COMPLETE;
  190. p_ucb->UCB_status=SCCB_ERROR;
  191. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  192. if (callback)
  193. callback(p_ucb);
  194. #endif
  196. #if (FW_TYPE==_SCCB_MGR_)
  197. p_Sccb->HostStatus = SCCB_COMPLETE;
  198. p_Sccb->SccbStatus = SCCB_ERROR;
  199. callback = (CALL_BK_FN)p_Sccb->SccbCallback;
  200. if (callback)
  201. callback(p_Sccb);
  202. #endif
  204. mOS_UnLock((PSCCBcard)pCurrCard);
  205. return;
  206. }
  208. #if (FW_TYPE==_SCCB_MGR_)
  209.    sinits(p_Sccb,thisCard);
  210. #endif
  213. #if (FW_TYPE==_UCB_MGR_)
  214. #ifndef NO_IOCTLS
  216.    if (p_ucb->UCB_opcode & OPC_IOCTL)
  217. {
  219. switch (p_ucb->UCB_IOCTLCommand) 
  220. {
  221. case READ_NVRAM:
  222. ReadNVRam((PSCCBcard)pCurrCard,p_ucb);
  223. p_ucb->UCB_status=UCB_SUCCESS;
  224. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  225. if (callback)
  226. callback(p_ucb);
  227. mOS_UnLock((PSCCBcard)pCurrCard);
  228. return;
  230. case WRITE_NVRAM:
  231. WriteNVRam((PSCCBcard)pCurrCard,p_ucb);
  232. p_ucb->UCB_status=UCB_SUCCESS;
  233. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  234. if (callback)
  235. callback(p_ucb);
  236. mOS_UnLock((PSCCBcard)pCurrCard);
  237. return;
  239. case SEND_SCSI_PASSTHRU:
  240. #if (FW_TYPE != _SCCB_MGR_)
  241. if( p_ucb->UCB_targid >=
  242.     ((PSCCBcard)pCurrCard)->cardInfo->ai_MaxTarg )
  243. {
  244. p_ucb->UCB_status = UCB_ERROR;
  245. p_ucb->UCB_hbastat = HASTAT_HW_ERROR;
  246. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  247. if (callback)
  248. callback(p_ucb);
  249. mOS_UnLock((PSCCBcard)pCurrCard);
  250. return;
  251. }
  252. #endif
  253. break;
  255. case HARD_RESET:
  256. p_ucb->UCB_status = UCB_INVALID;
  257. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  258. if (callback)
  259. callback(p_ucb);
  260. mOS_UnLock((PSCCBcard)pCurrCard);
  261. return;
  262. case GET_DEVICE_SYNCRATE:
  263. if( !GetDevSyncRate((PSCCBcard)pCurrCard,p_ucb) )
  264. {
  265. p_ucb->UCB_status = UCB_SUCCESS;
  266. }
  267. else
  268. {
  269. p_ucb->UCB_status = UCB_ERROR;
  270. p_ucb->UCB_hbastat = HASTAT_HW_ERROR;
  271. }
  272. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  273. if (callback)
  274. callback(p_ucb);
  275. mOS_UnLock((PSCCBcard)pCurrCard);
  276. return;
  277. case SET_DEVICE_SYNCRATE:
  278. if( !SetDevSyncRate((PSCCBcard)pCurrCard,p_ucb) )
  279. {
  280. p_ucb->UCB_status = UCB_SUCCESS;
  281. }
  282. else
  283. {
  284. p_ucb->UCB_status = UCB_ERROR;
  285. p_ucb->UCB_hbastat = HASTAT_HW_ERROR;
  286. }
  287. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  288. if (callback)
  289. callback(p_ucb);
  290. mOS_UnLock((PSCCBcard)pCurrCard);
  291. return;
  292. case GET_WIDE_MODE:
  293. if( !GetDevWideMode((PSCCBcard)pCurrCard,p_ucb) )
  294. {
  295. p_ucb->UCB_status = UCB_SUCCESS;
  296. }
  297. else
  298. {
  299. p_ucb->UCB_status = UCB_ERROR;
  300. p_ucb->UCB_hbastat = HASTAT_HW_ERROR;
  301. }
  302. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  303. if (callback)
  304. callback(p_ucb);
  305. mOS_UnLock((PSCCBcard)pCurrCard);
  306. return;
  307. case SET_WIDE_MODE:
  308. if( !SetDevWideMode((PSCCBcard)pCurrCard,p_ucb) )
  309. {
  310. p_ucb->UCB_status = UCB_SUCCESS;
  311. }
  312. else
  313. {
  314. p_ucb->UCB_status = UCB_ERROR;
  315. p_ucb->UCB_hbastat = HASTAT_HW_ERROR;
  316. }
  317. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  318. if (callback)
  319. callback(p_ucb);
  320. mOS_UnLock((PSCCBcard)pCurrCard);
  321. return;
  322. default:
  323. p_ucb->UCB_status=UCB_INVALID;
  324. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  325. if (callback)
  326. callback(p_ucb);
  327. mOS_UnLock((PSCCBcard)pCurrCard);
  328. return;
  329. }
  330. }
  331. #endif /* NO_IOCTLS */
  332. #endif /* (FW_TYPE==_UCB_MGR_) */
  335.    if (!((PSCCBcard) pCurrCard)->cmdCounter)
  336.       {
  337.       WR_HARPOON(ioport+hp_semaphore, (RD_HARPOON(ioport+hp_semaphore)
  338.          | SCCB_MGR_ACTIVE));
  340.       if (((PSCCBcard) pCurrCard)->globalFlags & F_GREEN_PC)
  341.          {
  342.  WR_HARPOON(ioport+hp_clkctrl_0, CLKCTRL_DEFAULT);
  343.  WR_HARPOON(ioport+hp_sys_ctrl, 0x00);
  344.          }
  345.       }
  347.    ((PSCCBcard)pCurrCard)->cmdCounter++;
  349.    if (RD_HARPOON(ioport+hp_semaphore) & BIOS_IN_USE) {
  351.       WR_HARPOON(ioport+hp_semaphore, (RD_HARPOON(ioport+hp_semaphore)
  352.          | TICKLE_ME));
  353. if(p_Sccb->OperationCode == RESET_COMMAND)
  354. {
  355. pSaveSccb = ((PSCCBcard) pCurrCard)->currentSCCB;
  356. ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  357. queueSelectFail(&BL_Card[thisCard], thisCard);
  358. ((PSCCBcard) pCurrCard)->currentSCCB = pSaveSccb;
  359. }
  360. else
  361. {
  362.       queueAddSccb(p_Sccb,thisCard);
  363. }
  364.       }
  366.    else if ((RD_HARPOON(ioport+hp_page_ctrl) & G_INT_DISABLE)) {
  368. if(p_Sccb->OperationCode == RESET_COMMAND)
  369. {
  370. pSaveSccb = ((PSCCBcard) pCurrCard)->currentSCCB;
  371. ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  372. queueSelectFail(&BL_Card[thisCard], thisCard);
  373. ((PSCCBcard) pCurrCard)->currentSCCB = pSaveSccb;
  374. }
  375. else
  376. {
  377.       queueAddSccb(p_Sccb,thisCard);
  378. }
  379.       }
  381.    else {
  383.       MDISABLE_INT(ioport);
  385. if((((PSCCBcard) pCurrCard)->globalFlags & F_CONLUN_IO) && 
  386. ((sccbMgrTbl[thisCard][p_Sccb->TargID].TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
  387. lun = p_Sccb->Lun;
  388. else
  389. lun = 0;
  390.       if ((((PSCCBcard) pCurrCard)->currentSCCB == NULL) &&
  391.          (sccbMgrTbl[thisCard][p_Sccb->TargID].TarSelQ_Cnt == 0) &&
  392.          (sccbMgrTbl[thisCard][p_Sccb->TargID].TarLUNBusy[lun]
  393.          == FALSE)) {
  395.             ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  396.    mOS_UnLock((PSCCBcard)pCurrCard);
  397. #if defined(DOS)
  398.             ssel((USHORT)p_Sccb->SccbIOPort,thisCard);
  399. #else
  400.     ssel(p_Sccb->SccbIOPort,thisCard);
  401. #endif
  402.    mOS_Lock((PSCCBcard)pCurrCard);
  403.          }
  405.       else {
  407. if(p_Sccb->OperationCode == RESET_COMMAND)
  408. {
  409. pSaveSccb = ((PSCCBcard) pCurrCard)->currentSCCB;
  410. ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  411. queueSelectFail(&BL_Card[thisCard], thisCard);
  412. ((PSCCBcard) pCurrCard)->currentSCCB = pSaveSccb;
  413. }
  414. else
  415. {
  416.           queueAddSccb(p_Sccb,thisCard);
  417. }
  418.          }
  421.       MENABLE_INT(ioport);
  422.       }
  424.    mOS_UnLock((PSCCBcard)pCurrCard);
  425. }
  428. /*---------------------------------------------------------------------
  429.  *
  430.  * Function: SccbMgr_abort_sccb
  431.  *
  432.  * Description: Abort the command pointed to by p_Sccb.  When the
  433.  *              command is completed it will be returned via the
  434.  *              callback function.
  435.  *
  436.  *---------------------------------------------------------------------*/
  437. #if (FW_TYPE==_UCB_MGR_)
  438. s32bits SccbMgr_abort_sccb(CARD_HANDLE pCurrCard, PUCB p_ucb)
  439. #else
  440. #if defined(DOS)
  441. int SccbMgr_abort_sccb(USHORT pCurrCard, PSCCB p_Sccb)
  442. #else
  443. int SccbMgr_abort_sccb(ULONG pCurrCard, PSCCB p_Sccb)
  444. #endif
  445. #endif
  447. {
  448. #if defined(DOS)
  449. USHORT ioport;
  450. #else
  451. ULONG ioport;
  452. #endif
  454. UCHAR thisCard;
  455. CALL_BK_FN callback;
  456. UCHAR TID;
  457. PSCCB pSaveSCCB;
  458. PSCCBMgr_tar_info currTar_Info;
  461. #if (FW_TYPE==_UCB_MGR_)
  462. PSCCB    p_Sccb;
  463. p_Sccb=(PSCCB)p_ucb->UCB_MgrPrivatePtr;
  464. #endif
  466. ioport = ((PSCCBcard) pCurrCard)->ioPort;
  468. thisCard = ((PSCCBcard)pCurrCard)->cardIndex;
  470. mOS_Lock((PSCCBcard)pCurrCard);
  472. if (RD_HARPOON(ioport+hp_page_ctrl) & G_INT_DISABLE)
  473. {
  474. mOS_UnLock((PSCCBcard)pCurrCard);
  475. }
  477. else
  478. {
  480. if (queueFindSccb(p_Sccb,thisCard))
  481. {
  483. mOS_UnLock((PSCCBcard)pCurrCard);
  485. ((PSCCBcard)pCurrCard)->cmdCounter--;
  487. if (!((PSCCBcard)pCurrCard)->cmdCounter)
  488. WR_HARPOON(ioport+hp_semaphore,(RD_HARPOON(ioport+hp_semaphore)
  489. & (UCHAR)(~(SCCB_MGR_ACTIVE | TICKLE_ME)) ));
  491. #if (FW_TYPE==_SCCB_MGR_)
  492. p_Sccb->SccbStatus = SCCB_ABORT;
  493. callback = p_Sccb->SccbCallback;
  494. callback(p_Sccb);
  495. #else
  496. p_ucb->UCB_status=SCCB_ABORT;
  497. callback = (CALL_BK_FN)p_ucb->UCB_callback;
  498. callback(p_ucb);
  499. #endif
  501. return(0);
  502. }
  504. else
  505. {
  506. mOS_UnLock((PSCCBcard)pCurrCard);
  508. if (((PSCCBcard)pCurrCard)->currentSCCB == p_Sccb)
  509. {
  510. p_Sccb->SccbStatus = SCCB_ABORT;
  511. return(0);
  513. }
  515. else
  516. {
  518. TID = p_Sccb->TargID;
  521. if(p_Sccb->Sccb_tag)
  522. {
  523. MDISABLE_INT(ioport);
  524. if (((PSCCBcard) pCurrCard)->discQ_Tbl[p_Sccb->Sccb_tag]==p_Sccb)
  525. {
  526. p_Sccb->SccbStatus = SCCB_ABORT;
  527. p_Sccb->Sccb_scsistat = ABORT_ST;
  528. #if (FW_TYPE==_UCB_MGR_)
  529. p_ucb->UCB_status=SCCB_ABORT;
  530. #endif
  531. p_Sccb->Sccb_scsimsg = SMABORT_TAG;
  533. if(((PSCCBcard) pCurrCard)->currentSCCB == NULL)
  534. {
  535. ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  536. ssel(ioport, thisCard);
  537. }
  538. else
  539. {
  540. pSaveSCCB = ((PSCCBcard) pCurrCard)->currentSCCB;
  541. ((PSCCBcard) pCurrCard)->currentSCCB = p_Sccb;
  542. queueSelectFail((PSCCBcard) pCurrCard, thisCard);
  543. ((PSCCBcard) pCurrCard)->currentSCCB = pSaveSCCB;
  544. }
  545. }
  546. MENABLE_INT(ioport);
  547. return(0);
  548. }
  549. else
  550. {
  551. currTar_Info = &sccbMgrTbl[thisCard][p_Sccb->TargID];
  553. if(BL_Card[thisCard].discQ_Tbl[currTar_Info->LunDiscQ_Idx[p_Sccb->Lun]] 
  554. == p_Sccb)
  555. {
  556. p_Sccb->SccbStatus = SCCB_ABORT;
  557. return(0);
  558. }
  559. }
  560. }
  561. }
  562. }
  563. return(-1);
  564. }
  567. /*---------------------------------------------------------------------
  568.  *
  569.  * Function: SccbMgr_my_int
  570.  *
  571.  * Description: Do a quick check to determine if there is a pending
  572.  *              interrupt for this card and disable the IRQ Pin if so.
  573.  *
  574.  *---------------------------------------------------------------------*/
  575. #if (FW_TYPE==_UCB_MGR_)
  576. u08bits SccbMgr_my_int(CARD_HANDLE pCurrCard)
  577. #else
  578. #if defined(DOS)
  579. UCHAR SccbMgr_my_int(USHORT pCurrCard)
  580. #else
  581. UCHAR SccbMgr_my_int(ULONG pCurrCard)
  582. #endif
  583. #endif
  584. {
  585. #if defined(DOS)
  586.    USHORT ioport;
  587. #else
  588.    ULONG ioport;
  589. #endif
  591.    ioport = ((PSCCBcard)pCurrCard)->ioPort;
  593.    if (RD_HARPOON(ioport+hp_int_status) & INT_ASSERTED)
  594.    {
  596. #if defined(DOS)
  597.       MDISABLE_INT(ioport);
  598. #endif
  600.       return(TRUE);
  601.    }
  603.    else
  605.       return(FALSE);
  606. }
  610. /*---------------------------------------------------------------------
  611.  *
  612.  * Function: SccbMgr_isr
  613.  *
  614.  * Description: This is our entry point when an interrupt is generated
  615.  *              by the card and the upper level driver passes it on to
  616.  *              us.
  617.  *
  618.  *---------------------------------------------------------------------*/
  619. #if (FW_TYPE==_UCB_MGR_)
  620. s32bits SccbMgr_isr(CARD_HANDLE pCurrCard)
  621. #else
  622. #if defined(DOS)
  623. int SccbMgr_isr(USHORT pCurrCard)
  624. #else
  625. int SccbMgr_isr(ULONG pCurrCard)
  626. #endif
  627. #endif
  628. {
  629.    PSCCB currSCCB;
  630.    UCHAR thisCard,result,bm_status, bm_int_st;
  631.    USHORT hp_int;
  632.    UCHAR i, target;
  633. #if defined(DOS)
  634.    USHORT ioport;
  635. #else
  636.    ULONG ioport;
  637. #endif
  639.    mOS_Lock((PSCCBcard)pCurrCard);
  641.    thisCard = ((PSCCBcard)pCurrCard)->cardIndex;
  642.    ioport = ((PSCCBcard)pCurrCard)->ioPort;
  644.    MDISABLE_INT(ioport);
  646. #if defined(BUGBUG)
  647.    WR_HARPOON(ioport+hp_user_defined_D, RD_HARPOON(ioport+hp_int_status));
  648. #endif
  650.    if ((bm_int_st=RD_HARPOON(ioport+hp_int_status)) & EXT_STATUS_ON)
  651. bm_status = RD_HARPOON(ioport+hp_ext_status) & (UCHAR)BAD_EXT_STATUS;
  652.    else
  653.       bm_status = 0;
  655.    WR_HARPOON(ioport+hp_int_mask, (INT_CMD_COMPL | SCSI_INTERRUPT));
  657.    mOS_UnLock((PSCCBcard)pCurrCard);
  659.    while ((hp_int = RDW_HARPOON((ioport+hp_intstat)) & default_intena) |
  660.   bm_status)
  661.      {
  663.        currSCCB = ((PSCCBcard)pCurrCard)->currentSCCB;
  665. #if defined(BUGBUG)
  666.    Debug_Load(thisCard,(UCHAR) 0XFF);
  667.    Debug_Load(thisCard,bm_int_st);
  669.    Debug_Load(thisCard,hp_int_0);
  670.    Debug_Load(thisCard,hp_int_1);
  671. #endif
  674.       if (hp_int & (FIFO | TIMEOUT | RESET | SCAM_SEL) || bm_status) {
  675.          result = SccbMgr_bad_isr(ioport,thisCard,((PSCCBcard)pCurrCard),hp_int);
  676.          WRW_HARPOON((ioport+hp_intstat), (FIFO | TIMEOUT | RESET | SCAM_SEL));
  677.          bm_status = 0;
  679.          if (result) {
  681.    mOS_Lock((PSCCBcard)pCurrCard);
  682.             MENABLE_INT(ioport);
  683.    mOS_UnLock((PSCCBcard)pCurrCard);
  684.             return(result);
  685.             }
  686.          }
  689.       else if (hp_int & ICMD_COMP) {
  691.          if ( !(hp_int & BUS_FREE) ) {
  692.             /* Wait for the BusFree before starting a new command.  We
  693.                must also check for being reselected since the BusFree
  694.                may not show up if another device reselects us in 1.5us or
  695.                less.  SRR Wednesday, 3/8/1995.
  696.          */
  697.    while (!(RDW_HARPOON((ioport+hp_intstat)) & (BUS_FREE | RSEL))) ;
  698.  }
  700.          if (((PSCCBcard)pCurrCard)->globalFlags & F_HOST_XFER_ACT)
  702.             phaseChkFifo(ioport, thisCard);
  704. /*         WRW_HARPOON((ioport+hp_intstat),
  705.             (BUS_FREE | ICMD_COMP | ITAR_DISC | XFER_CNT_0));
  706.          */
  708.  WRW_HARPOON((ioport+hp_intstat), CLR_ALL_INT_1);
  710.          autoCmdCmplt(ioport,thisCard);
  712.          }
  715.       else if (hp_int & ITAR_DISC)
  716.          {
  718.          if (((PSCCBcard)pCurrCard)->globalFlags & F_HOST_XFER_ACT) {
  720.             phaseChkFifo(ioport, thisCard);
  722.             }
  724.          if (RD_HARPOON(ioport+hp_gp_reg_1) == SMSAVE_DATA_PTR) {
  726.             WR_HARPOON(ioport+hp_gp_reg_1, 0x00);
  727.             currSCCB->Sccb_XferState |= F_NO_DATA_YET;
  729.             currSCCB->Sccb_savedATC = currSCCB->Sccb_ATC;
  730.             }
  732.          currSCCB->Sccb_scsistat = DISCONNECT_ST;
  733.          queueDisconnect(currSCCB,thisCard);
  735.             /* Wait for the BusFree before starting a new command.  We
  736.                must also check for being reselected since the BusFree
  737.                may not show up if another device reselects us in 1.5us or
  738.                less.  SRR Wednesday, 3/8/1995.
  739.              */
  740.    while (!(RDW_HARPOON((ioport+hp_intstat)) & (BUS_FREE | RSEL)) &&
  741.   !((RDW_HARPOON((ioport+hp_intstat)) & PHASE) &&
  742.     RD_HARPOON((ioport+hp_scsisig)) ==
  743.     (SCSI_BSY | SCSI_REQ | SCSI_CD | SCSI_MSG | SCSI_IOBIT))) ;
  745.    /*
  746.      The additional loop exit condition above detects a timing problem
  747.      with the revision D/E harpoon chips.  The caller should reset the
  748.      host adapter to recover when 0xFE is returned.
  749.    */
  750.    if (!(RDW_HARPOON((ioport+hp_intstat)) & (BUS_FREE | RSEL)))
  751.      {
  752.        mOS_Lock((PSCCBcard)pCurrCard);
  753.        MENABLE_INT(ioport);
  754.        mOS_UnLock((PSCCBcard)pCurrCard);
  755.        return 0xFE;
  756.      }
  758.          WRW_HARPOON((ioport+hp_intstat), (BUS_FREE | ITAR_DISC));
  761.          ((PSCCBcard)pCurrCard)->globalFlags |= F_NEW_SCCB_CMD;
  763.        }
  766.       else if (hp_int & RSEL) {
  768.          WRW_HARPOON((ioport+hp_intstat), (PROG_HLT | RSEL | PHASE | BUS_FREE));
  770.          if (RDW_HARPOON((ioport+hp_intstat)) & ITAR_DISC)
  771.       {
  772.             if (((PSCCBcard)pCurrCard)->globalFlags & F_HOST_XFER_ACT)
  773.       {
  774.                phaseChkFifo(ioport, thisCard);
  775.                }
  777.             if (RD_HARPOON(ioport+hp_gp_reg_1) == SMSAVE_DATA_PTR)
  778.       {
  779.                WR_HARPOON(ioport+hp_gp_reg_1, 0x00);
  780.                currSCCB->Sccb_XferState |= F_NO_DATA_YET;
  781.                currSCCB->Sccb_savedATC = currSCCB->Sccb_ATC;
  782.                }
  784.             WRW_HARPOON((ioport+hp_intstat), (BUS_FREE | ITAR_DISC));
  785.             currSCCB->Sccb_scsistat = DISCONNECT_ST;
  786.             queueDisconnect(currSCCB,thisCard);
  787.             }
  789.          sres(ioport,thisCard,((PSCCBcard)pCurrCard));
  790.          phaseDecode(ioport,thisCard);
  792.          }
  795.       else if ((hp_int & IDO_STRT) && (!(hp_int & BUS_FREE)))
  796.          {
  798.             WRW_HARPOON((ioport+hp_intstat), (IDO_STRT | XFER_CNT_0));
  799.             phaseDecode(ioport,thisCard);
  801.          }
  804.       else if ( (hp_int & IUNKWN) || (hp_int & PROG_HLT) )
  805.    {
  806.      WRW_HARPOON((ioport+hp_intstat), (PHASE | IUNKWN | PROG_HLT));
  807.      if ((RD_HARPOON(ioport+hp_prgmcnt_0) & (UCHAR)0x3f)< (UCHAR)SELCHK)
  808.      {
  809.      phaseDecode(ioport,thisCard);
  810.      }
  811.      else
  812.      {
  813.    /* Harpoon problem some SCSI target device respond to selection
  814.    with short BUSY pulse (<400ns) this will make the Harpoon is not able
  815.    to latch the correct Target ID into reg. x53.
  816.    The work around require to correct this reg. But when write to this
  817.    reg. (0x53) also increment the FIFO write addr reg (0x6f), thus we
  818.    need to read this reg first then restore it later. After update to 0x53 */
  820.      i = (UCHAR)(RD_HARPOON(ioport+hp_fifowrite));
  821.      target = (UCHAR)(RD_HARPOON(ioport+hp_gp_reg_3));
  822.      WR_HARPOON(ioport+hp_xfer_pad, (UCHAR) ID_UNLOCK);
  823.      WR_HARPOON(ioport+hp_select_id, (UCHAR)(target | target<<4));
  824.      WR_HARPOON(ioport+hp_xfer_pad, (UCHAR) 0x00);
  825.      WR_HARPOON(ioport+hp_fifowrite, i);
  826.      WR_HARPOON(ioport+hp_autostart_3, (AUTO_IMMED+TAG_STRT));
  827.      }
  828.      }
  830.       else if (hp_int & XFER_CNT_0) {
  832.          WRW_HARPOON((ioport+hp_intstat), XFER_CNT_0);
  834.          schkdd(ioport,thisCard);
  836.          }
  839.       else if (hp_int & BUS_FREE) {
  841.          WRW_HARPOON((ioport+hp_intstat), BUS_FREE);
  843.          if (((PSCCBcard)pCurrCard)->globalFlags & F_HOST_XFER_ACT) {
  845.             hostDataXferAbort(ioport,thisCard,currSCCB);
  846. }
  848.          phaseBusFree(ioport,thisCard);
  849. }
  852.       else if (hp_int & ITICKLE) {
  854.          WRW_HARPOON((ioport+hp_intstat), ITICKLE);
  855.          ((PSCCBcard)pCurrCard)->globalFlags |= F_NEW_SCCB_CMD;
  856.          }
  860.       if (((PSCCBcard)pCurrCard)->globalFlags & F_NEW_SCCB_CMD) {
  863.          ((PSCCBcard)pCurrCard)->globalFlags &= ~F_NEW_SCCB_CMD;
  866.          if (((PSCCBcard)pCurrCard)->currentSCCB == NULL) {
  868.             queueSearchSelect(((PSCCBcard)pCurrCard),thisCard);
  869.             }
  871.          if (((PSCCBcard)pCurrCard)->currentSCCB != NULL) {
  872.             ((PSCCBcard)pCurrCard)->globalFlags &= ~F_NEW_SCCB_CMD;
  873.             ssel(ioport,thisCard);
  874.             }
  876.          break;
  878.          }
  880.       }  /*end while */
  882.    mOS_Lock((PSCCBcard)pCurrCard);
  883.    MENABLE_INT(ioport);
  884.    mOS_UnLock((PSCCBcard)pCurrCard);
  886.    return(0);
  887. }
  889. /*---------------------------------------------------------------------
  890.  *
  891.  * Function: Sccb_bad_isr
  892.  *
  893.  * Description: Some type of interrupt has occurred which is slightly
  894.  *              out of the ordinary.  We will now decode it fully, in
  895.  *              this routine.  This is broken up in an attempt to save
  896.  *              processing time.
  897.  *
  898.  *---------------------------------------------------------------------*/
  899. #if defined(DOS)
  900. UCHAR SccbMgr_bad_isr(USHORT p_port, UCHAR p_card, PSCCBcard pCurrCard, USHORT p_int)
  901. #else
  902. UCHAR SccbMgr_bad_isr(ULONG p_port, UCHAR p_card, PSCCBcard pCurrCard, USHORT p_int)
  903. #endif
  904. {
  905. #if defined(HARP_REVX)
  906.    ULONG timer;
  907. #endif
  908. UCHAR temp, ScamFlg;
  909. PSCCBMgr_tar_info currTar_Info;
  910. PNVRamInfo pCurrNvRam;
  913.    if (RD_HARPOON(p_port+hp_ext_status) &
  914.          (BM_FORCE_OFF | PCI_DEV_TMOUT | BM_PARITY_ERR | PIO_OVERRUN) )
  915.       {
  917.       if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
  918.          {
  920.          hostDataXferAbort(p_port,p_card, pCurrCard->currentSCCB);
  921.          }
  923.       if (RD_HARPOON(p_port+hp_pci_stat_cfg) & REC_MASTER_ABORT)
  925.          {
  926.          WR_HARPOON(p_port+hp_pci_stat_cfg,
  927.             (RD_HARPOON(p_port+hp_pci_stat_cfg) & ~REC_MASTER_ABORT));
  929.          WR_HARPOON(p_port+hp_host_blk_cnt, 0x00);
  931.          }
  933.       if (pCurrCard->currentSCCB != NULL)
  934.          {
  936.          if (!pCurrCard->currentSCCB->HostStatus)
  937.             pCurrCard->currentSCCB->HostStatus = SCCB_BM_ERR;
  939.          sxfrp(p_port,p_card);
  941.      temp = (UCHAR)(RD_HARPOON(p_port+hp_ee_ctrl) &
  942. (EXT_ARB_ACK | SCSI_TERM_ENA_H));
  943.        WR_HARPOON(p_port+hp_ee_ctrl, ((UCHAR)temp | SEE_MS | SEE_CS));
  944.          WR_HARPOON(p_port+hp_ee_ctrl, temp);
  946.          if (!(RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | RESET)))
  947.             {
  948.             phaseDecode(p_port,p_card);
  949.             }
  950.          }
  951.       }
  954.    else if (p_int & RESET)
  955.          {
  957. WR_HARPOON(p_port+hp_clkctrl_0, CLKCTRL_DEFAULT);
  958. WR_HARPOON(p_port+hp_sys_ctrl, 0x00);
  959.            if (pCurrCard->currentSCCB != NULL) {
  961.                if (pCurrCard->globalFlags & F_HOST_XFER_ACT)
  963.                hostDataXferAbort(p_port,p_card, pCurrCard->currentSCCB);
  964.                }
  967.            DISABLE_AUTO(p_port);
  969.            sresb(p_port,p_card);
  971.            while(RD_HARPOON(p_port+hp_scsictrl_0) & SCSI_RST) {}
  973. pCurrNvRam = pCurrCard->pNvRamInfo;
  974. if(pCurrNvRam){
  975. ScamFlg = pCurrNvRam->niScamConf;
  976. }
  977. else{
  978.    ScamFlg = (UCHAR) utilEERead(p_port, SCAM_CONFIG/2);
  979. }
  981.            XbowInit(p_port, ScamFlg);
  983.                scini(p_card, pCurrCard->ourId, 0);
  985.            return(0xFF);
  986.          }
  989.    else if (p_int & FIFO) {
  991.       WRW_HARPOON((p_port+hp_intstat), FIFO);
  993. #if defined(HARP_REVX)
  995.       for (timer=0x00FFFFFFL; timer != 0x00000000L; timer--) {
  997.          if (RD_HARPOON(p_port+hp_xferstat) & FIFO_EMPTY)
  998.             break;
  1000.          if (RDW_HARPOON((p_port+hp_intstat)) & BUS_FREE)
  1001.             break;
  1002.          }
  1005.       if ( (RD_HARPOON(p_port+hp_xferstat) & FIFO_EMPTY) &&
  1006.            (RD_HARPOON(p_port+hp_fiforead) !=
  1007.             RD_HARPOON(p_port+hp_fifowrite)) &&
  1008.            (RD_HARPOON(p_port+hp_xfercnt_0))
  1009.          )
  1011.             WR_HARPOON((p_port+hp_xferstat), 0x01);
  1013. /*      else
  1014.  */
  1015. /*         sxfrp(p_port,p_card);
  1016.  */
  1017. #else
  1018.       if (pCurrCard->currentSCCB != NULL)
  1019.          sxfrp(p_port,p_card);
  1020. #endif
  1021.       }
  1023.    else if (p_int & TIMEOUT)
  1024.       {
  1026.       DISABLE_AUTO(p_port);
  1028.       WRW_HARPOON((p_port+hp_intstat),
  1029.   (PROG_HLT | TIMEOUT | SEL |BUS_FREE | PHASE | IUNKWN));
  1031.       pCurrCard->currentSCCB->HostStatus = SCCB_SELECTION_TIMEOUT;
  1034. currTar_Info = &sccbMgrTbl[p_card][pCurrCard->currentSCCB->TargID];
  1035. if((pCurrCard->globalFlags & F_CONLUN_IO) &&
  1036. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
  1037.       currTar_Info->TarLUNBusy[pCurrCard->currentSCCB->Lun] = FALSE;
  1038. else
  1039.       currTar_Info->TarLUNBusy[0] = FALSE;
  1042.       if (currTar_Info->TarEEValue & EE_SYNC_MASK)
  1043.          {
  1044.        currTar_Info->TarSyncCtrl = 0;
  1045.          currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
  1046.          }
  1048.       if (currTar_Info->TarEEValue & EE_WIDE_SCSI)
  1049.          {
  1050.          currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
  1051.          }
  1053.       sssyncv(p_port, pCurrCard->currentSCCB->TargID, NARROW_SCSI,currTar_Info);
  1055.       queueCmdComplete(pCurrCard, pCurrCard->currentSCCB, p_card);
  1057.       }
  1059. #if defined(SCAM_LEV_2)
  1061.    else if (p_int & SCAM_SEL)
  1062.       {
  1064.       scarb(p_port,LEVEL2_TAR);
  1065.       scsel(p_port);
  1066.       scasid(p_card, p_port);
  1068.       scbusf(p_port);
  1070.       WRW_HARPOON((p_port+hp_intstat), SCAM_SEL);
  1071.       }
  1072. #endif
  1074.    return(0x00);
  1075. }
  1078. /*---------------------------------------------------------------------
  1079.  *
  1080.  * Function: SccbMgr_scsi_reset
  1081.  *
  1082.  * Description: A SCSI bus reset will be generated and all outstanding
  1083.  *              Sccbs will be returned via the callback.
  1084.  *
  1085.  *---------------------------------------------------------------------*/
  1086. #if (FW_TYPE==_UCB_MGR_)
  1087. void SccbMgr_scsi_reset(CARD_HANDLE pCurrCard)
  1088. #else
  1089. #if defined(DOS)
  1090. void SccbMgr_scsi_reset(USHORT pCurrCard)
  1091. #else
  1092. void SccbMgr_scsi_reset(ULONG pCurrCard)
  1093. #endif
  1094. #endif
  1095. {
  1096.    UCHAR thisCard;
  1098.    thisCard = ((PSCCBcard)pCurrCard)->cardIndex;
  1100.    mOS_Lock((PSCCBcard)pCurrCard);
  1102.    if (((PSCCBcard) pCurrCard)->globalFlags & F_GREEN_PC)
  1103.       {
  1104.       WR_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_clkctrl_0, CLKCTRL_DEFAULT);
  1105.       WR_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_sys_ctrl, 0x00);
  1106.       }
  1108.    sresb(((PSCCBcard)pCurrCard)->ioPort,thisCard);
  1110.    if (RD_HARPOON(((PSCCBcard)pCurrCard)->ioPort+hp_ext_status) & BM_CMD_BUSY)
  1111.       {
  1112.       WR_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_page_ctrl,
  1113.          (RD_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_page_ctrl)
  1114.          & ~SCATTER_EN));
  1116.       WR_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_sg_addr,0x00);
  1118.       ((PSCCBcard) pCurrCard)->globalFlags &= ~F_HOST_XFER_ACT;
  1119.       busMstrTimeOut(((PSCCBcard) pCurrCard)->ioPort);
  1121.       WR_HARPOON(((PSCCBcard) pCurrCard)->ioPort+hp_int_mask,
  1122.          (INT_CMD_COMPL | SCSI_INTERRUPT));
  1123.       }
  1125. /*
  1126.       if (utilEERead(((PSCCBcard)pCurrCard)->ioPort, (SCAM_CONFIG/2))
  1127.             & SCAM_ENABLED)
  1128. */
  1129.          scini(thisCard, ((PSCCBcard)pCurrCard)->ourId, 0);
  1131. #if (FW_TYPE==_UCB_MGR_)
  1132.    ((PSCCBcard)pCurrCard)->cardInfo->ai_AEN_routine(0x01,pCurrCard,0,0,0,0);
  1133. #endif
  1135.    mOS_UnLock((PSCCBcard)pCurrCard);
  1136. }
  1139. /*---------------------------------------------------------------------
  1140.  *
  1141.  * Function: SccbMgr_timer_expired
  1142.  *
  1143.  * Description: This function allow me to kill my own job that has not
  1144.  *              yet completed, and has cause a timeout to occur.  This
  1145.  *              timeout has caused the upper level driver to call this
  1146.  *              function.
  1147.  *
  1148.  *---------------------------------------------------------------------*/
  1150. #if (FW_TYPE==_UCB_MGR_)
  1151. void SccbMgr_timer_expired(CARD_HANDLE pCurrCard)
  1152. #else
  1153. #if defined(DOS)
  1154. void SccbMgr_timer_expired(USHORT pCurrCard)
  1155. #else
  1156. void SccbMgr_timer_expired(ULONG pCurrCard)
  1157. #endif
  1158. #endif
  1159. {
  1160. }
  1162. #if defined(DOS)
  1163. /*---------------------------------------------------------------------
  1164.  *
  1165.  * Function: SccbMgr_status
  1166.  *
  1167.  * Description: This function returns the number of outstanding SCCB's.
  1168.  *              This is specific to the DOS enviroment, which needs this
  1169.  *              to help them keep protected and real mode commands staight.
  1170.  *
  1171.  *---------------------------------------------------------------------*/
  1173. USHORT SccbMgr_status(USHORT pCurrCard)
  1174. {
  1175.    return(BL_Card[pCurrCard].cmdCounter);
  1176. }
  1177. #endif
  1179. /*---------------------------------------------------------------------
  1180.  *
  1181.  * Function: SccbMgrTableInit
  1182.  *
  1183.  * Description: Initialize all Sccb manager data structures.
  1184.  *
  1185.  *---------------------------------------------------------------------*/
  1187. void SccbMgrTableInitAll()
  1188. {
  1189.    UCHAR thisCard;
  1191.    for (thisCard = 0; thisCard < MAX_CARDS; thisCard++)
  1192.       {
  1193.       SccbMgrTableInitCard(&BL_Card[thisCard],thisCard);
  1195.       BL_Card[thisCard].ioPort      = 0x00;
  1196.       BL_Card[thisCard].cardInfo    = NULL;
  1197.       BL_Card[thisCard].cardIndex   = 0xFF;
  1198.       BL_Card[thisCard].ourId       = 0x00;
  1199. BL_Card[thisCard].pNvRamInfo = NULL;
  1200.       }
  1201. }
  1204. /*---------------------------------------------------------------------
  1205.  *
  1206.  * Function: SccbMgrTableInit
  1207.  *
  1208.  * Description: Initialize all Sccb manager data structures.
  1209.  *
  1210.  *---------------------------------------------------------------------*/
  1212. void SccbMgrTableInitCard(PSCCBcard pCurrCard, UCHAR p_card)
  1213. {
  1214.    UCHAR scsiID, qtag;
  1216. for (qtag = 0; qtag < QUEUE_DEPTH; qtag++)
  1217. {
  1218. BL_Card[p_card].discQ_Tbl[qtag] = NULL;
  1219. }
  1221.    for (scsiID = 0; scsiID < MAX_SCSI_TAR; scsiID++)
  1222.       {
  1223.       sccbMgrTbl[p_card][scsiID].TarStatus = 0;
  1224.       sccbMgrTbl[p_card][scsiID].TarEEValue = 0;
  1225.       SccbMgrTableInitTarget(p_card, scsiID);
  1226.       }
  1228.    pCurrCard->scanIndex = 0x00;
  1229.    pCurrCard->currentSCCB = NULL;
  1230.    pCurrCard->globalFlags = 0x00;
  1231.    pCurrCard->cmdCounter  = 0x00;
  1232. pCurrCard->tagQ_Lst = 0x01;
  1233. pCurrCard->discQCount = 0; 
  1236. }
  1239. /*---------------------------------------------------------------------
  1240.  *
  1241.  * Function: SccbMgrTableInit
  1242.  *
  1243.  * Description: Initialize all Sccb manager data structures.
  1244.  *
  1245.  *---------------------------------------------------------------------*/
  1247. void SccbMgrTableInitTarget(UCHAR p_card, UCHAR target)
  1248. {
  1250. UCHAR lun, qtag;
  1251. PSCCBMgr_tar_info currTar_Info;
  1253. currTar_Info = &sccbMgrTbl[p_card][target];
  1255. currTar_Info->TarSelQ_Cnt = 0;
  1256. currTar_Info->TarSyncCtrl = 0;
  1258. currTar_Info->TarSelQ_Head = NULL;
  1259. currTar_Info->TarSelQ_Tail = NULL;
  1260. currTar_Info->TarTagQ_Cnt = 0;
  1261. currTar_Info->TarLUN_CA = FALSE;
  1264. for (lun = 0; lun < MAX_LUN; lun++)
  1265. {
  1266. currTar_Info->TarLUNBusy[lun] = FALSE;
  1267. currTar_Info->LunDiscQ_Idx[lun] = 0;
  1268. }
  1270. for (qtag = 0; qtag < QUEUE_DEPTH; qtag++)
  1271. {
  1272. if(BL_Card[p_card].discQ_Tbl[qtag] != NULL)
  1273. {
  1274. if(BL_Card[p_card].discQ_Tbl[qtag]->TargID == target)
  1275. {
  1276. BL_Card[p_card].discQ_Tbl[qtag] = NULL;
  1277. BL_Card[p_card].discQCount--;
  1278. }
  1279. }
  1280. }
  1281. }
  1283. #if defined(BUGBUG)
  1285. /*****************************************************************
  1286.  * Save the current byte in the debug array
  1287.  *****************************************************************/
  1290. void Debug_Load(UCHAR p_card, UCHAR p_bug_data)
  1291. {
  1292.    debug_int[p_card][debug_index[p_card]] = p_bug_data;
  1293.    debug_index[p_card]++;
  1295.    if (debug_index[p_card] == debug_size)
  1297.       debug_index[p_card] = 0;
  1298. }
  1300. #endif
  1301. #ident "$Id: sccb_dat.c 1.10 1997/02/22 03:16:02 awin Exp $"
  1302. /*----------------------------------------------------------------------
  1303.  *
  1304.  *
  1305.  *   Copyright 1995-1996 by Mylex Corporation.  All Rights Reserved
  1306.  *
  1307.  *   This file is available under both the GNU General Public License
  1308.  *   and a BSD-style copyright; see LICENSE.FlashPoint for details.
  1309.  *
  1310.  *   $Workfile:   sccb_dat.c  $
  1311.  *
  1312.  *   Description:  Functions relating to handling of the SCCB interface 
  1313.  *                 between the device driver and the HARPOON.
  1314.  *
  1315.  *   $Date: 1997/02/22 03:16:02 $
  1316.  *
  1317.  *   $Revision: 1.10 $
  1318.  *
  1319.  *----------------------------------------------------------------------*/
  1321. /*#include <globals.h>*/
  1323. #if (FW_TYPE==_UCB_MGR_)
  1324. /*#include <budi.h>*/
  1325. #endif
  1327. /*#include <sccbmgr.h>*/
  1328. /*#include <blx30.h>*/
  1329. /*#include <target.h>*/
  1330. /*#include <harpoon.h>*/
  1332. /*
  1333. **  IMPORTANT NOTE!!!
  1334. **
  1335. **  You MUST preassign all data to a valid value or zero.  This is
  1336. **  required due to the MS compiler bug under OS/2 and Solaris Real-Mode
  1337. **  driver environment.
  1338. */
  1341. SCCBMGR_TAR_INFO sccbMgrTbl[MAX_CARDS][MAX_SCSI_TAR] = { { { 0 } } };
  1342. SCCBCARD BL_Card[MAX_CARDS] = { { 0 } };
  1343. SCCBSCAM_INFO scamInfo[MAX_SCSI_TAR] = { { { 0 } } };
  1344. NVRAMINFO nvRamInfo[MAX_MB_CARDS] = { { 0 } };
  1347. #if defined(OS2)
  1348. void (far *s_PhaseTbl[8]) (ULONG, UCHAR) = { 0 };
  1349. UCHAR temp_id_string[ID_STRING_LENGTH] = { 0 };
  1350. #elif defined(SOLARIS_REAL_MODE) || defined(__STDC__)
  1351. void (*s_PhaseTbl[8]) (ULONG, UCHAR) = { 0 };
  1352. #else
  1353. void (*s_PhaseTbl[8]) ();
  1354. #endif
  1356. #if defined(DOS)
  1357. UCHAR first_time = 0;
  1358. #endif
  1360. UCHAR mbCards = 0;
  1361. UCHAR scamHAString[] = {0x63, 0x07, 'B', 'U', 'S', 'L', 'O', 'G', 'I', 'C', 
  1362. ' ', 'B', 'T', '-', '9', '3', '0', 
  1363. 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
  1364. 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20};
  1366. USHORT default_intena = 0;
  1368. #if defined(BUGBUG)
  1369. UCHAR    debug_int[MAX_CARDS][debug_size] = { 0 };
  1370. UCHAR    debug_index[MAX_CARDS] = { 0 };
  1371. UCHAR    reserved_1[3] = { 0 };
  1372. #endif
  1373. #ident "$Id: scsi.c 1.23 1997/07/09 21:42:54 mohan Exp $"
  1374. /*----------------------------------------------------------------------
  1375.  *
  1376.  *
  1377.  *   Copyright 1995-1996 by Mylex Corporation.  All Rights Reserved
  1378.  *
  1379.  *   This file is available under both the GNU General Public License
  1380.  *   and a BSD-style copyright; see LICENSE.FlashPoint for details.
  1381.  *
  1382.  *   $Workfile:   scsi.c  $
  1383.  *
  1384.  *   Description:  Functions for handling SCSI bus functions such as
  1385.  *                 selection/reselection, sync negotiation, message-in
  1386.  *                 decoding.
  1387.  *
  1388.  *   $Date: 1997/07/09 21:42:54 $
  1389.  *
  1390.  *   $Revision: 1.23 $
  1391.  *
  1392.  *----------------------------------------------------------------------*/
  1394. /*#include <globals.h>*/
  1396. #if (FW_TYPE==_UCB_MGR_)
  1397. /*#include <budi.h>*/
  1398. #endif
  1400. /*#include <sccbmgr.h>*/
  1401. /*#include <blx30.h>*/
  1402. /*#include <target.h>*/
  1403. /*#include <scsi2.h>*/
  1404. /*#include <eeprom.h>*/
  1405. /*#include <harpoon.h>*/
  1408. /*
  1409. extern SCCBCARD BL_Card[MAX_CARDS];
  1410. extern SCCBMGR_TAR_INFO sccbMgrTbl[MAX_CARDS][MAX_SCSI_TAR];
  1411. #if defined(BUGBUG)
  1412. void Debug_Load(UCHAR p_card, UCHAR p_bug_data);
  1413. #endif
  1414. */
  1416. /*---------------------------------------------------------------------
  1417.  *
  1418.  * Function: sfetm
  1419.  *
  1420.  * Description: Read in a message byte from the SCSI bus, and check
  1421.  *              for a parity error.
  1422.  *
  1423.  *---------------------------------------------------------------------*/
  1425. #if defined(DOS)
  1426. UCHAR sfm(USHORT port, PSCCB pCurrSCCB)
  1427. #else
  1428. UCHAR sfm(ULONG port, PSCCB pCurrSCCB)
  1429. #endif
  1430. {
  1431. UCHAR message;
  1432. USHORT TimeOutLoop;
  1434. TimeOutLoop = 0;
  1435. while( (!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ)) &&
  1436. (TimeOutLoop++ < 20000) ){}
  1439. WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  1441. message = RD_HARPOON(port+hp_scsidata_0);
  1443. WR_HARPOON(port+hp_scsisig, SCSI_ACK + S_MSGI_PH);
  1446. if (TimeOutLoop > 20000)
  1447. message = 0x00;   /* force message byte = 0 if Time Out on Req */
  1449. if ((RDW_HARPOON((port+hp_intstat)) & PARITY) &&
  1450. (RD_HARPOON(port+hp_addstat) & SCSI_PAR_ERR))
  1451. {
  1452. WR_HARPOON(port+hp_scsisig, (SCSI_ACK + S_ILL_PH));
  1453. WR_HARPOON(port+hp_xferstat, 0);
  1454. WR_HARPOON(port+hp_fiforead, 0);
  1455. WR_HARPOON(port+hp_fifowrite, 0);
  1456. if (pCurrSCCB != NULL)
  1457. {
  1458. pCurrSCCB->Sccb_scsimsg = SMPARITY;
  1459. }
  1460. message = 0x00;
  1461. do
  1462. {
  1463. ACCEPT_MSG_ATN(port);
  1464. TimeOutLoop = 0;
  1465. while( (!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ)) &&
  1466. (TimeOutLoop++ < 20000) ){}
  1467. if (TimeOutLoop > 20000)
  1468. {
  1469. WRW_HARPOON((port+hp_intstat), PARITY);
  1470. return(message);
  1471. }
  1472. if ((RD_HARPOON(port+hp_scsisig) & S_SCSI_PHZ) != S_MSGI_PH)
  1473. {
  1474. WRW_HARPOON((port+hp_intstat), PARITY);
  1475. return(message);
  1476. }
  1477. WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  1479. RD_HARPOON(port+hp_scsidata_0);
  1481. WR_HARPOON(port+hp_scsisig, (SCSI_ACK + S_ILL_PH));
  1483. }while(1);
  1485. }
  1486. WR_HARPOON(port+hp_scsisig, (SCSI_ACK + S_ILL_PH));
  1487. WR_HARPOON(port+hp_xferstat, 0);
  1488. WR_HARPOON(port+hp_fiforead, 0);
  1489. WR_HARPOON(port+hp_fifowrite, 0);
  1490. return(message);
  1491. }
  1494. /*---------------------------------------------------------------------
  1495.  *
  1496.  * Function: ssel
  1497.  *
  1498.  * Description: Load up automation and select target device.
  1499.  *
  1500.  *---------------------------------------------------------------------*/
  1502. #if defined(DOS)
  1503. void ssel(USHORT port, UCHAR p_card)
  1504. #else
  1505. void ssel(ULONG port, UCHAR p_card)
  1506. #endif
  1507. {
  1509. #if defined(DOS)
  1510.    UCHAR auto_loaded, i, target, *theCCB;
  1511. #elif defined(OS2)
  1512.    UCHAR auto_loaded, i, target;
  1513.    UCHAR far *theCCB;
  1514. #else
  1515.    UCHAR auto_loaded, i, target, *theCCB;
  1516. #endif
  1518. #if defined(DOS)
  1519.    USHORT cdb_reg;
  1520. #else
  1521.    ULONG cdb_reg;
  1522. #endif
  1523.    PSCCBcard CurrCard;
  1524.    PSCCB currSCCB;
  1525.    PSCCBMgr_tar_info currTar_Info;
  1526.    UCHAR lastTag, lun;
  1528.    CurrCard = &BL_Card[p_card];
  1529.    currSCCB = CurrCard->currentSCCB;
  1530.    target = currSCCB->TargID;
  1531.    currTar_Info = &sccbMgrTbl[p_card][target];
  1532.    lastTag = CurrCard->tagQ_Lst;
  1534.    ARAM_ACCESS(port);
  1537. if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_REJECT)
  1538. currSCCB->ControlByte &= ~F_USE_CMD_Q;
  1540. if(((CurrCard->globalFlags & F_CONLUN_IO) && 
  1541. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING)))
  1543.    lun = currSCCB->Lun;
  1544. else
  1545. lun = 0;
  1548. #if defined(DOS)
  1549.    currTar_Info->TarLUNBusy[lun] = TRUE;
  1551. #else
  1553.    if (CurrCard->globalFlags & F_TAG_STARTED)
  1554.       {
  1555.       if (!(currSCCB->ControlByte & F_USE_CMD_Q))
  1556.          {
  1557.        if ((currTar_Info->TarLUN_CA == FALSE)
  1558.            && ((currTar_Info->TarStatus & TAR_TAG_Q_MASK)
  1559.            == TAG_Q_TRYING))
  1560.             {
  1562.          if (currTar_Info->TarTagQ_Cnt !=0)
  1563.                   {
  1564.              currTar_Info->TarLUNBusy[lun] = TRUE;
  1565.              queueSelectFail(CurrCard,p_card);
  1566.    SGRAM_ACCESS(port);
  1567.              return;
  1568.              }
  1570.             else {
  1571.             currTar_Info->TarLUNBusy[lun] = TRUE;
  1572.             }
  1574.           }  /*End non-tagged */
  1576.       else {
  1577.          currTar_Info->TarLUNBusy[lun] = TRUE;
  1578.          }
  1580.       }  /*!Use cmd Q Tagged */
  1582.    else {
  1583.          if (currTar_Info->TarLUN_CA == TRUE)
  1584.                {
  1585.              queueSelectFail(CurrCard,p_card);
  1586.    SGRAM_ACCESS(port);
  1587.              return;
  1588.             }
  1590.         currTar_Info->TarLUNBusy[lun] = TRUE;
  1592.          }  /*else use cmd Q tagged */
  1594.       }  /*if glob tagged started */
  1596.    else {
  1597.         currTar_Info->TarLUNBusy[lun] = TRUE;
  1598.         }
  1600. #endif /* DOS */
  1604. if((((CurrCard->globalFlags & F_CONLUN_IO) && 
  1605. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING)) 
  1606. || (!(currSCCB->ControlByte & F_USE_CMD_Q))))
  1607. {
  1608. if(CurrCard->discQCount >= QUEUE_DEPTH)
  1609. {
  1610. currTar_Info->TarLUNBusy[lun] = TRUE;
  1611. queueSelectFail(CurrCard,p_card);
  1612. SGRAM_ACCESS(port);
  1613. return;
  1614. }
  1615. for (i = 1; i < QUEUE_DEPTH; i++)
  1616. {
  1617. if (++lastTag >= QUEUE_DEPTH) lastTag = 1;
  1618. if (CurrCard->discQ_Tbl[lastTag] == NULL)
  1619. {
  1620. CurrCard->tagQ_Lst = lastTag;
  1621. currTar_Info->LunDiscQ_Idx[lun] = lastTag;
  1622. CurrCard->discQ_Tbl[lastTag] = currSCCB;
  1623. CurrCard->discQCount++;
  1624. break;
  1625. }
  1626. }
  1627. if(i == QUEUE_DEPTH)
  1628. {
  1629. currTar_Info->TarLUNBusy[lun] = TRUE;
  1630. queueSelectFail(CurrCard,p_card);
  1631. SGRAM_ACCESS(port);
  1632. return;
  1633. }
  1634. }
  1638.    auto_loaded = FALSE;
  1640.    WR_HARPOON(port+hp_select_id, target);
  1641.    WR_HARPOON(port+hp_gp_reg_3, target);  /* Use by new automation logic */
  1643.    if (currSCCB->OperationCode == RESET_COMMAND) {
  1644.       WRW_HARPOON((port+ID_MSG_STRT), (MPM_OP+AMSG_OUT+
  1645.                  (currSCCB->Sccb_idmsg & ~DISC_PRIV)));
  1647.       WRW_HARPOON((port+ID_MSG_STRT+2),BRH_OP+ALWAYS+NP);
  1649.       currSCCB->Sccb_scsimsg = SMDEV_RESET;
  1651.       WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  1652.       auto_loaded = TRUE;
  1653.       currSCCB->Sccb_scsistat = SELECT_BDR_ST;
  1655.       if (currTar_Info->TarEEValue & EE_SYNC_MASK)
  1656.          {
  1657.        currTar_Info->TarSyncCtrl = 0;
  1658.       currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
  1659.       }
  1661. #if defined(WIDE_SCSI)
  1663.       if (currTar_Info->TarEEValue & EE_WIDE_SCSI)
  1664.          {
  1665.        currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
  1666.        }
  1667. #endif
  1669.       sssyncv(port, target, NARROW_SCSI,currTar_Info);
  1670.       SccbMgrTableInitTarget(p_card, target);
  1672.       }
  1674. else if(currSCCB->Sccb_scsistat == ABORT_ST)
  1675. {
  1676. WRW_HARPOON((port+ID_MSG_STRT), (MPM_OP+AMSG_OUT+
  1677. (currSCCB->Sccb_idmsg & ~DISC_PRIV)));
  1679.       WRW_HARPOON((port+ID_MSG_STRT+2),BRH_OP+ALWAYS+CMDPZ);
  1681. WRW_HARPOON((port+SYNC_MSGS+0), (MPM_OP+AMSG_OUT+
  1682. (((UCHAR)(currSCCB->ControlByte & TAG_TYPE_MASK)
  1683. >> 6) | (UCHAR)0x20)));
  1684. WRW_HARPOON((port+SYNC_MSGS+2),
  1685. (MPM_OP+AMSG_OUT+currSCCB->Sccb_tag));
  1686. WRW_HARPOON((port+SYNC_MSGS+4), (BRH_OP+ALWAYS+NP ));
  1688. WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  1689. auto_loaded = TRUE;
  1691. }
  1693. #if defined(WIDE_SCSI)
  1696.    else if (!(currTar_Info->TarStatus & WIDE_NEGOCIATED))  {
  1697.       auto_loaded = siwidn(port,p_card);
  1698.       currSCCB->Sccb_scsistat = SELECT_WN_ST;
  1699.       }
  1701. #endif
  1704.    else if (!((currTar_Info->TarStatus & TAR_SYNC_MASK)
  1705.       == SYNC_SUPPORTED))  {
  1706.       auto_loaded = sisyncn(port,p_card, FALSE);
  1707.       currSCCB->Sccb_scsistat = SELECT_SN_ST;
  1708.       }
  1711.    if (!auto_loaded)
  1712.       {
  1714. #if !defined(DOS)
  1715.       if (currSCCB->ControlByte & F_USE_CMD_Q)
  1716.          {
  1718.          CurrCard->globalFlags |= F_TAG_STARTED;
  1720.          if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK)
  1721.             == TAG_Q_REJECT)
  1722.             {
  1723.             currSCCB->ControlByte &= ~F_USE_CMD_Q;
  1725.             /* Fix up the start instruction with a jump to
  1726.                Non-Tag-CMD handling */
  1727.             WRW_HARPOON((port+ID_MSG_STRT),BRH_OP+ALWAYS+NTCMD);
  1729.             WRW_HARPOON((port+NON_TAG_ID_MSG),
  1730.                      (MPM_OP+AMSG_OUT+currSCCB->Sccb_idmsg));
  1732.          WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  1734.          /* Setup our STATE so we know what happend when
  1735.                the wheels fall off. */
  1736.             currSCCB->Sccb_scsistat = SELECT_ST;
  1738.          currTar_Info->TarLUNBusy[lun] = TRUE;
  1739.             }
  1741.          else
  1742.             {
  1743.             WRW_HARPOON((port+ID_MSG_STRT), (MPM_OP+AMSG_OUT+currSCCB->Sccb_idmsg));
  1745.             WRW_HARPOON((port+ID_MSG_STRT+2), (MPM_OP+AMSG_OUT+
  1746.                         (((UCHAR)(currSCCB->ControlByte & TAG_TYPE_MASK)
  1747.                         >> 6) | (UCHAR)0x20)));
  1749. for (i = 1; i < QUEUE_DEPTH; i++)
  1750. {
  1751. if (++lastTag >= QUEUE_DEPTH) lastTag = 1;
  1752. if (CurrCard->discQ_Tbl[lastTag] == NULL)
  1753. {
  1754. WRW_HARPOON((port+ID_MSG_STRT+6),
  1755. (MPM_OP+AMSG_OUT+lastTag));
  1756. CurrCard->tagQ_Lst = lastTag;
  1757. currSCCB->Sccb_tag = lastTag;
  1758. CurrCard->discQ_Tbl[lastTag] = currSCCB;
  1759. CurrCard->discQCount++;
  1760. break;
  1761. }
  1762. }
  1765.             if ( i == QUEUE_DEPTH )
  1766.                {
  1767.              currTar_Info->TarLUNBusy[lun] = TRUE;
  1768.                queueSelectFail(CurrCard,p_card);
  1769.    SGRAM_ACCESS(port);
  1770.              return;
  1771.              }
  1773.             currSCCB->Sccb_scsistat = SELECT_Q_ST;
  1775.           WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  1776.             }
  1777.          }
  1779.       else
  1780.          {
  1781. #endif   /* !DOS */
  1783.          WRW_HARPOON((port+ID_MSG_STRT),BRH_OP+ALWAYS+NTCMD);
  1785.        WRW_HARPOON((port+NON_TAG_ID_MSG),
  1786.             (MPM_OP+AMSG_OUT+currSCCB->Sccb_idmsg));
  1788.          currSCCB->Sccb_scsistat = SELECT_ST;
  1790.          WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  1791. #if !defined(DOS)
  1792.          }
  1793. #endif
  1796. #if defined(OS2)
  1797.       theCCB = (UCHAR far *)&currSCCB->Cdb[0];
  1798. #else
  1799.       theCCB = (UCHAR *)&currSCCB->Cdb[0];
  1800. #endif
  1802.       cdb_reg = port + CMD_STRT;
  1804.       for (i=0; i < currSCCB->CdbLength; i++)
  1805.          {
  1806.          WRW_HARPOON(cdb_reg, (MPM_OP + ACOMMAND + *theCCB));
  1807.          cdb_reg +=2;
  1808.          theCCB++;
  1809.          }
  1811.       if (currSCCB->CdbLength != TWELVE_BYTE_CMD)
  1812.          WRW_HARPOON(cdb_reg, (BRH_OP+ALWAYS+    NP));
  1814.       }  /* auto_loaded */
  1816. #if defined(WIDE_SCSI)
  1817.    WRW_HARPOON((port+hp_fiforead), (USHORT) 0x00);
  1818.    WR_HARPOON(port+hp_xferstat, 0x00);
  1819. #endif
  1821.    WRW_HARPOON((port+hp_intstat), (PROG_HLT | TIMEOUT | SEL | BUS_FREE));
  1823.    WR_HARPOON(port+hp_portctrl_0,(SCSI_PORT));
  1826.    if (!(currSCCB->Sccb_MGRFlags & F_DEV_SELECTED))
  1827.       {
  1828.       WR_HARPOON(port+hp_scsictrl_0, (SEL_TAR | ENA_ATN | ENA_RESEL | ENA_SCAM_SEL));
  1829.       }
  1830.    else
  1831.       {
  1833. /*      auto_loaded =  (RD_HARPOON(port+hp_autostart_3) & (UCHAR)0x1F);
  1834.       auto_loaded |= AUTO_IMMED; */
  1835.       auto_loaded = AUTO_IMMED;
  1837.       DISABLE_AUTO(port);
  1839.       WR_HARPOON(port+hp_autostart_3, auto_loaded);
  1840.       }
  1842.    SGRAM_ACCESS(port);
  1843. }
  1846. /*---------------------------------------------------------------------
  1847.  *
  1848.  * Function: sres
  1849.  *
  1850.  * Description: Hookup the correct CCB and handle the incoming messages.
  1851.  *
  1852.  *---------------------------------------------------------------------*/
  1854. #if defined(DOS)
  1855. void sres(USHORT port, UCHAR p_card, PSCCBcard pCurrCard)
  1856. #else
  1857. void sres(ULONG port, UCHAR p_card, PSCCBcard pCurrCard)
  1858. #endif
  1859. {
  1861. #if defined(V302)
  1862. #ifdef DOS
  1863.    UCHAR our_target,message, msgRetryCount;
  1864.    extern UCHAR lun, tag;
  1865. #else
  1866.    UCHAR our_target,message,lun,tag, msgRetryCount;
  1867. #endif
  1869. #else  /* V302 */
  1870.    UCHAR our_target, message, lun = 0, tag, msgRetryCount;
  1871. #endif /* V302 */
  1874.    PSCCBMgr_tar_info currTar_Info;
  1875. PSCCB currSCCB;
  1880. if(pCurrCard->currentSCCB != NULL)
  1881. {
  1882. currTar_Info = &sccbMgrTbl[p_card][pCurrCard->currentSCCB->TargID];
  1883. DISABLE_AUTO(port);
  1886. WR_HARPOON((port+hp_scsictrl_0),(ENA_RESEL | ENA_SCAM_SEL));
  1889. currSCCB = pCurrCard->currentSCCB;
  1890. if(currSCCB->Sccb_scsistat == SELECT_WN_ST)
  1891. {
  1892. currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
  1893. currSCCB->Sccb_scsistat = BUS_FREE_ST;
  1894. }
  1895. if(currSCCB->Sccb_scsistat == SELECT_SN_ST)
  1896. {
  1897. currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
  1898. currSCCB->Sccb_scsistat = BUS_FREE_ST;
  1899. }
  1900. if(((pCurrCard->globalFlags & F_CONLUN_IO) &&
  1901. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING)))
  1902. {
  1903.        currTar_Info->TarLUNBusy[currSCCB->Lun] = FALSE;
  1904. if(currSCCB->Sccb_scsistat != ABORT_ST)
  1905. {
  1906. pCurrCard->discQCount--;
  1907. pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[currSCCB->Lun]] 
  1908. = NULL;
  1909. }
  1910. }
  1911. else
  1912. {
  1913.       currTar_Info->TarLUNBusy[0] = FALSE;
  1914. if(currSCCB->Sccb_tag)
  1915. {
  1916. if(currSCCB->Sccb_scsistat != ABORT_ST)
  1917. {
  1918. pCurrCard->discQCount--;
  1919. pCurrCard->discQ_Tbl[currSCCB->Sccb_tag] = NULL;
  1920. }
  1921. }else
  1922. {
  1923. if(currSCCB->Sccb_scsistat != ABORT_ST)
  1924. {
  1925. pCurrCard->discQCount--;
  1926. pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[0]] = NULL;
  1927. }
  1928. }
  1929. }
  1931.       queueSelectFail(&BL_Card[p_card],p_card);
  1932. }
  1934. #if defined(WIDE_SCSI)
  1935. WRW_HARPOON((port+hp_fiforead), (USHORT) 0x00);
  1936. #endif
  1939. our_target = (UCHAR)(RD_HARPOON(port+hp_select_id) >> 4);
  1940. currTar_Info = &sccbMgrTbl[p_card][our_target];
  1943. msgRetryCount = 0;
  1944. do
  1945. {
  1947. #if defined(V302)
  1949. message = GetTarLun(port, p_card, our_target, pCurrCard, &tag, &lun);
  1951. #else /* V302 */
  1953. currTar_Info = &sccbMgrTbl[p_card][our_target];
  1954. tag = 0;
  1957. while(!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ))
  1958. {
  1959. if (! (RD_HARPOON(port+hp_scsisig) & SCSI_BSY))
  1960. {
  1962. WRW_HARPOON((port+hp_intstat), PHASE);
  1963. return;
  1964. }
  1965. }
  1967. WRW_HARPOON((port+hp_intstat), PHASE);
  1968. if ((RD_HARPOON(port+hp_scsisig) & S_SCSI_PHZ) == S_MSGI_PH)
  1969. {
  1971. message = sfm(port,pCurrCard->currentSCCB);
  1972. if (message)
  1973. {
  1975. if (message <= (0x80 | LUN_MASK))
  1976. {
  1977. lun = message & (UCHAR)LUN_MASK;
  1979. #if !defined(DOS)
  1980. if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_TRYING)
  1981. {
  1982. if (currTar_Info->TarTagQ_Cnt != 0)
  1983. {
  1985. if (!(currTar_Info->TarLUN_CA))
  1986. {
  1987. ACCEPT_MSG(port);    /*Release the ACK for ID msg. */
  1990. message = sfm(port,pCurrCard->currentSCCB);
  1991. if (message)
  1992. {
  1993. ACCEPT_MSG(port);
  1994. }
  1996. else
  1997.     message = FALSE;
  1999. if(message != FALSE)
  2000. {
  2001. tag = sfm(port,pCurrCard->currentSCCB);
  2003. if (!(tag)) 
  2004. message = FALSE;
  2005. }
  2007. } /*C.A. exists! */
  2009. } /*End Q cnt != 0 */
  2011. } /*End Tag cmds supported! */
  2012. #endif /* !DOS */
  2014. } /*End valid ID message.  */
  2016. else
  2017. {
  2019. ACCEPT_MSG_ATN(port);
  2020. }
  2022. } /* End good id message. */
  2024. else
  2025. {
  2027. message = FALSE;
  2028. }
  2029. }
  2030. else
  2031. {
  2032. ACCEPT_MSG_ATN(port);
  2034.    while (!(RDW_HARPOON((port+hp_intstat)) & (PHASE | RESET)) &&
  2035.   !(RD_HARPOON(port+hp_scsisig) & SCSI_REQ) &&
  2036.   (RD_HARPOON(port+hp_scsisig) & SCSI_BSY)) ;
  2038. return;
  2039. }
  2041. #endif /* V302 */
  2043. if(message == FALSE)
  2044. {
  2045. msgRetryCount++;
  2046. if(msgRetryCount == 1)
  2047. {
  2048. SendMsg(port, SMPARITY);
  2049. }
  2050. else
  2051. {
  2052. SendMsg(port, SMDEV_RESET);
  2054. sssyncv(port, our_target, NARROW_SCSI,currTar_Info);
  2056. if (sccbMgrTbl[p_card][our_target].TarEEValue & EE_SYNC_MASK) 
  2057. {
  2059. sccbMgrTbl[p_card][our_target].TarStatus &= ~TAR_SYNC_MASK;
  2061. }
  2063. if (sccbMgrTbl[p_card][our_target].TarEEValue & EE_WIDE_SCSI) 
  2064. {
  2066. sccbMgrTbl[p_card][our_target].TarStatus &= ~TAR_WIDE_MASK;
  2067. }
  2070. queueFlushTargSccb(p_card, our_target, SCCB_COMPLETE);
  2071. SccbMgrTableInitTarget(p_card,our_target);
  2072. return;
  2073. }
  2074. }
  2075. }while(message == FALSE);
  2079. if(((pCurrCard->globalFlags & F_CONLUN_IO) &&
  2080. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING)))
  2081. {
  2082. currTar_Info->TarLUNBusy[lun] = TRUE;
  2083. pCurrCard->currentSCCB = pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[lun]];
  2084. if(pCurrCard->currentSCCB != NULL)
  2085. {
  2086. ACCEPT_MSG(port);
  2087. }
  2088. else 
  2089. {
  2090. ACCEPT_MSG_ATN(port);
  2091. }
  2092. }
  2093. else
  2094. {
  2095. currTar_Info->TarLUNBusy[0] = TRUE;
  2098. if (tag)
  2099. {
  2100. if (pCurrCard->discQ_Tbl[tag] != NULL)
  2101. {
  2102. pCurrCard->currentSCCB = pCurrCard->discQ_Tbl[tag];
  2103.   currTar_Info->TarTagQ_Cnt--;
  2104. ACCEPT_MSG(port);
  2105. }
  2106. else
  2107. {
  2108. ACCEPT_MSG_ATN(port);
  2109. }
  2110. }else
  2111. {
  2112. pCurrCard->currentSCCB = pCurrCard->discQ_Tbl[currTar_Info->LunDiscQ_Idx[0]];
  2113. if(pCurrCard->currentSCCB != NULL)
  2114. {
  2115. ACCEPT_MSG(port);
  2116. }
  2117. else 
  2118. {
  2119. ACCEPT_MSG_ATN(port);
  2120. }
  2121. }
  2122. }
  2124. if(pCurrCard->currentSCCB != NULL)
  2125. {
  2126. if(pCurrCard->currentSCCB->Sccb_scsistat == ABORT_ST)
  2127. {
  2128. /* During Abort Tag command, the target could have got re-selected
  2129. and completed the command. Check the select Q and remove the CCB
  2130. if it is in the Select Q */
  2131. queueFindSccb(pCurrCard->currentSCCB, p_card);
  2132. }
  2133. }
  2136.    while (!(RDW_HARPOON((port+hp_intstat)) & (PHASE | RESET)) &&
  2137.   !(RD_HARPOON(port+hp_scsisig) & SCSI_REQ) &&
  2138.   (RD_HARPOON(port+hp_scsisig) & SCSI_BSY)) ;
  2139. }
  2141. #if defined(V302)
  2143. #if defined(DOS)
  2144. UCHAR GetTarLun(USHORT port, UCHAR p_card, UCHAR our_target, PSCCBcard pCurrCard, PUCHAR tag, PUCHAR lun)
  2145. #else
  2146. UCHAR GetTarLun(ULONG port, UCHAR p_card, UCHAR our_target, PSCCBcard pCurrCard, PUCHAR tag, PUCHAR lun)
  2147. #endif
  2148. {
  2149.    UCHAR message;
  2150.    PSCCBMgr_tar_info currTar_Info;
  2153. currTar_Info = &sccbMgrTbl[p_card][our_target];
  2154. *tag = 0;
  2157. while(!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ))
  2158. {
  2159. if (! (RD_HARPOON(port+hp_scsisig) & SCSI_BSY))
  2160. {
  2162. WRW_HARPOON((port+hp_intstat), PHASE);
  2163. return(TRUE);
  2164. }
  2165. }
  2167. WRW_HARPOON((port+hp_intstat), PHASE);
  2168. if ((RD_HARPOON(port+hp_scsisig) & S_SCSI_PHZ) == S_MSGI_PH)
  2169. {
  2171. message = sfm(port,pCurrCard->currentSCCB);
  2172. if (message)
  2173. {
  2175. if (message <= (0x80 | LUN_MASK))
  2176. {
  2177. *lun = message & (UCHAR)LUN_MASK;
  2179. #if !defined(DOS)
  2180. if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_TRYING)
  2181. {
  2182. if (currTar_Info->TarTagQ_Cnt != 0)
  2183. {
  2185. if (!(currTar_Info->TarLUN_CA))
  2186. {
  2187. ACCEPT_MSG(port);    /*Release the ACK for ID msg. */
  2190. message = sfm(port,pCurrCard->currentSCCB);
  2191. if (message)
  2192. {
  2193. ACCEPT_MSG(port);
  2194. }
  2196. else
  2197.     return(FALSE);
  2199. *tag = sfm(port,pCurrCard->currentSCCB);
  2201. if (!(*tag)) return(FALSE);
  2203. } /*C.A. exists! */
  2205. } /*End Q cnt != 0 */
  2207. } /*End Tag cmds supported! */
  2208. #endif /* !DOS */
  2210. } /*End valid ID message.  */
  2212. else
  2213. {
  2215. ACCEPT_MSG_ATN(port);
  2216. }
  2218. } /* End good id message. */
  2220. else
  2221. {
  2223. return(FALSE);
  2224. }
  2225. }
  2226. else
  2227. {
  2228. ACCEPT_MSG_ATN(port);
  2229. return(TRUE);
  2230. }
  2231. return(TRUE);
  2232. }
  2234. #endif /* V302 */
  2236. #if defined(DOS)
  2237. void SendMsg(USHORT port, UCHAR message)
  2238. #else
  2239. void SendMsg(ULONG port, UCHAR message)
  2240. #endif
  2241. {
  2242. while(!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ))
  2243. {
  2244. if (! (RD_HARPOON(port+hp_scsisig) & SCSI_BSY))
  2245. {
  2247. WRW_HARPOON((port+hp_intstat), PHASE);
  2248. return;
  2249. }
  2250. }
  2252. WRW_HARPOON((port+hp_intstat), PHASE);
  2253. if ((RD_HARPOON(port+hp_scsisig) & S_SCSI_PHZ) == S_MSGO_PH)
  2254. {
  2255. WRW_HARPOON((port+hp_intstat), (BUS_FREE | PHASE | XFER_CNT_0));
  2258. WR_HARPOON(port+hp_portctrl_0, SCSI_BUS_EN);
  2260. WR_HARPOON(port+hp_scsidata_0,message);
  2262. WR_HARPOON(port+hp_scsisig, (SCSI_ACK + S_ILL_PH));
  2264. ACCEPT_MSG(port);
  2266. WR_HARPOON(port+hp_portctrl_0, 0x00);
  2268. if ((message == SMABORT) || (message == SMDEV_RESET) ||
  2269. (message == SMABORT_TAG) )
  2270. {
  2271. while(!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | PHASE))) {}
  2273. if (RDW_HARPOON((port+hp_intstat)) & BUS_FREE)
  2274. {
  2275. WRW_HARPOON((port+hp_intstat), BUS_FREE);
  2276. }
  2277. }
  2278. }
  2279. }
  2281. /*---------------------------------------------------------------------
  2282.  *
  2283.  * Function: sdecm
  2284.  *
  2285.  * Description: Determine the proper responce to the message from the
  2286.  *              target device.
  2287.  *
  2288.  *---------------------------------------------------------------------*/
  2289. #if defined(DOS)
  2290. void sdecm(UCHAR message, USHORT port, UCHAR p_card)
  2291. #else
  2292. void sdecm(UCHAR message, ULONG port, UCHAR p_card)
  2293. #endif
  2294. {
  2295. PSCCB currSCCB;
  2296. PSCCBcard CurrCard;
  2297. PSCCBMgr_tar_info currTar_Info;
  2299. CurrCard = &BL_Card[p_card];
  2300. currSCCB = CurrCard->currentSCCB;
  2302. currTar_Info = &sccbMgrTbl[p_card][currSCCB->TargID];
  2304. if (message == SMREST_DATA_PTR)
  2305. {
  2306. if (!(currSCCB->Sccb_XferState & F_NO_DATA_YET))
  2307. {
  2308. currSCCB->Sccb_ATC = currSCCB->Sccb_savedATC;
  2310. hostDataXferRestart(currSCCB);
  2311. }
  2313. ACCEPT_MSG(port);
  2314. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2315. }
  2317. else if (message == SMCMD_COMP)
  2318. {
  2321. if (currSCCB->Sccb_scsistat == SELECT_Q_ST)
  2322. {
  2323. currTar_Info->TarStatus &= ~(UCHAR)TAR_TAG_Q_MASK;
  2324. currTar_Info->TarStatus |= (UCHAR)TAG_Q_REJECT;
  2325. }
  2327. ACCEPT_MSG(port);
  2329. }
  2331. else if ((message == SMNO_OP) || (message >= SMIDENT) 
  2332. || (message == SMINIT_RECOVERY) || (message == SMREL_RECOVERY))
  2333. {
  2335. ACCEPT_MSG(port);
  2336. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2337. }
  2339. else if (message == SMREJECT)
  2340. {
  2342. if ((currSCCB->Sccb_scsistat == SELECT_SN_ST) ||
  2343. (currSCCB->Sccb_scsistat == SELECT_WN_ST) ||
  2344. ((currTar_Info->TarStatus & TAR_SYNC_MASK) == SYNC_TRYING ) ||
  2345. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_TRYING ) )
  2347. {
  2348. WRW_HARPOON((port+hp_intstat), BUS_FREE);
  2350. ACCEPT_MSG(port);
  2353. while ((!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ)) &&
  2354. (!(RDW_HARPOON((port+hp_intstat)) & BUS_FREE))) {}
  2356. if(currSCCB->Lun == 0x00)
  2357. {
  2358. if ((currSCCB->Sccb_scsistat == SELECT_SN_ST))
  2359. {
  2361. currTar_Info->TarStatus |= (UCHAR)SYNC_SUPPORTED;
  2363. currTar_Info->TarEEValue &= ~EE_SYNC_MASK;
  2364. }
  2366. #if defined(WIDE_SCSI)
  2367. else if ((currSCCB->Sccb_scsistat == SELECT_WN_ST))
  2368. {
  2371. currTar_Info->TarStatus = (currTar_Info->TarStatus &
  2372. ~WIDE_ENABLED) | WIDE_NEGOCIATED;
  2374. currTar_Info->TarEEValue &= ~EE_WIDE_SCSI;
  2376. }
  2377. #endif
  2379. else if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_TRYING )
  2380. {
  2381. currTar_Info->TarStatus = (currTar_Info->TarStatus &
  2382. ~(UCHAR)TAR_TAG_Q_MASK) | TAG_Q_REJECT;
  2385. currSCCB->ControlByte &= ~F_USE_CMD_Q;
  2386. CurrCard->discQCount--;
  2387. CurrCard->discQ_Tbl[currSCCB->Sccb_tag] = NULL;
  2388. currSCCB->Sccb_tag = 0x00;
  2390. }
  2391. }
  2393. if (RDW_HARPOON((port+hp_intstat)) & BUS_FREE)
  2394. {
  2397. if(currSCCB->Lun == 0x00)
  2398. {
  2399. WRW_HARPOON((port+hp_intstat), BUS_FREE);
  2400. CurrCard->globalFlags |= F_NEW_SCCB_CMD;
  2401. }
  2402. }
  2404. else 
  2405. {
  2407. if((CurrCard->globalFlags & F_CONLUN_IO) &&
  2408. ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
  2409. currTar_Info->TarLUNBusy[currSCCB->Lun] = TRUE;
  2410. else
  2411. currTar_Info->TarLUNBusy[0] = TRUE;
  2414. currSCCB->ControlByte &= ~(UCHAR)F_USE_CMD_Q;
  2416. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2418. }
  2419. }
  2421. else
  2422. {
  2423. ACCEPT_MSG(port);
  2425. while ((!(RD_HARPOON(port+hp_scsisig) & SCSI_REQ)) &&
  2426. (!(RDW_HARPOON((port+hp_intstat)) & BUS_FREE))) {}
  2428. if (!(RDW_HARPOON((port+hp_intstat)) & BUS_FREE))
  2429. {
  2430. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2431. }
  2432. }
  2433. }
  2435. else if (message == SMEXT)
  2436. {
  2438. ACCEPT_MSG(port);
  2439. shandem(port,p_card,currSCCB);
  2440. }
  2442. else if (message == SMIGNORWR)
  2443. {
  2445. ACCEPT_MSG(port);          /* ACK the RESIDUE MSG */
  2447. message = sfm(port,currSCCB);
  2449. if(currSCCB->Sccb_scsimsg != SMPARITY)
  2450. ACCEPT_MSG(port);
  2451. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2452. }
  2455. else
  2456. {
  2458. currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
  2459. currSCCB->Sccb_scsimsg = SMREJECT;
  2461. ACCEPT_MSG_ATN(port);
  2462. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2463. }
  2464. }
  2467. /*---------------------------------------------------------------------
  2468.  *
  2469.  * Function: shandem
  2470.  *
  2471.  * Description: Decide what to do with the extended message.
  2472.  *
  2473.  *---------------------------------------------------------------------*/
  2474. #if defined(DOS)
  2475. void shandem(USHORT port, UCHAR p_card, PSCCB pCurrSCCB)
  2476. #else
  2477. void shandem(ULONG port, UCHAR p_card, PSCCB pCurrSCCB)
  2478. #endif
  2479. {
  2480. UCHAR length,message;
  2482. length = sfm(port,pCurrSCCB);
  2483. if (length) 
  2484. {
  2486. ACCEPT_MSG(port);
  2487. message = sfm(port,pCurrSCCB);
  2488. if (message) 
  2489. {
  2491. if (message == SMSYNC) 
  2492. {
  2494. if (length == 0x03)
  2495. {
  2497. ACCEPT_MSG(port);
  2498. stsyncn(port,p_card);
  2499. }
  2500. else 
  2501. {
  2503. pCurrSCCB->Sccb_scsimsg = SMREJECT;
  2504. ACCEPT_MSG_ATN(port);
  2505. }
  2506. }
  2507. #if defined(WIDE_SCSI)
  2508. else if (message == SMWDTR) 
  2509. {
  2511. if (length == 0x02)
  2512. {
  2514. ACCEPT_MSG(port);
  2515. stwidn(port,p_card);
  2516. }
  2517. else 
  2518. {
  2520. pCurrSCCB->Sccb_scsimsg = SMREJECT;
  2521. ACCEPT_MSG_ATN(port);
  2523. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2524. }
  2525. }
  2526. #endif
  2527. else 
  2528. {
  2530. pCurrSCCB->Sccb_scsimsg = SMREJECT;
  2531. ACCEPT_MSG_ATN(port);
  2533. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2534. }
  2535. }
  2536. else
  2537. {
  2538. if(pCurrSCCB->Sccb_scsimsg != SMPARITY)
  2539. ACCEPT_MSG(port);
  2540. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2541. }
  2542. }else
  2543. {
  2544. if(pCurrSCCB->Sccb_scsimsg == SMPARITY)
  2545. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2546. }
  2547. }
  2550. /*---------------------------------------------------------------------
  2551.  *
  2552.  * Function: sisyncn
  2553.  *
  2554.  * Description: Read in a message byte from the SCSI bus, and check
  2555.  *              for a parity error.
  2556.  *
  2557.  *---------------------------------------------------------------------*/
  2559. #if defined(DOS)
  2560. UCHAR sisyncn(USHORT port, UCHAR p_card, UCHAR syncFlag)
  2561. #else
  2562. UCHAR sisyncn(ULONG port, UCHAR p_card, UCHAR syncFlag)
  2563. #endif
  2564. {
  2565.    PSCCB currSCCB;
  2566.    PSCCBMgr_tar_info currTar_Info;
  2568.    currSCCB = BL_Card[p_card].currentSCCB;
  2569.    currTar_Info = &sccbMgrTbl[p_card][currSCCB->TargID];
  2571.    if (!((currTar_Info->TarStatus & TAR_SYNC_MASK) == SYNC_TRYING)) {
  2574.       WRW_HARPOON((port+ID_MSG_STRT),
  2575.                  (MPM_OP+AMSG_OUT+(currSCCB->Sccb_idmsg & ~(UCHAR)DISC_PRIV)));
  2577.       WRW_HARPOON((port+ID_MSG_STRT+2),BRH_OP+ALWAYS+CMDPZ);
  2579.       WRW_HARPOON((port+SYNC_MSGS+0), (MPM_OP+AMSG_OUT+SMEXT ));
  2580.       WRW_HARPOON((port+SYNC_MSGS+2), (MPM_OP+AMSG_OUT+0x03  ));
  2581.       WRW_HARPOON((port+SYNC_MSGS+4), (MPM_OP+AMSG_OUT+SMSYNC));
  2584.       if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_20MB)
  2586.  WRW_HARPOON((port+SYNC_MSGS+6), (MPM_OP+AMSG_OUT+ 12));
  2588.       else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_10MB)
  2590.  WRW_HARPOON((port+SYNC_MSGS+6), (MPM_OP+AMSG_OUT+ 25));
  2592.       else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_5MB)
  2594.  WRW_HARPOON((port+SYNC_MSGS+6), (MPM_OP+AMSG_OUT+ 50));
  2596.       else
  2597.  WRW_HARPOON((port+SYNC_MSGS+6), (MPM_OP+AMSG_OUT+ 00));
  2600.       WRW_HARPOON((port+SYNC_MSGS+8), (RAT_OP                ));
  2601.       WRW_HARPOON((port+SYNC_MSGS+10),(MPM_OP+AMSG_OUT+DEFAULT_OFFSET));
  2602.       WRW_HARPOON((port+SYNC_MSGS+12),(BRH_OP+ALWAYS+NP      ));
  2605. if(syncFlag == FALSE)
  2606. {
  2607.    WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  2608.       currTar_Info->TarStatus = ((currTar_Info->TarStatus &
  2609.           ~(UCHAR)TAR_SYNC_MASK) | (UCHAR)SYNC_TRYING);
  2610. }
  2611. else
  2612. {
  2613.    WR_HARPOON(port+hp_autostart_3, (AUTO_IMMED + CMD_ONLY_STRT));
  2614. }
  2617.       return(TRUE);
  2618.       }
  2620.    else {
  2622.       currTar_Info->TarStatus |=  (UCHAR)SYNC_SUPPORTED;
  2623.       currTar_Info->TarEEValue &= ~EE_SYNC_MASK;
  2624.       return(FALSE);
  2625.       }
  2626. }
  2630. /*---------------------------------------------------------------------
  2631.  *
  2632.  * Function: stsyncn
  2633.  *
  2634.  * Description: The has sent us a Sync Nego message so handle it as
  2635.  *              necessary.
  2636.  *
  2637.  *---------------------------------------------------------------------*/
  2638. #if defined(DOS)
  2639. void stsyncn(USHORT port, UCHAR p_card)
  2640. #else
  2641. void stsyncn(ULONG port, UCHAR p_card)
  2642. #endif
  2643. {
  2644.    UCHAR sync_msg,offset,sync_reg,our_sync_msg;
  2645.    PSCCB currSCCB;
  2646.    PSCCBMgr_tar_info currTar_Info;
  2648.    currSCCB = BL_Card[p_card].currentSCCB;
  2649.    currTar_Info = &sccbMgrTbl[p_card][currSCCB->TargID];
  2651.    sync_msg = sfm(port,currSCCB);
  2653. if((sync_msg == 0x00) && (currSCCB->Sccb_scsimsg == SMPARITY))
  2654. {
  2655. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2656. return;
  2657. }
  2659.    ACCEPT_MSG(port);
  2662.    offset = sfm(port,currSCCB);
  2664. if((offset == 0x00) && (currSCCB->Sccb_scsimsg == SMPARITY))
  2665. {
  2666. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2667. return;
  2668. }
  2670.    if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_20MB)
  2672.       our_sync_msg = 12;              /* Setup our Message to 20mb/s */
  2674.    else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_10MB)
  2676.       our_sync_msg = 25;              /* Setup our Message to 10mb/s */
  2678.    else if ((currTar_Info->TarEEValue & EE_SYNC_MASK) == EE_SYNC_5MB)
  2680.       our_sync_msg = 50;              /* Setup our Message to 5mb/s */
  2681.    else
  2683.       our_sync_msg = 0;               /* Message = Async */
  2685.    if (sync_msg < our_sync_msg) {
  2686.       sync_msg = our_sync_msg;    /*if faster, then set to max. */
  2687.       }
  2689.    if (offset == ASYNC)
  2690.       sync_msg = ASYNC;
  2692.    if (offset > MAX_OFFSET)
  2693.       offset = MAX_OFFSET;
  2695.    sync_reg = 0x00;
  2697.    if (sync_msg > 12)
  2699.       sync_reg = 0x20;        /* Use 10MB/s */
  2701.    if (sync_msg > 25)
  2703.       sync_reg = 0x40;        /* Use 6.6MB/s */
  2705.    if (sync_msg > 38)
  2707.       sync_reg = 0x60;        /* Use 5MB/s */
  2709.    if (sync_msg > 50)
  2711.       sync_reg = 0x80;        /* Use 4MB/s */
  2713.    if (sync_msg > 62)
  2715.       sync_reg = 0xA0;        /* Use 3.33MB/s */
  2717.    if (sync_msg > 75)
  2719.       sync_reg = 0xC0;        /* Use 2.85MB/s */
  2721.    if (sync_msg > 87)
  2723.       sync_reg = 0xE0;        /* Use 2.5MB/s */
  2725.    if (sync_msg > 100) {
  2727.       sync_reg = 0x00;        /* Use ASYNC */
  2728.       offset = 0x00;
  2729.       }
  2732. #if defined(WIDE_SCSI)
  2733.    if (currTar_Info->TarStatus & WIDE_ENABLED)
  2735.       sync_reg |= offset;
  2737.    else
  2739.       sync_reg |= (offset | NARROW_SCSI);
  2741. #else
  2742.    sync_reg |= (offset | NARROW_SCSI);
  2743. #endif
  2745.    sssyncv(port,currSCCB->TargID,sync_reg,currTar_Info);
  2748.    if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
  2751.       ACCEPT_MSG(port);
  2753.       currTar_Info->TarStatus = ((currTar_Info->TarStatus &
  2754.          ~(UCHAR)TAR_SYNC_MASK) | (UCHAR)SYNC_SUPPORTED);
  2756.       WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2757.       }
  2759.    else {
  2762.       ACCEPT_MSG_ATN(port);
  2764.       sisyncr(port,sync_msg,offset);
  2766.       currTar_Info->TarStatus = ((currTar_Info->TarStatus &
  2767.          ~(UCHAR)TAR_SYNC_MASK) | (UCHAR)SYNC_SUPPORTED);
  2768.       }
  2769. }
  2772. /*---------------------------------------------------------------------
  2773.  *
  2774.  * Function: sisyncr
  2775.  *
  2776.  * Description: Answer the targets sync message.
  2777.  *
  2778.  *---------------------------------------------------------------------*/
  2779. #if defined(DOS)
  2780. void sisyncr(USHORT port,UCHAR sync_pulse, UCHAR offset)
  2781. #else
  2782. void sisyncr(ULONG port,UCHAR sync_pulse, UCHAR offset)
  2783. #endif
  2784. {
  2785.    ARAM_ACCESS(port);
  2786.    WRW_HARPOON((port+SYNC_MSGS+0), (MPM_OP+AMSG_OUT+SMEXT ));
  2787.    WRW_HARPOON((port+SYNC_MSGS+2), (MPM_OP+AMSG_OUT+0x03  ));
  2788.    WRW_HARPOON((port+SYNC_MSGS+4), (MPM_OP+AMSG_OUT+SMSYNC));
  2789.    WRW_HARPOON((port+SYNC_MSGS+6), (MPM_OP+AMSG_OUT+sync_pulse));
  2790.    WRW_HARPOON((port+SYNC_MSGS+8), (RAT_OP                ));
  2791.    WRW_HARPOON((port+SYNC_MSGS+10),(MPM_OP+AMSG_OUT+offset));
  2792.    WRW_HARPOON((port+SYNC_MSGS+12),(BRH_OP+ALWAYS+NP      ));
  2793.    SGRAM_ACCESS(port);
  2795.    WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  2796.    WRW_HARPOON((port+hp_intstat), CLR_ALL_INT_1);
  2798.    WR_HARPOON(port+hp_autostart_3, (AUTO_IMMED+CMD_ONLY_STRT));
  2800.    while (!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | AUTO_INT))) {}
  2801. }
  2805. #if defined(WIDE_SCSI)
  2807. /*---------------------------------------------------------------------
  2808.  *
  2809.  * Function: siwidn
  2810.  *
  2811.  * Description: Read in a message byte from the SCSI bus, and check
  2812.  *              for a parity error.
  2813.  *
  2814.  *---------------------------------------------------------------------*/
  2816. #if defined(DOS)
  2817. UCHAR siwidn(USHORT port, UCHAR p_card)
  2818. #else
  2819. UCHAR siwidn(ULONG port, UCHAR p_card)
  2820. #endif
  2821. {
  2822.    PSCCB currSCCB;
  2823.    PSCCBMgr_tar_info currTar_Info;
  2825.    currSCCB = BL_Card[p_card].currentSCCB;
  2826.    currTar_Info = &sccbMgrTbl[p_card][currSCCB->TargID];
  2828.    if (!((currTar_Info->TarStatus & TAR_WIDE_MASK) == WIDE_NEGOCIATED)) {
  2831.       WRW_HARPOON((port+ID_MSG_STRT),
  2832.               (MPM_OP+AMSG_OUT+(currSCCB->Sccb_idmsg & ~(UCHAR)DISC_PRIV)));
  2834.       WRW_HARPOON((port+ID_MSG_STRT+2),BRH_OP+ALWAYS+CMDPZ);
  2836.       WRW_HARPOON((port+SYNC_MSGS+0), (MPM_OP+AMSG_OUT+SMEXT ));
  2837.       WRW_HARPOON((port+SYNC_MSGS+2), (MPM_OP+AMSG_OUT+0x02  ));
  2838.       WRW_HARPOON((port+SYNC_MSGS+4), (MPM_OP+AMSG_OUT+SMWDTR));
  2839.       WRW_HARPOON((port+SYNC_MSGS+6), (RAT_OP                ));
  2840.       WRW_HARPOON((port+SYNC_MSGS+8), (MPM_OP+AMSG_OUT+ SM16BIT));
  2841.       WRW_HARPOON((port+SYNC_MSGS+10),(BRH_OP+ALWAYS+NP      ));
  2843.       WR_HARPOON(port+hp_autostart_3, (SELECT+SELCHK_STRT));
  2846.       currTar_Info->TarStatus = ((currTar_Info->TarStatus &
  2847.          ~(UCHAR)TAR_WIDE_MASK) | (UCHAR)WIDE_ENABLED);
  2849.       return(TRUE);
  2850.       }
  2852.    else {
  2854.       currTar_Info->TarStatus = ((currTar_Info->TarStatus &
  2855.                ~(UCHAR)TAR_WIDE_MASK) | WIDE_NEGOCIATED);
  2857.       currTar_Info->TarEEValue &= ~EE_WIDE_SCSI;
  2858.       return(FALSE);
  2859.       }
  2860. }
  2864. /*---------------------------------------------------------------------
  2865.  *
  2866.  * Function: stwidn
  2867.  *
  2868.  * Description: The has sent us a Wide Nego message so handle it as
  2869.  *              necessary.
  2870.  *
  2871.  *---------------------------------------------------------------------*/
  2872. #if defined(DOS)
  2873. void stwidn(USHORT port, UCHAR p_card)
  2874. #else
  2875. void stwidn(ULONG port, UCHAR p_card)
  2876. #endif
  2877. {
  2878.    UCHAR width;
  2879.    PSCCB currSCCB;
  2880.    PSCCBMgr_tar_info currTar_Info;
  2882.    currSCCB = BL_Card[p_card].currentSCCB;
  2883.    currTar_Info = &sccbMgrTbl[p_card][currSCCB->TargID];
  2885.    width = sfm(port,currSCCB);
  2887. if((width == 0x00) && (currSCCB->Sccb_scsimsg == SMPARITY))
  2888. {
  2889. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2890. return;
  2891. }
  2894.    if (!(currTar_Info->TarEEValue & EE_WIDE_SCSI))
  2895.       width = 0;
  2897.    if (width) {
  2898.       currTar_Info->TarStatus |= WIDE_ENABLED;
  2899.       width = 0;
  2900.       }
  2901.    else {
  2902.       width = NARROW_SCSI;
  2903.       currTar_Info->TarStatus &= ~WIDE_ENABLED;
  2904.       }
  2907.    sssyncv(port,currSCCB->TargID,width,currTar_Info);
  2910.    if (currSCCB->Sccb_scsistat == SELECT_WN_ST)
  2911. {
  2915.       currTar_Info->TarStatus |=  WIDE_NEGOCIATED;
  2917.    if (!((currTar_Info->TarStatus & TAR_SYNC_MASK) == SYNC_SUPPORTED))
  2918. {
  2919.       ACCEPT_MSG_ATN(port);
  2920.    ARAM_ACCESS(port);
  2921.       sisyncn(port,p_card, TRUE);
  2922.       currSCCB->Sccb_scsistat = SELECT_SN_ST;
  2923.    SGRAM_ACCESS(port);
  2924. }
  2925. else
  2926. {
  2927.       ACCEPT_MSG(port);
  2928.       WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  2929. }
  2930.    }
  2932.    else {
  2935.       ACCEPT_MSG_ATN(port);
  2937.       if (currTar_Info->TarEEValue & EE_WIDE_SCSI)
  2938.         width = SM16BIT;
  2939.       else
  2940.         width = SM8BIT;
  2942.       siwidr(port,width);
  2944.       currTar_Info->TarStatus |= (WIDE_NEGOCIATED | WIDE_ENABLED);
  2945.       }
  2946. }
  2949. /*---------------------------------------------------------------------
  2950.  *
  2951.  * Function: siwidr
  2952.  *
  2953.  * Description: Answer the targets Wide nego message.
  2954.  *
  2955.  *---------------------------------------------------------------------*/
  2956. #if defined(DOS)
  2957. void siwidr(USHORT port, UCHAR width)
  2958. #else
  2959. void siwidr(ULONG port, UCHAR width)
  2960. #endif
  2961. {
  2962.    ARAM_ACCESS(port);
  2963.    WRW_HARPOON((port+SYNC_MSGS+0), (MPM_OP+AMSG_OUT+SMEXT ));
  2964.    WRW_HARPOON((port+SYNC_MSGS+2), (MPM_OP+AMSG_OUT+0x02  ));
  2965.    WRW_HARPOON((port+SYNC_MSGS+4), (MPM_OP+AMSG_OUT+SMWDTR));
  2966.    WRW_HARPOON((port+SYNC_MSGS+6), (RAT_OP                ));
  2967.    WRW_HARPOON((port+SYNC_MSGS+8),(MPM_OP+AMSG_OUT+width));
  2968.    WRW_HARPOON((port+SYNC_MSGS+10),(BRH_OP+ALWAYS+NP      ));
  2969.    SGRAM_ACCESS(port);
  2971.    WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  2972.    WRW_HARPOON((port+hp_intstat), CLR_ALL_INT_1);
  2974.    WR_HARPOON(port+hp_autostart_3, (AUTO_IMMED+CMD_ONLY_STRT));
  2976.    while (!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | AUTO_INT))) {}
  2977. }
  2979. #endif
  2983. /*---------------------------------------------------------------------
  2984.  *
  2985.  * Function: sssyncv
  2986.  *
  2987.  * Description: Write the desired value to the Sync Register for the
  2988.  *              ID specified.
  2989.  *
  2990.  *---------------------------------------------------------------------*/
  2991. #if defined(DOS)
  2992. void sssyncv(USHORT p_port, UCHAR p_id, UCHAR p_sync_value,PSCCBMgr_tar_info currTar_Info)
  2993. #else
  2994. void sssyncv(ULONG p_port, UCHAR p_id, UCHAR p_sync_value,PSCCBMgr_tar_info currTar_Info)
  2995. #endif
  2996. {
  2997.    UCHAR index;
  2999.    index = p_id;
  3001.    switch (index) {
  3003.       case 0:
  3004.  index = 12;             /* hp_synctarg_0 */
  3005.  break;
  3006.       case 1:
  3007.  index = 13;             /* hp_synctarg_1 */
  3008.  break;
  3009.       case 2:
  3010.  index = 14;             /* hp_synctarg_2 */
  3011.  break;
  3012.       case 3:
  3013.  index = 15;             /* hp_synctarg_3 */
  3014.  break;
  3015.       case 4:
  3016.  index = 8;              /* hp_synctarg_4 */
  3017.  break;
  3018.       case 5:
  3019.  index = 9;              /* hp_synctarg_5 */
  3020.  break;
  3021.       case 6:
  3022.  index = 10;             /* hp_synctarg_6 */
  3023.  break;
  3024.       case 7:
  3025.  index = 11;             /* hp_synctarg_7 */
  3026.  break;
  3027.       case 8:
  3028.  index = 4;              /* hp_synctarg_8 */
  3029.  break;
  3030.       case 9:
  3031.  index = 5;              /* hp_synctarg_9 */
  3032.  break;
  3033.       case 10:
  3034.  index = 6;              /* hp_synctarg_10 */
  3035.  break;
  3036.       case 11:
  3037.  index = 7;              /* hp_synctarg_11 */
  3038.  break;
  3039.       case 12:
  3040.  index = 0;              /* hp_synctarg_12 */
  3041.  break;
  3042.       case 13:
  3043.  index = 1;              /* hp_synctarg_13 */
  3044.  break;
  3045.       case 14:
  3046.  index = 2;              /* hp_synctarg_14 */
  3047.  break;
  3048.       case 15:
  3049.  index = 3;              /* hp_synctarg_15 */
  3051.       }
  3053.    WR_HARPOON(p_port+hp_synctarg_base+index, p_sync_value);
  3055. currTar_Info->TarSyncCtrl = p_sync_value;
  3056. }
  3059. /*---------------------------------------------------------------------
  3060.  *
  3061.  * Function: sresb
  3062.  *
  3063.  * Description: Reset the desired card's SCSI bus.
  3064.  *
  3065.  *---------------------------------------------------------------------*/
  3066. #if defined(DOS)
  3067. void sresb(USHORT port, UCHAR p_card)
  3068. #else
  3069. void sresb(ULONG port, UCHAR p_card)
  3070. #endif
  3071. {
  3072.    UCHAR scsiID, i;
  3074.    PSCCBMgr_tar_info currTar_Info;
  3076.    WR_HARPOON(port+hp_page_ctrl,
  3077.       (RD_HARPOON(port+hp_page_ctrl) | G_INT_DISABLE));
  3078.    WRW_HARPOON((port+hp_intstat), CLR_ALL_INT);
  3080.    WR_HARPOON(port+hp_scsictrl_0, SCSI_RST);
  3082.    scsiID = RD_HARPOON(port+hp_seltimeout);
  3083.    WR_HARPOON(port+hp_seltimeout,TO_5ms);
  3084.    WRW_HARPOON((port+hp_intstat), TIMEOUT);
  3086.    WR_HARPOON(port+hp_portctrl_0,(SCSI_PORT | START_TO));
  3088.    while (!(RDW_HARPOON((port+hp_intstat)) & TIMEOUT)) {}
  3090.    WR_HARPOON(port+hp_seltimeout,scsiID);
  3092.    WR_HARPOON(port+hp_scsictrl_0, ENA_SCAM_SEL);
  3094.    Wait(port, TO_5ms);
  3096.    WRW_HARPOON((port+hp_intstat), CLR_ALL_INT);
  3098.    WR_HARPOON(port+hp_int_mask, (RD_HARPOON(port+hp_int_mask) | 0x00));
  3100.    for (scsiID = 0; scsiID < MAX_SCSI_TAR; scsiID++)
  3101.       {
  3102.       currTar_Info = &sccbMgrTbl[p_card][scsiID];
  3104.       if (currTar_Info->TarEEValue & EE_SYNC_MASK)
  3105.          {
  3106.        currTar_Info->TarSyncCtrl = 0;
  3107.        currTar_Info->TarStatus &= ~TAR_SYNC_MASK;
  3108.       }
  3110.       if (currTar_Info->TarEEValue & EE_WIDE_SCSI)
  3111.          {
  3112.        currTar_Info->TarStatus &= ~TAR_WIDE_MASK;
  3113.        }
  3115.       sssyncv(port, scsiID, NARROW_SCSI,currTar_Info);
  3117.       SccbMgrTableInitTarget(p_card, scsiID);
  3118.       }
  3120.    BL_Card[p_card].scanIndex = 0x00;
  3121.    BL_Card[p_card].currentSCCB = NULL;
  3122.    BL_Card[p_card].globalFlags &= ~(F_TAG_STARTED | F_HOST_XFER_ACT 
  3123. | F_NEW_SCCB_CMD);
  3124.    BL_Card[p_card].cmdCounter  = 0x00;
  3125. BL_Card[p_card].discQCount = 0x00;
  3126.    BL_Card[p_card].tagQ_Lst = 0x01; 
  3128. for(i = 0; i < QUEUE_DEPTH; i++)
  3129. BL_Card[p_card].discQ_Tbl[i] = NULL;
  3131.    WR_HARPOON(port+hp_page_ctrl,
  3132.       (RD_HARPOON(port+hp_page_ctrl) & ~G_INT_DISABLE));
  3134. }
  3136. /*---------------------------------------------------------------------
  3137.  *
  3138.  * Function: ssenss
  3139.  *
  3140.  * Description: Setup for the Auto Sense command.
  3141.  *
  3142.  *---------------------------------------------------------------------*/
  3143. void ssenss(PSCCBcard pCurrCard)
  3144. {
  3145.    UCHAR i;
  3146.    PSCCB currSCCB;
  3148.    currSCCB = pCurrCard->currentSCCB;
  3151.    currSCCB->Save_CdbLen = currSCCB->CdbLength;
  3153.    for (i = 0; i < 6; i++) {
  3155.       currSCCB->Save_Cdb[i] = currSCCB->Cdb[i];
  3156.       }
  3158.    currSCCB->CdbLength = SIX_BYTE_CMD;
  3159.    currSCCB->Cdb[0]    = SCSI_REQUEST_SENSE;
  3160.    currSCCB->Cdb[1]    = currSCCB->Cdb[1] & (UCHAR)0xE0; /*Keep LUN. */
  3161.    currSCCB->Cdb[2]    = 0x00;
  3162.    currSCCB->Cdb[3]    = 0x00;
  3163.    currSCCB->Cdb[4]    = currSCCB->RequestSenseLength;
  3164.    currSCCB->Cdb[5]    = 0x00;
  3166.    currSCCB->Sccb_XferCnt = (unsigned long)currSCCB->RequestSenseLength;
  3168.    currSCCB->Sccb_ATC = 0x00;
  3170.    currSCCB->Sccb_XferState |= F_AUTO_SENSE;
  3172.    currSCCB->Sccb_XferState &= ~F_SG_XFER;
  3174.    currSCCB->Sccb_idmsg = currSCCB->Sccb_idmsg & ~(UCHAR)DISC_PRIV;
  3176.    currSCCB->ControlByte = 0x00;
  3178.    currSCCB->Sccb_MGRFlags &= F_STATUSLOADED;
  3179. }
  3183. /*---------------------------------------------------------------------
  3184.  *
  3185.  * Function: sxfrp
  3186.  *
  3187.  * Description: Transfer data into the bit bucket until the device
  3188.  *              decides to switch phase.
  3189.  *
  3190.  *---------------------------------------------------------------------*/
  3192. #if defined(DOS)
  3193. void sxfrp(USHORT p_port, UCHAR p_card)
  3194. #else
  3195. void sxfrp(ULONG p_port, UCHAR p_card)
  3196. #endif
  3197. {
  3198.    UCHAR curr_phz;
  3201.    DISABLE_AUTO(p_port);
  3203.    if (BL_Card[p_card].globalFlags & F_HOST_XFER_ACT) {
  3205.       hostDataXferAbort(p_port,p_card,BL_Card[p_card].currentSCCB);
  3207.       }
  3209.    /* If the Automation handled the end of the transfer then do not
  3210.       match the phase or we will get out of sync with the ISR.       */
  3212.    if (RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | XFER_CNT_0 | AUTO_INT))
  3213.       return;
  3215.    WR_HARPOON(p_port+hp_xfercnt_0, 0x00);
  3217.    curr_phz = RD_HARPOON(p_port+hp_scsisig) & (UCHAR)S_SCSI_PHZ;
  3219.    WRW_HARPOON((p_port+hp_intstat), XFER_CNT_0);
  3222.    WR_HARPOON(p_port+hp_scsisig, curr_phz);
  3224.    while ( !(RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | RESET)) &&
  3225.       (curr_phz == (RD_HARPOON(p_port+hp_scsisig) & (UCHAR)S_SCSI_PHZ)) )
  3226.       {
  3227.       if (curr_phz & (UCHAR)SCSI_IOBIT)
  3228.          {
  3229.        WR_HARPOON(p_port+hp_portctrl_0, (SCSI_PORT | HOST_PORT | SCSI_INBIT));
  3231.       if (!(RD_HARPOON(p_port+hp_xferstat) & FIFO_EMPTY))
  3232.             {
  3233.          RD_HARPOON(p_port+hp_fifodata_0);
  3234.          }
  3235.       }
  3236.       else
  3237.          {
  3238.        WR_HARPOON(p_port+hp_portctrl_0, (SCSI_PORT | HOST_PORT | HOST_WRT));
  3239.        if (RD_HARPOON(p_port+hp_xferstat) & FIFO_EMPTY)
  3240.             {
  3241.          WR_HARPOON(p_port+hp_fifodata_0,0xFA);
  3242.          }
  3243.       }
  3244.       } /* End of While loop for padding data I/O phase */
  3246.       while ( !(RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | RESET)))
  3247.          {
  3248.          if (RD_HARPOON(p_port+hp_scsisig) & SCSI_REQ)
  3249.           break;
  3250.          }
  3252.       WR_HARPOON(p_port+hp_portctrl_0, (SCSI_PORT | HOST_PORT | SCSI_INBIT));
  3253.       while (!(RD_HARPOON(p_port+hp_xferstat) & FIFO_EMPTY))
  3254.          {
  3255.          RD_HARPOON(p_port+hp_fifodata_0);
  3256.          }
  3258.       if ( !(RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | RESET)))
  3259.          {
  3260.          WR_HARPOON(p_port+hp_autostart_0, (AUTO_IMMED+DISCONNECT_START));
  3261.          while (!(RDW_HARPOON((p_port+hp_intstat)) & AUTO_INT)) {}
  3263.          if (RDW_HARPOON((p_port+hp_intstat)) & (ICMD_COMP | ITAR_DISC))
  3264.        while (!(RDW_HARPOON((p_port+hp_intstat)) & (BUS_FREE | RSEL))) ;
  3265.          }
  3266. }
  3269. /*---------------------------------------------------------------------
  3270.  *
  3271.  * Function: schkdd
  3272.  *
  3273.  * Description: Make sure data has been flushed from both FIFOs and abort
  3274.  *              the operations if necessary.
  3275.  *
  3276.  *---------------------------------------------------------------------*/
  3278. #if defined(DOS)
  3279. void schkdd(USHORT port, UCHAR p_card)
  3280. #else
  3281. void schkdd(ULONG port, UCHAR p_card)
  3282. #endif
  3283. {
  3284.    USHORT TimeOutLoop;
  3285. UCHAR sPhase;
  3287.    PSCCB currSCCB;
  3289.    currSCCB = BL_Card[p_card].currentSCCB;
  3292.    if ((currSCCB->Sccb_scsistat != DATA_OUT_ST) &&
  3293.        (currSCCB->Sccb_scsistat != DATA_IN_ST)) {
  3294.       return;
  3295.       }
  3299.    if (currSCCB->Sccb_XferState & F_ODD_BALL_CNT)
  3300.       {
  3302.       currSCCB->Sccb_ATC += (currSCCB->Sccb_XferCnt-1);
  3304.       currSCCB->Sccb_XferCnt = 1;
  3306.       currSCCB->Sccb_XferState &= ~F_ODD_BALL_CNT;
  3307.       WRW_HARPOON((port+hp_fiforead), (USHORT) 0x00);
  3308.       WR_HARPOON(port+hp_xferstat, 0x00);
  3309.       }
  3311.    else
  3312.       {
  3314.       currSCCB->Sccb_ATC += currSCCB->Sccb_XferCnt;
  3316.       currSCCB->Sccb_XferCnt = 0;
  3317.       }
  3319.    if ((RDW_HARPOON((port+hp_intstat)) & PARITY) &&
  3320.       (currSCCB->HostStatus == SCCB_COMPLETE)) {
  3322.       currSCCB->HostStatus = SCCB_PARITY_ERR;
  3323.       WRW_HARPOON((port+hp_intstat), PARITY);
  3324.       }
  3327.    hostDataXferAbort(port,p_card,currSCCB);
  3330.    while (RD_HARPOON(port+hp_scsisig) & SCSI_ACK) {}
  3332.    TimeOutLoop = 0;
  3334.    while(RD_HARPOON(port+hp_xferstat) & FIFO_EMPTY)
  3335.       {
  3336.       if (RDW_HARPOON((port+hp_intstat)) & BUS_FREE) {
  3337.       return;
  3338.        }
  3339.       if (RD_HARPOON(port+hp_offsetctr) & (UCHAR)0x1F) {
  3340.       break;
  3341.        }
  3342.       if (RDW_HARPOON((port+hp_intstat)) & RESET) {
  3343.       return;
  3344.        }
  3345.       if ((RD_HARPOON(port+hp_scsisig) & SCSI_REQ) || (TimeOutLoop++>0x3000) )
  3346.        break;
  3347.       }
  3349. sPhase = RD_HARPOON(port+hp_scsisig) & (SCSI_BSY | S_SCSI_PHZ);
  3350.    if ((!(RD_HARPOON(port+hp_xferstat) & FIFO_EMPTY))                     ||
  3351.       (RD_HARPOON(port+hp_offsetctr) & (UCHAR)0x1F)                       ||
  3352.       (sPhase == (SCSI_BSY | S_DATAO_PH)) ||
  3353.       (sPhase == (SCSI_BSY | S_DATAI_PH)))
  3354.       {
  3356.    WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  3358.    if (!(currSCCB->Sccb_XferState & F_ALL_XFERRED))
  3359.          {
  3360.       if (currSCCB->Sccb_XferState & F_HOST_XFER_DIR) {
  3361.          phaseDataIn(port,p_card);
  3362.        }
  3364.     else {
  3365.        phaseDataOut(port,p_card);
  3366.         }
  3367.     }
  3368. else
  3369.        {
  3370.     sxfrp(port,p_card);
  3371.     if (!(RDW_HARPOON((port+hp_intstat)) &
  3372.       (BUS_FREE | ICMD_COMP | ITAR_DISC | RESET)))
  3373.          {
  3374.     WRW_HARPOON((port+hp_intstat), AUTO_INT);
  3375.    phaseDecode(port,p_card);
  3376.    }
  3377.    }
  3379.    }
  3381.    else {
  3382.       WR_HARPOON(port+hp_portctrl_0, 0x00);
  3383.       }
  3384. }
  3387. /*---------------------------------------------------------------------
  3388.  *
  3389.  * Function: sinits
  3390.  *
  3391.  * Description: Setup SCCB manager fields in this SCCB.
  3392.  *
  3393.  *---------------------------------------------------------------------*/
  3395. void sinits(PSCCB p_sccb, UCHAR p_card)
  3396. {
  3397.    PSCCBMgr_tar_info currTar_Info;
  3399. if((p_sccb->TargID > MAX_SCSI_TAR) || (p_sccb->Lun > MAX_LUN))
  3400. {
  3401. return;
  3402. }
  3403.    currTar_Info = &sccbMgrTbl[p_card][p_sccb->TargID];
  3405.    p_sccb->Sccb_XferState     = 0x00;
  3406.    p_sccb->Sccb_XferCnt       = p_sccb->DataLength;
  3408.    if ((p_sccb->OperationCode == SCATTER_GATHER_COMMAND) ||
  3409.       (p_sccb->OperationCode == RESIDUAL_SG_COMMAND)) {
  3411.       p_sccb->Sccb_SGoffset   = 0;
  3412.       p_sccb->Sccb_XferState  = F_SG_XFER;
  3413.       p_sccb->Sccb_XferCnt    = 0x00;
  3414.       }
  3416.    if (p_sccb->DataLength == 0x00)
  3418.       p_sccb->Sccb_XferState |= F_ALL_XFERRED;
  3420.    if (p_sccb->ControlByte & F_USE_CMD_Q)
  3421.       {
  3422.       if ((currTar_Info->TarStatus & TAR_TAG_Q_MASK) == TAG_Q_REJECT)
  3423.          p_sccb->ControlByte &= ~F_USE_CMD_Q;
  3425.       else
  3426.       currTar_Info->TarStatus |= TAG_Q_TRYING;
  3427.       }
  3429. /*      For !single SCSI device in system  & device allow Disconnect
  3430. or command is tag_q type then send Cmd with Disconnect Enable
  3431. else send Cmd with Disconnect Disable */
  3433. /*
  3434.    if (((!(BL_Card[p_card].globalFlags & F_SINGLE_DEVICE)) &&
  3435.       (currTar_Info->TarStatus & TAR_ALLOW_DISC)) ||
  3436.       (currTar_Info->TarStatus & TAG_Q_TRYING)) {
  3437. */
  3438.    if ((currTar_Info->TarStatus & TAR_ALLOW_DISC) ||
  3439.       (currTar_Info->TarStatus & TAG_Q_TRYING)) {
  3440.       p_sccb->Sccb_idmsg      = (UCHAR)(SMIDENT | DISC_PRIV) | p_sccb->Lun;
  3441.       }
  3443.    else {
  3445.       p_sccb->Sccb_idmsg      = (UCHAR)SMIDENT | p_sccb->Lun;
  3446.       }
  3448.    p_sccb->HostStatus         = 0x00;
  3449.    p_sccb->TargetStatus       = 0x00;
  3450.    p_sccb->Sccb_tag           = 0x00;
  3451.    p_sccb->Sccb_MGRFlags      = 0x00;
  3452.    p_sccb->Sccb_sgseg         = 0x00;
  3453.    p_sccb->Sccb_ATC           = 0x00;
  3454.    p_sccb->Sccb_savedATC      = 0x00;
  3455. /*
  3456.    p_sccb->SccbVirtDataPtr    = 0x00;
  3457.    p_sccb->Sccb_forwardlink   = NULL;
  3458.    p_sccb->Sccb_backlink      = NULL;
  3459.  */
  3460.    p_sccb->Sccb_scsistat      = BUS_FREE_ST;
  3461.    p_sccb->SccbStatus         = SCCB_IN_PROCESS;
  3462.    p_sccb->Sccb_scsimsg       = SMNO_OP;
  3464. }
  3467. #ident "$Id: phase.c 1.11 1997/01/31 02:08:49 mohan Exp $"
  3468. /*----------------------------------------------------------------------
  3469.  *
  3470.  *
  3471.  *   Copyright 1995-1996 by Mylex Corporation.  All Rights Reserved
  3472.  *
  3473.  *   This file is available under both the GNU General Public License
  3474.  *   and a BSD-style copyright; see LICENSE.FlashPoint for details.
  3475.  *
  3476.  *   $Workfile:   phase.c  $
  3477.  *
  3478.  *   Description:  Functions to intially handle the SCSI bus phase when
  3479.  *                 the target asserts request (and the automation is not
  3480.  *                 enabled to handle the situation).
  3481.  *
  3482.  *   $Date: 1997/01/31 02:08:49 $
  3483.  *
  3484.  *   $Revision: 1.11 $
  3485.  *
  3486.  *----------------------------------------------------------------------*/
  3488. /*#include <globals.h>*/
  3490. #if (FW_TYPE==_UCB_MGR_)
  3491. /*#include <budi.h>*/
  3492. #endif
  3494. /*#include <sccbmgr.h>*/
  3495. /*#include <blx30.h>*/
  3496. /*#include <target.h>*/
  3497. /*#include <scsi2.h>*/
  3498. /*#include <harpoon.h>*/
  3501. /*
  3502. extern SCCBCARD BL_Card[MAX_CARDS];
  3503. extern SCCBMGR_TAR_INFO sccbMgrTbl[MAX_CARDS][MAX_SCSI_TAR];
  3505. #if defined(OS2)
  3506.    extern void (far *s_PhaseTbl[8]) (ULONG, UCHAR);
  3507. #else
  3508.    #if defined(DOS)
  3509.       extern void (*s_PhaseTbl[8]) (USHORT, UCHAR);
  3510.    #else
  3511.       extern void (*s_PhaseTbl[8]) (ULONG, UCHAR);
  3512.    #endif
  3513. #endif
  3514. */
  3516. /*---------------------------------------------------------------------
  3517.  *
  3518.  * Function: Phase Decode
  3519.  *
  3520.  * Description: Determine the phase and call the appropriate function.
  3521.  *
  3522.  *---------------------------------------------------------------------*/
  3524. #if defined(DOS)
  3525. void phaseDecode(USHORT p_port, UCHAR p_card)
  3526. #else
  3527. void phaseDecode(ULONG p_port, UCHAR p_card)
  3528. #endif
  3529. {
  3530.    unsigned char phase_ref;
  3531. #if defined(OS2)
  3532.    void (far *phase) (ULONG, UCHAR);
  3533. #else
  3534.    #if defined(DOS)
  3535.       void (*phase) (USHORT, UCHAR);
  3536.    #else
  3537.       void (*phase) (ULONG, UCHAR);
  3538.    #endif
  3539. #endif
  3542.    DISABLE_AUTO(p_port);
  3544.    phase_ref = (UCHAR) (RD_HARPOON(p_port+hp_scsisig) & S_SCSI_PHZ);
  3546.    phase = s_PhaseTbl[phase_ref];
  3548.    (*phase)(p_port, p_card);           /* Call the correct phase func */
  3549. }
  3553. /*---------------------------------------------------------------------
  3554.  *
  3555.  * Function: Data Out Phase
  3556.  *
  3557.  * Description: Start up both the BusMaster and Xbow.
  3558.  *
  3559.  *---------------------------------------------------------------------*/
  3561. #if defined(OS2)
  3562. void far phaseDataOut(ULONG port, UCHAR p_card)
  3563. #else
  3564. #if defined(DOS)
  3565. void phaseDataOut(USHORT port, UCHAR p_card)
  3566. #else
  3567. void phaseDataOut(ULONG port, UCHAR p_card)
  3568. #endif
  3569. #endif
  3570. {
  3572.    PSCCB currSCCB;
  3574.    currSCCB = BL_Card[p_card].currentSCCB;
  3575.    if (currSCCB == NULL)
  3576.       {
  3577.       return;  /* Exit if No SCCB record */
  3578.       }
  3580.    currSCCB->Sccb_scsistat = DATA_OUT_ST;
  3581.    currSCCB->Sccb_XferState &= ~(F_HOST_XFER_DIR | F_NO_DATA_YET);
  3583.    WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  3585.    WRW_HARPOON((port+hp_intstat), XFER_CNT_0);
  3587.    WR_HARPOON(port+hp_autostart_0, (END_DATA+END_DATA_START));
  3589.    dataXferProcessor(port, &BL_Card[p_card]);
  3591. #if defined(NOBUGBUG)
  3592.    if (RDW_HARPOON((port+hp_intstat)) & XFER_CNT_0)
  3593.       WRW_HARPOON((port+hp_intstat), XFER_CNT_0);
  3595. #endif
  3598.    if (currSCCB->Sccb_XferCnt == 0) {
  3601.       if ((currSCCB->ControlByte & SCCB_DATA_XFER_OUT) &&
  3602.  (currSCCB->HostStatus == SCCB_COMPLETE))
  3603.  currSCCB->HostStatus = SCCB_DATA_OVER_RUN;
  3605.       sxfrp(port,p_card);
  3606.       if (!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | RESET)))
  3607.     phaseDecode(port,p_card);
  3608.       }
  3609. }
  3612. /*---------------------------------------------------------------------
  3613.  *
  3614.  * Function: Data In Phase
  3615.  *
  3616.  * Description: Startup the BusMaster and the XBOW.
  3617.  *
  3618.  *---------------------------------------------------------------------*/
  3620. #if defined(OS2)
  3621. void far phaseDataIn(ULONG port, UCHAR p_card)
  3622. #else
  3623. #if defined(DOS)
  3624. void phaseDataIn(USHORT port, UCHAR p_card)
  3625. #else
  3626. void phaseDataIn(ULONG port, UCHAR p_card)
  3627. #endif
  3628. #endif
  3629. {
  3631.    PSCCB currSCCB;
  3633.    currSCCB = BL_Card[p_card].currentSCCB;
  3635.    if (currSCCB == NULL)
  3636.       {
  3637.       return;  /* Exit if No SCCB record */
  3638.       }
  3641.    currSCCB->Sccb_scsistat = DATA_IN_ST;
  3642.    currSCCB->Sccb_XferState |= F_HOST_XFER_DIR;
  3643.    currSCCB->Sccb_XferState &= ~F_NO_DATA_YET;
  3645.    WR_HARPOON(port+hp_portctrl_0, SCSI_PORT);
  3647.    WRW_HARPOON((port+hp_intstat), XFER_CNT_0);
  3649.    WR_HARPOON(port+hp_autostart_0, (END_DATA+END_DATA_START));
  3651.    dataXferProcessor(port, &BL_Card[p_card]);
  3653.    if (currSCCB->Sccb_XferCnt == 0) {
  3656.       if ((currSCCB->ControlByte & SCCB_DATA_XFER_IN) &&
  3657.  (currSCCB->HostStatus == SCCB_COMPLETE))
  3658.  currSCCB->HostStatus = SCCB_DATA_OVER_RUN;
  3660.       sxfrp(port,p_card);
  3661.       if (!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | RESET)))
  3662.     phaseDecode(port,p_card);
  3664.       }
  3665. }
  3667. /*---------------------------------------------------------------------
  3668.  *
  3669.  * Function: Command Phase
  3670.  *
  3671.  * Description: Load the CDB into the automation and start it up.
  3672.  *
  3673.  *---------------------------------------------------------------------*/
  3675. #if defined(OS2)
  3676. void far phaseCommand(ULONG p_port, UCHAR p_card)
  3677. #else
  3678. #if defined(DOS)
  3679. void phaseCommand(USHORT p_port, UCHAR p_card)
  3680. #else
  3681. void phaseCommand(ULONG p_port, UCHAR p_card)
  3682. #endif
  3683. #endif
  3684. {
  3685.    PSCCB currSCCB;
  3686. #if defined(DOS)
  3687.    USHORT cdb_reg;
  3688. #else
  3689.    ULONG cdb_reg;
  3690. #endif
  3691.    UCHAR i;
  3693.    currSCCB = BL_Card[p_card].currentSCCB;
  3695.    if (currSCCB->OperationCode == RESET_COMMAND) {
  3697.       currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
  3698.       currSCCB->CdbLength = SIX_BYTE_CMD;
  3699.       }
  3701.    WR_HARPOON(p_port+hp_scsisig, 0x00);
  3703.    ARAM_ACCESS(p_port);
  3706.    cdb_reg = p_port + CMD_STRT;
  3708.    for (i=0; i < currSCCB->CdbLength; i++) {
  3710.       if (currSCCB->OperationCode == RESET_COMMAND)
  3712.  WRW_HARPOON(cdb_reg, (MPM_OP + ACOMMAND + 0x00));
  3714.       else
  3715.  WRW_HARPOON(cdb_reg, (MPM_OP + ACOMMAND + currSCCB->Cdb[i]));
  3716.       cdb_reg +=2;
  3717.       }
  3719.    if (currSCCB->CdbLength != TWELVE_BYTE_CMD)
  3720.       WRW_HARPOON(cdb_reg, (BRH_OP+ALWAYS+    NP));
  3722.    WR_HARPOON(p_port+hp_portctrl_0,(SCSI_PORT));
  3724.    currSCCB->Sccb_scsistat = COMMAND_ST;
  3726.    WR_HARPOON(p_port+hp_autostart_3, (AUTO_IMMED | CMD_ONLY_STRT));
  3727.    SGRAM_ACCESS(p_port);
  3728. }
  3731. /*---------------------------------------------------------------------
  3732.  *
  3733.  * Function: Status phase
  3734.  *
  3735.  * Description: Bring in the status and command complete message bytes
  3736.  *
  3737.  *---------------------------------------------------------------------*/
  3739. #if defined(OS2)
  3740. void far phaseStatus(ULONG port, UCHAR p_card)
  3741. #else
  3742. #if defined(DOS)
  3743. void phaseStatus(USHORT port, UCHAR p_card)
  3744. #else
  3745. void phaseStatus(ULONG port, UCHAR p_card)
  3746. #endif
  3747. #endif
  3748. {
  3749.    /* Start-up the automation to finish off this command and let the
  3750.       isr handle the interrupt for command complete when it comes in.
  3751.       We could wait here for the interrupt to be generated?
  3752.     */
  3754.    WR_HARPOON(port+hp_scsisig, 0x00);
  3756.    WR_HARPOON(port+hp_autostart_0, (AUTO_IMMED+END_DATA_START));
  3757. }
  3760. /*---------------------------------------------------------------------
  3761.  *
  3762.  * Function: Phase Message Out
  3763.  *
  3764.  * Description: Send out our message (if we have one) and handle whatever
  3765.  *              else is involed.
  3766.  *
  3767.  *---------------------------------------------------------------------*/
  3769. #if defined(OS2)
  3770. void far phaseMsgOut(ULONG port, UCHAR p_card)
  3771. #else
  3772. #if defined(DOS)
  3773. void phaseMsgOut(USHORT port, UCHAR p_card)
  3774. #else
  3775. void phaseMsgOut(ULONG port, UCHAR p_card)
  3776. #endif
  3777. #endif
  3778. {
  3779. UCHAR message,scsiID;
  3780. PSCCB currSCCB;
  3781. PSCCBMgr_tar_info currTar_Info;
  3783. currSCCB = BL_Card[p_card].currentSCCB;
  3785. if (currSCCB != NULL) {
  3787. message = currSCCB->Sccb_scsimsg;
  3788. scsiID = currSCCB->TargID;
  3790. if (message == SMDEV_RESET) 
  3791. {
  3794. currTar_Info = &sccbMgrTbl[p_card][scsiID];
  3795. currTar_Info->TarSyncCtrl = 0;
  3796. sssyncv(port, scsiID, NARROW_SCSI,currTar_Info);
  3798. if (sccbMgrTbl[p_card][scsiID].TarEEValue & EE_SYNC_MASK) 
  3799. {
  3801. sccbMgrTbl[p_card][scsiID].TarStatus &= ~TAR_SYNC_MASK;
  3803. }
  3805. if (sccbMgrTbl[p_card][scsiID].TarEEValue & EE_WIDE_SCSI) 
  3806. {
  3808. sccbMgrTbl[p_card][scsiID].TarStatus &= ~TAR_WIDE_MASK;
  3809. }
  3812. queueFlushSccb(p_card,SCCB_COMPLETE);
  3813. SccbMgrTableInitTarget(p_card,scsiID);
  3814. }
  3815. else if (currSCCB->Sccb_scsistat == ABORT_ST)
  3816. {
  3817. currSCCB->HostStatus = SCCB_COMPLETE;
  3818. if(BL_Card[p_card].discQ_Tbl[currSCCB->Sccb_tag] != NULL)
  3819. {
  3820. BL_Card[p_card].discQ_Tbl[currSCCB->Sccb_tag] = NULL;
  3821. sccbMgrTbl[p_card][scsiID].TarTagQ_Cnt--;
  3822. }
  3824. }
  3826. else if (currSCCB->Sccb_scsistat < COMMAND_ST) 
  3827. {
  3830. if(message == SMNO_OP)
  3831. {
  3832. currSCCB->Sccb_MGRFlags |= F_DEV_SELECTED;
  3834. ssel(port,p_card);
  3835. return;
  3836. }
  3837. }
  3838. else 
  3839. {
  3842. if (message == SMABORT)
  3844. queueFlushSccb(p_card,SCCB_COMPLETE);
  3845. }
  3847. }
  3848. else 
  3849. {
  3850. message = SMABORT;
  3851. }
  3853. WRW_HARPOON((port+hp_intstat), (BUS_FREE | PHASE | XFER_CNT_0));
  3856. WR_HARPOON(port+hp_portctrl_0, SCSI_BUS_EN);
  3858. WR_HARPOON(port+hp_scsidata_0,message);
  3860. WR_HARPOON(port+hp_scsisig, (SCSI_ACK + S_ILL_PH));
  3862. ACCEPT_MSG(port);
  3864. WR_HARPOON(port+hp_portctrl_0, 0x00);
  3866. if ((message == SMABORT) || (message == SMDEV_RESET) || 
  3867. (message == SMABORT_TAG) ) 
  3868. {
  3870. while(!(RDW_HARPOON((port+hp_intstat)) & (BUS_FREE | PHASE))) {}
  3872. if (RDW_HARPOON((port+hp_intstat)) & BUS_FREE) 
  3873. {
  3874. WRW_HARPOON((port+hp_intstat), BUS_FREE);
  3876. if (currSCCB != NULL) 
  3877. {
  3879. if((BL_Card[p_card].globalFlags & F_CONLUN_IO) &&
  3880. ((sccbMgrTbl[p_card][currSCCB->TargID].TarStatus & TAR_TAG_Q_MASK) != TAG_Q_TRYING))
  3881. sccbMgrTbl[p_card][currSCCB->TargID].TarLUNBusy[currSCCB->Lun] = FALSE;
  3882. else
  3883. sccbMgrTbl[p_card][currSCCB->TargID].TarLUNBusy[0] = FALSE;
  3885. queueCmdComplete(&BL_Card[p_card],currSCCB, p_card);
  3886. }
  3888. else 
  3889. {
  3890. BL_Card[p_card].globalFlags |= F_NEW_SCCB_CMD;
  3891. }
  3892. }
  3894. else 
  3895. {
  3897. sxfrp(port,p_card);
  3898. }
  3899. }
  3901. else 
  3902. {
  3904. if(message == SMPARITY)
  3905. {
  3906. currSCCB->Sccb_scsimsg = SMNO_OP;
  3907. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  3908. }
  3909. else
  3910. {
  3911. sxfrp(port,p_card);
  3912. }
  3913. }
  3914. }
  3917. /*---------------------------------------------------------------------
  3918.  *
  3919.  * Function: Message In phase
  3920.  *
  3921.  * Description: Bring in the message and determine what to do with it.
  3922.  *
  3923.  *---------------------------------------------------------------------*/
  3925. #if defined(OS2)
  3926. void far phaseMsgIn(ULONG port, UCHAR p_card)
  3927. #else
  3928. #if defined(DOS)
  3929. void phaseMsgIn(USHORT port, UCHAR p_card)
  3930. #else
  3931. void phaseMsgIn(ULONG port, UCHAR p_card)
  3932. #endif
  3933. #endif
  3934. {
  3935. UCHAR message;
  3936. PSCCB currSCCB;
  3938. currSCCB = BL_Card[p_card].currentSCCB;
  3940. if (BL_Card[p_card].globalFlags & F_HOST_XFER_ACT) 
  3941. {
  3943. phaseChkFifo(port, p_card);
  3944. }
  3946. message = RD_HARPOON(port+hp_scsidata_0);
  3947. if ((message == SMDISC) || (message == SMSAVE_DATA_PTR)) 
  3948. {
  3950. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+END_DATA_START));
  3952. }
  3954. else 
  3955. {
  3957. message = sfm(port,currSCCB);
  3958. if (message) 
  3959. {
  3962. sdecm(message,port,p_card);
  3964. }
  3965. else
  3966. {
  3967. if(currSCCB->Sccb_scsimsg != SMPARITY)
  3968. ACCEPT_MSG(port);
  3969. WR_HARPOON(port+hp_autostart_1, (AUTO_IMMED+DISCONNECT_START));
  3970. }
  3971. }
  3973. }
  3976. /*---------------------------------------------------------------------
  3977.  *
  3978.  * Function: Illegal phase
  3979.  *
  3980.  * Description: Target switched to some illegal phase, so all we can do
  3981.  *              is report an error back to the host (if that is possible)
  3982.  *              and send an ABORT message to the misbehaving target.
  3983.  *
  3984.  *---------------------------------------------------------------------*/
  3986. #if defined(OS2)
  3987. void far phaseIllegal(ULONG port, UCHAR p_card)
  3988. #else
  3989. #if defined(DOS)
  3990. void phaseIllegal(USHORT port, UCHAR p_card)
  3991. #else
  3992. void phaseIllegal(ULONG port, UCHAR p_card)
  3993. #endif
  3994. #endif
  3995. {
  3996.    PSCCB currSCCB;
  3998.    currSCCB = BL_Card[p_card].currentSCCB;
  4000.    WR_HARPOON(port+hp_scsisig, RD_HARPOON(port+hp_scsisig));
  4001.    if (currSCCB != NULL) {
  4003.       currSCCB->HostStatus = SCCB_PHASE_SEQUENCE_FAIL;
  4004.       currSCCB->Sccb_scsistat = ABORT_ST;
  4005.       currSCCB->Sccb_scsimsg = SMABORT;
  4006.       }
  4008.    ACCEPT_MSG_ATN(port);
  4009. }
  4013. /*---------------------------------------------------------------------
  4014.  *
  4015.  * Function: Phase Check FIFO
  4016.  *
  4017.  * Description: Make sure data has been flushed from both FIFOs and abort
  4018.  *              the operations if necessary.
  4019.  *
  4020.  *---------------------------------------------------------------------*/
  4022. #if defined(DOS)
  4023. void phaseChkFifo(USHORT port, UCHAR p_card)
  4024. #else
  4025. void phaseChkFifo(ULONG port, UCHAR p_card)
  4026. #endif
  4027. {
  4028.    ULONG xfercnt;
  4029.    PSCCB currSCCB;
  4031.    currSCCB = BL_Card[p_card].currentSCCB;
  4033.    if (currSCCB->Sccb_scsistat == DATA_IN_ST)
  4034.       {
  4036.       while((!(RD_HARPOON(port+hp_xferstat) & FIFO_EMPTY)) &&
  4037.       (RD_HARPOON(port+hp_ext_status) & BM_CMD_BUSY)) {}
  4040.       if (!(RD_HARPOON(port+hp_xferstat) & FIFO_EMPTY))
  4041.          {
  4042.       currSCCB->Sccb_ATC += currSCCB->Sccb_XferCnt;
  4044.       currSCCB->Sccb_XferCnt = 0;
  4046.       if ((RDW_HARPOON((port+hp_intstat)) & PARITY) &&
  4047.             (currSCCB->HostStatus == SCCB_COMPLETE))
  4048.             {
  4049.          currSCCB->HostStatus = SCCB_PARITY_ERR;
  4050.          WRW_HARPOON((port+hp_intstat), PARITY);
  4051.          }
  4053.       hostDataXferAbort(port,p_card,currSCCB);