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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-openserver.c：源码内容
  1. /* @(#)scsi-openserver.c 1.16 00/01/26 Copyright 1998 J. Schilling, Santa Cruz Operation */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-openserver.c 1.16 00/01/26 Copyright 1998 J. Schilling, Santa Cruz Operation";
  5. #endif
  6. /*
  7.  * Interface for the SCO SCSI implementation.
  8.  *
  9.  * Warning: you may change this source, but if you do that
  10.  * you need to change the _scg_version and _scg_auth* string below.
  11.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  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) 1998 J. Schilling, Santa Cruz Operation
  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. #undef sense
  35. #include <sys/scsicmd.h>
  37. /*
  38.  * Warning: you may change this source, but if you do that
  39.  * you need to change the _scg_version and _scg_auth* string below.
  40.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  41.  * Choose your name instead of "schily" and make clear that the version
  42.  * string is related to a modified source.
  43.  */
  44. LOCAL char _scg_trans_version[] = "scsi-openserver.c-1.16"; /* The version for this transport*/
  46. #define MAX_SCG 16 /* Max # of cdrom devices */
  47. #define MAX_TGT 16 /* Not really needed      */
  48. #define MAX_LUN 8 /* Not really needed      */
  50. #define MAX_DMA (32*1024) /* Maybe even more ???    */
  51. #define MAXPATH        256 /* max length of devicepath  */
  52. #define MAXLINE 80 /* max length of input line  */
  53. #define MAXSCSI 99 /* max number of mscsi lines */
  54. #define MAXDRVN 10 /* max length of drivername  */
  56. #define DEV_DIR "/tmp"
  57. #define DEV_NAME "scg.s%1dt%1dl%1d"
  59. /* We will only deal with disks, cdroms and tapes ! */
  60. /* Sflp devices (floptical) 21Mb scsi floppy devices */
  61. /* will be ignored. Hmm, I can't remember that I ever  */
  62. /* have seen one ;^) */
  64. #define DEV_ROOT "/dev/rdsk/0s0"
  65. #define DEV_SDSK "/dev/rdsk/%ds0"
  66. #define DEV_SROM "/dev/rcd%d"
  67. #define DEV_STP "/dev/xStp%d"
  69. #define SCAN_DEV "%s%s%d%d%d%d"
  71. #define SCSI_CFG "/etc/sconf -r" /* no. of configured devices  */
  72. #define SCSI_DEV "/etc/sconf -g %d" /* read line 'n' of mscsi tbl */
  74. #define DRV_ATAPI "wd"
  76. typedef struct scg2sdi {
  78. int valid;
  79. int open;
  80. int atapi;
  81. int fd;
  82. int lmscsi;
  84. } scg2sdi_t;
  86. LOCAL scg2sdi_t sdidevs [MAX_SCG][MAX_TGT][MAX_LUN];
  88. typedef struct amscsi {
  89. char typ[MAXDRVN];
  90. char drv[MAXDRVN];
  91. int hba;
  92. int bus;
  93. int scg;
  94. int tgt;
  95. int lun;
  96. char dev[MAXPATH];
  98. } amscsi_t;
  100. struct scg_local {
  101. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  102. };
  103. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  105. LOCAL int sort_mscsi __PR((const void *l1, const void *l2));
  106. LOCAL int openserver_init __PR((SCSI *scgp));
  107. LOCAL void cp_scg2sco __PR((struct scsicmd2 *sco, struct scg_cmd *scg));
  108. LOCAL void cp_sco2scg __PR((struct scsicmd2 *sco, struct scg_cmd *scg));
  110. /* -------------------------------------------------------------------------
  111. ** SCO OpenServer does not have a generic scsi device driver, which can
  112. ** be used to access any configured scsi device. 
  113. **
  114. ** But we can use the "Srom" scsi peripherial driver (for CD-ROM devices) 
  115. ** etc. to send SCSIUSERCMD2's to any target device controlled by the 
  116. ** corresponding target driver.
  117. **
  118. ** This pass-through implementation for libscg currently allows to 
  119. ** handle the following devices classes:
  120. **
  121. ** 1. DISK handled by Sdsk
  122. ** 2. CD-ROM handled by Srom
  123. ** 3. TAPES handled by Stp
  124. **
  125. ** NOTE: The libscg OpenServer passthrough routines have changed with 
  126. **       cdrecord-1.8 to enable the -scanbus option. Therefore the
  127. **  addressing scheme is now the same as used on many other platforms
  128. **  like Solaris, Linux etc.
  129. **
  130. **   ===============================================================
  131. **   RUN 'cdrecord -scanbus' TO SEE THE DEVICE ADDRESSES YOU CAN USE
  132. **   ===============================================================
  133. **
  134. */
  136. /*
  137.  * Return version information for the low level SCSI transport code.
  138.  * This has been introduced to make it easier to trace down problems
  139.  * in applications.
  140.  */
  141. EXPORT char *
  142. scg__version(scgp, what)
  143. SCSI *scgp;
  144. int what;
  145. {
  146. if (scgp != (SCSI *)0) {
  147. switch (what) {
  149. case SCG_VERSION:
  150. return (_scg_trans_version);
  151. /*
  152.  * If you changed this source, you are not allowed to
  153.  * return "schily" for the SCG_AUTHOR request.
  154.  */
  155. case SCG_AUTHOR:
  156. return (_scg_auth_schily);
  157. case SCG_SCCS_ID:
  158. return (__sccsid);
  159. }
  160. }
  161. return ((char *)0);
  162. }
  164. /* ---------------------------------------------------------------
  165. ** This routine sorts the amscsi_t lines on the following columns
  166. ** in ascending order:
  167. **
  168. ** 1. drv  - driver name
  169. ** 2. bus  - scsibus per controller
  170. ** 3. tgt  - target id of device
  171. ** 4. lun  - lun of the device
  172. **
  173. */
  176. LOCAL int
  177. sort_mscsi(l1, l2)
  178. const void *l1;
  179. const void *l2;
  180. {
  181. amscsi_t *t1 = (amscsi_t *) l1;
  182. amscsi_t *t2 = (amscsi_t *) l2;
  184. if ( strcmp(t1->drv, t2->drv) == 0 ) {
  185. if (t1->bus < t2->bus) {
  186. return (-1);
  188. } else if (t1->bus > t2->bus) {
  189. return (1);
  191. } else if (t1->tgt < t2->tgt) {
  192. return (-1);
  194. } else if (t1->tgt > t2->tgt) {
  195. return (1);
  197. } else if (t1->lun < t2->lun) {
  198. return (-1);
  200. } else if (t1->lun > t2->lun) {
  201. return (1);
  202. } else {
  203. return (0);
  204. }
  205. } else {
  206. return (strcmp(t1->drv, t2->drv));
  207. }
  208. }
  210. /* ---------------------------------------------------------------
  211. ** This routine is introduced to find all scsi devices which are
  212. ** currently configured into the kernel. This is done by reading
  213. ** the dynamic kernel mscsi tables and parse the resulting lines.
  214. ** As the output of 'sconf' is not directly usable the information
  215. ** found is to be sorted and re-arranged to be used with the libscg
  216. ** routines.
  217. **
  218. ** NOTE: One problem is currently still not solved ! If you don't
  219. **       have a media in your CD-ROM/CD-Writer we are not able to 
  220. **       do an open() and therefore will set the drive to be not 
  221. **       available (valid=0).
  222. **
  223. **       This will for example cause cdrecord to not list the drive 
  224. **  in the -scanbus output.
  225. **
  226. */
  228. LOCAL int 
  229. openserver_init(scgp)
  230. SCSI *scgp;
  231. {
  232. FILE *cmd;
  233. int nscg  = -1, lhba  = -1, lbus = -1;
  234. int nSrom = -1, nSdsk = -1, nStp = -1;
  235. int atapi, fd, nopen = 0;
  236. int pos = 0, len = 0, nlm = 0;
  237. int s = 0, t = 0, l = 0;
  238. int mscsi;
  239. char sconf[MAXLINE];
  240. char lines[MAXLINE];
  241. char drvid[MAXDRVN];
  242. amscsi_t cmtbl[MAXSCSI];
  243. char dname[MAXPATH];
  244. char **evsave;
  245. extern char **environ;
  248. for (s = 0; s < MAX_SCG; s++) {
  249. for (t = 0; t < MAX_TGT; t++) {
  250. for (l = 0; l < MAX_LUN ; l++) {
  251.   sdidevs[s][t][l].valid  =  0;
  252.   sdidevs[s][t][l].open   = -1;
  253.   sdidevs[s][t][l].atapi  = -1;
  254.   sdidevs[s][t][l].fd     = -1;
  255.   sdidevs[s][t][l].lmscsi = -1;
  256. }
  257. }
  258. }
  260. /* read sconf -r and get number of kernel mscsi lines ! */
  262. evsave = environ;
  263. environ = 0;
  264. if ((cmd = popen(SCSI_CFG,"r")) == NULL) {
  265. if (scgp->errstr)
  266. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  267. "Error popen() for "%s"",
  268. SCSI_CFG);
  269. environ = evsave;
  270. return (-1);
  271. }
  272. environ = evsave;
  274. if (fgets(lines, MAXLINE, cmd) == NULL) {
  275. errno = EIO;
  276. if (scgp->errstr)
  277. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  278. "Error reading popen() for "%s"",
  279. SCSI_CFG);
  280. return (-1);
  281. } else
  282. nlm = atoi(lines);
  284. if (scgp->debug) {
  285. printf("-------------------- n");
  286. printf("mscsi lines = %dn", nlm);
  287. printf("-------------------- n");
  288. }
  290. if (pclose(cmd) == -1) {
  291. if (scgp->errstr)
  292. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  293. "Error pclose() for "%s"",
  294. SCSI_CFG);
  295. return (-1);
  296. }
  299. for (l = 0; l < nlm; l++) {
  301. /* initialize cmtbl entry */
  303. cmtbl[l].hba = -1;
  304. cmtbl[l].bus = -1;
  305. cmtbl[l].tgt = -1;
  306. cmtbl[l].lun = -1;
  307. cmtbl[l].scg = -1;
  309. memset( cmtbl[l].typ, '', MAXDRVN);
  310. memset( cmtbl[l].drv, '', MAXDRVN);
  311. memset( cmtbl[l].dev, '', MAXDRVN);
  313. /* read sconf -g 'n' and get line of kernel mscsi table! */
  314. /* the order the lines will be received in will determine */
  315. /* the device name we can use to open the device         */
  317. sprintf(sconf, SCSI_DEV, l + 1); /* enumeration starts with 1 */
  319. evsave = environ;
  320. environ = 0;
  321. if ((cmd = popen(sconf,"r")) == NULL) {
  322. if (scgp->errstr)
  323. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  324. "Error popen() for "%s"",
  325. sconf);
  326. environ = evsave;
  327. return (-1);
  328. }
  329. environ = evsave;
  331. if (fgets(lines, MAXLINE, cmd) == NULL) 
  332. break;
  334. if (pclose(cmd) == -1) {
  335. if (scgp->errstr)
  336. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  337. "Error pclose() for "%s"",
  338. sconf);
  339. return (-1);
  340. }
  342. sscanf(lines, SCAN_DEV,  cmtbl[l].typ, 
  343.  cmtbl[l].drv,
  344. &cmtbl[l].hba, 
  345. &cmtbl[l].bus, 
  346. &cmtbl[l].tgt, 
  347. &cmtbl[l].lun);
  349. if ( strstr(cmtbl[l].typ, "Sdsk") != NULL ){
  350. sprintf(cmtbl[l].dev, DEV_SDSK, ++nSdsk);
  351. }
  353. if ( strstr(cmtbl[l].typ, "Srom") != NULL ){
  354. sprintf(cmtbl[l].dev, DEV_SROM, ++nSrom);
  355. }
  357. if ( strstr(cmtbl[l].typ, "Stp") != NULL ){
  358. sprintf(cmtbl[l].dev, DEV_STP, ++nStp);
  359. }
  361. if (scgp->debug) {
  362. printf("%-4s = %5s(%d,%d,%d,%d) -> %sn", 
  363. cmtbl[l].typ, 
  364. cmtbl[l].drv, 
  365. cmtbl[l].hba, 
  366. cmtbl[l].bus, 
  367. cmtbl[l].tgt, 
  368. cmtbl[l].lun,
  369. cmtbl[l].dev);
  370. }
  372. }
  374. if (scgp->debug) {
  375. printf("-------------------- n");
  376. printf("%2d DISK  n", nSdsk + 1);
  377. printf("%2d CD-ROMn", nSrom + 1);
  378. printf("%2d TAPE  n", nStp  + 1);
  379. printf("-------------------- n");
  380. }
  382. /* ok, now let's sort this array of scsi devices */
  384. qsort((void *) cmtbl, nlm, sizeof(amscsi_t), sort_mscsi);
  386. if (scgp->debug) {
  387. for (l = 0; l < nlm; l++)
  388. printf("%-4s = %5s(%d,%d,%d,%d) -> %sn", 
  389. cmtbl[l].typ, 
  390. cmtbl[l].drv, 
  391. cmtbl[l].hba, 
  392. cmtbl[l].bus, 
  393. cmtbl[l].tgt, 
  394. cmtbl[l].lun,
  395. cmtbl[l].dev);
  396. printf("-------------------- n");
  397. }
  401. /* find root disk controller to make it scg 0      */
  403. for (l = 0; l < nlm; l++)
  404. if (strcmp(cmtbl[l].dev, DEV_ROOT) == 0)
  405. t = l;
  408. if (scgp->debug) {
  409. printf("root = %5s(%d,%d,%d,%d) -> %sn", 
  410. cmtbl[t].drv, 
  411. cmtbl[t].hba, 
  412. cmtbl[t].bus, 
  413. cmtbl[t].tgt, 
  414. cmtbl[t].lun,
  415. cmtbl[t].dev);
  416. printf("-------------------- n");
  417. }
  419. /* calculate scg from drv, hba and bus  */
  421. strcpy(drvid, "");
  423. for (l = 0, s = t; l < nlm; l++, s = (t + l) % nlm) {
  425. if (strcmp(drvid, cmtbl[s].drv) != 0) {
  426. strcpy(drvid, cmtbl[s].drv);
  427. lhba = cmtbl[s].hba;
  428. lbus = cmtbl[s].bus;
  429. cmtbl[s].scg = ++nscg;
  431. } else if (cmtbl[s].hba != lhba) {
  432. lhba = cmtbl[s].hba;
  433. lbus = cmtbl[s].bus;
  434. cmtbl[s].scg = ++nscg;
  436. } else if (cmtbl[s].bus != lbus) {
  437. lbus = cmtbl[s].bus;
  438. cmtbl[s].scg = ++nscg;
  439. } else {
  440. cmtbl[s].scg = nscg;
  441. }
  442. sdidevs[cmtbl[s].scg][cmtbl[s].tgt][cmtbl[s].lun].valid  = 1;
  443. sdidevs[cmtbl[s].scg][cmtbl[s].tgt][cmtbl[s].lun].open   = 0;
  445. if (strcmp(cmtbl[s].drv, DRV_ATAPI) == 0) 
  446. sdidevs[cmtbl[s].scg][cmtbl[s].tgt][cmtbl[s].lun].atapi = 1;
  448. sdidevs[cmtbl[s].scg][cmtbl[s].tgt][cmtbl[s].lun].lmscsi = s;
  450. }
  453. /* open all device nodes */
  455. for (s = 0; s < MAX_SCG; s++) {
  456. for (t = 0; t < MAX_TGT; t++) {
  457. for (l = 0; l < MAX_LUN ; l++) {
  459.   if ( sdidevs[s][t][l].valid == 0) 
  460.    continue;
  462.   /* Open pass-through device node */
  464. mscsi = sdidevs[s][t][l].lmscsi;
  466. strcpy(dname, cmtbl[mscsi].dev);
  468. /* ------------------------------------------------------------------
  469. ** NOTE: If we can't open the device, we will set the device invalid!
  470. ** ------------------------------------------------------------------
  471. */
  473. if ((fd = open(dname, O_RDONLY | O_NONBLOCK)) < 0) {
  474. sdidevs[s][t][l].valid = 0;
  475. continue;
  476. }
  478. if (scgp->debug) {
  479. printf("%d,%d,%d => %5s(%d,%d,%d,%d) -> %d : %s n", 
  480. s, t, l,
  481. cmtbl[mscsi].drv, 
  482. cmtbl[mscsi].hba, 
  483. cmtbl[mscsi].bus, 
  484. cmtbl[mscsi].tgt, 
  485. cmtbl[mscsi].lun,
  486. cmtbl[mscsi].scg,
  487. cmtbl[mscsi].dev);
  488. }
  490. sdidevs[s][t][l].fd   = fd;
  491. sdidevs[s][t][l].open = 1;
  492. nopen++;
  493. scglocal(scgp)->scgfiles[s][t][l] = (short) fd;
  494. }
  495. }
  496. }
  498. if (scgp->debug) {
  499. printf("-------------------- n");
  500. printf("nopen = %d devices   n", nopen);
  501. printf("-------------------- n");
  502. }
  504. return (nopen);
  505. }
  508. EXPORT int
  509. scsi_open(scgp, device, busno, tgt, tlun)
  510. SCSI *scgp;
  511. char *device;
  512. int busno;
  513. int tgt;
  514. int tlun;
  515. {
  516. int f, b, t, l;
  517. int nopen = 0;
  518. char devname[64];
  520. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  521. errno = EINVAL;
  522. if (scgp->errstr)
  523. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  524. "Illegal value for busno, target or lun '%d,%d,%d'",
  525. busno, tgt, tlun);
  526. return (-1);
  527. }
  529. if (scgp->local == NULL) {
  530. scgp->local = malloc(sizeof(struct scg_local));
  531. if (scgp->local == NULL)
  532. return (0);
  534. for (b = 0; b < MAX_SCG; b++) {
  535. for (t = 0; t < MAX_TGT; t++) {
  536. for (l = 0; l < MAX_LUN ; l++)
  537. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  538. }
  539. }
  540. }
  542. if (*device != '') {          /* we don't allow old dev usage */
  543. errno = EINVAL;
  544. if (scgp->errstr)
  545. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  546. "Open by 'devname' no longer supported on this OS");
  547. return (-1);
  548. } 
  550. return ( openserver_init(scgp) );
  552. }
  554. EXPORT int
  555. scsi_close(scgp)
  556. SCSI *scgp;
  557. {
  558. register int f;
  559. register int b;
  560. register int t;
  561. register int l;
  563. if (scgp->local == NULL)
  564. return (-1);
  566. for (b=0; b < MAX_SCG; b++) {
  567. for (t=0; t < MAX_TGT; t++) {
  568. for (l=0; l < MAX_LUN ; l++)
  570. f = scglocal(scgp)->scgfiles[b][t][l];
  571. if (f >= 0)
  572. close(f);
  574. sdidevs[b][t][l].fd    = -1;
  575. sdidevs[b][t][l].open  =  0;
  576. sdidevs[b][t][l].valid =  0;
  578. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  579. }
  580. }
  581. return (0);
  582. }
  584. LOCAL long
  585. scsi_maxdma(scgp)
  586. SCSI *scgp;
  587. {
  588. return (MAX_DMA);
  589. }
  592. EXPORT void *
  593. scsi_getbuf(scgp, amt)
  594. SCSI *scgp;
  595. long amt;
  596. {
  597. if (amt <= 0 || amt > scsi_maxdma(scgp))
  598. return ((void *)0);
  599. if (scgp->debug)
  600. printf("scsi_getbuf: %ld bytesn", amt);
  602. scgp->bufbase = valloc((size_t)(amt));
  604. return (scgp->bufbase);
  605. }
  607. EXPORT void
  608. scsi_freebuf(scgp)
  609. SCSI *scgp;
  610. {
  611. if (scgp->bufbase)
  612. free(scgp->bufbase);
  613. scgp->bufbase = NULL;
  614. }
  616. EXPORT
  617. BOOL scsi_havebus(scgp, busno)
  618. SCSI *scgp;
  619. int busno;
  620. {
  621. register int t;
  622. register int l;
  624. if (busno < 0 || busno >= MAX_SCG)
  625. return (FALSE);
  627. if (scgp->local == NULL)
  628. return (FALSE);
  630. for (t=0; t < MAX_TGT; t++) {
  631. for (l=0; l < MAX_LUN ; l++)
  632. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  633. return (TRUE);
  634. }
  635. return (FALSE);
  636. }
  638. EXPORT
  639. int scsi_fileno(scgp, busno, tgt, tlun)
  640. SCSI *scgp;
  641. int busno;
  642. int tgt;
  643. int tlun;
  644. {
  645. if (busno < 0 || busno >= MAX_SCG ||
  646.     tgt   < 0 || tgt   >= MAX_TGT ||
  647.     tlun  < 0 || tlun  >= MAX_LUN)
  648. return (-1);
  650. if (scgp->local == NULL)
  651. return (-1);
  653. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  654. }
  656. EXPORT int
  657. scsi_initiator_id(scgp)
  658. SCSI *scgp;
  659. {
  660. return (-1);
  662. /* We don't know the initiator ID yet, but we can if we parse the 
  663. ** output of the command 'cat /dev/string/cfg | grep "%adapter"'  
  664. **
  665. ** Sample line:                                                   
  666. **
  667.   **   %adapter 0xE800-0xE8FF 11 - type=alad ha=0 bus=0 id=7 fts=sto  
  668. **
  669. ** This tells us that the alad controller 0 has an id of 7 !
  670. ** The parsing should be done in openserver_init().
  671. **
  672. */
  673. }
  675. EXPORT
  676. int scsi_isatapi(scgp)
  677. SCSI *scgp;
  678. {
  679. return (sdidevs[scgp->scsibus][scgp->target][scgp->lun].atapi);
  680. }
  682. EXPORT
  683. int scsireset(scgp)
  684. SCSI *scgp;
  685. {
  686. return(-1); /* no scsi reset available */
  687. }
  689. LOCAL void
  690. cp_scg2sco(sco, scg)
  691. struct scsicmd2 *sco;
  692. struct scg_cmd *scg;
  693. {
  694. sco->cmd.data_ptr = (char *) scg->addr;
  695. sco->cmd.data_len = scg->size;
  696. sco->cmd.cdb_len  = scg->cdb_len;
  698. sco->sense_len    = scg->sense_len;
  699. sco->sense_ptr    = scg->u_sense.cmd_sense;
  701. if (!(scg->flags & SCG_RECV_DATA) && (scg->size > 0))
  702. sco->cmd.is_write = 1;
  704. if (scg->cdb_len == SC_G0_CDBLEN )
  705. memcpy(sco->cmd.cdb, &scg->cdb.g0_cdb, scg->cdb_len);
  707. if (scg->cdb_len == SC_G1_CDBLEN )
  708. memcpy(sco->cmd.cdb, &scg->cdb.g1_cdb, scg->cdb_len);
  710. if (scg->cdb_len == SC_G5_CDBLEN )
  711. memcpy(sco->cmd.cdb, &scg->cdb.g5_cdb, scg->cdb_len);
  712. }
  715. LOCAL void
  716. cp_sco2scg(sco, scg)
  717. struct scsicmd2 *sco;
  718. struct scg_cmd *scg;
  719. {
  720. scg->size      = sco->cmd.data_len;
  722. memset(&scg->scb, 0, sizeof(scg->scb));
  724. if (sco->sense_len > SCG_MAX_SENSE)
  725. scg->sense_count = SCG_MAX_SENSE;
  726. else
  727. scg->sense_count = sco->sense_len;
  729. scg->resid = 0;
  730. scg->u_scb.cmd_scb[0] = sco->cmd.target_sts;
  732. }
  735. LOCAL int
  736. scsi_send(scgp, fd, sp)
  737. SCSI *scgp;
  738. int fd;
  739. struct scg_cmd *sp;
  740. {
  741. struct scsicmd2 scsi_cmd;
  742. int i;
  743. u_char sense_buf[SCG_MAX_SENSE];
  745. if ( fd < 0 ) {
  746. sp->error = SCG_FATAL;
  747. return (0);
  748. }
  750. memset(&scsi_cmd, 0, sizeof(scsi_cmd));
  751. memset(sense_buf,  0, sizeof(sense_buf));
  752. scsi_cmd.sense_ptr = sense_buf;
  753. scsi_cmd.sense_len = sizeof(sense_buf);
  754. cp_scg2sco(&scsi_cmd, sp);
  756. errno = 0;
  757. for (;;) {
  758. int ioctlStatus;
  760. if ((ioctlStatus = ioctl(fd, SCSIUSERCMD2, &scsi_cmd)) < 0) {
  761. if (errno == EINTR)
  762. continue;
  764. cp_sco2scg(&scsi_cmd, sp);
  765. sp->ux_errno = errno;
  766. if (errno == 0)
  767. sp->ux_errno = EIO;
  768. sp->error    = SCG_RETRYABLE;
  770. return (0);
  771. }
  772. break;
  773. }
  775. cp_sco2scg(&scsi_cmd, sp);
  776. sp->ux_errno = errno;
  777. if (scsi_cmd.cmd.target_sts & 0x02) {
  778. if (errno == 0)
  779. sp->ux_errno = EIO;
  780. sp->error    = SCG_RETRYABLE;
  781. } else {
  782. sp->error    = SCG_NO_ERROR;
  783. }
  785. return 0;
  786. }
  789. #define sense u_sense.Sense