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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-os2.c：源码内容
  1. /* @(#)scsi-os2.c 1.12 99/11/27 Copyright 1998 J. Schilling, C. Wohlgemuth */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-os2.c 1.12 99/11/27 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.  * 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.  * XXX it currently uses static SRB and for this reason is not reentrant
  18.  *
  19.  * Copyright (c) 1998 J. Schilling
  20.  * Copyright (c) 1998 C. Wohlgemuth for this interface.
  21.  */
  22. /*
  23.  * This program is free software; you can redistribute it and/or modify
  24.  * it under the terms of the GNU General Public License as published by
  25.  * the Free Software Foundation; either version 2, or (at your option)
  26.  * any later version.
  27.  *
  28.  * This program is distributed in the hope that it will be useful,
  29.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31.  * GNU General Public License for more details.
  32.  *
  33.  * You should have received a copy of the GNU General Public License
  34.  * along with this program; see the file COPYING.  If not, write to
  35.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  36.  */
  38. #undef sense
  40. /*#define DEBUG*/
  42. /* For AspiRouter */
  43. #include "scg/srb_os2.h"
  45. /*
  46.  * Warning: you may change this source, but if you do that
  47.  * you need to change the _scg_version and _scg_auth* string below.
  48.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  49.  * Choose your name instead of "schily" and make clear that the version
  50.  * string is related to a modified source.
  51.  */
  52. LOCAL char _scg_trans_version[] = "scsi-os2.c-1.12"; /* The version for this transport*/
  54. #define FILE_OPEN 0x0001
  55. #define OPEN_SHARE_DENYREADWRITE 0x0010
  56. #define OPEN_ACCESS_READWRITE 0x0002
  57. #define DC_SEM_SHARED 0x01
  58. #define OBJ_TILE 0x0040
  59. #define PAG_READ 0x0001
  60. #define PAG_WRITE 0x0002
  61. #define PAG_COMMIT 0x0010
  63. typedef unsigned long LHANDLE;
  64. typedef unsigned long ULONG;
  65. typedef unsigned char *PSZ;
  66. typedef unsigned short USHORT;
  67. typedef unsigned char UCHAR;
  69. typedef LHANDLE HFILE;
  70. typedef ULONG HEV;
  72. #define MAX_SCG 16 /* Max # of SCSI controllers */
  73. #define MAX_TGT 16
  74. #define MAX_LUN 8
  76. struct scg_local {
  77. int dummy;
  78. };
  79. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  81. #define MAX_DMA_OS2 (63*1024) /* ASPI-Router allows up to 64k */
  83. LOCAL void *buffer = NULL;
  84. LOCAL HFILE driver_handle = 0;
  85. LOCAL HEV postSema = 0;
  87. LOCAL BOOL open_driver __PR((void));
  88. LOCAL BOOL close_driver __PR((void));
  89. LOCAL ULONG wait_post __PR((ULONG ulTimeOut));
  90. LOCAL BOOL  init_buffer __PR((void* mem));
  91. EXPORT void exit_func __PR((void));
  92. LOCAL void set_error __PR((SRB *srb, struct scg_cmd *sp));
  95. EXPORT void
  96. exit_func()
  97. {
  98. if (!close_driver())
  99. fprintf(stderr, "Cannot close OS/2-ASPI-Router!n");
  100. }
  102. /*
  103.  * Return version information for the low level SCSI transport code.
  104.  * This has been introduced to make it easier to trace down problems
  105.  * in applications.
  106.  */
  107. EXPORT char *
  108. scg__version(scgp, what)
  109. SCSI *scgp;
  110. int what;
  111. {
  112. if (scgp != (SCSI *)0) {
  113. switch (what) {
  115. case SCG_VERSION:
  116. return (_scg_trans_version);
  117. /*
  118.  * If you changed this source, you are not allowed to
  119.  * return "schily" for the SCG_AUTHOR request.
  120.  */
  121. case SCG_AUTHOR:
  122. return (_scg_auth_schily);
  123. case SCG_SCCS_ID:
  124. return (__sccsid);
  125. }
  126. }
  127. return ((char *)0);
  128. }
  130. EXPORT int
  131. scsi_open(scgp, device, busno, tgt, tlun)
  132. SCSI *scgp;
  133. char *device;
  134. int busno;
  135. int tgt;
  136. int tlun;
  137. {
  138. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  139. errno = EINVAL;
  140. if (scgp->errstr)
  141. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  142. "Illegal value for busno, target or lun '%d,%d,%d'",
  143. busno, tgt, tlun);
  144. return (-1);
  145. }
  147. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  148. errno = EINVAL;
  149. if (scgp->errstr)
  150. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  151. "Open by 'devname' not supported on this OS");
  152. return (-1);
  153. }
  155. if (scgp->local == NULL) {
  156. scgp->local = malloc(sizeof(struct scg_local));
  157. if (scgp->local == NULL)
  158. return (0);
  159. }
  161. if (!open_driver()) /* Try to open ASPI-Router */
  162. return (-1);
  163. atexit(exit_func); /* Install Exit Function which closes the ASPI-Router */
  164.   
  165. /* 
  166.  * Success after all 
  167.  */ 
  168. return (1);
  169. }
  171. EXPORT int
  172. scsi_close(scgp)
  173. SCSI *scgp;
  174. {
  175. exit_func();
  176. return (0);
  177. }
  179. LOCAL long
  180. scsi_maxdma(scgp)
  181. SCSI *scgp;
  182. {
  183. long maxdma = MAX_DMA_OS2;
  184. return (maxdma);
  185. }
  187. EXPORT void *
  188. scsi_getbuf(scgp, amt)
  189. SCSI *scgp;
  190. long amt;
  191. {
  192. ULONG rc;
  194. if (amt <= 0 || amt > scsi_maxdma(scgp))
  195. return ((void *)0);
  196. #ifdef DEBUG
  197. printf("scsi_getbuf: %ld bytesn", amt);
  198. #endif
  199. rc = DosAllocMem(&buffer, amt, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
  201. if (rc) {
  202. fprintf(stderr, "Cannot allocate buffer.n");
  203. return ((void *)0);
  204. }
  205. scgp->bufbase = buffer;
  207. #ifdef DEBUG
  208. printf("Buffer allocated at: 0x%xn", scgp->bufbase);
  209. #endif
  211. /* Lock memory */
  212. if (init_buffer(scgp->bufbase))
  213. return (scgp->bufbase);
  215. fprintf(stderr, "Cannot lock memory buffer.n");
  216. return ((void *)0); /* Error */
  217. }
  219. EXPORT void
  220. scsi_freebuf(scgp)
  221. SCSI *scgp;
  222. {
  223. if (scgp->bufbase && DosFreeMem(scgp->bufbase))
  224. fprintf(stderr, "Cannot free buffer memory for ASPI-Router!n"); /* Free our memory buffer if not already done */
  225. if (buffer == scgp->bufbase)
  226. buffer = NULL;
  227. scgp->bufbase = NULL;
  228. }
  230. EXPORT
  231. BOOL scsi_havebus(scgp, busno)
  232. SCSI *scgp;
  233. int busno;
  234. {
  235. register int t;
  236. register int l;
  238. if (busno < 0 || busno >= MAX_SCG)
  239. return (FALSE);
  241. return (TRUE);
  242. }
  244. EXPORT
  245. int scsi_fileno(scgp, busno, tgt, tlun)
  246. SCSI *scgp;
  247. int busno;
  248. int tgt;
  249. int tlun;
  250. {
  251. if (busno < 0 || busno >= MAX_SCG ||
  252.     tgt < 0 || tgt >= MAX_TGT ||
  253.     tlun < 0 || tlun >= MAX_LUN)
  254. return (-1);
  256. /*
  257.  * Return fake
  258.  */
  259. return (1);
  260. }
  263. EXPORT int
  264. scsi_initiator_id(scgp)
  265. SCSI *scgp;
  266. {
  267. return (-1);
  268. }
  270. EXPORT int
  271. scsi_isatapi(scgp)
  272. SCSI *scgp;
  273. {
  274. return (FALSE);
  275. }
  278. EXPORT
  279. int scsireset(scgp)
  280. SCSI *scgp;
  281. {
  282. ULONG rc; /* return value */
  283. ULONG cbreturn;
  284. ULONG cbParam;
  285. BOOL success;
  286. static SRB SRBlock; /* XXX makes it non reentrant */
  288. SRBlock.cmd = SRB_Reset; /* reset device */
  289. SRBlock.ha_num = scgp->scsibus;/* host adapter number */
  290. SRBlock.flags = SRB_Post; /* posting enabled */
  291. SRBlock.u.res.target = scgp->target; /* target id */
  292. SRBlock.u.res.lun = scgp->lun; /* target LUN */
  294. rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  295. (void*) &SRBlock, sizeof(SRB), &cbreturn);
  296. if (rc) {
  297. fprintf(stderr, "DosDevIOCtl() failed in resetDevice.n");
  298. return (1); /* DosDevIOCtl failed */
  299. } else {
  300. success = wait_post(40000); /** wait for SRB being processed */
  301. if (success)
  302. return (2);
  303. }
  304. if (SRBlock.status != SRB_Done)
  305. return (3);
  306. #ifdef DEBUG
  307. printf("resetDevice of host: %d target: %d lun: %d successful.n", scgp->scsibus, scgp->target, scgp->lun);
  308. printf("SRBlock.ha_status: 0x%x, SRBlock.target_status: 0x%x, SRBlock.satus: 0x%xn",
  309.  SRBlock.u.cmd.ha_status, SRBlock.u.cmd.target_status, SRBlock.status);
  310. #endif
  311. return (0);
  312. }
  314. /*
  315.  * Set error flags
  316.  */
  317. LOCAL void
  318. set_error(srb, sp)
  319. SRB *srb;
  320. struct scg_cmd *sp;
  321. {
  322. switch (srb->status) {
  324. case SRB_InvalidCmd: /* 0x80 Invalid SCSI request      */
  325. case SRB_InvalidHA: /* 0x81 Invalid host adapter number  */
  326. case SRB_BadDevice: /* 0x82 SCSI device not installed    */
  327. sp->error = SCG_FATAL;
  328. sp->ux_errno = EINVAL;
  329. break;
  332. case SRB_Busy: /* 0x00 SCSI request in progress     */
  333. case SRB_Aborted: /* 0x02 SCSI aborted by host      */
  334. case SRB_BadAbort: /* 0x03 Unable to abort SCSI request */
  335. case SRB_Error: /* 0x04 SCSI request completed with error */
  336. default:
  337. sp->error = SCG_RETRYABLE;
  338. sp->ux_errno = EIO;
  339. break;
  340. }
  341. }
  343. LOCAL int
  344. scsi_send(scgp, f, sp)
  345. SCSI *scgp;
  346. int f;
  347. struct scg_cmd *sp;
  348. {
  349. ULONG rc; /* return value */
  350. static SRB SRBlock; /* XXX makes it non reentrant */
  351. Ulong cbreturn;
  352. Ulong cbParam;
  353. UCHAR* ptr;
  355. if (!f) { /* Set in scsi_open() */
  356. sp->error = SCG_FATAL;
  357. return (-1);
  358. }
  360. if (sp->cdb_len > sizeof(SRBlock.u.cmd.cdb_st)) { /* commandsize too big */
  361. sp->error = SCG_FATAL;
  362. sp->ux_errno = EINVAL;
  363. fprintf(stderr, "sp->cdb_len > SRBlock.u.cmd.cdb_st. Fatal error in scsi_send, exiting...n");
  364. return (-1);
  365. }
  367. /* clear command block */
  368. fillbytes((caddr_t)&SRBlock.u.cmd.cdb_st, sizeof(SRBlock.u.cmd.cdb_st), '');
  369. /* copy cdrecord command into SRB */
  370. movebytes(&sp->cdb, &SRBlock.u.cmd.cdb_st, sp->cdb_len);
  372. /* Build SRB command block */
  373. SRBlock.cmd = SRB_Command;
  374. SRBlock.ha_num = scgp->scsibus; /* host adapter number */
  376. SRBlock.flags = SRB_Post; /* flags */
  378. SRBlock.u.cmd.target = scgp->target; /* Target SCSI ID */
  379. SRBlock.u.cmd.lun = scgp->lun; /* Target SCSI LUN */
  380. SRBlock.u.cmd.data_len = sp->size; /* # of bytes transferred */
  381. SRBlock.u.cmd.data_ptr = 0; /* pointer to data buffer */
  382. SRBlock.u.cmd.sense_len = sp->sense_len;/* length of sense buffer */
  384. SRBlock.u.cmd.link_ptr = 0; /* pointer to next SRB */
  385. SRBlock.u.cmd.cdb_len = sp->cdb_len; /* SCSI command length */
  387. /* Specify direction */
  388. if (sp->flags & SCG_RECV_DATA) {
  389. SRBlock.flags |= SRB_Read;
  390. } else {
  391. if (sp->size > 0) {
  392. SRBlock.flags |= SRB_Write;
  393. if (scgp->bufbase != sp->addr) {/* Copy only if data not in ASPI-Mem */
  394. movebytes(sp->addr, scgp->bufbase, sp->size);
  395. }
  396. } else {
  397. SRBlock.flags |= SRB_NoTransfer;
  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;
  405. /* execute SCSI command */
  406. rc = DosDevIOCtl(driver_handle, 0x92, 0x02,
  407.  (void*) &SRBlock, sizeof(SRB), &cbParam,
  408.  (void*) &SRBlock, sizeof(SRB), &cbreturn);
  410. if (rc) { /* An error occured */
  411. fprintf(stderr, "DosDevIOCtl() in sendCommand failed.n");
  412. sp->error = SCG_FATAL;
  413. sp->ux_errno = EIO; /* Sp鋞er vielleicht errno einsetzen */
  414. return (rc);
  415. } else {
  416. /* Wait until the command is processed */
  417. rc = wait_post(sp->timeout*1000);
  418. if (rc) { /* An error occured */
  419. if (rc == 640) {
  420. /* Timeout */
  421. sp->error = SCG_TIMEOUT;
  422. sp->ux_errno = EIO;
  423. fprintf(stderr, "Timeout during SCSI-Command.n");
  424. return (1);
  425. }
  426. sp->error = SCG_FATAL;
  427. sp->ux_errno = EIO;
  428. fprintf(stderr, "Fatal Error during DosWaitEventSem().n");
  429. return (1);
  430. }
  432. /* The command is processed */
  433. if (SRBlock.status == SRB_Done) { /* succesful completion */
  434. #ifdef DEBUG
  435. printf("Command successful finished. SRBlock.status=0x%xnn", SRBlock.status);
  436. #endif
  437. sp->sense_count = 0;
  438. sp->resid = 0;
  439. if (sp->flags & SCG_RECV_DATA) { /* We read data */
  440. if (sp->addr && sp->size) {
  441. if (scgp->bufbase != sp->addr) /* Copy only if data not in ASPI-Mem */
  442. movebytes(scgp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
  443. ptr = (UCHAR*)sp->addr;
  444. sp->resid = sp->size - SRBlock.u.cmd.data_len;/*nicht 黚ertragene bytes. Korrekt berechnet???*/
  445. }
  446. } /* end of if (sp->flags & SCG_RECV_DATA) */
  447. if (SRBlock.u.cmd.target_status == SRB_CheckStatus) { /* Sense data valid */
  448. sp->sense_count = (int)SRBlock.u.cmd.sense_len;
  449. if (sp->sense_count > sp->sense_len)
  450. sp->sense_count = sp->sense_len;
  452. ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
  453. ptr += SRBlock.u.cmd.cdb_len;
  455. fillbytes(&sp->u_sense.Sense, sizeof(sp->u_sense.Sense), '');
  456. movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
  458. sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
  459. sp->ux_errno = EIO; /* Sp鋞er differenzieren? */
  460. }
  461. return (0);
  462. }
  463. /* SCSI-Error occured */
  464. set_error(&SRBlock, sp);
  466. if (SRBlock.u.cmd.target_status == SRB_CheckStatus) { /* Sense data valid */
  467. sp->sense_count = (int)SRBlock.u.cmd.sense_len;
  468. if (sp->sense_count > sp->sense_len)
  469. sp->sense_count = sp->sense_len;
  471. ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
  472. ptr += SRBlock.u.cmd.cdb_len;
  474. fillbytes(&sp->u_sense.Sense, sizeof(sp->u_sense.Sense), '');
  475. movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
  477. sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
  478. }
  479. if (sp->flags & SCG_RECV_DATA) {
  480. if (sp->addr && sp->size) {
  481. if (scgp->bufbase != sp->addr) /* Copy only if data not in ASPI-Mem */
  482. movebytes(scgp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
  483. }
  484. }
  485. #ifdef really
  486. sp->resid = SRBlock.u.cmd.data_len;/* XXXXX Got no Data ????? */
  487. #else
  488. sp->resid = sp->size - SRBlock.u.cmd.data_len;
  489. #endif
  490. return (1);
  491. }
  492. }
  494. /***************************************************************************
  495.  *                                                                         *
  496.  *  BOOL open_driver()                                                     *
  497.  *                                                                         *
  498.  *  Opens the ASPI Router device driver and sets device_handle.            *
  499.  *  Returns:                                                               *
  500.  *    TRUE - Success                                                       *
  501.  *    FALSE - Unsuccessful opening of device driver                        *
  502.  *                                                                         *
  503.  *  Preconditions: ASPI Router driver has be loaded                        *
  504.  *                                                                         *
  505.  ***************************************************************************/
  506. LOCAL BOOL
  507. open_driver()
  508. {
  509. ULONG rc; /* return value */
  510. ULONG ActionTaken; /* return value */
  511. USHORT openSemaReturn; /* return value */
  512. ULONG cbreturn;
  513. ULONG cbParam;
  515. if (driver_handle) /* ASPI-Router already opened */
  516. return (TRUE);
  518. rc = DosOpen((PSZ) "aspirou$", /* open driver*/
  519. &driver_handle,
  520. &ActionTaken,
  521. 0,
  522. 0,
  523. FILE_OPEN,
  524. OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
  525. NULL);
  526. if (rc) {
  527. fprintf(stderr, "Cannot open ASPI-Router!n");
  528. return (FALSE); /* opening failed -> return false*/
  529. }
  531. /* Init semaphore */
  532. if (DosCreateEventSem(NULL, &postSema, /* create event semaphore */
  533.  DC_SEM_SHARED, 0)) {
  534. DosClose(driver_handle);
  535. fprintf(stderr, "Cannot create event semaphore!n");
  536. return (FALSE);
  537. }
  538. rc = DosDevIOCtl(driver_handle, 0x92, 0x03, /* pass semaphore handle */
  539. (void*) &postSema, sizeof(HEV), /* to driver  */
  540. &cbParam, (void*) &openSemaReturn,
  541. sizeof(USHORT), &cbreturn);
  543. if (rc||openSemaReturn) { /* Error */
  544. DosCloseEventSem(postSema);
  545. DosClose(driver_handle);
  546. return (FALSE);
  547. }
  548. return (TRUE);
  549. }
  551. /***************************************************************************
  552.  *                                                                         *
  553.  *  BOOL close_driver()                                                    *
  554.  *                                                                         *
  555.  *  Closes the device driver                                               *
  556.  *  Returns:                                                               *
  557.  *    TRUE - Success                                                       *
  558.  *    FALSE - Unsuccessful closing of device driver                        *
  559.  *                                                                         *
  560.  *  Preconditions: ASPI Router driver has be opened with open_driver       *
  561.  *                                                                         *
  562.  ***************************************************************************/
  563. LOCAL BOOL
  564. close_driver()
  565. {
  566. ULONG rc; /* return value */
  568. if (driver_handle) {
  569. rc = DosClose(driver_handle);
  570. if (rc)
  571. return (FALSE); /* closing failed -> return false */
  572. driver_handle = 0;
  573. if (DosCloseEventSem(postSema))
  574. fprintf(stderr, "Cannot close event semaphore!n");
  575. if (buffer && DosFreeMem(buffer))
  576. fprintf(stderr, "Cannot free buffer memory for ASPI-Router!n"); /* Free our memory buffer if not already done */
  577. buffer = NULL;
  578. }
  579. return (TRUE);
  580. }
  582. LOCAL ULONG
  583. wait_post(ULONG ulTimeOut)
  584. {
  585. ULONG count = 0;
  586. ULONG rc; /* return value */
  588. /* rc = DosWaitEventSem(postSema, -1);*/ /* wait forever*/
  589. rc = DosWaitEventSem(postSema, ulTimeOut);
  590. DosResetEventSem(postSema, &count);
  591. return (rc);
  592. }
  594. LOCAL BOOL 
  595. init_buffer(mem)
  596. void *mem;
  597. {
  598. ULONG rc; /* return value */
  599. USHORT lockSegmentReturn; /* return value */
  600. Ulong cbreturn;
  601. Ulong cbParam;
  603. rc = DosDevIOCtl(driver_handle, 0x92, 0x04, /* pass buffers pointer */
  604. (void*) mem, sizeof(void*), /* to driver */
  605. &cbParam, (void*) &lockSegmentReturn,
  606. sizeof(USHORT), &cbreturn);
  607. if (rc)
  608. return (FALSE); /* DosDevIOCtl failed */
  609. if (lockSegmentReturn)
  610. return (FALSE); /* Driver could not lock segment */
  611. return (TRUE);
  612. }
  613. #define sense u_sense.Sense