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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-vms.c：源码内容
  1. /* @(#)scsi-vms.c 1.14 99/09/07 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-vms.c 1.14 99/09/07 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.  * Copyright (c) 1997 J. Schilling
  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. #include <iodef.h>
  31. #include <ssdef.h>
  32. #include <descrip.h>
  33. #include <starlet.h>
  34. #include <string.h>
  35. #include <LIB$ROUTINES.H>
  37. #define MAX_SCG  16 /* Max # of SCSI controllers */
  38. #define MAX_TGT  16
  39. #define MAX_LUN  8
  41. #define MAX_DMA_VMS (96*512)/* Check if this is not too big */
  42. #define MAX_PHSTMO_VMS 300
  43. #define MAX_DSCTMO_VMS 65535 /* max value for OpenVMS/AXP 7.1 ehh*/
  46. LOCAL int do_scsi_cmd __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  47. LOCAL int do_scsi_sense __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  49. #define DEVICE_NAMELEN 7
  51. struct SCSI$DESC {
  52. Uint SCSI$L_OPCODE; /* SCSI Operation Code */
  53. Uint SCSI$L_FLAGS; /* SCSI Flags Bit Map */
  54. char *SCSI$A_CMD_ADDR; /* ->SCSI command buffer */
  55. Uint SCSI$L_CMD_LEN;  /* SCSI command length, bytes */
  56. char *SCSI$A_DATA_ADDR; /* ->SCSI data buffer */
  57. Uint SCSI$L_DATA_LEN; /* SCSI data length, bytes */
  58. Uint SCSI$L_PAD_LEN;  /* SCSI pad length, bytes */
  59. Uint SCSI$L_PH_CH_TMOUT; /* SCSI phase change timeout */
  60. Uint SCSI$L_DISCON_TMOUT; /* SCSI disconnect timeout */
  61. Uint SCSI$L_RES_1; /* Reserved */
  62. Uint SCSI$L_RES_2; /* Reserved */
  63. Uint SCSI$L_RES_3; /* Reserved */
  64. Uint SCSI$L_RES_4; /* Reserved */
  65. Uint SCSI$L_RES_5; /* Reserved */
  66. Uint SCSI$L_RES_6; /* Reserved */
  67. };
  69. #ifdef __ALPHA
  70. #pragma member_alignment save
  71. #pragma nomember_alignment
  72. #endif
  74. struct SCSI$IOSB {
  75. Ushort SCSI$W_VMS_STAT; /* VMS status code */
  76. Ulong SCSI$L_IOSB_TFR_CNT; /* Actual #bytes transferred */
  77. char SCSI$B_IOSB_FILL_1;
  78. Uchar SCSI$B_IOSB_STS; /* SCSI device status */
  79. };
  81. #ifdef __ALPHA
  82. #pragma member_alignment restore
  83. #endif
  85. #define SCSI$K_GOOD_STATUS 0
  86. #define SCSI$K_CHECK_CONDITION 0x2
  87. #define SCSI$K_CONDITION_MET 0x4
  88. #define SCSI$K_BUSY 0x8
  89. #define SCSI$K_INTERMEDIATE 0x10
  90. #define SCSI$K_INTERMEDIATE_C_MET 0x14
  91. #define SCSI$K_RESERVATION_CONFLICT 0x18
  92. #define SCSI$K_COMMAND_TERMINATED 0x22
  93. #define SCSI$K_QUEUE_FULL 0x28
  96. #define SCSI$K_WRITE 0X0 /* direction of transfer=write */
  97. #define SCSI$K_READ 0X1 /* direction of transfer=read */
  98. #define SCSI$K_FL_ENAB_DIS 0X2 /* enable disconnects */
  99. #define SCSI$K_FL_ENAB_SYNC 0X4 /* enable sync */
  100. #define GK_EFN 0 /* Event flag number */
  102. static char gk_device[8]; /* XXX JS hoffentlich gibt es keinen Ueberlauf */
  103. static Ushort gk_chan;
  104. static Ushort transfer_length;
  105. static int i;
  106. static int status;
  107. static $DESCRIPTOR(gk_device_desc, gk_device);
  108. static struct SCSI$IOSB gk_iosb ;
  109. static struct SCSI$DESC gk_desc;
  110. static FILE *fp;
  113. struct scg_local {
  114. Ushort gk_chan;
  115. };
  116. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  118. EXPORT int
  119. scsi_open(scgp, device, busno, tgt, tlun)
  120. SCSI *scgp;
  121. char *device;
  122. int busno;
  123. int tgt;
  124. int tlun;
  125. {
  126. char devname[DEVICE_NAMELEN];
  127. char buschar;
  128. char buschar1;
  130. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  131. errno = EINVAL;
  132. if (scgp->errstr)
  133. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  134. "Illegal value for busno, target or lun '%d,%d,%d'",
  135. busno, tgt, tlun);
  136. return (-1);
  137. }
  139. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  140. errno = EINVAL;
  141. if (scgp->errstr)
  142. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  143. "Open by 'devname' not supported on this OS");
  144. return (-1);
  145. }
  147. if (scgp->local == NULL) {
  148. scgp->local = malloc(sizeof(struct scg_local));
  149. if (scgp->local == NULL)
  150. return (0);
  151. }
  153. switch (busno) {
  155. case 0: buschar = 'd';
  156. buschar1 = 'a';
  157. break;
  158. case 1: buschar = 'd';
  159. buschar1 = 'b';
  160. break;
  161. case 2: buschar = 'd';
  162. buschar1 = 'c';
  163. break;
  164. case 3: buschar = 'd';
  165. buschar1 = 'd';
  166. break;
  167. case 4: buschar = 'g';
  168. buschar1 = 'a';
  169. break;
  170. case 5: buschar = 'g';
  171. buschar1 = 'b';
  172. break;
  173. case 6: buschar = 'g';
  174. buschar1 = 'c';
  175. break;
  176. case 7: buschar = 'g';
  177. buschar1 = 'd';
  178. break;
  179. default :
  180. if (scgp->errstr)
  181. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  182. "Wrong scsibus-# (%d)", busno);
  183. return (-1);
  184. }
  185. /* XXX JS XXX devname length snprintf ??? */
  186. sprintf(devname, "%ck%c%d0%d:", buschar, buschar1, tgt, tlun);
  187. strcpy (gk_device, devname);
  188. status = sys$assign(&gk_device_desc, &gk_chan, 0, 0);
  189. if (!(status & 1)) {
  190. printf("Unable to access scsi-device "%s"n", &gk_device[0]);
  191. return (-1);
  192. }
  193. if (scgp->debug) {
  194. fp = fopen("cdrecord_io.log","w","rfm=stmlf","rat=cr");
  195. if (fp == NULL) {
  196. perror("Failing opening i/o-logfile");
  197. exit(SS$_NORMAL);
  198. }
  199. }
  200. return (status);
  201. }
  203. EXPORT int
  204. scsi_close(scgp)
  205. SCSI *scgp;
  206. {
  207. /*
  208.  * XXX close gk_chan ???
  209.  */
  210. return (0);
  211. }
  213. LOCAL long
  214. scsi_maxdma(scgp)
  215. SCSI *scgp;
  216. {
  217. return (MAX_DMA_VMS);
  218. }
  220. EXPORT
  221. BOOL scsi_havebus(scgp, busno)
  222. SCSI *scgp;
  223. int busno;
  224. {
  225. if (gk_chan <= 0)
  226. return (FALSE);
  227. return (TRUE);
  228. }
  230. EXPORT
  231. int scsi_fileno(scgp, busno, tgt, tlun)
  232. SCSI *scgp;
  233. int busno;
  234. int tgt;
  235. int tlun;
  236. {
  237. if (gk_chan <= 0)
  238. return (-1);
  239. return (gk_chan);
  240. }
  242. EXPORT int
  243. scsi_initiator_id(scgp)
  244. SCSI *scgp;
  245. {
  246. return (-1);
  247. }
  249. EXPORT
  250. int scsi_isatapi(scgp)
  251. SCSI *scgp;
  252. {
  253. return (FALSE);
  254. }
  256. EXPORT
  257. int scsireset(scgp)
  258. SCSI *scgp;
  259. {
  260. return (-1);
  261. }
  263. EXPORT void *
  264. scsi_getbuf(scgp, amt)
  265. SCSI *scgp;
  266. long amt;
  267. {
  268. if (amt <= 0 || amt > scsi_maxdma(scgp))
  269. return ((void *)0);
  270. if (scgp->debug)
  271. printf("scsi_getbuf: %ld bytesn", amt);
  272. scgp->bufbase = malloc((size_t)(amt)); /* XXX JS XXX valloc() ??? */
  273. return (scgp->bufbase);
  274. }
  276. EXPORT void
  277. scsi_freebuf(scgp)
  278. SCSI *scgp;
  279. {
  280. if (scgp->bufbase)
  281. free(scgp->bufbase);
  282. scgp->bufbase = NULL;
  283. }
  285. LOCAL int
  286. do_scsi_cmd(scgp, f, sp)
  287. SCSI *scgp;
  288. int f;
  289. struct scg_cmd *sp;
  290. {
  291. char *cmdadr;
  292. int notcmdretry;
  293. int len;
  294. int severity;
  296. /* XXX JS XXX This cannot be OK */
  297. notcmdretry = (sp->flags & SCG_CMD_RETRY)^SCG_CMD_RETRY;
  298. /* error corrected ehh */
  299. /* XXX JS Wenn das notcmdretry Flag bei VMS auch 0x08 ist und Du darauf hoffst,
  300.    XXX Dasz ich den Wert nie aendere, dann ist das richtig.
  301.    XXX Siehe unten: Das gleiche gilt fuer SCG_RECV_DATA und SCG_DISRE_ENA !!!
  302. */
  304. cmdadr = (char *)sp->cdb.cmd_cdb;
  305. /* XXX JS XXX This cannot be OK */
  306. gk_desc.SCSI$L_FLAGS = ((sp->flags & SCG_RECV_DATA) |
  307. (sp->flags & SCG_DISRE_ENA)|
  308. notcmdretry);
  309. /* XXX siehe oben, das ist ein bitweises oder!!! */
  310. gk_desc.SCSI$A_DATA_ADDR = sp->addr;
  311. gk_desc.SCSI$L_DATA_LEN = sp->size;
  312. gk_desc.SCSI$A_CMD_ADDR = cmdadr;
  313. gk_desc.SCSI$L_CMD_LEN = sp->cdb_len;
  314. gk_desc.SCSI$L_PH_CH_TMOUT = sp->timeout;
  315. gk_desc.SCSI$L_DISCON_TMOUT = sp->timeout;
  316.         if (gk_desc.SCSI$L_PH_CH_TMOUT > MAX_PHSTMO_VMS)
  317.             gk_desc.SCSI$L_PH_CH_TMOUT = MAX_PHSTMO_VMS;
  318.         if (gk_desc.SCSI$L_DISCON_TMOUT > MAX_DSCTMO_VMS)
  319.             gk_desc.SCSI$L_DISCON_TMOUT = MAX_DSCTMO_VMS;
  320. gk_desc.SCSI$L_OPCODE = 1; /* SCSI Operation Code */
  321. gk_desc.SCSI$L_PAD_LEN = 0; /* SCSI pad length, bytes */
  322. gk_desc.SCSI$L_RES_1 = 0; /* Reserved */
  323. gk_desc.SCSI$L_RES_2 = 0; /* Reserved */
  324. gk_desc.SCSI$L_RES_3 = 0; /* Reserved */
  325. gk_desc.SCSI$L_RES_4 = 0; /* Reserved */
  326. gk_desc.SCSI$L_RES_5 = 0; /* Reserved */
  327. gk_desc.SCSI$L_RES_6 = 0; /* Reserved */
  328. if (scgp->debug) {
  329. fprintf(fp, "***********************************************************n");
  330. fprintf(fp, "SCSI VMS-I/O parametersn");
  331. fprintf(fp, "OPCODE: %d", gk_desc.SCSI$L_OPCODE);
  332. fprintf(fp, " FLAGS: %dn", gk_desc.SCSI$L_FLAGS);
  333. fprintf(fp, "CMD:");
  334. for (i = 0; i < gk_desc.SCSI$L_CMD_LEN; i++) {
  335. fprintf(fp, "%x ", sp->cdb.cmd_cdb[i]);
  336. }
  337. fprintf(fp, "n");
  338. fprintf(fp, "DATA_LEN: %dn", gk_desc.SCSI$L_DATA_LEN);
  339. fprintf(fp, "PH_CH_TMOUT: %d", gk_desc.SCSI$L_PH_CH_TMOUT);
  340. fprintf(fp, " DISCON_TMOUT: %dn", gk_desc.SCSI$L_DISCON_TMOUT);
  341. }
  342. status = sys$qiow(GK_EFN, gk_chan, IO$_DIAGNOSE, &gk_iosb, 0, 0,
  343. &gk_desc, sizeof(gk_desc), 0, 0, 0, 0);
  345. if (scgp->debug) {
  346. fprintf(fp, "qiow-status: %in", status);
  347. fprintf(fp, "VMS status code %in",gk_iosb.SCSI$W_VMS_STAT);
  348. fprintf(fp, "Actual #bytes transferred %in",gk_iosb.SCSI$L_IOSB_TFR_CNT);
  349. fprintf(fp, "SCSI device status %in",gk_iosb.SCSI$B_IOSB_STS);
  350. if (gk_iosb.SCSI$L_IOSB_TFR_CNT != gk_desc.SCSI$L_DATA_LEN) {
  351. fprintf(fp,"#bytes transferred != DATA_LENn");
  352. }
  353. }
  355. if (!(status & 1)) { /* Fehlerindikation fuer sys$qiow() */
  356. sp->ux_errno = geterrno();
  357. /* schwerwiegender nicht SCSI bedingter Fehler => return(-1) */
  358. if (sp->ux_errno == ENOTTY || sp->ux_errno == ENXIO ||
  359.     sp->ux_errno == EINVAL || sp->ux_errno == EACCES) {
  360. return (-1);
  361. }
  362. } else {
  363. sp->ux_errno = 0;
  364. }
  366. sp->resid = gk_desc.SCSI$L_DATA_LEN - gk_iosb.SCSI$L_IOSB_TFR_CNT;
  368. if (gk_iosb.SCSI$W_VMS_STAT == SS$_NORMAL &&
  369.     gk_iosb.SCSI$B_IOSB_STS == 0) {
  371. sp->error = SCG_NO_ERROR;
  372. if (scgp->debug) {
  373. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS == 0n");
  374. fprintf(fp,"sp->error %in",sp->error);
  375. fprintf(fp,"sp->resid %in",sp->resid);
  376. }
  377. return(0);
  378. }
  380. severity = gk_iosb.SCSI$W_VMS_STAT & 0x7;
  382. if (severity == 4) {
  383. sp->error = SCG_FATAL;
  384. if (scgp->debug) {
  385. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  386. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT & 0x7 == SS$_FATALn");
  387. fprintf(fp,"sp->error %in",sp->error);
  388. }
  389. return (0);
  390. }
  391. if (gk_iosb.SCSI$W_VMS_STAT == SS$_TIMEOUT) {
  392. sp->error = SCG_TIMEOUT;
  393. if (scgp->debug) {
  394. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  395. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT == SS$_TIMEOUTn");
  396. fprintf(fp,"sp->error %in",sp->error);
  397. }
  398. return (0);
  399. }
  400. sp->error = SCG_RETRYABLE;
  401. sp->ux_errno = EIO;
  402. sp->u_scb.cmd_scb[0] = gk_iosb.SCSI$B_IOSB_STS;
  403. if (scgp->debug) {
  404. fprintf(fp,"gk_iosb.SCSI$B_IOSB_STS & 2n");
  405. fprintf(fp,"gk_iosb.SCSI$W_VMS_STAT != 0n");
  406. fprintf(fp,"sp->error %in",sp->error);
  407. }
  408. return(0);
  409. }
  411. LOCAL int
  412. do_scsi_sense(scgp, f, sp)
  413. SCSI *scgp;
  414. int f;
  415. struct scg_cmd *sp;
  416. {
  417. int ret;
  418. struct scg_cmd s_cmd;
  420. if (sp->sense_len > SCG_MAX_SENSE)
  421. sp->sense_len = SCG_MAX_SENSE;
  423. fillbytes((caddr_t)&s_cmd, sizeof(s_cmd), '');
  424. s_cmd.addr = (char *)sp->u_sense.cmd_sense;
  425. s_cmd.size = sp->sense_len;
  426. s_cmd.flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  427. s_cmd.cdb_len = SC_G0_CDBLEN;
  428. s_cmd.sense_len = CCS_SENSE_LEN;
  429. s_cmd.target = scgp->target;
  430. s_cmd.cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
  431. s_cmd.cdb.g0_cdb.lun = sp->cdb.g0_cdb.lun;
  432. s_cmd.cdb.g0_cdb.count = sp->sense_len;
  433. ret = do_scsi_cmd(scgp, f, &s_cmd);
  435. if (ret < 0)
  436. return (ret);
  437. if (s_cmd.u_scb.cmd_scb[0] & 02) {
  438. /* XXX ??? Check condition on request Sense ??? */
  439. }
  440. sp->sense_count = sp->sense_len - s_cmd.resid;
  441. return (ret);
  442. }
  444. LOCAL int
  445. scsi_send(scgp, f, sp)
  446. SCSI *scgp;
  447. int f;
  448. struct scg_cmd *sp;
  449. {
  450. int ret;
  452. if (f < 0) {
  453. sp->error = SCG_FATAL;
  454. return (0);
  455. }
  456. ret = do_scsi_cmd(scgp, f, sp);
  457. if (ret < 0)
  458. return (ret);
  459. if (sp->u_scb.cmd_scb[0] & 02)
  460. ret = do_scsi_sense(scgp, f, sp);
  461. return (ret);
  462. }