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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
scsi-wnt.c
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：21k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

scsi-wnt.c：源码内容
  1. /* @(#)scsi-wnt.c 1.16 99/09/08 Copyright 1998, 1999 J. Schilling, A.L. Faber */
  2. #ifndef lint
  3. static char ___sccsid[] =
  4. "@(#)scsi-wnt.c 1.16 99/09/08 Copyright 1998, 1999 J. Schilling, A.L. Faber";
  5. #endif
  6. /*
  7.  * Interface for the Win32 ASPI library.
  8.  * You need wnaspi32.dll and aspi32.sys
  9.  * Both can be installed from ASPI_ME
  10.  *
  11.  * Copyright (c) 1998 J. Schilling
  12.  * Copyright (c) 1999 A.L. Faber for the first implementation
  13.  *    of this interface.
  14.  * TODO:
  15.  * - DMA resid handling
  16.  * - better handling of maxDMA
  17.  * - SCSI reset support
  18.  */
  19. /*
  20.  * This program is free software; you can redistribute it and/or modify
  21.  * it under the terms of the GNU General Public License as published by
  22.  * the Free Software Foundation; either version 2, or (at your option)
  23.  * any later version.
  24.  *
  25.  * This program is distributed in the hope that it will be useful,
  26.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  * GNU General Public License for more details.
  29.  *
  30.  * You should have received a copy of the GNU General Public License
  31.  * along with this program; see the file COPYING.  If not, write to
  32.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  33.  */
  36. /*
  37.  * Include for Win32 ASPI AspiRouter
  38.  *
  39.  * NOTE: aspi-win32.h includes Windows.h and Windows.h includes
  40.  *  Base.h which has a second typedef for BOOL.
  41.  *  We define BOOL to make all local code use BOOL
  42.  *  from Windows.h and use the hidden __SBOOL for
  43.  *  our global interfaces.
  44.  */
  45. #define BOOL WBOOL /* This is the Win BOOL */
  46. #define format __format
  47. #include <scg/aspi-win32.h>
  48. #undef format
  50. #ifdef __CYGWIN32__ /* Use dlopen() */
  51. #include <dlfcn.h>
  52. #endif
  54. /*
  55.  * Local defines and constants
  56.  */
  57. /*#define DEBUG_WNTASPI*/
  59. #define MAX_SCG 16 /* Max # of SCSI controllers */
  60. #define MAX_TGT 16 /* Max # of SCSI Targets */
  61. #define MAX_LUN 8 /* Max # of SCSI LUNs */
  63. #ifdef DEBUG_WNTASPI
  64. #endif
  66. struct scg_local {
  67. int dummy;
  68. };
  69. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  71. /*
  72.  * Local variables
  73.  */
  74. LOCAL int busses;
  75. LOCAL DWORD (*pfnGetASPI32SupportInfo)(void) = NULL;
  76. LOCAL DWORD (*pfnSendASPI32Command)(LPSRB) = NULL;
  77. LOCAL BOOL (*pfnGetASPI32Buffer)(PASPI32BUFF) = NULL;
  78. LOCAL BOOL (*pfnFreeASPI32Buffer)(PASPI32BUFF) = NULL;
  79. LOCAL BOOL (*pfnTranslateASPI32Address)(PDWORD, PDWORD) = NULL;
  81. LOCAL BOOL AspiLoaded = FALSE;
  82. LOCAL HANDLE hAspiLib = NULL; /* Used for Loadlib */
  84. #define MAX_DMA_WNT (63L*1024L) /* ASPI-Driver  allows up to 64k ??? */
  86. /*
  87.  * Local function prototypes
  88.  */
  89. LOCAL void exit_func __PR((void));
  90. #ifdef DEBUG_WNTASPI
  91. LOCAL void DebugScsiSend __PR((SRB_ExecSCSICmd s, int bDisplayBuffer));
  92. #endif
  93. LOCAL void copy_sensedata __PR((SRB_ExecSCSICmd *cp, struct scg_cmd *sp));
  94. LOCAL void set_error __PR((SRB_ExecSCSICmd *cp, struct scg_cmd *sp));
  95. LOCAL BOOL open_driver __PR((SCSI *scgp));
  96. LOCAL BOOL close_driver __PR((void));
  97. LOCAL int ha_inquiry __PR((SCSI *scgp, int id, SRB_HAInquiry *ip));
  98. LOCAL int resetSCSIBus __PR((void));
  99. LOCAL int scsiabort __PR((SCSI *scgp, SRB_ExecSCSICmd *sp));
  101. LOCAL void
  102. exit_func()
  103. {
  104. if (!close_driver())
  105. errmsgno(EX_BAD, "Cannot close Win32-ASPI-Driver.n");
  106. }
  108. EXPORT int
  109. scsi_open(scgp, device, busno, tgt, tlun)
  110. SCSI *scgp;
  111. char *device;
  112. int busno;
  113. int tgt;
  114. int tlun;
  115. {
  116. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  117. errno = EINVAL;
  118. if (scgp->errstr)
  119. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  120. "Illegal value for busno, target or lun '%d,%d,%d'",
  121. busno, tgt, tlun);
  122. return (-1);
  123. }
  125. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  126. errno = EINVAL;
  127. if (scgp->errstr)
  128. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  129. "Open by 'devname' not supported on this OS");
  130. return (-1);
  131. }
  133. /*
  134.  *  Check if variables are within the range
  135.  */
  136. if (tgt >= 0 && tgt >= 0 && tlun >= 0) {
  137. /*
  138.  * This is the non -scanbus case.
  139.  */
  140. ;
  141. } else if (tgt != -1 || tgt != -1 || tlun != -1) {
  142. errno = EINVAL;
  143. return (-1);
  144. }
  146. if (scgp->local == NULL) {
  147. scgp->local = malloc(sizeof(struct scg_local));
  148. if (scgp->local == NULL)
  149. return (0);
  150. }
  151. /*
  152.  * Try to open ASPI-Router
  153.  */
  154. if (!open_driver(scgp))
  155. return (-1);
  157. /*
  158.  * More than we have ...
  159.  */
  160. if (busno >= busses) {
  161. close_driver();
  162. return (-1);
  163. }
  165. /*
  166.  * Install Exit Function which closes the ASPI-Router
  167.  */
  168. atexit(exit_func);
  170. /*
  171.  * Success after all
  172.  */
  173. return (1);
  174. }
  176. EXPORT int
  177. scsi_close(scgp)
  178. SCSI *scgp;
  179. {
  180. exit_func();
  181. return (0);
  182. }
  184. LOCAL long
  185. scsi_maxdma(scgp)
  186. SCSI *scgp;
  187. {
  188. return (MAX_DMA_WNT);
  189. }
  191. EXPORT void *
  192. scsi_getbuf(scgp, amt)
  193. SCSI *scgp;
  194. long amt;
  195. {
  196. if (amt <= 0 || amt > scsi_maxdma(scgp)) {
  197. errmsgno(EX_BAD,
  198. "scsi_getbuf: buffer out of range; requested size is %ld bytesn", amt);
  199. return ((void *)0);
  200. }
  201. if (scgp->debug)
  202. printf("scsi_getbuf: %ld bytesn", amt);
  204. scgp->bufbase = malloc((size_t)(amt));
  205. return (scgp->bufbase);
  206. }
  208. EXPORT void
  209. scsi_freebuf(scgp)
  210. SCSI *scgp;
  211. {
  212. if (scgp->bufbase)
  213. free(scgp->bufbase);
  214. scgp->bufbase = NULL;
  215. }
  217. EXPORT __SBOOL
  218. scsi_havebus(scgp, busno)
  219. SCSI *scgp;
  220. int busno;
  221. {
  222. if (busno < 0 || busno >= busses)
  223. return (FALSE);
  225. return (TRUE);
  226. }
  228. EXPORT int
  229. scsi_fileno(scgp, busno, tgt, tlun)
  230. SCSI *scgp;
  231. int busno;
  232. int tgt;
  233. int tlun;
  234. {
  235. if (busno < 0 || busno >= busses ||
  236.     tgt < 0 || tgt >= MAX_TGT ||
  237.     tlun < 0 || tlun >= MAX_LUN)
  238. return (-1);
  240. /*
  241.  * Return fake
  242.  */
  243. return (1);
  244. }
  247. EXPORT int
  248. scsi_initiator_id(scgp)
  249. SCSI *scgp;
  250. {
  251. SRB_HAInquiry s;
  253. if (ha_inquiry(scgp, scgp->scsibus, &s) < 0)
  254. return (-1);
  255. return (s.HA_SCSI_ID);
  256. }
  258. EXPORT int
  259. scsi_isatapi(scgp)
  260. SCSI *scgp;
  261. {
  262. return (-1); /* XXX Need to add real test */
  263. }
  266. /*
  267.  * XXX scsireset not yet tested
  268.  */
  269. EXPORT int
  270. scsireset(scgp)
  271. SCSI *scgp;
  272. {
  274. DWORD Status = 0;
  275. DWORD EventStatus = WAIT_OBJECT_0;
  276. HANDLE Event  = NULL;
  277. SRB_BusDeviceReset s;
  279. if (scgp->debug)
  280. printf("Attempting to reset SCSI devicen");
  282. /*
  283.  * Check if ASPI library is loaded
  284.  */
  285. if (AspiLoaded == FALSE) {
  286. printf("error in scsireset: ASPI driver not loaded !n");
  287. return (FALSE);
  288. }
  290. memset(&s, 0, sizeof(s)); /* Clear SRB_BesDeviceReset structure */
  292. Event = CreateEvent(NULL, TRUE, FALSE, NULL);
  294. /*
  295.  * Set structure variables
  296.  */
  297. s.SRB_Cmd = SC_RESET_DEV; /* ASPI command code = SC_RESET_DEV */
  298. s.SRB_HaId = scgp->scsibus; /* ASPI host adapter number */
  299. s.SRB_Flags = SRB_EVENT_NOTIFY; /* Flags */
  300. s.SRB_Target = scgp->target; /* Target's SCSI ID */
  301. s.SRB_Lun = scgp->lun; /* Target's LUN number */
  302. s.SRB_PostProc = (LPVOID)Event; /* Post routine */
  304. /*
  305.  * Initiate SCSI command
  306.  */
  307. Status = pfnSendASPI32Command((LPSRB)&s);
  309. /*
  310.  * Check status
  311.  */
  312. if (Status == SS_PENDING) {
  313. /*
  314.  * Wait till command completes
  315.  */
  316. EventStatus = WaitForSingleObject(Event, INFINITE);
  317. }
  320. /**************************************************/
  321. /* Reset event to non-signaled state.             */
  322. /**************************************************/
  324. if (EventStatus == WAIT_OBJECT_0) {
  325. /*
  326.  * Clear event
  327.  */
  328. ResetEvent(Event);
  329. }
  331. /*
  332.  * Close the event handle
  333.  */
  334. CloseHandle(Event);
  336. /*
  337.  * Check condition
  338.  */
  339. if (s.SRB_Status != SS_COMP) {
  340. printf("ERROR! 0x%08Xn", s.SRB_Status);
  342. /*
  343.  * Indicate that error has occured
  344.  */
  345. return (FALSE);
  346. }
  348. if (scgp->debug)
  349. printf("Reset SCSI device completedn");
  351. /*
  352.  * Everything went OK
  353.  */
  354. return (TRUE);
  355. }
  358. #ifdef DEBUG_WNTASPI
  359. LOCAL void
  360. DebugScsiSend(s, bDisplayBuffer)
  361. SRB_ExecSCSICmd s;
  362. int bDisplayBuffer;
  363. {
  364. int i;
  366. printf("nnDebugScsiSendn");
  367. printf("s.SRB_Cmd          = 0x%02xn", s.SRB_Cmd);
  368. printf("s.SRB_HaId         = 0x%02xn", s.SRB_HaId);
  369. printf("s.SRB_Flags        = 0x%02xn", s.SRB_Flags); 
  370. printf("s.SRB_Target       = 0x%02xn", s.SRB_Target); 
  371. printf("s.SRB_Lun          = 0x%02xn", s.SRB_Lun);
  372. printf("s.SRB_BufLen       = 0x%02xn", s.SRB_BufLen);
  373. printf("s.SRB_BufPointer   = %xn",     s.SRB_BufPointer);
  374. printf("s.SRB_CDBLen       = 0x%02xn", s.SRB_CDBLen);
  375. printf("s.SRB_SenseLen     = 0x%02xn", s.SRB_SenseLen);
  376. printf("s.CDBByte          =");
  377. for (i=0; i < min(s.SRB_CDBLen, 16); i++) {
  378. printf(" %02X ", s.CDBByte[i]);
  379. }
  380. printf("n");
  382. /*
  383. if (bDisplayBuffer != 0 && s.SRB_BufLen >= 8) {
  385. printf("s.SRB_BufPointer   =");
  386. for (i=0; i < 8; i++) {
  387. printf(" %02X ", ((char*)s.SRB_BufPointer)[i]);
  388. }
  389. printf("n");
  390. }
  391. */
  392. printf("Debug donen");
  393. }
  394. #endif
  396. LOCAL void
  397. copy_sensedata(cp, sp)
  398. SRB_ExecSCSICmd *cp;
  399. struct scg_cmd *sp;
  400. {
  401. sp->sense_count = cp->SRB_SenseLen;
  402. if (sp->sense_count > sp->sense_len)
  403. sp->sense_count = sp->sense_len;
  405. memset(&sp->u_sense.Sense, 0x00, sizeof(sp->u_sense.Sense));
  406. memcpy(&sp->u_sense.Sense, cp->SenseArea, sp->sense_len);
  408. sp->u_scb.cmd_scb[0] = cp->SRB_TargStat;
  409. }
  411. /*
  412.  * Set error flags
  413.  */
  414. LOCAL void
  415. set_error(cp, sp)
  416. SRB_ExecSCSICmd *cp;
  417. struct scg_cmd *sp;
  418. {
  419. switch (cp->SRB_Status) {
  421. case SS_COMP: /* 0x01 SRB completed without error  */
  422. sp->error = SCG_NO_ERROR;
  423. sp->ux_errno = 0;
  424. break;
  426. case SS_PENDING: /* 0x00 SRB being processed          */
  427. /*
  428.  * XXX Could SS_PENDING happen ???
  429.  */
  430. case SS_ABORTED: /* 0x02 SRB aborted                  */
  431. case SS_ABORT_FAIL: /* 0x03 Unable to abort SRB          */
  432. case SS_ERR: /* 0x04 SRB completed with error     */
  433. default:
  434. sp->error = SCG_RETRYABLE;
  435. sp->ux_errno = EIO;
  436. break;
  438. case SS_INVALID_CMD: /* 0x80 Invalid ASPI command         */
  439. case SS_INVALID_HA: /* 0x81 Invalid host adapter number  */
  440. case SS_NO_DEVICE: /* 0x82 SCSI device not installed    */
  442. case SS_INVALID_SRB: /* 0xE0 Invalid parameter set in SRB */
  443. case SS_ILLEGAL_MODE: /* 0xE2 Unsupported Windows mode     */
  444. case SS_NO_ASPI: /* 0xE3 No ASPI managers             */
  445. case SS_FAILED_INIT: /* 0xE4 ASPI for windows failed init */
  446. case SS_MISMATCHED_COMPONENTS: /* 0xE7 The DLLs/EXEs of ASPI don't  */
  447. /*      version check                */
  448. case SS_NO_ADAPTERS: /* 0xE8 No host adapters to manager  */
  450. case SS_ASPI_IS_SHUTDOWN: /* 0xEA Call came to ASPI after      */
  451. /*      PROCESS_DETACH               */
  452. case SS_BAD_INSTALL: /* 0xEB The DLL or other components  */
  453. /*      are installed wrong          */
  454. sp->error = SCG_FATAL;
  455. sp->ux_errno = EINVAL;
  456. break;
  458. #ifdef XXX
  459. case SS_OLD_MANAGER: /* 0xE1 ASPI manager doesn't support */
  460. /*      windows                      */
  461. #endif
  462. case SS_BUFFER_ALIGN: /* 0xE1 Buffer not aligned (replaces */
  463. /*      SS_OLD_MANAGER in Win32)     */
  464. sp->error = SCG_FATAL;
  465. sp->ux_errno = EFAULT;
  466. break;
  468. case SS_ASPI_IS_BUSY: /* 0xE5 No resources available to    */
  469. /*      execute command              */
  470. sp->error = SCG_RETRYABLE;
  471. sp->ux_errno = EBUSY;
  472. break;
  474. #ifdef XXX
  475. case SS_BUFFER_TO_BIG: /* 0xE6 Buffer size too big to handle*/
  476. #endif
  477. case SS_BUFFER_TOO_BIG: /* 0xE6 Correct spelling of 'too'    */
  478. case SS_INSUFFICIENT_RESOURCES: /* 0xE9 Couldn't allocate resources  */
  479. /*      needed to init               */
  480. sp->error = SCG_RETRYABLE;
  481. sp->ux_errno = ENOMEM;
  482. break;
  483. }
  484. }
  487. LOCAL int
  488. scsi_send(scgp, f, sp)
  489. SCSI *scgp;
  490. int f;
  491. struct scg_cmd *sp;
  492. {
  493. DWORD Status = 0;
  494. DWORD EventStatus = WAIT_OBJECT_0;
  495. HANDLE Event  = NULL;
  496. SRB_ExecSCSICmd s;
  498. /*
  499.  * Check if ASPI library is loaded
  500.  */
  501. if (AspiLoaded == FALSE) {
  502. errmsgno(EX_BAD, "error in scsi_send: ASPI driver not loaded.n");
  503. sp->error = SCG_FATAL;
  504. return (-1);
  505. }
  507. if (f < 0) {
  508. sp->error = SCG_FATAL;
  509. return (-1);
  510. }
  512. /*
  513.  * Initialize variables
  514.  */
  515. sp->error = SCG_NO_ERROR;
  516. sp->sense_count = 0;
  517. sp->u_scb.cmd_scb[0] = 0;
  518. sp->resid = 0;
  520. memset(&s, 0, sizeof(s)); /* Clear SRB structure */
  522. /*
  523.  * Check cbd_len > the maximum command pakket that can be handled by ASPI
  524.  */
  525. if (sp->cdb_len > 16) {
  526. sp->error = SCG_FATAL;
  527. sp->ux_errno = EINVAL;
  528. printf("sp->cdb_len > sizeof(SRB_ExecSCSICmd.CDBByte). Fatal error in scsi_send, exiting...n");
  529. return (-1);
  530. }
  531. /*
  532.  * copy cdrecord command into SRB
  533.  */
  534. movebytes(&sp->cdb, &(s.CDBByte), sp->cdb_len);
  536. Event = CreateEvent(NULL, TRUE, FALSE, NULL);
  538. /*
  539.  * Fill ASPI structure
  540.  */
  541. s.SRB_Cmd = SC_EXEC_SCSI_CMD; /* SCSI Command */
  542. s.SRB_HaId = scgp->scsibus; /* Host adapter number */
  543. s.SRB_Flags = SRB_EVENT_NOTIFY; /* Flags */
  544. s.SRB_Target = scgp->target; /* Target SCSI ID */
  545. s.SRB_Lun = scgp->lun; /* Target SCSI LUN */
  546. s.SRB_BufLen = sp->size; /* # of bytes transferred */
  547. s.SRB_BufPointer= sp->addr; /* pointer to data buffer */
  548. s.SRB_CDBLen = sp->cdb_len; /* SCSI command length */
  549. s.SRB_PostProc = Event; /* Post proc event */
  550. s.SRB_SenseLen = SENSE_LEN; /* Lenght of sense buffer */
  552. /*
  553.  * Do we receive data from this ASPI command?
  554.  */
  555. if (sp->flags & SCG_RECV_DATA) {
  557. s.SRB_Flags |= SRB_DIR_IN;
  558. } else {
  559. /*
  560.  * Set direction to output
  561.  */
  562. if (sp->size > 0) {
  563. s.SRB_Flags |= SRB_DIR_OUT;
  564. }
  565. }
  567. #ifdef DEBUG_WNTASPI
  568. /*
  569.  * Dump some debug information when enabled
  570.  */
  571. DebugScsiSend(s, TRUE);
  572. /* DebugScsiSend(s, (s.SRB_Flags&SRB_DIR_OUT) == SRB_DIR_OUT);*/
  573. #endif
  575. /*
  576.  * ------------ Send SCSI command --------------------------
  577.  */
  579. ResetEvent(Event); /* Clear event handle      */
  580. Status = pfnSendASPI32Command((LPSRB)&s);/* Initiate SCSI command    */
  582. if (Status == SS_PENDING) { /* If in progress      */
  583. /*
  584.  * Wait untill command completes, or times out.
  585.  */
  586. EventStatus = WaitForSingleObject(Event, sp->timeout*1000L);
  587. /* EventStatus = WaitForSingleObject(Event, 10L);*/
  589. if (EventStatus == WAIT_OBJECT_0)
  590. ResetEvent(Event); /* Clear event, time out     */
  592. if (s.SRB_Status == SS_PENDING) {/* Check if we got a timeout*/
  593. if (scgp->debug)
  594. printf("Timeout....n");
  595. scsiabort(scgp, &s);
  596. ResetEvent(Event); /* Clear event, time out     */
  597. CloseHandle(Event); /* Close the event handle    */
  599. sp->error = SCG_TIMEOUT;
  600. return (1); /* Return error      */
  601. }
  602. }
  603. CloseHandle(Event); /* Close the event handle    */
  605. /*
  606.  * Check ASPI command status
  607.  */
  608. if (s.SRB_Status != SS_COMP) {
  609. if (scgp->debug)
  610. printf("Error in scsi_send: s.SRB_Status is 0x%xn", s.SRB_Status);
  612. set_error(&s, sp); /* Set error flags      */
  613. copy_sensedata(&s, sp); /* Copy sense and status     */
  615. if (scgp->debug)
  616. printf("Mapped to: error %d errno: %dn", sp->error, sp->ux_errno);
  617. return (1);
  618. }
  620. /*
  621.  * Return success
  622.  */
  623. return (0);
  624. }
  626. /***************************************************************************
  627.  *                                                                         *
  628.  *  BOOL open_driver()                                                     *
  629.  *                                                                         *
  630.  *  Opens the ASPI Router device driver and sets device_handle.            *
  631.  *  Returns:                                                               *
  632.  *    TRUE - Success                                                       *
  633.  *    FALSE - Unsuccessful opening of device driver                        *
  634.  *                                                                         *
  635.  *  Preconditions: ASPI Router driver has be loaded                        *
  636.  *                                                                         *
  637.  ***************************************************************************/
  638. LOCAL BOOL
  639. open_driver(scgp)
  640. SCSI *scgp;
  641. {
  642. DWORD astatus;
  643. BYTE HACount;
  644. BYTE ASPIStatus;
  645. int i;
  647. #ifdef DEBUG_WNTASPI
  648. printf("enter open_drivern");
  649. #endif
  651. /*
  652.  * Check if ASPI library is already loaded yet
  653.  */
  654. if (AspiLoaded == TRUE)
  655. return (TRUE);
  657. /*
  658.  * Load the ASPI library
  659.  */
  660. #ifdef __CYGWIN32__
  661. hAspiLib = dlopen("WNASPI32", RTLD_NOW);
  662. #else
  663. hAspiLib = LoadLibrary("WNASPI32");
  664. #endif
  666. /*
  667.  * Check if ASPI library is loaded correctly
  668.  */
  669. if (hAspiLib == NULL) {
  670. printf("Can not load ASPI driver! ");
  671. return (FALSE);
  672. }
  673.   
  674. /*
  675.  * Get a pointer to GetASPI32SupportInfo function
  676.  * and a pointer to SendASPI32Command function
  677.  */
  678. #ifdef __CYGWIN32__
  679. pfnGetASPI32SupportInfo = (DWORD(*)(void))dlsym(hAspiLib, "GetASPI32SupportInfo");
  680. pfnSendASPI32Command = (DWORD(*)(LPSRB))dlsym(hAspiLib, "SendASPI32Command");
  681. #else
  682. pfnGetASPI32SupportInfo = (DWORD(*)(void))GetProcAddress(hAspiLib, "GetASPI32SupportInfo");
  683. pfnSendASPI32Command = (DWORD(*)(LPSRB))GetProcAddress(hAspiLib, "SendASPI32Command");
  684. #endif
  686. if ((pfnGetASPI32SupportInfo == NULL) || (pfnSendASPI32Command == NULL)) {
  687. printf("ASPI function not found in library!");
  688. return (FALSE);
  689. }
  691. #ifdef __CYGWIN32__
  692. pfnGetASPI32Buffer = (BOOL(*)(PASPI32BUFF))dlsym(hAspiLib, "GetASPI32Buffer");
  693. pfnFreeASPI32Buffer = (BOOL(*)(PASPI32BUFF))dlsym(hAspiLib, "FreeASPI32Buffer");
  694. pfnTranslateASPI32Address = (BOOL(*)(PDWORD, PDWORD))dlsym(hAspiLib, "TranslateASPI32Address");
  695. #else
  696. pfnGetASPI32Buffer = (BOOL(*)(PASPI32BUFF))GetProcAddress(hAspiLib, "GetASPI32Buffer");
  697. pfnFreeASPI32Buffer = (BOOL(*)(PASPI32BUFF))GetProcAddress(hAspiLib, "FreeASPI32Buffer");
  698. pfnTranslateASPI32Address = (BOOL(*)(PDWORD, PDWORD))GetProcAddress(hAspiLib, "TranslateASPI32Address");
  699. #endif
  701. /*
  702.  * Set AspiLoaded variable
  703.  */
  704. AspiLoaded = TRUE;
  706. astatus = pfnGetASPI32SupportInfo();
  708. ASPIStatus = HIBYTE(LOWORD(astatus));
  709. HACount    = LOBYTE(LOWORD(astatus));
  711. if (scgp->debug)
  712. printf("open_driver %X HostASPIStatus=0x%x HACount=0x%xn", astatus, ASPIStatus, HACount);
  714. if (ASPIStatus != SS_COMP && ASPIStatus != SS_NO_ADAPTERS) {
  715. printf("Could not find any host adaptersn");
  716. printf("ASPIStatus == 0x%02X", ASPIStatus);
  717. return (FALSE);
  718. }
  719. busses = HACount;
  721. #ifdef DEBUG_WNTASPI
  722. printf("open_driver HostASPIStatus=0x%x HACount=0x%xn", ASPIStatus, HACount);
  723. printf("leaving open_drivern");
  724. #endif
  726. for (i=0; i < busses; i++) {
  727. SRB_HAInquiry s;
  729. ha_inquiry(scgp, i, &s);
  730. }
  732. /*
  733.  * Indicate that library loaded/initialized properly
  734.  */
  735. return (TRUE);
  736. }
  739. /***************************************************************************
  740.  *                                                                         *
  741.  *  BOOL close_driver()                                                    *
  742.  *                                                                         *
  743.  *  Closes the device driver                                               *
  744.  *  Returns:                                                               *
  745.  *    TRUE - Success                                                       *
  746.  *    FALSE - Unsuccessful closing of device driver                        *
  747.  *                                                                         *
  748.  *  Preconditions: ASPI Router driver has be opened with open_driver       *
  749.  *                                                                         *
  750.  ***************************************************************************/
  751. LOCAL BOOL
  752. close_driver()
  753. {
  754. /*
  755.  * If library is loaded
  756.  */
  757. if (hAspiLib) {
  758. /*
  759.  * Clear all variables
  760.  */
  761. AspiLoaded = FALSE;
  762. pfnGetASPI32SupportInfo = NULL;
  763. pfnSendASPI32Command = NULL;
  764. pfnGetASPI32Buffer = NULL;
  765. pfnFreeASPI32Buffer = NULL;
  766. pfnTranslateASPI32Address = NULL;
  768. /*
  769.  * Free ASPI library, we do not need it any longer
  770.  */
  771. #ifdef __CYGWIN32__
  772. dlclose(hAspiLib);
  773. #else
  774. FreeLibrary(hAspiLib);
  775. #endif
  776. hAspiLib = NULL;
  777. }
  779. /*
  780.  * Indicate that shutdown has been finished properly
  781.  */
  782. return (TRUE);
  783. }
  785. LOCAL int
  786. ha_inquiry(scgp, id, ip)
  787. SCSI *scgp;
  788. int id;
  789. SRB_HAInquiry *ip;
  790. {
  791. DWORD Status;
  793. ip->SRB_Cmd = SC_HA_INQUIRY;
  794. ip->SRB_HaId = id;
  795. ip->SRB_Flags = 0;
  796. ip->SRB_Hdr_Rsvd= 0;
  798. Status = pfnSendASPI32Command((LPSRB)ip);
  800. if (scgp->debug) {
  801. printf("Status : %dn", Status);
  802. printf("hacount: %dn", ip->HA_Count);
  803. printf("SCSI id: %dn", ip->HA_SCSI_ID);
  804. printf("Manager: '%.16s'n", ip->HA_ManagerId);
  805. printf("Identif: '%.16s'n", ip->HA_Identifier);
  806. scsiprbytes("Unique:", ip->HA_Unique, 16);
  807. }
  808. if (ip->SRB_Status != SS_COMP)
  809. return (-1);
  810. return (0);
  811. }
  813. LOCAL int
  814. resetSCSIBus(void)
  815. {
  816. DWORD Status;
  817. HANDLE Event;
  818. SRB_BusDeviceReset s;
  820. printf("Attempting to reset SCSI busn");
  822. Event = CreateEvent(NULL, TRUE, FALSE, NULL);
  824. memset(&s, 0, sizeof(s)); /* Clear SRB_BesDeviceReset structure */
  826. /*
  827.  * Set structure variables
  828.  */
  829. s.SRB_Cmd = SC_RESET_DEV;
  830. s.SRB_PostProc = (LPVOID)Event;
  832. /*
  833.  * Clear event
  834.  */
  835. ResetEvent(Event);
  837. /*
  838.  * Initiate SCSI command
  839.  */
  840. Status = pfnSendASPI32Command((LPSRB)&s);
  842. /*
  843.  * Check status
  844.  */
  845. if (Status == SS_PENDING) {
  846. /*
  847.  * Wait till command completes
  848.  */
  849. WaitForSingleObject(Event, INFINITE);
  850. }
  852. /*
  853.  * Close the event handle
  854.  */
  855. CloseHandle(Event);
  857. /*
  858.  * Check condition
  859.  */
  860. if (s.SRB_Status != SS_COMP) {
  861. printf("ERROR  0x%08Xn", s.SRB_Status);
  863. /*
  864.  * Indicate that error has occured
  865.  */
  866. return (FALSE);
  867. }
  869. /*
  870.  * Everything went OK
  871.  */
  872. return (TRUE);
  873. }
  875. LOCAL int
  876. scsiabort(scgp, sp)
  877. SCSI *scgp;
  878. SRB_ExecSCSICmd *sp;
  879. {
  880. DWORD Status = 0;
  881. SRB_Abort s;
  883. if (scgp->debug)
  884. printf("Attempting to abort SCSI commandn");
  886. /*
  887.  * Check if ASPI library is loaded
  888.  */
  889. if (AspiLoaded == FALSE) {
  890. printf("error in scsiabort: ASPI driver not loaded !n");
  891. return (FALSE);
  892. }
  894. /*
  895.  * Set structure variables
  896.  */
  897. s.SRB_Cmd = SC_ABORT_SRB; /* ASPI command code = SC_ABORT_SRB */
  898. s.SRB_HaId = scgp->scsibus; /* ASPI host adapter number */
  899. s.SRB_Flags = 0; /* Flags */
  900. s.SRB_ToAbort = (LPSRB)&sp; /* sp */
  902. /*
  903.  * Initiate SCSI abort
  904.  */
  905. Status = pfnSendASPI32Command((LPSRB)&s);
  907. /*
  908.  * Check condition
  909.  */
  910. if (s.SRB_Status != SS_COMP) {
  911. printf("Abort ERROR! 0x%08Xn", s.SRB_Status);
  913. /*
  914.  * Indicate that error has occured
  915.  */
  916. return (FALSE);
  917. }
  919. if (scgp->debug)
  920. printf("Abort SCSI command completedn");
  922. /*
  923.  * Everything went OK
  924.  */
  925. return (TRUE);
  926. }