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

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

SCSI/ASPI

开发平台：

MultiPlatform

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