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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsitransp.c：源码内容
  1. /* @(#)scsitransp.c 1.48 99/11/12 Copyright 1988,1995 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)scsitransp.c 1.48 99/11/12 Copyright 1988,1995 J. Schilling";
  5. #endif
  6. /*
  7.  * SCSI user level command transport routines for
  8.  * the SCSI general driver 'scg'.
  9.  *
  10.  * Warning: you may change this source, but if you do that
  11.  * you need to change the _scg_version and _scg_auth* string below.
  12.  * Choose your name instead of "schily" and make clear that the version
  13.  * string is related to a modified source.
  14.  *
  15.  * Copyright (c) 1988,1995 J. Schilling
  16.  */
  17. /*
  18.  * This program is free software; you can redistribute it and/or modify
  19.  * it under the terms of the GNU General Public License as published by
  20.  * the Free Software Foundation; either version 2, or (at your option)
  21.  * any later version.
  22.  *
  23.  * This program is distributed in the hope that it will be useful,
  24.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26.  * GNU General Public License for more details.
  27.  *
  28.  * You should have received a copy of the GNU General Public License
  29.  * along with this program; see the file COPYING.  If not, write to
  30.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  31.  */
  33. #include <mconfig.h>
  35. #ifdef HAVE_SYS_PARAM_H
  36. #include <sys/param.h> /* XXX nonportable to use u_char */
  37. #endif
  38. #include <stdio.h>
  39. #include <standard.h>
  40. #include <stdxlib.h>
  41. #include <unixstd.h>
  42. #include <errno.h>
  43. #include <timedefs.h>
  44. #include <sys/ioctl.h>
  45. #include <fctldefs.h>
  47. #include <scg/scgio.h>
  48. #include <scg/scsireg.h>
  49. #include <scg/scsitransp.h>
  51. #ifdef sun
  52. # define HAVE_SCG /* Currently only on SunOS/Solaris */
  53. #endif
  55. /*
  56.  * Warning: you may change this source, but if you do that
  57.  * you need to change the _scg_version and _scg_auth* string below.
  58.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  59.  * Choose your name instead of "schily" and make clear that the version
  60.  * string is related to a modified source.
  61.  */
  62. LOCAL char _scg_version[] = "0.1"; /* The global libscg version */
  63. LOCAL char _scg_auth_schily[] = "schily"; /* The author for this module */
  64. #ifdef HAVE_SCG
  65. LOCAL char _scg_trans_version[] = "scg-1.48"; /* The version for /dev/scg */
  66. #endif
  68. #define DEFTIMEOUT 20 /* Default timeout for SCSI command transport */
  70. /*
  71.  * Need to move this into an scg driver ioctl.
  72.  */
  73. /*#define MAX_DMA_SUN4M (1024*1024)*/
  74. #define MAX_DMA_SUN4M (124*1024) /* Currently max working size */
  75. /*#define MAX_DMA_SUN4C (126*1024)*/
  76. #define MAX_DMA_SUN4C (124*1024) /* Currently max working size */
  77. #define MAX_DMA_SUN3 (63*1024)
  78. #define MAX_DMA_SUN386 (56*1024)
  79. #define MAX_DMA_OTHER (32*1024)
  81. #define ARCH_MASK 0xF0
  82. #define ARCH_SUN2 0x00
  83. #define ARCH_SUN3 0x10
  84. #define ARCH_SUN4 0x20
  85. #define ARCH_SUN386 0x30
  86. #define ARCH_SUN3X 0x40
  87. #define ARCH_SUN4C 0x50
  88. #define ARCH_SUN4E 0x60
  89. #define ARCH_SUN4M 0x70
  90. #define ARCH_SUNX 0x80
  92. EXPORT char *scg_version __PR((SCSI *scgp, int what));
  93. EXPORT char *scg__version __PR((SCSI *scgp, int what));
  94. EXPORT int scsi_open __PR((SCSI *scgp, char *device, int busno, int tgt, int tlun));
  95. EXPORT int scsi_close __PR((SCSI *scgp));
  96. LOCAL long scsi_maxdma __PR((SCSI *scgp));
  97. EXPORT BOOL scsi_havebus __PR((SCSI *scgp, int));
  98. EXPORT int scsi_fileno __PR((SCSI *scgp, int, int, int));
  99. EXPORT int scsi_initiator_id __PR((SCSI *scgp));
  100. EXPORT int scsi_isatapi __PR((SCSI *scgp));
  101. EXPORT int scsireset __PR((SCSI *scgp));
  102. EXPORT void *scsi_getbuf __PR((SCSI *scgp, long));
  103. EXPORT void scsi_freebuf __PR((SCSI *scgp));
  104. EXPORT long scsi_bufsize __PR((SCSI *scgp, long));
  105. EXPORT void scsi_setnonstderrs __PR((SCSI *scgp, const char **));
  106. EXPORT BOOL scsi_yes __PR((char *));
  107. #ifdef nonono
  108. LOCAL void scsi_sighandler __PR((int));
  109. #endif
  110. EXPORT int scsicmd __PR((SCSI *scgp));
  111. EXPORT int scsigetresid __PR((SCSI *scgp));
  112. LOCAL void scsitimes __PR((SCSI *scgp));
  113. LOCAL BOOL scsierr __PR((SCSI *scgp));
  114. LOCAL int scsicheckerr __PR((SCSI *scgp));
  115. EXPORT void scsiprinterr __PR((SCSI *scgp));
  116. EXPORT void scsiprintcdb __PR((SCSI *scgp));
  117. EXPORT void scsiprintwdata __PR((SCSI *scgp));
  118. EXPORT void scsiprintrdata __PR((SCSI *scgp));
  119. EXPORT void scsiprintresult __PR((SCSI *scgp));
  120. EXPORT void scsiprintstatus __PR((SCSI *scgp));
  121. EXPORT void scsiprbytes __PR((char *, unsigned char *, int));
  122. EXPORT void scsiprsense __PR((unsigned char *, int));
  123. EXPORT int scsi_sense_key __PR((SCSI *scgp));
  124. EXPORT int scsi_sense_code __PR((SCSI *scgp));
  125. EXPORT int scsi_sense_qual __PR((SCSI *scgp));
  126. EXPORT void scsiprintdev __PR((struct scsi_inquiry *));
  128. #ifdef HAVE_SCG
  129. # include <libport.h> /* Needed for gethostid() */
  130. #ifdef sun
  131. #ifdef HAVE_SUN_DKIO_H
  132. # include <sun/dkio.h>
  134. # define dk_cinfo dk_conf
  135. # define dki_slave dkc_slave
  136. # define DKIO_GETCINFO DKIOCGCONF
  137. #endif
  138. #ifdef HAVE_SYS_DKIO_H
  139. # include <sys/dkio.h>
  141. # define DKIO_GETCINFO DKIOCINFO
  142. #endif
  144. #define TARGET(slave) ((slave >> 3) & 07)
  146. #endif /* sun */
  147. /*
  148.  * We are using a "real" /dev/scg?
  149.  */
  150. # define scsi_send(scgp, f, cmdp) ioctl((f), SCGIO_CMD, (cmdp))
  151. # define MAX_SCG 16 /* Max # of SCSI controllers */
  153. struct scg_local {
  154. int scgfiles[MAX_SCG];
  155. };
  156. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  157. #define scgfiles(p) ((int *)((p)->local)) 
  159. #else
  160. /*
  161.  * We are emulating the functionality of /dev/scg? with the local
  162.  * SCSI user land implementation.
  163.  */
  164. # include "scsihack.c"
  166. #endif /* HAVE_SCG */
  168. /*
  169.  * Return version information for the SCSI transport code.
  170.  * This has been introduced to make it easier to trace down problems
  171.  * in applications.
  172.  *
  173.  * If scgp is NULL, return general library version information.
  174.  * If scgp is != NULL, return version information for the low level transport.
  175.  */
  176. EXPORT char *
  177. scg_version(scgp, what)
  178. SCSI *scgp;
  179. int what;
  180. {
  181. if (scgp == (SCSI *)0) {
  182. switch (what) {
  184. case SCG_VERSION:
  185. return (_scg_version);
  186. /*
  187.  * If you changed this source, you are not allowed to
  188.  * return "schily" for the SCG_AUTHOR request.
  189.  */
  190. case SCG_AUTHOR:
  191. return (_scg_auth_schily);
  192. case SCG_SCCS_ID:
  193. return (sccsid);
  194. default:
  195. return ((char *)0);
  196. }
  197. }
  198. return (scg__version(scgp, what));
  199. }
  201. #ifdef HAVE_SCG
  203. /*
  204.  * Return version information for the low level SCSI transport code.
  205.  * This has been introduced to make it easier to trace down problems
  206.  * in applications.
  207.  */
  208. EXPORT char *
  209. scg__version(scgp, what)
  210. SCSI *scgp;
  211. int what;
  212. {
  213. if (scgp != (SCSI *)0) {
  214. switch (what) {
  216. case SCG_VERSION:
  217. return (_scg_trans_version);
  218. /*
  219.  * If you changed this source, you are not allowed to
  220.  * return "schily" for the SCG_AUTHOR request.
  221.  */
  222. case SCG_AUTHOR:
  223. return (_scg_auth_schily);
  224. case SCG_SCCS_ID:
  225. return (sccsid);
  226. }
  227. }
  228. return ((char *)0);
  229. }
  231. EXPORT int
  232. scsi_open(scgp, device, busno, tgt, tlun)
  233. SCSI *scgp;
  234. char *device;
  235. int busno;
  236. int tgt;
  237. int tlun;
  238. {
  239. register int f;
  240. register int i;
  241. register int nopen = 0;
  242. char devname[32];
  244. if (busno >= MAX_SCG) {
  245. errno = EINVAL;
  246. if (scgp->errstr)
  247. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  248. "Illegal value for busno '%d'", busno);
  249. return (-1);
  250. }
  252. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  253. errno = EINVAL;
  254. if (scgp->errstr)
  255. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  256. "Open by 'devname' not supported on this OS");
  257. return (-1);
  258. }
  260. if (scgp->local == NULL) {
  261. scgp->local = malloc(sizeof(struct scg_local));
  262. if (scgp->local == NULL) {
  263. if (scgp->errstr)
  264. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE, "No memory for scg_local");
  265. return (0);
  266. }
  268. for (i=0; i < MAX_SCG; i++) {
  269. scgfiles(scgp)[i] = -1;
  270. }
  271. }
  274. for (i=0; i < MAX_SCG; i++) {
  275. sprintf(devname, "/dev/scg%d", i);
  276. f = open(devname, 2);
  277. if (f < 0) {
  278. if (errno != ENOENT && errno != ENXIO) {
  279. if (scgp->errstr)
  280. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  281. "Cannot open '%s'", devname);
  282. return (-1);
  283. }
  284. } else {
  285. nopen++;
  286. }
  287. scgfiles(scgp)[i] = f;
  288. }
  289. return (nopen);
  290. }
  292. EXPORT int
  293. scsi_close(scgp)
  294. SCSI *scgp;
  295. {
  296. register int i;
  298. if (scgfiles(scgp) == NULL)
  299. return (-1);
  301. for (i=0; i < MAX_SCG; i++) {
  302. if (scgfiles(scgp)[i] >= 0)
  303. close(scgfiles(scgp)[i]);
  304. scgfiles(scgp)[i] = -1;
  305. }
  306. return (0);
  307. }
  309. LOCAL long
  310. scsi_maxdma(scgp)
  311. SCSI *scgp;
  312. {
  313. long maxdma = 0L;
  315. #ifdef sun
  316. #if defined(__i386_) || defined(i386)
  317. return (MAX_DMA_SUN386);
  318. #else
  319. int cpu_type = gethostid() >> 24;
  321. switch (cpu_type & ARCH_MASK) {
  323. case ARCH_SUN4C:
  324. case ARCH_SUN4E:
  325. maxdma = MAX_DMA_SUN4C;
  326. break;
  328. case ARCH_SUN4M:
  329. case ARCH_SUNX:
  330. maxdma = MAX_DMA_SUN4M;
  331. break;
  333. default:
  334. maxdma = MAX_DMA_SUN3;
  335. }
  336. #endif /* sun */
  337. #else
  338. maxdma = MAX_DMA_OTHER;
  339. #endif
  341. #ifndef __SVR4
  342. /*
  343.  * SunOS 4.x allows esp hardware on VME boards and thus
  344.  * limits DMA on esp to 64k-1
  345.  */
  346. if (maxdma > MAX_DMA_SUN3)
  347. maxdma = MAX_DMA_SUN3;
  348. #endif
  349. return (maxdma);
  350. }
  352. EXPORT
  353. BOOL scsi_havebus(scgp, busno)
  354. SCSI *scgp;
  355. int busno;
  356. {
  357. if (scgfiles(scgp) == NULL)
  358. return (FALSE);
  359. return (busno < 0 || busno >= MAX_SCG) ? FALSE : (scgfiles(scgp)[busno] >= 0);
  360. }
  362. EXPORT
  363. int scsi_fileno(scgp, busno, tgt, tlun)
  364. SCSI *scgp;
  365. int busno;
  366. int tgt;
  367. int tlun;
  368. {
  369. if (scgfiles(scgp) == NULL)
  370. return (-1);
  371. return (busno < 0 || busno >= MAX_SCG) ? -1 : scgfiles(scgp)[busno];
  372. }
  374. EXPORT int
  375. scsi_initiator_id(scgp)
  376. SCSI *scgp;
  377. {
  378. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  379. int id = -1;
  380. #ifdef DKIO_GETCINFO
  381. struct dk_cinfo conf;
  383. if (ioctl(f, DKIO_GETCINFO, &conf) < 0)
  384. return (id);
  385. if (TARGET(conf.dki_slave) != -1)
  386. id = TARGET(conf.dki_slave);
  387. #endif
  388. return (id);
  389. }
  391. EXPORT
  392. int scsi_isatapi(scgp)
  393. SCSI *scgp;
  394. {
  395. return (FALSE);
  396. }
  398. EXPORT
  399. int scsireset(scgp)
  400. SCSI *scgp;
  401. {
  402. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  404. return (ioctl(f, SCGIORESET, 0));
  405. }
  407. EXPORT void *
  408. scsi_getbuf(scgp, amt)
  409. SCSI *scgp;
  410. long amt;
  411. {
  412. if (amt <= 0 || amt > scsi_maxdma(scgp))
  413. return ((void *)0);
  414. scgp->bufbase = (void *)valloc((size_t)amt);
  415. return (scgp->bufbase);
  416. }
  418. EXPORT void
  419. scsi_freebuf(scgp)
  420. SCSI *scgp;
  421. {
  422. if (scgp->bufbase)
  423. free(scgp->bufbase);
  424. scgp->bufbase = NULL;
  425. }
  427. #endif /* HAVE_SCG */
  429. EXPORT long
  430. scsi_bufsize(scgp, amt)
  431. SCSI *scgp;
  432. long amt;
  433. {
  434. long maxdma;
  436. maxdma = scsi_maxdma(scgp);
  438. if (amt <= 0 || amt > maxdma)
  439. return (maxdma);
  440. return (amt);
  441. }
  443. EXPORT void
  444. scsi_setnonstderrs(scgp, vec)
  445. SCSI *scgp;
  446. const char **vec;
  447. {
  448. scgp->nonstderrs = vec;
  449. }
  451. EXPORT
  452. BOOL scsi_yes(msg)
  453. char *msg;
  454. {
  455. char okbuf[10];
  457. printf("%s", msg);
  458. flush();
  459. if (getline(okbuf, sizeof(okbuf)) == EOF)
  460. exit(EX_BAD);
  461. if(streql(okbuf, "y") || streql(okbuf, "yes") ||
  462.    streql(okbuf, "Y") || streql(okbuf, "YES"))
  463. return(TRUE);
  464. else
  465. return(FALSE);
  466. }
  468. #ifdef nonono
  469. LOCAL void
  470. scsi_sighandler(sig)
  471. int sig;
  472. {
  473. printf("n");
  474. if (scsi_running) {
  475. printf("Running command: %sn", scsi_command);
  476. printf("Resetting SCSI - Bus.n");
  477. if (scsireset(scgp) < 0)
  478. errmsg("Cannot reset SCSI - Bus.n");
  479. }
  480. if (scsi_yes("EXIT ? "))
  481. exit(sig);
  482. }
  483. #endif
  485. EXPORT
  486. int scsicmd(scgp)
  487. SCSI *scgp;
  488. {
  489.  int f;
  490.  int ret;
  491. register struct scg_cmd *scmd = scgp->scmd;
  493. f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  494. scmd->kdebug = scgp->kdebug;
  495. if (scmd->timeout == 0 || scmd->timeout < scgp->deftimeout)
  496. scmd->timeout = scgp->deftimeout;
  497. if (scgp->disre_disable)
  498. scmd->flags &= ~SCG_DISRE_ENA;
  499. if (scgp->noparity)
  500. scmd->flags |= SCG_NOPARITY;
  502. scmd->u_sense.cmd_sense[0] = 0; /* Paranioa */
  504. if (scgp->verbose) {
  505. printf("nExecuting '%s' command on Bus %d Target %d, Lun %d timeout %dsn",
  506. scgp->cmdname, scgp->scsibus, scgp->target, scmd->cdb.g0_cdb.lun,
  507. scmd->timeout);
  508. scsiprintcdb(scgp);
  509. if (scgp->verbose > 1)
  510. scsiprintwdata(scgp);
  511. flush();
  512. }
  514. if (scgp->running) {
  515. if (scgp->curcmdname) {
  516. error("Currently running '%s' command.n",
  517. scgp->curcmdname);
  518. }
  519. raisecond("SCSI ALREADY RUNNING !!", 0L);
  520. }
  521. gettimeofday(scgp->cmdstart, (struct timezone *)0);
  522. scgp->curcmdname = scgp->cmdname;
  523. scgp->running = TRUE;
  524. ret = scsi_send(scgp, f, scmd);
  525. scgp->running = FALSE;
  526. scsitimes(scgp);
  527. if (ret < 0) {
  528. /*
  529.  * Old /dev/scg versions will not allow to access targets > 7.
  530.  * Include a workaround to make this non fatal.
  531.  */
  532. if (scgp->target < 8 || geterrno() != EINVAL)
  533. comerr("Cannot send SCSI cmd via ioctln");
  534. if (scmd->ux_errno == 0)
  535. scmd->ux_errno = geterrno();
  536. if (scmd->error == SCG_NO_ERROR)
  537. scmd->error = SCG_FATAL;
  538. if (scgp->debug) {
  539. errmsg("ret < 0 errno: %d ux_errno: %d error: %dn",
  540. geterrno(), scmd->ux_errno, scmd->error);
  541. }
  542. }
  543. ret = scsicheckerr(scgp);
  544. if (scgp->verbose || (ret && scgp->silent <= 0)) {
  545. scsiprintresult(scgp);
  546. }
  547. return (ret);
  548. }
  550. EXPORT
  551. int scsigetresid(scgp)
  552. SCSI *scgp;
  553. {
  554. return (scgp->scmd->resid);
  555. }
  557. LOCAL
  558. void scsitimes(scgp)
  559. SCSI *scgp;
  560. {
  561. struct timeval *stp = scgp->cmdstop;
  563. gettimeofday(stp, (struct timezone *)0);
  564. stp->tv_sec -= scgp->cmdstart->tv_sec;
  565. stp->tv_usec -= scgp->cmdstart->tv_usec;
  566. while (stp->tv_usec < 0) {
  567. stp->tv_sec -= 1;
  568. stp->tv_usec += 1000000;
  569. }
  570. }
  572. LOCAL BOOL
  573. scsierr(scgp)
  574. SCSI *scgp;
  575. {
  576. register struct scg_cmd *cp = scgp->scmd;
  578. if(cp->error != SCG_NO_ERROR ||
  579. cp->ux_errno != 0 ||
  580. *(u_char *)&cp->scb != 0 ||
  581. cp->u_sense.cmd_sense[0] != 0) /* Paranioa */
  582. return (TRUE);
  583. return (FALSE);
  584. }
  586. LOCAL int
  587. scsicheckerr(scgp)
  588. SCSI *scgp;
  589. {
  590. register int ret;
  592. ret = 0;
  593. if(scsierr(scgp)) {
  594. if (!scgp->silent || scgp->verbose)
  595. scsiprinterr(scgp);
  596. ret = -1;
  597. }
  598. if ((!scgp->silent || scgp->verbose) && scgp->scmd->resid) {
  599. printf("resid: %dn", scgp->scmd->resid);
  600. flush();
  601. }
  602. return (ret);
  603. }
  605. EXPORT void
  606. scsiprinterr(scgp)
  607. SCSI *scgp;
  608. {
  609. register struct scg_cmd *cp = scgp->scmd;
  610. register char *err;
  611. char errbuf[64];
  613. switch (cp->error) {
  615. case SCG_NO_ERROR : err = "no error"; break;
  616. case SCG_RETRYABLE: err = "retryable error"; break;
  617. case SCG_FATAL    : err = "fatal error"; break;
  618. /*
  619.  * We need to cast timeval->* to long because
  620.  * of the broken sys/time.h in Linux.
  621.  */
  622. case SCG_TIMEOUT  : sprintf(errbuf,
  623. "cmd timeout after %ld.%03ld (%d) s",
  624. (long)scgp->cmdstop->tv_sec,
  625. (long)scgp->cmdstop->tv_usec/1000,
  626. cp->timeout);
  627. err = errbuf;
  628. break;
  629. default: sprintf(errbuf, "error: %d", cp->error);
  630. err = errbuf;
  631. }
  633. errmsgno(cp->ux_errno, "%s: scsi sendcmd: %sn", scgp->cmdname, err);
  634. scsiprintcdb(scgp);
  636. if (cp->error <= SCG_RETRYABLE)
  637. scsiprintstatus(scgp);
  639. if (cp->scb.chk) {
  640. scsiprsense((u_char *)&cp->sense, cp->sense_count);
  641. scsierrmsg(scgp, &cp->sense, &cp->scb, -1, scgp->nonstderrs);
  642. }
  643. flush();
  644. }
  646. EXPORT void
  647. scsiprintcdb(scgp)
  648. SCSI *scgp;
  649. {
  650. scsiprbytes("CDB: ", scgp->scmd->cdb.cmd_cdb, scgp->scmd->cdb_len);
  651. }
  653. EXPORT void
  654. scsiprintwdata(scgp)
  655. SCSI *scgp;
  656. {
  657. register struct scg_cmd *scmd = scgp->scmd;
  659. if (scmd->size > 0 && (scmd->flags & SCG_RECV_DATA) == 0) {
  660. printf("Sending %d (0x%X) bytes of data.n",
  661. scmd->size, scmd->size);
  662. scsiprbytes("Write Data: ",
  663. (Uchar *)scmd->addr,
  664. scmd->size > 100 ? 100 : scmd->size);
  665. }
  666. }
  668. EXPORT void
  669. scsiprintrdata(scgp)
  670. SCSI *scgp;
  671. {
  672. register struct scg_cmd *scmd = scgp->scmd;
  674. if (scmd->size > 0 && (scmd->flags & SCG_RECV_DATA) != 0) {
  675. printf("Got %d (0x%X), expecting %d (0x%X) bytes of data.n",
  676. scmd->size-scmd->resid, scmd->size-scmd->resid,
  677. scmd->size, scmd->size);
  678. scsiprbytes("Received Data: ",
  679. (Uchar *)scmd->addr,
  680. (scmd->size-scmd->resid) > 100 ?
  681. 100 : (scmd->size-scmd->resid));
  682. }
  683. }
  685. EXPORT void
  686. scsiprintresult(scgp)
  687. SCSI *scgp;
  688. {
  689. printf("cmd finished after %ld.%03lds timeout %dsn",
  690. (long)scgp->cmdstop->tv_sec,
  691. (long)scgp->cmdstop->tv_usec/1000,
  692. scgp->scmd->timeout);
  693. if (scgp->verbose > 1)
  694. scsiprintrdata(scgp);
  695. flush();
  696. }
  698. EXPORT
  699. void scsiprintstatus(scgp)
  700. SCSI *scgp;
  701. {
  702. register struct scg_cmd *cp = scgp->scmd;
  704. error("status: 0x%x ", *(u_char *)&cp->scb);
  705. #ifdef SCSI_EXTENDED_STATUS
  706. if (cp->scb.ext_st1)
  707. error("0x%x ", ((u_char *)&cp->scb)[1]);
  708. if (cp->scb.ext_st2)
  709. error("0x%x ", ((u_char *)&cp->scb)[2]);
  710. #endif
  711. error("(");
  713. switch (*(u_char *)&cp->scb & 036) {
  715. case 0  : error("GOOD STATUS"); break;
  716. case 02 : error("CHECK CONDITION"); break;
  717. case 04 : error("CONDITION MET/GOOD"); break;
  718. case 010: error("BUSY"); break;
  719. case 020: error("INTERMEDIATE GOOD STATUS"); break;
  720. case 024: error("INTERMEDIATE CONDITION MET/GOOD"); break;
  721. case 030: error("RESERVATION CONFLICT"); break;
  722. default : error("Reserved"); break;
  723. }
  725. #ifdef SCSI_EXTENDED_STATUS
  726. if (cp->scb.ext_st1 && cp->scb.ha_er)
  727. error(" host adapter detected error");
  728. #endif
  729. error(")n");
  730. }
  732. EXPORT void
  733. scsiprbytes(s, cp, n)
  734. char *s;
  735. register u_char *cp;
  736. register int n;
  737. {
  738. printf(s);
  739. while (--n >= 0)
  740. printf(" %02X", *cp++);
  741. printf("n");
  742. }
  744. EXPORT void
  745. scsiprsense(cp, n)
  746. u_char *cp;
  747. int n;
  748. {
  749. scsiprbytes("Sense Bytes:", cp, n);
  750. }
  752. EXPORT int
  753. scsi_sense_key(scgp)
  754. SCSI *scgp;
  755. {
  756. register struct scg_cmd *cp = scgp->scmd;
  757. int key = -1;
  759. if(!scsierr(scgp))
  760. return (0);
  762. if (cp->sense.code >= 0x70)
  763. key = ((struct scsi_ext_sense*)&(cp->sense))->key;
  764. return(key);
  765. }
  767. EXPORT int
  768. scsi_sense_code(scgp)
  769. SCSI *scgp;
  770. {
  771. register struct scg_cmd *cp = scgp->scmd;
  772. int code = -1;
  774. if(!scsierr(scgp))
  775. return (0);
  777. if (cp->sense.code >= 0x70)
  778. code = ((struct scsi_ext_sense*)&(cp->sense))->sense_code;
  779. else
  780. code = cp->sense.code;
  781. return(code);
  782. }
  784. EXPORT int
  785. scsi_sense_qual(scgp)
  786. SCSI *scgp;
  787. {
  788. register struct scg_cmd *cp = scgp->scmd;
  790. if(!scsierr(scgp))
  791. return (0);
  793. if (cp->sense.code >= 0x70)
  794. return (((struct scsi_ext_sense*)&(cp->sense))->qual_code);
  795. else
  796. return (0);
  797. }
  799. EXPORT
  800. void scsiprintdev(ip)
  801. struct scsi_inquiry *ip;
  802. {
  803. if (ip->removable)
  804. printf("Removable ");
  805. if (ip->data_format >= 2) {
  806. switch (ip->qualifier) {
  808. case INQ_DEV_PRESENT: break;
  809. case INQ_DEV_NOTPR:
  810. printf("not present "); break;
  811. case INQ_DEV_RES:
  812. printf("reserved "); break;
  813. case INQ_DEV_NOTSUP:
  814. if (ip->type == INQ_NODEV) {
  815. printf("unsupportedn"); return;
  816. }
  817. printf("unsupported "); break;
  818. default:
  819. printf("vendor specific %d ", ip->qualifier);
  820. }
  821. }
  822. switch (ip->type) {
  824. case INQ_DASD:
  825. printf("Disk"); break;
  826. case INQ_SEQD:
  827. printf("Tape"); break;
  828. case INQ_PRTD:
  829. printf("Printer"); break;
  830. case INQ_PROCD:
  831. printf("Processor"); break;
  832. case INQ_WORM:
  833. printf("WORM"); break;
  834. case INQ_ROMD:
  835. printf("CD-ROM"); break;
  836. case INQ_SCAN:
  837. printf("Scanner"); break;
  838. case INQ_OMEM:
  839. printf("Optical Storage"); break;
  840. case INQ_JUKE:
  841. printf("Juke Box"); break;
  842. case INQ_COMM:
  843. printf("Communication"); break;
  844. case INQ_IT8_1:
  845. printf("IT8 1"); break;
  846. case INQ_IT8_2:
  847. printf("IT8 2"); break;
  848. case INQ_STARR:
  849. printf("Storage array"); break;
  850. case INQ_ENCL:
  851. printf("Enclosure services"); break;
  853. case INQ_NODEV:
  854. if (ip->data_format >= 2) {
  855. printf("unknown/no device");
  856. break;
  857. } else if (ip->qualifier == INQ_DEV_NOTSUP) {
  858. printf("unit not present");
  859. break;
  860. }
  861. default:
  862. printf("unknown device type 0x%x", ip->type);
  863. }
  864. printf("n");
  865. }