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

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

SCSI/ASPI

开发平台：

MultiPlatform

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