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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-bsd.c：源码内容
  1. /* @(#)scsi-bsd.c 1.26 99/09/17 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-bsd.c 1.26 99/09/17 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.  * Warning: you may change this source, but if you do that
  16.  * you need to change the _scg_version and _scg_auth* string below.
  17.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  18.  * Choose your name instead of "schily" and make clear that the version
  19.  * string is related to a modified source.
  20.  *
  21.  * Copyright (c) 1997 J. Schilling
  22.  */
  23. /*
  24.  * This program is free software; you can redistribute it and/or modify
  25.  * it under the terms of the GNU General Public License as published by
  26.  * the Free Software Foundation; either version 2, or (at your option)
  27.  * any later version.
  28.  *
  29.  * This program is distributed in the hope that it will be useful,
  30.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32.  * GNU General Public License for more details.
  33.  *
  34.  * You should have received a copy of the GNU General Public License
  35.  * along with this program; see the file COPYING.  If not, write to
  36.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  37.  */
  39. #ifndef HAVE_CAMLIB_H
  41. #undef sense
  42. #include <sys/scsiio.h>
  44. /*
  45.  * Warning: you may change this source, but if you do that
  46.  * you need to change the _scg_version and _scg_auth* string below.
  47.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  48.  * Choose your name instead of "schily" and make clear that the version
  49.  * string is related to a modified source.
  50.  */
  51. LOCAL char _scg_trans_version[] = "scsi-bsd.c-1.26"; /* The version for this transport*/
  53. #define MAX_SCG 16 /* Max # of SCSI controllers */
  54. #define MAX_TGT 16
  55. #define MAX_LUN 8
  57. struct scg_local {
  58. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  59. };
  60. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  62. /*#define MAX_DMA_BSD (32*1024)*/
  63. #define MAX_DMA_BSD (60*1024) /* More seems to make problems */
  65. #if defined(__NetBSD__) && defined(TYPE_ATAPI)
  66. /*
  67.  * NetBSD 1.3 has a merged SCSI/ATAPI system, so this structure
  68.  * is slightly different.
  69.  */
  70. #define MAYBE_ATAPI
  71. #define SADDR_ISSCSI(a) ((a).type == TYPE_SCSI)
  73. #define SADDR_BUS(a) (SADDR_ISSCSI(a)?(a).addr.scsi.scbus:(MAX_SCG-1))
  74. #define SADDR_TARGET(a) (SADDR_ISSCSI(a)?(a).addr.scsi.target:(a).addr.atapi.atbus*2+(a).addr.atapi.drive)
  75. #define SADDR_LUN(a) (SADDR_ISSCSI(a)?(a).addr.scsi.lun:0)
  76. #else
  77. #define SADDR_ISSCSI(a) (1)
  79. #define SADDR_BUS(a) (a).scbus
  80. #define SADDR_TARGET(a) (a).target
  81. #define SADDR_LUN(a) (a).lun
  82. #endif /* __NetBSD__ && TYPE_ATAPI */
  84. LOCAL BOOL scsi_setup __PR((SCSI *scgp, int f, int busno, int tgt, int tlun));
  86. /*
  87.  * Return version information for the low level SCSI transport code.
  88.  * This has been introduced to make it easier to trace down problems
  89.  * in applications.
  90.  */
  91. EXPORT char *
  92. scg__version(scgp, what)
  93. SCSI *scgp;
  94. int what;
  95. {
  96. if (scgp != (SCSI *)0) {
  97. switch (what) {
  99. case SCG_VERSION:
  100. return (_scg_trans_version);
  101. /*
  102.  * If you changed this source, you are not allowed to
  103.  * return "schily" for the SCG_AUTHOR request.
  104.  */
  105. case SCG_AUTHOR:
  106. return (_scg_auth_schily);
  107. case SCG_SCCS_ID:
  108. return (__sccsid);
  109. }
  110. }
  111. return ((char *)0);
  112. }
  114. EXPORT int
  115. scsi_open(scgp, device, busno, tgt, tlun)
  116. SCSI *scgp;
  117. char *device;
  118. int busno;
  119. int tgt;
  120. int tlun;
  121. {
  122. register int f;
  123. register int b;
  124. register int t;
  125. register int l;
  126. register int nopen = 0;
  127. char devname[64];
  129. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  130. errno = EINVAL;
  131. if (scgp->errstr)
  132. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  133. "Illegal value for busno, target or lun '%d,%d,%d'",
  134. busno, tgt, tlun);
  135. return (-1);
  136. }
  138. if (scgp->local == NULL) {
  139. scgp->local = malloc(sizeof(struct scg_local));
  140. if (scgp->local == NULL)
  141. return (0);
  143. for (b=0; b < MAX_SCG; b++) {
  144. for (t=0; t < MAX_TGT; t++) {
  145. for (l=0; l < MAX_LUN ; l++)
  146. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  147. }
  148. }
  149. }
  151. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2))
  152. goto openbydev;
  154. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  156. sprintf(devname, "/dev/su%d-%d-%d", busno, tgt, tlun);
  157. f = open(devname, O_RDWR);
  158. if (f < 0) {
  159. goto openbydev;
  160. }
  161. scglocal(scgp)->scgfiles[busno][tgt][tlun] = f;
  162. return(1);
  164. } else for (b=0; b < MAX_SCG; b++) {
  165. for (t=0; t < MAX_TGT; t++) {
  166. for (l=0; l < MAX_LUN ; l++) {
  167. sprintf(devname, "/dev/su%d-%d-%d", b, t, l);
  168. f = open(devname, O_RDWR);
  169. /* error("open (%s) = %dn", devname, f);*/
  171. if (f < 0) {
  172. if (errno != ENOENT &&
  173.     errno != ENXIO &&
  174.     errno != ENODEV) {
  175. if (scgp->errstr)
  176. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  177. "Cannot open '%s'",
  178. devname);
  179. return (0);
  180. }
  181. } else {
  182. if (scsi_setup(scgp, f, b, t, l))
  183. nopen++;
  184. }
  185. }
  186. }
  187. }
  188. /*
  189.  * Could not open /dev/su-* or got dev=devname:b,l,l / dev=devname:@,l
  190.  * We do the apropriate tests and try our best.
  191.  */
  192. openbydev:
  193. if (nopen == 0) {
  194. struct scsi_addr saddr;
  196. if (device == NULL || device[0] == '')
  197. return (0);
  198. f = open(device, O_RDWR);
  199. if (f < 0)
  200. return (0);
  201. if (tgt == -2) {
  202. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0) {
  203. close(f);
  204. errno = EINVAL;
  205. return (0);
  206. }
  207. scgp->scsibus = busno = SADDR_BUS(saddr);
  208. scgp->target  = tgt = SADDR_TARGET(saddr);
  209. if ((tlun >= 0) && (tlun != SADDR_LUN(saddr))) {
  210. close(f);
  211. errno = EINVAL;
  212. return (0);
  213. }
  214. scgp->lun     = tlun = SADDR_LUN(saddr);
  215. }
  216. if (scsi_setup(scgp, f, busno, tgt, tlun))
  217. nopen++;
  218. }
  219. return (nopen);
  220. }
  222. EXPORT int
  223. scsi_close(scgp)
  224. SCSI *scgp;
  225. {
  226. register int f;
  227. register int b;
  228. register int t;
  229. register int l;
  231. if (scgp->local == NULL)
  232. return (-1);
  234. for (b=0; b < MAX_SCG; b++) {
  235. for (t=0; t < MAX_TGT; t++) {
  236. for (l=0; l < MAX_LUN ; l++)
  237. f = scglocal(scgp)->scgfiles[b][t][l];
  238. if (f >= 0)
  239. close(f);
  240. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  241. }
  242. }
  243. return (0);
  244. }
  246. LOCAL BOOL
  247. scsi_setup(scgp, f, busno, tgt, tlun)
  248. SCSI *scgp;
  249. int f;
  250. int busno;
  251. int tgt;
  252. int tlun;
  253. {
  254. struct scsi_addr saddr;
  255. int Bus;
  256. int Target;
  257. int Lun;
  258. BOOL onetarget = FALSE;
  260. if (scgp->scsibus >= 0 && scgp->target >= 0 && scgp->lun >= 0)
  261. onetarget = TRUE;
  263. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0) {
  264. errmsg("Cannot get SCSI addr.n");
  265. close(f);
  266. return (FALSE);
  267. }
  268. Bus = SADDR_BUS(saddr);
  269. Target = SADDR_TARGET(saddr);
  270. Lun = SADDR_LUN(saddr);
  272. if (scgp->debug)
  273. printf("Bus: %d Target: %d Lun: %dn", Bus, Target, Lun);
  275. if (Bus >= MAX_SCG || Target >= MAX_TGT || Lun >= MAX_LUN) {
  276. close(f);
  277. return (FALSE);
  278. }
  280. if (scglocal(scgp)->scgfiles[Bus][Target][Lun] == (short)-1)
  281. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)f;
  283. if (onetarget) {
  284. if (Bus == busno && Target == tgt && Lun == tlun) {
  285. return (TRUE);
  286. } else {
  287. scglocal(scgp)->scgfiles[Bus][Target][Lun] = (short)-1;
  288. close(f);
  289. }
  290. }
  291. return (FALSE);
  292. }
  294. LOCAL long
  295. scsi_maxdma(scgp)
  296. SCSI *scgp;
  297. {
  298. long maxdma = MAX_DMA_BSD;
  300. return (maxdma);
  301. }
  303. EXPORT void *
  304. scsi_getbuf(scgp, amt)
  305. SCSI *scgp;
  306. long amt;
  307. {
  308. if (amt <= 0 || amt > scsi_maxdma(scgp))
  309. return ((void *)0);
  310. if (scgp->debug)
  311. printf("scsi_getbuf: %ld bytesn", amt);
  312. scgp->bufbase = valloc((size_t)(amt));
  313. return (scgp->bufbase);
  314. }
  316. EXPORT void
  317. scsi_freebuf(scgp)
  318. SCSI *scgp;
  319. {
  320. if (scgp->bufbase)
  321. free(scgp->bufbase);
  322. scgp->bufbase = NULL;
  323. }
  325. EXPORT
  326. BOOL scsi_havebus(scgp, busno)
  327. SCSI *scgp;
  328. int busno;
  329. {
  330. register int t;
  331. register int l;
  333. if (busno < 0 || busno >= MAX_SCG)
  334. return (FALSE);
  336. if (scgp->local == NULL)
  337. return (FALSE);
  339. for (t=0; t < MAX_TGT; t++) {
  340. for (l=0; l < MAX_LUN ; l++)
  341. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  342. return (TRUE);
  343. }
  344. return (FALSE);
  345. }
  347. EXPORT
  348. int scsi_fileno(scgp, busno, tgt, tlun)
  349. SCSI *scgp;
  350. int busno;
  351. int tgt;
  352. int tlun;
  353. {
  354. if (busno < 0 || busno >= MAX_SCG ||
  355.     tgt < 0 || tgt >= MAX_TGT ||
  356.     tlun < 0 || tlun >= MAX_LUN)
  357. return (-1);
  359. if (scgp->local == NULL)
  360. return (-1);
  362. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  363. }
  365. EXPORT int
  366. scsi_initiator_id(scgp)
  367. SCSI *scgp;
  368. {
  369. return (-1);
  370. }
  372. EXPORT
  373. int scsi_isatapi(scgp)
  374. SCSI *scgp;
  376. {
  377. #ifdef MAYBE_ATAPI
  378. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  379. struct scsi_addr saddr;
  381. if (ioctl(f, SCIOCIDENTIFY, &saddr) < 0)
  382. return (-1);
  384. if (!SADDR_ISSCSI(saddr))
  385. return (TRUE);
  386. #endif
  387. return (FALSE);
  388. }
  390. EXPORT
  391. int scsireset(scgp)
  392. SCSI *scgp;
  393. {
  394. int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
  396. return (ioctl(f, SCIOCRESET, 0));
  397. }
  399. LOCAL int
  400. scsi_send(scgp, f, sp)
  401. SCSI *scgp;
  402. int f;
  403. struct scg_cmd *sp;
  404. {
  405. scsireq_t req;
  406. register long *lp1;
  407. register long *lp2;
  408. int ret = 0;
  410. /* printf("f: %dn", f);*/
  411. if (f < 0) {
  412. sp->error = SCG_FATAL;
  413. return (0);
  414. }
  415. req.flags = SCCMD_ESCAPE; /* We set the SCSI cmd len */
  416. if (sp->flags & SCG_RECV_DATA)
  417. req.flags |= SCCMD_READ;
  418. else if (sp->size > 0)
  419. req.flags |= SCCMD_WRITE;
  421. req.timeout = sp->timeout * 1000;
  422. lp1 = (long *)sp->cdb.cmd_cdb;
  423. lp2 = (long *)req.cmd;
  424. *lp2++ = *lp1++;
  425. *lp2++ = *lp1++;
  426. *lp2++ = *lp1++;
  427. *lp2++ = *lp1++;
  428. req.cmdlen = sp->cdb_len;
  429. req.databuf = sp->addr;
  430. req.datalen = sp->size;
  431. req.datalen_used = 0;
  432. fillbytes(req.sense, sizeof(req.sense), '');
  433. if (sp->sense_len > sizeof(req.sense))
  434. req.senselen = sizeof(req.sense);
  435. else if (sp->sense_len < 0)
  436. req.senselen = 0;
  437. else
  438. req.senselen = sp->sense_len;
  439. req.senselen_used = 0;
  440. req.status = 0;
  441. req.retsts = 0;
  442. req.error = 0;
  444. if (ioctl(f, SCIOCCOMMAND, (void *)&req) < 0) {
  445. ret  = -1;
  446. sp->ux_errno = geterrno();
  447. if (sp->ux_errno != ENOTTY)
  448. ret = 0;
  449. } else {
  450. sp->ux_errno = 0;
  451. if (req.retsts != SCCMD_OK)
  452. sp->ux_errno = EIO;
  453. }
  454. fillbytes(&sp->scb, sizeof(sp->scb), '');
  455. fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  456. sp->resid = req.datalen - req.datalen_used;
  457. sp->sense_count = req.senselen_used;
  458. if (sp->sense_count > SCG_MAX_SENSE)
  459. sp->sense_count = SCG_MAX_SENSE;
  460. movebytes(req.sense, sp->u_sense.cmd_sense, sp->sense_count);
  461. sp->u_scb.cmd_scb[0] = req.status;
  463. switch (req.retsts) {
  465. case SCCMD_OK:
  466. #ifdef BSD_SCSI_SENSE_BUG
  467. sp->u_scb.cmd_scb[0] = 0;
  468. sp->ux_errno = 0;
  469. #endif
  470. sp->error = SCG_NO_ERROR; break;
  471. case SCCMD_TIMEOUT: sp->error = SCG_TIMEOUT; break;
  472. default:
  473. case SCCMD_BUSY: sp->error = SCG_RETRYABLE; break;
  474. case SCCMD_SENSE: sp->error = SCG_RETRYABLE; break;
  475. case SCCMD_UNKNOWN: sp->error = SCG_FATAL; break;
  476. }
  478. return (ret);
  479. }
  480. #define sense u_sense.Sense
  482. #else /* BSD_CAM */
  483. /*
  484.  * Interface for the FreeBSD CAM passthrough device.
  485.  *
  486.  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
  487.  * Copyright (c) 1998 Kenneth D. Merry <ken@kdm.org>
  488.  * Copyright (c) 1998 Joerg Schilling <schilling@fokus.gmd.de>
  489.  * All rights reserved.
  490.  *
  491.  * Redistribution and use in source and binary forms, with or without
  492.  * modification, are permitted provided that the following conditions
  493.  * are met:
  494.  * 1. Redistributions of source code must retain the above copyright
  495.  *    notice, this list of conditions and the following disclaimer.
  496.  * 2. Redistributions in binary form must reproduce the above copyright
  497.  *    notice, this list of conditions and the following disclaimer in the
  498.  *    documentation and/or other materials provided with the distribution.
  499.  *
  500.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  501.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  502.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  503.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  504.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  505.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  506.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  507.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  508.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  509.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  510.  * SUCH DAMAGE.
  511.  *
  512.  */
  514. #undef sense
  515. #define scsi_sense CAM_scsi_sense
  516. #define scsi_inquiry CAM_scsi_inquiry
  517. #include <sys/param.h>
  518. #include <cam/cam.h>
  519. #include <cam/cam_ccb.h>
  520. #include <cam/scsi/scsi_message.h>
  521. #include <cam/scsi/scsi_pass.h>
  522. #include <camlib.h>
  524. /*
  525.  * Warning: you may change this source, but if you do that
  526.  * you need to change the _scg_version and _scg_auth* string below.
  527.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  528.  * Choose your name instead of "schily" and make clear that the version
  529.  * string is related to a modified source.
  530.  */
  531. LOCAL char _scg_trans_version[] = "scsi-bsd.c-1.26"; /* The version for this transport*/
  533. #define CAM_MAXDEVS 128
  534. struct scg_local {
  535. struct cam_device *cam_devices[CAM_MAXDEVS + 1];
  536. };
  537. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  539. /*
  540.  * Return version information for the low level SCSI transport code.
  541.  * This has been introduced to make it easier to trace down problems
  542.  * in applications.
  543.  */
  544. EXPORT char *
  545. scg__version(scgp, what)
  546. SCSI *scgp;
  547. int what;
  548. {
  549. if (scgp != (SCSI *)0) {
  550. switch (what) {
  552. case SCG_VERSION:
  553. return (_scg_trans_version);
  554. /*
  555.  * If you changed this source, you are not allowed to
  556.  * return "schily" for the SCG_AUTHOR request.
  557.  */
  558. case SCG_AUTHOR:
  559. return (_scg_auth_schily);
  560. case SCG_SCCS_ID:
  561. return (__sccsid);
  562. }
  563. }
  564. return ((char *)0);
  565. }
  567. /*
  568.  * Build a list of everything we can find.
  569.  */
  570. EXPORT int
  571. scsi_open(scgp, device, busno, tgt, tlun)
  572. SCSI *scgp;
  573. char *device;
  574. int busno;
  575. int tgt;
  576. int tlun;
  577. {
  578. char name[16];
  579. int unit;
  580. int nopen = 0;
  581. union ccb ccb;
  582. int bufsize;
  583. struct periph_match_pattern *match_pat;
  584. int fd;
  586. if ((device != NULL && *device != '') || (busno == -2 && tgt == -2)) {
  587. errno = EINVAL;
  588. if (scgp->errstr)
  589. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  590. "Open by 'devname' not supported on this OS");
  591. return (-1);
  592. }
  594. if (scgp->local == NULL) {
  595. scgp->local = malloc(sizeof(struct scg_local));
  596. if (scgp->local == NULL)
  597. return (0);
  599. for (unit = 0; unit <= CAM_MAXDEVS; unit++) {
  600. scglocal(scgp)->cam_devices[unit] = (struct cam_device *)-1;
  601. }
  602. }
  605. /*
  606.  * If we're not scanning the bus, just open one device.
  607.  */
  608. if (busno >= 0 && tgt >= 0 && tlun >= 0) {
  609. scglocal(scgp)->cam_devices[0] = cam_open_btl(busno, tgt, tlun, O_RDWR, NULL);
  610. if (scglocal(scgp)->cam_devices[0] == NULL)
  611. return(-1);
  612. nopen++;
  613. return(nopen);
  614. }
  616. /*
  617.  * First open the transport layer device.  There's no point in the
  618.  * rest of this if we can't open it.
  619.  */
  621. if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
  622. if (scgp->errstr)
  623. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  624. "Open of %s failed", XPT_DEVICE);
  625. return(-1);
  626. }
  627. fillbytes(&ccb, sizeof(union ccb), '');
  629. /*
  630.  * Get a list of up to CAM_MAXDEVS passthrough devices in the
  631.  * system.
  632.  */
  633. ccb.ccb_h.func_code = XPT_DEV_MATCH;
  635. /*
  636.  * Setup the result buffer.
  637.  */
  638. bufsize = sizeof(struct dev_match_result) * CAM_MAXDEVS;
  639. ccb.cdm.match_buf_len = bufsize;
  640. ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
  641. if (ccb.cdm.matches == NULL) {
  642. if (scgp->errstr)
  643. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  644. "Couldn't malloc match buffer");
  645. close(fd);
  646. return(-1);
  647. }
  648. ccb.cdm.num_matches = 0;
  650. /*
  651.  * Setup the pattern buffer.  We're matching against all
  652.  * peripherals named "pass".
  653.  */
  654. ccb.cdm.num_patterns = 1;
  655. ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
  656. ccb.cdm.patterns = (struct dev_match_pattern *)malloc(
  657. sizeof(struct dev_match_pattern));
  658. if (ccb.cdm.patterns == NULL) {
  659. if (scgp->errstr)
  660. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  661. "Couldn't malloc pattern buffer");
  662. close(fd);
  663. free(ccb.cdm.matches);
  664. return(-1);
  665. }
  666. ccb.cdm.patterns[0].type = DEV_MATCH_PERIPH;
  667. match_pat = &ccb.cdm.patterns[0].pattern.periph_pattern;
  668. sprintf(match_pat->periph_name, "pass");
  669. match_pat->flags = PERIPH_MATCH_NAME;
  671. if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
  672. if (scgp->errstr)
  673. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  674. "CAMIOCOMMAND ioctl failed");
  675. close(fd);
  676. free(ccb.cdm.matches);
  677. free(ccb.cdm.patterns);
  678. return(-1);
  679. }
  681. if ((ccb.ccb_h.status != CAM_REQ_CMP)
  682.  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
  683.     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
  684. /* errmsgno(EX_BAD, "Got CAM error 0x%X, CDM error %d.n",*/
  685. if (scgp->errstr)
  686. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  687. "Got CAM error 0x%X, CDM error %d",
  688. ccb.ccb_h.status, ccb.cdm.status);
  689. close(fd);
  690. free(ccb.cdm.matches);
  691. free(ccb.cdm.patterns);
  692. return(-1);
  693. }
  695. free(ccb.cdm.patterns);
  696. close(fd);
  698. for (unit = 0; unit < MIN(CAM_MAXDEVS, ccb.cdm.num_matches); unit++) {
  699. struct periph_match_result *periph_result;
  701. /*
  702.  * We shouldn't have anything other than peripheral
  703.  * matches in here.  If we do, it means an error in the
  704.  * device matching code in the transport layer.
  705.  */
  706. if (ccb.cdm.matches[unit].type != DEV_MATCH_PERIPH) {
  707. /* errmsgno(EX_BAD, "Kernel error! got periph match type %d!!n",*/
  708. if (scgp->errstr)
  709. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  710. "Kernel error! got periph match type %d!!",
  711. ccb.cdm.matches[unit].type);
  712. free(ccb.cdm.matches);
  713. return(-1);
  714. }
  715. periph_result = &ccb.cdm.matches[unit].result.periph_result;
  717. sprintf(name, "/dev/%s%d", periph_result->periph_name,
  718. periph_result->unit_number);
  720. /*
  721.  * cam_open_pass() avoids all lookup and translation from
  722.  * "regular device name" to passthrough unit number and
  723.  * just opens the device in question as a passthrough device.
  724.  */
  725. scglocal(scgp)->cam_devices[unit] = cam_open_pass(name, O_RDWR, NULL);
  727. /*
  728.  * If we get back NULL from the open routine, it wasn't
  729.  * able to open the given passthrough device for one reason
  730.  * or another.
  731.  */
  732. if (scglocal(scgp)->cam_devices[unit] == NULL) {
  733. #ifdef OLD
  734. errmsgno(EX_BAD, "Error opening /dev/%s%dn",
  735. periph_result->periph_name,
  736. periph_result->unit_number);
  737. errmsgno(EX_BAD, "%sn", cam_errbuf);
  738. #endif
  739. if (scgp->errstr)
  740. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  741. "Error opening /dev/%s%d Cam error '%s'",
  742. periph_result->periph_name,
  743. periph_result->unit_number,
  744. cam_errbuf);
  745. break;
  746. }
  747. nopen++;
  748. }
  750. free(ccb.cdm.matches);
  751. return (nopen);
  752. }
  754. EXPORT int
  755. scsi_close(scgp)
  756. SCSI *scgp;
  757. {
  758. register int i;
  760. if (scgp->local == NULL)
  761. return (-1);
  763. for (i = 0; i <= CAM_MAXDEVS; i++) {
  764. if (scglocal(scgp)->cam_devices[i] != (struct cam_device *)-1)
  765. cam_close_device(scglocal(scgp)->cam_devices[i]);
  766. scglocal(scgp)->cam_devices[i] = (struct cam_device *)-1;
  767.         }
  768. return (0);
  769. }
  771. LOCAL
  772. long scsi_maxdma(scgp)
  773. SCSI *scgp;
  774. {
  775. #ifdef DFLTPHYS
  776. return (DFLTPHYS);
  777. #else
  778. return (MAXPHYS);
  779. #endif
  780. }
  782. EXPORT void *
  783. scsi_getbuf(scgp, amt)
  784. SCSI *scgp;
  785. long amt;
  786. {
  787. if (amt <= 0 || amt > scsi_maxdma(scgp))
  788. return ((void *)0);
  789. if (scgp->debug)
  790. printf("scsi_getbuf: %ld bytesn", amt);
  791. scgp->bufbase = valloc((size_t)(amt));
  792. return (scgp->bufbase);
  793. }
  795. EXPORT void
  796. scsi_freebuf(scgp)
  797. SCSI *scgp;
  798. {
  799. if (scgp->bufbase)
  800. free(scgp->bufbase);
  801. scgp->bufbase = NULL;
  802. }
  804. EXPORT
  805. BOOL scsi_havebus(scgp, busno)
  806. SCSI *scgp;
  807. int busno;
  808. {
  809. int unit;
  811. if (scgp->local == NULL)
  812. return (FALSE);
  814. /*
  815.  * There's a "cleaner" way to do this, using the matching code, but
  816.  * it would involve more code than this solution...
  817.  */
  818. for (unit = 0; scglocal(scgp)->cam_devices[unit] != (struct cam_device *)-1; unit++) {
  819. if (scglocal(scgp)->cam_devices[unit] == NULL)
  820. continue;
  821. if (scglocal(scgp)->cam_devices[unit]->path_id == busno)
  822. return (TRUE);
  823. }
  824. return (FALSE);
  825. }
  827. EXPORT
  828. int scsi_fileno(scgp, busno, unit, tlun)
  829. SCSI *scgp;
  830. int busno;
  831. int unit;
  832. int tlun;
  833. {
  834. int i;
  836. if (scgp->local == NULL)
  837. return (-1);
  839. for (i = 0; scglocal(scgp)->cam_devices[i] != (struct cam_device *)-1; i++) {
  840. if (scglocal(scgp)->cam_devices[i] == NULL)
  841. continue;
  842. if ((scglocal(scgp)->cam_devices[i]->path_id == busno) &&
  843.     (scglocal(scgp)->cam_devices[i]->target_id == unit) &&
  844.     (scglocal(scgp)->cam_devices[i]->target_lun == tlun))
  845. return (i);
  846. }
  847. return (-1);
  848. }
  850. EXPORT int
  851. scsi_initiator_id(scgp)
  852. SCSI *scgp;
  853. {
  854. return (-1);
  855. }
  857. EXPORT
  858. int scsi_isatapi(scgp)
  859. SCSI *scgp;
  860. {
  861. return (FALSE);
  862. }
  864. EXPORT
  865. int scsireset(scgp)
  866. SCSI *scgp;
  867. {
  868. /* XXX synchronous reset command - is this wise? */
  869. return (-1);
  870. }
  872. LOCAL int
  873. scsi_send(scgp, unit, sp)
  874. SCSI *scgp;
  875. int unit;
  876. struct scg_cmd *sp;
  877. {
  878. struct cam_device *dev;
  879. union ccb ccb_space;
  880. union ccb *ccb = &ccb_space;
  881. int rv, result;
  882. u_int32_t ccb_flags;
  884. if (unit < 0) {
  885. #if 0
  886. fprintf(stderr, "attempt to reference invalid unit %dn", unit);
  887. #endif
  888. sp->error = SCG_FATAL;
  889. return (0);
  890. }
  892. dev = scglocal(scgp)->cam_devices[unit];
  893. fillbytes(&ccb->ccb_h, sizeof(struct ccb_hdr), '');
  894. ccb->ccb_h.path_id = dev->path_id;
  895. ccb->ccb_h.target_id = dev->target_id;
  896. ccb->ccb_h.target_lun = dev->target_lun;
  898. /* Build the CCB */
  899. fillbytes(&(&ccb->ccb_h)[1], sizeof(struct ccb_scsiio), '');
  900. movebytes(sp->cdb.cmd_cdb, &ccb->csio.cdb_io.cdb_bytes, sp->cdb_len);
  902. /*
  903.  * Set the data direction flags.
  904.  */
  905. if (sp->size != 0) {
  906. ccb_flags = (sp->flags & SCG_RECV_DATA) ? CAM_DIR_IN :
  907.    CAM_DIR_OUT;
  908. } else {
  909. ccb_flags = CAM_DIR_NONE;
  910. }
  912. ccb_flags |= CAM_DEV_QFRZDIS;
  914. /*
  915.  * If you don't want to bother with sending tagged commands under CAM,
  916.  * we don't need to do anything to cdrecord.  If you want to send
  917.  * tagged commands to those devices that support it, we'll need to set
  918.  * the tag action valid field like this in scsi_send():
  919.    *         
  920.  *        ccb_flags |= CAM_DEV_QFRZDIS | CAM_TAG_ACTION_VALID;
  921.  */
  923. cam_fill_csio(&ccb->csio,
  924.       /* retries */ 1,
  925.       /* cbfncp */ NULL,
  926.       /* flags */ ccb_flags,
  927.       /* tag_action */ MSG_SIMPLE_Q_TAG,
  928.       /* data_ptr */ (u_int8_t *)sp->addr,
  929.       /* dxfer_len */ sp->size,
  930.       /* sense_len */ SSD_FULL_SIZE,
  931.       /* cdb_len */ sp->cdb_len,
  932.       /* timeout */ sp->timeout * 1000);
  934. /* Run the command */
  935. errno = 0;
  936. if ((rv = cam_send_ccb(dev, ccb)) == -1) {
  937. return (rv);
  938. } else {
  939. /*
  940.  * Check for command status.  Selection timeouts are fatal.
  941.  * For command timeouts, we pass back the appropriate
  942.  * error.  If we completed successfully, there's (obviously)
  943.  * no error.  We declare anything else "retryable".
  944.  */
  945. switch(ccb->ccb_h.status & CAM_STATUS_MASK) {
  946. case CAM_SEL_TIMEOUT:
  947. result = SCG_FATAL;
  948. break;
  949. case CAM_CMD_TIMEOUT:
  950. result = SCG_TIMEOUT;
  951. break;
  952. case CAM_REQ_CMP:
  953. result = SCG_NO_ERROR;
  954. break;
  955. default:
  956. result = SCG_RETRYABLE;
  957. break;
  958. }
  959. }
  961. sp->error = result;
  962. if (result != SCG_NO_ERROR)
  963. sp->ux_errno = EIO;
  965. /* Pass the result back up */
  966. fillbytes(&sp->scb, sizeof(sp->scb), '');
  967. fillbytes(&sp->u_sense.cmd_sense, sizeof(sp->u_sense.cmd_sense), '');
  968. sp->resid = ccb->csio.resid;
  969. sp->sense_count = SSD_FULL_SIZE - ccb->csio.sense_resid;
  971. /*
  972.  * Determine how much room we have for sense data.
  973.  */
  974. if (sp->sense_count > SCG_MAX_SENSE)
  975. sp->sense_count = SCG_MAX_SENSE;
  977. /* Copy the sense data out */
  978. movebytes(&ccb->csio.sense_data, &sp->u_sense.cmd_sense, sp->sense_count);
  980. sp->u_scb.cmd_scb[0] = ccb->csio.scsi_status;
  982. return (0);
  983. }
  985. #undef scsi_sense
  986. #undef scsi_inquiry
  987. #define sense u_sense.Sense
  989. #endif /* BSD_CAM */