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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-linux-pg.c：源码内容
  1. /* @(#)scsi-linux-pg.c 1.18 99/09/07 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char ___sccsid[] =
  4. "@(#)scsi-linux-pg.c 1.18 99/09/07 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * Interface for the Linux PARIDE implementation.
  8.  *
  9.  * We emulate the functionality of the scg driver, via the pg driver.
  10.  *
  11.  * Copyright (c) 1997  J. Schilling
  12.  * Copyright (c) 1998  Grant R. Guenther <grant@torque.net>
  13.  *     Under the terms of the GNU public license.
  14.  */
  15. /*
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2, or (at your option)
  19.  * any later version.
  20.  *
  21.  * This program is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  * GNU General Public License for more details.
  25.  *
  26.  * You should have received a copy of the GNU General Public License
  27.  * along with this program; see the file COPYING.  If not, write to
  28.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  */
  31. #include <linux/pg.h>
  33. #ifdef USE_PG_ONLY
  35. #define MAX_SCG 1 /* Max # of SCSI controllers */
  36. #define MAX_TGT 8
  37. #define MAX_LUN 8
  39. struct scg_local {
  40. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  41. short buscookies[MAX_SCG];
  42. int pgbus;
  43. char *SCSIbuf;
  44. };
  45. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  47. #else
  49. #define scsi_open pg_open
  50. #define scsi_close pg_close
  51. #define scsi_send pg_send
  52. #define scsi_maxdma pg_maxdma
  53. #define scsi_initiator_id pg_initiator_id
  54. #define scsi_isatapi pg_isatapi
  55. #define scsireset pg_reset
  57. LOCAL int pg_open __PR((SCSI *scgp, char *device, int busno, int tgt, int tlun));
  58. LOCAL int pg_close __PR((SCSI *scgp));
  59. LOCAL long pg_maxdma __PR((SCSI *scgp));
  60. LOCAL int  pg_initiator_id __PR((SCSI *scgp));
  61. LOCAL int  pg_isatapi __PR((SCSI *scgp));
  62. LOCAL int pg_reset __PR((SCSI *scgp));
  63. LOCAL int pg_send __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  65. #endif
  67. LOCAL int do_scsi_cmd __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  68. LOCAL int do_scsi_sense __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  71. EXPORT int
  72. scsi_open(scgp, device, busno, tgt, tlun)
  73. SCSI *scgp;
  74. char *device;
  75. int busno;
  76. int tgt;
  77. int tlun;
  78. {
  79. register int f;
  80. register int b;
  81. #ifdef USE_PG_ONLY
  82. register int t;
  83. register int l;
  84. #endif
  85. register int nopen = 0;
  86. char devname[32];
  88. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  89. errno = EINVAL;
  90. if (scgp->errstr)
  91. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  92. "Illegal value for busno, target or lun '%d,%d,%d'",
  93. busno, tgt, tlun);
  94. return (-1);
  95. }
  97. #ifndef USE_PG_ONLY
  98. /*
  99.  * We need to find a fake bus number for the parallel port interface.
  100.  * Unfortunatly, the buscookie array may contain holes if
  101.  * SCSI_IOCTL_GET_BUS_NUMBER works, so we are searching backwards
  102.  * for some place for us.
  103.  * XXX Should add extra space in buscookies for a "PP bus".
  104.  */
  106. if (scglocal(scgp)->buscookies[MAX_SCG-1] != (short)-1)
  107. return (0); /* No space for pgbus */
  109. for (b=MAX_SCG-1; b >= 0; b--) {
  110. if (scglocal(scgp)->buscookies[b] != (short)-1) {
  111. scglocal(scgp)->pgbus = ++b;
  112. break;
  113. }
  114. }
  115. if (scgp->debug)
  116. printf("PP Bus: %dn", scglocal(scgp)->pgbus);
  117. #else
  118. if (scgp->local == NULL) {
  119. scgp->local = malloc(sizeof(struct scg_local));
  120. if (scgp->local == NULL)
  121. return (0);
  123. scglocal(scgp)->pgbus = -2;
  124. scglocal(scgp)->SCSIbuf = (char *)-1;
  126. for (b=0; b < MAX_SCG; b++) {
  127. for (t=0; t < MAX_TGT; t++) {
  128. for (l=0; l < MAX_LUN ; l++)
  129. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  130. }
  131. }
  132. }
  133. #endif
  134. if (scglocal(scgp)->pgbus < 0)
  135. scglocal(scgp)->pgbus = 0;
  137. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2))
  138. goto openbydev;
  140. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  141. #ifndef USE_PG_ONLY
  142. if (scglocal(scgp)->pgbus != busno)
  143. return (0);
  144. #endif
  145. sprintf(devname, "/dev/pg%d", tgt);
  146. f = open(devname, 2);
  147. if (f < 0) {
  148. if (scgp->errstr)
  149. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  150. "Cannot open '%s'", devname);
  151. return (0);
  152. }
  153. scglocal(scgp)->scgfiles[busno][tgt][tlun] = f;
  154. return 1;
  155. } else {
  156. /* scgp->scsibus = 0; scgp->lun = 0;*/
  157. tlun = 0;
  158. for(tgt=0;tgt<MAX_TGT;tgt++) {
  159. sprintf(devname, "/dev/pg%d", tgt);
  160. f = open(devname, 2);
  161. if (f >= 0) {
  162. scglocal(scgp)->scgfiles[scglocal(scgp)->pgbus][tgt][tlun] = f;
  163. nopen++;
  164. }
  165. }
  166. }
  167. openbydev:
  168. if (device != NULL && *device != '') {
  169. char *p;
  171. if (tlun < 0)
  172. return (0);
  173. f = open(device, 2);
  174. if (f < 0 && errno == ENOENT)
  175. return (0);
  177. p = device + strlen(device) -1;
  178. tgt = *p - '0';
  179. if (tgt < 0 || tgt > 9)
  180. return (0);
  181. scgp->scsibus = scglocal(scgp)->pgbus;
  182. scgp->target = tgt;
  183. scgp->lun = tlun;
  184. scglocal(scgp)->scgfiles[scglocal(scgp)->pgbus][tgt][tlun] = f;
  185. return (++nopen);
  186. }
  187. return (nopen);
  188. }
  190. EXPORT int
  191. scsi_close(scgp)
  192. SCSI *scgp;
  193. {
  194. register int f;
  195. register int b;
  196. register int t;
  197. register int l;
  199. if (scgp->local == NULL)
  200. return (-1);
  201. if (scglocal(scgp)->pgbus < 0)
  202. return (0);
  203. b = scglocal(scgp)->pgbus;
  204. scglocal(scgp)->buscookies[b] = (short)-1;
  206. for (t=0; t < MAX_TGT; t++) {
  207. for (l=0; l < MAX_LUN ; l++) {
  208. f = scglocal(scgp)->scgfiles[b][t][l];
  209. if (f >= 0)
  210. close(f);
  211. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  212. }
  213. }
  214. return (0);
  215. }
  217. LOCAL long
  218. scsi_maxdma(scgp)
  219. SCSI *scgp;
  220. {
  221. return (PG_MAX_DATA);
  222. }
  224. #ifdef USE_PG_ONLY
  226. EXPORT void *
  227. scsi_getbuf(scgp, amt)
  228. SCSI *scgp;
  229. long amt;
  230. {
  231.         char    *ret;
  233. if (amt <= 0 || amt > scsi_maxdma(scgp))
  234.                 return ((void *)0);
  235.         if (scgp->debug)
  236.                 printf("scsi_getbuf: %ld bytesn", amt);
  238.         ret = valloc((size_t)(amt+getpagesize()));
  239.         if (ret == NULL)
  240.                 return (ret);
  241. scgp->bufbase = ret;
  242.         ret += getpagesize();
  243.         scglocal(scgp)->SCSIbuf = ret;
  244.         return ((void *)ret);
  246. }
  248. EXPORT void
  249. scsi_freebuf(scgp)
  250. SCSI *scgp;
  251. {
  252. if (scgp->bufbase)
  253. free(scgp->bufbase);
  254. scgp->bufbase = NULL;
  255. }
  257. EXPORT
  258. BOOL scsi_havebus(scgp, busno)
  259. SCSI *scgp;
  260. int busno;
  261. {
  262. register int t;
  263. register int l;
  265. if (busno < 0 || busno >= MAX_SCG)
  266. return (FALSE);
  268. if (scgp->local == NULL)
  269. return (FALSE);
  271. for (t=0; t < MAX_TGT; t++) {
  272. for (l=0; l < MAX_LUN ; l++)
  273. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  274. return (TRUE);
  275. }
  276. return (FALSE);
  277. }
  279. EXPORT
  280. int scsi_fileno(scgp, busno, tgt, tlun)
  281. SCSI *scgp;
  282. int busno;
  283. int tgt;
  284. int tlun;
  285. {
  286. if (busno < 0 || busno >= MAX_SCG ||
  287.     tgt < 0 || tgt >= MAX_TGT ||
  288.     tlun < 0 || tlun >= MAX_LUN)
  289. return (-1);
  291. if (scgp->local == NULL)
  292. return (-1);
  294. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  295. }
  296. #endif /* USE_PG_ONLY */
  298. EXPORT int
  299. scsi_initiator_id(scgp)
  300. SCSI *scgp;
  301. {
  302. return (-1);
  303. }
  305. EXPORT
  306. int scsi_isatapi(scgp)
  307. SCSI *scgp;
  308. {
  309. return (TRUE);
  310. }
  312. EXPORT
  313. int scsireset(scgp)
  314. SCSI *scgp;
  315. {
  316. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  318. struct pg_write_hdr hdr = {PG_MAGIC, PG_RESET, 0};
  320. return (write(f, (char *)&hdr, sizeof(hdr)));
  322. }
  324. #ifndef MAX
  325. #define MAX(a,b) ((a)>(b)?(a):(b))
  326. #endif
  328. #define RHSIZE sizeof(struct pg_read_hdr)
  329. #define WHSIZE  sizeof(struct pg_write_hdr)
  330. #define LEAD MAX(RHSIZE,WHSIZE)
  332. LOCAL int
  333. do_scsi_cmd(scgp, f, sp)
  334. SCSI *scgp;
  335. int f;
  336. struct scg_cmd *sp;
  337. {
  339. char local[LEAD+PG_MAX_DATA];
  340. int use_local, i, r;
  341. int inward = (sp->flags & SCG_RECV_DATA);
  343. struct pg_write_hdr *whp;
  344. struct pg_read_hdr  *rhp;
  345. char     *dbp;
  347. if (sp->cdb_len > 12)
  348. comerrno(EX_BAD, "Can't do %d byte command.n", sp->cdb_len);
  350. if (sp->addr == scglocal(scgp)->SCSIbuf) {
  351. use_local = 0; 
  352. dbp = sp->addr;
  353. } else {
  354. use_local = 1;
  355. dbp = &local[LEAD];
  356. if (!inward) 
  357. movebytes(sp->addr, dbp, sp->size);
  358. }
  360. whp = (struct pg_write_hdr *)(dbp - WHSIZE);
  361. rhp = (struct pg_read_hdr *)(dbp - RHSIZE);
  363. whp->magic   = PG_MAGIC;
  364. whp->func    = PG_COMMAND;
  365. whp->dlen    = sp->size;
  366. whp->timeout = sp->timeout;
  368. for(i=0; i<12; i++) {
  369. if (i < sp->cdb_len)
  370. whp->packet[i] = sp->cdb.cmd_cdb[i];
  371. else
  372. whp->packet[i] = 0;
  373. }
  375. i = WHSIZE;
  376. if (!inward) 
  377. i += sp->size;
  379. r = write(f, (char *)whp, i);
  381. if (r < 0) { /* command was not sent */
  382. sp->ux_errno = geterrno();
  383. if (sp->ux_errno == ETIME) {
  384. /*
  385.  * If the previous command timed out, we cannot send
  386.  * any further command until the command in the drive
  387.  * is ready. So we behave as if the drive did not
  388.  * respond to the command.
  389.  */
  390. sp->error = SCG_FATAL;
  391. return 0;
  392. }
  393. return -1;
  394. }
  396. if (r != i)
  397. errmsg("scsi_send(%s) wrote %d bytes (expected %d).n",
  398. scgp->cmdname, r, i);
  400. sp->ux_errno = 0;
  401. sp->sense_count = 0;
  403. r = read(f, (char *)rhp, RHSIZE+sp->size);
  405. if (r < 0) {
  406. sp->ux_errno = geterrno();
  407. if (sp->ux_errno == ETIME) {
  408. sp->error = SCG_TIMEOUT;
  409. return 0;
  410. }
  411. sp->error = SCG_FATAL;
  412. return -1;
  413. }
  415. i = rhp->dlen;
  416. if (i > sp->size) {
  417. /*
  418.  * "DMA overrun" should be handled in the kernel.
  419.  * However this may happen with flaky PP adapters.
  420.  */
  421. errmsgno(EX_BAD,
  422. "DMA (read) overrun by %d bytes (requested %d bytes).n",
  423. i - sp->size, sp->size);
  424. i = sp->size;
  425. }
  427. if (use_local && inward)
  428. movebytes(dbp, sp->addr, i);
  430. sp->resid = sp->size - i;
  432. fillbytes(&sp->scb, sizeof(sp->scb), '');
  433.         fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  435. sp->error = SCG_NO_ERROR;
  436. i = rhp->scsi?2:0;
  437. sp->u_scb.cmd_scb[0] = i;
  438. if (i) {
  439. if (sp->ux_errno == 0)
  440. sp->ux_errno = EIO;
  441. sp->error = SCG_RETRYABLE;
  442. }
  444. return 0;
  446. }
  448. LOCAL int
  449. do_scsi_sense(scgp, f, sp)
  450. SCSI *scgp;
  451. int f;
  452. struct scg_cmd *sp;
  453. {
  454.         int             ret;
  455.         struct scg_cmd  s_cmd;
  457.         if (sp->sense_len > SCG_MAX_SENSE)
  458.                 sp->sense_len = SCG_MAX_SENSE;
  460.         fillbytes((caddr_t)&s_cmd, sizeof(s_cmd), '');
  461.         s_cmd.addr = sp->u_sense.cmd_sense;
  462.         s_cmd.size = sp->sense_len;
  463.         s_cmd.flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  464.         s_cmd.cdb_len = SC_G0_CDBLEN;
  465.         s_cmd.sense_len = CCS_SENSE_LEN;
  466.         s_cmd.target = scgp->target;
  467.         s_cmd.cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
  468.         s_cmd.cdb.g0_cdb.lun = sp->cdb.g0_cdb.lun;
  469.         s_cmd.cdb.g0_cdb.count = sp->sense_len;
  470.         ret = do_scsi_cmd(scgp, f, &s_cmd);
  472.         if (ret < 0)
  473.                 return (ret);
  475.         sp->sense_count = sp->sense_len - s_cmd.resid;
  476.         return (ret);
  478. }
  480. LOCAL int
  481. scsi_send(scgp, f, sp)
  482. SCSI *scgp;
  483. int f;
  484. struct scg_cmd *sp;
  485. {
  486. int ret;
  488. if (f < 0) {
  489. sp->error = SCG_FATAL;
  490. return (0);
  491. }
  492. ret = do_scsi_cmd(scgp, f, sp);
  493. if (ret < 0)
  494. return (ret);
  495. if (sp->u_scb.cmd_scb[0])
  496. ret = do_scsi_sense(scgp, f, sp);
  497. return (ret);
  498. }
  500. /* end of scsi-linux-pg.c */
  502. #ifndef USE_PG_ONLY
  504. #undef scsi_open
  505. #undef scsi_close
  506. #undef scsi_send
  507. #undef scsi_maxdma
  508. #undef scsi_initiator_id
  509. #undef scsi_isatapi
  510. #undef scsireset
  512. #endif