Lines Matching +full:hi +full:- +full:speed
1 /*-
2 * SPDX-License-Identifier: BSD-4-Clause
5 * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
75 #define SBP_QUEUE_LEN ((SBP_DMA_SIZE - SBP_LOGIN_SIZE) / sizeof(struct sbp_ocb))
81 *-----------------------
82 * 0- 1( 2): 0 (alignment)
83 * 2- 7( 6): target
84 * 8-15( 8): lun
85 * 16-31( 8): reserved
86 * 32-47(16): SBP_BIND_HI
87 * 48-64(16): bus_id, node_id
104 static int max_speed = -1;
114 "SBP-II Subsystem");
120 "SBP transfer max speed");
151 #define OCB_MATCH(o,s) ((o)->bus_addr == ntohl((s)->orb_lo))
219 #define SBP_LOCK(sbp) mtx_lock(&(sbp)->mtx)
220 #define SBP_UNLOCK(sbp) mtx_unlock(&(sbp)->mtx)
221 #define SBP_LOCK_ASSERT(sbp) mtx_assert(&(sbp)->mtx, MA_OWNED)
247 static MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/FireWire");
258 /* 2 */ "Speed not supported",
283 /* 2 */ "Time-out error",
306 if (device_find_child(parent, "sbp", -1) == NULL)
321 device_set_desc(dev, "SBP-2/SCSI over FireWire");
339 fwdev = sdev->target->fwdev;
340 device_printf(sdev->target->sbp->fd.dev,
342 "speed:%d maxrec:%d\n",
344 sdev->bustgtlun,
345 (sdev->type & 0x40) >> 6,
346 (sdev->type & 0x1f),
347 fwdev->eui.hi,
348 fwdev->eui.lo,
349 fwdev->dst,
350 fwdev->speed,
351 fwdev->maxrec);
353 device_printf(sdev->target->sbp->fd.dev,
356 sdev->bustgtlun,
357 sdev->vendor,
358 sdev->product,
359 sdev->revision);
373 {-1, -1, {0,0}}
379 int bus, i, target=-1;
383 bus = device_get_unit(sbp->fd.dev);
385 /* XXX wired-down configuration should be gotten from
390 if (wired[i].eui.hi == fwdev->eui.hi &&
391 wired[i].eui.lo == fwdev->eui.lo)
397 sbp->targets[target].fwdev == NULL)
399 device_printf(sbp->fd.dev,
401 target, fwdev->eui.hi, fwdev->eui.lo);
402 target = -1;
404 /* non-wired target */
406 if (sbp->targets[i].fwdev == NULL && w[i] == 0) {
423 sbp = target->sbp;
424 crom_init_context(&cc, target->fwdev->csrrom);
426 maxlun = -1;
431 lun = reg->val & 0xffff;
433 printf("target %d lun %d found\n", target->target_id, lun);
440 device_printf(target->sbp->fd.dev, "%d no LUN found\n",
441 target->target_id);
448 for (lun = 0; lun < target->num_lun; lun++) {
449 sdev = target->luns[lun];
452 sdev->flags &= ~VALID_LUN;
457 target->luns[lun] = NULL;
462 if (maxlun != target->num_lun) {
463 newluns = (struct sbp_dev **) realloc(target->luns,
469 newluns = target->luns;
470 maxlun = target->num_lun;
477 if (maxlun > target->num_lun)
478 bzero(&newluns[target->num_lun],
480 (maxlun - target->num_lun));
482 target->luns = newluns;
483 target->num_lun = maxlun;
486 crom_init_context(&cc, target->fwdev->csrrom);
493 lun = reg->val & 0xffff;
499 sdev = target->luns[lun];
507 target->luns[lun] = sdev;
508 sdev->lun_id = lun;
509 sdev->target = target;
510 STAILQ_INIT(&sdev->ocbs);
511 callout_init_mtx(&sdev->login_callout, &sbp->mtx, 0);
512 sdev->status = SBP_DEV_RESET;
514 snprintf(sdev->bustgtlun, 32, "%s:%d:%d",
515 device_get_nameunit(sdev->target->sbp->fd.dev),
516 sdev->target->target_id,
517 sdev->lun_id);
519 sdev->flags |= VALID_LUN;
520 sdev->type = (reg->val & 0xff0000) >> 16;
525 fwdma_malloc(sbp->fd.fc,
527 SBP_DMA_SIZE, &sdev->dma, BUS_DMA_NOWAIT |
529 if (sdev->dma.v_addr == NULL) {
533 target->luns[lun] = NULL;
536 sdev->login = (struct sbp_login_res *) sdev->dma.v_addr;
537 sdev->ocb = (struct sbp_ocb *)
538 ((char *)sdev->dma.v_addr + SBP_LOGIN_SIZE);
539 bzero((char *)sdev->ocb,
542 STAILQ_INIT(&sdev->free_ocbs);
545 ocb = &sdev->ocb[i];
546 ocb->bus_addr = sdev->dma.bus_addr
550 if (bus_dmamap_create(sbp->dmat, 0, &ocb->dmamap)) {
555 callout_init_mtx(&ocb->timer, &sbp->mtx, 0);
564 for (lun = 0; lun < target->num_lun; lun++) {
565 sdev = target->luns[lun];
566 if (sdev != NULL && (sdev->flags & VALID_LUN) == 0) {
569 target->luns[lun] = NULL;
587 device_printf(sbp->fd.dev, "increase SBP_NUM_TARGETS!\n");
591 target = &sbp->targets[i];
592 target->fwdev = fwdev;
593 target->target_id = i;
596 crom_init_context(&cc, target->fwdev->csrrom);
598 if (reg == NULL || reg->val == 0) {
600 target->fwdev = NULL;
603 target->mgm_hi = 0xffff;
604 target->mgm_lo = 0xf0000000 | (reg->val << 2);
605 target->mgm_ocb_cur = NULL;
607 printf("target:%d mgm_port: %x\n", i, target->mgm_lo);
609 STAILQ_INIT(&target->xferlist);
610 target->n_xfer = 0;
611 STAILQ_INIT(&target->mgm_ocb_queue);
612 callout_init_mtx(&target->mgm_ocb_timeout, &sbp->mtx, 0);
613 callout_init_mtx(&target->scan_callout, &sbp->mtx, 0);
615 target->luns = NULL;
616 target->num_lun = 0;
627 bzero(sdev->vendor, sizeof(sdev->vendor));
628 bzero(sdev->product, sizeof(sdev->product));
630 fwdev = sdev->target->fwdev;
631 crom_init_context(cc, fwdev->csrrom);
635 crom_parse_text(cc, sdev->vendor, sizeof(sdev->vendor));
636 /* skip to the unit directory for SBP-2 */
638 if (reg->val == CSRVAL_T10SBP2)
645 snprintf(sdev->revision, sizeof(sdev->revision),
646 "%06x", reg->val);
650 crom_parse_text(cc, sdev->product, sizeof(sdev->product));
657 SBP_LOCK_ASSERT(sdev->target->sbp);
669 timevalsub(&delta, &sdev->target->sbp->last_busreset);
679 callout_reset(&sdev->login_callout, ticks,
683 #define SBP_FWDEV_ALIVE(fwdev) (((fwdev)->status == FWDEVATTACHED) \
684 && crom_has_specver((fwdev)->csrrom, CSRVAL_ANSIT10, CSRVAL_T10SBP2))
689 struct sbp_softc *sbp = target->sbp;
693 alive = SBP_FWDEV_ALIVE(target->fwdev);
695 device_printf(sbp->fd.dev, "%s %d%salive\n",
696 __func__, target->target_id,
703 for (i=0; i < target->num_lun; i++) {
704 sdev = target->luns[i];
707 if (alive && (sdev->status != SBP_DEV_DEAD)) {
708 if (sdev->path != NULL) {
709 xpt_freeze_devq(sdev->path, 1);
710 sdev->freeze++;
718 switch (sdev->status) {
733 switch (sdev->status) {
737 device_printf(sbp->fd.dev, "%s: lost target\n",
740 if (sdev->path) {
741 xpt_freeze_devq(sdev->path, 1);
742 sdev->freeze++;
744 sdev->status = SBP_DEV_RETRY;
747 target->luns[i] = NULL;
751 sdev->status = SBP_DEV_RESET;
772 if ((sbp->flags & SIMQ_FREEZED) == 0) {
773 xpt_freeze_simq(sbp->sim, /*count*/1);
774 sbp->flags |= SIMQ_FREEZED;
776 microtime(&sbp->last_busreset);
796 sbp_cold--;
802 target = &sbp->targets[i];
803 if (target->fwdev == NULL)
806 STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link)
807 if (target->fwdev == fwdev)
817 STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link) {
819 device_printf(sbp->fd.dev,"%s:: EUI:%08x%08x %s attached, state=%d\n",
820 __func__, fwdev->eui.hi, fwdev->eui.lo,
821 (fwdev->status != FWDEVATTACHED) ? "not" : "",
822 fwdev->status);
826 target = &sbp->targets[i];
827 if (target->fwdev == fwdev) {
853 if (target->num_lun == 0)
856 if ((sbp->flags & SIMQ_FREEZED) != 0) {
857 xpt_release_simq(sbp->sim, /*run queue*/TRUE);
858 sbp->flags &= ~SIMQ_FREEZED;
868 sdev = (struct sbp_dev *)xfer->sc;
870 device_printf(sdev->target->sbp->fd.dev,"%s\n", __func__);
873 SBP_LOCK(sdev->target->sbp);
874 STAILQ_INSERT_TAIL(&sdev->target->sbp->fwb.xferlist, xfer, link);
875 SBP_UNLOCK(sdev->target->sbp);
885 sdev = (struct sbp_dev *)xfer->sc;
887 SBP_LOCK_ASSERT(sdev->target->sbp);
888 STAILQ_INSERT_TAIL(&sdev->target->xferlist, xfer, link);
894 struct sbp_dev *tsdev, *sdev = (struct sbp_dev *)xfer->sc;
895 struct sbp_target *target = sdev->target;
898 if (xfer->resp != 0) {
899 device_printf(sdev->target->sbp->fd.dev,
900 "%s: %s failed: resp=%d\n", __func__, sdev->bustgtlun, xfer->resp);
903 SBP_LOCK(target->sbp);
904 for (i = 0; i < target->num_lun; i++) {
905 tsdev = target->luns[i];
906 if (tsdev != NULL && tsdev->status == SBP_DEV_LOGIN)
909 SBP_UNLOCK(target->sbp);
919 device_printf(sdev->target->sbp->fd.dev,
920 "%s:%s\n", __func__,sdev->bustgtlun);
924 xfer->hand = sbp_reset_start_callback;
925 fp = &xfer->send.hdr;
926 fp->mode.wreqq.dest_hi = 0xffff;
927 fp->mode.wreqq.dest_lo = 0xf0000000 | RESET_START;
928 fp->mode.wreqq.data = htonl(0xf);
929 fw_asyreq(xfer->fc, -1, xfer);
937 sdev = (struct sbp_dev *)xfer->sc;
940 device_printf(sdev->target->sbp->fd.dev,
941 "%s:%s\n", __func__, sdev->bustgtlun);
943 SBP_LOCK(sdev->target->sbp);
945 SBP_UNLOCK(sdev->target->sbp);
954 for (i = lun, sdevp = &target->luns[lun]; i < target->num_lun;
956 if (*sdevp != NULL && (*sdevp)->status == SBP_DEV_PROBE)
969 sdev = (struct sbp_dev *) ccb->ccb_h.ccb_sdev_ptr;
970 target = sdev->target;
971 sbp = target->sbp;
974 device_printf(sbp->fd.dev,
975 "%s:%s\n", __func__, sdev->bustgtlun);
977 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
978 sdev->status = SBP_DEV_ATTACHED;
980 device_printf(sbp->fd.dev,
981 "%s:%s failed\n", __func__, sdev->bustgtlun);
983 sdev = sbp_next_dev(target, sdev->lun_id + 1);
990 xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI);
991 ccb->ccb_h.ccb_sdev_ptr = sdev;
992 ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
996 xpt_release_devq(sdev->path, sdev->freeze, TRUE);
997 sdev->freeze = 1;
1007 SBP_LOCK_ASSERT(target->sbp);
1011 target->target_id);
1015 device_printf(sdev->target->sbp->fd.dev,
1016 "%s:%s\n", __func__, sdev->bustgtlun);
1023 SBP_UNLOCK(target->sbp);
1025 xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI);
1026 ccb->ccb_h.func_code = XPT_SCAN_LUN;
1027 ccb->ccb_h.cbfcnp = sbp_cam_scan_lun;
1028 ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
1029 ccb->crcn.flags = CAM_FLAG_NONE;
1030 ccb->ccb_h.ccb_sdev_ptr = sdev;
1035 SBP_LOCK(target->sbp);
1036 xpt_release_devq(sdev->path, sdev->freeze, TRUE);
1037 sdev->freeze = 1;
1043 sdev->status = SBP_DEV_PROBE;
1044 callout_reset_sbt(&sdev->target->scan_callout, SBT_1MS * scan_delay, 0,
1045 sbp_cam_scan_target, (void *)sdev->target, 0);
1055 sdev = (struct sbp_dev *)xfer->sc;
1056 target = sdev->target;
1057 sbp = target->sbp;
1060 device_printf(sdev->target->sbp->fd.dev,
1061 "%s:%s\n", __func__, sdev->bustgtlun);
1065 if (sdev->path == NULL)
1066 xpt_create_path(&sdev->path, NULL,
1067 cam_sim_path(target->sbp->sim),
1068 target->target_id, sdev->lun_id);
1076 sdev->status = SBP_DEV_ATTACHED;
1090 sdev = (struct sbp_dev *)xfer->sc;
1092 device_printf(sdev->target->sbp->fd.dev,
1093 "%s:%s\n", __func__, sdev->bustgtlun);
1095 if (xfer->resp != 0) {
1096 device_printf(sdev->target->sbp->fd.dev,
1097 "%s:%s resp=%d\n", __func__, sdev->bustgtlun, xfer->resp);
1100 SBP_LOCK(sdev->target->sbp);
1102 if (sdev->path) {
1103 xpt_release_devq(sdev->path, sdev->freeze, TRUE);
1104 sdev->freeze = 0;
1106 SBP_UNLOCK(sdev->target->sbp);
1115 SBP_LOCK_ASSERT(sdev->target->sbp);
1117 device_printf(sdev->target->sbp->fd.dev,
1118 "%s:%s\n", __func__, sdev->bustgtlun);
1123 if (sdev->status == SBP_DEV_ATTACHED || sdev->status == SBP_DEV_PROBE)
1124 xfer->hand = sbp_agent_reset_callback;
1126 xfer->hand = sbp_do_attach;
1127 fp = &xfer->send.hdr;
1128 fp->mode.wreqq.data = htonl(0xf);
1129 fw_asyreq(xfer->fc, -1, xfer);
1138 sdev = (struct sbp_dev *)xfer->sc;
1140 device_printf(sdev->target->sbp->fd.dev,
1141 "%s:%s\n", __func__, sdev->bustgtlun);
1143 SBP_LOCK(sdev->target->sbp);
1146 SBP_UNLOCK(sdev->target->sbp);
1155 device_printf(sdev->target->sbp->fd.dev,
1156 "%s:%s\n", __func__, sdev->bustgtlun);
1160 xfer->hand = sbp_busy_timeout_callback;
1161 fp = &xfer->send.hdr;
1162 fp->mode.wreqq.dest_hi = 0xffff;
1163 fp->mode.wreqq.dest_lo = 0xf0000000 | BUSY_TIMEOUT;
1164 fp->mode.wreqq.data = htonl((1 << (13 + 12)) | 0xf);
1165 fw_asyreq(xfer->fc, -1, xfer);
1172 sdev = (struct sbp_dev *)xfer->sc;
1175 device_printf(sdev->target->sbp->fd.dev,
1176 "%s:%s\n", __func__, sdev->bustgtlun);
1178 if (xfer->resp != 0) {
1180 printf("%s: xfer->resp = %d\n", __func__, xfer->resp);
1182 SBP_LOCK(sdev->target->sbp);
1185 sdev->flags &= ~ORB_POINTER_ACTIVE;
1187 if ((sdev->flags & ORB_POINTER_NEED) != 0) {
1190 sdev->flags &= ~ORB_POINTER_NEED;
1191 ocb = STAILQ_FIRST(&sdev->ocbs);
1195 SBP_UNLOCK(sdev->target->sbp);
1205 device_printf(sdev->target->sbp->fd.dev,
1207 __func__, sdev->bustgtlun,
1208 (uint32_t)ocb->bus_addr);
1211 SBP_LOCK_ASSERT(sdev->target->sbp);
1213 if ((sdev->flags & ORB_POINTER_ACTIVE) != 0) {
1217 sdev->flags |= ORB_POINTER_NEED;
1221 sdev->flags |= ORB_POINTER_ACTIVE;
1225 xfer->hand = sbp_orb_pointer_callback;
1227 fp = &xfer->send.hdr;
1228 fp->mode.wreqb.len = 8;
1229 fp->mode.wreqb.extcode = 0;
1230 xfer->send.payload[0] =
1231 htonl(((sdev->target->sbp->fd.fc->nodeid | FWLOCALBUS) << 16));
1232 xfer->send.payload[1] = htonl((uint32_t)ocb->bus_addr);
1234 if (fw_asyreq(xfer->fc, -1, xfer) != 0) {
1236 ocb->ccb->ccb_h.status = CAM_REQ_INVALID;
1237 xpt_done(ocb->ccb);
1245 sdev = (struct sbp_dev *)xfer->sc;
1248 device_printf(sdev->target->sbp->fd.dev,
1249 "%s:%s\n", __func__, sdev->bustgtlun);
1251 if (xfer->resp != 0) {
1253 device_printf(sdev->target->sbp->fd.dev,
1254 "%s: xfer->resp = %d\n", __func__, xfer->resp);
1256 SBP_LOCK(sdev->target->sbp);
1258 sdev->flags &= ~ORB_DOORBELL_ACTIVE;
1259 if ((sdev->flags & ORB_DOORBELL_NEED) != 0) {
1260 sdev->flags &= ~ORB_DOORBELL_NEED;
1263 SBP_UNLOCK(sdev->target->sbp);
1272 device_printf(sdev->target->sbp->fd.dev,
1273 "%s:%s\n", __func__, sdev->bustgtlun);
1276 if ((sdev->flags & ORB_DOORBELL_ACTIVE) != 0) {
1277 sdev->flags |= ORB_DOORBELL_NEED;
1280 sdev->flags |= ORB_DOORBELL_ACTIVE;
1284 xfer->hand = sbp_doorbell_callback;
1285 fp = &xfer->send.hdr;
1286 fp->mode.wreqq.data = htonl(0xf);
1287 fw_asyreq(xfer->fc, -1, xfer);
1298 SBP_LOCK_ASSERT(sdev->target->sbp);
1300 target = sdev->target;
1301 xfer = STAILQ_FIRST(&target->xferlist);
1303 if (target->n_xfer > 5 /* XXX */) {
1312 target->n_xfer++;
1314 printf("sbp: alloc %d xfer\n", target->n_xfer);
1317 STAILQ_REMOVE_HEAD(&target->xferlist, link);
1321 xfer->recv.pay_len = 0;
1322 xfer->send.spd = min(sdev->target->fwdev->speed, max_speed);
1323 xfer->fc = sdev->target->sbp->fd.fc;
1327 xfer->send.pay_len = 8;
1329 xfer->send.pay_len = 0;
1331 xfer->sc = (caddr_t)sdev;
1332 fp = &xfer->send.hdr;
1333 fp->mode.wreqq.dest_hi = sdev->login->cmd_hi;
1334 fp->mode.wreqq.dest_lo = sdev->login->cmd_lo + offset;
1335 fp->mode.wreqq.tlrt = 0;
1336 fp->mode.wreqq.tcode = tcode;
1337 fp->mode.wreqq.pri = 0;
1338 fp->mode.wreqq.dst = FWLOCALBUS | sdev->target->fwdev->dst;
1352 target = sdev->target;
1353 nid = target->sbp->fd.fc->nodeid | FWLOCALBUS;
1355 SBP_LOCK_ASSERT(target->sbp);
1357 ocb = STAILQ_FIRST(&target->mgm_ocb_queue);
1358 if (target->mgm_ocb_cur != NULL || ocb == NULL) {
1361 STAILQ_REMOVE_HEAD(&target->mgm_ocb_queue, ocb);
1368 ocb->flags = OCB_ACT_MGM;
1369 ocb->sdev = sdev;
1371 bzero((void *)ocb->orb, sizeof(ocb->orb));
1372 ocb->orb[6] = htonl((nid << 16) | SBP_BIND_HI);
1373 ocb->orb[7] = htonl(SBP_DEV2ADDR(target->target_id, sdev->lun_id));
1376 device_printf(sdev->target->sbp->fd.dev,
1378 __func__,sdev->bustgtlun,
1383 ocb->orb[0] = ocb->orb[1] = 0; /* password */
1384 ocb->orb[2] = htonl(nid << 16);
1385 ocb->orb[3] = htonl(sdev->dma.bus_addr);
1386 ocb->orb[4] = htonl(ORB_NOTIFY | sdev->lun_id);
1388 ocb->orb[4] |= htonl(ORB_EXV);
1389 ocb->orb[5] = htonl(SBP_LOGIN_SIZE);
1390 fwdma_sync(&sdev->dma, BUS_DMASYNC_PREREAD);
1393 ocb->orb[0] = htonl((0 << 16) | 0);
1394 ocb->orb[1] = htonl(aocb->bus_addr & 0xffffffff);
1401 ocb->orb[4] = htonl(ORB_NOTIFY | func | sdev->login->id);
1405 if (target->mgm_ocb_cur != NULL) {
1407 STAILQ_INSERT_TAIL(&sdev->target->mgm_ocb_queue, ocb, ocb);
1411 target->mgm_ocb_cur = ocb;
1413 callout_reset(&target->mgm_ocb_timeout, 5 * hz,
1419 xfer->hand = sbp_mgm_callback;
1421 fp = &xfer->send.hdr;
1422 fp->mode.wreqb.dest_hi = sdev->target->mgm_hi;
1423 fp->mode.wreqb.dest_lo = sdev->target->mgm_lo;
1424 fp->mode.wreqb.len = 8;
1425 fp->mode.wreqb.extcode = 0;
1426 xfer->send.payload[0] = htonl(nid << 16);
1427 xfer->send.payload[1] = htonl(ocb->bus_addr & 0xffffffff);
1429 fw_asyreq(xfer->fc, -1, xfer);
1437 csio = &ocb->ccb->csio;
1442 device_get_nameunit(ocb->sdev->target->sbp->fd.dev),
1443 ocb->ccb->ccb_h.target_id,
1444 (uintmax_t)ocb->ccb->ccb_h.target_lun,
1445 csio->cdb_io.cdb_bytes[0],
1446 csio->cdb_io.cdb_bytes[1],
1447 csio->cdb_io.cdb_bytes[2],
1448 csio->cdb_io.cdb_bytes[3],
1449 csio->cdb_io.cdb_bytes[4],
1450 csio->cdb_io.cdb_bytes[5],
1451 csio->cdb_io.cdb_bytes[6],
1452 csio->cdb_io.cdb_bytes[7],
1453 csio->cdb_io.cdb_bytes[8],
1454 csio->cdb_io.cdb_bytes[9],
1455 ocb->ccb->ccb_h.flags & CAM_DIR_MASK,
1456 csio->cdb_len, csio->dxfer_len,
1457 csio->sense_len);
1466 sbp_cmd_status = (struct sbp_cmd_status *)sbp_status->data;
1467 sense = (struct scsi_sense_data_fixed *)&ocb->ccb->csio.sense_data;
1473 ocb->sdev->bustgtlun,
1474 sbp_cmd_status->status,
1475 sbp_cmd_status->sfmt,
1476 sbp_cmd_status->valid,
1477 sbp_cmd_status->s_key,
1478 sbp_cmd_status->s_code,
1479 sbp_cmd_status->s_qlfr,
1480 sbp_status->len);
1483 switch (sbp_cmd_status->status) {
1487 if (sbp_cmd_status->sfmt == SBP_SFMT_CURR) {
1488 sense->error_code = SSD_CURRENT_ERROR;
1490 sense->error_code = SSD_DEFERRED_ERROR;
1492 if (sbp_cmd_status->valid)
1493 sense->error_code |= SSD_ERRCODE_VALID;
1494 sense->flags = sbp_cmd_status->s_key;
1495 if (sbp_cmd_status->mark)
1496 sense->flags |= SSD_FILEMARK;
1497 if (sbp_cmd_status->eom)
1498 sense->flags |= SSD_EOM;
1499 if (sbp_cmd_status->ill_len)
1500 sense->flags |= SSD_ILI;
1502 bcopy(&sbp_cmd_status->info, &sense->info[0], 4);
1504 if (sbp_status->len <= 1)
1506 sense->extra_len = 0;
1507 else if (sbp_status->len <= 4)
1509 sense->extra_len = 6;
1512 sense->extra_len = 10;
1514 bcopy(&sbp_cmd_status->cdb, &sense->cmd_spec_info[0], 4);
1516 sense->add_sense_code = sbp_cmd_status->s_code;
1517 sense->add_sense_code_qual = sbp_cmd_status->s_qlfr;
1518 sense->fru = sbp_cmd_status->fru;
1520 bcopy(&sbp_cmd_status->s_keydep[0],
1521 &sense->sense_key_spec[0], 3);
1523 ocb->ccb->csio.scsi_status = sbp_cmd_status->status;
1524 ocb->ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
1540 device_printf(ocb->sdev->target->sbp->fd.dev,
1542 __func__, ocb->sdev->bustgtlun,
1543 sbp_cmd_status->status);
1554 ccb = ocb->ccb;
1555 sdev = ocb->sdev;
1557 if (ccb->csio.cdb_io.cdb_bytes[1] & SI_EVPD)
1560 device_printf(sdev->target->sbp->fd.dev,
1561 "%s:%s\n", __func__, sdev->bustgtlun);
1563 inq = (struct scsi_inquiry_data *) ccb->csio.data_ptr;
1572 inq->device |= T_RBC; /* T_DIRECT == 0 */
1581 bcopy(sdev->vendor, inq->vendor, sizeof(inq->vendor));
1582 bcopy(sdev->product, inq->product, sizeof(inq->product));
1583 bcopy(sdev->revision + 2, inq->revision, sizeof(inq->revision));
1592 inq->flags |= SID_CmdQue;
1594 inq->flags &= ~SID_CmdQue;
1615 ld = xfer->recv.buf;
1617 xfer->resp, xfer->recv.len, xfer->recv.off, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3]));
1621 sbp = (struct sbp_softc *)xfer->sc;
1623 if (xfer->resp != 0) {
1624 printf("sbp_recv: xfer->resp = %d\n", xfer->resp);
1627 if (xfer->recv.payload == NULL) {
1628 printf("sbp_recv: xfer->recv.payload == NULL\n");
1631 rfp = &xfer->recv.hdr;
1632 if (rfp->mode.wreqb.tcode != FWTCODE_WREQB) {
1633 printf("sbp_recv: tcode = %d\n", rfp->mode.wreqb.tcode);
1636 sbp_status = (struct sbp_status *)xfer->recv.payload;
1637 addr = rfp->mode.wreqb.dest_lo;
1643 device_printf(sbp->fd.dev,
1647 target = &sbp->targets[t];
1649 if (l >= target->num_lun || target->luns[l] == NULL) {
1650 device_printf(sbp->fd.dev,
1654 sdev = target->luns[l];
1657 switch (sbp_status->src) {
1661 ocb = target->mgm_ocb_cur;
1664 callout_stop(&target->mgm_ocb_timeout);
1665 target->mgm_ocb_cur = NULL;
1671 device_printf(sdev->target->sbp->fd.dev,
1673 __func__,sdev->bustgtlun,
1674 ntohl(sbp_status->orb_lo));
1679 device_printf(sdev->target->sbp->fd.dev,
1681 __func__, sdev->bustgtlun);
1684 device_printf(sdev->target->sbp->fd.dev,
1685 "%s:%s unknown sbp_status->src\n",
1686 __func__, sdev->bustgtlun);
1689 status_valid0 = (sbp_status->src < 2
1690 && sbp_status->resp == ORB_RES_CMPL
1691 && sbp_status->dead == 0);
1692 status_valid = (status_valid0 && sbp_status->status == 0);
1697 device_printf(sdev->target->sbp->fd.dev,
1700 __func__, sdev->bustgtlun,
1701 sbp_status->src, sbp_status->resp, sbp_status->dead,
1702 sbp_status->len, sbp_status->status,
1703 ntohs(sbp_status->orb_hi), ntohl(sbp_status->orb_lo));
1705 device_printf(sdev->target->sbp->fd.dev,
1706 "%s\n", sdev->bustgtlun);
1707 status = sbp_status->status;
1708 switch (sbp_status->resp) {
1727 printf("unknown respose code %d\n", sbp_status->resp);
1732 if (sbp_status->dead) {
1733 if (sdev->path) {
1734 xpt_freeze_devq(sdev->path, 1);
1735 sdev->freeze++;
1743 switch (ntohl(ocb->orb[4]) & ORB_FMT_MSK) {
1749 switch (ocb->flags) {
1751 orb_fun = ntohl(ocb->orb[4]) & ORB_FUN_MSK;
1755 fwdma_sync(&sdev->dma, BUS_DMASYNC_POSTREAD);
1756 login_res = sdev->login;
1757 login_res->len = ntohs(login_res->len);
1758 login_res->id = ntohs(login_res->id);
1759 login_res->cmd_hi = ntohs(login_res->cmd_hi);
1760 login_res->cmd_lo = ntohl(login_res->cmd_lo);
1763 device_printf(sdev->target->sbp->fd.dev,
1765 __func__, sdev->bustgtlun,
1766 login_res->len, login_res->id,
1767 login_res->cmd_hi, login_res->cmd_lo,
1768 ntohs(login_res->recon_hold));
1773 device_printf(sdev->target->sbp->fd.dev,
1775 __func__, sdev->bustgtlun);
1776 sdev->status = SBP_DEV_RESET;
1780 login_res = sdev->login;
1783 device_printf(sdev->target->sbp->fd.dev,
1785 __func__, sdev->bustgtlun,
1786 login_res->len, login_res->id,
1787 login_res->cmd_hi, login_res->cmd_lo);
1789 if (sdev->status == SBP_DEV_ATTACHED)
1796 device_printf(sdev->target->sbp->fd.dev,
1798 __func__, sdev->bustgtlun);
1804 sdev->status = SBP_DEV_RESET;
1815 device_printf(sdev->target->sbp->fd.dev,
1817 __func__, sdev->bustgtlun, orb_fun);
1823 sdev->timeout = 0;
1824 if (ocb->ccb != NULL) {
1827 ccb = ocb->ccb;
1828 if (sbp_status->len > 1) {
1831 if (sbp_status->resp != ORB_RES_CMPL) {
1832 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1834 ccb->ccb_h.status = CAM_REQ_CMP;
1838 if (ccb->csio.cdb_io.cdb_bytes[0] == INQUIRY)
1855 xfer->recv.pay_len = SBP_RECV_LEN;
1864 xfer->send.off = 0;
1865 sfp = (struct fw_pkt *)xfer->send.buf;
1866 sfp->mode.wres.dst = rfp->mode.wreqb.src;
1867 xfer->dst = sfp->mode.wres.dst;
1868 xfer->spd = min(sdev->target->fwdev->speed, max_speed);
1869 xfer->hand = sbp_loginres_callback;
1871 sfp->mode.wres.tlrt = rfp->mode.wreqb.tlrt;
1872 sfp->mode.wres.tcode = FWTCODE_WRES;
1873 sfp->mode.wres.rtcode = 0;
1874 sfp->mode.wres.pri = 0;
1876 fw_asyreq(xfer->fc, -1, xfer);
1879 STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link);
1888 sbp = (struct sbp_softc *)xfer->sc;
1919 sbp->fd.dev = dev;
1920 sbp->fd.fc = fc = device_get_ivars(dev);
1921 mtx_init(&sbp->mtx, "sbp", NULL, MTX_DEF);
1924 max_speed = fc->speed;
1926 error = bus_dma_tag_create(/*parent*/fc->dmat,
1937 /*lockarg*/&sbp->mtx,
1938 &sbp->dmat);
1941 "- error %d\n", error);
1950 sbp->targets[i].fwdev = NULL;
1951 sbp->targets[i].luns = NULL;
1952 sbp->targets[i].sbp = sbp;
1955 sbp->sim = cam_sim_alloc(sbp_action, sbp_poll, "sbp", sbp,
1957 &sbp->mtx,
1959 /*tagged*/ SBP_QUEUE_LEN - 1,
1962 if (sbp->sim == NULL) {
1968 if (xpt_bus_register(sbp->sim, dev, /*bus*/0) != CAM_SUCCESS)
1971 if (xpt_create_path(&sbp->path, NULL, cam_sim_path(sbp->sim),
1973 xpt_bus_deregister(cam_sim_path(sbp->sim));
1979 sbp->fwb.start = ((u_int64_t)SBP_BIND_HI << 32) | SBP_DEV2ADDR(0, 0);
1980 sbp->fwb.end = sbp->fwb.start + 0xffff;
1981 /* pre-allocate xfer */
1982 STAILQ_INIT(&sbp->fwb.xferlist);
1983 fw_xferlist_add(&sbp->fwb.xferlist, M_SBP,
1987 fw_bindadd(fc, &sbp->fwb);
1989 sbp->fd.post_busreset = sbp_post_busreset;
1990 sbp->fd.post_explore = sbp_post_explore;
1992 if (fc->status != -1) {
1997 xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL);
2003 cam_sim_free(sbp->sim, /*free_devq*/TRUE);
2019 target = &sbp->targets[i];
2020 if (target->luns == NULL)
2022 for (j = 0; j < target->num_lun; j++) {
2023 sdev = target->luns[j];
2026 callout_stop(&sdev->login_callout);
2027 if (sdev->status >= SBP_DEV_TOATTACH &&
2028 sdev->status <= SBP_DEV_ATTACHED)
2055 sbp = sdev->target->sbp;
2057 callout_drain(&sdev->login_callout);
2059 callout_drain(&sdev->ocb[i].timer);
2060 bus_dmamap_destroy(sbp->dmat, sdev->ocb[i].dmamap);
2062 fwdma_free(sbp->fd.fc, &sdev->dma);
2074 if (target->luns == NULL)
2076 sbp = target->sbp;
2079 callout_drain(&target->mgm_ocb_timeout);
2080 callout_drain(&target->scan_callout);
2082 for (i = 0; i < target->num_lun; i++)
2083 sbp_free_sdev(target->luns[i]);
2085 STAILQ_FOREACH_SAFE(xfer, &target->xferlist, link, next) {
2088 STAILQ_INIT(&target->xferlist);
2089 free(target->luns, M_SBP);
2090 target->num_lun = 0;
2091 target->luns = NULL;
2092 target->fwdev = NULL;
2099 struct firewire_comm *fc = sbp->fd.fc;
2108 sbp_cam_detach_target(&sbp->targets[i]);
2110 xpt_async(AC_LOST_DEVICE, sbp->path, NULL);
2111 xpt_free_path(sbp->path);
2112 xpt_bus_deregister(cam_sim_path(sbp->sim));
2113 cam_sim_free(sbp->sim, /*free_devq*/ TRUE);
2123 sbp_free_target(&sbp->targets[i]);
2126 fw_bindremove(fc, &sbp->fwb);
2127 fw_xferlist_remove(&sbp->fwb.xferlist);
2129 bus_dma_tag_destroy(sbp->dmat);
2130 mtx_destroy(&sbp->mtx);
2140 if (sdev->status == SBP_DEV_DEAD)
2142 if (sdev->status == SBP_DEV_RESET)
2144 SBP_LOCK_ASSERT(sdev->target->sbp);
2146 if (sdev->path) {
2147 xpt_release_devq(sdev->path,
2148 sdev->freeze, TRUE);
2149 sdev->freeze = 0;
2150 xpt_async(AC_LOST_DEVICE, sdev->path, NULL);
2151 xpt_free_path(sdev->path);
2152 sdev->path = NULL;
2161 SBP_LOCK_ASSERT(target->sbp);
2162 if (target->luns != NULL) {
2164 printf("sbp_detach_target %d\n", target->target_id);
2166 callout_stop(&target->scan_callout);
2167 for (i = 0; i < target->num_lun; i++)
2168 sbp_cam_detach_sdev(target->luns[i]);
2176 struct sbp_target *target = sdev->target;
2179 SBP_LOCK_ASSERT(target->sbp);
2180 for (i = 0; i < target->num_lun; i++) {
2181 tsdev = target->luns[i];
2184 if (tsdev->status == SBP_DEV_DEAD)
2186 if (tsdev->status == SBP_DEV_RESET)
2188 xpt_freeze_devq(tsdev->path, 1);
2189 tsdev->freeze++;
2192 tsdev->status = SBP_DEV_LOGIN;
2211 struct sbp_dev *sdev = ocb->sdev;
2212 struct sbp_target *target = sdev->target;
2214 SBP_LOCK_ASSERT(target->sbp);
2215 device_printf(sdev->target->sbp->fd.dev,
2217 __func__, sdev->bustgtlun, (uint32_t)ocb->bus_addr);
2218 target->mgm_ocb_cur = NULL;
2225 device_printf(sdev->target->sbp->fd.dev,
2227 __func__, sdev->bustgtlun);
2235 struct sbp_dev *sdev = ocb->sdev;
2237 device_printf(sdev->target->sbp->fd.dev,
2239 __func__, sdev->bustgtlun, (uint32_t)ocb->bus_addr);
2241 SBP_LOCK_ASSERT(sdev->target->sbp);
2242 sdev->timeout++;
2243 switch (sdev->timeout) {
2246 xpt_freeze_devq(sdev->path, 1);
2247 sdev->freeze++;
2253 sbp_target_reset(sdev, sdev->timeout - 1);
2259 if (target->luns != NULL)
2260 free(target->luns, M_SBP);
2261 target->num_lun = 0;
2262 target->luns = NULL;
2263 target->fwdev = NULL;
2278 /* target:lun -> sdev mapping */
2280 && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD
2281 && ccb->ccb_h.target_id < SBP_NUM_TARGETS) {
2282 target = &sbp->targets[ccb->ccb_h.target_id];
2283 if (target->fwdev != NULL
2284 && ccb->ccb_h.target_lun != CAM_LUN_WILDCARD
2285 && ccb->ccb_h.target_lun < target->num_lun) {
2286 sdev = target->luns[ccb->ccb_h.target_lun];
2287 if (sdev != NULL && sdev->status != SBP_DEV_ATTACHED &&
2288 sdev->status != SBP_DEV_PROBE)
2296 ccb->ccb_h.target_id, (uintmax_t)ccb->ccb_h.target_lun);
2299 switch (ccb->ccb_h.func_code) {
2309 device_get_nameunit(sbp->fd.dev),
2310 ccb->ccb_h.target_id,
2311 (uintmax_t)ccb->ccb_h.target_lun,
2312 ccb->ccb_h.func_code);
2315 ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2327 ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) {
2331 device_get_nameunit(sbp->fd.dev),
2332 ccb->ccb_h.target_id,
2333 (uintmax_t)ccb->ccb_h.target_lun,
2334 ccb->ccb_h.func_code);
2336 ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2346 switch (ccb->ccb_h.func_code) {
2351 int speed;
2354 csio = &ccb->csio;
2355 mtx_assert(sim->mtx, MA_OWNED);
2362 device_get_nameunit(sbp->fd.dev),
2363 ccb->ccb_h.target_id, (uintmax_t)ccb->ccb_h.target_lun,
2364 csio->cdb_io.cdb_bytes[0],
2365 csio->cdb_io.cdb_bytes[1],
2366 csio->cdb_io.cdb_bytes[2],
2367 csio->cdb_io.cdb_bytes[3],
2368 csio->cdb_io.cdb_bytes[4],
2369 csio->cdb_io.cdb_bytes[5],
2370 csio->cdb_io.cdb_bytes[6],
2371 csio->cdb_io.cdb_bytes[7],
2372 csio->cdb_io.cdb_bytes[8],
2373 csio->cdb_io.cdb_bytes[9],
2374 ccb->ccb_h.flags & CAM_DIR_MASK,
2375 csio->cdb_len, csio->dxfer_len,
2376 csio->sense_len);
2379 ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2383 if (csio->cdb_len > sizeof(ocb->orb) - 5 * sizeof(uint32_t)) {
2384 ccb->ccb_h.status = CAM_REQ_INVALID;
2390 if (sdev->status == SBP_DEV_PROBE) {
2392 name = xpt_path_periph(ccb->ccb_h.path)->periph_name;
2395 ccb->ccb_h.status = CAM_REQUEUE_REQ;
2402 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
2403 if (sdev->freeze == 0) {
2404 xpt_freeze_devq(sdev->path, 1);
2405 sdev->freeze++;
2411 ocb->flags = OCB_ACT_CMD;
2412 ocb->sdev = sdev;
2413 ocb->ccb = ccb;
2414 ccb->ccb_h.ccb_sdev_ptr = sdev;
2415 ocb->orb[0] = htonl(1U << 31);
2416 ocb->orb[1] = 0;
2417 ocb->orb[2] = htonl(((sbp->fd.fc->nodeid | FWLOCALBUS) << 16));
2418 ocb->orb[3] = htonl(ocb->bus_addr + IND_PTR_OFFSET);
2419 speed = min(target->fwdev->speed, max_speed);
2420 ocb->orb[4] = htonl(ORB_NOTIFY | ORB_CMD_SPD(speed)
2421 | ORB_CMD_MAXP(speed + 7));
2422 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
2423 ocb->orb[4] |= htonl(ORB_CMD_IN);
2426 if (csio->ccb_h.flags & CAM_CDB_POINTER)
2427 cdb = (void *)csio->cdb_io.cdb_ptr;
2429 cdb = (void *)&csio->cdb_io.cdb_bytes;
2430 bcopy(cdb, (void *)&ocb->orb[5], csio->cdb_len);
2432 printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[0]), ntohl(ocb->orb[1]), ntohl(ocb->orb[2]), ntohl(ocb->orb[3]));
2433 printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[4]), ntohl(ocb->orb[5]), ntohl(ocb->orb[6]), ntohl(ocb->orb[7]));
2435 if (ccb->csio.dxfer_len > 0) {
2438 error = bus_dmamap_load_ccb(/*dma tag*/sbp->dmat,
2439 /*dma map*/ocb->dmamap,
2454 ccg = &ccb->ccg;
2455 if (ccg->block_size == 0) {
2457 ccb->ccb_h.status = CAM_REQ_INVALID;
2464 device_get_nameunit(sbp->fd.dev),
2465 cam_sim_path(sbp->sim),
2466 ccb->ccb_h.target_id, (uintmax_t)ccb->ccb_h.target_lun,
2467 (uintmax_t)ccg->volume_size);
2479 device_get_nameunit(sbp->fd.dev), cam_sim_path(sbp->sim));
2482 ccb->ccb_h.status = CAM_REQ_INVALID;
2488 struct ccb_pathinq *cpi = &ccb->cpi;
2492 device_get_nameunit(sbp->fd.dev),
2493 ccb->ccb_h.target_id, (uintmax_t)ccb->ccb_h.target_lun);
2495 cpi->version_num = 1; /* XXX??? */
2496 cpi->hba_inquiry = PI_TAG_ABLE;
2497 cpi->target_sprt = 0;
2498 cpi->hba_misc = PIM_NOBUSRESET | PIM_NO_6_BYTE;
2499 cpi->hba_eng_cnt = 0;
2500 cpi->max_target = SBP_NUM_TARGETS - 1;
2501 cpi->max_lun = SBP_NUM_LUNS - 1;
2502 cpi->initiator_id = SBP_INITIATOR;
2503 cpi->bus_id = sim->bus_id;
2504 cpi->base_transfer_speed = 400 * 1000 / 8;
2505 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
2506 strlcpy(cpi->hba_vid, "SBP", HBA_IDLEN);
2507 strlcpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
2508 cpi->unit_number = sim->unit_number;
2509 cpi->transport = XPORT_SPI; /* XX should have a FireWire */
2510 cpi->transport_version = 2;
2511 cpi->protocol = PROTO_SCSI;
2512 cpi->protocol_version = SCSI_REV_2;
2514 cpi->ccb_h.status = CAM_REQ_CMP;
2520 struct ccb_trans_settings *cts = &ccb->cts;
2522 &cts->proto_specific.scsi;
2524 &cts->xport_specific.spi;
2526 cts->protocol = PROTO_SCSI;
2527 cts->protocol_version = SCSI_REV_2;
2528 cts->transport = XPORT_SPI; /* should have a FireWire */
2529 cts->transport_version = 2;
2530 spi->valid = CTS_SPI_VALID_DISC;
2531 spi->flags = CTS_SPI_FLAGS_DISC_ENB;
2532 scsi->valid = CTS_SCSI_VALID_TQ;
2533 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
2536 device_get_nameunit(sbp->fd.dev),
2537 ccb->ccb_h.target_id, (uintmax_t)ccb->ccb_h.target_lun);
2539 cts->ccb_h.status = CAM_REQ_CMP;
2544 ccb->ccb_h.status = CAM_UA_ABORT;
2550 ccb->ccb_h.status = CAM_REQ_INVALID;
2581 if (s->ds_len > SBP_SEG_MAX)
2583 ocb->orb[3] = htonl(s->ds_addr);
2584 ocb->orb[4] |= htonl(s->ds_len);
2591 if (s->ds_len < 16)
2594 "(seg=%d/%d)\n", (size_t)s->ds_len, i + 1, seg);
2596 if (s->ds_len > SBP_SEG_MAX)
2598 ocb->ind_ptr[i].hi = htonl(s->ds_len << 16);
2599 ocb->ind_ptr[i].lo = htonl(s->ds_addr);
2601 ocb->orb[4] |= htonl(ORB_CMD_PTBL | seg);
2605 bus_dmamap_sync(ocb->sdev->target->sbp->dmat, ocb->dmamap,
2606 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2608 prev = sbp_enqueue_ocb(ocb->sdev, ocb);
2609 fwdma_sync(&ocb->sdev->dma, BUS_DMASYNC_PREWRITE);
2612 if (ocb->sdev->last_ocb != NULL)
2613 sbp_doorbell(ocb->sdev);
2615 sbp_orb_pointer(ocb->sdev, ocb);
2618 if (prev == NULL || (ocb->sdev->flags & ORB_LINK_DEAD) != 0) {
2619 ocb->sdev->flags &= ~ORB_LINK_DEAD;
2620 sbp_orb_pointer(ocb->sdev, ocb);
2632 fc = sbp->fd.fc;
2634 fc->poll(fc, 0, -1);
2647 device_printf(sdev->target->sbp->fd.dev,
2649 __func__, sdev->bustgtlun, ntohl(sbp_status->orb_lo), sbp_status->src);
2651 SBP_LOCK_ASSERT(sdev->target->sbp);
2652 STAILQ_FOREACH_SAFE(ocb, &sdev->ocbs, ocb, next) {
2655 STAILQ_REMOVE(&sdev->ocbs, ocb, sbp_ocb, ocb);
2656 if (ocb->ccb != NULL)
2657 callout_stop(&ocb->timer);
2658 if (ntohl(ocb->orb[4]) & 0xffff) {
2659 bus_dmamap_sync(sdev->target->sbp->dmat,
2660 ocb->dmamap,
2661 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2664 bus_dmamap_unload(sdev->target->sbp->dmat,
2665 ocb->dmamap);
2668 if (sbp_status->src == SRC_NO_NEXT) {
2677 sdev->flags |= ORB_LINK_DEAD;
2685 if (sdev->last_ocb != NULL) {
2686 sbp_free_ocb(sdev, sdev->last_ocb);
2688 sdev->last_ocb = ocb;
2690 sbp_status->src == SRC_NO_NEXT)
2699 device_printf(sdev->target->sbp->fd.dev,
2701 __func__, sdev->bustgtlun, order);
2712 SBP_LOCK_ASSERT(sdev->target->sbp);
2714 device_printf(sdev->target->sbp->fd.dev,
2715 "%s:%s 0x%08jx\n", __func__, sdev->bustgtlun, (uintmax_t)ocb->bus_addr);
2717 prev2 = prev = STAILQ_LAST(&sdev->ocbs, sbp_ocb, ocb);
2718 STAILQ_INSERT_TAIL(&sdev->ocbs, ocb, ocb);
2720 if (ocb->ccb != NULL) {
2721 callout_reset_sbt(&ocb->timer,
2722 SBT_1MS * ocb->ccb->ccb_h.timeout, 0, sbp_timeout,
2727 prev2 = sdev->last_ocb;
2729 if (prev2 != NULL && (ocb->sdev->flags & ORB_LINK_DEAD) == 0) {
2731 printf("linking chain 0x%jx -> 0x%jx\n",
2732 (uintmax_t)prev2->bus_addr, (uintmax_t)ocb->bus_addr);
2739 *(volatile uint32_t *)&prev2->orb[1] = htonl(ocb->bus_addr);
2740 *(volatile uint32_t *)&prev2->orb[0] = 0;
2751 SBP_LOCK_ASSERT(sdev->target->sbp);
2752 ocb = STAILQ_FIRST(&sdev->free_ocbs);
2754 sdev->flags |= ORB_SHORTAGE;
2758 STAILQ_REMOVE_HEAD(&sdev->free_ocbs, ocb);
2759 ocb->ccb = NULL;
2766 ocb->flags = 0;
2767 ocb->ccb = NULL;
2769 SBP_LOCK_ASSERT(sdev->target->sbp);
2770 STAILQ_INSERT_TAIL(&sdev->free_ocbs, ocb, ocb);
2771 if ((sdev->flags & ORB_SHORTAGE) != 0) {
2774 sdev->flags &= ~ORB_SHORTAGE;
2775 count = sdev->freeze;
2776 sdev->freeze = 0;
2777 xpt_release_devq(sdev->path, count, TRUE);
2786 sdev = ocb->sdev;
2787 SBP_LOCK_ASSERT(sdev->target->sbp);
2789 device_printf(sdev->target->sbp->fd.dev,
2790 "%s:%s 0x%jx\n", __func__, sdev->bustgtlun, (uintmax_t)ocb->bus_addr);
2793 if (ocb->ccb != NULL)
2796 if (ntohl(ocb->orb[4]) & 0xffff) {
2797 bus_dmamap_sync(sdev->target->sbp->dmat, ocb->dmamap,
2798 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2800 bus_dmamap_unload(sdev->target->sbp->dmat, ocb->dmamap);
2802 if (ocb->ccb != NULL) {
2803 callout_stop(&ocb->timer);
2804 ocb->ccb->ccb_h.status = status;
2805 xpt_done(ocb->ccb);
2817 SBP_LOCK_ASSERT(sdev->target->sbp);
2818 STAILQ_CONCAT(&temp, &sdev->ocbs);
2819 STAILQ_INIT(&sdev->ocbs);
2824 if (sdev->last_ocb != NULL) {
2825 sbp_free_ocb(sdev, sdev->last_ocb);
2826 sdev->last_ocb = NULL;