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

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

SCSI/ASPI

开发平台：

MultiPlatform

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