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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-sgi.c：源码内容
  1. /* @(#)scsi-sgi.c 1.19 99/09/17 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-sgi.c 1.19 99/09/17 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * Interface for the SGI generic SCSI implementation.
  8.  *
  9.  * First Hacky implementation
  10.  * (needed libds, did not support bus scanning and had no error checking)
  11.  * from "Frank van Beek" <frank@neogeo.nl>
  12.  *
  13.  * Actual implementation supports all scg features.
  14.  *
  15.  * Warning: you may change this source, but if you do that
  16.  * you need to change the _scg_version and _scg_auth* string below.
  17.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  18.  * Choose your name instead of "schily" and make clear that the version
  19.  * string is related to a modified source.
  20.  *
  21.  * Copyright (c) 1997 J. Schilling
  22.  */
  23. /*
  24.  * This program is free software; you can redistribute it and/or modify
  25.  * it under the terms of the GNU General Public License as published by
  26.  * the Free Software Foundation; either version 2, or (at your option)
  27.  * any later version.
  28.  *
  29.  * This program is distributed in the hope that it will be useful,
  30.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32.  * GNU General Public License for more details.
  33.  *
  34.  * You should have received a copy of the GNU General Public License
  35.  * along with this program; see the file COPYING.  If not, write to
  36.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  37.  */
  39. #include <dslib.h>
  41. /*
  42.  * Warning: you may change this source, but if you do that
  43.  * you need to change the _scg_version and _scg_auth* string below.
  44.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  45.  * Choose your name instead of "schily" and make clear that the version
  46.  * string is related to a modified source.
  47.  */
  48. LOCAL char _scg_trans_version[] = "scsi-sgi.c-1.19"; /* The version for this transport*/
  50. #ifdef USE_DSLIB
  52. struct dsreq * dsp = 0;
  53. #define MAX_SCG 1 /* Max # of SCSI controllers */
  55. #else
  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. #endif
  68. #define MAX_DMA_SGI (256*1024) /* Check if this is not too big */
  71. #ifndef USE_DSLIB
  72. LOCAL int scsi_sendreq __PR((SCSI *scgp, int f, struct scg_cmd *sp, struct dsreq *dsp));
  73. #endif
  76. /*
  77.  * Return version information for the low level SCSI transport code.
  78.  * This has been introduced to make it easier to trace down problems
  79.  * in applications.
  80.  */
  81. EXPORT char *
  82. scg__version(scgp, what)
  83. SCSI *scgp;
  84. int what;
  85. {
  86. if (scgp != (SCSI *)0) {
  87. switch (what) {
  89. case SCG_VERSION:
  90. return (_scg_trans_version);
  91. /*
  92.  * If you changed this source, you are not allowed to
  93.  * return "schily" for the SCG_AUTHOR request.
  94.  */
  95. case SCG_AUTHOR:
  96. return (_scg_auth_schily);
  97. case SCG_SCCS_ID:
  98. return (__sccsid);
  99. }
  100. }
  101. return ((char *)0);
  102. }
  104. EXPORT int
  105. scsi_open(scgp, device, busno, tgt, tlun)
  106. SCSI *scgp;
  107. char *device;
  108. int busno;
  109. int tgt;
  110. int tlun;
  111. {
  112. register int f;
  113. register int b;
  114. register int t;
  115. register int l;
  116. register int nopen = 0;
  117. char devname[64];
  119. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  120. errno = EINVAL;
  121. if (scgp->errstr)
  122. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  123. "Illegal value for busno, target or lun '%d,%d,%d'",
  124. busno, tgt, tlun);
  125. return (-1);
  126. }
  128. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  129. errno = EINVAL;
  130. if (scgp->errstr)
  131. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  132. "Open by 'devname' not supported on this OS");
  133. return (-1);
  134. }
  136. if (scgp->local == NULL) {
  137. scgp->local = malloc(sizeof(struct scg_local));
  138. if (scgp->local == NULL)
  139. return (0);
  141. for (b=0; b < MAX_SCG; b++) {
  142. for (t=0; t < MAX_TGT; t++) {
  143. for (l=0; l < MAX_LUN ; l++)
  144. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  145. }
  146. }
  147. }
  149. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  151. sprintf(devname, "/dev/scsi/sc%dd%dl%d", busno, tgt, tlun);
  152. #ifdef USE_DSLIB
  153. dsp = dsopen(devname, O_RDWR);
  154. if (dsp == 0)
  155. return(-1);
  156. #else
  157. f = open(devname, O_RDWR);
  158. if (f < 0)
  159. return(-1);
  160. scglocal(scgp)->scgfiles[busno][tgt][tlun] = f;
  161. #endif
  162. return(1);
  163. } else {
  164. #ifdef USE_DSLIB
  165. return(-1);
  166. #else
  167. for (b=0; b < MAX_SCG; b++) {
  168. for (t=0; t < MAX_TGT; t++) {
  169. /* for (l=0; l < MAX_LUN ; l++) {*/
  170. for (l=0; l < 1 ; l++) {
  171. sprintf(devname, "/dev/scsi/sc%dd%dl%d", b, t, l);
  172. f = open(devname, O_RDWR);
  173. if (f >= 0) {
  174. scglocal(scgp)->scgfiles[b][t][l] = (short)f;
  175. nopen++;
  176. }
  177. }
  178. }
  179. }
  180. #endif
  181. }
  182. return (nopen);
  183. }
  185. EXPORT int
  186. scsi_close(scgp)
  187. SCSI *scgp;
  188. {
  189. #ifndef USE_DSLIB
  190. register int f;
  191. register int b;
  192. register int t;
  193. register int l;
  195. if (scgp->local == NULL)
  196. return (-1);
  198. for (b=0; b < MAX_SCG; b++) {
  199. for (t=0; t < MAX_TGT; t++) {
  200. for (l=0; l < MAX_LUN ; l++)
  201. f = scglocal(scgp)->scgfiles[b][t][l];
  202. if (f >= 0)
  203. close(f);
  204. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  205. }
  206. }
  207. #else
  208. dsclose(dsp);
  209. #endif
  210. return (0);
  211. }
  213. LOCAL long
  214. scsi_maxdma(scgp)
  215. SCSI *scgp;
  216. {
  217. return (MAX_DMA_SGI);
  218. }
  220. EXPORT void *
  221. scsi_getbuf(scgp, amt)
  222. SCSI *scgp;
  223. long amt;
  224. {
  225. if (amt <= 0 || amt > scsi_maxdma(scgp))
  226. return ((void *)0);
  227. if (scgp->debug)
  228. printf("scsi_getbuf: %ld bytesn", amt);
  229. scgp->bufbase = valloc((size_t)(amt));
  230. return (scgp->bufbase);
  231. }
  233. EXPORT void
  234. scsi_freebuf(scgp)
  235. SCSI *scgp;
  236. {
  237. if (scgp->bufbase)
  238. free(scgp->bufbase);
  239. scgp->bufbase = NULL;
  240. }
  242. EXPORT
  243. BOOL scsi_havebus(scgp, busno)
  244. SCSI *scgp;
  245. int busno;
  246. {
  247. register int t;
  248. register int l;
  250. if (busno < 0 || busno >= MAX_SCG)
  251. return (FALSE);
  253. if (scgp->local == NULL)
  254. return (FALSE);
  256. for (t=0; t < MAX_TGT; t++) {
  257. for (l=0; l < MAX_LUN ; l++)
  258. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  259. return (TRUE);
  260. }
  261. return (FALSE);
  262. }
  264. EXPORT
  265. int scsi_fileno(scgp, busno, tgt, tlun)
  266. SCSI *scgp;
  267. int busno;
  268. int tgt;
  269. int tlun;
  270. {
  271. #ifdef USE_DSLIB
  272. if (dsp == NULL)
  273. return (-1);
  274. return (getfd(dsp));
  275. #else
  276. if (busno < 0 || busno >= MAX_SCG ||
  277.     tgt < 0 || tgt >= MAX_TGT ||
  278.     tlun < 0 || tlun >= MAX_LUN)
  279. return (-1);
  281. if (scgp->local == NULL)
  282. return (-1);
  284. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  285. #endif
  286. }
  288. EXPORT int
  289. scsi_initiator_id(scgp)
  290. SCSI *scgp;
  291. {
  292. return (-1);
  293. }
  295. EXPORT
  296. int scsi_isatapi(scgp)
  297. SCSI *scgp;
  298. {
  299. return (FALSE);
  300. }
  302. EXPORT
  303. int scsireset(scgp)
  304. SCSI *scgp;
  305. {
  306. /*
  307.  * Do we have a SCSI reset on SGI?
  308.  */
  309. #ifdef DS_RESET
  310. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  312. return (ioctl(f, DS_RESET, 0));
  313. #else
  314. return (-1);
  315. #endif
  316. }
  318. #ifndef USE_DSLIB
  319. LOCAL int
  320. scsi_sendreq(scgp, f, sp, dsp)
  321. SCSI *scgp;
  322. int f;
  323. struct scg_cmd *sp;
  324. struct dsreq *dsp;
  325. {
  326. int ret;
  327. int retries = 4;
  328. u_char status;
  330. /* if ((sp->flags & SCG_CMD_RETRY) == 0)*/
  331. /* retries = 0;*/
  333. while (--retries > 0) {
  334. ret = ioctl(f, DS_ENTER, dsp);
  335. if (ret < 0)  {
  336. RET(dsp) = DSRT_DEVSCSI;
  337. return (-1);
  338. }
  339. /*
  340.  * SGI implementattion botch!!!
  341.  * If a target does not select the bus,
  342.  * the return code is DSRT_TIMEOUT
  343.  */
  344. if (RET(dsp) == DSRT_TIMEOUT) {
  345. struct timeval to;
  347. to.tv_sec = TIME(dsp)/1000;
  348. to.tv_usec = TIME(dsp)%1000;
  349. scsitimes(scgp);
  351. if (sp->cdb.g0_cdb.cmd == SC_TEST_UNIT_READY &&
  352.     scgp->cmdstop->tv_sec < to.tv_sec ||
  353.     (scgp->cmdstop->tv_sec == to.tv_sec &&
  354. scgp->cmdstop->tv_usec < to.tv_usec)) {
  356. RET(dsp) = DSRT_NOSEL;
  357. return (-1);
  358. }
  359. }
  360. if (RET(dsp) == DSRT_NOSEL)
  361. continue; /* retry noselect 3X */
  363. status = STATUS(dsp);
  364. switch (status) {
  366. case 0x08: /*  BUSY */
  367. case 0x18: /*  RESERV CONFLICT */
  368. if (retries > 0)
  369. sleep(2);
  370. continue;
  371. case 0x00: /*  GOOD */
  372. case 0x02: /*  CHECK CONDITION */
  373. case 0x10: /*  INTERM/GOOD */
  374. default:
  375. return (status);
  376. }
  377. }
  378. return (-1); /* failed retry limit */
  379. }
  380. #endif
  382. LOCAL int
  383. scsi_send(scgp, f, sp)
  384. SCSI *scgp;
  385. int f;
  386. struct scg_cmd *sp;
  387. {
  388. int ret;
  389. int i;
  390. int amt = sp->cdb_len;
  391. int flags;
  392. #ifndef USE_DSLIB
  393. struct dsreq ds;
  394. struct dsreq *dsp = &ds;
  396. dsp->ds_iovbuf = 0;
  397. dsp->ds_iovlen = 0;
  398. #endif
  400. if (f < 0) {
  401. sp->error = SCG_FATAL;
  402. return (0);
  403. }
  405. flags = DSRQ_SENSE;
  406. if (sp->flags & SCG_RECV_DATA)
  407. flags |= DSRQ_READ;
  408. else if (sp->size > 0)
  409. flags |= DSRQ_WRITE;
  411. dsp->ds_flags = flags;
  412. dsp->ds_link = 0;
  413. dsp->ds_synch = 0;
  414. dsp->ds_ret   = 0;
  416. DATABUF(dsp)  = sp->addr;
  417. DATALEN(dsp) = sp->size;
  418. CMDBUF(dsp) = (void *) &sp->cdb;
  419. CMDLEN(dsp) = sp->cdb_len;
  420. SENSEBUF(dsp) = sp->u_sense.cmd_sense;
  421. SENSELEN(dsp) = sizeof (sp->u_sense.cmd_sense);
  422. TIME(dsp) = (sp->timeout * 1000) + 100;
  424. errno = 0;
  425. sp->ux_errno = 0;
  426. sp->sense_count = 0;
  428. #ifdef USE_DSLIB
  429. ret = doscsireq(f, dsp);
  430. #else
  431. ret = scsi_sendreq(scgp, f, sp, dsp);
  432. #endif
  434. if (RET(dsp) != DSRT_DEVSCSI)
  435. ret = 0;
  437. if (RET(dsp)) {
  438. if (RET(dsp) == DSRT_SHORT) {
  439. sp->resid = DATALEN(dsp)- DATASENT(dsp);
  440. } else if (errno) {
  441. sp->ux_errno = errno;
  442. } else {
  443. sp->ux_errno = EIO;
  444. }
  446. sp->u_scb.cmd_scb[0] = STATUS(dsp);
  448. sp->sense_count = SENSESENT(dsp);
  449. if (sp->sense_count > SCG_MAX_SENSE)
  450. sp->sense_count = SCG_MAX_SENSE;
  452. }
  453. switch(RET(dsp)) {
  455. default:
  456. sp->error = SCG_RETRYABLE; break;
  458. case 0: /* OK         */
  459. case DSRT_SHORT: /* not implemented        */
  460. sp->error = SCG_NO_ERROR; break;
  462. case DSRT_UNIMPL: /* not implemented        */
  463. case DSRT_REVCODE: /* software obsolete must recompile   */
  464. case DSRT_NOSEL:
  465. sp->u_scb.cmd_scb[0] = 0;
  466. sp->error = SCG_FATAL; break;
  468. case DSRT_TIMEOUT:
  469. sp->u_scb.cmd_scb[0] = 0;
  470. sp->error = SCG_TIMEOUT; break;
  471. }
  472. return (ret);
  473. }