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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-bsd.c：源码内容
  1. /* @(#)scsi-bsd.c 1.25 99/09/07 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-bsd.c 1.25 99/09/07 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * Interface for the NetBSD/FreeBSD/OpenBSD generic SCSI implementation.
  8.  *
  9.  * This is a hack, that tries to emulate the functionality
  10.  * of the scg driver.
  11.  * The SCSI tranport of the generic *BSD implementation is very
  12.  * similar to the SCSI command transport of the
  13.  * 6 years older scg driver.
  14.  *
  15.  * Copyright (c) 1997 J. Schilling
  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. #ifndef HAVE_CAMLIB_H
  35. #undef sense
  36. #include <sys/scsiio.h>
  38. #define MAX_SCG 16 /* Max # of SCSI controllers */
  39. #define MAX_TGT 16
  40. #define MAX_LUN 8
  42. struct scg_local {
  43. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  44. };
  45. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  47. /*#define MAX_DMA_BSD (32*1024)*/
  48. #define MAX_DMA_BSD (60*1024) /* More seems to make problems */
  50. #if defined(__NetBSD__) && defined(TYPE_ATAPI)
  51. /*
  52.  * NetBSD 1.3 has a merged SCSI/ATAPI system, so this structure
  53.  * is slightly different.
  54.  */
  55. #define MAYBE_ATAPI
  56. #define SADDR_ISSCSI(a) ((a).type == TYPE_SCSI)
  58. #define SADDR_BUS(a) (SADDR_ISSCSI(a)?(a).addr.scsi.scbus:(MAX_SCG-1))
  59. #define SADDR_TARGET(a) (SADDR_ISSCSI(a)?(a).addr.scsi.target:(a).addr.atapi.atbus*2+(a).addr.atapi.drive)
  60. #define SADDR_LUN(a) (SADDR_ISSCSI(a)?(a).addr.scsi.lun:0)
  61. #else
  62. #define SADDR_ISSCSI(a) (1)
  64. #define SADDR_BUS(a) (a).scbus
  65. #define SADDR_TARGET(a) (a).target
  66. #define SADDR_LUN(a) (a).lun
  67. #endif /* __NetBSD__ && TYPE_ATAPI */
  69. LOCAL BOOL scsi_setup __PR((SCSI *scgp, int f, int busno, int tgt, int tlun));
  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. register int t;
  82. register int l;
  83. register int nopen = 0;
  84. char devname[64];
  86. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  87. errno = EINVAL;
  88. if (scgp->errstr)
  89. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  90. "Illegal value for busno, target or lun '%d,%d,%d'",
  91. busno, tgt, tlun);
  92. return (-1);
  93. }
  95. if (scgp->local == NULL) {
  96. scgp->local = malloc(sizeof(struct scg_local));
  97. if (scgp->local == NULL)
  98. return (0);
  100. for (b=0; b < MAX_SCG; b++) {
  101. for (t=0; t < MAX_TGT; t++) {
  102. for (l=0; l < MAX_LUN ; l++)
  103. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  104. }
  105. }
  106. }
  108. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2))
  109. goto openbydev;
  111. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  113. sprintf(devname, "/dev/su%d-%d-%d", busno, tgt, tlun);
  114. f = open(devname, O_RDWR);
  115. if (f < 0) {
  116. goto openbydev;
  117. }
  118. scglocal(scgp)->scgfiles[busno][tgt][tlun] = f;
  119. return(1);
  121. } else for (b=0; b < MAX_SCG; b++) {
  122. for (t=0; t < MAX_TGT; t++) {
  123. for (l=0; l < MAX_LUN ; l++) {
  124. sprintf(devname, "/dev/su%d-%d-%d", b, t, l);
  125. f = open(devname, O_RDWR);
  126. /* error("open (%s) = %dn", devname, f);*/
  128. if (f < 0) {
  129. if (errno != ENOENT &&
  130.     errno != ENXIO &&
  131.     errno != ENODEV) {
  132. if (scgp->errstr)
  133. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  134. "Cannot open '%s'",
  135. devname);
  136. return (0);
  137. }
  138. } else {
  139. if (scsi_setup(scgp, f, b, t, l))
  140. nopen++;
  141. }
  142. }
  143. }
  144. }
  145. /*
  146.  * Could not open /dev/su-* or got dev=devname:b,l,l / dev=devname:@,l
  147.  * We do the apropriate tests and try our best.
  148.  */
  149. openbydev:
  150. if (nopen == 0) {
  151. struct scsi_addr saddr;
  153. if (device == NULL || device[0] == '')
  154. return (0);
  155. f = open(device, O_RDWR);
  156. if (f < 0)
  157. return (0);
  158. if (tgt == -2) {
  159. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0) {
  160. close(f);
  161. errno = EINVAL;
  162. return (0);
  163. }
  164. scgp->scsibus = busno = SADDR_BUS(saddr);
  165. scgp->target  = tgt = SADDR_TARGET(saddr);
  166. if ((tlun >= 0) && (tlun != SADDR_LUN(saddr))) {
  167. close(f);
  168. errno = EINVAL;
  169. return (0);
  170. }
  171. scgp->lun     = tlun = SADDR_LUN(saddr);
  172. }
  173. if (scsi_setup(scgp, f, busno, tgt, tlun))
  174. nopen++;
  175. }
  176. return (nopen);
  177. }
  179. EXPORT int
  180. scsi_close(scgp)
  181. SCSI *scgp;
  182. {
  183. register int f;
  184. register int b;
  185. register int t;
  186. register int l;
  188. if (scgp->local == NULL)
  189. return (-1);
  191. for (b=0; b < MAX_SCG; b++) {
  192. for (t=0; t < MAX_TGT; t++) {
  193. for (l=0; l < MAX_LUN ; l++) {
  194. f = scglocal(scgp)->scgfiles[b][t][l];
  195. if (f >= 0)
  196. close(f);
  197. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  198. }
  199. }
  200. }
  201. return (0);
  202. }
  204. LOCAL BOOL
  205. scsi_setup(scgp, f, busno, tgt, tlun)
  206. SCSI *scgp;
  207. int f;
  208. int busno;
  209. int tgt;
  210. int tlun;
  211. {
  212. struct scsi_addr saddr;
  213. int Bus;
  214. int Target;
  215. int Lun;
  216. BOOL onetarget = FALSE;
  218. if (scgp->scsibus >= 0 && scgp->target >= 0 && scgp->lun >= 0)
  219. onetarget = TRUE;
  221. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0) {
  222. errmsg("Cannot get SCSI addr.n");
  223. close(f);
  224. return (FALSE);
  225. }
  226. Bus = SADDR_BUS(saddr);
  227. Target = SADDR_TARGET(saddr);
  228. Lun = SADDR_LUN(saddr);
  230. if (scgp->debug)
  231. printf("Bus: %d Target: %d Lun: %dn", Bus, Target, Lun);
  233. if (Bus >= MAX_SCG || Target >= MAX_TGT || Lun >= MAX_LUN) {
  234. close(f);
  235. return (FALSE);
  236. }
  238. if (scglocal(scgp)->scgfiles[Bus][Target][Lun] == (short)-1)
  239. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)f;
  241. if (onetarget) {
  242. if (Bus == busno && Target == tgt && Lun == tlun) {
  243. return (TRUE);
  244. } else {
  245. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)-1;
  246. close(f);
  247. }
  248. }
  249. return (FALSE);
  250. }
  252. LOCAL long
  253. scsi_maxdma(scgp)
  254. SCSI *scgp;
  255. {
  256. long maxdma = MAX_DMA_BSD;
  258. return (maxdma);
  259. }
  261. EXPORT void *
  262. scsi_getbuf(scgp, amt)
  263. SCSI *scgp;
  264. long amt;
  265. {
  266. if (amt <= 0 || amt > scsi_maxdma(scgp))
  267. return ((void *)0);
  268. if (scgp->debug)
  269. printf("scsi_getbuf: %ld bytesn", amt);
  270. scgp->bufbase = valloc((size_t)(amt));
  271. return (scgp->bufbase);
  272. }
  274. EXPORT void
  275. scsi_freebuf(scgp)
  276. SCSI *scgp;
  277. {
  278. if (scgp->bufbase)
  279. free(scgp->bufbase);
  280. scgp->bufbase = NULL;
  281. }
  283. EXPORT
  284. BOOL scsi_havebus(scgp, busno)
  285. SCSI *scgp;
  286. int busno;
  287. {
  288. register int t;
  289. register int l;
  291. if (busno < 0 || busno >= MAX_SCG)
  292. return (FALSE);
  294. if (scgp->local == NULL)
  295. return (FALSE);
  297. for (t=0; t < MAX_TGT; t++) {
  298. for (l=0; l < MAX_LUN ; l++)
  299. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  300. return (TRUE);
  301. }
  302. return (FALSE);
  303. }
  305. EXPORT
  306. int scsi_fileno(scgp, busno, tgt, tlun)
  307. SCSI *scgp;
  308. int busno;
  309. int tgt;
  310. int tlun;
  311. {
  312. if (busno < 0 || busno >= MAX_SCG ||
  313.     tgt < 0 || tgt >= MAX_TGT ||
  314.     tlun < 0 || tlun >= MAX_LUN)
  315. return (-1);
  317. if (scgp->local == NULL)
  318. return (-1);
  320. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  321. }
  323. EXPORT int
  324. scsi_initiator_id(scgp)
  325. SCSI *scgp;
  326. {
  327. return (-1);
  328. }
  330. EXPORT
  331. int scsi_isatapi(scgp)
  332. SCSI *scgp;
  334. {
  335. #ifdef MAYBE_ATAPI
  336. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  337. struct scsi_addr saddr;
  339. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0)
  340. return (-1);
  342. if (!SADDR_ISSCSI(saddr))
  343. return (TRUE);
  344. #endif
  345. return (FALSE);
  346. }
  348. EXPORT
  349. int scsireset(scgp)
  350. SCSI *scgp;
  351. {
  352. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  354. return (ioctl(f, SCIOCRESET, 0));
  355. }
  357. LOCAL int
  358. scsi_send(scgp, f, sp)
  359. SCSI *scgp;
  360. int f;
  361. struct scg_cmd *sp;
  362. {
  363. scsireq_t req;
  364. register long *lp1;
  365. register long *lp2;
  366. int ret = 0;
  368. /* printf("f: %dn", f);*/
  369. if (f < 0) {
  370. sp->error = SCG_FATAL;
  371. return (0);
  372. }
  373. req.flags = SCCMD_ESCAPE; /* We set the SCSI cmd len */
  374. if (sp->flags & SCG_RECV_DATA)
  375. req.flags |= SCCMD_READ;
  376. else if (sp->size > 0)
  377. req.flags |= SCCMD_WRITE;
  379. req.timeout = sp->timeout * 1000;
  380. lp1 = (long *)sp->cdb.cmd_cdb;
  381. lp2 = (long *)req.cmd;
  382. *lp2++ = *lp1++;
  383. *lp2++ = *lp1++;
  384. *lp2++ = *lp1++;
  385. *lp2++ = *lp1++;
  386. req.cmdlen = sp->cdb_len;
  387. req.databuf = sp->addr;
  388. req.datalen = sp->size;
  389. req.datalen_used = 0;
  390. fillbytes(req.sense, sizeof(req.sense), '');
  391. if (sp->sense_len > sizeof(req.sense))
  392. req.senselen = sizeof(req.sense);
  393. else if (sp->sense_len < 0)
  394. req.senselen = 0;
  395. else
  396. req.senselen = sp->sense_len;
  397. req.senselen_used = 0;
  398. req.status = 0;
  399. req.retsts = 0;
  400. req.error = 0;
  402. if (ioctl(f, SCIOCCOMMAND, (void *)&req) < 0) {
  403. ret  = -1;
  404. sp->ux_errno = geterrno();
  405. if (sp->ux_errno != ENOTTY)
  406. ret = 0;
  407. } else {
  408. sp->ux_errno = 0;
  409. if (req.retsts != SCCMD_OK)
  410. sp->ux_errno = EIO;
  411. }
  412. fillbytes(&sp->scb, sizeof(sp->scb), '');
  413. fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  414. sp->resid = req.datalen - req.datalen_used;
  415. sp->sense_count = req.senselen_used;
  416. if (sp->sense_count > SCG_MAX_SENSE)
  417. sp->sense_count = SCG_MAX_SENSE;
  418. movebytes(req.sense, sp->u_sense.cmd_sense, sp->sense_count);
  419. sp->u_scb.cmd_scb[0] = req.status;
  421. switch (req.retsts) {
  423. case SCCMD_OK:
  424. #ifdef BSD_SCSI_SENSE_BUG
  425. sp->u_scb.cmd_scb[0] = 0;
  426. sp->ux_errno = 0;
  427. #endif
  428. sp->error = SCG_NO_ERROR; break;
  429. case SCCMD_TIMEOUT: sp->error = SCG_TIMEOUT; break;
  430. default:
  431. case SCCMD_BUSY: sp->error = SCG_RETRYABLE; break;
  432. case SCCMD_SENSE: sp->error = SCG_RETRYABLE; break;
  433. case SCCMD_UNKNOWN: sp->error = SCG_FATAL; break;
  434. }
  436. return (ret);
  437. }
  438. #define sense u_sense.Sense
  440. #else /* BSD_CAM */
  441. /*
  442.  * Interface for the FreeBSD CAM passthrough device.
  443.  *
  444.  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
  445.  * Copyright (c) 1998 Kenneth D. Merry <ken@kdm.org>
  446.  * Copyright (c) 1998 Joerg Schilling <schilling@fokus.gmd.de>
  447.  * All rights reserved.
  448.  *
  449.  * Redistribution and use in source and binary forms, with or without
  450.  * modification, are permitted provided that the following conditions
  451.  * are met:
  452.  * 1. Redistributions of source code must retain the above copyright
  453.  *    notice, this list of conditions and the following disclaimer.
  454.  * 2. Redistributions in binary form must reproduce the above copyright
  455.  *    notice, this list of conditions and the following disclaimer in the
  456.  *    documentation and/or other materials provided with the distribution.
  457.  *
  458.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  459.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  460.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  461.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  462.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  463.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  464.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  465.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  466.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  467.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  468.  * SUCH DAMAGE.
  469.  *
  470.  */
  472. #undef sense
  473. #define scsi_sense CAM_scsi_sense
  474. #define scsi_inquiry CAM_scsi_inquiry
  475. #include <sys/param.h>
  476. #include <cam/cam.h>
  477. #include <cam/cam_ccb.h>
  478. #include <cam/scsi/scsi_message.h>
  479. #include <cam/scsi/scsi_pass.h>
  480. #include <camlib.h>
  482. #define CAM_MAXDEVS 128
  483. struct scg_local {
  484. struct cam_device *cam_devices[CAM_MAXDEVS + 1];
  485. };
  486. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  488. /*
  489.  * Build a list of everything we can find.
  490.  */
  491. EXPORT int
  492. scsi_open(scgp, device, busno, tgt, tlun)
  493. SCSI *scgp;
  494. char *device;
  495. int busno;
  496. int tgt;
  497. int tlun;
  498. {
  499. char name[16];
  500. int unit;
  501. int nopen = 0;
  502. union ccb ccb;
  503. int bufsize;
  504. struct periph_match_pattern *match_pat;
  505. int fd;
  507. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  508. errno = EINVAL;
  509. if (scgp->errstr)
  510. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  511. "Open by 'devname' not supported on this OS");
  512. return (-1);
  513. }
  515. if (scgp->local == NULL) {
  516. scgp->local = malloc(sizeof(struct scg_local));
  517. if (scgp->local == NULL)
  518. return (0);
  520. for (unit = 0; unit <= CAM_MAXDEVS; unit++) {
  521. scglocal(scgp)->cam_devices[unit] = (struct cam_device *)-1;
  522. }
  523. }
  526. /*
  527.  * If we're not scanning the bus, just open one device.
  528.  */
  529. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  530. scglocal(scgp)->cam_devices[0] = cam_open_btl(busno, tgt, tlun, O_RDWR, NULL);
  531. if (scglocal(scgp)->cam_devices[0] == NULL)
  532. return(-1);
  533. nopen++;
  534. return(nopen);
  535. }
  537. /*
  538.  * First open the transport layer device.  There's no point in the
  539.  * rest of this if we can't open it.
  540.  */
  542. if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
  543. if (scgp->errstr)
  544. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  545. "Open of %s failed", XPT_DEVICE);
  546. return(-1);
  547. }
  548. fillbytes(&ccb, sizeof(union ccb), '');
  550. /*
  551.  * Get a list of up to CAM_MAXDEVS passthrough devices in the
  552.  * system.
  553.  */
  554. ccb.ccb_h.func_code = XPT_DEV_MATCH;
  556. /*
  557.  * Setup the result buffer.
  558.  */
  559. bufsize = sizeof(struct dev_match_result) * CAM_MAXDEVS;
  560. ccb.cdm.match_buf_len = bufsize;
  561. ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
  562. if (ccb.cdm.matches == NULL) {
  563. if (scgp->errstr)
  564. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  565. "Couldn't malloc match buffer");
  566. close(fd);
  567. return(-1);
  568. }
  569. ccb.cdm.num_matches = 0;
  571. /*
  572.  * Setup the pattern buffer.  We're matching against all
  573.  * peripherals named "pass".
  574.  */
  575. ccb.cdm.num_patterns = 1;
  576. ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
  577. ccb.cdm.patterns = (struct dev_match_pattern *)malloc(
  578. sizeof(struct dev_match_pattern));
  579. if (ccb.cdm.patterns == NULL) {
  580. if (scgp->errstr)
  581. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  582. "Couldn't malloc pattern buffer");
  583. close(fd);
  584. free(ccb.cdm.matches);
  585. return(-1);
  586. }
  587. ccb.cdm.patterns[0].type = DEV_MATCH_PERIPH;
  588. match_pat = &ccb.cdm.patterns[0].pattern.periph_pattern;
  589. sprintf(match_pat->periph_name, "pass");
  590. match_pat->flags = PERIPH_MATCH_NAME;
  592. if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
  593. if (scgp->errstr)
  594. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  595. "CAMIOCOMMAND ioctl failed");
  596. close(fd);
  597. free(ccb.cdm.matches);
  598. free(ccb.cdm.patterns);
  599. return(-1);
  600. }
  602. if ((ccb.ccb_h.status != CAM_REQ_CMP)
  603.  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
  604.     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
  605. /* errmsgno(EX_BAD, "Got CAM error 0x%X, CDM error %d.n",*/
  606. if (scgp->errstr)
  607. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  608. "Got CAM error 0x%X, CDM error %d",
  609. ccb.ccb_h.status, ccb.cdm.status);
  610. close(fd);
  611. free(ccb.cdm.matches);
  612. free(ccb.cdm.patterns);
  613. return(-1);
  614. }
  616. free(ccb.cdm.patterns);
  617. close(fd);
  619. for (unit = 0; unit < MIN(CAM_MAXDEVS, ccb.cdm.num_matches); unit++) {
  620. struct periph_match_result *periph_result;
  622. /*
  623.  * We shouldn't have anything other than peripheral
  624.  * matches in here.  If we do, it means an error in the
  625.  * device matching code in the transport layer.
  626.  */
  627. if (ccb.cdm.matches[unit].type != DEV_MATCH_PERIPH) {
  628. /* errmsgno(EX_BAD, "Kernel error! got periph match type %d!!n",*/
  629. if (scgp->errstr)
  630. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  631. "Kernel error! got periph match type %d!!",
  632. ccb.cdm.matches[unit].type);
  633. free(ccb.cdm.matches);
  634. return(-1);
  635. }
  636. periph_result = &ccb.cdm.matches[unit].result.periph_result;
  638. sprintf(name, "/dev/%s%d", periph_result->periph_name,
  639. periph_result->unit_number);
  641. /*
  642.  * cam_open_pass() avoids all lookup and translation from
  643.  * "regular device name" to passthrough unit number and
  644.  * just opens the device in question as a passthrough device.
  645.  */
  646. scglocal(scgp)->cam_devices[unit] = cam_open_pass(name, O_RDWR, NULL);
  648. /*
  649.  * If we get back NULL from the open routine, it wasn't
  650.  * able to open the given passthrough device for one reason
  651.  * or another.
  652.  */
  653. if (scglocal(scgp)->cam_devices[unit] == NULL) {
  654. #ifdef OLD
  655. errmsgno(EX_BAD, "Error opening /dev/%s%dn",
  656. periph_result->periph_name,
  657. periph_result->unit_number);
  658. errmsgno(EX_BAD, "%sn", cam_errbuf);
  659. #endif
  660. if (scgp->errstr)
  661. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  662. "Error opening /dev/%s%d Cam error '%s'",
  663. periph_result->periph_name,
  664. periph_result->unit_number,
  665. cam_errbuf);
  666. break;
  667. }
  668. nopen++;
  669. }
  671. free(ccb.cdm.matches);
  672. return (nopen);
  673. }
  675. EXPORT int
  676. scsi_close(scgp)
  677. SCSI *scgp;
  678. {
  679. register int i;
  681. if (scgp->local == NULL)
  682. return (-1);
  684. for (i = 0; i <= CAM_MAXDEVS; i++) {
  685. if (scglocal(scgp)->cam_devices[i] != (struct cam_device *)-1)
  686. cam_close_device(scglocal(scgp)->cam_devices[i]);
  687. scglocal(scgp)->cam_devices[i] = (struct cam_device *)-1;
  688.         }
  689. return (0);
  690. }
  692. LOCAL
  693. long scsi_maxdma(scgp)
  694. SCSI *scgp;
  695. {
  696. #ifdef DFLTPHYS
  697. return (DFLTPHYS);
  698. #else
  699. return (MAXPHYS);
  700. #endif
  701. }
  703. EXPORT void *
  704. scsi_getbuf(scgp, amt)
  705. SCSI *scgp;
  706. long amt;
  707. {
  708. if (amt <= 0 || amt > scsi_maxdma(scgp))
  709. return ((void *)0);
  710. if (scgp->debug)
  711. printf("scsi_getbuf: %ld bytesn", amt);
  712. scgp->bufbase = valloc((size_t)(amt));
  713. return (scgp->bufbase);
  714. }
  716. EXPORT void
  717. scsi_freebuf(scgp)
  718. SCSI *scgp;
  719. {
  720. if (scgp->bufbase)
  721. free(scgp->bufbase);
  722. scgp->bufbase = NULL;
  723. }
  725. EXPORT
  726. BOOL scsi_havebus(scgp, busno)
  727. SCSI *scgp;
  728. int busno;
  729. {
  730. int unit;
  732. if (scgp->local == NULL)
  733. return (FALSE);
  735. /*
  736.  * There's a "cleaner" way to do this, using the matching code, but
  737.  * it would involve more code than this solution...
  738.  */
  739. for (unit = 0; scglocal(scgp)->cam_devices[unit] != (struct cam_device *)-1; unit++) {
  740. if (scglocal(scgp)->cam_devices[unit] == NULL)
  741. continue;
  742. if (scglocal(scgp)->cam_devices[unit]->path_id == busno)
  743. return (TRUE);
  744. }
  745. return (FALSE);
  746. }
  748. EXPORT
  749. int scsi_fileno(scgp, busno, unit, tlun)
  750. SCSI *scgp;
  751. int busno;
  752. int unit;
  753. int tlun;
  754. {
  755. int i;
  757. if (scgp->local == NULL)
  758. return (-1);
  760. for (i = 0; scglocal(scgp)->cam_devices[i] != (struct cam_device *)-1; i++) {
  761. if (scglocal(scgp)->cam_devices[i] == NULL)
  762. continue;
  763. if ((scglocal(scgp)->cam_devices[i]->path_id == busno) &&
  764.     (scglocal(scgp)->cam_devices[i]->target_id == unit) &&
  765.     (scglocal(scgp)->cam_devices[i]->target_lun == tlun))
  766. return (i);
  767. }
  768. return (-1);
  769. }
  771. EXPORT int
  772. scsi_initiator_id(scgp)
  773. SCSI *scgp;
  774. {
  775. return (-1);
  776. }
  778. EXPORT
  779. int scsi_isatapi(scgp)
  780. SCSI *scgp;
  781. {
  782. return (FALSE);
  783. }
  785. EXPORT
  786. int scsireset(scgp)
  787. SCSI *scgp;
  788. {
  789. /* XXX synchronous reset command - is this wise? */
  790. return (-1);
  791. }
  793. LOCAL int
  794. scsi_send(scgp, unit, sp)
  795. SCSI *scgp;
  796. int unit;
  797. struct scg_cmd *sp;
  798. {
  799. struct cam_device *dev;
  800. union ccb ccb_space;
  801. union ccb *ccb = &ccb_space;
  802. int rv, result;
  803. u_int32_t ccb_flags;
  805. if (unit < 0) {
  806. #if 0
  807. fprintf(stderr, "attempt to reference invalid unit %dn", unit);
  808. #endif
  809. sp->error = SCG_FATAL;
  810. return (0);
  811. }
  813. dev = scglocal(scgp)->cam_devices[unit];
  814. fillbytes(&ccb->ccb_h, sizeof(struct ccb_hdr), '');
  815. ccb->ccb_h.path_id = dev->path_id;
  816. ccb->ccb_h.target_id = dev->target_id;
  817. ccb->ccb_h.target_lun = dev->target_lun;
  819. /* Build the CCB */
  820. fillbytes(&(&ccb->ccb_h)[1], sizeof(struct ccb_scsiio), '');
  821. movebytes(sp->cdb.cmd_cdb, &ccb->csio.cdb_io.cdb_bytes, sp->cdb_len);
  823. /*
  824.  * Set the data direction flags.
  825.  */
  826. if (sp->size != 0) {
  827. ccb_flags = (sp->flags & SCG_RECV_DATA) ? CAM_DIR_IN :
  828.    CAM_DIR_OUT;
  829. } else {
  830. ccb_flags = CAM_DIR_NONE;
  831. }
  833. ccb_flags |= CAM_DEV_QFRZDIS;
  835. /*
  836.  * If you don't want to bother with sending tagged commands under CAM,
  837.  * we don't need to do anything to cdrecord.  If you want to send
  838.  * tagged commands to those devices that support it, we'll need to set
  839.  * the tag action valid field like this in scsi_send():
  840.    *         
  841.  *        ccb_flags |= CAM_DEV_QFRZDIS | CAM_TAG_ACTION_VALID;
  842.  */
  844. cam_fill_csio(&ccb->csio,
  845.       /* retries */ 1,
  846.       /* cbfncp */ NULL,
  847.       /* flags */ ccb_flags,
  848.       /* tag_action */ MSG_SIMPLE_Q_TAG,
  849.       /* data_ptr */ (u_int8_t *)sp->addr,
  850.       /* dxfer_len */ sp->size,
  851.       /* sense_len */ SSD_FULL_SIZE,
  852.       /* cdb_len */ sp->cdb_len,
  853.       /* timeout */ sp->timeout * 1000);
  855. /* Run the command */
  856. errno = 0;
  857. if ((rv = cam_send_ccb(dev, ccb)) == -1) {
  858. return (rv);
  859. } else {
  860. /*
  861.  * Check for command status.  Selection timeouts are fatal.
  862.  * For command timeouts, we pass back the appropriate
  863.  * error.  If we completed successfully, there's (obviously)
  864.  * no error.  We declare anything else "retryable".
  865.  */
  866. switch(ccb->ccb_h.status & CAM_STATUS_MASK) {
  867. case CAM_SEL_TIMEOUT:
  868. result = SCG_FATAL;
  869. break;
  870. case CAM_CMD_TIMEOUT:
  871. result = SCG_TIMEOUT;
  872. break;
  873. case CAM_REQ_CMP:
  874. result = SCG_NO_ERROR;
  875. break;
  876. default:
  877. result = SCG_RETRYABLE;
  878. break;
  879. }
  880. }
  882. sp->error = result;
  883. if (result != SCG_NO_ERROR)
  884. sp->ux_errno = EIO;
  886. /* Pass the result back up */
  887. fillbytes(&sp->scb, sizeof(sp->scb), '');
  888. fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  889. sp->resid = ccb->csio.resid;
  890. sp->sense_count = SSD_FULL_SIZE - ccb->csio.sense_resid;
  892. /*
  893.  * Determine how much room we have for sense data.
  894.  */
  895. if (sp->sense_count > SCG_MAX_SENSE)
  896. sp->sense_count = SCG_MAX_SENSE;
  898. /* Copy the sense data out */
  899. movebytes(&ccb->csio.sense_data, &sp->u_sense.cmd_sense, sp->sense_count);
  901. sp->u_scb.cmd_scb[0] = ccb->csio.scsi_status;
  903. return (0);
  904. }
  906. #undef scsi_sense
  907. #undef scsi_inquiry
  908. #define sense u_sense.Sense
  910. #endif /* BSD_CAM */