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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-linux-pg.c：源码内容
  1. /* @(#)scsi-linux-pg.c 1.21 99/11/30 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char ___sccsid[] =
  4. "@(#)scsi-linux-pg.c 1.21 99/11/30 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.  * Warning: you may change this source, but if you do that
  12.  * you need to change the _scg_version and _scg_auth* string below.
  13.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  14.  * Choose your name instead of "schily" and make clear that the version
  15.  * string is related to a modified source.
  16.  *
  17.  * Copyright (c) 1997  J. Schilling
  18.  * Copyright (c) 1998  Grant R. Guenther <grant@torque.net>
  19.  *     Under the terms of the GNU public license.
  20.  */
  21. /*
  22.  * This program is free software; you can redistribute it and/or modify
  23.  * it under the terms of the GNU General Public License as published by
  24.  * the Free Software Foundation; either version 2, or (at your option)
  25.  * any later version.
  26.  *
  27.  * This program is distributed in the hope that it will be useful,
  28.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30.  * GNU General Public License for more details.
  31.  *
  32.  * You should have received a copy of the GNU General Public License
  33.  * along with this program; see the file COPYING.  If not, write to
  34.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  35.  */
  37. #ifdef HAVE_LINUX_PG_H
  38. #include <linux/pg.h>
  39. #else
  40. #include "pg.h" /* Use local version as Linux sometimes doesn't have */
  41. #endif /* installed. Now libscg always supports PP SCSI     */
  43. /*
  44.  * Warning: you may change this source, but if you do that
  45.  * you need to change the _scg_version and _scg_auth* string below.
  46.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  47.  * Choose your name instead of "schily" and make clear that the version
  48.  * string is related to a modified source.
  49.  */
  50. LOCAL char _scg_trans_version_pg[] = "scsi-linux-pg.c-1.21"; /* The version for this transport*/
  52. #ifdef USE_PG_ONLY
  54. #define MAX_SCG 1 /* Max # of SCSI controllers */
  55. #define MAX_TGT 8
  56. #define MAX_LUN 8
  58. struct scg_local {
  59. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  60. short buscookies[MAX_SCG];
  61. int pgbus;
  62. char *SCSIbuf;
  63. };
  64. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  66. #else
  68. #define scg__version pg_version
  69. #define scsi_open pg_open
  70. #define scsi_close pg_close
  71. #define scsi_send pg_send
  72. #define scsi_maxdma pg_maxdma
  73. #define scsi_initiator_id pg_initiator_id
  74. #define scsi_isatapi pg_isatapi
  75. #define scsireset pg_reset
  77. EXPORT char *pg_version __PR((SCSI *scgp, int what));
  78. LOCAL int pg_open __PR((SCSI *scgp, char *device, int busno, int tgt, int tlun));
  79. LOCAL int pg_close __PR((SCSI *scgp));
  80. LOCAL long pg_maxdma __PR((SCSI *scgp));
  81. LOCAL int  pg_initiator_id __PR((SCSI *scgp));
  82. LOCAL int  pg_isatapi __PR((SCSI *scgp));
  83. LOCAL int pg_reset __PR((SCSI *scgp));
  84. LOCAL int pg_send __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  86. #endif
  88. LOCAL int do_scsi_cmd __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  89. LOCAL int do_scsi_sense __PR((SCSI *scgp, int f, struct scg_cmd *sp));
  92. /*
  93.  * Return version information for the low level SCSI transport code.
  94.  * This has been introduced to make it easier to trace down problems
  95.  * in applications.
  96.  */
  97. EXPORT char *
  98. scg__version(scgp, what)
  99. SCSI *scgp;
  100. int what;
  101. {
  102. if (scgp != (SCSI *)0) {
  103. switch (what) {
  105. case SCG_VERSION:
  106. return (_scg_trans_version_pg);
  107. /*
  108.  * If you changed this source, you are not allowed to
  109.  * return "schily" for the SCG_AUTHOR request.
  110.  */
  111. case SCG_AUTHOR:
  112. return (_scg_auth_schily);
  113. case SCG_SCCS_ID:
  114. return (___sccsid);
  115. }
  116. }
  117. return ((char *)0);
  118. }
  120. EXPORT int
  121. scsi_open(scgp, device, busno, tgt, tlun)
  122. SCSI *scgp;
  123. char *device;
  124. int busno;
  125. int tgt;
  126. int tlun;
  127. {
  128. register int f;
  129. register int b;
  130. #ifdef USE_PG_ONLY
  131. register int t;
  132. register int l;
  133. #endif
  134. register int nopen = 0;
  135. char devname[32];
  137. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  138. errno = EINVAL;
  139. if (scgp->errstr)
  140. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  141. "Illegal value for busno, target or lun '%d,%d,%d'",
  142. busno, tgt, tlun);
  143. return (-1);
  144. }
  146. #ifndef USE_PG_ONLY
  147. /*
  148.  * We need to find a fake bus number for the parallel port interface.
  149.  * Unfortunatly, the buscookie array may contain holes if
  150.  * SCSI_IOCTL_GET_BUS_NUMBER works, so we are searching backwards
  151.  * for some place for us.
  152.  * XXX Should add extra space in buscookies for a "PP bus".
  153.  */
  155. if (scglocal(scgp)->buscookies[MAX_SCG-1] != (short)-1)
  156. return (0); /* No space for pgbus */
  158. for (b=MAX_SCG-1; b >= 0; b--) {
  159. if (scglocal(scgp)->buscookies[b] != (short)-1) {
  160. scglocal(scgp)->pgbus = ++b;
  161. break;
  162. }
  163. }
  164. if (scgp->debug)
  165. printf("PP Bus: %dn", scglocal(scgp)->pgbus);
  166. #else
  167. if (scgp->local == NULL) {
  168. scgp->local = malloc(sizeof(struct scg_local));
  169. if (scgp->local == NULL)
  170. return (0);
  172. scglocal(scgp)->pgbus = -2;
  173. scglocal(scgp)->SCSIbuf = (char *)-1;
  175. for (b=0; b < MAX_SCG; b++) {
  176. for (t=0; t < MAX_TGT; t++) {
  177. for (l=0; l < MAX_LUN ; l++)
  178. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  179. }
  180. }
  181. }
  182. #endif
  183. if (scglocal(scgp)->pgbus < 0)
  184. scglocal(scgp)->pgbus = 0;
  186. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2))
  187. goto openbydev;
  189. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  190. #ifndef USE_PG_ONLY
  191. if (scglocal(scgp)->pgbus != busno)
  192. return (0);
  193. #endif
  194. sprintf(devname, "/dev/pg%d", tgt);
  195. f = open(devname, 2);
  196. if (f < 0) {
  197. if (scgp->errstr)
  198. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  199. "Cannot open '%s'", devname);
  200. return (0);
  201. }
  202. scglocal(scgp)->scgfiles[busno][tgt][tlun] = f;
  203. return 1;
  204. } else {
  205. /* scgp->scsibus = 0; scgp->lun = 0;*/
  206. tlun = 0;
  207. for(tgt=0;tgt<MAX_TGT;tgt++) {
  208. sprintf(devname, "/dev/pg%d", tgt);
  209. f = open(devname, 2);
  210. if (f >= 0) {
  211. scglocal(scgp)->scgfiles[scglocal(scgp)->pgbus][tgt][tlun] = f;
  212. nopen++;
  213. }
  214. }
  215. }
  216. openbydev:
  217. if (device != NULL && *device != '') {
  218. char *p;
  220. if (tlun < 0)
  221. return (0);
  222. f = open(device, 2);
  223. if (f < 0 && errno == ENOENT)
  224. return (0);
  226. p = device + strlen(device) -1;
  227. tgt = *p - '0';
  228. if (tgt < 0 || tgt > 9)
  229. return (0);
  230. scgp->scsibus = scglocal(scgp)->pgbus;
  231. scgp->target = tgt;
  232. scgp->lun = tlun;
  233. scglocal(scgp)->scgfiles[scglocal(scgp)->pgbus][tgt][tlun] = f;
  234. return (++nopen);
  235. }
  236. return (nopen);
  237. }
  239. EXPORT int
  240. scsi_close(scgp)
  241. SCSI *scgp;
  242. {
  243. register int f;
  244. register int b;
  245. register int t;
  246. register int l;
  248. if (scgp->local == NULL)
  249. return (-1);
  250. if (scglocal(scgp)->pgbus < 0)
  251. return (0);
  252. b = scglocal(scgp)->pgbus;
  253. scglocal(scgp)->buscookies[b] = (short)-1;
  255. for (t=0; t < MAX_TGT; t++) {
  256. for (l=0; l < MAX_LUN ; l++)
  257. f = scglocal(scgp)->scgfiles[b][t][l];
  258. if (f >= 0)
  259. close(f);
  260. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  261. }
  262. return (0);
  263. }
  265. LOCAL long
  266. scsi_maxdma(scgp)
  267. SCSI *scgp;
  268. {
  269. return (PG_MAX_DATA);
  270. }
  272. #ifdef USE_PG_ONLY
  274. EXPORT void *
  275. scsi_getbuf(scgp, amt)
  276. SCSI *scgp;
  277. long amt;
  278. {
  279.         char    *ret;
  281. if (amt <= 0 || amt > scsi_maxdma(scgp))
  282.                 return ((void *)0);
  283.         if (scgp->debug)
  284.                 printf("scsi_getbuf: %ld bytesn", amt);
  286.         ret = valloc((size_t)(amt+getpagesize()));
  287.         if (ret == NULL)
  288.                 return (ret);
  289. scgp->bufbase = ret;
  290.         ret += getpagesize();
  291.         scglocal(scgp)->SCSIbuf = ret;
  292.         return ((void *)ret);
  294. }
  296. EXPORT void
  297. scsi_freebuf(scgp)
  298. SCSI *scgp;
  299. {
  300. if (scgp->bufbase)
  301. free(scgp->bufbase);
  302. scgp->bufbase = NULL;
  303. }
  305. EXPORT
  306. BOOL scsi_havebus(scgp, busno)
  307. SCSI *scgp;
  308. int busno;
  309. {
  310. register int t;
  311. register int l;
  313. if (busno < 0 || busno >= MAX_SCG)
  314. return (FALSE);
  316. if (scgp->local == NULL)
  317. return (FALSE);
  319. for (t=0; t < MAX_TGT; t++) {
  320. for (l=0; l < MAX_LUN ; l++)
  321. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  322. return (TRUE);
  323. }
  324. return (FALSE);
  325. }
  327. EXPORT
  328. int scsi_fileno(scgp, busno, tgt, tlun)
  329. SCSI *scgp;
  330. int busno;
  331. int tgt;
  332. int tlun;
  333. {
  334. if (busno < 0 || busno >= MAX_SCG ||
  335.     tgt < 0 || tgt >= MAX_TGT ||
  336.     tlun < 0 || tlun >= MAX_LUN)
  337. return (-1);
  339. if (scgp->local == NULL)
  340. return (-1);
  342. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  343. }
  344. #endif /* USE_PG_ONLY */
  346. EXPORT int
  347. scsi_initiator_id(scgp)
  348. SCSI *scgp;
  349. {
  350. return (-1);
  351. }
  353. EXPORT
  354. int scsi_isatapi(scgp)
  355. SCSI *scgp;
  356. {
  357. return (TRUE);
  358. }
  360. EXPORT
  361. int scsireset(scgp)
  362. SCSI *scgp;
  363. {
  364. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  366. struct pg_write_hdr hdr = {PG_MAGIC, PG_RESET, 0};
  368. return (write(f, (char *)&hdr, sizeof(hdr)));
  370. }
  372. #ifndef MAX
  373. #define MAX(a,b) ((a)>(b)?(a):(b))
  374. #endif
  376. #define RHSIZE sizeof(struct pg_read_hdr)
  377. #define WHSIZE  sizeof(struct pg_write_hdr)
  378. #define LEAD MAX(RHSIZE,WHSIZE)
  380. LOCAL int
  381. do_scsi_cmd(scgp, f, sp)
  382. SCSI *scgp;
  383. int f;
  384. struct scg_cmd *sp;
  385. {
  387. char local[LEAD+PG_MAX_DATA];
  388. int use_local, i, r;
  389. int inward = (sp->flags & SCG_RECV_DATA);
  391. struct pg_write_hdr *whp;
  392. struct pg_read_hdr  *rhp;
  393. char     *dbp;
  395. if (sp->cdb_len > 12)
  396. comerrno(EX_BAD, "Can't do %d byte command.n", sp->cdb_len);
  398. if (sp->addr == scglocal(scgp)->SCSIbuf) {
  399. use_local = 0; 
  400. dbp = sp->addr;
  401. } else {
  402. use_local = 1;
  403. dbp = &local[LEAD];
  404. if (!inward) 
  405. movebytes(sp->addr, dbp, sp->size);
  406. }
  408. whp = (struct pg_write_hdr *)(dbp - WHSIZE);
  409. rhp = (struct pg_read_hdr *)(dbp - RHSIZE);
  411. whp->magic   = PG_MAGIC;
  412. whp->func    = PG_COMMAND;
  413. whp->dlen    = sp->size;
  414. whp->timeout = sp->timeout;
  416. for(i=0; i<12; i++) {
  417. if (i < sp->cdb_len)
  418. whp->packet[i] = sp->cdb.cmd_cdb[i];
  419. else
  420. whp->packet[i] = 0;
  421. }
  423. i = WHSIZE;
  424. if (!inward) 
  425. i += sp->size;
  427. r = write(f, (char *)whp, i);
  429. if (r < 0) { /* command was not sent */
  430. sp->ux_errno = geterrno();
  431. if (sp->ux_errno == ETIME) {
  432. /*
  433.  * If the previous command timed out, we cannot send
  434.  * any further command until the command in the drive
  435.  * is ready. So we behave as if the drive did not
  436.  * respond to the command.
  437.  */
  438. sp->error = SCG_FATAL;
  439. return 0;
  440. }
  441. return -1;
  442. }
  444. if (r != i)
  445. errmsg("scsi_send(%s) wrote %d bytes (expected %d).n",
  446. scgp->cmdname, r, i);
  448. sp->ux_errno = 0;
  449. sp->sense_count = 0;
  451. r = read(f, (char *)rhp, RHSIZE+sp->size);
  453. if (r < 0) {
  454. sp->ux_errno = geterrno();
  455. if (sp->ux_errno == ETIME) {
  456. sp->error = SCG_TIMEOUT;
  457. return 0;
  458. }
  459. sp->error = SCG_FATAL;
  460. return -1;
  461. }
  463. i = rhp->dlen;
  464. if (i > sp->size) {
  465. /*
  466.  * "DMA overrun" should be handled in the kernel.
  467.  * However this may happen with flaky PP adapters.
  468.  */
  469. errmsgno(EX_BAD,
  470. "DMA (read) overrun by %d bytes (requested %d bytes).n",
  471. i - sp->size, sp->size);
  472. i = sp->size;
  473. }
  475. if (use_local && inward)
  476. movebytes(dbp, sp->addr, i);
  478. sp->resid = sp->size - i;
  480. fillbytes(&sp->scb, sizeof(sp->scb), '');
  481.         fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  483. sp->error = SCG_NO_ERROR;
  484. i = rhp->scsi?2:0;
  485. sp->u_scb.cmd_scb[0] = i;
  486. if (i) {
  487. if (sp->ux_errno == 0)
  488. sp->ux_errno = EIO;
  489. sp->error = SCG_RETRYABLE;
  490. }
  492. return 0;
  494. }
  496. LOCAL int
  497. do_scsi_sense(scgp, f, sp)
  498. SCSI *scgp;
  499. int f;
  500. struct scg_cmd *sp;
  501. {
  502.         int             ret;
  503.         struct scg_cmd  s_cmd;
  505.         if (sp->sense_len > SCG_MAX_SENSE)
  506.                 sp->sense_len = SCG_MAX_SENSE;
  508.         fillbytes((caddr_t)&s_cmd, sizeof(s_cmd), '');
  509.         s_cmd.addr = sp->u_sense.cmd_sense;
  510.         s_cmd.size = sp->sense_len;
  511.         s_cmd.flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  512.         s_cmd.cdb_len = SC_G0_CDBLEN;
  513.         s_cmd.sense_len = CCS_SENSE_LEN;
  514.         s_cmd.target = scgp->target;
  515.         s_cmd.cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
  516.         s_cmd.cdb.g0_cdb.lun = sp->cdb.g0_cdb.lun;
  517.         s_cmd.cdb.g0_cdb.count = sp->sense_len;
  518.         ret = do_scsi_cmd(scgp, f, &s_cmd);
  520.         if (ret < 0)
  521.                 return (ret);
  523.         sp->sense_count = sp->sense_len - s_cmd.resid;
  524.         return (ret);
  526. }
  528. LOCAL int
  529. scsi_send(scgp, f, sp)
  530. SCSI *scgp;
  531. int f;
  532. struct scg_cmd *sp;
  533. {
  534. int ret;
  536. if (f < 0) {
  537. sp->error = SCG_FATAL;
  538. return (0);
  539. }
  540. ret = do_scsi_cmd(scgp, f, sp);
  541. if (ret < 0)
  542. return (ret);
  543. if (sp->u_scb.cmd_scb[0])
  544. ret = do_scsi_sense(scgp, f, sp);
  545. return (ret);
  546. }
  548. /* end of scsi-linux-pg.c */
  550. #ifndef USE_PG_ONLY
  552. #undef scg__version
  553. #undef scsi_open
  554. #undef scsi_close
  555. #undef scsi_send
  556. #undef scsi_maxdma
  557. #undef scsi_initiator_id
  558. #undef scsi_isatapi
  559. #undef scsireset
  561. #endif