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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-linux-sg.c：源码内容
  1. /* @(#)scsi-linux-sg.c 1.37 99/09/07 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-linux-sg.c 1.37 99/09/07 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * Interface for Linux generic SCSI implementation (sg).
  8.  *
  9.  * This is the interface for the broken Linux SCSI generic driver.
  10.  * This is a hack, that tries to emulate the functionality
  11.  * of the scg driver.
  12.  *
  13.  * Design flaws of the sg driver:
  14.  * - cannot see if SCSI command could not be send
  15.  * - cannot get SCSI status byte
  16.  * - cannot get real dma count of tranfer
  17.  * - cannot get number of bytes valid in auto sense data
  18.  * - to few data in auto sense (CCS/SCSI-2/SCSI-3 needs >= 18)
  19.  *
  20.  * This code contains support for the sg driver version 2
  21.  *
  22.  * Copyright (c) 1997 J. Schilling
  23.  */
  24. /*
  25.  * This program is free software; you can redistribute it and/or modify
  26.  * it under the terms of the GNU General Public License as published by
  27.  * the Free Software Foundation; either version 2, or (at your option)
  28.  * any later version.
  29.  *
  30.  * This program is distributed in the hope that it will be useful,
  31.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33.  * GNU General Public License for more details.
  34.  *
  35.  * You should have received a copy of the GNU General Public License
  36.  * along with this program; see the file COPYING.  If not, write to
  37.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  38.  */
  40. #include <linux/version.h>
  42. #ifndef LINUX_VERSION_CODE /* Very old kernel? */
  43. # define LINUX_VERSION_CODE 0
  44. #endif
  46. #if LINUX_VERSION_CODE >= 0x01031a /* <linux/scsi.h> introduced in 1.3.26 */
  47. #if LINUX_VERSION_CODE >= 0x020000 /* <scsi/scsi.h> introduced somewhere. */
  48. /* Need to fine tune the ifdef so we get the transition point right. */
  49. #include <scsi/scsi.h>
  50. #else
  51. #include <linux/scsi.h>
  52. #endif
  53. #else
  54. #define __KERNEL__
  55. #include <linux/fs.h>
  56. #undef __KERNEL__
  57. #include "block/blk.h"
  58. #include "scsi/scsi.h"
  59. #endif
  61. #include "scsi/sg.h"
  63. #ifndef SCSI_IOCTL_GET_BUS_NUMBER
  64. #define SCSI_IOCTL_GET_BUS_NUMBER 0x5386
  65. #endif
  67. /*
  68.  * XXX There must be a better way than duplicating things from system include
  69.  * XXX files. This is stolen from /usr/src/linux/drivers/scsi/scsi.h
  70.  */
  71. #ifndef DID_OK
  72. #define DID_OK          0x00 /* NO error                                */
  73. #define DID_NO_CONNECT  0x01 /* Couldn't connect before timeout period  */
  74. #define DID_BUS_BUSY    0x02 /* BUS stayed busy through time out period */
  75. #define DID_TIME_OUT    0x03 /* TIMED OUT for other reason              */
  76. #define DID_BAD_TARGET  0x04 /* BAD target.                             */
  77. #define DID_ABORT       0x05 /* Told to abort for some other reason     */
  78. #define DID_PARITY      0x06 /* Parity error                            */
  79. #define DID_ERROR       0x07 /* Internal error                          */
  80. #define DID_RESET       0x08 /* Reset by somebody.                      */
  81. #define DID_BAD_INTR    0x09 /* Got an interrupt we weren't expecting.  */ 
  82. #endif
  84. /*
  85.  *  These indicate the error that occurred, and what is available.
  86.  */
  87. #ifndef DRIVER_BUSY
  88. #define DRIVER_BUSY         0x01
  89. #define DRIVER_SOFT         0x02
  90. #define DRIVER_MEDIA        0x03
  91. #define DRIVER_ERROR        0x04
  92.  
  93. #define DRIVER_INVALID      0x05
  94. #define DRIVER_TIMEOUT      0x06
  95. #define DRIVER_HARD         0x07
  96. #define DRIVER_SENSE        0x08
  97. #endif
  99. /*
  100.  * XXX Should add extra space in buscookies and scgfiles for a "PP bus"
  101.  * XXX and for two "ATAPI busses".
  102.  */
  103. #define MAX_SCG 16 /* Max # of SCSI controllers */
  104. #define MAX_TGT 16
  105. #define MAX_LUN 8
  107. struct scg_local {
  108. int scgfile; /* Used for SG_GET_BUFSIZE ioctl()*/
  109. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  110. short buscookies[MAX_SCG];
  111. int pgbus;
  112. int pack_id; /* Should be a random number */
  113. char *SCSIbuf;
  114. };
  115. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  117. #ifdef SG_BIG_BUFF
  118. #define MAX_DMA_LINUX SG_BIG_BUFF /* Defined in include/scsi/sg.h */
  119. #else
  120. #define MAX_DMA_LINUX (4*1024) /* Old Linux versions */
  121. #endif
  123. #ifndef SG_MAX_SENSE
  124. # define SG_MAX_SENSE 16 /* Too small for CCS / SCSI-2 */
  125. #endif /* But cannot be changed */
  127. #if !defined(__i386) && !defined(i386) && !defined(mc68000)
  128. #define MISALIGN
  129. #endif
  130. /*#define MISALIGN*/
  131. /*#undef SG_GET_BUFSIZE*/
  133. #if defined(USE_PG) && !defined(USE_PG_ONLY)
  134. #include "scsi-linux-pg.c"
  135. #endif
  137. #ifdef MISALIGN
  138. LOCAL int scsi_getint __PR((int *ip));
  139. #endif
  140. LOCAL int scsi_send __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  141. LOCAL BOOL sg_setup __PR((SCSI *scgp, int f, int busno, int tgt, int tlun));
  142. LOCAL void sg_initdev __PR((SCSI *scgp, int f));
  143. LOCAL int sg_mapbus __PR((SCSI *scgp, int busno, int ino));
  144. LOCAL BOOL sg_mapdev __PR((SCSI *scgp, int f, int *busp, int *tgtp, int *lunp,
  145. int *chanp, int *inop));
  146. LOCAL void sg_settimeout __PR((int f, int timeout));
  148. EXPORT int
  149. scsi_open(scgp, device, busno, tgt, tlun)
  150. SCSI *scgp;
  151. char *device;
  152. int busno;
  153. int tgt;
  154. int tlun;
  155. {
  156. register int f;
  157. register int i;
  158. register int b;
  159. register int t;
  160. register int l;
  161. register int nopen = 0;
  162. char devname[64];
  164. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  165. errno = EINVAL;
  166. if (scgp->errstr)
  167. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  168. "Illegal value for busno, target or lun '%d,%d,%d'",
  169. busno, tgt, tlun);
  170. return (-1);
  171. }
  173. if (scgp->local == NULL) {
  174. scgp->local = malloc(sizeof(struct scg_local));
  175. if (scgp->local == NULL)
  176. return (0);
  178. scglocal(scgp)->scgfile = -1;
  179. scglocal(scgp)->pgbus = -2;
  180. scglocal(scgp)->SCSIbuf = (char *)-1;
  181. scglocal(scgp)->pack_id = 5;
  183. for (b=0; b < MAX_SCG; b++) {
  184. scglocal(scgp)->buscookies[b] = (short)-1;
  185. for (t=0; t < MAX_TGT; t++) {
  186. for (l=0; l < MAX_LUN ; l++)
  187. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  188. }
  189. }
  190. }
  192. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2))
  193. goto openbydev;
  195. for (i=0; i < 32; i++) {
  196. sprintf(devname, "/dev/sg%d", i);
  197. f = open(devname, 2);
  198. if (f < 0) {
  199. if (errno != EACCES && errno != ENOENT && errno != ENXIO && errno != ENODEV) {
  200. if (scgp->errstr)
  201. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  202. "Cannot open '%s'", devname);
  203. return (0);
  204. }
  205. } else {
  206. if (sg_setup(scgp, f, busno, tgt, tlun))
  207. return (++nopen);
  208. if (busno < 0 && tgt < 0 && tlun < 0)
  209. nopen++;
  210. }
  211. }
  212. if (nopen == 0) for (i=0; i <= 25; i++) {
  213. sprintf(devname, "/dev/sg%c", i+'a');
  214. f = open(devname, 2);
  215. if (f < 0) {
  216. if (errno != ENOENT && errno != ENXIO && errno != ENODEV) {
  217. if (scgp->errstr)
  218. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  219. "Cannot open '%s'", devname);
  220. return (0);
  221. }
  222. } else {
  223. if (sg_setup(scgp, f, busno, tgt, tlun))
  224. return (++nopen);
  225. if (busno < 0 && tgt < 0 && tlun < 0)
  226. nopen++;
  227. }
  228. }
  229. openbydev:
  230. if (device != NULL && *device != '') {
  231. f = open(device, 2);
  232. if (f < 0 && errno == ENOENT)
  233. goto openpg;
  235. if (!sg_mapdev(scgp, f, &busno, &tgt, &tlun, 0, 0)) {
  236. close(f);
  237. goto openpg;
  238. }
  240. if (scgp->scsibus < 0)
  241. scgp->scsibus = busno;
  242. if (scgp->target < 0)
  243. scgp->target = tgt;
  244. if (scgp->lun < 0)
  245. scgp->lun = tlun;
  247. if (sg_setup(scgp, f, busno, tgt, tlun))
  248. return (++nopen);
  249. }
  250. openpg:
  251. #ifdef USE_PG
  252. nopen += pg_open(scgp, device, busno, tgt, tlun);
  253. #endif
  254. if (scgp->debug) for (b=0; b < MAX_SCG; b++) {
  255. printf("Bus: %d cookie: %Xn", b, scglocal(scgp)->buscookies[b]);
  256. for (t=0; t < MAX_TGT; t++) {
  257. for (l=0; l < MAX_LUN ; l++)
  258. if (scglocal(scgp)->scgfiles[b][t][l] != (short)-1)
  259. printf("file (%d,%d,%d): %dn",
  260. b, t, l, scglocal(scgp)->scgfiles[b][t][l]);
  261. }
  262. }
  263. return (nopen);
  264. }
  266. EXPORT int
  267. scsi_close(scgp)
  268. SCSI *scgp;
  269. {
  270. register int f;
  271. register int b;
  272. register int t;
  273. register int l;
  275. if (scgp->local == NULL)
  276. return (-1);
  278. for (b=0; b < MAX_SCG; b++) {
  279. if (b == scglocal(scgp)->pgbus)
  280. continue;
  281. scglocal(scgp)->buscookies[b] = (short)-1;
  282. for (t=0; t < MAX_TGT; t++) {
  283. for (l=0; l < MAX_LUN ; l++) {
  284. f = scglocal(scgp)->scgfiles[b][t][l];
  285. if (f >= 0)
  286. close(f);
  287. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  288. }
  289. }
  290. }
  291. #ifdef USE_PG
  292. pg_close(scgp);
  293. #endif
  294. return (0);
  295. }
  297. LOCAL BOOL
  298. sg_setup(scgp, f, busno, tgt, tlun)
  299. SCSI *scgp;
  300. int f;
  301. int busno;
  302. int tgt;
  303. int tlun;
  304. {
  305. int n;
  306. int Chan;
  307. int Ino;
  308. int Bus;
  309. int Target;
  310. int Lun;
  311. BOOL onetarget = FALSE;
  314. if (scgp->scsibus >= 0 && scgp->target >= 0 && scgp->lun >= 0)
  315. onetarget = TRUE;
  317. sg_mapdev(scgp, f, &Bus, &Target, &Lun, &Chan, &Ino);
  319. /*
  320.  * For old kernels try to make the best guess.
  321.  */
  322. Ino |= Chan << 8;
  323. n = sg_mapbus(scgp, Bus, Ino);
  324. if (Bus == -1) {
  325. Bus = n;
  326. if (scgp->debug)
  327. printf("SCSI Bus: %d (mapped from %d)n", Bus, Ino);
  328. }
  330. if (Bus < 0 || Bus >= MAX_SCG || Target < 0 || Target >= MAX_TGT ||
  331. Lun < 0 || Lun >= MAX_LUN) {
  332. return (FALSE);
  333. }
  335. if (scglocal(scgp)->scgfiles[Bus][Target][Lun] == (short)-1)
  336. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)f;
  338. if (onetarget) {
  339. if (Bus == busno && Target == tgt && Lun == tlun) {
  340. sg_initdev(scgp, f);
  341. scglocal(scgp)->scgfile = f; /* remember file for ioctl's */
  342. return (TRUE);
  343. } else {
  344. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)-1;
  345. close(f);
  346. }
  347. } else {
  348. sg_initdev(scgp, f);
  349. if (scglocal(scgp)->scgfile < 0)
  350. scglocal(scgp)->scgfile = f; /* remember file for ioctl's */
  351. }
  352. return (FALSE);
  353. }
  355. LOCAL void
  356. sg_initdev(scgp, f)
  357. SCSI *scgp;
  358. int f;
  359. {
  360. struct sg_rep {
  361. struct sg_header hd;
  362. unsigned char rbuf[100];
  363. } sg_rep;
  364. int n;
  366. /* Eat any unwanted garbage from prior use of this device */
  368. n = fcntl(f, F_GETFL); /* Be very proper about this */
  369. fcntl(f, F_SETFL, n|O_NONBLOCK);
  371. fillbytes((caddr_t)&sg_rep, sizeof(struct sg_header), '');
  372. sg_rep.hd.reply_len = sizeof(struct sg_header);
  374. while (read(f, &sg_rep, sizeof(sg_rep)) >= 0 || errno != EAGAIN)
  375. ;
  377. fcntl(f, F_SETFL, n);
  379. sg_settimeout(f, scgp->deftimeout);
  380. }
  382. LOCAL int
  383. sg_mapbus(scgp, busno, ino)
  384. SCSI *scgp;
  385. int busno;
  386. int ino;
  387. {
  388. register int i;
  390. if (busno >= 0 && busno < MAX_SCG) {
  391. /*
  392.  * SCSI_IOCTL_GET_BUS_NUMBER worked.
  393.  * Now we have the problem that Linux does not properly number
  394.  * SCSI busses. The Bus number that Linux creates really is
  395.  * the controller (card) number. I case of multi SCSI bus
  396.  * cards we are lost.
  397.  */
  398. if (scglocal(scgp)->buscookies[busno] == (short)-1) {
  399. scglocal(scgp)->buscookies[busno] = ino;
  400. return (busno);
  401. }
  402. if (scglocal(scgp)->buscookies[busno] != (short)ino)
  403. errmsgno(EX_BAD, "Warning Linux Bus mapping botch.n");
  404. return (busno);
  406. } else for (i=0; i < MAX_SCG; i++) {
  407. if (scglocal(scgp)->buscookies[i] == (short)-1) {
  408. scglocal(scgp)->buscookies[i] = ino;
  409. return (i);
  410. }
  412. if (scglocal(scgp)->buscookies[i] == ino)
  413. return (i);
  414. }
  415. return (0);
  416. }
  418. LOCAL BOOL
  419. sg_mapdev(scgp, f, busp, tgtp, lunp, chanp, inop)
  420. SCSI *scgp;
  421. int f;
  422. int *busp;
  423. int *tgtp;
  424. int *lunp;
  425. int *chanp;
  426. int *inop;
  427. {
  428. struct sg_id {
  429. long l1; /* target | lun << 8 | channel << 16 | low_ino << 24 */
  430. long l2; /* Unique id */
  431. } sg_id;
  432. int Chan;
  433. int Ino;
  434. int Bus;
  435. int Target;
  436. int Lun;
  438. if (ioctl(f, SCSI_IOCTL_GET_IDLUN, &sg_id))
  439. return (FALSE);
  440. if (scgp->debug)
  441. printf("l1: 0x%lX l2: 0x%lXn", sg_id.l1, sg_id.l2);
  442. if (ioctl(f, SCSI_IOCTL_GET_BUS_NUMBER, &Bus) < 0) {
  443. Bus = -1;
  444. }
  446. Target = sg_id.l1 & 0xFF;
  447. Lun = (sg_id.l1 >> 8) & 0xFF;
  448. Chan = (sg_id.l1 >> 16) & 0xFF;
  449. Ino = (sg_id.l1 >> 24) & 0xFF;
  450. if (scgp->debug) {
  451. printf("Bus: %d Target: %d Lun: %d Chan: %d Ino: %dn",
  452. Bus, Target, Lun, Chan, Ino);
  453. }
  454. *busp = Bus;
  455. *tgtp = Target;
  456. *lunp = Lun;
  457. if (chanp)
  458. *chanp = Chan;
  459. if (inop)
  460. *inop = Ino;
  461. return (TRUE);
  462. }
  464. LOCAL long
  465. scsi_maxdma(scgp)
  466. SCSI *scgp;
  467. {
  468. long maxdma = MAX_DMA_LINUX;
  470. #ifdef SG_GET_BUFSIZE
  471. /*
  472.  * We assume that all /dev/sg instances use the same
  473.  * maximum buffer size.
  474.  */
  475. if ((maxdma = ioctl(scglocal(scgp)->scgfile, SG_GET_BUFSIZE, 0)) < 0) {
  476. if (scglocal(scgp)->scgfile >= 0) {
  477. maxdma = MAX_DMA_LINUX;
  478. }
  479. }
  480. #endif
  481. #ifdef USE_PG
  482. if (scgp->scsibus == scglocal(scgp)->pgbus)
  483. return (pg_maxdma(scgp));
  484. if ((scgp->scsibus < 0) && (pg_maxdma(scgp) < maxdma))
  485. return (pg_maxdma(scgp));
  486. #endif
  487. return (maxdma);
  488. }
  490. EXPORT void *
  491. scsi_getbuf(scgp, amt)
  492. SCSI *scgp;
  493. long amt;
  494. {
  495. char *ret;
  497. if (amt <= 0 || amt > scsi_maxdma(scgp))
  498. return ((void *)0);
  499. if (scgp->debug)
  500. printf("scsi_getbuf: %ld bytesn", amt);
  501. /*
  502.  * For performance reason, we allocate pagesize()
  503.  * bytes before the SCSI buffer to avoid
  504.  * copying the whole buffer contents when
  505.  * setting up the /dev/sg data structures.
  506.  */
  507. ret = valloc((size_t)(amt+getpagesize()));
  508. if (ret == NULL)
  509. return (ret);
  510. scgp->bufbase = ret;
  511. ret += getpagesize();
  512. scglocal(scgp)->SCSIbuf = ret;
  513. return ((void *)ret);
  514. }
  516. EXPORT void
  517. scsi_freebuf(scgp)
  518. SCSI *scgp;
  519. {
  520. if (scgp->bufbase)
  521. free(scgp->bufbase);
  522. scgp->bufbase = NULL;
  523. }
  525. EXPORT
  526. BOOL scsi_havebus(scgp, busno)
  527. SCSI *scgp;
  528. int busno;
  529. {
  530. register int t;
  531. register int l;
  533. if (busno < 0 || busno >= MAX_SCG)
  534. return (FALSE);
  536. if (scgp->local == NULL)
  537. return (FALSE);
  539. for (t=0; t < MAX_TGT; t++) {
  540. for (l=0; l < MAX_LUN ; l++)
  541. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  542. return (TRUE);
  543. }
  544. return (FALSE);
  545. }
  547. EXPORT
  548. int scsi_fileno(scgp, busno, tgt, tlun)
  549. SCSI *scgp;
  550. int busno;
  551. int tgt;
  552. int tlun;
  553. {
  554. if (busno < 0 || busno >= MAX_SCG ||
  555.     tgt < 0 || tgt >= MAX_TGT ||
  556.     tlun < 0 || tlun >= MAX_LUN)
  557. return (-1);
  559. if (scgp->local == NULL)
  560. return (-1);
  562. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  563. }
  565. EXPORT int
  566. scsi_initiator_id(scgp)
  567. SCSI *scgp;
  568. {
  569. #ifdef USE_PG
  570. if (scgp->scsibus == scglocal(scgp)->pgbus)
  571. return (pg_initiator_id(scgp));
  572. #endif
  573. return (-1);
  574. }
  576. EXPORT
  577. int scsi_isatapi(scgp)
  578. SCSI *scgp;
  579. {
  580. #ifdef USE_PG
  581. if (scgp->scsibus == scglocal(scgp)->pgbus)
  582. return (pg_isatapi(scgp));
  583. #endif
  585. #ifdef SG_EMULATED_HOST
  586. {
  587. int emulated = FALSE;
  588. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  590. if (ioctl(f, SG_EMULATED_HOST, &emulated) >= 0)
  591. return (emulated != 0);
  592. }
  593. #endif
  594. return (-1);
  595. }
  597. EXPORT
  598. int scsireset(scgp)
  599. SCSI *scgp;
  600. {
  601. #ifdef USE_PG
  602. if (scgp->scsibus == scglocal(scgp)->pgbus)
  603. return (pg_reset(scgp));
  604. #endif
  605. /*
  606.  * Do we have a SCSI reset in the Linux sg driver?
  607.  */
  608. return (-1);
  609. }
  611. LOCAL void
  612. sg_settimeout(f, tmo)
  613. int f;
  614. int tmo;
  615. {
  616. tmo *= HZ;
  617. if (tmo)
  618. tmo += HZ/2;
  620. if (ioctl(f, SG_SET_TIMEOUT, &tmo) < 0)
  621. comerr("Cannot set SG_SET_TIMEOUT.n");
  622. }
  624. /*
  625.  * Get misaligned int.
  626.  * Needed for all recent processors (sparc/ppc/alpha)
  627.  * because the /dev/sg design forces us to do misaligned
  628.  * reads of integers.
  629.  */
  630. #ifdef MISALIGN
  631. LOCAL int
  632. scsi_getint(ip)
  633. int *ip;
  634. {
  635.  int ret;
  636. register char *cp = (char *)ip;
  637. register char *tp = (char *)&ret;
  638. register int i;
  640. for (i = sizeof(int); --i >= 0; )
  641. *tp++ = *cp++;
  643. return (ret);
  644. }
  645. #define GETINT(a) scsi_getint(&(a))
  646. #else
  647. #define GETINT(a) (a)
  648. #endif
  650. LOCAL int
  651. scsi_send(scgp, f, sp)
  652. SCSI *scgp;
  653. int f;
  654. struct scg_cmd *sp;
  655. {
  656. struct sg_rq *sgp;
  657. struct sg_rq *sgp2;
  658. int i;
  659. int pack_len;
  660. int reply_len;
  661. int amt = sp->cdb_len;
  662. struct sg_rq {
  663. struct sg_header hd;
  664. unsigned char buf[MAX_DMA_LINUX+SCG_MAX_CMD];
  665. } sg_rq;
  666. #ifdef SG_GET_BUFSIZE /* We may use a 'sg' version 2 driver */
  667. char driver_byte;
  668. char host_byte;
  669. char msg_byte;
  670. char status_byte;
  671. #endif
  673. if (f < 0) {
  674. sp->error = SCG_FATAL;
  675. return (0);
  676. }
  677. #ifdef USE_PG
  678. if (scgp->scsibus == scglocal(scgp)->pgbus)
  679. return (pg_send(scgp, f, sp));
  680. #endif
  681. if (sp->timeout != scgp->deftimeout)
  682. sg_settimeout(f, sp->timeout);
  685. sgp2 = sgp = &sg_rq;
  686. if (sp->addr == scglocal(scgp)->SCSIbuf) {
  687. sgp = (struct sg_rq *)
  688. (scglocal(scgp)->SCSIbuf - (sizeof(struct sg_header) + amt));
  689. sgp2 = (struct sg_rq *)
  690. (scglocal(scgp)->SCSIbuf - (sizeof(struct sg_header)));
  691. } else {
  692. if (scgp->debug) {
  693. printf("DMA addr: 0x%8.8lX size: %d - using copy buffern",
  694. (long)sp->addr, sp->size);
  695. }
  696. if (sp->size > (int)(sizeof(sg_rq.buf) - SCG_MAX_CMD)) {
  697. errno = ENOMEM;
  698. return (-1);
  699. }
  700. }
  702. /*
  703.  * This is done to avoid misaligned access of sgp->some_int
  704.  */
  705. pack_len = sizeof(struct sg_header) + amt;
  706. reply_len = sizeof(struct sg_header);
  707. if (sp->flags & SCG_RECV_DATA) {
  708. reply_len += sp->size;
  709. } else {
  710. pack_len += sp->size;
  711. }
  713. #ifdef MISALIGN
  714. /*
  715.  * sgp->some_int may be misaligned if (sp->addr == SCSIbuf)
  716.  * This is no problem on Intel porocessors, however
  717.  * all other processors don't like it.
  718.  * sizeof(struct sg_header) + amt is usually not a multiple of
  719.  * sizeof(int). For this reason, we fill in the values into sg_rq
  720.  * which is always corectly aligned and then copy it to the real
  721.  * location if this location differs from sg_rq.
  722.  * Never read/write directly to sgp->some_int !!!!!
  723.  */
  724. fillbytes((caddr_t)&sg_rq, sizeof(struct sg_header), '');
  726. sg_rq.hd.pack_len = pack_len;
  727. sg_rq.hd.reply_len = reply_len;
  728. sg_rq.hd.pack_id = scglocal(scgp)->pack_id++;
  729. /* sg_rq.hd.result = 0; not needed because of fillbytes() */
  731. if ((caddr_t)&sg_rq != (caddr_t)sgp)
  732. movebytes((caddr_t)&sg_rq, (caddr_t)sgp, sizeof(struct sg_header));
  733. #else
  734. fillbytes((caddr_t)sgp, sizeof(struct sg_header), '');
  736. sgp->hd.pack_len = pack_len;
  737. sgp->hd.reply_len = reply_len;
  738. sgp->hd.pack_id = scglocal(scgp)->pack_id++;
  739. /* sgp->hd.result = 0; not needed because of fillbytes() */
  740. #endif
  741. if (amt == 12)
  742. sgp->hd.twelve_byte = 1;
  745. for (i = 0; i < amt; i++ ) {
  746. sgp->buf[i] = sp->cdb.cmd_cdb[i];;
  747. }
  748. if (!(sp->flags & SCG_RECV_DATA)) {
  749. if ((void *)sp->addr != (void *)&sgp->buf[amt])
  750. movebytes(sp->addr, &sgp->buf[amt], sp->size);
  751. amt += sp->size;
  752. }
  753. #ifdef SG_GET_BUFSIZE
  754. sgp->hd.want_new  = 1; /* Order new behaviour */
  755. sgp->hd.cdb_len   = sp->cdb_len; /* Set CDB length */
  756. if (sp->sense_len > SG_MAX_SENSE)
  757. sgp->hd.sense_len = SG_MAX_SENSE;
  758. else
  759. sgp->hd.sense_len = sp->sense_len;
  760. #endif
  761. i = sizeof(struct sg_header) + amt;
  762. if ((amt = write(f, sgp, i)) < 0) { /* write */
  763. sg_settimeout(f, scgp->deftimeout);
  764. return (-1);
  765. } else if (amt != i) {
  766. errmsg("scsi_send(%s) wrote %d bytes (expected %d).n",
  767. scgp->cmdname, amt, i);
  768. }
  770. if (sp->addr == scglocal(scgp)->SCSIbuf) {
  771. movebytes(sgp, sgp2, sizeof(struct sg_header));
  772. sgp = sgp2;
  773. }
  774. sgp->hd.sense_buffer[0] = 0;
  775. if ((amt = read(f, sgp, reply_len)) < 0) { /* read */
  776. sg_settimeout(f, scgp->deftimeout);
  777. return (-1);
  778. }
  780. if (sp->flags & SCG_RECV_DATA && ((void *)sgp->buf != (void *)sp->addr)) {
  781. movebytes(sgp->buf, sp->addr, sp->size);
  782. }
  783. sp->ux_errno = GETINT(sgp->hd.result); /* Unaligned read */
  784. sp->error = SCG_NO_ERROR;
  786. #ifdef SG_GET_BUFSIZE
  787. if (sgp->hd.grant_new) {
  788. sp->sense_count = sgp->hd.sense_len;
  789. pack_len    = GETINT(sgp->hd.sg_cmd_status); /* Unaligned read */
  790. driver_byte = (pack_len  >> 24) & 0xFF;
  791. host_byte   = (pack_len  >> 16) & 0xFF;
  792. msg_byte    = (pack_len  >> 8) & 0xFF;
  793. status_byte =  pack_len  & 0xFF;
  795. switch (host_byte) {
  797. case DID_OK:
  798. if ((driver_byte & DRIVER_SENSE ||
  799.     sgp->hd.sense_buffer[0] != 0)
  800. && status_byte == 0) {
  801. /*
  802.  * The Linux SCSI system up to 2.1.xx
  803.  * trashes the status byte in the
  804.  * kernel. This is true at least for
  805.  * ide-scsi emulation. Until this gets
  806.  * fixed, we need this hack.
  807.  */
  808. sp->error = SCG_RETRYABLE;
  809. status_byte = ST_CHK_COND;
  810. if (sgp->hd.sense_len == 0)
  811. sgp->hd.sense_len = SG_MAX_SENSE;
  812. }
  813. break;
  815. case DID_NO_CONNECT: /* Arbitration won, retry NO_CONNECT? */
  816. case DID_BAD_TARGET:
  817. sp->error = SCG_FATAL;
  818. break;
  820. case DID_TIME_OUT:
  821. sp->error = SCG_TIMEOUT;
  822. break;
  824. default:
  825. sp->error = SCG_RETRYABLE;
  827. if ((driver_byte & DRIVER_SENSE ||
  828.     sgp->hd.sense_buffer[0] != 0)
  829. && status_byte == 0)
  830. status_byte = ST_CHK_COND;
  831. if (status_byte != 0 && sgp->hd.sense_len == 0)
  832. sgp->hd.sense_len = SG_MAX_SENSE;
  833. break;
  835. }
  836. if ((host_byte != DID_OK || status_byte != 0) && sp->ux_errno == 0)
  837. sp->ux_errno = EIO;
  838. sp->u_scb.cmd_scb[0] = status_byte;
  839. if (status_byte & ST_CHK_COND) {
  840. sp->sense_count = sgp->hd.sense_len;
  841. movebytes(sgp->hd.sense_buffer, sp->u_sense.cmd_sense, sp->sense_count);
  842. }
  843. } else
  844. #endif
  845. {
  846. if (GETINT(sgp->hd.result) == EBUSY) { /* Unaligned read */
  847. struct timeval to;
  849. to.tv_sec = sp->timeout;
  850. to.tv_usec = 500000;
  851. scsitimes(scgp);
  853. if (scgp->cmdstop->tv_sec < to.tv_sec ||
  854.     (scgp->cmdstop->tv_sec == to.tv_sec &&
  855. scgp->cmdstop->tv_usec < to.tv_usec)) {
  857. sp->ux_errno = 0;
  858. sp->error = SCG_TIMEOUT; /* a timeout */
  859. } else {
  860. sp->error = SCG_RETRYABLE; /* may be BUS_BUSY */
  861. }
  862. }
  864. if (sp->flags & SCG_RECV_DATA)
  865. sp->resid = (sp->size + sizeof(struct sg_header)) - amt;
  866. else
  867. sp->resid = 0; /* sg version1 cannot return DMA resid count */
  869. if (sgp->hd.sense_buffer[0] != 0) {
  870. sp->error = SCG_RETRYABLE;
  871. sp->scb.chk = 1;
  872. sp->sense_count = SG_MAX_SENSE;
  873. movebytes(sgp->hd.sense_buffer, sp->u_sense.cmd_sense, sp->sense_count);
  874. if (sp->ux_errno == 0)
  875. sp->ux_errno = EIO;
  876. }
  877. }
  879. if (scgp->verbose > 0 && scgp->debug) {
  880. #ifdef SG_GET_BUFSIZE
  881. printf("status: 0x%08X pack_len: %d, reply_len: %d pack_id: %d result: %d wn: %d gn: %d cdb_len: %d sense_len: %d sense[0]: %02Xn",
  882. GETINT(sgp->hd.sg_cmd_status),
  883. GETINT(sgp->hd.pack_len),
  884. GETINT(sgp->hd.reply_len),
  885. GETINT(sgp->hd.pack_id),
  886. GETINT(sgp->hd.result),
  887. sgp->hd.want_new,
  888. sgp->hd.grant_new,
  889. sgp->hd.cdb_len,
  890. sgp->hd.sense_len,
  891. sgp->hd.sense_buffer[0]);
  892. #else
  893. printf("pack_len: %d, reply_len: %d pack_id: %d result: %d sense[0]: %02Xn",
  894. GETINT(sgp->hd.pack_len),
  895. GETINT(sgp->hd.reply_len),
  896. GETINT(sgp->hd.pack_id),
  897. GETINT(sgp->hd.result),
  898. sgp->hd.sense_buffer[0]);
  899. #endif
  900. #ifdef DEBUG
  901. printf("sense: ");
  902. for (i=0; i < 16; i++)
  903. printf("%02X ", sgp->hd.sense_buffer[i]);
  904. printf("n");
  905. #endif
  906. }
  908. if (sp->timeout != scgp->deftimeout)
  909. sg_settimeout(f, scgp->deftimeout);
  910. return 0;
  911. }