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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-os2.c：源码内容
  1. /* @(#)scsi-os2.c 1.8 99/09/07 Copyright 1998 J. Schilling, C. Wohlgemuth */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-os2.c 1.8 99/09/07 Copyright 1998 J. Schilling, C. Wohlgemuth";
  5. #endif
  6. /*
  7.  * Interface for the OS/2 ASPI-Router ASPIROUT.SYS ((c) D. Dorau).
  8.  * This additional driver is a prerequisite for using cdrecord.
  9.  * Get it from HOBBES or LEO.
  10.  *
  11.  * Copyright (c) 1998 J. Schilling
  12.  * Copyright (c) 1998 C. Wohlgemuth for this interface.
  13.  */
  14. /*
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2, or (at your option)
  18.  * any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; see the file COPYING.  If not, write to
  27.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  28.  */
  30. #undef sense
  32. /*#define DEBUG*/
  33. /*#define DEBUG2*/
  34. /*#define SCANDEBUG*/
  36. /* For AspiRouter */
  37. #include "scg/srb_os2.h"
  39. #define FILE_OPEN 0x0001
  40. #define OPEN_SHARE_DENYREADWRITE 0x0010
  41. #define OPEN_ACCESS_READWRITE 0x0002
  42. #define DC_SEM_SHARED 0x01
  43. #define OBJ_TILE 0x0040
  44. #define PAG_READ 0x0001
  45. #define PAG_WRITE 0x0002
  46. #define PAG_COMMIT 0x0010
  48. typedef unsigned long LHANDLE;
  49. typedef unsigned long ULONG;
  50. typedef unsigned char *PSZ;
  51. typedef unsigned short USHORT;
  52. typedef unsigned char UCHAR;
  54. typedef LHANDLE HFILE;
  55. typedef ULONG HEV;
  57. #define MAX_SCG 16 /* Max # of SCSI controllers */
  58. #define MAX_TGT 16
  59. #define MAX_LUN 8
  61. struct scg_local {
  62. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  63. };
  64. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  66. #define MAX_DMA_OS2 (63*1024) /* ASPI-Router allows up to 64k */
  68. LOCAL void *buffer = NULL;
  69. LOCAL HFILE driver_handle = 0;
  70. LOCAL HEV postSema = 0;
  71. #ifdef XXX
  72. LOCAL int fileHandle;
  73. #endif
  75. LOCAL BOOL open_driver __PR((void));
  76. LOCAL BOOL close_driver __PR((void));
  77. LOCAL ULONG wait_post __PR((ULONG ulTimeOut));
  78. LOCAL BOOL  init_buffer __PR((void* mem));
  79. EXPORT void exit_func __PR((void));
  80. #ifdef SCANDEBUG
  81. LOCAL ULONG test_unit_ready_aspi __PR(( UCHAR busno, UCHAR tgt, UCHAR tlun));
  82. #endif
  85. EXPORT void
  86. exit_func()
  87. {
  88. if (!close_driver())
  89. fprintf(stderr, "Cannot close OS/2-ASPI-Router!n");
  90. }
  92. EXPORT int
  93. scsi_open(scgp, device, busno, tgt, tlun)
  94. SCSI *scgp;
  95. char *device;
  96. int busno;
  97. int tgt;
  98. int tlun;
  99. {
  100. register int b;
  101. register int t;
  102. register int l;
  103. register int f;
  104. register int nopen = 0;
  106. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  107. errno = EINVAL;
  108. if (scgp->errstr)
  109. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  110. "Illegal value for busno, target or lun '%d,%d,%d'",
  111. busno, tgt, tlun);
  112. return (-1);
  113. }
  115. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  116. errno = EINVAL;
  117. if (scgp->errstr)
  118. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  119. "Open by 'devname' not supported on this OS");
  120. return (-1);
  121. }
  123. if (scgp->local == NULL) {
  124. scgp->local = malloc(sizeof(struct scg_local));
  125. if (scgp->local == NULL)
  126. return (0);
  128. for (b=0; b < MAX_SCG; b++) {
  129. for (t=0; t < MAX_TGT; t++) {
  130. for (l=0; l < MAX_LUN ; l++)
  131. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  132. }
  133. }
  134. }
  136. if (!open_driver()) /* Try to open ASPI-Router */
  137. return (-1);
  138. atexit(exit_func); /* Install Exit Function which closes the ASPI-Router */
  139.   
  140. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  142. scglocal(scgp)->scgfiles[busno][tgt][tlun] = 1; /* We do not need it anywhere */
  143. #ifdef XXX
  144. fileHandle = open("test.wav", O_BINARY|O_RDWR|O_CREAT|O_SYNC, S_IREAD|S_IWRITE);
  145. if (fileHandle == -1) {
  146. fileHandle = 0;
  147. printf("Cannot open testfile.n");
  148. }
  149. #endif
  150. return (1);
  151. } else {
  152. for (b=0; b < MAX_SCG; b++) {
  153. for (t=0; t < MAX_TGT; t++) {
  154. for (l=0; l < MAX_LUN ; l++) {
  155. #ifdef SCANDEBUG
  156. f = test_unit_ready_aspi(b, t, l);
  157. if (f == 0) {
  158. scglocal(scgp)->scgfiles[b][t][l] = (short)f;
  159. scglocal(scgp)->scgfiles[b][t][l] = (short)1;
  160. nopen++;
  161. } else if (scgp->debug) {
  162. errmsg("open '0x%x 0x%x 0x%x'n",
  163. b, t, l);
  164. }
  165. #else
  166. scglocal(scgp)->scgfiles[b][t][l] = (short)1;
  167. nopen++;
  168. #endif
  169. }
  170. }
  171. }
  172. }
  173. return (nopen);
  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. long maxdma = MAX_DMA_OS2;
  189. return (maxdma);
  190. }
  192. EXPORT void *
  193. scsi_getbuf(scgp, amt)
  194. SCSI *scgp;
  195. long amt;
  196. {
  197. ULONG rc;
  199. if (amt <= 0 || amt > scsi_maxdma(scgp))
  200. return ((void *)0);
  201. #ifdef DEBUG
  202. printf("scsi_getbuf: %ld bytesn", amt);
  203. #endif
  204. rc = DosAllocMem(&buffer, amt, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
  206. if (rc) {
  207. fprintf(stderr, "Cannot allocate buffer.n");
  208. return ((void *)0);
  209. }
  210. scgp->bufbase = buffer;
  212. #ifdef DEBUG
  213. printf("Buffer allocated at: 0x%xn", scgp->bufbase);
  214. #endif
  216. /* Lock memory */
  217. if (init_buffer(scgp->bufbase))
  218. return (scgp->bufbase);
  220. fprintf(stderr, "Cannot lock memory buffer.n");
  221. return ((void *)0); /* Error */
  222. }
  224. EXPORT void
  225. scsi_freebuf(scgp)
  226. SCSI *scgp;
  227. {
  228. if (scgp->bufbase && DosFreeMem(scgp->bufbase))
  229. fprintf(stderr, "Cannot free buffer memory for ASPI-Router!n"); /* Free our memory buffer if not already done */
  230. if (buffer == scgp->bufbase)
  231. buffer = NULL;
  232. scgp->bufbase = NULL;
  233. }
  235. EXPORT
  236. BOOL scsi_havebus(scgp, busno)
  237. SCSI *scgp;
  238. int busno;
  239. {
  240. register int t;
  241. register int l;
  243. if (busno < 0 || busno >= MAX_SCG)
  244. return (FALSE);
  246. if (scgp->local == NULL)
  247. return (FALSE);
  249. for (t=0; t < MAX_TGT; t++) {
  250. for (l=0; l < MAX_LUN ; l++)
  251. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  252. return (TRUE);
  253. }
  254. return (FALSE);
  255. }
  257. EXPORT
  258. int scsi_fileno(scgp, busno, tgt, tlun)
  259. SCSI *scgp;
  260. int busno;
  261. int tgt;
  262. int tlun;
  263. {
  264. if (busno < 0 || busno >= MAX_SCG ||
  265.     tgt < 0 || tgt >= MAX_TGT ||
  266.     tlun < 0 || tlun >= MAX_LUN)
  267. return (-1);
  269. if (scgp->local == NULL)
  270. return (-1);
  272. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  273. }
  276. EXPORT int
  277. scsi_initiator_id(scgp)
  278. SCSI *scgp;
  279. {
  280. return (-1);
  281. }
  283. EXPORT int
  284. scsi_isatapi(scgp)
  285. SCSI *scgp;
  286. {
  287. return (FALSE);
  288. }
  291. EXPORT
  292. int scsireset(scgp)
  293. SCSI *scgp;
  294. {
  295. ULONG rc; /* return value */
  296. Ulong cbreturn;
  297. Ulong cbParam;
  298. BOOL success;
  299. SRB SRBlock;
  301. SRBlock.cmd = SRB_Reset; /* reset device */
  302. SRBlock.ha_num = scgp->scsibus;/* host adapter number */
  303. SRBlock.flags = SRB_Post; /* posting enabled */
  304. SRBlock.u.res.target = scgp->target; /* target id */
  305. SRBlock.u.res.lun = scgp->lun; /* target LUN */
  307. rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  308. (void*) &SRBlock, sizeof(SRB), &cbreturn);
  309. if (rc) {
  310. fprintf(stderr, "DosDevIOCtl() failed in resetDevice.n");
  311. return (1); /* DosDevIOCtl failed */
  312. } else {
  313. success = wait_post(40000); /** wait for SRB being processed */
  314. if (success)
  315. return (2);
  316. }
  317. if (SRBlock.status != SRB_Done)
  318. return (3);
  319. #ifdef DEBUG
  320. printf("resetDevice of host: %d target: %d lun: %d successful.n", scgp->scsibus, scgp->target, scgp->lun);
  321. printf("SRBlock.ha_status: 0x%x, SRBlock.target_status: 0x%x, SRBlock.satus: 0x%xn",
  322.  SRBlock.u.cmd.ha_status, SRBlock.u.cmd.target_status, SRBlock.status);
  323. #endif
  324. return (0);
  325. }
  327. LOCAL int
  328. scsi_send(scgp, f, sp)
  329. SCSI *scgp;
  330. int f;
  331. struct scg_cmd *sp;
  332. {
  333. ULONG rc; /* return value */
  334. SRB SRBlock;
  335. Ulong cbreturn;
  336. Ulong cbParam;
  337. UCHAR* ptr;
  338. static int done = 0;
  340. if (!f) { /* Set in scsi_open() */
  341. sp->error = SCG_FATAL;
  342. return (-1);
  343. }
  345. if (sp->cdb_len > sizeof(SRBlock.u.cmd.cdb_st)) { /* commandsize too big */
  346. sp->error = SCG_FATAL;
  347. fprintf(stderr, "sp->cdb_len > SRBlock.u.cmd.cdb_st. Fatal error in scsi_send, exiting...n");
  348. return (-1);
  349. }
  351. /* clear command block */
  352. fillbytes((caddr_t)&SRBlock.u.cmd.cdb_st, sizeof(SRBlock.u.cmd.cdb_st), '');
  353. /* copy cdrecord command into SRB */
  354. movebytes(&sp->cdb, &SRBlock.u.cmd.cdb_st, sp->cdb_len);
  356. /* execute SCSI command */
  357. SRBlock.cmd = SRB_Command;
  358. SRBlock.ha_num = scgp->scsibus; /* host adapter number */
  359. SRBlock.flags = 0;
  361. SRBlock.flags = SRB_Post; /* flags */
  363. SRBlock.u.cmd.target = scgp->target; /* Target SCSI ID */
  364. SRBlock.u.cmd.lun = scgp->lun; /* Target SCSI LUN */
  365. SRBlock.u.cmd.data_len = sp->size; /* # of bytes transferred */
  366. SRBlock.u.cmd.data_ptr = 0; /* pointer to data buffer */
  367. SRBlock.u.cmd.sense_len = sp->sense_len;/* length of sense buffer */
  369. SRBlock.u.cmd.link_ptr = 0; /* pointer to next SRB */
  370. SRBlock.u.cmd.cdb_len = sp->cdb_len; /* SCSI command length */
  372. if (sp->flags & SCG_RECV_DATA) {
  373. SRBlock.flags |= SRB_Read;
  374. } else {
  375. if (sp->size > 0) {
  376. SRBlock.flags |= SRB_Write;
  377. if (scgp->bufbase != sp->addr) {/* Copy only if data not in ASPI-Mem */
  378. movebytes(sp->addr, scgp->bufbase, sp->size);
  379. } else {
  380. /* SRBlock.flags |= SRB_NoTransfer;*/
  381. }
  383. #ifdef DEBUG2
  384. printf("data_len=0d%d, sp->size=0d%d, sp->addr0x%x, buffer0x%xn",
  385. SRBlock.u.cmd.data_len, sp->size, sp->addr, scgp->bufbase);
  386. printf("Input cdb[](0x): %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %xn",
  387. SRBlock.u.cmd.cdb_st[0], SRBlock.u.cmd.cdb_st[1],
  388. SRBlock.u.cmd.cdb_st[2], SRBlock.u.cmd.cdb_st[3], SRBlock.u.cmd.cdb_st[4], SRBlock.u.cmd.cdb_st[5],
  389. SRBlock.u.cmd.cdb_st[6], SRBlock.u.cmd.cdb_st[7], SRBlock.u.cmd.cdb_st[8], SRBlock.u.cmd.cdb_st[9],
  390. SRBlock.u.cmd.cdb_st[10], SRBlock.u.cmd.cdb_st[11], SRBlock.u.cmd.cdb_st[12], SRBlock.u.cmd.cdb_st[13],
  391. SRBlock.u.cmd.cdb_st[14], SRBlock.u.cmd.cdb_st[15], SRBlock.u.cmd.cdb_st[16], SRBlock.u.cmd.cdb_st[17],
  392. SRBlock.u.cmd.cdb_st[18], SRBlock.u.cmd.cdb_st[19], SRBlock.u.cmd.cdb_st[20], SRBlock.u.cmd.cdb_st[21]);
  393. #endif
  394. #ifdef XXX
  395. if (fileHandle)
  396. write(fileHandle, sp->addr, sp->size);
  397. #endif
  398. }
  399. }
  400. sp->error = SCG_NO_ERROR;
  401. sp->sense_count = 0;
  402. sp->u_scb.cmd_scb[0] = 0;
  403. sp->resid = 0;
  404. #ifdef DEBUG2
  405. printf("Input cdb[](0x): %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %xn",
  406.  SRBlock.u.cmd.cdb_st[0], SRBlock.u.cmd.cdb_st[1],
  407.  SRBlock.u.cmd.cdb_st[2], SRBlock.u.cmd.cdb_st[3], SRBlock.u.cmd.cdb_st[4], SRBlock.u.cmd.cdb_st[5],
  408.  SRBlock.u.cmd.cdb_st[6], SRBlock.u.cmd.cdb_st[7], SRBlock.u.cmd.cdb_st[8], SRBlock.u.cmd.cdb_st[9],
  409.  SRBlock.u.cmd.cdb_st[10], SRBlock.u.cmd.cdb_st[11], SRBlock.u.cmd.cdb_st[12], SRBlock.u.cmd.cdb_st[13],
  410.  SRBlock.u.cmd.cdb_st[14], SRBlock.u.cmd.cdb_st[15], SRBlock.u.cmd.cdb_st[16], SRBlock.u.cmd.cdb_st[17],
  411.  SRBlock.u.cmd.cdb_st[18], SRBlock.u.cmd.cdb_st[19], SRBlock.u.cmd.cdb_st[20], SRBlock.u.cmd.cdb_st[21]);
  412. printf("data_len=0x%x, sense_len=0x%x, cdb_len=0x%xn",
  413.  SRBlock.u.cmd.data_len, SRBlock.u.cmd.sense_len, SRBlock.u.cmd.cdb_len);
  414. ptr = (UCHAR*)&sp->cdb;
  415. printf("buffer(0x): %x %x %x %x %x %x, addr=%xn",
  416.  *(ptr), *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
  417.  *(ptr+5), sp->addr);
  418. #endif
  419. done++;
  421. rc = DosDevIOCtl(driver_handle, 0x92, 0x02,
  422.  (void*) &SRBlock, sizeof(SRB), &cbParam,
  423.  (void*) &SRBlock, sizeof(SRB), &cbreturn);
  425. if (rc) {
  426. fprintf(stderr, "DosDevIOCtl() in sendCommand failed.n");
  427. sp->error = SCG_FATAL;
  428. sp->ux_errno = EIO; /* Sp鋞er vielleicht errno einsetzen */
  429. return (rc);
  430. } else {
  431. rc = wait_post(sp->timeout*1000);
  432. if (rc) {
  433. if (rc == 640) {
  434. sp->error = SCG_TIMEOUT;
  435. fprintf(stderr, "Timeout during SCSI-Command.n");
  436. return (1);
  437. }
  438. sp->error = SCG_FATAL;
  439. fprintf(stderr, "Fatal Error during DosWaitEventSem().n");
  440. return (1);
  441. }
  442. #ifdef DEBUG2
  443. printf("wait_post() returned rc=%xn", rc);
  444. printf("Done cdb[](0x): %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %xn",
  445.  SRBlock.u.cmd.cdb_st[0], SRBlock.u.cmd.cdb_st[1],
  446.  SRBlock.u.cmd.cdb_st[2], SRBlock.u.cmd.cdb_st[3], SRBlock.u.cmd.cdb_st[4], SRBlock.u.cmd.cdb_st[5],
  447.  SRBlock.u.cmd.cdb_st[6], SRBlock.u.cmd.cdb_st[7], SRBlock.u.cmd.cdb_st[8], SRBlock.u.cmd.cdb_st[9],
  448.  SRBlock.u.cmd.cdb_st[10], SRBlock.u.cmd.cdb_st[11], SRBlock.u.cmd.cdb_st[12], SRBlock.u.cmd.cdb_st[13],
  449.  SRBlock.u.cmd.cdb_st[14], SRBlock.u.cmd.cdb_st[15], SRBlock.u.cmd.cdb_st[16], SRBlock.u.cmd.cdb_st[17],
  450.  SRBlock.u.cmd.cdb_st[18], SRBlock.u.cmd.cdb_st[19], SRBlock.u.cmd.cdb_st[20], SRBlock.u.cmd.cdb_st[21],
  451.  SRBlock.u.cmd.cdb_st[22], SRBlock.u.cmd.cdb_st[23], SRBlock.u.cmd.cdb_st[24], SRBlock.u.cmd.cdb_st[25],
  452.  SRBlock.u.cmd.cdb_st[26], SRBlock.u.cmd.cdb_st[27]);
  453. printf("data_len=0x%x, sense_len=0x%x, cdb_len=0x%x, SRBlock.status=0x%x, size=0x%x, target_status=0x%xn",
  454.  SRBlock.u.cmd.data_len, SRBlock.u.cmd.sense_len, SRBlock.u.cmd.cdb_len, SRBlock.status,
  455.  sp->size, SRBlock.u.cmd.target_status);
  456. ptr = (UCHAR*)scgp->bufbase;
  457. printf("buffer(0x): %x %x %x %x %x %x, buffer=%xn",
  458.  *(ptr), *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
  459.  *(ptr+5), scgp->bufbase);
  460. #endif
  461. if (SRBlock.status == SRB_Done) { /* succesful completion */
  462. #ifdef DEBUG
  463. printf("Command successful finished. SRBlock.status=0x%xnn", SRBlock.status);
  464. #endif
  465. sp->sense_count = 0;
  466. sp->resid = 0;
  467. if (sp->flags & SCG_RECV_DATA) {
  468. if (sp->addr && sp->size) {
  469. if (scgp->bufbase != sp->addr) /* Copy only if data not in ASPI-Mem */
  470. movebytes(scgp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
  471. ptr = (UCHAR*)sp->addr;
  472. sp->resid = sp->size - SRBlock.u.cmd.data_len;/*nicht 黚ertragene bytes. Korrekt berechnet???*/
  473. }
  474. } /* end of if (sp->flags & SCG_RECV_DATA) */
  475. if (SRBlock.u.cmd.target_status == SRB_CheckStatus) { /* Sense data valid */
  476. sp->sense_count = (int)SRBlock.u.cmd.sense_len;
  477. if (sp->sense_count > sp->sense_len)
  478. sp->sense_count = sp->sense_len;
  480. ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
  481. ptr += SRBlock.u.cmd.cdb_len;
  483. fillbytes(&sp->u_sense.Sense, sizeof(sp->u_sense.Sense), '');
  484. movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
  486. sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
  487. sp->ux_errno = EIO; /* Sp鋞er differenzieren? */
  488. }
  489. return (0);
  490. }
  491. /* SCSI-Error occured */
  492. sp->error = SCG_RETRYABLE;
  493. #ifdef DEBUG2
  494. printf("Done cdb[](0x): %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %xn",
  495.  SRBlock.u.cmd.cdb_st[0], SRBlock.u.cmd.cdb_st[1],
  496.  SRBlock.u.cmd.cdb_st[2], SRBlock.u.cmd.cdb_st[3], SRBlock.u.cmd.cdb_st[4], SRBlock.u.cmd.cdb_st[5],
  497.  SRBlock.u.cmd.cdb_st[6], SRBlock.u.cmd.cdb_st[7], SRBlock.u.cmd.cdb_st[8], SRBlock.u.cmd.cdb_st[9],
  498.  SRBlock.u.cmd.cdb_st[10], SRBlock.u.cmd.cdb_st[11], SRBlock.u.cmd.cdb_st[12], SRBlock.u.cmd.cdb_st[13],
  499.  SRBlock.u.cmd.cdb_st[14], SRBlock.u.cmd.cdb_st[15], SRBlock.u.cmd.cdb_st[16], SRBlock.u.cmd.cdb_st[17],
  500.  SRBlock.u.cmd.cdb_st[18], SRBlock.u.cmd.cdb_st[19], SRBlock.u.cmd.cdb_st[20], SRBlock.u.cmd.cdb_st[21],
  501.  SRBlock.u.cmd.cdb_st[22], SRBlock.u.cmd.cdb_st[23], SRBlock.u.cmd.cdb_st[24], SRBlock.u.cmd.cdb_st[25],
  502.  SRBlock.u.cmd.cdb_st[26], SRBlock.u.cmd.cdb_st[27]);
  503. printf("data_len=0x%x, cdb_len=0x%x, SRBlock.status=0x%x, flags=0x%x, ha_status=0x%x, target_status=0x%xn",
  504.  SRBlock.u.cmd.data_len, SRBlock.u.cmd.cdb_len, SRBlock.status,
  505.  sp->flags, SRBlock.u.cmd.ha_status, SRBlock.u.cmd.target_status);
  506. ptr = (UCHAR*)scgp->bufbase;
  507. printf("buffer(0x): %x %x %x %x %x %x, buffer=%xn",
  508.  *(ptr), *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
  509.  *(ptr+5), scgp->bufbase);
  510. #endif
  511. if (SRBlock.u.cmd.target_status == SRB_CheckStatus) { /* Sense data valid */
  512. sp->sense_count = (int)SRBlock.u.cmd.sense_len;
  513. if (sp->sense_count > sp->sense_len)
  514. sp->sense_count = sp->sense_len;
  516. ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
  517. ptr += SRBlock.u.cmd.cdb_len;
  519. fillbytes(&sp->u_sense.Sense, sizeof(sp->u_sense.Sense), '');
  520. movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
  522. sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
  523. sp->ux_errno = EIO;
  524. }
  525. if (sp->flags & SCG_RECV_DATA) {
  526. if (sp->addr && sp->size) {
  527. if (scgp->bufbase != sp->addr) /* Copy only if data not in ASPI-Mem */
  528. movebytes(scgp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
  529. }
  530. }
  531. #ifdef really
  532. sp->resid = SRBlock.u.cmd.data_len;/* XXXXX Got no Data ????? */
  533. #else
  534. sp->resid = sp->size - SRBlock.u.cmd.data_len;
  535. #endif
  536. return (0);
  537. }
  538. }
  540. /***************************************************************************
  541.  *                                                                         *
  542.  *  BOOL open_driver()                                                     *
  543.  *                                                                         *
  544.  *  Opens the ASPI Router device driver and sets device_handle.            *
  545.  *  Returns:                                                               *
  546.  *    TRUE - Success                                                       *
  547.  *    FALSE - Unsuccessful opening of device driver                        *
  548.  *                                                                         *
  549.  *  Preconditions: ASPI Router driver has be loaded                        *
  550.  *                                                                         *
  551.  ***************************************************************************/
  552. LOCAL BOOL
  553. open_driver()
  554. {
  555. ULONG rc; /* return value */
  556. ULONG ActionTaken; /* return value */
  557. USHORT openSemaReturn; /* return value */
  558. Ulong cbreturn;
  559. Ulong cbParam;
  561. if (driver_handle) /* ASPI-Router already opened */
  562. return (TRUE);
  564. rc = DosOpen((PSZ) "aspirou$", /* open driver*/
  565. &driver_handle,
  566. &ActionTaken,
  567. 0,
  568. 0,
  569. FILE_OPEN,
  570. OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
  571. NULL);
  572. if (rc) {
  573. fprintf(stderr, "Cannot open ASPI-Router!n");
  574. return (FALSE); /* opening failed -> return false*/
  575. }
  577. /* Init semaphore */
  578. if (DosCreateEventSem(NULL, &postSema, /* create event semaphore */
  579.  DC_SEM_SHARED, 0)) {
  580. DosClose(driver_handle);
  581. fprintf(stderr, "Cannot create event semaphore!n");
  582. return (FALSE);
  583. }
  584. rc = DosDevIOCtl(driver_handle, 0x92, 0x03, /* pass semaphore handle */
  585. (void*) &postSema, sizeof(HEV), /* to driver  */
  586. &cbParam, (void*) &openSemaReturn,
  587. sizeof(USHORT), &cbreturn);
  589. if (rc||openSemaReturn) { /* Error */
  590. DosCloseEventSem(postSema);
  591. DosClose(driver_handle);
  592. return (FALSE);
  593. }
  594. return (TRUE);
  595. }
  597. /***************************************************************************
  598.  *                                                                         *
  599.  *  BOOL close_driver()                                                    *
  600.  *                                                                         *
  601.  *  Closes the device driver                                               *
  602.  *  Returns:                                                               *
  603.  *    TRUE - Success                                                       *
  604.  *    FALSE - Unsuccessful closing of device driver                        *
  605.  *                                                                         *
  606.  *  Preconditions: ASPI Router driver has be opened with open_driver       *
  607.  *                                                                         *
  608.  ***************************************************************************/
  609. LOCAL BOOL
  610. close_driver()
  611. {
  612. ULONG rc; /* return value */
  614. if (driver_handle) {
  615. rc = DosClose(driver_handle);
  616. if (rc)
  617. return (FALSE); /* closing failed -> return false */
  618. driver_handle = 0;
  619. if (DosCloseEventSem(postSema))
  620. fprintf(stderr, "Cannot close event semaphore!n");
  621. if (buffer && DosFreeMem(buffer))
  622. fprintf(stderr, "Cannot free buffer memory for ASPI-Router!n"); /* Free our memory buffer if not already done */
  623. buffer = NULL;
  624. }
  625. return (TRUE);
  626. }
  629. #ifdef SCANDEBUG
  630. /***************************************************************************/
  631. /*                                                                         */
  632. /*  ULONG test_unit_ready_aspi(UCHAR busno, UCHAR tgt, UCHAR tlun)         */
  633. /*                                                                         */
  634. /*  Sends a SRB containing a test unit ready command                       */
  635. /*  Returns:                                                               */
  636. /*    0  - Success                                                         */
  637. /*    1  - DevIOCtl failed                                                 */
  638. /*    2  - Semaphore access failure                                        */
  639. /*    3  - SCSI command failed                                             */
  640. /*                                                                         */
  641. /*  Preconditions: init() has to be called successfully before             */
  642. /*                                                                         */
  643. /***************************************************************************/
  644. ULONG test_unit_ready_aspi( UCHAR busno, UCHAR tgt, UCHAR tlun)
  645. {
  646. ULONG rc; /* return value */
  647. BOOL  success; /* return value */
  648. Ulong cbreturn;
  649. Ulong cbParam;
  650. SRB SRBlock;
  651.   
  652. SRBlock.cmd = SRB_Command; /* execute SCSI cmd */
  653. SRBlock.ha_num = busno; /* host adapter number */
  654. SRBlock.flags = SRB_NoTransfer | SRB_Post; /* no data transfer, posting enabled */
  655. SRBlock.u.cmd.target = tgt; /* Target SCSI ID */
  656. SRBlock.u.cmd.lun = tlun; /* Target SCSI LUN */
  657. SRBlock.u.cmd.data_len = 0; /* # of bytes transferred */
  658. SRBlock.u.cmd.sense_len = 32; /* length of sense buffer */
  659. SRBlock.u.cmd.data_ptr = 0; /* pointer to data buffer */
  660. SRBlock.u.cmd.link_ptr = 0; /* pointer to next SRB */
  661. SRBlock.u.cmd.cdb_len = 6; /* SCSI command length */
  662. SRBlock.u.cmd.cdb_st[0] = 0x0; /* test unit ready command */
  663. SRBlock.u.cmd.cdb_st[1] = (tlun << 5); /* lun */
  664. SRBlock.u.cmd.cdb_st[2] = 0;
  665. SRBlock.u.cmd.cdb_st[3] = 0;
  666. SRBlock.u.cmd.cdb_st[4] = 0;
  667. SRBlock.u.cmd.cdb_st[5] = 0;
  669. rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  670.    (void*) &SRBlock, sizeof(SRB), &cbreturn);
  671. if (rc) {
  672. return 1; /* DosDevIOCtl failed */
  673. } else {
  674. success = wait_post(40000); /* wait for SRB being processed */
  675. if (success) return 2; /* semaphore could not be accessed */
  676. }
  677. if (SRBlock.status != SRB_Done) return 3;
  678. if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  679. if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  681. return (0);
  682. }
  683. #endif /* SCANDEBUG */
  685. LOCAL ULONG
  686. wait_post(ULONG ulTimeOut)
  687. {
  688. ULONG count = 0;
  689. ULONG rc; /* return value */
  691. /* rc = DosWaitEventSem(postSema, -1);*/ /* wait forever*/
  692. rc = DosWaitEventSem(postSema, ulTimeOut);
  693. if (!rc)
  694. DosResetEventSem(postSema, &count); /* ?????????? */
  695. return (rc);
  696. }
  698. LOCAL BOOL 
  699. init_buffer(mem)
  700. void *mem;
  701. {
  702. ULONG rc; /* return value */
  703. USHORT lockSegmentReturn; /* return value */
  704. Ulong cbreturn;
  705. Ulong cbParam;
  707. rc = DosDevIOCtl(driver_handle, 0x92, 0x04, /* pass buffers pointer */
  708. (void*) mem, sizeof(void*), /* to driver */
  709. &cbParam, (void*) &lockSegmentReturn,
  710. sizeof(USHORT), &cbreturn);
  711. if (rc)
  712. return (FALSE); /* DosDevIOCtl failed */
  713. if (lockSegmentReturn)
  714. return (FALSE); /* Driver could not lock segment */
  715. return (TRUE);
  716. }
  717. #define sense u_sense.Sense