sys/dev/disk/sbp/sbp.c

   1 /*
   2  * Copyright (c) 2003 Hidetoshi Shimokawa
   3  * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the acknowledgement as bellow:
  16  *
  17  *    This product includes software developed by K. Kobayashi and H. Shimokawa
  18  *
  19  * 4. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  24  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  26  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * $FreeBSD: src/sys/dev/firewire/sbp.c,v 1.74 2004/01/08 14:58:09 simokawa Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/conf.h>
  40 #include <sys/module.h>
  41 #include <sys/bus.h>
  42 #include <sys/kernel.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/malloc.h>
  45
  46 #include <sys/devicestat.h>     /* for struct devstat */
  47 #include <sys/thread2.h>
  48
  49 #include <bus/cam/cam.h>
  50 #include <bus/cam/cam_ccb.h>
  51 #include <bus/cam/cam_sim.h>
  52 #include <bus/cam/cam_xpt_sim.h>
  53 #include <bus/cam/cam_debug.h>
  54 #include <bus/cam/cam_periph.h>
  55 #include <bus/cam/scsi/scsi_all.h>
  56
  57 #include <bus/firewire/firewire.h>
  58 #include <bus/firewire/firewirereg.h>
  59 #include <bus/firewire/fwdma.h>
  60 #include <bus/firewire/iec13213.h>
  61 #include "sbp.h"
  62
  63 #define ccb_sdev_ptr    spriv_ptr0
  64 #define ccb_sbp_ptr     spriv_ptr1
  65
  66 #define SBP_NUM_TARGETS 8 /* MAX 64 */
  67 /*
  68  * Scan_bus doesn't work for more than 8 LUNs
  69  * because of CAM_SCSI2_MAXLUN in cam_xpt.c
  70  */
  71 #define SBP_NUM_LUNS 64
  72 #define SBP_DMA_SIZE PAGE_SIZE
  73 #define SBP_LOGIN_SIZE sizeof(struct sbp_login_res)
  74 #define SBP_QUEUE_LEN ((SBP_DMA_SIZE - SBP_LOGIN_SIZE) / sizeof(struct sbp_ocb))
  75 #define SBP_NUM_OCB (SBP_QUEUE_LEN * SBP_NUM_TARGETS)
  76
  77 /*
  78  * STATUS FIFO addressing
  79  *   bit
  80  * -----------------------
  81  *  0- 1( 2): 0 (alingment)
  82  *  2- 7( 6): target
  83  *  8-15( 8): lun
  84  * 16-31( 8): reserved
  85  * 32-47(16): SBP_BIND_HI
  86  * 48-64(16): bus_id, node_id
  87  */
  88 #define SBP_BIND_HI 0x1
  89 #define SBP_DEV2ADDR(t, l) \
  90         (((u_int64_t)SBP_BIND_HI << 32) \
  91         | (((l) & 0xff) << 8) \
  92         | (((t) & 0x3f) << 2))
  93 #define SBP_ADDR2TRG(a) (((a) >> 2) & 0x3f)
  94 #define SBP_ADDR2LUN(a) (((a) >> 8) & 0xff)
  95 #define SBP_INITIATOR 7
  96
  97 static char *orb_fun_name[] = {
  98         ORB_FUN_NAMES
  99 };
 100
 101 static int debug = 0;
 102 static int auto_login = 1;
 103 static int max_speed = -1;
 104 #if 0
 105 static int sbp_cold = 1;
 106 #endif
 107 static int ex_login = 1;
 108 static int login_delay = 1000;  /* msec */
 109 static int scan_delay = 500;    /* msec */
 110 static int sbp_tags = 0;
 111
 112 SYSCTL_DECL(_hw_firewire);
 113 SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD, 0, "SBP-II Subsystem");
 114 SYSCTL_INT(_debug, OID_AUTO, sbp_debug, CTLFLAG_RW, &debug, 0,
 115         "SBP debug flag");
 116 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, auto_login, CTLFLAG_RW, &auto_login, 0,
 117         "SBP perform login automatically");
 118 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, max_speed, CTLFLAG_RW, &max_speed, 0,
 119         "SBP transfer max speed");
 120 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, exclusive_login, CTLFLAG_RW,
 121         &ex_login, 0, "SBP transfer max speed");
 122 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, login_delay, CTLFLAG_RW,
 123         &login_delay, 0, "SBP login delay in msec");
 124 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, scan_delay, CTLFLAG_RW,
 125         &scan_delay, 0, "SBP scan delay in msec");
 126 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, tags, CTLFLAG_RW, &sbp_tags, 0,
 127         "SBP tagged queuing support");
 128
 129 TUNABLE_INT("hw.firewire.sbp.auto_login", &auto_login);
 130 TUNABLE_INT("hw.firewire.sbp.max_speed", &max_speed);
 131 TUNABLE_INT("hw.firewire.sbp.exclusive_login", &ex_login);
 132 TUNABLE_INT("hw.firewire.sbp.login_delay", &login_delay);
 133 TUNABLE_INT("hw.firewire.sbp.scan_delay", &scan_delay);
 134 TUNABLE_INT("hw.firewire.sbp.tags", &sbp_tags);
 135
 136 #define NEED_RESPONSE 0
 137
 138 #define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE)
 139 #ifdef __sparc64__ /* iommu */
 140 #define SBP_IND_MAX howmany(MAXPHYS, SBP_SEG_MAX)
 141 #else
 142 #define SBP_IND_MAX howmany(MAXPHYS, PAGE_SIZE)
 143 #endif
 144 struct sbp_ocb {
 145         STAILQ_ENTRY(sbp_ocb)   ocb;
 146         union ccb       *ccb;
 147         bus_addr_t      bus_addr;
 148         u_int32_t       orb[8];
 149 #define IND_PTR_OFFSET  (8*sizeof(u_int32_t))
 150         struct ind_ptr  ind_ptr[SBP_IND_MAX];
 151         struct sbp_dev  *sdev;
 152         int             flags; /* XXX should be removed */
 153         bus_dmamap_t    dmamap;
 154 };
 155
 156 #define OCB_ACT_MGM 0
 157 #define OCB_ACT_CMD 1
 158 #define OCB_MATCH(o,s)  ((o)->bus_addr == ntohl((s)->orb_lo))
 159
 160 struct sbp_dev{
 161 #define SBP_DEV_RESET           0       /* accept login */
 162 #define SBP_DEV_LOGIN           1       /* to login */
 163 #if 0
 164 #define SBP_DEV_RECONN          2       /* to reconnect */
 165 #endif
 166 #define SBP_DEV_TOATTACH        3       /* to attach */
 167 #define SBP_DEV_PROBE           4       /* scan lun */
 168 #define SBP_DEV_ATTACHED        5       /* in operation */
 169 #define SBP_DEV_DEAD            6       /* unavailable unit */
 170 #define SBP_DEV_RETRY           7       /* unavailable unit */
 171         u_int8_t status:4,
 172                  timeout:4;
 173         u_int8_t type;
 174         u_int16_t lun_id;
 175         u_int16_t freeze;
 176 #define ORB_LINK_DEAD           (1 << 0)
 177 #define VALID_LUN               (1 << 1)
 178 #define ORB_POINTER_ACTIVE      (1 << 2)
 179 #define ORB_POINTER_NEED        (1 << 3)
 180         u_int16_t flags;
 181         struct cam_path *path;
 182         struct sbp_target *target;
 183         struct fwdma_alloc dma;
 184         struct sbp_login_res *login;
 185         struct callout login_callout;
 186         struct sbp_ocb *ocb;
 187         STAILQ_HEAD(, sbp_ocb) ocbs;
 188         STAILQ_HEAD(, sbp_ocb) free_ocbs;
 189         char vendor[32];
 190         char product[32];
 191         char revision[10];
 192 };
 193
 194 struct sbp_target {
 195         int target_id;
 196         int num_lun;
 197         struct sbp_dev  **luns;
 198         struct sbp_softc *sbp;
 199         struct fw_device *fwdev;
 200         u_int32_t mgm_hi, mgm_lo;
 201         struct sbp_ocb *mgm_ocb_cur;
 202         STAILQ_HEAD(, sbp_ocb) mgm_ocb_queue;
 203         struct callout mgm_ocb_timeout;
 204         struct callout scan_callout;
 205         STAILQ_HEAD(, fw_xfer) xferlist;
 206         int n_xfer;
 207 };
 208
 209 struct sbp_softc {
 210         struct firewire_dev_comm fd;
 211         struct cam_sim  *sim;
 212         struct cam_path  *path;
 213         struct sbp_target targets[SBP_NUM_TARGETS];
 214         struct fw_bind fwb;
 215         bus_dma_tag_t   dmat;
 216         struct timeval last_busreset;
 217 #define SIMQ_FREEZED 1
 218         int flags;
 219 };
 220
 221 static void sbp_post_explore (void *);
 222 static void sbp_recv (struct fw_xfer *);
 223 static void sbp_mgm_callback (struct fw_xfer *);
 224 #if 0
 225 static void sbp_cmd_callback (struct fw_xfer *);
 226 #endif
 227 static void sbp_orb_pointer (struct sbp_dev *, struct sbp_ocb *);
 228 static void sbp_execute_ocb (void *,  bus_dma_segment_t *, int, int);
 229 static void sbp_free_ocb (struct sbp_dev *, struct sbp_ocb *);
 230 static void sbp_abort_ocb (struct sbp_ocb *, int);
 231 static void sbp_abort_all_ocbs (struct sbp_dev *, int);
 232 static struct fw_xfer * sbp_write_cmd (struct sbp_dev *, int, int);
 233 static struct sbp_ocb * sbp_get_ocb (struct sbp_dev *);
 234 static struct sbp_ocb * sbp_enqueue_ocb (struct sbp_dev *, struct sbp_ocb *);
 235 static struct sbp_ocb * sbp_dequeue_ocb (struct sbp_dev *, struct sbp_status *);
 236 static void sbp_cam_detach_sdev(struct sbp_dev *);
 237 static void sbp_free_sdev(struct sbp_dev *);
 238 static void sbp_cam_detach_target (struct sbp_target *);
 239 static void sbp_free_target (struct sbp_target *);
 240 static void sbp_mgm_timeout (void *arg);
 241 static void sbp_timeout (void *arg);
 242 static void sbp_mgm_orb (struct sbp_dev *, int, struct sbp_ocb *);
 243
 244 MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/FireWire");
 245
 246 /* cam related functions */
 247 static void     sbp_action(struct cam_sim *sim, union ccb *ccb);
 248 static void     sbp_poll(struct cam_sim *sim);
 249 static void     sbp_cam_scan_lun(struct cam_periph *, union ccb *);
 250 static void     sbp_cam_scan_target(void *arg);
 251
 252 static char *orb_status0[] = {
 253         /* 0 */ "No additional information to report",
 254         /* 1 */ "Request type not supported",
 255         /* 2 */ "Speed not supported",
 256         /* 3 */ "Page size not supported",
 257         /* 4 */ "Access denied",
 258         /* 5 */ "Logical unit not supported",
 259         /* 6 */ "Maximum payload too small",
 260         /* 7 */ "Reserved for future standardization",
 261         /* 8 */ "Resources unavailable",
 262         /* 9 */ "Function rejected",
 263         /* A */ "Login ID not recognized",
 264         /* B */ "Dummy ORB completed",
 265         /* C */ "Request aborted",
 266         /* FF */ "Unspecified error"
 267 #define MAX_ORB_STATUS0 0xd
 268 };
 269
 270 static char *orb_status1_object[] = {
 271         /* 0 */ "Operation request block (ORB)",
 272         /* 1 */ "Data buffer",
 273         /* 2 */ "Page table",
 274         /* 3 */ "Unable to specify"
 275 };
 276
 277 static char *orb_status1_serial_bus_error[] = {
 278         /* 0 */ "Missing acknowledge",
 279         /* 1 */ "Reserved; not to be used",
 280         /* 2 */ "Time-out error",
 281         /* 3 */ "Reserved; not to be used",
 282         /* 4 */ "Busy retry limit exceeded(X)",
 283         /* 5 */ "Busy retry limit exceeded(A)",
 284         /* 6 */ "Busy retry limit exceeded(B)",
 285         /* 7 */ "Reserved for future standardization",
 286         /* 8 */ "Reserved for future standardization",
 287         /* 9 */ "Reserved for future standardization",
 288         /* A */ "Reserved for future standardization",
 289         /* B */ "Tardy retry limit exceeded",
 290         /* C */ "Conflict error",
 291         /* D */ "Data error",
 292         /* E */ "Type error",
 293         /* F */ "Address error"
 294 };
 295
 296 /*
 297  * sbp_probe()
 298  */
 299 static int
 300 sbp_probe(device_t dev)
 301 {
 302         device_t pa;
 303
 304 SBP_DEBUG(0)
 305         kprintf("sbp_probe\n");
 306 END_DEBUG
 307
 308         pa = device_get_parent(dev);
 309         if(device_get_unit(dev) != device_get_unit(pa)){
 310                 return(ENXIO);
 311         }
 312
 313         device_set_desc(dev, "SBP-2/SCSI over FireWire");
 314
 315         if (bootverbose)
 316                 debug = bootverbose;
 317         return (0);
 318 }
 319
 320 static void
 321 sbp_show_sdev_info(struct sbp_dev *sdev, int new)
 322 {
 323         struct fw_device *fwdev;
 324
 325         kprintf("%s:%d:%d ",
 326                 device_get_nameunit(sdev->target->sbp->fd.dev),
 327                 sdev->target->target_id,
 328                 sdev->lun_id
 329         );
 330         if (new == 2) {
 331                 return;
 332         }
 333         fwdev = sdev->target->fwdev;
 334         kprintf("ordered:%d type:%d EUI:%08x%08x node:%d "
 335                 "speed:%d maxrec:%d",
 336                 (sdev->type & 0x40) >> 6,
 337                 (sdev->type & 0x1f),
 338                 fwdev->eui.hi,
 339                 fwdev->eui.lo,
 340                 fwdev->dst,
 341                 fwdev->speed,
 342                 fwdev->maxrec
 343         );
 344         if (new)
 345                 kprintf(" new!\n");
 346         else
 347                 kprintf("\n");
 348         sbp_show_sdev_info(sdev, 2);
 349         kprintf("'%s' '%s' '%s'\n", sdev->vendor, sdev->product, sdev->revision);
 350 }
 351
 352 static struct {
 353         int bus;
 354         int target;
 355         struct fw_eui64 eui;
 356 } wired[] = {
 357         /* Bus  Target  EUI64 */
 358 #if 0
 359         {0,     2,      {0x00018ea0, 0x01fd0154}},      /* Logitec HDD */
 360         {0,     0,      {0x00018ea6, 0x00100682}},      /* Logitec DVD */
 361         {0,     1,      {0x00d03200, 0xa412006a}},      /* Yano HDD */
 362 #endif
 363         {-1,    -1,     {0,0}}
 364 };
 365
 366 static int
 367 sbp_new_target(struct sbp_softc *sbp, struct fw_device *fwdev)
 368 {
 369         int bus, i, target=-1;
 370         char w[SBP_NUM_TARGETS];
 371
 372         bzero(w, sizeof(w));
 373         bus = device_get_unit(sbp->fd.dev);
 374
 375         /* XXX wired-down configuration should be gotten from
 376                                         tunable or device hint */
 377         for (i = 0; wired[i].bus >= 0; i ++) {
 378                 if (wired[i].bus == bus) {
 379                         w[wired[i].target] = 1;
 380                         if (wired[i].eui.hi == fwdev->eui.hi &&
 381                                         wired[i].eui.lo == fwdev->eui.lo)
 382                                 target = wired[i].target;
 383                 }
 384         }
 385         if (target >= 0) {
 386                 if(target < SBP_NUM_TARGETS &&
 387                                 sbp->targets[target].fwdev == NULL)
 388                         return(target);
 389                 device_printf(sbp->fd.dev,
 390                         "target %d is not free for %08x:%08x\n",
 391                         target, fwdev->eui.hi, fwdev->eui.lo);
 392                 target = -1;
 393         }
 394         /* non-wired target */
 395         for (i = 0; i < SBP_NUM_TARGETS; i ++)
 396                 if (sbp->targets[i].fwdev == NULL && w[i] == 0) {
 397                         target = i;
 398                         break;
 399                 }
 400
 401         return target;
 402 }
 403
 404 static void
 405 sbp_alloc_lun(struct sbp_target *target)
 406 {
 407         struct crom_context cc;
 408         struct csrreg *reg;
 409         struct sbp_dev *sdev, **newluns;
 410         struct sbp_softc *sbp;
 411         int maxlun, lun, i;
 412
 413         sbp = target->sbp;
 414         crom_init_context(&cc, target->fwdev->csrrom);
 415         /* XXX shoud parse appropriate unit directories only */
 416         maxlun = -1;
 417         while (cc.depth >= 0) {
 418                 reg = crom_search_key(&cc, CROM_LUN);
 419                 if (reg == NULL)
 420                         break;
 421                 lun = reg->val & 0xffff;
 422 SBP_DEBUG(0)
 423                 kprintf("target %d lun %d found\n", target->target_id, lun);
 424 END_DEBUG
 425                 if (maxlun < lun)
 426                         maxlun = lun;
 427                 crom_next(&cc);
 428         }
 429         if (maxlun < 0)
 430                 kprintf("%s:%d no LUN found\n",
 431                     device_get_nameunit(target->sbp->fd.dev),
 432                     target->target_id);
 433
 434         maxlun ++;
 435         if (maxlun >= SBP_NUM_LUNS)
 436                 maxlun = SBP_NUM_LUNS;
 437
 438         /* Invalidiate stale devices */
 439         for (lun = 0; lun < target->num_lun; lun ++) {
 440                 sdev = target->luns[lun];
 441                 if (sdev == NULL)
 442                         continue;
 443                 sdev->flags &= ~VALID_LUN;
 444                 if (lun >= maxlun) {
 445                         /* lost device */
 446                         sbp_cam_detach_sdev(sdev);
 447                         sbp_free_sdev(sdev);
 448                 }
 449         }
 450
 451         /* Reallocate */
 452         if (maxlun != target->num_lun) {
 453                 /*
 454                  * note: krealloc() does not support M_ZERO.  We must zero
 455                  * the extended region manually.
 456                  */
 457                 newluns = krealloc(target->luns,
 458                                 sizeof(struct sbp_dev *) * maxlun,
 459                                 M_SBP, M_WAITOK);
 460
 461                 if (maxlun > target->num_lun) {
 462                         bzero(&newluns[target->num_lun],
 463                             sizeof(struct sbp_dev *) *
 464                              (maxlun - target->num_lun));
 465                 }
 466                 target->luns = newluns;
 467                 target->num_lun = maxlun;
 468         }
 469
 470         crom_init_context(&cc, target->fwdev->csrrom);
 471         while (cc.depth >= 0) {
 472                 int new = 0;
 473
 474                 reg = crom_search_key(&cc, CROM_LUN);
 475                 if (reg == NULL)
 476                         break;
 477                 lun = reg->val & 0xffff;
 478                 if (lun >= SBP_NUM_LUNS) {
 479                         kprintf("too large lun %d\n", lun);
 480                         goto next;
 481                 }
 482
 483                 sdev = target->luns[lun];
 484                 if (sdev == NULL) {
 485                         sdev = kmalloc(sizeof(struct sbp_dev),
 486                             M_SBP, M_WAITOK | M_ZERO);
 487                         target->luns[lun] = sdev;
 488                         sdev->lun_id = lun;
 489                         sdev->target = target;
 490                         STAILQ_INIT(&sdev->ocbs);
 491                         CALLOUT_INIT(&sdev->login_callout);
 492                         sdev->status = SBP_DEV_RESET;
 493                         new = 1;
 494                 }
 495                 sdev->flags |= VALID_LUN;
 496                 sdev->type = (reg->val & 0xff0000) >> 16;
 497
 498                 if (new == 0)
 499                         goto next;
 500
 501                 fwdma_malloc(sbp->fd.fc,
 502                         /* alignment */ sizeof(u_int32_t),
 503                         SBP_DMA_SIZE, &sdev->dma, BUS_DMA_NOWAIT);
 504                 if (sdev->dma.v_addr == NULL) {
 505                         kprintf("%s: dma space allocation failed\n",
 506                                                         __func__);
 507                         kfree(sdev, M_SBP);
 508                         target->luns[lun] = NULL;
 509                         goto next;
 510                 }
 511                 sdev->login = (struct sbp_login_res *) sdev->dma.v_addr;
 512                 sdev->ocb = (struct sbp_ocb *)
 513                                 ((char *)sdev->dma.v_addr + SBP_LOGIN_SIZE);
 514                 bzero((char *)sdev->ocb,
 515                         sizeof (struct sbp_ocb) * SBP_QUEUE_LEN);
 516
 517                 STAILQ_INIT(&sdev->free_ocbs);
 518                 for (i = 0; i < SBP_QUEUE_LEN; i++) {
 519                         struct sbp_ocb *ocb;
 520                         ocb = &sdev->ocb[i];
 521                         ocb->bus_addr = sdev->dma.bus_addr
 522                                 + SBP_LOGIN_SIZE
 523                                 + sizeof(struct sbp_ocb) * i
 524                                 + offsetof(struct sbp_ocb, orb[0]);
 525                         if (bus_dmamap_create(sbp->dmat, 0, &ocb->dmamap)) {
 526                                 kprintf("sbp_attach: cannot create dmamap\n");
 527                                 /* XXX */
 528                                 goto next;
 529                         }
 530                         sbp_free_ocb(sdev, ocb);
 531                 }
 532 next:
 533                 crom_next(&cc);
 534         }
 535
 536         for (lun = 0; lun < target->num_lun; lun ++) {
 537                 sdev = target->luns[lun];
 538                 if (sdev != NULL && (sdev->flags & VALID_LUN) == 0) {
 539                         sbp_cam_detach_sdev(sdev);
 540                         sbp_free_sdev(sdev);
 541                         target->luns[lun] = NULL;
 542                 }
 543         }
 544 }
 545
 546 static struct sbp_target *
 547 sbp_alloc_target(struct sbp_softc *sbp, struct fw_device *fwdev)
 548 {
 549         int i;
 550         struct sbp_target *target;
 551         struct crom_context cc;
 552         struct csrreg *reg;
 553
 554 SBP_DEBUG(1)
 555         kprintf("sbp_alloc_target\n");
 556 END_DEBUG
 557         i = sbp_new_target(sbp, fwdev);
 558         if (i < 0) {
 559                 device_printf(sbp->fd.dev, "increase SBP_NUM_TARGETS!\n");
 560                 return NULL;
 561         }
 562         /* new target */
 563         target = &sbp->targets[i];
 564         target->sbp = sbp;
 565         target->fwdev = fwdev;
 566         target->target_id = i;
 567         /* XXX we may want to reload mgm port after each bus reset */
 568         /* XXX there might be multiple management agents */
 569         crom_init_context(&cc, target->fwdev->csrrom);
 570         reg = crom_search_key(&cc, CROM_MGM);
 571         if (reg == NULL || reg->val == 0) {
 572                 kprintf("NULL management address\n");
 573                 target->fwdev = NULL;
 574                 return NULL;
 575         }
 576         target->mgm_hi = 0xffff;
 577         target->mgm_lo = 0xf0000000 | (reg->val << 2);
 578         target->mgm_ocb_cur = NULL;
 579 SBP_DEBUG(1)
 580         kprintf("target:%d mgm_port: %x\n", i, target->mgm_lo);
 581 END_DEBUG
 582         STAILQ_INIT(&target->xferlist);
 583         target->n_xfer = 0;
 584         STAILQ_INIT(&target->mgm_ocb_queue);
 585         CALLOUT_INIT(&target->mgm_ocb_timeout);
 586         CALLOUT_INIT(&target->scan_callout);
 587
 588         target->luns = NULL;
 589         target->num_lun = 0;
 590         return target;
 591 }
 592
 593 static void
 594 sbp_probe_lun(struct sbp_dev *sdev)
 595 {
 596         struct fw_device *fwdev;
 597         struct crom_context c, *cc = &c;
 598         struct csrreg *reg;
 599
 600         bzero(sdev->vendor, sizeof(sdev->vendor));
 601         bzero(sdev->product, sizeof(sdev->product));
 602
 603         fwdev = sdev->target->fwdev;
 604         crom_init_context(cc, fwdev->csrrom);
 605         /* get vendor string */
 606         crom_search_key(cc, CSRKEY_VENDOR);
 607         crom_next(cc);
 608         crom_parse_text(cc, sdev->vendor, sizeof(sdev->vendor));
 609         /* skip to the unit directory for SBP-2 */
 610         while ((reg = crom_search_key(cc, CSRKEY_VER)) != NULL) {
 611                 if (reg->val == CSRVAL_T10SBP2)
 612                         break;
 613                 crom_next(cc);
 614         }
 615         /* get firmware revision */
 616         reg = crom_search_key(cc, CSRKEY_FIRM_VER);
 617         if (reg != NULL)
 618                 ksnprintf(sdev->revision, sizeof(sdev->revision),
 619                                                 "%06x", reg->val);
 620         /* get product string */
 621         crom_search_key(cc, CSRKEY_MODEL);
 622         crom_next(cc);
 623         crom_parse_text(cc, sdev->product, sizeof(sdev->product));
 624 }
 625
 626 static void
 627 sbp_login_callout(void *arg)
 628 {
 629         struct sbp_dev *sdev = (struct sbp_dev *)arg;
 630         sbp_mgm_orb(sdev, ORB_FUN_LGI, NULL);
 631 }
 632
 633 static void
 634 sbp_login(struct sbp_dev *sdev)
 635 {
 636         struct timeval delta;
 637         struct timeval t;
 638         int ticks = 0;
 639
 640         microtime(&delta);
 641         timevalsub(&delta, &sdev->target->sbp->last_busreset);
 642         t.tv_sec = login_delay / 1000;
 643         t.tv_usec = (login_delay % 1000) * 1000;
 644         timevalsub(&t, &delta);
 645         if (t.tv_sec >= 0 && t.tv_usec > 0)
 646                 ticks = (t.tv_sec * 1000 + t.tv_usec / 1000) * hz / 1000;
 647 SBP_DEBUG(0)
 648         kprintf("%s: sec = %ld usec = %ld ticks = %d\n", __func__,
 649             t.tv_sec, t.tv_usec, ticks);
 650 END_DEBUG
 651         callout_reset(&sdev->login_callout, ticks,
 652                         sbp_login_callout, (void *)(sdev));
 653 }
 654
 655 #define SBP_FWDEV_ALIVE(fwdev) (((fwdev)->status == FWDEVATTACHED) \
 656         && crom_has_specver((fwdev)->csrrom, CSRVAL_ANSIT10, CSRVAL_T10SBP2))
 657
 658 static void
 659 sbp_probe_target(void *arg)
 660 {
 661         struct sbp_target *target = (struct sbp_target *)arg;
 662         struct sbp_softc *sbp;
 663         struct sbp_dev *sdev;
 664         struct firewire_comm *fc;
 665         int i, alive;
 666
 667         alive = SBP_FWDEV_ALIVE(target->fwdev);
 668 SBP_DEBUG(1)
 669         kprintf("sbp_probe_target %d\n", target->target_id);
 670         if (!alive)
 671                 kprintf("not alive\n");
 672 END_DEBUG
 673
 674         sbp = target->sbp;
 675         fc = target->sbp->fd.fc;
 676         sbp_alloc_lun(target);
 677
 678         /* XXX callout_stop mgm_ocb and dequeue */
 679         for (i=0; i < target->num_lun; i++) {
 680                 sdev = target->luns[i];
 681                 if (sdev == NULL)
 682                         continue;
 683                 if (alive && (sdev->status != SBP_DEV_DEAD)) {
 684                         if (sdev->path != NULL) {
 685                                 xpt_freeze_devq(sdev->path, 1);
 686                                 sdev->freeze ++;
 687                         }
 688                         sbp_probe_lun(sdev);
 689 SBP_DEBUG(0)
 690                         sbp_show_sdev_info(sdev,
 691                                         (sdev->status == SBP_DEV_RESET));
 692 END_DEBUG
 693
 694                         sbp_abort_all_ocbs(sdev, CAM_SCSI_BUS_RESET);
 695                         switch (sdev->status) {
 696                         case SBP_DEV_RESET:
 697                                 /* new or revived target */
 698                                 if (auto_login)
 699                                         sbp_login(sdev);
 700                                 break;
 701                         case SBP_DEV_TOATTACH:
 702                         case SBP_DEV_PROBE:
 703                         case SBP_DEV_ATTACHED:
 704                         case SBP_DEV_RETRY:
 705                         default:
 706                                 sbp_mgm_orb(sdev, ORB_FUN_RCN, NULL);
 707                                 break;
 708                         }
 709                 } else {
 710                         switch (sdev->status) {
 711                         case SBP_DEV_ATTACHED:
 712 SBP_DEBUG(0)
 713                                 /* the device has gone */
 714                                 sbp_show_sdev_info(sdev, 2);
 715                                 kprintf("lost target\n");
 716 END_DEBUG
 717 #if 0
 718                                 if (sdev->path) {
 719                                         xpt_freeze_devq(sdev->path, 1);
 720                                         sdev->freeze ++;
 721                                 }
 722                                 sdev->status = SBP_DEV_RETRY;
 723                                 sbp_abort_all_ocbs(sdev, CAM_SCSI_BUS_RESET);
 724 #endif
 725                                 sbp_cam_detach_target(sdev->target);
 726                                 sdev->status = SBP_DEV_RESET;
 727                                 break;
 728                         case SBP_DEV_PROBE:
 729                         case SBP_DEV_TOATTACH:
 730                                 sdev->status = SBP_DEV_RESET;
 731                                 break;
 732                         case SBP_DEV_RETRY:
 733                         case SBP_DEV_RESET:
 734                         case SBP_DEV_DEAD:
 735                                 break;
 736                         }
 737                 }
 738         }
 739 }
 740
 741 static void
 742 sbp_post_busreset(void *arg)
 743 {
 744         struct sbp_softc *sbp;
 745
 746         sbp = (struct sbp_softc *)arg;
 747 SBP_DEBUG(0)
 748         kprintf("sbp_post_busreset\n");
 749 END_DEBUG
 750         if ((sbp->sim->flags & SIMQ_FREEZED) == 0) {
 751                 xpt_freeze_simq(sbp->sim, /*count*/1);
 752                 sbp->sim->flags |= SIMQ_FREEZED;
 753         }
 754         microtime(&sbp->last_busreset);
 755 }
 756
 757 static void
 758 sbp_post_explore(void *arg)
 759 {
 760         struct sbp_softc *sbp = (struct sbp_softc *)arg;
 761         struct sbp_target *target;
 762         struct fw_device *fwdev;
 763         int i, alive;
 764
 765 SBP_DEBUG(0)
 766         kprintf("sbp_post_explore\n");
 767 END_DEBUG
 768 #if 0
 769         if (sbp_cold > 0)
 770                 sbp_cold --;
 771 #endif
 772
 773 #if 0
 774         /*
 775          * XXX don't let CAM the bus rest.
 776          * CAM tries to do something with freezed (DEV_RETRY) devices.
 777          */
 778         xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL);
 779 #endif
 780
 781         /* Gabage Collection */
 782         for(i = 0 ; i < SBP_NUM_TARGETS ; i ++){
 783                 target = &sbp->targets[i];
 784                 STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link)
 785                         if (target->fwdev == NULL || target->fwdev == fwdev)
 786                                 break;
 787                 if (fwdev == NULL) {
 788                         /* device has removed in lower driver */
 789                         sbp_cam_detach_target(target);
 790                         sbp_free_target(target);
 791                 }
 792         }
 793         /* traverse device list */
 794         STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link) {
 795 SBP_DEBUG(0)
 796                 kprintf("sbp_post_explore: EUI:%08x%08x ",
 797                                 fwdev->eui.hi, fwdev->eui.lo);
 798                 if (fwdev->status != FWDEVATTACHED)
 799                         kprintf("not attached, state=%d.\n", fwdev->status);
 800                 else
 801                         kprintf("attached\n");
 802 END_DEBUG
 803                 alive = SBP_FWDEV_ALIVE(fwdev);
 804                 for(i = 0 ; i < SBP_NUM_TARGETS ; i ++){
 805                         target = &sbp->targets[i];
 806                         if(target->fwdev == fwdev ) {
 807                                 /* known target */
 808                                 break;
 809                         }
 810                 }
 811                 if(i == SBP_NUM_TARGETS){
 812                         if (alive) {
 813                                 /* new target */
 814                                 target = sbp_alloc_target(sbp, fwdev);
 815                                 if (target == NULL)
 816                                         continue;
 817                         } else {
 818                                 continue;
 819                         }
 820                 }
 821                 sbp_probe_target((void *)target);
 822                 if (target->num_lun == 0)
 823                         sbp_free_target(target);
 824         }
 825         xpt_release_simq(sbp->sim, /*run queue*/TRUE);
 826         sbp->sim->flags &= ~SIMQ_FREEZED;
 827 }
 828
 829 #if NEED_RESPONSE
 830 static void
 831 sbp_loginres_callback(struct fw_xfer *xfer){
 832         struct sbp_dev *sdev;
 833         sdev = (struct sbp_dev *)xfer->sc;
 834 SBP_DEBUG(1)
 835         sbp_show_sdev_info(sdev, 2);
 836         kprintf("sbp_loginres_callback\n");
 837 END_DEBUG
 838         /* recycle */
 839         crit_enter();
 840         STAILQ_INSERT_TAIL(&sdev->target->sbp->fwb.xferlist, xfer, link);
 841         crit_exit();
 842         return;
 843 }
 844 #endif
 845
 846 static __inline void
 847 sbp_xfer_free(struct fw_xfer *xfer)
 848 {
 849         struct sbp_dev *sdev;
 850
 851         sdev = (struct sbp_dev *)xfer->sc;
 852         fw_xfer_unload(xfer);
 853         crit_enter();
 854         STAILQ_INSERT_TAIL(&sdev->target->xferlist, xfer, link);
 855         crit_exit();
 856 }
 857
 858 static void
 859 sbp_reset_start_callback(struct fw_xfer *xfer)
 860 {
 861         struct sbp_dev *tsdev, *sdev = (struct sbp_dev *)xfer->sc;
 862         struct sbp_target *target = sdev->target;
 863         int i;
 864
 865         if (xfer->resp != 0) {
 866                 sbp_show_sdev_info(sdev, 2);
 867                 kprintf("sbp_reset_start failed: resp=%d\n", xfer->resp);
 868         }
 869
 870         for (i = 0; i < target->num_lun; i++) {
 871                 tsdev = target->luns[i];
 872                 if (tsdev != NULL && tsdev->status == SBP_DEV_LOGIN)
 873                         sbp_login(tsdev);
 874         }
 875 }
 876
 877 static void
 878 sbp_reset_start(struct sbp_dev *sdev)
 879 {
 880         struct fw_xfer *xfer;
 881         struct fw_pkt *fp;
 882
 883 SBP_DEBUG(0)
 884         sbp_show_sdev_info(sdev, 2);
 885         kprintf("sbp_reset_start\n");
 886 END_DEBUG
 887
 888         xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0);
 889         xfer->act.hand = sbp_reset_start_callback;
 890         fp = &xfer->send.hdr;
 891         fp->mode.wreqq.dest_hi = 0xffff;
 892         fp->mode.wreqq.dest_lo = 0xf0000000 | RESET_START;
 893         fp->mode.wreqq.data = htonl(0xf);
 894         fw_asyreq(xfer->fc, -1, xfer);
 895 }
 896
 897 static void
 898 sbp_mgm_callback(struct fw_xfer *xfer)
 899 {
 900         struct sbp_dev *sdev;
 901         int resp;
 902
 903         sdev = (struct sbp_dev *)xfer->sc;
 904
 905 SBP_DEBUG(1)
 906         sbp_show_sdev_info(sdev, 2);
 907         kprintf("sbp_mgm_callback\n");
 908 END_DEBUG
 909         resp = xfer->resp;
 910         sbp_xfer_free(xfer);
 911 #if 0
 912         if (resp != 0) {
 913                 sbp_show_sdev_info(sdev, 2);
 914                 kprintf("management ORB failed(%d) ... RESET_START\n", resp);
 915                 sbp_reset_start(sdev);
 916         }
 917 #endif
 918         return;
 919 }
 920
 921 static struct sbp_dev *
 922 sbp_next_dev(struct sbp_target *target, int lun)
 923 {
 924         struct sbp_dev **sdevp;
 925         int i;
 926
 927         for (i = lun, sdevp = &target->luns[lun]; i < target->num_lun;
 928             i++, sdevp++)
 929                 if (*sdevp != NULL && (*sdevp)->status == SBP_DEV_PROBE)
 930                         return(*sdevp);
 931         return(NULL);
 932 }
 933
 934 #define SCAN_PRI 1
 935 static void
 936 sbp_cam_scan_lun(struct cam_periph *periph, union ccb *ccb)
 937 {
 938         struct sbp_target *target;
 939         struct sbp_dev *sdev;
 940
 941         sdev = (struct sbp_dev *) ccb->ccb_h.ccb_sdev_ptr;
 942         target = sdev->target;
 943 SBP_DEBUG(0)
 944         sbp_show_sdev_info(sdev, 2);
 945         kprintf("sbp_cam_scan_lun\n");
 946 END_DEBUG
 947         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 948                 sdev->status = SBP_DEV_ATTACHED;
 949         } else {
 950                 sbp_show_sdev_info(sdev, 2);
 951                 kprintf("scan failed\n");
 952         }
 953         sdev = sbp_next_dev(target, sdev->lun_id + 1);
 954         if (sdev == NULL) {
 955                 kfree(ccb, M_SBP);
 956                 return;
 957         }
 958         /* reuse ccb */
 959         xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI);
 960         ccb->ccb_h.ccb_sdev_ptr = sdev;
 961         xpt_action(ccb);
 962         xpt_release_devq(sdev->path, sdev->freeze, TRUE);
 963         sdev->freeze = 1;
 964 }
 965
 966 static void
 967 sbp_cam_scan_target(void *arg)
 968 {
 969         struct sbp_target *target = (struct sbp_target *)arg;
 970         struct sbp_dev *sdev;
 971         union ccb *ccb;
 972
 973         sdev = sbp_next_dev(target, 0);
 974         if (sdev == NULL) {
 975                 kprintf("sbp_cam_scan_target: nothing to do for target%d\n",
 976                                                         target->target_id);
 977                 return;
 978         }
 979 SBP_DEBUG(0)
 980         sbp_show_sdev_info(sdev, 2);
 981         kprintf("sbp_cam_scan_target\n");
 982 END_DEBUG
 983         ccb = kmalloc(sizeof(union ccb), M_SBP, M_WAITOK | M_ZERO);
 984         xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI);
 985         ccb->ccb_h.func_code = XPT_SCAN_LUN;
 986         ccb->ccb_h.cbfcnp = sbp_cam_scan_lun;
 987         ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
 988         ccb->crcn.flags = CAM_FLAG_NONE;
 989         ccb->ccb_h.ccb_sdev_ptr = sdev;
 990
 991         /* The scan is in progress now. */
 992         xpt_action(ccb);
 993         xpt_release_devq(sdev->path, sdev->freeze, TRUE);
 994         sdev->freeze = 1;
 995 }
 996
 997 static __inline void
 998 sbp_scan_dev(struct sbp_dev *sdev)
 999 {
1000         sdev->status = SBP_DEV_PROBE;
1001         callout_reset(&sdev->target->scan_callout, scan_delay * hz / 1000,
1002                         sbp_cam_scan_target, (void *)sdev->target);
1003 }
1004
1005 static void
1006 sbp_do_attach(struct fw_xfer *xfer)
1007 {
1008         struct sbp_dev *sdev;
1009         struct sbp_target *target;
1010         struct sbp_softc *sbp;
1011
1012         sdev = (struct sbp_dev *)xfer->sc;
1013         target = sdev->target;
1014         sbp = target->sbp;
1015 SBP_DEBUG(0)
1016         sbp_show_sdev_info(sdev, 2);
1017         kprintf("sbp_do_attach\n");
1018 END_DEBUG
1019         sbp_xfer_free(xfer);
1020
1021         if (sdev->path == NULL)
1022                 xpt_create_path(&sdev->path, xpt_periph,
1023                         cam_sim_path(target->sbp->sim),
1024                         target->target_id, sdev->lun_id);
1025
1026 #if 0
1027         /*
1028          * Let CAM scan the bus if we are in the boot process.
1029          * XXX xpt_scan_bus cannot detect LUN larger than 0
1030          * if LUN 0 doesn't exists.
1031          */
1032         if (sbp_cold > 0) {
1033                 sdev->status = SBP_DEV_ATTACHED;
1034                 return;
1035         }
1036 #endif
1037
1038         sbp_scan_dev(sdev);
1039         return;
1040 }
1041
1042 static void
1043 sbp_agent_reset_callback(struct fw_xfer *xfer)
1044 {
1045         struct sbp_dev *sdev;
1046
1047         sdev = (struct sbp_dev *)xfer->sc;
1048 SBP_DEBUG(1)
1049         sbp_show_sdev_info(sdev, 2);
1050         kprintf("%s\n", __func__);
1051 END_DEBUG
1052         if (xfer->resp != 0) {
1053                 sbp_show_sdev_info(sdev, 2);
1054                 kprintf("%s: resp=%d\n", __func__, xfer->resp);
1055         }
1056
1057         sbp_xfer_free(xfer);
1058         if (sdev->path) {
1059                 xpt_release_devq(sdev->path, sdev->freeze, TRUE);
1060                 sdev->freeze = 0;
1061         }
1062 }
1063
1064 static void
1065 sbp_agent_reset(struct sbp_dev *sdev)
1066 {
1067         struct fw_xfer *xfer;
1068         struct fw_pkt *fp;
1069
1070 SBP_DEBUG(0)
1071         sbp_show_sdev_info(sdev, 2);
1072         kprintf("sbp_agent_reset\n");
1073 END_DEBUG
1074         xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x04);
1075         if (xfer == NULL)
1076                 return;
1077         if (sdev->status == SBP_DEV_ATTACHED || sdev->status == SBP_DEV_PROBE)
1078                 xfer->act.hand = sbp_agent_reset_callback;
1079         else
1080                 xfer->act.hand = sbp_do_attach;
1081         fp = &xfer->send.hdr;
1082         fp->mode.wreqq.data = htonl(0xf);
1083         fw_asyreq(xfer->fc, -1, xfer);
1084         sbp_abort_all_ocbs(sdev, CAM_BDR_SENT);
1085 }
1086
1087 static void
1088 sbp_busy_timeout_callback(struct fw_xfer *xfer)
1089 {
1090         struct sbp_dev *sdev;
1091
1092         sdev = (struct sbp_dev *)xfer->sc;
1093 SBP_DEBUG(1)
1094         sbp_show_sdev_info(sdev, 2);
1095         kprintf("sbp_busy_timeout_callback\n");
1096 END_DEBUG
1097         sbp_xfer_free(xfer);
1098         sbp_agent_reset(sdev);
1099 }
1100
1101 static void
1102 sbp_busy_timeout(struct sbp_dev *sdev)
1103 {
1104         struct fw_pkt *fp;
1105         struct fw_xfer *xfer;
1106 SBP_DEBUG(0)
1107         sbp_show_sdev_info(sdev, 2);
1108         kprintf("sbp_busy_timeout\n");
1109 END_DEBUG
1110         xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0);
1111
1112         xfer->act.hand = sbp_busy_timeout_callback;
1113         fp = &xfer->send.hdr;
1114         fp->mode.wreqq.dest_hi = 0xffff;
1115         fp->mode.wreqq.dest_lo = 0xf0000000 | BUSY_TIMEOUT;
1116         fp->mode.wreqq.data = htonl((1 << (13+12)) | 0xf);
1117         fw_asyreq(xfer->fc, -1, xfer);
1118 }
1119
1120 static void
1121 sbp_orb_pointer_callback(struct fw_xfer *xfer)
1122 {
1123         struct sbp_dev *sdev;
1124         sdev = (struct sbp_dev *)xfer->sc;
1125
1126 SBP_DEBUG(1)
1127         sbp_show_sdev_info(sdev, 2);
1128         kprintf("%s\n", __func__);
1129 END_DEBUG
1130         if (xfer->resp != 0) {
1131                 /* XXX */
1132                 kprintf("%s: xfer->resp = %d\n", __func__, xfer->resp);
1133         }
1134         sbp_xfer_free(xfer);
1135         sdev->flags &= ~ORB_POINTER_ACTIVE;
1136
1137         if ((sdev->flags & ORB_POINTER_NEED) != 0) {
1138                 struct sbp_ocb *ocb;
1139
1140                 sdev->flags &= ~ORB_POINTER_NEED;
1141                 ocb = STAILQ_FIRST(&sdev->ocbs);
1142                 if (ocb != NULL)
1143                         sbp_orb_pointer(sdev, ocb);
1144         }
1145         return;
1146 }
1147
1148 static void
1149 sbp_orb_pointer(struct sbp_dev *sdev, struct sbp_ocb *ocb)
1150 {
1151         struct fw_xfer *xfer;
1152         struct fw_pkt *fp;
1153 SBP_DEBUG(1)
1154         sbp_show_sdev_info(sdev, 2);
1155         kprintf("%s: 0x%08x\n", __func__, (u_int32_t)ocb->bus_addr);
1156 END_DEBUG
1157
1158         if ((sdev->flags & ORB_POINTER_ACTIVE) != 0) {
1159 SBP_DEBUG(0)
1160                 kprintf("%s: orb pointer active\n", __func__);
1161 END_DEBUG
1162                 sdev->flags |= ORB_POINTER_NEED;
1163                 return;
1164         }
1165
1166         sdev->flags |= ORB_POINTER_ACTIVE;
1167         xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0x08);
1168         if (xfer == NULL)
1169                 return;
1170         xfer->act.hand = sbp_orb_pointer_callback;
1171
1172         fp = &xfer->send.hdr;
1173         fp->mode.wreqb.len = 8;
1174         fp->mode.wreqb.extcode = 0;
1175         xfer->send.payload[0] =
1176                 htonl(((sdev->target->sbp->fd.fc->nodeid | FWLOCALBUS )<< 16));
1177         xfer->send.payload[1] = htonl((u_int32_t)ocb->bus_addr);
1178
1179         if(fw_asyreq(xfer->fc, -1, xfer) != 0){
1180                         sbp_xfer_free(xfer);
1181                         ocb->ccb->ccb_h.status = CAM_REQ_INVALID;
1182                         xpt_done(ocb->ccb);
1183         }
1184 }
1185
1186 #if 0
1187 static void
1188 sbp_cmd_callback(struct fw_xfer *xfer)
1189 {
1190 SBP_DEBUG(1)
1191         struct sbp_dev *sdev;
1192         sdev = (struct sbp_dev *)xfer->sc;
1193         sbp_show_sdev_info(sdev, 2);
1194         kprintf("sbp_cmd_callback\n");
1195 END_DEBUG
1196         if (xfer->resp != 0) {
1197                 /* XXX */
1198                 kprintf("%s: xfer->resp = %d\n", __func__, xfer->resp);
1199         }
1200         sbp_xfer_free(xfer);
1201         return;
1202 }
1203
1204 static void
1205 sbp_doorbell(struct sbp_dev *sdev)
1206 {
1207         struct fw_xfer *xfer;
1208         struct fw_pkt *fp;
1209 SBP_DEBUG(1)
1210         sbp_show_sdev_info(sdev, 2);
1211         kprintf("sbp_doorbell\n");
1212 END_DEBUG
1213
1214         xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x10);
1215         if (xfer == NULL)
1216                 return;
1217         xfer->act.hand = sbp_cmd_callback;
1218         fp = (struct fw_pkt *)xfer->send.buf;
1219         fp->mode.wreqq.data = htonl(0xf);
1220         fw_asyreq(xfer->fc, -1, xfer);
1221 }
1222 #endif
1223
1224 static struct fw_xfer *
1225 sbp_write_cmd(struct sbp_dev *sdev, int tcode, int offset)
1226 {
1227         struct fw_xfer *xfer;
1228         struct fw_pkt *fp;
1229         struct sbp_target *target;
1230         int new = 0;
1231
1232         target = sdev->target;
1233         crit_enter();
1234         xfer = STAILQ_FIRST(&target->xferlist);
1235         if (xfer == NULL) {
1236                 if (target->n_xfer > 5 /* XXX */) {
1237                         kprintf("sbp: no more xfer for this target\n");
1238                         crit_exit();
1239                         return(NULL);
1240                 }
1241                 xfer = fw_xfer_alloc_buf(M_SBP, 8, 0);
1242                 if(xfer == NULL){
1243                         kprintf("sbp: fw_xfer_alloc_buf failed\n");
1244                         crit_exit();
1245                         return NULL;
1246                 }
1247                 target->n_xfer ++;
1248                 if (debug)
1249                         kprintf("sbp: alloc %d xfer\n", target->n_xfer);
1250                 new = 1;
1251         } else {
1252                 STAILQ_REMOVE_HEAD(&target->xferlist, link);
1253         }
1254         crit_exit();
1255
1256         microtime(&xfer->tv);
1257
1258         if (new) {
1259                 xfer->recv.pay_len = 0;
1260                 xfer->send.spd = min(sdev->target->fwdev->speed, max_speed);
1261                 xfer->fc = sdev->target->sbp->fd.fc;
1262                 xfer->retry_req = fw_asybusy;
1263         }
1264
1265         if (tcode == FWTCODE_WREQB)
1266                 xfer->send.pay_len = 8;
1267         else
1268                 xfer->send.pay_len = 0;
1269
1270         xfer->sc = (caddr_t)sdev;
1271         fp = &xfer->send.hdr;
1272         fp->mode.wreqq.dest_hi = sdev->login->cmd_hi;
1273         fp->mode.wreqq.dest_lo = sdev->login->cmd_lo + offset;
1274         fp->mode.wreqq.tlrt = 0;
1275         fp->mode.wreqq.tcode = tcode;
1276         fp->mode.wreqq.pri = 0;
1277         fp->mode.wreqq.dst = FWLOCALBUS | sdev->target->fwdev->dst;
1278
1279         return xfer;
1280
1281 }
1282
1283 static void
1284 sbp_mgm_orb(struct sbp_dev *sdev, int func, struct sbp_ocb *aocb)
1285 {
1286         struct fw_xfer *xfer;
1287         struct fw_pkt *fp;
1288         struct sbp_ocb *ocb;
1289         struct sbp_target *target;
1290         int nid;
1291
1292         target = sdev->target;
1293         nid = target->sbp->fd.fc->nodeid | FWLOCALBUS;
1294
1295         crit_enter();
1296         if (func == ORB_FUN_RUNQUEUE) {
1297                 ocb = STAILQ_FIRST(&target->mgm_ocb_queue);
1298                 if (target->mgm_ocb_cur != NULL || ocb == NULL) {
1299                         crit_exit();
1300                         return;
1301                 }
1302                 STAILQ_REMOVE_HEAD(&target->mgm_ocb_queue, ocb);
1303                 goto start;
1304         }
1305         if ((ocb = sbp_get_ocb(sdev)) == NULL) {
1306                 crit_exit();
1307                 /* XXX */
1308                 return;
1309         }
1310         ocb->flags = OCB_ACT_MGM;
1311         ocb->sdev = sdev;
1312
1313         bzero((void *)ocb->orb, sizeof(ocb->orb));
1314         ocb->orb[6] = htonl((nid << 16) | SBP_BIND_HI);
1315         ocb->orb[7] = htonl(SBP_DEV2ADDR(target->target_id, sdev->lun_id));
1316
1317 SBP_DEBUG(0)
1318         sbp_show_sdev_info(sdev, 2);
1319         kprintf("%s\n", orb_fun_name[(func>>16)&0xf]);
1320 END_DEBUG
1321         switch (func) {
1322         case ORB_FUN_LGI:
1323                 ocb->orb[0] = ocb->orb[1] = 0; /* password */
1324                 ocb->orb[2] = htonl(nid << 16);
1325                 ocb->orb[3] = htonl(sdev->dma.bus_addr);
1326                 ocb->orb[4] = htonl(ORB_NOTIFY | sdev->lun_id);
1327                 if (ex_login)
1328                         ocb->orb[4] |= htonl(ORB_EXV);
1329                 ocb->orb[5] = htonl(SBP_LOGIN_SIZE);
1330                 fwdma_sync(&sdev->dma, BUS_DMASYNC_PREREAD);
1331                 break;
1332         case ORB_FUN_ATA:
1333                 ocb->orb[0] = htonl((0 << 16) | 0);
1334                 ocb->orb[1] = htonl(aocb->bus_addr & 0xffffffff);
1335                 /* fall through */
1336         case ORB_FUN_RCN:
1337         case ORB_FUN_LGO:
1338         case ORB_FUN_LUR:
1339         case ORB_FUN_RST:
1340         case ORB_FUN_ATS:
1341                 ocb->orb[4] = htonl(ORB_NOTIFY | func | sdev->login->id);
1342                 break;
1343         }
1344
1345         if (target->mgm_ocb_cur != NULL) {
1346                 /* there is a standing ORB */
1347                 STAILQ_INSERT_TAIL(&sdev->target->mgm_ocb_queue, ocb, ocb);
1348                 crit_exit();
1349                 return;
1350         }
1351 start:
1352         target->mgm_ocb_cur = ocb;
1353         crit_exit();
1354
1355         callout_reset(&target->mgm_ocb_timeout, 5*hz,
1356                                 sbp_mgm_timeout, (caddr_t)ocb);
1357         xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0);
1358         if(xfer == NULL){
1359                 return;
1360         }
1361         xfer->act.hand = sbp_mgm_callback;
1362
1363         fp = &xfer->send.hdr;
1364         fp->mode.wreqb.dest_hi = sdev->target->mgm_hi;
1365         fp->mode.wreqb.dest_lo = sdev->target->mgm_lo;
1366         fp->mode.wreqb.len = 8;
1367         fp->mode.wreqb.extcode = 0;
1368         xfer->send.payload[0] = htonl(nid << 16);
1369         xfer->send.payload[1] = htonl(ocb->bus_addr & 0xffffffff);
1370 SBP_DEBUG(0)
1371         sbp_show_sdev_info(sdev, 2);
1372         kprintf("mgm orb: %08x\n", (u_int32_t)ocb->bus_addr);
1373 END_DEBUG
1374
1375         fw_asyreq(xfer->fc, -1, xfer);
1376 }
1377
1378 static void
1379 sbp_print_scsi_cmd(struct sbp_ocb *ocb)
1380 {
1381         struct ccb_scsiio *csio;
1382
1383         csio = &ocb->ccb->csio;
1384         kprintf("%s:%d:%d XPT_SCSI_IO: "
1385                 "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x"
1386                 ", flags: 0x%02x, "
1387                 "%db cmd/%db data/%db sense\n",
1388                 device_get_nameunit(ocb->sdev->target->sbp->fd.dev),
1389                 ocb->ccb->ccb_h.target_id, ocb->ccb->ccb_h.target_lun,
1390                 csio->cdb_io.cdb_bytes[0],
1391                 csio->cdb_io.cdb_bytes[1],
1392                 csio->cdb_io.cdb_bytes[2],
1393                 csio->cdb_io.cdb_bytes[3],
1394                 csio->cdb_io.cdb_bytes[4],
1395                 csio->cdb_io.cdb_bytes[5],
1396                 csio->cdb_io.cdb_bytes[6],
1397                 csio->cdb_io.cdb_bytes[7],
1398                 csio->cdb_io.cdb_bytes[8],
1399                 csio->cdb_io.cdb_bytes[9],
1400                 ocb->ccb->ccb_h.flags & CAM_DIR_MASK,
1401                 csio->cdb_len, csio->dxfer_len,
1402                 csio->sense_len);
1403 }
1404
1405 static void
1406 sbp_scsi_status(struct sbp_status *sbp_status, struct sbp_ocb *ocb)
1407 {
1408         struct sbp_cmd_status *sbp_cmd_status;
1409         struct scsi_sense_data *sense;
1410
1411         sbp_cmd_status = (struct sbp_cmd_status *)sbp_status->data;
1412         sense = &ocb->ccb->csio.sense_data;
1413
1414 SBP_DEBUG(0)
1415         sbp_print_scsi_cmd(ocb);
1416         /* XXX need decode status */
1417         sbp_show_sdev_info(ocb->sdev, 2);
1418         kprintf("SCSI status %x sfmt %x valid %x key %x code %x qlfr %x len %d\n",
1419                 sbp_cmd_status->status,
1420                 sbp_cmd_status->sfmt,
1421                 sbp_cmd_status->valid,
1422                 sbp_cmd_status->s_key,
1423                 sbp_cmd_status->s_code,
1424                 sbp_cmd_status->s_qlfr,
1425                 sbp_status->len
1426         );
1427 END_DEBUG
1428
1429         switch (sbp_cmd_status->status) {
1430         case SCSI_STATUS_CHECK_COND:
1431         case SCSI_STATUS_BUSY:
1432         case SCSI_STATUS_CMD_TERMINATED:
1433                 if(sbp_cmd_status->sfmt == SBP_SFMT_CURR){
1434                         sense->error_code = SSD_CURRENT_ERROR;
1435                 }else{
1436                         sense->error_code = SSD_DEFERRED_ERROR;
1437                 }
1438                 if(sbp_cmd_status->valid)
1439                         sense->error_code |= SSD_ERRCODE_VALID;
1440                 sense->flags = sbp_cmd_status->s_key;
1441                 if(sbp_cmd_status->mark)
1442                         sense->flags |= SSD_FILEMARK;
1443                 if(sbp_cmd_status->eom)
1444                         sense->flags |= SSD_EOM;
1445                 if(sbp_cmd_status->ill_len)
1446                         sense->flags |= SSD_ILI;
1447
1448                 bcopy(&sbp_cmd_status->info, &sense->info[0], 4);
1449
1450                 if (sbp_status->len <= 1)
1451                         /* XXX not scsi status. shouldn't be happened */
1452                         sense->extra_len = 0;
1453                 else if (sbp_status->len <= 4)
1454                         /* add_sense_code(_qual), info, cmd_spec_info */
1455                         sense->extra_len = 6;
1456                 else
1457                         /* fru, sense_key_spec */
1458                         sense->extra_len = 10;
1459
1460                 bcopy(&sbp_cmd_status->cdb, &sense->cmd_spec_info[0], 4);
1461
1462                 sense->add_sense_code = sbp_cmd_status->s_code;
1463                 sense->add_sense_code_qual = sbp_cmd_status->s_qlfr;
1464                 sense->fru = sbp_cmd_status->fru;
1465
1466                 bcopy(&sbp_cmd_status->s_keydep[0],
1467                     &sense->sense_key_spec[0], 3);
1468
1469                 ocb->ccb->csio.scsi_status = sbp_cmd_status->status;
1470                 ocb->ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
1471                                                         | CAM_AUTOSNS_VALID;
1472 /*
1473 {
1474                 u_int8_t j, *tmp;
1475                 tmp = sense;
1476                 for( j = 0 ; j < 32 ; j+=8){
1477                         kprintf("sense %02x%02x %02x%02x %02x%02x %02x%02x\n",
1478                                 tmp[j], tmp[j+1], tmp[j+2], tmp[j+3],
1479                                 tmp[j+4], tmp[j+5], tmp[j+6], tmp[j+7]);
1480                 }
1481
1482 }
1483 */
1484                 break;
1485         default:
1486                 sbp_show_sdev_info(ocb->sdev, 2);
1487                 kprintf("sbp_scsi_status: unknown scsi status 0x%x\n",
1488                                                 sbp_cmd_status->status);
1489         }
1490 }
1491
1492 static void
1493 sbp_fix_inq_data(struct sbp_ocb *ocb)
1494 {
1495         union ccb *ccb;
1496         struct sbp_dev *sdev;
1497         struct scsi_inquiry_data *inq;
1498
1499         ccb = ocb->ccb;
1500         sdev = ocb->sdev;
1501
1502         if (ccb->csio.cdb_io.cdb_bytes[1] & SI_EVPD)
1503                 return;
1504 SBP_DEBUG(1)
1505         sbp_show_sdev_info(sdev, 2);
1506         kprintf("sbp_fix_inq_data\n");
1507 END_DEBUG
1508         inq = (struct scsi_inquiry_data *) ccb->csio.data_ptr;
1509         switch (SID_TYPE(inq)) {
1510         case T_DIRECT:
1511 #if 0
1512                 /*
1513                  * XXX Convert Direct Access device to RBC.
1514                  * I've never seen FireWire DA devices which support READ_6.
1515                  */
1516                 if (SID_TYPE(inq) == T_DIRECT)
1517                         inq->device |= T_RBC; /*  T_DIRECT == 0 */
1518 #endif
1519                 /* fall through */
1520         case T_RBC:
1521                 /* enable tagged queuing */
1522                 if (sbp_tags)
1523                         inq->flags |= SID_CmdQue;
1524                 else
1525                         inq->flags &= ~SID_CmdQue;
1526                 /*
1527                  * Override vendor/product/revision information.
1528                  * Some devices sometimes return strange strings.
1529                  */
1530 #if 1
1531                 bcopy(sdev->vendor, inq->vendor, sizeof(inq->vendor));
1532                 bcopy(sdev->product, inq->product, sizeof(inq->product));
1533                 bcopy(sdev->revision+2, inq->revision, sizeof(inq->revision));
1534 #endif
1535                 break;
1536         }
1537 }
1538
1539 static void
1540 sbp_recv1(struct fw_xfer *xfer)
1541 {
1542         struct fw_pkt *rfp;
1543 #if NEED_RESPONSE
1544         struct fw_pkt *sfp;
1545 #endif
1546         struct sbp_softc *sbp;
1547         struct sbp_dev *sdev;
1548         struct sbp_ocb *ocb;
1549         struct sbp_login_res *login_res = NULL;
1550         struct sbp_status *sbp_status;
1551         struct sbp_target *target;
1552         int     orb_fun, status_valid0, status_valid, t, l, reset_agent = 0;
1553         u_int32_t addr;
1554 /*
1555         u_int32_t *ld;
1556         ld = xfer->recv.buf;
1557 kprintf("sbp %x %d %d %08x %08x %08x %08x\n",
1558                         xfer->resp, xfer->recv.len, xfer->recv.off, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3]));
1559 kprintf("sbp %08x %08x %08x %08x\n", ntohl(ld[4]), ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7]));
1560 kprintf("sbp %08x %08x %08x %08x\n", ntohl(ld[8]), ntohl(ld[9]), ntohl(ld[10]), ntohl(ld[11]));
1561 */
1562         sbp = (struct sbp_softc *)xfer->sc;
1563         if (xfer->resp != 0){
1564                 kprintf("sbp_recv: xfer->resp = %d\n", xfer->resp);
1565                 goto done0;
1566         }
1567         if (xfer->recv.payload == NULL){
1568                 kprintf("sbp_recv: xfer->recv.payload == NULL\n");
1569                 goto done0;
1570         }
1571         rfp = &xfer->recv.hdr;
1572         if(rfp->mode.wreqb.tcode != FWTCODE_WREQB){
1573                 kprintf("sbp_recv: tcode = %d\n", rfp->mode.wreqb.tcode);
1574                 goto done0;
1575         }
1576         sbp_status = (struct sbp_status *)xfer->recv.payload;
1577         addr = rfp->mode.wreqb.dest_lo;
1578 SBP_DEBUG(2)
1579         kprintf("received address 0x%x\n", addr);
1580 END_DEBUG
1581         t = SBP_ADDR2TRG(addr);
1582         if (t >= SBP_NUM_TARGETS) {
1583                 device_printf(sbp->fd.dev,
1584                         "sbp_recv1: invalid target %d\n", t);
1585                 goto done0;
1586         }
1587         target = &sbp->targets[t];
1588         l = SBP_ADDR2LUN(addr);
1589         if (l >= target->num_lun || target->luns[l] == NULL) {
1590                 device_printf(sbp->fd.dev,
1591                         "sbp_recv1: invalid lun %d (target=%d)\n", l, t);
1592                 goto done0;
1593         }
1594         sdev = target->luns[l];
1595
1596         ocb = NULL;
1597         switch (sbp_status->src) {
1598         case 0:
1599         case 1:
1600                 /* check mgm_ocb_cur first */
1601                 ocb  = target->mgm_ocb_cur;
1602                 if (ocb != NULL) {
1603                         if (OCB_MATCH(ocb, sbp_status)) {
1604                                 callout_stop(&target->mgm_ocb_timeout);
1605                                 target->mgm_ocb_cur = NULL;
1606                                 break;
1607                         }
1608                 }
1609                 ocb = sbp_dequeue_ocb(sdev, sbp_status);
1610                 if (ocb == NULL) {
1611                         sbp_show_sdev_info(sdev, 2);
1612                         kprintf("No ocb(%x) on the queue\n",
1613                                         ntohl(sbp_status->orb_lo));
1614                 }
1615                 break;
1616         case 2:
1617                 /* unsolicit */
1618                 sbp_show_sdev_info(sdev, 2);
1619                 kprintf("unsolicit status received\n");
1620                 break;
1621         default:
1622                 sbp_show_sdev_info(sdev, 2);
1623                 kprintf("unknown sbp_status->src\n");
1624         }
1625
1626         status_valid0 = (sbp_status->src < 2
1627                         && sbp_status->resp == ORB_RES_CMPL
1628                         && sbp_status->dead == 0);
1629         status_valid = (status_valid0 && sbp_status->status == 0);
1630
1631         if (!status_valid0 || debug > 2){
1632                 int status;
1633 SBP_DEBUG(0)
1634                 sbp_show_sdev_info(sdev, 2);
1635                 kprintf("ORB status src:%x resp:%x dead:%x"
1636                                 " len:%x stat:%x orb:%x%08x\n",
1637                         sbp_status->src, sbp_status->resp, sbp_status->dead,
1638                         sbp_status->len, sbp_status->status,
1639                         ntohs(sbp_status->orb_hi), ntohl(sbp_status->orb_lo));
1640 END_DEBUG
1641                 sbp_show_sdev_info(sdev, 2);
1642                 status = sbp_status->status;
1643                 switch(sbp_status->resp) {
1644                 case 0:
1645                         if (status > MAX_ORB_STATUS0)
1646                                 kprintf("%s\n", orb_status0[MAX_ORB_STATUS0]);
1647                         else
1648                                 kprintf("%s\n", orb_status0[status]);
1649                         break;
1650                 case 1:
1651                         kprintf("Obj: %s, Error: %s\n",
1652                                 orb_status1_object[(status>>6) & 3],
1653                                 orb_status1_serial_bus_error[status & 0xf]);
1654                         break;
1655                 case 2:
1656                         kprintf("Illegal request\n");
1657                         break;
1658                 case 3:
1659                         kprintf("Vendor dependent\n");
1660                         break;
1661                 default:
1662                         kprintf("unknown respose code %d\n", sbp_status->resp);
1663                 }
1664         }
1665
1666         /* we have to reset the fetch agent if it's dead */
1667         if (sbp_status->dead) {
1668                 if (sdev->path) {
1669                         xpt_freeze_devq(sdev->path, 1);
1670                         sdev->freeze ++;
1671                 }
1672                 reset_agent = 1;
1673         }
1674
1675         if (ocb == NULL)
1676                 goto done;
1677
1678         switch(ntohl(ocb->orb[4]) & ORB_FMT_MSK){
1679         case ORB_FMT_NOP:
1680                 break;
1681         case ORB_FMT_VED:
1682                 break;
1683         case ORB_FMT_STD:
1684                 switch(ocb->flags) {
1685                 case OCB_ACT_MGM:
1686                         orb_fun = ntohl(ocb->orb[4]) & ORB_FUN_MSK;
1687                         reset_agent = 0;
1688                         switch(orb_fun) {
1689                         case ORB_FUN_LGI:
1690                                 fwdma_sync(&sdev->dma, BUS_DMASYNC_POSTREAD);
1691                                 login_res = sdev->login;
1692                                 login_res->len = ntohs(login_res->len);
1693                                 login_res->id = ntohs(login_res->id);
1694                                 login_res->cmd_hi = ntohs(login_res->cmd_hi);
1695                                 login_res->cmd_lo = ntohl(login_res->cmd_lo);
1696                                 if (status_valid) {
1697 SBP_DEBUG(0)
1698 sbp_show_sdev_info(sdev, 2);
1699 kprintf("login: len %d, ID %d, cmd %08x%08x, recon_hold %d\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo, ntohs(login_res->recon_hold));
1700 END_DEBUG
1701                                         sbp_busy_timeout(sdev);
1702                                 } else {
1703                                         /* forgot logout? */
1704                                         sbp_show_sdev_info(sdev, 2);
1705                                         kprintf("login failed\n");
1706                                         sdev->status = SBP_DEV_RESET;
1707                                 }
1708                                 break;
1709                         case ORB_FUN_RCN:
1710                                 login_res = sdev->login;
1711                                 if (status_valid) {
1712 SBP_DEBUG(0)
1713 sbp_show_sdev_info(sdev, 2);
1714 kprintf("reconnect: len %d, ID %d, cmd %08x%08x\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo);
1715 END_DEBUG
1716 #if 1
1717                                         if (sdev->status == SBP_DEV_ATTACHED)
1718                                                 sbp_scan_dev(sdev);
1719                                         else
1720                                                 sbp_agent_reset(sdev);
1721 #else
1722                                         sdev->status = SBP_DEV_ATTACHED;
1723                                         sbp_mgm_orb(sdev, ORB_FUN_ATS, NULL);
1724 #endif
1725                                 } else {
1726                                         /* reconnection hold time exceed? */
1727 SBP_DEBUG(0)
1728                                         sbp_show_sdev_info(sdev, 2);
1729                                         kprintf("reconnect failed\n");
1730 END_DEBUG
1731                                         sbp_login(sdev);
1732                                 }
1733                                 break;
1734                         case ORB_FUN_LGO:
1735                                 sdev->status = SBP_DEV_RESET;
1736                                 break;
1737                         case ORB_FUN_RST:
1738                                 sbp_busy_timeout(sdev);
1739                                 break;
1740                         case ORB_FUN_LUR:
1741                         case ORB_FUN_ATA:
1742                         case ORB_FUN_ATS:
1743                                 sbp_agent_reset(sdev);
1744                                 break;
1745                         default:
1746                                 sbp_show_sdev_info(sdev, 2);
1747                                 kprintf("unknown function %d\n", orb_fun);
1748                                 break;
1749                         }
1750                         sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL);
1751                         break;
1752                 case OCB_ACT_CMD:
1753                         sdev->timeout = 0;
1754                         if(ocb->ccb != NULL){
1755                                 union ccb *ccb;
1756 /*
1757                                 u_int32_t *ld;
1758                                 ld = ocb->ccb->csio.data_ptr;
1759                                 if(ld != NULL && ocb->ccb->csio.dxfer_len != 0)
1760                                         kprintf("ptr %08x %08x %08x %08x\n", ld[0], ld[1], ld[2], ld[3]);
1761                                 else
1762                                         kprintf("ptr NULL\n");
1763 kprintf("len %d\n", sbp_status->len);
1764 */
1765                                 ccb = ocb->ccb;
1766                                 if(sbp_status->len > 1){
1767                                         sbp_scsi_status(sbp_status, ocb);
1768                                 }else{
1769                                         if(sbp_status->resp != ORB_RES_CMPL){
1770                                                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1771                                         }else{
1772                                                 ccb->ccb_h.status = CAM_REQ_CMP;
1773                                         }
1774                                 }
1775                                 /* fix up inq data */
1776                                 if (ccb->csio.cdb_io.cdb_bytes[0] == INQUIRY)
1777                                         sbp_fix_inq_data(ocb);
1778                                 xpt_done(ccb);
1779                         }
1780                         break;
1781                 default:
1782                         break;
1783                 }
1784         }
1785
1786         sbp_free_ocb(sdev, ocb);
1787 done:
1788         if (reset_agent)
1789                 sbp_agent_reset(sdev);
1790
1791 done0:
1792         xfer->recv.pay_len = SBP_RECV_LEN;
1793 /* The received packet is usually small enough to be stored within
1794  * the buffer. In that case, the controller return ack_complete and
1795  * no respose is necessary.
1796  *
1797  * XXX fwohci.c and firewire.c should inform event_code such as
1798  * ack_complete or ack_pending to upper driver.
1799  */
1800 #if NEED_RESPONSE
1801         xfer->send.off = 0;
1802         sfp = (struct fw_pkt *)xfer->send.buf;
1803         sfp->mode.wres.dst = rfp->mode.wreqb.src;
1804         xfer->dst = sfp->mode.wres.dst;
1805         xfer->spd = min(sdev->target->fwdev->speed, max_speed);
1806         xfer->act.hand = sbp_loginres_callback;
1807         xfer->retry_req = fw_asybusy;
1808
1809         sfp->mode.wres.tlrt = rfp->mode.wreqb.tlrt;
1810         sfp->mode.wres.tcode = FWTCODE_WRES;
1811         sfp->mode.wres.rtcode = 0;
1812         sfp->mode.wres.pri = 0;
1813
1814         fw_asyreq(xfer->fc, -1, xfer);
1815 #else
1816         /* recycle */
1817         STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link);
1818 #endif
1819
1820         return;
1821
1822 }
1823
1824 static void
1825 sbp_recv(struct fw_xfer *xfer)
1826 {
1827         crit_enter();
1828         sbp_recv1(xfer);
1829         crit_exit();
1830 }
1831 /*
1832  * sbp_attach()
1833  */
1834 static int
1835 sbp_attach(device_t dev)
1836 {
1837         struct sbp_softc *sbp;
1838         struct cam_devq *devq;
1839         struct fw_xfer *xfer;
1840         int i, error;
1841
1842 SBP_DEBUG(0)
1843         kprintf("sbp_attach (cold=%d)\n", cold);
1844 END_DEBUG
1845
1846 #if 0
1847         if (cold)
1848                 sbp_cold ++;
1849 #endif
1850         sbp = ((struct sbp_softc *)device_get_softc(dev));
1851         bzero(sbp, sizeof(struct sbp_softc));
1852         sbp->fd.dev = dev;
1853         sbp->fd.fc = device_get_ivars(dev);
1854
1855         if (max_speed < 0)
1856                 max_speed = sbp->fd.fc->speed;
1857
1858         error = bus_dma_tag_create(/*parent*/sbp->fd.fc->dmat,
1859                                 /* XXX shoud be 4 for sane backend? */
1860                                 /*alignment*/1,
1861                                 /*boundary*/0,
1862                                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
1863                                 /*highaddr*/BUS_SPACE_MAXADDR,
1864                                 /*filter*/NULL, /*filterarg*/NULL,
1865                                 /*maxsize*/0x100000, /*nsegments*/SBP_IND_MAX,
1866                                 /*maxsegsz*/SBP_SEG_MAX,
1867                                 /*flags*/BUS_DMA_ALLOCNOW,
1868 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
1869                                 /*lockfunc*/busdma_lock_mutex,
1870                                 /*lockarg*/&Giant,
1871 #endif
1872                                 &sbp->dmat);
1873         if (error != 0) {
1874                 kprintf("sbp_attach: Could not allocate DMA tag "
1875                         "- error %d\n", error);
1876                         return (ENOMEM);
1877         }
1878
1879         devq = cam_simq_alloc(/*maxopenings*/SBP_NUM_OCB);
1880         if (devq == NULL)
1881                 return (ENXIO);
1882
1883         for( i = 0 ; i < SBP_NUM_TARGETS ; i++){
1884                 sbp->targets[i].fwdev = NULL;
1885                 sbp->targets[i].luns = NULL;
1886         }
1887
1888         sbp->sim = cam_sim_alloc(sbp_action, sbp_poll, "sbp", sbp,
1889                                  device_get_unit(dev),
1890                                  &sim_mplock,
1891                                  /*untagged*/ 1,
1892                                  /*tagged*/ SBP_QUEUE_LEN - 1,
1893                                  devq);
1894         cam_simq_release(devq);
1895         if (sbp->sim == NULL)
1896                 return (ENXIO);
1897
1898         if (xpt_bus_register(sbp->sim, /*bus*/0) != CAM_SUCCESS)
1899                 goto fail;
1900
1901         if (xpt_create_path(&sbp->path, xpt_periph, cam_sim_path(sbp->sim),
1902             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
1903                 xpt_bus_deregister(cam_sim_path(sbp->sim));
1904                 goto fail;
1905         }
1906
1907         /* We reserve 16 bit space (4 bytes X 64 targets X 256 luns) */
1908         sbp->fwb.start = ((u_int64_t)SBP_BIND_HI << 32) | SBP_DEV2ADDR(0, 0);
1909         sbp->fwb.end = sbp->fwb.start + 0xffff;
1910         sbp->fwb.act_type = FWACT_XFER;
1911         /* pre-allocate xfer */
1912         STAILQ_INIT(&sbp->fwb.xferlist);
1913         for (i = 0; i < SBP_NUM_OCB/2; i ++) {
1914                 xfer = fw_xfer_alloc_buf(M_SBP,
1915                         /* send */0,
1916                         /* recv */SBP_RECV_LEN);
1917                 xfer->act.hand = sbp_recv;
1918 #if NEED_RESPONSE
1919                 xfer->fc = sbp->fd.fc;
1920 #endif
1921                 xfer->sc = (caddr_t)sbp;
1922                 STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link);
1923         }
1924         fw_bindadd(sbp->fd.fc, &sbp->fwb);
1925
1926         sbp->fd.post_busreset = sbp_post_busreset;
1927         sbp->fd.post_explore = sbp_post_explore;
1928
1929         if (sbp->fd.fc->status != -1) {
1930                 crit_enter();
1931                 sbp_post_busreset((void *)sbp);
1932                 sbp_post_explore((void *)sbp);
1933                 crit_exit();
1934         }
1935         xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL);
1936
1937         return (0);
1938 fail:
1939         cam_sim_free(sbp->sim);
1940         return (ENXIO);
1941 }
1942
1943 static int
1944 sbp_logout_all(struct sbp_softc *sbp)
1945 {
1946         struct sbp_target *target;
1947         struct sbp_dev *sdev;
1948         int i, j;
1949
1950 SBP_DEBUG(0)
1951         kprintf("sbp_logout_all\n");
1952 END_DEBUG
1953         for (i = 0 ; i < SBP_NUM_TARGETS ; i ++) {
1954                 target = &sbp->targets[i];
1955                 if (target->luns == NULL)
1956                         continue;
1957                 for (j = 0; j < target->num_lun; j++) {
1958                         sdev = target->luns[j];
1959                         if (sdev == NULL)
1960                                 continue;
1961                         callout_stop(&sdev->login_callout);
1962                         if (sdev->status >= SBP_DEV_TOATTACH &&
1963                                         sdev->status <= SBP_DEV_ATTACHED)
1964                                 sbp_mgm_orb(sdev, ORB_FUN_LGO, NULL);
1965                 }
1966         }
1967
1968         return 0;
1969 }
1970
1971 static int
1972 sbp_shutdown(device_t dev)
1973 {
1974         struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev));
1975
1976         sbp_logout_all(sbp);
1977         return (0);
1978 }
1979
1980 static void
1981 sbp_free_sdev(struct sbp_dev *sdev)
1982 {
1983         int i;
1984
1985         if (sdev == NULL)
1986                 return;
1987         for (i = 0; i < SBP_QUEUE_LEN; i++)
1988                 bus_dmamap_destroy(sdev->target->sbp->dmat,
1989                     sdev->ocb[i].dmamap);
1990         fwdma_free(sdev->target->sbp->fd.fc, &sdev->dma);
1991         kfree(sdev, M_SBP);
1992 }
1993
1994 static void
1995 sbp_free_target(struct sbp_target *target)
1996 {
1997         struct sbp_softc *sbp;
1998         struct fw_xfer *xfer, *next;
1999         int i;
2000
2001         if (target->luns == NULL)
2002                 return;
2003         callout_stop(&target->mgm_ocb_timeout);
2004         sbp = target->sbp;
2005         for (i = 0; i < target->num_lun; i++)
2006                 sbp_free_sdev(target->luns[i]);
2007
2008         for (xfer = STAILQ_FIRST(&target->xferlist);
2009                         xfer != NULL; xfer = next) {
2010                 next = STAILQ_NEXT(xfer, link);
2011                 fw_xfer_free_buf(xfer);
2012         }
2013         STAILQ_INIT(&target->xferlist);
2014         kfree(target->luns, M_SBP);
2015         target->num_lun = 0;
2016         target->luns = NULL;
2017         target->fwdev = NULL;
2018 }
2019
2020 static int
2021 sbp_detach(device_t dev)
2022 {
2023         struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev));
2024         struct firewire_comm *fc = sbp->fd.fc;
2025         struct fw_xfer *xfer, *next;
2026         int i;
2027
2028 SBP_DEBUG(0)
2029         kprintf("sbp_detach\n");
2030 END_DEBUG
2031
2032         for (i = 0; i < SBP_NUM_TARGETS; i ++)
2033                 sbp_cam_detach_target(&sbp->targets[i]);
2034         xpt_async(AC_LOST_DEVICE, sbp->path, NULL);
2035         xpt_free_path(sbp->path);
2036         xpt_bus_deregister(cam_sim_path(sbp->sim));
2037         cam_sim_free(sbp->sim);
2038
2039         sbp_logout_all(sbp);
2040
2041         /* XXX wait for logout completion */
2042         tsleep(&i, FWPRI, "sbpdtc", hz/2);
2043
2044         for (i = 0 ; i < SBP_NUM_TARGETS ; i ++)
2045                 sbp_free_target(&sbp->targets[i]);
2046
2047         for (xfer = STAILQ_FIRST(&sbp->fwb.xferlist);
2048                                 xfer != NULL; xfer = next) {
2049                 next = STAILQ_NEXT(xfer, link);
2050                 fw_xfer_free_buf(xfer);
2051         }
2052         STAILQ_INIT(&sbp->fwb.xferlist);
2053         fw_bindremove(fc, &sbp->fwb);
2054
2055         bus_dma_tag_destroy(sbp->dmat);
2056
2057         return (0);
2058 }
2059
2060 static void
2061 sbp_cam_detach_sdev(struct sbp_dev *sdev)
2062 {
2063         if (sdev == NULL)
2064                 return;
2065         if (sdev->status == SBP_DEV_DEAD)
2066                 return;
2067         if (sdev->status == SBP_DEV_RESET)
2068                 return;
2069         if (sdev->path) {
2070                 xpt_release_devq(sdev->path,
2071                                  sdev->freeze, TRUE);
2072                 sdev->freeze = 0;
2073                 xpt_async(AC_LOST_DEVICE, sdev->path, NULL);
2074                 xpt_free_path(sdev->path);
2075                 sdev->path = NULL;
2076         }
2077         sbp_abort_all_ocbs(sdev, CAM_DEV_NOT_THERE);
2078 }
2079
2080 static void
2081 sbp_cam_detach_target(struct sbp_target *target)
2082 {
2083         int i;
2084
2085         if (target->luns != NULL) {
2086 SBP_DEBUG(0)
2087                 kprintf("sbp_detach_target %d\n", target->target_id);
2088 END_DEBUG
2089                 callout_stop(&target->scan_callout);
2090                 for (i = 0; i < target->num_lun; i++)
2091                         sbp_cam_detach_sdev(target->luns[i]);
2092         }
2093 }
2094
2095 static void
2096 sbp_target_reset(struct sbp_dev *sdev, int method)
2097 {
2098         int i;
2099         struct sbp_target *target = sdev->target;
2100         struct sbp_dev *tsdev;
2101
2102         for (i = 0; i < target->num_lun; i++) {
2103                 tsdev = target->luns[i];
2104                 if (tsdev == NULL)
2105                         continue;
2106                 if (tsdev->status == SBP_DEV_DEAD)
2107                         continue;
2108                 if (tsdev->status == SBP_DEV_RESET)
2109                         continue;
2110                 xpt_freeze_devq(tsdev->path, 1);
2111                 tsdev->freeze ++;
2112                 sbp_abort_all_ocbs(tsdev, CAM_CMD_TIMEOUT);
2113                 if (method == 2)
2114                         tsdev->status = SBP_DEV_LOGIN;
2115         }
2116         switch(method) {
2117         case 1:
2118                 kprintf("target reset\n");
2119                 sbp_mgm_orb(sdev, ORB_FUN_RST, NULL);
2120                 break;
2121         case 2:
2122                 kprintf("reset start\n");
2123                 sbp_reset_start(sdev);
2124                 break;
2125         }
2126
2127 }
2128
2129 static void
2130 sbp_mgm_timeout(void *arg)
2131 {
2132         struct sbp_ocb *ocb = (struct sbp_ocb *)arg;
2133         struct sbp_dev *sdev = ocb->sdev;
2134         struct sbp_target *target = sdev->target;
2135
2136         sbp_show_sdev_info(sdev, 2);
2137         kprintf("request timeout(mgm orb:0x%08x) ... ",
2138             (u_int32_t)ocb->bus_addr);
2139         target->mgm_ocb_cur = NULL;
2140         sbp_free_ocb(sdev, ocb);
2141 #if 0
2142         /* XXX */
2143         kprintf("run next request\n");
2144         sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL);
2145 #endif
2146 #if 1
2147         kprintf("reset start\n");
2148         sbp_reset_start(sdev);
2149 #endif
2150 }
2151
2152 static void
2153 sbp_timeout(void *arg)
2154 {
2155         struct sbp_ocb *ocb = (struct sbp_ocb *)arg;
2156         struct sbp_dev *sdev = ocb->sdev;
2157
2158         sbp_show_sdev_info(sdev, 2);
2159         kprintf("request timeout(cmd orb:0x%08x) ... ",
2160             (u_int32_t)ocb->bus_addr);
2161
2162         sdev->timeout ++;
2163         switch(sdev->timeout) {
2164         case 1:
2165                 kprintf("agent reset\n");
2166                 xpt_freeze_devq(sdev->path, 1);
2167                 sdev->freeze ++;
2168                 sbp_abort_all_ocbs(sdev, CAM_CMD_TIMEOUT);
2169                 sbp_agent_reset(sdev);
2170                 break;
2171         case 2:
2172         case 3:
2173                 sbp_target_reset(sdev, sdev->timeout - 1);
2174                 break;
2175 #if 0
2176         default:
2177                 /* XXX give up */
2178                 sbp_cam_detach_target(target);
2179                 if (target->luns != NULL)
2180                         kfree(target->luns, M_SBP);
2181                 target->num_lun = 0;
2182                 target->luns = NULL;
2183                 target->fwdev = NULL;
2184 #endif
2185         }
2186 }
2187
2188 static void
2189 sbp_action1(struct cam_sim *sim, union ccb *ccb)
2190 {
2191
2192         struct sbp_softc *sbp = (struct sbp_softc *)sim->softc;
2193         struct sbp_target *target = NULL;
2194         struct sbp_dev *sdev = NULL;
2195
2196         /* target:lun -> sdev mapping */
2197         if (sbp != NULL
2198                         && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD
2199                         && ccb->ccb_h.target_id < SBP_NUM_TARGETS) {
2200                 target = &sbp->targets[ccb->ccb_h.target_id];
2201                 if (target->fwdev != NULL
2202                                 && ccb->ccb_h.target_lun != CAM_LUN_WILDCARD
2203                                 && ccb->ccb_h.target_lun < target->num_lun) {
2204                         sdev = target->luns[ccb->ccb_h.target_lun];
2205                         if (sdev != NULL && sdev->status != SBP_DEV_ATTACHED &&
2206                                 sdev->status != SBP_DEV_PROBE)
2207                                 sdev = NULL;
2208                 }
2209         }
2210
2211 SBP_DEBUG(1)
2212         if (sdev == NULL)
2213                 kprintf("invalid target %d lun %d\n",
2214                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2215 END_DEBUG
2216
2217         switch (ccb->ccb_h.func_code) {
2218         case XPT_SCSI_IO:
2219         case XPT_RESET_DEV:
2220         case XPT_GET_TRAN_SETTINGS:
2221         case XPT_SET_TRAN_SETTINGS:
2222         case XPT_CALC_GEOMETRY:
2223                 if (sdev == NULL) {
2224 SBP_DEBUG(1)
2225                         kprintf("%s:%d:%d:func_code 0x%04x: "
2226                                 "Invalid target (target needed)\n",
2227                                 device_get_nameunit(sbp->fd.dev),
2228                                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2229                                 ccb->ccb_h.func_code);
2230 END_DEBUG
2231
2232                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2233                         xpt_done(ccb);
2234                         return;
2235                 }
2236                 break;
2237         case XPT_PATH_INQ:
2238         case XPT_NOOP:
2239                 /* The opcodes sometimes aimed at a target (sc is valid),
2240                  * sometimes aimed at the SIM (sc is invalid and target is
2241                  * CAM_TARGET_WILDCARD)
2242                  */
2243                 if (sbp == NULL &&
2244                         ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) {
2245 SBP_DEBUG(0)
2246                         kprintf("%s:%d:%d func_code 0x%04x: "
2247                                 "Invalid target (no wildcard)\n",
2248                                 device_get_nameunit(sbp->fd.dev),
2249                                 ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2250                                 ccb->ccb_h.func_code);
2251 END_DEBUG
2252                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2253                         xpt_done(ccb);
2254                         return;
2255                 }
2256                 break;
2257         default:
2258                 /* XXX Hm, we should check the input parameters */
2259                 break;
2260         }
2261
2262         switch (ccb->ccb_h.func_code) {
2263         case XPT_SCSI_IO:
2264         {
2265                 struct ccb_scsiio *csio;
2266                 struct sbp_ocb *ocb;
2267                 int speed;
2268                 void *cdb;
2269
2270                 csio = &ccb->csio;
2271
2272 SBP_DEBUG(2)
2273                 kprintf("%s:%d:%d XPT_SCSI_IO: "
2274                         "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x"
2275                         ", flags: 0x%02x, "
2276                         "%db cmd/%db data/%db sense\n",
2277                         device_get_nameunit(sbp->fd.dev),
2278                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2279                         csio->cdb_io.cdb_bytes[0],
2280                         csio->cdb_io.cdb_bytes[1],
2281                         csio->cdb_io.cdb_bytes[2],
2282                         csio->cdb_io.cdb_bytes[3],
2283                         csio->cdb_io.cdb_bytes[4],
2284                         csio->cdb_io.cdb_bytes[5],
2285                         csio->cdb_io.cdb_bytes[6],
2286                         csio->cdb_io.cdb_bytes[7],
2287                         csio->cdb_io.cdb_bytes[8],
2288                         csio->cdb_io.cdb_bytes[9],
2289                         ccb->ccb_h.flags & CAM_DIR_MASK,
2290                         csio->cdb_len, csio->dxfer_len,
2291                         csio->sense_len);
2292 END_DEBUG
2293                 if(sdev == NULL){
2294                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2295                         xpt_done(ccb);
2296                         return;
2297                 }
2298 #if 0
2299                 /* if we are in probe stage, pass only probe commands */
2300                 if (sdev->status == SBP_DEV_PROBE) {
2301                         char *name;
2302                         name = xpt_path_periph(ccb->ccb_h.path)->periph_name;
2303                         kprintf("probe stage, periph name: %s\n", name);
2304                         if (strcmp(name, "probe") != 0) {
2305                                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
2306                                 xpt_done(ccb);
2307                                 return;
2308                         }
2309                 }
2310 #endif
2311                 if ((ocb = sbp_get_ocb(sdev)) == NULL) {
2312                         ccb->ccb_h.status = CAM_REQUEUE_REQ;
2313                         xpt_done(ccb);
2314                         return;
2315                 }
2316
2317                 ocb->flags = OCB_ACT_CMD;
2318                 ocb->sdev = sdev;
2319                 ocb->ccb = ccb;
2320                 ccb->ccb_h.ccb_sdev_ptr = sdev;
2321                 ocb->orb[0] = htonl(1 << 31);
2322                 ocb->orb[1] = 0;
2323                 ocb->orb[2] = htonl(((sbp->fd.fc->nodeid | FWLOCALBUS )<< 16) );
2324                 ocb->orb[3] = htonl(ocb->bus_addr + IND_PTR_OFFSET);
2325                 speed = min(target->fwdev->speed, max_speed);
2326                 ocb->orb[4] = htonl(ORB_NOTIFY | ORB_CMD_SPD(speed)
2327                                                 | ORB_CMD_MAXP(speed + 7));
2328                 if((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN){
2329                         ocb->orb[4] |= htonl(ORB_CMD_IN);
2330                 }
2331
2332                 if (csio->ccb_h.flags & CAM_SCATTER_VALID)
2333                         kprintf("sbp: CAM_SCATTER_VALID\n");
2334                 if (csio->ccb_h.flags & CAM_DATA_PHYS)
2335                         kprintf("sbp: CAM_DATA_PHYS\n");
2336
2337                 if (csio->ccb_h.flags & CAM_CDB_POINTER)
2338                         cdb = (void *)csio->cdb_io.cdb_ptr;
2339                 else
2340                         cdb = (void *)&csio->cdb_io.cdb_bytes;
2341                 bcopy(cdb, (void *)&ocb->orb[5], csio->cdb_len);
2342 /*
2343 kprintf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[0]), ntohl(ocb->orb[1]), ntohl(ocb->orb[2]), ntohl(ocb->orb[3]));
2344 kprintf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[4]), ntohl(ocb->orb[5]), ntohl(ocb->orb[6]), ntohl(ocb->orb[7]));
2345 */
2346                 if (ccb->csio.dxfer_len > 0) {
2347                         int error;
2348
2349                         crit_enter();
2350                         error = bus_dmamap_load(/*dma tag*/sbp->dmat,
2351                                         /*dma map*/ocb->dmamap,
2352                                         ccb->csio.data_ptr,
2353                                         ccb->csio.dxfer_len,
2354                                         sbp_execute_ocb,
2355                                         ocb,
2356                                         /*flags*/0);
2357                         crit_exit();
2358                         if (error)
2359                                 kprintf("sbp: bus_dmamap_load error %d\n", error);
2360                 } else
2361                         sbp_execute_ocb(ocb, NULL, 0, 0);
2362                 break;
2363         }
2364         case XPT_CALC_GEOMETRY:
2365         {
2366                 struct ccb_calc_geometry *ccg;
2367 #if defined(__DragonFly__) || __FreeBSD_version < 501100
2368                 u_int32_t size_mb;
2369                 u_int32_t secs_per_cylinder;
2370                 int extended = 1;
2371 #endif
2372
2373                 ccg = &ccb->ccg;
2374                 if (ccg->block_size == 0) {
2375                         kprintf("sbp_action1: block_size is 0.\n");
2376                         ccb->ccb_h.status = CAM_REQ_INVALID;
2377                         xpt_done(ccb);
2378                         break;
2379                 }
2380 SBP_DEBUG(1)
2381                 kprintf("%s:%d:%d:%d:XPT_CALC_GEOMETRY: Volume size = %ju\n",
2382                         device_get_nameunit(sbp->fd.dev),
2383                         cam_sim_path(sbp->sim),
2384                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2385                         (uintmax_t)ccg->volume_size);
2386 END_DEBUG
2387
2388 #if defined(__DragonFly__) || __FreeBSD_version < 501100
2389                 size_mb = ccg->volume_size
2390                         / ((1024L * 1024L) / ccg->block_size);
2391
2392                 if (size_mb > 1024 && extended) {
2393                         ccg->heads = 255;
2394                         ccg->secs_per_track = 63;
2395                 } else {
2396                         ccg->heads = 64;
2397                         ccg->secs_per_track = 32;
2398                 }
2399                 secs_per_cylinder = ccg->heads * ccg->secs_per_track;
2400                 ccg->cylinders = ccg->volume_size / secs_per_cylinder;
2401                 ccb->ccb_h.status = CAM_REQ_CMP;
2402 #else
2403                 cam_calc_geometry(ccg, /*extended*/1);
2404 #endif
2405                 xpt_done(ccb);
2406                 break;
2407         }
2408         case XPT_RESET_BUS:             /* Reset the specified SCSI bus */
2409         {
2410
2411 SBP_DEBUG(1)
2412                 kprintf("%s:%d:XPT_RESET_BUS: \n",
2413                         device_get_nameunit(sbp->fd.dev), cam_sim_path(sbp->sim));
2414 END_DEBUG
2415
2416                 ccb->ccb_h.status = CAM_REQ_INVALID;
2417                 xpt_done(ccb);
2418                 break;
2419         }
2420         case XPT_PATH_INQ:              /* Path routing inquiry */
2421         {
2422                 struct ccb_pathinq *cpi = &ccb->cpi;
2423
2424 SBP_DEBUG(1)
2425                 kprintf("%s:%d:%d XPT_PATH_INQ:.\n",
2426                         device_get_nameunit(sbp->fd.dev),
2427                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2428 END_DEBUG
2429                 cpi->version_num = 1; /* XXX??? */
2430                 cpi->hba_inquiry = PI_TAG_ABLE;
2431                 cpi->target_sprt = 0;
2432                 cpi->hba_misc = PIM_NOBUSRESET | PIM_NO_6_BYTE;
2433                 cpi->hba_eng_cnt = 0;
2434                 cpi->max_target = SBP_NUM_TARGETS - 1;
2435                 cpi->max_lun = SBP_NUM_LUNS - 1;
2436                 cpi->initiator_id = SBP_INITIATOR;
2437                 cpi->bus_id = sim->bus_id;
2438                 cpi->base_transfer_speed = 400 * 1000 / 8;
2439                 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
2440                 strncpy(cpi->hba_vid, "SBP", HBA_IDLEN);
2441                 strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
2442                 cpi->unit_number = sim->unit_number;
2443                 cpi->transport = XPORT_SPI;     /* XX should have a FireWire */
2444                 cpi->transport_version = 2;
2445                 cpi->protocol = PROTO_SCSI;
2446                 cpi->protocol_version = SCSI_REV_2;
2447
2448                 cpi->ccb_h.status = CAM_REQ_CMP;
2449                 xpt_done(ccb);
2450                 break;
2451         }
2452         case XPT_GET_TRAN_SETTINGS:
2453         {
2454                 struct ccb_trans_settings *cts = &ccb->cts;
2455                 struct ccb_trans_settings_scsi *scsi =
2456                     &cts->proto_specific.scsi;
2457                 struct ccb_trans_settings_spi *spi =
2458                     &cts->xport_specific.spi;
2459
2460                 cts->protocol = PROTO_SCSI;
2461                 cts->protocol_version = SCSI_REV_2;
2462                 cts->transport = XPORT_SPI;     /* should have a FireWire */
2463                 cts->transport_version = 2;
2464                 spi->valid = CTS_SPI_VALID_DISC;
2465                 spi->flags = CTS_SPI_FLAGS_DISC_ENB;
2466                 scsi->valid = CTS_SCSI_VALID_TQ;
2467                 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
2468 SBP_DEBUG(1)
2469                 kprintf("%s:%d:%d XPT_GET_TRAN_SETTINGS:.\n",
2470                         device_get_nameunit(sbp->fd.dev),
2471                         ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2472 END_DEBUG
2473                 cts->ccb_h.status = CAM_REQ_CMP;
2474                 xpt_done(ccb);
2475                 break;
2476         }
2477         case XPT_ABORT:
2478                 ccb->ccb_h.status = CAM_UA_ABORT;
2479                 xpt_done(ccb);
2480                 break;
2481         case XPT_SET_TRAN_SETTINGS:
2482                 /* XXX */
2483         default:
2484                 ccb->ccb_h.status = CAM_REQ_INVALID;
2485                 xpt_done(ccb);
2486                 break;
2487         }
2488         return;
2489 }
2490
2491 static void
2492 sbp_action(struct cam_sim *sim, union ccb *ccb)
2493 {
2494         crit_enter();
2495         sbp_action1(sim, ccb);
2496         crit_exit();
2497 }
2498
2499 static void
2500 sbp_execute_ocb(void *arg,  bus_dma_segment_t *segments, int seg, int error)
2501 {
2502         int i;
2503         struct sbp_ocb *ocb;
2504         struct sbp_ocb *prev;
2505         bus_dma_segment_t *s;
2506
2507         if (error)
2508                 kprintf("sbp_execute_ocb: error=%d\n", error);
2509
2510         ocb = (struct sbp_ocb *)arg;
2511
2512 SBP_DEBUG(2)
2513         kprintf("sbp_execute_ocb: seg %d", seg);
2514         for (i = 0; i < seg; i++)
2515                 kprintf(", %jx:%jd", (uintmax_t)segments[i].ds_addr,
2516                                         (uintmax_t)segments[i].ds_len);
2517         kprintf("\n");
2518 END_DEBUG
2519
2520         if (seg == 1) {
2521                 /* direct pointer */
2522                 s = &segments[0];
2523                 if (s->ds_len > SBP_SEG_MAX)
2524                         panic("ds_len > SBP_SEG_MAX, fix busdma code");
2525                 ocb->orb[3] = htonl(s->ds_addr);
2526                 ocb->orb[4] |= htonl(s->ds_len);
2527         } else if(seg > 1) {
2528                 /* page table */
2529                 for (i = 0; i < seg; i++) {
2530                         s = &segments[i];
2531 SBP_DEBUG(0)
2532                         /* XXX LSI Logic "< 16 byte" bug might be hit */
2533                         if (s->ds_len < 16)
2534                                 kprintf("sbp_execute_ocb: warning, "
2535                                         "segment length(%zd) is less than 16."
2536                                         "(seg=%d/%jd)\n",
2537                                         (size_t)s->ds_len, i+1, (intmax_t)seg);
2538 END_DEBUG
2539                         if (s->ds_len > SBP_SEG_MAX)
2540                                 panic("ds_len > SBP_SEG_MAX, fix busdma code");
2541                         ocb->ind_ptr[i].hi = htonl(s->ds_len << 16);
2542                         ocb->ind_ptr[i].lo = htonl(s->ds_addr);
2543                 }
2544                 ocb->orb[4] |= htonl(ORB_CMD_PTBL | seg);
2545         }
2546
2547         if (seg > 0)
2548                 bus_dmamap_sync(ocb->sdev->target->sbp->dmat, ocb->dmamap,
2549                         (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2550                         BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
2551         prev = sbp_enqueue_ocb(ocb->sdev, ocb);
2552         fwdma_sync(&ocb->sdev->dma, BUS_DMASYNC_PREWRITE);
2553         if (prev == NULL || (ocb->sdev->flags & ORB_LINK_DEAD) != 0) {
2554                 ocb->sdev->flags &= ~ORB_LINK_DEAD;
2555                 sbp_orb_pointer(ocb->sdev, ocb);
2556         }
2557 }
2558
2559 static void
2560 sbp_poll(struct cam_sim *sim)
2561 {
2562         struct sbp_softc *sbp;
2563         struct firewire_comm *fc;
2564
2565         sbp = (struct sbp_softc *)sim->softc;
2566         fc = sbp->fd.fc;
2567
2568         fc->poll(fc, 0, -1);
2569
2570         return;
2571 }
2572
2573 static struct sbp_ocb *
2574 sbp_dequeue_ocb(struct sbp_dev *sdev, struct sbp_status *sbp_status)
2575 {
2576         struct sbp_ocb *ocb;
2577         struct sbp_ocb *next;
2578         int order = 0;
2579         int flags;
2580
2581         crit_enter();
2582
2583 SBP_DEBUG(1)
2584         sbp_show_sdev_info(sdev, 2);
2585         kprintf("%s: 0x%08x src %d\n",
2586             __func__, ntohl(sbp_status->orb_lo), sbp_status->src);
2587 END_DEBUG
2588         for (ocb = STAILQ_FIRST(&sdev->ocbs); ocb != NULL; ocb = next) {
2589                 next = STAILQ_NEXT(ocb, ocb);
2590                 flags = ocb->flags;
2591                 if (OCB_MATCH(ocb, sbp_status)) {
2592                         /* found */
2593                         STAILQ_REMOVE(&sdev->ocbs, ocb, sbp_ocb, ocb);
2594                         if (ocb->ccb != NULL)
2595                                 callout_stop(&ocb->ccb->ccb_h.timeout_ch);
2596                         if (ntohl(ocb->orb[4]) & 0xffff) {
2597                                 bus_dmamap_sync(sdev->target->sbp->dmat,
2598                                         ocb->dmamap,
2599                                         (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2600                                         BUS_DMASYNC_POSTREAD :
2601                                         BUS_DMASYNC_POSTWRITE);
2602                                 bus_dmamap_unload(sdev->target->sbp->dmat,
2603                                         ocb->dmamap);
2604                         }
2605                         if (sbp_status->src == SRC_NO_NEXT) {
2606                                 if (next != NULL)
2607                                         sbp_orb_pointer(sdev, next);
2608                                 else if (order > 0) {
2609                                         /*
2610                                          * Unordered execution
2611                                          * We need to send pointer for
2612                                          * next ORB
2613                                          */
2614                                         sdev->flags |= ORB_LINK_DEAD;
2615                                 }
2616                         }
2617                         break;
2618                 } else
2619                         order ++;
2620         }
2621         crit_exit();
2622 SBP_DEBUG(0)
2623         if (ocb && order > 0) {
2624                 sbp_show_sdev_info(sdev, 2);
2625                 kprintf("unordered execution order:%d\n", order);
2626         }
2627 END_DEBUG
2628         return (ocb);
2629 }
2630
2631 static struct sbp_ocb *
2632 sbp_enqueue_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb)
2633 {
2634         struct sbp_ocb *prev;
2635
2636         crit_enter();
2637
2638 SBP_DEBUG(1)
2639         sbp_show_sdev_info(sdev, 2);
2640         kprintf("%s: 0x%08jx\n", __func__, (uintmax_t)ocb->bus_addr);
2641 END_DEBUG
2642         prev = STAILQ_LAST(&sdev->ocbs, sbp_ocb, ocb);
2643         STAILQ_INSERT_TAIL(&sdev->ocbs, ocb, ocb);
2644
2645         if (ocb->ccb != NULL)
2646                 callout_reset(&ocb->ccb->ccb_h.timeout_ch,
2647                     (ocb->ccb->ccb_h.timeout * hz) / 1000, sbp_timeout, ocb);
2648
2649         if (prev != NULL) {
2650 SBP_DEBUG(2)
2651                 kprintf("linking chain 0x%jx -> 0x%jx\n",
2652                     (uintmax_t)prev->bus_addr, (uintmax_t)ocb->bus_addr);
2653 END_DEBUG
2654                 prev->orb[1] = htonl(ocb->bus_addr);
2655                 prev->orb[0] = 0;
2656         }
2657         crit_exit();
2658
2659         return prev;
2660 }
2661
2662 static struct sbp_ocb *
2663 sbp_get_ocb(struct sbp_dev *sdev)
2664 {
2665         struct sbp_ocb *ocb;
2666
2667         crit_enter();
2668         ocb = STAILQ_FIRST(&sdev->free_ocbs);
2669         if (ocb == NULL) {
2670                 kprintf("ocb shortage!!!\n");
2671                 crit_exit();
2672                 return NULL;
2673         }
2674         STAILQ_REMOVE_HEAD(&sdev->free_ocbs, ocb);
2675         crit_exit();
2676         ocb->ccb = NULL;
2677         return (ocb);
2678 }
2679
2680 static void
2681 sbp_free_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb)
2682 {
2683         ocb->flags = 0;
2684         ocb->ccb = NULL;
2685         STAILQ_INSERT_TAIL(&sdev->free_ocbs, ocb, ocb);
2686 }
2687
2688 static void
2689 sbp_abort_ocb(struct sbp_ocb *ocb, int status)
2690 {
2691         struct sbp_dev *sdev;
2692
2693         sdev = ocb->sdev;
2694 SBP_DEBUG(0)
2695         sbp_show_sdev_info(sdev, 2);
2696         kprintf("sbp_abort_ocb 0x%jx\n", (uintmax_t)ocb->bus_addr);
2697 END_DEBUG
2698 SBP_DEBUG(1)
2699         if (ocb->ccb != NULL)
2700                 sbp_print_scsi_cmd(ocb);
2701 END_DEBUG
2702         if (ntohl(ocb->orb[4]) & 0xffff) {
2703                 bus_dmamap_sync(sdev->target->sbp->dmat, ocb->dmamap,
2704                         (ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
2705                         BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
2706                 bus_dmamap_unload(sdev->target->sbp->dmat, ocb->dmamap);
2707         }
2708         if (ocb->ccb != NULL) {
2709                 callout_stop(&ocb->ccb->ccb_h.timeout_ch);
2710                 ocb->ccb->ccb_h.status = status;
2711                 xpt_done(ocb->ccb);
2712         }
2713         sbp_free_ocb(sdev, ocb);
2714 }
2715
2716 static void
2717 sbp_abort_all_ocbs(struct sbp_dev *sdev, int status)
2718 {
2719         struct sbp_ocb *ocb, *next;
2720         STAILQ_HEAD(, sbp_ocb) temp;
2721
2722         crit_enter();
2723         STAILQ_INIT(&temp);
2724         STAILQ_CONCAT(&temp, &sdev->ocbs);
2725         for (ocb = STAILQ_FIRST(&temp); ocb != NULL; ocb = next) {
2726                 next = STAILQ_NEXT(ocb, ocb);
2727                 sbp_abort_ocb(ocb, status);
2728         }
2729         crit_exit();
2730 }
2731
2732 static devclass_t sbp_devclass;
2733
2734 /*
2735  * Because sbp is a static device that always exists under any attached
2736  * firewire device, and not scanned by the firewire device, we need an
2737  * identify function to install the device.  For our sanity we want
2738  * the sbp device to have the same unit number as the fireweire device.
2739  */
2740
2741 static device_method_t sbp_methods[] = {
2742         /* device interface */
2743         DEVMETHOD(device_identify,      bus_generic_identify_sameunit),
2744         DEVMETHOD(device_probe,         sbp_probe),
2745         DEVMETHOD(device_attach,        sbp_attach),
2746         DEVMETHOD(device_detach,        sbp_detach),
2747         DEVMETHOD(device_shutdown,      sbp_shutdown),
2748
2749         { 0, 0 }
2750 };
2751
2752 static driver_t sbp_driver = {
2753         "sbp",
2754         sbp_methods,
2755         sizeof(struct sbp_softc),
2756 };
2757
2758 DECLARE_DUMMY_MODULE(sbp);
2759 DRIVER_MODULE(sbp, firewire, sbp_driver, sbp_devclass, NULL, NULL);
2760 MODULE_VERSION(sbp, 1);
2761 MODULE_DEPEND(sbp, firewire, 1, 1, 1);
2762 MODULE_DEPEND(sbp, cam, 1, 1, 1);