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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-vms.c：源码内容
  1. /* @(#)scsi-vms.c 1.15 99/09/17 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-vms.c 1.15 99/09/17 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * Interface for the VMS generic SCSI implementation.
  8.  *
  9.  * This is a hack, that tries to emulate the functionality
  10.  * of the scg driver.
  11.  *
  12.  * Warning: you may change this source, but if you do that
  13.  * you need to change the _scg_version and _scg_auth* string below.
  14.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  15.  * Choose your name instead of "schily" and make clear that the version
  16.  * string is related to a modified source.
  17.  *
  18.  * Copyright (c) 1997 J. Schilling
  19.  */
  20. /*
  21.  * This program is free software; you can redistribute it and/or modify
  22.  * it under the terms of the GNU General Public License as published by
  23.  * the Free Software Foundation; either version 2, or (at your option)
  24.  * any later version.
  25.  *
  26.  * This program is distributed in the hope that it will be useful,
  27.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29.  * GNU General Public License for more details.
  30.  *
  31.  * You should have received a copy of the GNU General Public License
  32.  * along with this program; see the file COPYING.  If not, write to
  33.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  34.  */
  36. #include <iodef.h>
  37. #include <ssdef.h>
  38. #include <descrip.h>
  39. #include <starlet.h>
  40. #include <string.h>
  41. #include <LIB$ROUTINES.H>
  43. /*
  44.  * Warning: you may change this source, but if you do that
  45.  * you need to change the _scg_version and _scg_auth* string below.
  46.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  47.  * Choose your name instead of "schily" and make clear that the version
  48.  * string is related to a modified source.
  49.  */
  50. LOCAL char _scg_trans_version[] = "scsi-vms.c-1.15"; /* The version for this transport*/
  52. #define MAX_SCG  16 /* Max # of SCSI controllers */
  53. #define MAX_TGT  16
  54. #define MAX_LUN  8
  56. #define MAX_DMA_VMS (96*512)/* Check if this is not too big */
  57. #define MAX_PHSTMO_VMS 300
  58. #define MAX_DSCTMO_VMS 65535 /* max value for OpenVMS/AXP 7.1 ehh*/
  61. LOCAL int do_scsi_cmd __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  62. LOCAL int do_scsi_sense __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  64. #define DEVICE_NAMELEN 7
  66. struct SCSI$DESC {
  67. Uint SCSI$L_OPCODE; /* SCSI Operation Code */
  68. Uint SCSI$L_FLAGS; /* SCSI Flags Bit Map */
  69. char *SCSI$A_CMD_ADDR; /* ->SCSI command buffer */
  70. Uint SCSI$L_CMD_LEN;  /* SCSI command length, bytes */
  71. char *SCSI$A_DATA_ADDR; /* ->SCSI data buffer */
  72. Uint SCSI$L_DATA_LEN; /* SCSI data length, bytes */
  73. Uint SCSI$L_PAD_LEN;  /* SCSI pad length, bytes */
  74. Uint SCSI$L_PH_CH_TMOUT; /* SCSI phase change timeout */
  75. Uint SCSI$L_DISCON_TMOUT; /* SCSI disconnect timeout */
  76. Uint SCSI$L_RES_1; /* Reserved */
  77. Uint SCSI$L_RES_2; /* Reserved */
  78. Uint SCSI$L_RES_3; /* Reserved */
  79. Uint SCSI$L_RES_4; /* Reserved */
  80. Uint SCSI$L_RES_5; /* Reserved */
  81. Uint SCSI$L_RES_6; /* Reserved */
  82. };
  84. #ifdef __ALPHA
  85. #pragma member_alignment save
  86. #pragma nomember_alignment
  87. #endif
  89. struct SCSI$IOSB {
  90. Ushort SCSI$W_VMS_STAT; /* VMS status code */
  91. Ulong SCSI$L_IOSB_TFR_CNT; /* Actual #bytes transferred */
  92. char SCSI$B_IOSB_FILL_1;
  93. Uchar SCSI$B_IOSB_STS; /* SCSI device status */
  94. };
  96. #ifdef __ALPHA
  97. #pragma member_alignment restore
  98. #endif
  100. #define SCSI$K_GOOD_STATUS 0
  101. #define SCSI$K_CHECK_CONDITION 0x2
  102. #define SCSI$K_CONDITION_MET 0x4
  103. #define SCSI$K_BUSY 0x8
  104. #define SCSI$K_INTERMEDIATE 0x10
  105. #define SCSI$K_INTERMEDIATE_C_MET 0x14
  106. #define SCSI$K_RESERVATION_CONFLICT 0x18
  107. #define SCSI$K_COMMAND_TERMINATED 0x22
  108. #define SCSI$K_QUEUE_FULL 0x28
  111. #define SCSI$K_WRITE 0X0 /* direction of transfer=write */
  112. #define SCSI$K_READ 0X1 /* direction of transfer=read */
  113. #define SCSI$K_FL_ENAB_DIS 0X2 /* enable disconnects */
  114. #define SCSI$K_FL_ENAB_SYNC 0X4 /* enable sync */
  115. #define GK_EFN 0 /* Event flag number */
  117. static char gk_device[8]; /* XXX JS hoffentlich gibt es keinen Ueberlauf */
  118. static Ushort gk_chan;
  119. static Ushort transfer_length;
  120. static int i;
  121. static int status;
  122. static $DESCRIPTOR(gk_device_desc, gk_device);
  123. static struct SCSI$IOSB gk_iosb ;
  124. static struct SCSI$DESC gk_desc;
  125. static FILE *fp;
  128. struct scg_local {
  129. Ushort gk_chan;
  130. };
  131. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  133. /*
  134.  * Return version information for the low level SCSI transport code.
  135.  * This has been introduced to make it easier to trace down problems
  136.  * in applications.
  137.  */
  138. EXPORT char *
  139. scg__version(scgp, what)
  140. SCSI *scgp;
  141. int what;
  142. {
  143. if (scgp != (SCSI *)0) {
  144. switch (what) {
  146. case SCG_VERSION:
  147. return (_scg_trans_version);
  148. /*
  149.  * If you changed this source, you are not allowed to
  150.  * return "schily" for the SCG_AUTHOR request.
  151.  */
  152. case SCG_AUTHOR:
  153. return (_scg_auth_schily);
  154. case SCG_SCCS_ID:
  155. return (__sccsid);
  156. }
  157. }
  158. return ((char *)0);
  159. }
  161. EXPORT int
  162. scsi_open(scgp, device, busno, tgt, tlun)
  163. SCSI *scgp;
  164. char *device;
  165. int busno;
  166. int tgt;
  167. int tlun;
  168. {
  169. char devname[DEVICE_NAMELEN];
  170. char buschar;
  171. char buschar1;
  173. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  174. errno = EINVAL;
  175. if (scgp->errstr)
  176. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  177. "Illegal value for busno, target or lun '%d,%d,%d'",
  178. busno, tgt, tlun);
  179. return (-1);
  180. }
  182. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  183. errno = EINVAL;
  184. if (scgp->errstr)
  185. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  186. "Open by 'devname' not supported on this OS");
  187. return (-1);
  188. }
  190. if (scgp->local == NULL) {
  191. scgp->local = malloc(sizeof(struct scg_local));
  192. if (scgp->local == NULL)
  193. return (0);
  194. }
  196. switch (busno) {
  198. case 0: buschar = 'd';
  199. buschar1 = 'a';
  200. break;
  201. case 1: buschar = 'd';
  202. buschar1 = 'b';
  203. break;
  204. case 2: buschar = 'd';
  205. buschar1 = 'c';
  206. break;
  207. case 3: buschar = 'd';
  208. buschar1 = 'd';
  209. break;
  210. case 4: buschar = 'g';
  211. buschar1 = 'a';
  212. break;
  213. case 5: buschar = 'g';
  214. buschar1 = 'b';
  215. break;
  216. case 6: buschar = 'g';
  217. buschar1 = 'c';
  218. break;
  219. case 7: buschar = 'g';
  220. buschar1 = 'd';
  221. break;
  222. default :
  223. if (scgp->errstr)
  224. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  225. "Wrong scsibus-# (%d)", busno);
  226. return (-1);
  227. }
  228. /* XXX JS XXX devname length snprintf ??? */
  229. sprintf(devname, "%ck%c%d0%d:", buschar, buschar1, tgt, tlun);
  230. strcpy (gk_device, devname);
  231. status = sys$assign(&gk_device_desc, &gk_chan, 0, 0);
  232. if (!(status & 1)) {
  233. printf("Unable to access scsi-device "%s"n", &gk_device[0]);
  234. return (-1);
  235. }
  236. if (scgp->debug) {
  237. fp = fopen("cdrecord_io.log","w","rfm=stmlf","rat=cr");
  238. if (fp == NULL) {
  239. perror("Failing opening i/o-logfile");
  240. exit(SS$_NORMAL);
  241. }
  242. }
  243. return (status);
  244. }
  246. EXPORT int
  247. scsi_close(scgp)
  248. SCSI *scgp;
  249. {
  250. /*
  251.  * XXX close gk_chan ???
  252.  */
  253. return (0);
  254. }
  256. LOCAL long
  257. scsi_maxdma(scgp)
  258. SCSI *scgp;
  259. {
  260. return (MAX_DMA_VMS);
  261. }
  263. EXPORT
  264. BOOL scsi_havebus(scgp, busno)
  265. SCSI *scgp;
  266. int busno;
  267. {
  268. if (gk_chan <= 0)
  269. return (FALSE);
  270. return (TRUE);
  271. }
  273. EXPORT
  274. int scsi_fileno(scgp, busno, tgt, tlun)
  275. SCSI *scgp;
  276. int busno;
  277. int tgt;
  278. int tlun;
  279. {
  280. if (gk_chan <= 0)
  281. return (-1);
  282. return (gk_chan);
  283. }
  285. EXPORT int
  286. scsi_initiator_id(scgp)
  287. SCSI *scgp;
  288. {
  289. return (-1);
  290. }
  292. EXPORT
  293. int scsi_isatapi(scgp)
  294. SCSI *scgp;
  295. {
  296. return (FALSE);
  297. }
  299. EXPORT
  300. int scsireset(scgp)
  301. SCSI *scgp;
  302. {
  303. return (-1);
  304. }
  306. EXPORT void *
  307. scsi_getbuf(scgp, amt)
  308. SCSI *scgp;
  309. long amt;
  310. {
  311. if (amt <= 0 || amt > scsi_maxdma(scgp))
  312. return ((void *)0);
  313. if (scgp->debug)
  314. printf("scsi_getbuf: %ld bytesn", amt);
  315. scgp->bufbase = malloc((size_t)(amt)); /* XXX JS XXX valloc() ??? */
  316. return (scgp->bufbase);
  317. }
  319. EXPORT void
  320. scsi_freebuf(scgp)
  321. SCSI *scgp;
  322. {
  323. if (scgp->bufbase)
  324. free(scgp->bufbase);
  325. scgp->bufbase = NULL;
  326. }
  328. LOCAL int
  329. do_scsi_cmd(scgp, f, sp)
  330. SCSI *scgp;
  331. int f;
  332. struct scg_cmd *sp;
  333. {
  334. char *cmdadr;
  335. int notcmdretry;
  336. int len;
  337. int severity;
  339. /* XXX JS XXX This cannot be OK */
  340. notcmdretry = (sp->flags & SCG_CMD_RETRY)^SCG_CMD_RETRY;
  341. /* error corrected ehh */
  342. /* XXX JS Wenn das notcmdretry Flag bei VMS auch 0x08 ist und Du darauf hoffst,
  343.    XXX Dasz ich den Wert nie aendere, dann ist das richtig.
  344.    XXX Siehe unten: Das gleiche gilt fuer SCG_RECV_DATA und SCG_DISRE_ENA !!!
  345. */
  347. cmdadr = (char *)sp->cdb.cmd_cdb;
  348. /* XXX JS XXX This cannot be OK */
  349. gk_desc.SCSI$L_FLAGS = ((sp->flags & SCG_RECV_DATA) |
  350. (sp->flags & SCG_DISRE_ENA)|
  351. notcmdretry);
  352. /* XXX siehe oben, das ist ein bitweises oder!!! */
  353. gk_desc.SCSI$A_DATA_ADDR = sp->addr;
  354. gk_desc.SCSI$L_DATA_LEN = sp->size;
  355. gk_desc.SCSI$A_CMD_ADDR = cmdadr;
  356. gk_desc.SCSI$L_CMD_LEN = sp->cdb_len;
  357. gk_desc.SCSI$L_PH_CH_TMOUT = sp->timeout;
  358. gk_desc.SCSI$L_DISCON_TMOUT = sp->timeout;
  359.         if (gk_desc.SCSI$L_PH_CH_TMOUT > MAX_PHSTMO_VMS)
  360.             gk_desc.SCSI$L_PH_CH_TMOUT = MAX_PHSTMO_VMS;
  361.         if (gk_desc.SCSI$L_DISCON_TMOUT > MAX_DSCTMO_VMS)
  362.             gk_desc.SCSI$L_DISCON_TMOUT = MAX_DSCTMO_VMS;
  363. gk_desc.SCSI$L_OPCODE = 1; /* SCSI Operation Code */
  364. gk_desc.SCSI$L_PAD_LEN = 0; /* SCSI pad length, bytes */
  365. gk_desc.SCSI$L_RES_1 = 0; /* Reserved */
  366. gk_desc.SCSI$L_RES_2 = 0; /* Reserved */
  367. gk_desc.SCSI$L_RES_3 = 0; /* Reserved */
  368. gk_desc.SCSI$L_RES_4 = 0; /* Reserved */
  369. gk_desc.SCSI$L_RES_5 = 0; /* Reserved */
  370. gk_desc.SCSI$L_RES_6 = 0; /* Reserved */
  371. if (scgp->debug) {
  372. fprintf(fp, "***********************************************************n");
  373. fprintf(fp, "SCSI VMS-I/O parametersn");
  374. fprintf(fp, "OPCODE: %d", gk_desc.SCSI$L_OPCODE);
  375. fprintf(fp, " FLAGS: %dn", gk_desc.SCSI$L_FLAGS);
  376. fprintf(fp, "CMD:");
  377. for (i = 0; i < gk_desc.SCSI$L_CMD_LEN; i++) {
  378. fprintf(fp, "%x ", sp->cdb.cmd_cdb[i]);
  379. }
  380. fprintf(fp, "n");
  381. fprintf(fp, "DATA_LEN: %dn", gk_desc.SCSI$L_DATA_LEN);
  382. fprintf(fp, "PH_CH_TMOUT: %d", gk_desc.SCSI$L_PH_CH_TMOUT);
  383. fprintf(fp, " DISCON_TMOUT: %dn", gk_desc.SCSI$L_DISCON_TMOUT);
  384. }
  385. status = sys$qiow(GK_EFN, gk_chan, IO$_DIAGNOSE, &gk_iosb, 0, 0,
  386. &gk_desc, sizeof(gk_desc), 0, 0, 0, 0);
  388. if (scgp->debug) {
  389. fprintf(fp, "qiow-status: %in", status);
  390. fprintf(fp, "VMS status code %in",gk_iosb.SCSI$W_VMS_STAT);
  391. fprintf(fp, "Actual #bytes transferred %in",gk_iosb.SCSI$L_IOSB_TFR_CNT);
  392. fprintf(fp, "SCSI device status %in",gk_iosb.SCSI$B_IOSB_STS);
  393. if (gk_iosb.SCSI$L_IOSB_TFR_CNT != gk_desc.SCSI$L_DATA_LEN) {
  394. fprintf(fp,"#bytes transferred != DATA_LENn");
  395. }
  396. }
  398. if (!(status & 1)) { /* Fehlerindikation fuer sys$qiow() */
  399. sp->ux_errno = geterrno();
  400. /* schwerwiegender nicht SCSI bedingter Fehler => return(-1) */
  401. if (sp->ux_errno == ENOTTY || sp->ux_errno == ENXIO ||
  402.     sp->ux_errno == EINVAL || sp->ux_errno == EACCES) {
  403. return (-1);
  404. }
  405. } else {
  406. sp->ux_errno = 0;
  407. }
  409. sp->resid = gk_desc.SCSI$L_DATA_LEN - gk_iosb.SCSI$L_IOSB_TFR_CNT;
  411. if (gk_iosb.SCSI$W_VMS_STAT == SS$_NORMAL &&
  412.     gk_iosb.SCSI$B_IOSB_STS == 0) {
  414. sp->error = SCG_NO_ERROR;
  415. if (scgp->debug) {
  416. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS == 0n");
  417. fprintf(fp,"sp->error %in",sp->error);
  418. fprintf(fp,"sp->resid %in",sp->resid);
  419. }
  420. return(0);
  421. }
  423. severity = gk_iosb.SCSI$W_VMS_STAT & 0x7;
  425. if (severity == 4) {
  426. sp->error = SCG_FATAL;
  427. if (scgp->debug) {
  428. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  429. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT & 0x7 == SS$_FATALn");
  430. fprintf(fp,"sp->error %in",sp->error);
  431. }
  432. return (0);
  433. }
  434. if (gk_iosb.SCSI$W_VMS_STAT == SS$_TIMEOUT) {
  435. sp->error = SCG_TIMEOUT;
  436. if (scgp->debug) {
  437. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  438. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT == SS$_TIMEOUTn");
  439. fprintf(fp,"sp->error %in",sp->error);
  440. }
  441. return (0);
  442. }
  443. sp->error = SCG_RETRYABLE;
  444. sp->ux_errno = EIO;
  445. sp->u_scb.cmd_scb[0] = gk_iosb.SCSI$B_IOSB_STS;
  446. if (scgp->debug) {
  447. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  448. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT != 0n");
  449. fprintf(fp,"sp->error %in",sp->error);
  450. }
  451. return(0);
  452. }
  454. LOCAL int
  455. do_scsi_sense(scgp, f, sp)
  456. SCSI *scgp;
  457. int f;
  458. struct scg_cmd *sp;
  459. {
  460. int ret;
  461. struct scg_cmd s_cmd;
  463. if (sp->sense_len > SCG_MAX_SENSE)
  464. sp->sense_len = SCG_MAX_SENSE;
  466. fillbytes((caddr_t)&s_cmd, sizeof(s_cmd), '');
  467. s_cmd.addr = (char *)sp->u_sense.cmd_sense;
  468. s_cmd.size = sp->sense_len;
  469. s_cmd.flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  470. s_cmd.cdb_len = SC_G0_CDBLEN;
  471. s_cmd.sense_len = CCS_SENSE_LEN;
  472. s_cmd.target = scgp->target;
  473. s_cmd.cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
  474. s_cmd.cdb.g0_cdb.lun = sp->cdb.g0_cdb.lun;
  475. s_cmd.cdb.g0_cdb.count = sp->sense_len;
  476. ret = do_scsi_cmd(scgp, f, &s_cmd);
  478. if (ret < 0)
  479. return (ret);
  480. if (s_cmd.u_scb.cmd_scb[0] & 02) {
  481. /* XXX ??? Check condition on request Sense ??? */
  482. }
  483. sp->sense_count = sp->sense_len - s_cmd.resid;
  484. return (ret);
  485. }
  487. LOCAL int
  488. scsi_send(scgp, f, sp)
  489. SCSI *scgp;
  490. int f;
  491. struct scg_cmd *sp;
  492. {
  493. int ret;
  495. if (f < 0) {
  496. sp->error = SCG_FATAL;
  497. return (0);
  498. }
  499. ret = do_scsi_cmd(scgp, f, sp);
  500. if (ret < 0)
  501. return (ret);
  502. if (sp->u_scb.cmd_scb[0] & 02)
  503. ret = do_scsi_sense(scgp, f, sp);
  504. return (ret);
  505. }