sys/dev/disk/isp/isp_freebsd.c

   1 /*-
   2  * Copyright (c) 1997-2009 by Matthew Jacob
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice immediately at the beginning of the file, without modification,
  10  *    this list of conditions, and the following disclaimer.
  11  * 2. The name of the author may not be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/isp/isp_freebsd.c,v 1.176 2011/11/06 00:44:40 mjacob Exp $
  27  */
  28
  29 /*
  30  * Platform (FreeBSD) dependent common attachment code for Qlogic adapters.
  31  */
  32 #include <dev/disk/isp/isp_freebsd.h>
  33 #include <sys/unistd.h>
  34 #include <sys/kthread.h>
  35 #include <sys/conf.h>
  36 #include <sys/module.h>
  37 #include <dev/disk/isp/isp_ioctl.h>
  38 #include <sys/devicestat.h>
  39 #include <bus/cam/cam_periph.h>
  40 #include <bus/cam/cam_xpt_periph.h>
  41 #include <sys/device.h>
  42
  43 #define THREAD_CREATE   kthread_create
  44
  45 MODULE_VERSION(isp, 1);
  46 MODULE_DEPEND(isp, cam, 1, 1, 1);
  47 int isp_announced = 0;
  48 int isp_fabric_hysteresis = 5;
  49 int isp_loop_down_limit = 60;   /* default loop down limit */
  50 int isp_change_is_bad = 0;      /* "changed" devices are bad */
  51 int isp_quickboot_time = 7;     /* don't wait more than N secs for loop up */
  52 int isp_gone_device_time = 30;  /* grace time before reporting device lost */
  53 int isp_autoconfig = 1;         /* automatically attach/detach devices */
  54 static const char *roles[4] = {
  55     "(none)", "Target", "Initiator", "Target/Initiator"
  56 };
  57 static const char prom3[] = "Chan %d PortID 0x%06x Departed from Target %u because of %s";
  58 static const char rqo[] = "%s: Request Queue Overflow\n";
  59
  60 static void isp_freeze_loopdown(ispsoftc_t *, int, char *);
  61 static d_ioctl_t ispioctl;
  62 static void isp_intr_enable(void *);
  63 static void isp_cam_async(void *, uint32_t, struct cam_path *, void *);
  64 static void isp_poll(struct cam_sim *);
  65 static timeout_t isp_watchdog;
  66 static timeout_t isp_gdt;
  67 static task_fn_t isp_gdt_task;
  68 static timeout_t isp_ldt;
  69 static task_fn_t isp_ldt_task;
  70 static void isp_kthread(void *);
  71 static void isp_action(struct cam_sim *, union ccb *);
  72 #ifdef  ISP_INTERNAL_TARGET
  73 static void isp_target_thread_pi(void *);
  74 static void isp_target_thread_fc(void *);
  75 #endif
  76 static void isp_timer(void *);
  77
  78 static struct dev_ops isp_ops = {
  79         { "isp", 0, D_DISK },
  80         .d_ioctl =      ispioctl,
  81 };
  82
  83 static int
  84 isp_attach_chan(ispsoftc_t *isp, struct cam_devq *devq, int chan)
  85 {
  86         struct ccb_setasync csa;
  87         struct cam_sim *sim;
  88         struct cam_path *path;
  89
  90         /*
  91          * Construct our SIM entry.
  92          */
  93         sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp, device_get_unit(isp->isp_dev), &isp->isp_osinfo.lock, isp->isp_maxcmds, isp->isp_maxcmds, devq);
  94         cam_simq_release(devq);
  95
  96         if (sim == NULL) {
  97                 return (ENOMEM);
  98         }
  99
 100         ISP_LOCK(isp);
 101         if (xpt_bus_register(sim, chan) != CAM_SUCCESS) {
 102                 ISP_UNLOCK(isp);
 103                 cam_sim_free(sim);
 104                 return (EIO);
 105         }
 106         ISP_UNLOCK(isp);
 107         if (xpt_create_path_unlocked(&path, NULL, cam_sim_path(sim), CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 108                 ISP_LOCK(isp);
 109                 xpt_bus_deregister(cam_sim_path(sim));
 110                 ISP_UNLOCK(isp);
 111                 cam_sim_free(sim);
 112                 return (ENXIO);
 113         }
 114         xpt_setup_ccb(&csa.ccb_h, path, 5);
 115         csa.ccb_h.func_code = XPT_SASYNC_CB;
 116         csa.event_enable = AC_LOST_DEVICE;
 117         csa.callback = isp_cam_async;
 118         csa.callback_arg = sim;
 119         xpt_action((union ccb *)&csa);
 120
 121         if (IS_SCSI(isp)) {
 122                 struct isp_spi *spi = ISP_SPI_PC(isp, chan);
 123                 spi->sim = sim;
 124                 spi->path = path;
 125 #ifdef  ISP_INTERNAL_TARGET
 126                 ISP_SET_PC(isp, chan, proc_active, 1);
 127                 if (THREAD_CREATE(isp_target_thread_pi, spi, &spi->target_proc, "%s: isp_test_tgt%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
 128                         ISP_SET_PC(isp, chan, proc_active, 0);
 129                         isp_prt(isp, ISP_LOGERR, "cannot create test target thread");
 130                 }
 131 #endif
 132         } else {
 133                 fcparam *fcp = FCPARAM(isp, chan);
 134                 struct isp_fc *fc = ISP_FC_PC(isp, chan);
 135
 136                 ISP_LOCK(isp);
 137                 fc->sim = sim;
 138                 fc->path = path;
 139                 fc->isp = isp;
 140                 fc->ready = 1;
 141
 142                 callout_init(&fc->ldt);
 143                 callout_init(&fc->gdt);
 144                 TASK_INIT(&fc->ltask, 1, isp_ldt_task, fc);
 145                 TASK_INIT(&fc->gtask, 1, isp_gdt_task, fc);
 146
 147                 /*
 148                  * We start by being "loop down" if we have an initiator role
 149                  */
 150                 if (fcp->role & ISP_ROLE_INITIATOR) {
 151                         isp_freeze_loopdown(isp, chan, "isp_attach");
 152                         callout_reset(&fc->ldt, isp_quickboot_time * hz, isp_ldt, fc);
 153                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Starting Initial Loop Down Timer @ %lu", (unsigned long) time_second);
 154                 }
 155                 ISP_UNLOCK(isp);
 156                 if (THREAD_CREATE(isp_kthread, fc, &fc->kthread, "%s: fc_thrd%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
 157                         xpt_free_path(fc->path);
 158                         ISP_LOCK(isp);
 159                         if (callout_active(&fc->ldt)) {
 160                                 callout_stop(&fc->ldt);
 161                         }
 162                         xpt_bus_deregister(cam_sim_path(fc->sim));
 163                         ISP_UNLOCK(isp);
 164                         cam_sim_free(fc->sim);
 165                         return (ENOMEM);
 166                 }
 167 #ifdef  ISP_INTERNAL_TARGET
 168                 ISP_SET_PC(isp, chan, proc_active, 1);
 169                 if (THREAD_CREATE(isp_target_thread_fc, fc, &fc->target_proc, "%s: isp_test_tgt%d", device_get_nameunit(isp->isp_osinfo.dev), chan)) {
 170                         ISP_SET_PC(isp, chan, proc_active, 0);
 171                         isp_prt(isp, ISP_LOGERR, "cannot create test target thread");
 172                 }
 173 #endif
 174                 if (chan == 0) {
 175                         SYSCTL_ADD_QUAD(&isp->isp_sysctl_ctx, SYSCTL_CHILDREN(isp->isp_sysctl_tree), OID_AUTO, "wwnn", CTLFLAG_RD, &FCPARAM(isp, 0)->isp_wwnn, 0, "World Wide Node Name");
 176                         SYSCTL_ADD_QUAD(&isp->isp_sysctl_ctx, SYSCTL_CHILDREN(isp->isp_sysctl_tree), OID_AUTO, "wwpn", CTLFLAG_RD, &FCPARAM(isp, 0)->isp_wwpn, 0, "World Wide Port Name");
 177                         SYSCTL_ADD_UINT(&isp->isp_sysctl_ctx, SYSCTL_CHILDREN(isp->isp_sysctl_tree), OID_AUTO, "loop_down_limit", CTLFLAG_RW, &ISP_FC_PC(isp, 0)->loop_down_limit, 0, "Loop Down Limit");
 178                         SYSCTL_ADD_UINT(&isp->isp_sysctl_ctx, SYSCTL_CHILDREN(isp->isp_sysctl_tree), OID_AUTO, "gone_device_time", CTLFLAG_RW, &ISP_FC_PC(isp, 0)->gone_device_time, 0, "Gone Device Time");
 179                 }
 180         }
 181         return (0);
 182 }
 183
 184 int
 185 isp_attach(ispsoftc_t *isp)
 186 {
 187         const char *nu = device_get_nameunit(isp->isp_osinfo.dev);
 188         int du = device_get_unit(isp->isp_dev);
 189         int chan;
 190
 191         isp->isp_osinfo.ehook.ich_func = isp_intr_enable;
 192         isp->isp_osinfo.ehook.ich_arg = isp;
 193         /*
 194          * Haha. Set this first, because if we're loaded as a module isp_intr_enable
 195          * will be called right awawy, which will clear isp_osinfo.ehook_active,
 196          * which would be unwise to then set again later.
 197          */
 198         isp->isp_osinfo.ehook_active = 1;
 199         if (config_intrhook_establish(&isp->isp_osinfo.ehook) != 0) {
 200                 isp_prt(isp, ISP_LOGERR, "could not establish interrupt enable hook");
 201                 return (-EIO);
 202         }
 203
 204         /*
 205          * Create the device queue for our SIM(s).
 206          */
 207         isp->isp_osinfo.devq = cam_simq_alloc(isp->isp_maxcmds);
 208         if (isp->isp_osinfo.devq == NULL) {
 209                 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
 210                 return (EIO);
 211         }
 212
 213         sysctl_ctx_init(&isp->isp_sysctl_ctx);
 214         isp->isp_sysctl_tree = SYSCTL_ADD_NODE(&isp->isp_sysctl_ctx,
 215             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
 216             device_get_nameunit(isp->isp_dev), CTLFLAG_RD, 0, "");
 217         if (isp->isp_sysctl_tree == NULL) {
 218                 device_printf(isp->isp_dev, "can't add sysctl node\n");
 219                 return (EINVAL);
 220         }
 221         for (chan = 0; chan < isp->isp_nchan; chan++) {
 222                 if (isp_attach_chan(isp, isp->isp_osinfo.devq, chan)) {
 223                         goto unwind;
 224                 }
 225         }
 226
 227         callout_init(&isp->isp_osinfo.tmo);
 228         callout_reset(&isp->isp_osinfo.tmo, hz, isp_timer, isp);
 229         isp->isp_osinfo.timer_active = 1;
 230
 231         isp->isp_osinfo.cdev = make_dev(&isp_ops, du, UID_ROOT, GID_OPERATOR, 0600, "%s", nu);
 232         if (isp->isp_osinfo.cdev) {
 233                 isp->isp_osinfo.cdev->si_drv1 = isp;
 234         }
 235         return (0);
 236
 237 unwind:
 238         while (--chan >= 0) {
 239                 struct cam_sim *sim;
 240                 struct cam_path *path;
 241                 if (IS_FC(isp)) {
 242                         sim = ISP_FC_PC(isp, chan)->sim;
 243                         path = ISP_FC_PC(isp, chan)->path;
 244                 } else {
 245                         sim = ISP_SPI_PC(isp, chan)->sim;
 246                         path = ISP_SPI_PC(isp, chan)->path;
 247                 }
 248                 xpt_free_path(path);
 249                 ISP_LOCK(isp);
 250                 xpt_bus_deregister(cam_sim_path(sim));
 251                 ISP_UNLOCK(isp);
 252                 cam_sim_free(sim);
 253         }
 254         if (isp->isp_osinfo.ehook_active) {
 255                 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
 256                 isp->isp_osinfo.ehook_active = 0;
 257         }
 258         if (isp->isp_osinfo.cdev) {
 259                 destroy_dev(isp->isp_osinfo.cdev);
 260                 isp->isp_osinfo.cdev = NULL;
 261         }
 262         isp->isp_osinfo.devq = NULL;
 263         return (-1);
 264 }
 265
 266 int
 267 isp_detach(ispsoftc_t *isp)
 268 {
 269         struct cam_sim *sim;
 270         struct cam_path *path;
 271         struct ccb_setasync csa;
 272         int chan;
 273
 274         ISP_LOCK(isp);
 275         for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1) {
 276                 if (IS_FC(isp)) {
 277                         sim = ISP_FC_PC(isp, chan)->sim;
 278                         path = ISP_FC_PC(isp, chan)->path;
 279                 } else {
 280                         sim = ISP_SPI_PC(isp, chan)->sim;
 281                         path = ISP_SPI_PC(isp, chan)->path;
 282                 }
 283                 if (sim->refcount > 2) {
 284                         ISP_UNLOCK(isp);
 285                         return (EBUSY);
 286                 }
 287         }
 288         if (isp->isp_osinfo.timer_active) {
 289                 callout_stop(&isp->isp_osinfo.tmo);
 290                 isp->isp_osinfo.timer_active = 0;
 291         }
 292         for (chan = isp->isp_nchan - 1; chan >= 0; chan -= 1) {
 293                 if (IS_FC(isp)) {
 294                         sim = ISP_FC_PC(isp, chan)->sim;
 295                         path = ISP_FC_PC(isp, chan)->path;
 296                 } else {
 297                         sim = ISP_SPI_PC(isp, chan)->sim;
 298                         path = ISP_SPI_PC(isp, chan)->path;
 299                 }
 300                 xpt_setup_ccb(&csa.ccb_h, path, 5);
 301                 csa.ccb_h.func_code = XPT_SASYNC_CB;
 302                 csa.event_enable = 0;
 303                 csa.callback = isp_cam_async;
 304                 csa.callback_arg = sim;
 305                 xpt_action((union ccb *)&csa);
 306                 xpt_free_path(path);
 307                 xpt_bus_deregister(cam_sim_path(sim));
 308                 cam_sim_free(sim);
 309         }
 310         ISP_UNLOCK(isp);
 311         if (isp->isp_osinfo.cdev) {
 312                 destroy_dev(isp->isp_osinfo.cdev);
 313                 isp->isp_osinfo.cdev = NULL;
 314         }
 315         if (isp->isp_osinfo.ehook_active) {
 316                 config_intrhook_disestablish(&isp->isp_osinfo.ehook);
 317                 isp->isp_osinfo.ehook_active = 0;
 318         }
 319         if (isp->isp_osinfo.devq != NULL) {
 320                 isp->isp_osinfo.devq = NULL;
 321         }
 322         if (isp->isp_sysctl_tree != NULL)
 323                 sysctl_ctx_free(&isp->isp_sysctl_ctx);
 324         return (0);
 325 }
 326
 327 static void
 328 isp_freeze_loopdown(ispsoftc_t *isp, int chan, char *msg)
 329 {
 330         if (IS_FC(isp)) {
 331                 struct isp_fc *fc = ISP_FC_PC(isp, chan);
 332                 if (fc->simqfrozen == 0) {
 333                         isp_prt(isp, ISP_LOGDEBUG0, "%s: freeze simq (loopdown) chan %d", msg, chan);
 334                         fc->simqfrozen = SIMQFRZ_LOOPDOWN;
 335                         xpt_freeze_simq(fc->sim, 1);
 336                 } else {
 337                         isp_prt(isp, ISP_LOGDEBUG0, "%s: mark frozen (loopdown) chan %d", msg, chan);
 338                         fc->simqfrozen |= SIMQFRZ_LOOPDOWN;
 339                 }
 340         }
 341 }
 342
 343 static void
 344 isp_unfreeze_loopdown(ispsoftc_t *isp, int chan)
 345 {
 346         if (IS_FC(isp)) {
 347                 struct isp_fc *fc = ISP_FC_PC(isp, chan);
 348                 int wasfrozen = fc->simqfrozen & SIMQFRZ_LOOPDOWN;
 349                 fc->simqfrozen &= ~SIMQFRZ_LOOPDOWN;
 350                 if (wasfrozen && fc->simqfrozen == 0) {
 351                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d releasing simq", __func__, chan);
 352                         xpt_release_simq(fc->sim, 1);
 353                 }
 354         }
 355 }
 356
 357
 358 static int
 359 ispioctl(struct dev_ioctl_args *ap)
 360 {
 361         cdev_t dev = ap->a_head.a_dev;
 362         caddr_t addr = ap->a_data;
 363         u_long c = ap->a_cmd;
 364         ispsoftc_t *isp;
 365         int nr, chan, retval = ENOTTY;
 366
 367         isp = dev->si_drv1;
 368
 369         switch (c) {
 370         case ISP_SDBLEV:
 371         {
 372                 int olddblev = isp->isp_dblev;
 373                 isp->isp_dblev = *(int *)addr;
 374                 *(int *)addr = olddblev;
 375                 retval = 0;
 376                 break;
 377         }
 378         case ISP_GETROLE:
 379                 chan = *(int *)addr;
 380                 if (chan < 0 || chan >= isp->isp_nchan) {
 381                         retval = -ENXIO;
 382                         break;
 383                 }
 384                 if (IS_FC(isp)) {
 385                         *(int *)addr = FCPARAM(isp, chan)->role;
 386                 } else {
 387                         *(int *)addr = SDPARAM(isp, chan)->role;
 388                 }
 389                 retval = 0;
 390                 break;
 391         case ISP_SETROLE:
 392                 nr = *(int *)addr;
 393                 chan = nr >> 8;
 394                 if (chan < 0 || chan >= isp->isp_nchan) {
 395                         retval = -ENXIO;
 396                         break;
 397                 }
 398                 nr &= 0xff;
 399                 if (nr & ~(ISP_ROLE_INITIATOR|ISP_ROLE_TARGET)) {
 400                         retval = EINVAL;
 401                         break;
 402                 }
 403                 if (IS_FC(isp)) {
 404                         /*
 405                          * We don't really support dual role at present on FC cards.
 406                          *
 407                          * We should, but a bunch of things are currently broken,
 408                          * so don't allow it.
 409                          */
 410                         if (nr == ISP_ROLE_BOTH) {
 411                                 isp_prt(isp, ISP_LOGERR, "cannot support dual role at present");
 412                                 retval = EINVAL;
 413                                 break;
 414                         }
 415                         *(int *)addr = FCPARAM(isp, chan)->role;
 416 #ifdef  ISP_INTERNAL_TARGET
 417                         ISP_LOCK(isp);
 418                         retval = isp_fc_change_role(isp, chan, nr);
 419                         ISP_UNLOCK(isp);
 420 #else
 421                         FCPARAM(isp, chan)->role = nr;
 422 #endif
 423                 } else {
 424                         *(int *)addr = SDPARAM(isp, chan)->role;
 425                         SDPARAM(isp, chan)->role = nr;
 426                 }
 427                 retval = 0;
 428                 break;
 429
 430         case ISP_RESETHBA:
 431                 ISP_LOCK(isp);
 432 #ifdef  ISP_TARGET_MODE
 433                 isp_del_all_wwn_entries(isp, ISP_NOCHAN);
 434 #endif
 435                 isp_reinit(isp, 0);
 436                 ISP_UNLOCK(isp);
 437                 retval = 0;
 438                 break;
 439
 440         case ISP_RESCAN:
 441                 if (IS_FC(isp)) {
 442                         chan = *(int *)addr;
 443                         if (chan < 0 || chan >= isp->isp_nchan) {
 444                                 retval = -ENXIO;
 445                                 break;
 446                         }
 447                         ISP_LOCK(isp);
 448                         if (isp_fc_runstate(isp, chan, 5 * 1000000)) {
 449                                 retval = EIO;
 450                         } else {
 451                                 retval = 0;
 452                         }
 453                         ISP_UNLOCK(isp);
 454                 }
 455                 break;
 456
 457         case ISP_FC_LIP:
 458                 if (IS_FC(isp)) {
 459                         chan = *(int *)addr;
 460                         if (chan < 0 || chan >= isp->isp_nchan) {
 461                                 retval = -ENXIO;
 462                                 break;
 463                         }
 464                         ISP_LOCK(isp);
 465                         if (isp_control(isp, ISPCTL_SEND_LIP, chan)) {
 466                                 retval = EIO;
 467                         } else {
 468                                 retval = 0;
 469                         }
 470                         ISP_UNLOCK(isp);
 471                 }
 472                 break;
 473         case ISP_FC_GETDINFO:
 474         {
 475                 struct isp_fc_device *ifc = (struct isp_fc_device *) addr;
 476                 fcportdb_t *lp;
 477
 478                 if (IS_SCSI(isp)) {
 479                         break;
 480                 }
 481                 if (ifc->loopid >= MAX_FC_TARG) {
 482                         retval = EINVAL;
 483                         break;
 484                 }
 485                 lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
 486                 if (lp->state == FC_PORTDB_STATE_VALID || lp->target_mode) {
 487                         ifc->role = lp->roles;
 488                         ifc->loopid = lp->handle;
 489                         ifc->portid = lp->portid;
 490                         ifc->node_wwn = lp->node_wwn;
 491                         ifc->port_wwn = lp->port_wwn;
 492                         retval = 0;
 493                 } else {
 494                         retval = ENODEV;
 495                 }
 496                 break;
 497         }
 498         case ISP_GET_STATS:
 499         {
 500                 isp_stats_t *sp = (isp_stats_t *) addr;
 501
 502                 ISP_MEMZERO(sp, sizeof (*sp));
 503                 sp->isp_stat_version = ISP_STATS_VERSION;
 504                 sp->isp_type = isp->isp_type;
 505                 sp->isp_revision = isp->isp_revision;
 506                 ISP_LOCK(isp);
 507                 sp->isp_stats[ISP_INTCNT] = isp->isp_intcnt;
 508                 sp->isp_stats[ISP_INTBOGUS] = isp->isp_intbogus;
 509                 sp->isp_stats[ISP_INTMBOXC] = isp->isp_intmboxc;
 510                 sp->isp_stats[ISP_INGOASYNC] = isp->isp_intoasync;
 511                 sp->isp_stats[ISP_RSLTCCMPLT] = isp->isp_rsltccmplt;
 512                 sp->isp_stats[ISP_FPHCCMCPLT] = isp->isp_fphccmplt;
 513                 sp->isp_stats[ISP_RSCCHIWAT] = isp->isp_rscchiwater;
 514                 sp->isp_stats[ISP_FPCCHIWAT] = isp->isp_fpcchiwater;
 515                 ISP_UNLOCK(isp);
 516                 retval = 0;
 517                 break;
 518         }
 519         case ISP_CLR_STATS:
 520                 ISP_LOCK(isp);
 521                 isp->isp_intcnt = 0;
 522                 isp->isp_intbogus = 0;
 523                 isp->isp_intmboxc = 0;
 524                 isp->isp_intoasync = 0;
 525                 isp->isp_rsltccmplt = 0;
 526                 isp->isp_fphccmplt = 0;
 527                 isp->isp_rscchiwater = 0;
 528                 isp->isp_fpcchiwater = 0;
 529                 ISP_UNLOCK(isp);
 530                 retval = 0;
 531                 break;
 532         case ISP_FC_GETHINFO:
 533         {
 534                 struct isp_hba_device *hba = (struct isp_hba_device *) addr;
 535                 int chan = hba->fc_channel;
 536
 537                 if (chan < 0 || chan >= isp->isp_nchan) {
 538                         retval = ENXIO;
 539                         break;
 540                 }
 541                 hba->fc_fw_major = ISP_FW_MAJORX(isp->isp_fwrev);
 542                 hba->fc_fw_minor = ISP_FW_MINORX(isp->isp_fwrev);
 543                 hba->fc_fw_micro = ISP_FW_MICROX(isp->isp_fwrev);
 544                 hba->fc_nchannels = isp->isp_nchan;
 545                 if (IS_FC(isp)) {
 546                         hba->fc_nports = MAX_FC_TARG;
 547                         hba->fc_speed = FCPARAM(isp, hba->fc_channel)->isp_gbspeed;
 548                         hba->fc_topology = FCPARAM(isp, chan)->isp_topo + 1;
 549                         hba->fc_loopid = FCPARAM(isp, chan)->isp_loopid;
 550                         hba->nvram_node_wwn = FCPARAM(isp, chan)->isp_wwnn_nvram;
 551                         hba->nvram_port_wwn = FCPARAM(isp, chan)->isp_wwpn_nvram;
 552                         hba->active_node_wwn = FCPARAM(isp, chan)->isp_wwnn;
 553                         hba->active_port_wwn = FCPARAM(isp, chan)->isp_wwpn;
 554                 } else {
 555                         hba->fc_nports = MAX_TARGETS;
 556                         hba->fc_speed = 0;
 557                         hba->fc_topology = 0;
 558                         hba->nvram_node_wwn = 0ull;
 559                         hba->nvram_port_wwn = 0ull;
 560                         hba->active_node_wwn = 0ull;
 561                         hba->active_port_wwn = 0ull;
 562                 }
 563                 retval = 0;
 564                 break;
 565         }
 566         case ISP_TSK_MGMT:
 567         {
 568                 int needmarker;
 569                 struct isp_fc_tsk_mgmt *fct = (struct isp_fc_tsk_mgmt *) addr;
 570                 uint16_t loopid;
 571                 mbreg_t mbs;
 572
 573                 if (IS_SCSI(isp)) {
 574                         break;
 575                 }
 576
 577                 chan = fct->chan;
 578                 if (chan < 0 || chan >= isp->isp_nchan) {
 579                         retval = -ENXIO;
 580                         break;
 581                 }
 582
 583                 needmarker = retval = 0;
 584                 loopid = fct->loopid;
 585                 ISP_LOCK(isp);
 586                 if (IS_24XX(isp)) {
 587                         uint8_t local[QENTRY_LEN];
 588                         isp24xx_tmf_t *tmf;
 589                         isp24xx_statusreq_t *sp;
 590                         fcparam *fcp = FCPARAM(isp, chan);
 591                         fcportdb_t *lp;
 592                         int i;
 593
 594                         for (i = 0; i < MAX_FC_TARG; i++) {
 595                                 lp = &fcp->portdb[i];
 596                                 if (lp->handle == loopid) {
 597                                         break;
 598                                 }
 599                         }
 600                         if (i == MAX_FC_TARG) {
 601                                 retval = ENXIO;
 602                                 ISP_UNLOCK(isp);
 603                                 break;
 604                         }
 605                         /* XXX VALIDATE LP XXX */
 606                         tmf = (isp24xx_tmf_t *) local;
 607                         ISP_MEMZERO(tmf, QENTRY_LEN);
 608                         tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
 609                         tmf->tmf_header.rqs_entry_count = 1;
 610                         tmf->tmf_nphdl = lp->handle;
 611                         tmf->tmf_delay = 2;
 612                         tmf->tmf_timeout = 2;
 613                         tmf->tmf_tidlo = lp->portid;
 614                         tmf->tmf_tidhi = lp->portid >> 16;
 615                         tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
 616                         tmf->tmf_lun[1] = fct->lun & 0xff;
 617                         if (fct->lun >= 256) {
 618                                 tmf->tmf_lun[0] = 0x40 | (fct->lun >> 8);
 619                         }
 620                         switch (fct->action) {
 621                         case IPT_CLEAR_ACA:
 622                                 tmf->tmf_flags = ISP24XX_TMF_CLEAR_ACA;
 623                                 break;
 624                         case IPT_TARGET_RESET:
 625                                 tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
 626                                 needmarker = 1;
 627                                 break;
 628                         case IPT_LUN_RESET:
 629                                 tmf->tmf_flags = ISP24XX_TMF_LUN_RESET;
 630                                 needmarker = 1;
 631                                 break;
 632                         case IPT_CLEAR_TASK_SET:
 633                                 tmf->tmf_flags = ISP24XX_TMF_CLEAR_TASK_SET;
 634                                 needmarker = 1;
 635                                 break;
 636                         case IPT_ABORT_TASK_SET:
 637                                 tmf->tmf_flags = ISP24XX_TMF_ABORT_TASK_SET;
 638                                 needmarker = 1;
 639                                 break;
 640                         default:
 641                                 retval = EINVAL;
 642                                 break;
 643                         }
 644                         if (retval) {
 645                                 ISP_UNLOCK(isp);
 646                                 break;
 647                         }
 648                         MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 5000000);
 649                         mbs.param[1] = QENTRY_LEN;
 650                         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
 651                         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 652                         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
 653                         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 654
 655                         if (FC_SCRATCH_ACQUIRE(isp, chan)) {
 656                                 ISP_UNLOCK(isp);
 657                                 retval = ENOMEM;
 658                                 break;
 659                         }
 660                         isp_put_24xx_tmf(isp, tmf, fcp->isp_scratch);
 661                         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
 662                         sp = (isp24xx_statusreq_t *) local;
 663                         sp->req_completion_status = 1;
 664                         retval = isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 665                         MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
 666                         isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)fcp->isp_scratch)[1], sp);
 667                         FC_SCRATCH_RELEASE(isp, chan);
 668                         if (retval || sp->req_completion_status != 0) {
 669                                 FC_SCRATCH_RELEASE(isp, chan);
 670                                 retval = EIO;
 671                         }
 672                         if (retval == 0) {
 673                                 if (needmarker) {
 674                                         fcp->sendmarker = 1;
 675                                 }
 676                         }
 677                 } else {
 678                         MBSINIT(&mbs, 0, MBLOGALL, 0);
 679                         if (ISP_CAP_2KLOGIN(isp) == 0) {
 680                                 loopid <<= 8;
 681                         }
 682                         switch (fct->action) {
 683                         case IPT_CLEAR_ACA:
 684                                 mbs.param[0] = MBOX_CLEAR_ACA;
 685                                 mbs.param[1] = loopid;
 686                                 mbs.param[2] = fct->lun;
 687                                 break;
 688                         case IPT_TARGET_RESET:
 689                                 mbs.param[0] = MBOX_TARGET_RESET;
 690                                 mbs.param[1] = loopid;
 691                                 needmarker = 1;
 692                                 break;
 693                         case IPT_LUN_RESET:
 694                                 mbs.param[0] = MBOX_LUN_RESET;
 695                                 mbs.param[1] = loopid;
 696                                 mbs.param[2] = fct->lun;
 697                                 needmarker = 1;
 698                                 break;
 699                         case IPT_CLEAR_TASK_SET:
 700                                 mbs.param[0] = MBOX_CLEAR_TASK_SET;
 701                                 mbs.param[1] = loopid;
 702                                 mbs.param[2] = fct->lun;
 703                                 needmarker = 1;
 704                                 break;
 705                         case IPT_ABORT_TASK_SET:
 706                                 mbs.param[0] = MBOX_ABORT_TASK_SET;
 707                                 mbs.param[1] = loopid;
 708                                 mbs.param[2] = fct->lun;
 709                                 needmarker = 1;
 710                                 break;
 711                         default:
 712                                 retval = EINVAL;
 713                                 break;
 714                         }
 715                         if (retval == 0) {
 716                                 if (needmarker) {
 717                                         FCPARAM(isp, chan)->sendmarker = 1;
 718                                 }
 719                                 retval = isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 720                                 if (retval) {
 721                                         retval = EIO;
 722                                 }
 723                         }
 724                 }
 725                 ISP_UNLOCK(isp);
 726                 break;
 727         }
 728         default:
 729                 break;
 730         }
 731         return (retval);
 732 }
 733
 734 static void
 735 isp_intr_enable(void *arg)
 736 {
 737         int chan;
 738         ispsoftc_t *isp = arg;
 739         ISP_LOCK(isp);
 740         for (chan = 0; chan < isp->isp_nchan; chan++) {
 741                 if (IS_FC(isp)) {
 742                         if (FCPARAM(isp, chan)->role != ISP_ROLE_NONE) {
 743                                 ISP_ENABLE_INTS(isp);
 744                                 break;
 745                         }
 746                 } else {
 747                         if (SDPARAM(isp, chan)->role != ISP_ROLE_NONE) {
 748                                 ISP_ENABLE_INTS(isp);
 749                                 break;
 750                         }
 751                 }
 752         }
 753         isp->isp_osinfo.ehook_active = 0;
 754         ISP_UNLOCK(isp);
 755         /* Release our hook so that the boot can continue. */
 756         config_intrhook_disestablish(&isp->isp_osinfo.ehook);
 757 }
 758
 759 /*
 760  * Local Inlines
 761  */
 762
 763 static ISP_INLINE int isp_get_pcmd(ispsoftc_t *, union ccb *);
 764 static ISP_INLINE void isp_free_pcmd(ispsoftc_t *, union ccb *);
 765
 766 static ISP_INLINE int
 767 isp_get_pcmd(ispsoftc_t *isp, union ccb *ccb)
 768 {
 769         ISP_PCMD(ccb) = isp->isp_osinfo.pcmd_free;
 770         if (ISP_PCMD(ccb) == NULL) {
 771                 return (-1);
 772         }
 773         isp->isp_osinfo.pcmd_free = ((struct isp_pcmd *)ISP_PCMD(ccb))->next;
 774         return (0);
 775 }
 776
 777 static ISP_INLINE void
 778 isp_free_pcmd(ispsoftc_t *isp, union ccb *ccb)
 779 {
 780         ((struct isp_pcmd *)ISP_PCMD(ccb))->next = isp->isp_osinfo.pcmd_free;
 781         isp->isp_osinfo.pcmd_free = ISP_PCMD(ccb);
 782         ISP_PCMD(ccb) = NULL;
 783 }
 784 /*
 785  * Put the target mode functions here, because some are inlines
 786  */
 787
 788 #ifdef  ISP_TARGET_MODE
 789 static ISP_INLINE int is_lun_enabled(ispsoftc_t *, int, lun_id_t);
 790 static ISP_INLINE tstate_t *get_lun_statep(ispsoftc_t *, int, lun_id_t);
 791 static ISP_INLINE tstate_t *get_lun_statep_from_tag(ispsoftc_t *, int, uint32_t);
 792 static ISP_INLINE void rls_lun_statep(ispsoftc_t *, tstate_t *);
 793 static ISP_INLINE inot_private_data_t *get_ntp_from_tagdata(ispsoftc_t *, uint32_t, uint32_t, tstate_t **);
 794 static ISP_INLINE atio_private_data_t *isp_get_atpd(ispsoftc_t *, tstate_t *, uint32_t);
 795 static ISP_INLINE void isp_put_atpd(ispsoftc_t *, tstate_t *, atio_private_data_t *);
 796 static ISP_INLINE inot_private_data_t *isp_get_ntpd(ispsoftc_t *, tstate_t *);
 797 static ISP_INLINE inot_private_data_t *isp_find_ntpd(ispsoftc_t *, tstate_t *, uint32_t, uint32_t);
 798 static ISP_INLINE void isp_put_ntpd(ispsoftc_t *, tstate_t *, inot_private_data_t *);
 799 static cam_status create_lun_state(ispsoftc_t *, int, struct cam_path *, tstate_t **);
 800 static void destroy_lun_state(ispsoftc_t *, tstate_t *);
 801 static void isp_enable_lun(ispsoftc_t *, union ccb *);
 802 static void isp_enable_deferred_luns(ispsoftc_t *, int);
 803 static cam_status isp_enable_deferred(ispsoftc_t *, int, lun_id_t);
 804 static void isp_disable_lun(ispsoftc_t *, union ccb *);
 805 static int isp_enable_target_mode(ispsoftc_t *, int);
 806 static void isp_ledone(ispsoftc_t *, lun_entry_t *);
 807 static timeout_t isp_refire_putback_atio;
 808 static void isp_complete_ctio(union ccb *);
 809 static void isp_target_putback_atio(union ccb *);
 810 static void isp_target_start_ctio(ispsoftc_t *, union ccb *);
 811 static void isp_handle_platform_atio(ispsoftc_t *, at_entry_t *);
 812 static void isp_handle_platform_atio2(ispsoftc_t *, at2_entry_t *);
 813 static void isp_handle_platform_atio7(ispsoftc_t *, at7_entry_t *);
 814 static void isp_handle_platform_ctio(ispsoftc_t *, void *);
 815 static void isp_handle_platform_notify_scsi(ispsoftc_t *, in_entry_t *);
 816 static void isp_handle_platform_notify_fc(ispsoftc_t *, in_fcentry_t *);
 817 static void isp_handle_platform_notify_24xx(ispsoftc_t *, in_fcentry_24xx_t *);
 818 static int isp_handle_platform_target_notify_ack(ispsoftc_t *, isp_notify_t *);
 819 static void isp_handle_platform_target_tmf(ispsoftc_t *, isp_notify_t *);
 820 static void isp_target_mark_aborted(ispsoftc_t *, union ccb *);
 821 static void isp_target_mark_aborted_early(ispsoftc_t *, tstate_t *, uint32_t);
 822
 823 static ISP_INLINE int
 824 is_lun_enabled(ispsoftc_t *isp, int bus, lun_id_t lun)
 825 {
 826         tstate_t *tptr;
 827         struct tslist *lhp;
 828
 829         ISP_GET_PC_ADDR(isp, bus, lun_hash[LUN_HASH_FUNC(lun)], lhp);
 830         SLIST_FOREACH(tptr, lhp, next) {
 831                 if (xpt_path_lun_id(tptr->owner) == lun) {
 832                         return (1);
 833                 }
 834         }
 835         return (0);
 836 }
 837
 838 static void
 839 dump_tstates(ispsoftc_t *isp, int bus)
 840 {
 841         int i, j;
 842         struct tslist *lhp;
 843         tstate_t *tptr = NULL;
 844
 845         if (bus >= isp->isp_nchan) {
 846                 return;
 847         }
 848         for (i = 0; i < LUN_HASH_SIZE; i++) {
 849                 ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
 850                 j = 0;
 851                 SLIST_FOREACH(tptr, lhp, next) {
 852                         xpt_print(tptr->owner, "[%d, %d] atio_cnt=%d inot_cnt=%d\n", i, j, tptr->atio_count, tptr->inot_count);
 853                         j++;
 854                 }
 855         }
 856 }
 857
 858 static ISP_INLINE tstate_t *
 859 get_lun_statep(ispsoftc_t *isp, int bus, lun_id_t lun)
 860 {
 861         tstate_t *tptr = NULL;
 862         struct tslist *lhp;
 863         int i;
 864
 865         if (bus < isp->isp_nchan) {
 866                 for (i = 0; i < LUN_HASH_SIZE; i++) {
 867                         ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
 868                         SLIST_FOREACH(tptr, lhp, next) {
 869                                 if (xpt_path_lun_id(tptr->owner) == lun) {
 870                                         tptr->hold++;
 871                                         return (tptr);
 872                                 }
 873                         }
 874                 }
 875         }
 876         return (NULL);
 877 }
 878
 879 static ISP_INLINE tstate_t *
 880 get_lun_statep_from_tag(ispsoftc_t *isp, int bus, uint32_t tagval)
 881 {
 882         tstate_t *tptr = NULL;
 883         atio_private_data_t *atp;
 884         struct tslist *lhp;
 885         int i;
 886
 887         if (bus < isp->isp_nchan && tagval != 0) {
 888                 for (i = 0; i < LUN_HASH_SIZE; i++) {
 889                         ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
 890                         SLIST_FOREACH(tptr, lhp, next) {
 891                                 atp = isp_get_atpd(isp, tptr, tagval);
 892                                 if (atp && atp->tag == tagval) {
 893                                         tptr->hold++;
 894                                         return (tptr);
 895                                 }
 896                         }
 897                 }
 898         }
 899         return (NULL);
 900 }
 901
 902 static ISP_INLINE inot_private_data_t *
 903 get_ntp_from_tagdata(ispsoftc_t *isp, uint32_t tag_id, uint32_t seq_id, tstate_t **rslt)
 904 {
 905         inot_private_data_t *ntp;
 906         tstate_t *tptr;
 907         struct tslist *lhp;
 908         int bus, i;
 909
 910         for (bus = 0; bus < isp->isp_nchan; bus++) {
 911                 for (i = 0; i < LUN_HASH_SIZE; i++) {
 912                         ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
 913                         SLIST_FOREACH(tptr, lhp, next) {
 914                                 ntp = isp_find_ntpd(isp, tptr, tag_id, seq_id);
 915                                 if (ntp) {
 916                                         *rslt = tptr;
 917                                         tptr->hold++;
 918                                         return (ntp);
 919                                 }
 920                         }
 921                 }
 922         }
 923         return (NULL);
 924 }
 925 static ISP_INLINE void
 926 rls_lun_statep(ispsoftc_t *isp, tstate_t *tptr)
 927 {
 928         KASSERT((tptr->hold), ("tptr not held"));
 929         tptr->hold--;
 930 }
 931
 932 static void
 933 isp_tmcmd_restart(ispsoftc_t *isp)
 934 {
 935         inot_private_data_t *ntp;
 936         tstate_t *tptr;
 937         struct tslist *lhp;
 938         int bus, i;
 939
 940         for (bus = 0; bus < isp->isp_nchan; bus++) {
 941                 for (i = 0; i < LUN_HASH_SIZE; i++) {
 942                         ISP_GET_PC_ADDR(isp, bus, lun_hash[i], lhp);
 943                         SLIST_FOREACH(tptr, lhp, next) {
 944                                 inot_private_data_t *restart_queue = tptr->restart_queue;
 945                                 tptr->restart_queue = NULL;
 946                                 while (restart_queue) {
 947                                         ntp = restart_queue;
 948                                         restart_queue = ntp->rd.nt.nt_hba;
 949                                         if (IS_24XX(isp)) {
 950                                                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at7_entry_t *)ntp->rd.data)->at_rxid);
 951                                                 isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->rd.data);
 952                                         } else {
 953                                                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at2_entry_t *)ntp->rd.data)->at_rxid);
 954                                                 isp_handle_platform_atio2(isp, (at2_entry_t *) ntp->rd.data);
 955                                         }
 956                                         isp_put_ntpd(isp, tptr, ntp);
 957                                         if (tptr->restart_queue && restart_queue != NULL) {
 958                                                 ntp = tptr->restart_queue;
 959                                                 tptr->restart_queue = restart_queue;
 960                                                 while (restart_queue->rd.nt.nt_hba) {
 961                                                         restart_queue = restart_queue->rd.nt.nt_hba;
 962                                                 }
 963                                                 restart_queue->rd.nt.nt_hba = ntp;
 964                                                 break;
 965                                         }
 966                                 }
 967                         }
 968                 }
 969         }
 970 }
 971
 972 static ISP_INLINE atio_private_data_t *
 973 isp_get_atpd(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag)
 974 {
 975         atio_private_data_t *atp;
 976
 977         if (tag == 0) {
 978                 atp = tptr->atfree;
 979                 if (atp) {
 980                         tptr->atfree = atp->next;
 981                 }
 982                 return (atp);
 983         }
 984         for (atp = tptr->atpool; atp < &tptr->atpool[ATPDPSIZE]; atp++) {
 985                 if (atp->tag == tag) {
 986                         return (atp);
 987                 }
 988         }
 989         return (NULL);
 990 }
 991
 992 static ISP_INLINE void
 993 isp_put_atpd(ispsoftc_t *isp, tstate_t *tptr, atio_private_data_t *atp)
 994 {
 995         atp->tag = 0;
 996         atp->dead = 0;
 997         atp->next = tptr->atfree;
 998         tptr->atfree = atp;
 999 }
1000
1001 static void
1002 isp_dump_atpd(ispsoftc_t *isp, tstate_t *tptr)
1003 {
1004         atio_private_data_t *atp;
1005         const char *states[8] = { "Free", "ATIO", "CAM", "CTIO", "LAST_CTIO", "PDON", "?6", "7" };
1006
1007         for (atp = tptr->atpool; atp < &tptr->atpool[ATPDPSIZE]; atp++) {
1008                 if (atp->tag == 0) {
1009                         continue;
1010                 }
1011                 xpt_print(tptr->owner, "ATP: [0x%x] origdlen %u bytes_xfrd %u last_xfr %u lun %u nphdl 0x%04x s_id 0x%06x d_id 0x%06x oxid 0x%04x state %s\n",
1012                     atp->tag, atp->orig_datalen, atp->bytes_xfered, atp->last_xframt, atp->lun, atp->nphdl, atp->sid, atp->portid, atp->oxid, states[atp->state & 0x7]);
1013         }
1014 }
1015
1016
1017 static ISP_INLINE inot_private_data_t *
1018 isp_get_ntpd(ispsoftc_t *isp, tstate_t *tptr)
1019 {
1020         inot_private_data_t *ntp;
1021         ntp = tptr->ntfree;
1022         if (ntp) {
1023                 tptr->ntfree = ntp->next;
1024         }
1025         return (ntp);
1026 }
1027
1028 static ISP_INLINE inot_private_data_t *
1029 isp_find_ntpd(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag_id, uint32_t seq_id)
1030 {
1031         inot_private_data_t *ntp;
1032         for (ntp = tptr->ntpool; ntp < &tptr->ntpool[ATPDPSIZE]; ntp++) {
1033                 if (ntp->rd.tag_id == tag_id && ntp->rd.seq_id == seq_id) {
1034                         return (ntp);
1035                 }
1036         }
1037         return (NULL);
1038 }
1039
1040 static ISP_INLINE void
1041 isp_put_ntpd(ispsoftc_t *isp, tstate_t *tptr, inot_private_data_t *ntp)
1042 {
1043         ntp->rd.tag_id = ntp->rd.seq_id = 0;
1044         ntp->next = tptr->ntfree;
1045         tptr->ntfree = ntp;
1046 }
1047
1048 static cam_status
1049 create_lun_state(ispsoftc_t *isp, int bus, struct cam_path *path, tstate_t **rslt)
1050 {
1051         cam_status status;
1052         lun_id_t lun;
1053         struct tslist *lhp;
1054         tstate_t *tptr;
1055         int i;
1056
1057         lun = xpt_path_lun_id(path);
1058         if (lun != CAM_LUN_WILDCARD) {
1059                 if (lun >= ISP_MAX_LUNS(isp)) {
1060                         return (CAM_LUN_INVALID);
1061                 }
1062         }
1063         if (is_lun_enabled(isp, bus, lun)) {
1064                 return (CAM_LUN_ALRDY_ENA);
1065         }
1066         tptr = kmalloc(sizeof (tstate_t), M_DEVBUF, M_WAITOK | M_ZERO);
1067         status = xpt_create_path(&tptr->owner, NULL, xpt_path_path_id(path), xpt_path_target_id(path), lun);
1068         if (status != CAM_REQ_CMP) {
1069                 kfree(tptr, M_DEVBUF);
1070                 return (status);
1071         }
1072         SLIST_INIT(&tptr->atios);
1073         SLIST_INIT(&tptr->inots);
1074         for (i = 0; i < ATPDPSIZE-1; i++) {
1075                 tptr->atpool[i].next = &tptr->atpool[i+1];
1076                 tptr->ntpool[i].next = &tptr->ntpool[i+1];
1077         }
1078         tptr->atfree = tptr->atpool;
1079         tptr->ntfree = tptr->ntpool;
1080         tptr->hold = 1;
1081         ISP_GET_PC_ADDR(isp, bus, lun_hash[LUN_HASH_FUNC(xpt_path_lun_id(tptr->owner))], lhp);
1082         SLIST_INSERT_HEAD(lhp, tptr, next);
1083         *rslt = tptr;
1084         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, path, "created tstate\n");
1085         return (CAM_REQ_CMP);
1086 }
1087
1088 static ISP_INLINE void
1089 destroy_lun_state(ispsoftc_t *isp, tstate_t *tptr)
1090 {
1091         struct tslist *lhp;
1092         KASSERT((tptr->hold == 0), ("tptr still held"));
1093         ISP_GET_PC_ADDR(isp, xpt_path_path_id(tptr->owner), lun_hash[LUN_HASH_FUNC(xpt_path_lun_id(tptr->owner))], lhp);
1094         SLIST_REMOVE(lhp, tptr, tstate, next);
1095         xpt_free_path(tptr->owner);
1096         kfree(tptr, M_DEVBUF);
1097 }
1098
1099 /*
1100  * Enable a lun.
1101  */
1102 static void
1103 isp_enable_lun(ispsoftc_t *isp, union ccb *ccb)
1104 {
1105         tstate_t *tptr = NULL;
1106         int bus, tm_enabled, target_role;
1107         target_id_t target;
1108         lun_id_t lun;
1109
1110         /*
1111          * We only support either a wildcard target/lun or a target ID of zero and a non-wildcard lun
1112          */
1113         bus = XS_CHANNEL(ccb);
1114         target = ccb->ccb_h.target_id;
1115         lun = ccb->ccb_h.target_lun;
1116         if (target != CAM_TARGET_WILDCARD && target != 0) {
1117                 ccb->ccb_h.status = CAM_TID_INVALID;
1118                 xpt_done(ccb);
1119                 return;
1120         }
1121         if (target == CAM_TARGET_WILDCARD && lun != CAM_LUN_WILDCARD) {
1122                 ccb->ccb_h.status = CAM_LUN_INVALID;
1123                 xpt_done(ccb);
1124                 return;
1125         }
1126
1127         if (target != CAM_TARGET_WILDCARD && lun == CAM_LUN_WILDCARD) {
1128                 ccb->ccb_h.status = CAM_LUN_INVALID;
1129                 xpt_done(ccb);
1130                 return;
1131         }
1132         if (isp->isp_dblev & ISP_LOGTDEBUG0) {
1133                 xpt_print(ccb->ccb_h.path, "enabling lun 0x%x on channel %d\n", lun, bus);
1134         }
1135
1136         /*
1137          * Wait until we're not busy with the lun enables subsystem
1138          */
1139         while (isp->isp_osinfo.tmbusy) {
1140                 isp->isp_osinfo.tmwanted = 1;
1141                 mtx_sleep(isp, &isp->isp_lock, 0, "want_isp_enable_lun", 0);
1142         }
1143         isp->isp_osinfo.tmbusy = 1;
1144
1145         /*
1146          * This is as a good a place as any to check f/w capabilities.
1147          */
1148
1149         if (IS_FC(isp)) {
1150                 if (ISP_CAP_TMODE(isp) == 0) {
1151                         xpt_print(ccb->ccb_h.path, "firmware does not support target mode\n");
1152                         ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
1153                         goto done;
1154                 }
1155                 /*
1156                  * We *could* handle non-SCCLUN f/w, but we'd have to
1157                  * dork with our already fragile enable/disable code.
1158                  */
1159                 if (ISP_CAP_SCCFW(isp) == 0) {
1160                         xpt_print(ccb->ccb_h.path, "firmware not SCCLUN capable\n");
1161                         ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
1162                         goto done;
1163                 }
1164
1165                 target_role = (FCPARAM(isp, bus)->role & ISP_ROLE_TARGET) != 0;
1166
1167         } else {
1168                 target_role = (SDPARAM(isp, bus)->role & ISP_ROLE_TARGET) != 0;
1169         }
1170
1171         /*
1172          * Create the state pointer.
1173          * It should not already exist.
1174          */
1175         tptr = get_lun_statep(isp, bus, lun);
1176         if (tptr) {
1177                 ccb->ccb_h.status = CAM_LUN_ALRDY_ENA;
1178                 goto done;
1179         }
1180         ccb->ccb_h.status = create_lun_state(isp, bus, ccb->ccb_h.path, &tptr);
1181         if (ccb->ccb_h.status != CAM_REQ_CMP) {
1182                 goto done;
1183         }
1184
1185         /*
1186          * We have a tricky maneuver to perform here.
1187          *
1188          * If target mode isn't already enabled here,
1189          * *and* our current role includes target mode,
1190          * we enable target mode here.
1191          *
1192          */
1193         ISP_GET_PC(isp, bus, tm_enabled, tm_enabled);
1194         if (tm_enabled == 0 && target_role != 0) {
1195                 if (isp_enable_target_mode(isp, bus)) {
1196                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1197                         destroy_lun_state(isp, tptr);
1198                         tptr = NULL;
1199                         goto done;
1200                 }
1201                 tm_enabled = 1;
1202         }
1203
1204         /*
1205          * Now check to see whether this bus is in target mode already.
1206          *
1207          * If not, a later role change into target mode will finish the job.
1208          */
1209         if (tm_enabled == 0) {
1210                 ISP_SET_PC(isp, bus, tm_enable_defer, 1);
1211                 ccb->ccb_h.status = CAM_REQ_CMP;
1212                 xpt_print(ccb->ccb_h.path, "Target Mode Not Enabled Yet- Lun Enables Deferred\n");
1213                 goto done;
1214         }
1215
1216         /*
1217          * Enable the lun.
1218          */
1219         ccb->ccb_h.status = isp_enable_deferred(isp, bus, lun);
1220
1221 done:
1222         if (ccb->ccb_h.status != CAM_REQ_CMP && tptr) {
1223                 destroy_lun_state(isp, tptr);
1224                 tptr = NULL;
1225         }
1226         if (tptr) {
1227                 rls_lun_statep(isp, tptr);
1228         }
1229         isp->isp_osinfo.tmbusy = 0;
1230         if (isp->isp_osinfo.tmwanted) {
1231                 isp->isp_osinfo.tmwanted = 0;
1232                 wakeup(isp);
1233         }
1234         xpt_done(ccb);
1235 }
1236
1237 static void
1238 isp_enable_deferred_luns(ispsoftc_t *isp, int bus)
1239 {
1240         /*
1241          * XXX: not entirely implemented yet
1242          */
1243         (void) isp_enable_deferred(isp, bus, 0);
1244 }
1245
1246 static uint32_t
1247 isp_enable_deferred(ispsoftc_t *isp, int bus, lun_id_t lun)
1248 {
1249         cam_status status;
1250
1251         isp_prt(isp, ISP_LOGTINFO, "%s: bus %d lun %u", __func__, bus, lun);
1252         if (IS_24XX(isp) || (IS_FC(isp) && ISP_FC_PC(isp, bus)->tm_luns_enabled)) {
1253                 status = CAM_REQ_CMP;
1254         } else {
1255                 int cmd_cnt, not_cnt;
1256
1257                 if (IS_23XX(isp)) {
1258                         cmd_cnt = DFLT_CMND_CNT;
1259                         not_cnt = DFLT_INOT_CNT;
1260                 } else {
1261                         cmd_cnt = 64;
1262                         not_cnt = 8;
1263                 }
1264                 status = CAM_REQ_INPROG;
1265                 isp->isp_osinfo.rptr = &status;
1266                 if (isp_lun_cmd(isp, RQSTYPE_ENABLE_LUN, bus, lun, DFLT_CMND_CNT, DFLT_INOT_CNT)) {
1267                         status = CAM_RESRC_UNAVAIL;
1268                 } else {
1269                         mtx_sleep(&status, &isp->isp_lock, PRIBIO, "isp_enable_deferred", 0);
1270                 }
1271                 isp->isp_osinfo.rptr = NULL;
1272         }
1273
1274         if (status == CAM_REQ_CMP) {
1275                 ISP_SET_PC(isp, bus, tm_luns_enabled, 1);
1276                 isp_prt(isp, ISP_LOGTINFO, "bus %d lun %u now enabled for target mode", bus, lun);
1277         }
1278         return (status);
1279 }
1280
1281 static void
1282 isp_disable_lun(ispsoftc_t *isp, union ccb *ccb)
1283 {
1284         tstate_t *tptr = NULL;
1285         int bus;
1286         cam_status status;
1287         target_id_t target;
1288         lun_id_t lun;
1289
1290         bus = XS_CHANNEL(ccb);
1291         target = ccb->ccb_h.target_id;
1292         lun = ccb->ccb_h.target_lun;
1293         if (target != CAM_TARGET_WILDCARD && target != 0) {
1294                 ccb->ccb_h.status = CAM_TID_INVALID;
1295                 xpt_done(ccb);
1296                 return;
1297         }
1298         if (target == CAM_TARGET_WILDCARD && lun != CAM_LUN_WILDCARD) {
1299                 ccb->ccb_h.status = CAM_LUN_INVALID;
1300                 xpt_done(ccb);
1301                 return;
1302         }
1303
1304         if (target != CAM_TARGET_WILDCARD && lun == CAM_LUN_WILDCARD) {
1305                 ccb->ccb_h.status = CAM_LUN_INVALID;
1306                 xpt_done(ccb);
1307                 return;
1308         }
1309         if (isp->isp_dblev & ISP_LOGTDEBUG0) {
1310                 xpt_print(ccb->ccb_h.path, "enabling lun 0x%x on channel %d\n", lun, bus);
1311         }
1312
1313         /*
1314          * See if we're busy disabling a lun now.
1315          */
1316         while (isp->isp_osinfo.tmbusy) {
1317                 isp->isp_osinfo.tmwanted = 1;
1318                 mtx_sleep(isp, &isp->isp_lock, PRIBIO, "want_isp_disable_lun", 0);
1319         }
1320         isp->isp_osinfo.tmbusy = 1;
1321
1322         /*
1323          * Find the state pointer.
1324          */
1325         if ((tptr = get_lun_statep(isp, bus, lun)) == NULL) {
1326                 ccb->ccb_h.status = CAM_PATH_INVALID;
1327                 goto done;
1328         }
1329
1330         /*
1331          * If we're a 24XX card, we're done.
1332          */
1333         if (IS_24XX(isp)) {
1334                 status = CAM_REQ_CMP;
1335                 goto done;
1336         }
1337
1338         /*
1339          * For SCC FW, we only deal with lun zero.
1340          */
1341         if (IS_FC(isp)) {
1342                 lun = 0;
1343         }
1344
1345         isp->isp_osinfo.rptr = &status;
1346         status = CAM_REQ_INPROG;
1347         if (isp_lun_cmd(isp, RQSTYPE_ENABLE_LUN, bus, lun, 0, 0)) {
1348                 status = CAM_RESRC_UNAVAIL;
1349         } else {
1350                 mtx_sleep(ccb, &isp->isp_lock, PRIBIO, "isp_disable_lun", 0);
1351         }
1352 done:
1353         if (status == CAM_REQ_CMP) {
1354                 xpt_print(ccb->ccb_h.path, "now disabled for target mode\n");
1355         }
1356         if (tptr) {
1357                 destroy_lun_state(isp, tptr);
1358         }
1359         isp->isp_osinfo.rptr = NULL;
1360         isp->isp_osinfo.tmbusy = 0;
1361         if (isp->isp_osinfo.tmwanted) {
1362                 isp->isp_osinfo.tmwanted = 0;
1363                 wakeup(isp);
1364         }
1365         xpt_done(ccb);
1366 }
1367
1368 static int
1369 isp_enable_target_mode(ispsoftc_t *isp, int bus)
1370 {
1371         int ct;
1372
1373         ISP_GET_PC(isp, bus, tm_enabled, ct);
1374         if (ct != 0) {
1375                 return (0);
1376         }
1377
1378         if (IS_SCSI(isp)) {
1379                 mbreg_t mbs;
1380
1381                 MBSINIT(&mbs, MBOX_ENABLE_TARGET_MODE, MBLOGALL, 0);
1382                 mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
1383                 mbs.param[1] = ENABLE_TARGET_FLAG|ENABLE_TQING_FLAG;
1384                 mbs.param[2] = bus << 7;
1385                 if (isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs) < 0 || mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1386                         isp_prt(isp, ISP_LOGERR, "Unable to add Target Role to Bus %d", bus);
1387                         return (EIO);
1388                 }
1389                 SDPARAM(isp, bus)->role |= ISP_ROLE_TARGET;
1390         }
1391         ISP_SET_PC(isp, bus, tm_enabled, 1);
1392         isp_prt(isp, ISP_LOGINFO, "Target Role added to Bus %d", bus);
1393         return (0);
1394 }
1395
1396 #ifdef  NEEDED
1397 static int
1398 isp_disable_target_mode(ispsoftc_t *isp, int bus)
1399 {
1400         int ct;
1401
1402         ISP_GET_PC(isp, bus, tm_enabled, ct);
1403         if (ct == 0) {
1404                 return (0);
1405         }
1406
1407         if (IS_SCSI(isp)) {
1408                 mbreg_t mbs;
1409
1410                 MBSINIT(&mbs, MBOX_ENABLE_TARGET_MODE, MBLOGALL, 0);
1411                 mbs.param[2] = bus << 7;
1412                 if (isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs) < 0 || mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1413                         isp_prt(isp, ISP_LOGERR, "Unable to subtract Target Role to Bus %d", bus);
1414                         return (EIO);
1415                 }
1416                 SDPARAM(isp, bus)->role &= ~ISP_ROLE_TARGET;
1417         }
1418         ISP_SET_PC(isp, bus, tm_enabled, 0);
1419         isp_prt(isp, ISP_LOGINFO, "Target Role subtracted from Bus %d", bus);
1420         return (0);
1421 }
1422 #endif
1423
1424 static void
1425 isp_ledone(ispsoftc_t *isp, lun_entry_t *lep)
1426 {
1427         uint32_t *rptr;
1428
1429         rptr = isp->isp_osinfo.rptr;
1430         if (lep->le_status != LUN_OK) {
1431                 isp_prt(isp, ISP_LOGERR, "ENABLE/MODIFY LUN returned 0x%x", lep->le_status);
1432                 if (rptr) {
1433                         *rptr = CAM_REQ_CMP_ERR;
1434                         wakeup_one(rptr);
1435                 }
1436         } else {
1437                 if (rptr) {
1438                         *rptr = CAM_REQ_CMP;
1439                         wakeup_one(rptr);
1440                 }
1441         }
1442 }
1443
1444 static void
1445 isp_target_start_ctio(ispsoftc_t *isp, union ccb *ccb)
1446 {
1447         void *qe;
1448         tstate_t *tptr;
1449         atio_private_data_t *atp;
1450         struct ccb_scsiio *cso = &ccb->csio;
1451         uint32_t dmaresult, handle;
1452         uint8_t local[QENTRY_LEN];
1453
1454         /*
1455          * Do some sanity checks.
1456          */
1457         if (cso->dxfer_len == 0) {
1458                 if ((ccb->ccb_h.flags & CAM_SEND_STATUS) == 0) {
1459                         xpt_print(ccb->ccb_h.path, "a data transfer length of zero but no status to send is wrong\n");
1460                         ccb->ccb_h.status = CAM_REQ_INVALID;
1461                         xpt_done(ccb);
1462                         return;
1463                 }
1464         }
1465
1466         tptr = get_lun_statep(isp, XS_CHANNEL(ccb), XS_LUN(ccb));
1467         if (tptr == NULL) {
1468                 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), CAM_LUN_WILDCARD);
1469                 if (tptr == NULL) {
1470                         xpt_print(ccb->ccb_h.path, "%s: [0x%x] cannot find tstate pointer in %s\n", __func__, cso->tag_id);
1471                         dump_tstates(isp, XS_CHANNEL(ccb));
1472                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
1473                         xpt_done(ccb);
1474                         return;
1475                 }
1476         }
1477
1478         atp = isp_get_atpd(isp, tptr, cso->tag_id);
1479         if (atp == NULL) {
1480                 xpt_print(ccb->ccb_h.path, "%s: [0x%x] cannot find private data adjunct\n", __func__, cso->tag_id);
1481                 isp_dump_atpd(isp, tptr);
1482                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1483                 xpt_done(ccb);
1484                 return;
1485         }
1486         if (atp->dead) {
1487                 xpt_print(ccb->ccb_h.path, "%s: [0x%x] stopping sending a CTIO for a dead command\n", __func__, cso->tag_id);
1488                 ccb->ccb_h.status = CAM_REQ_ABORTED;
1489                 xpt_done(ccb);
1490                 return;
1491         }
1492
1493         /*
1494          * Check to make sure we're still in target mode.
1495          */
1496         if ((FCPARAM(isp, XS_CHANNEL(ccb))->role & ISP_ROLE_TARGET) == 0) {
1497                 xpt_print(ccb->ccb_h.path, "%s: [0x%x] stopping sending a CTIO because we're no longer in target mode\n", __func__, cso->tag_id);
1498                 ccb->ccb_h.status = CAM_PROVIDE_FAIL;
1499                 xpt_done(ccb);
1500                 return;
1501         }
1502
1503         /*
1504          * Get some resources
1505          */
1506         if (isp_get_pcmd(isp, ccb)) {
1507                 rls_lun_statep(isp, tptr);
1508                 xpt_print(ccb->ccb_h.path, "out of PCMDs\n");
1509                 cam_freeze_devq(ccb->ccb_h.path);
1510                 cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 250, 0);
1511                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1512                 xpt_done(ccb);
1513                 return;
1514         }
1515         qe = isp_getrqentry(isp);
1516         if (qe == NULL) {
1517                 xpt_print(ccb->ccb_h.path, rqo, __func__);
1518                 cam_freeze_devq(ccb->ccb_h.path);
1519                 cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 250, 0);
1520                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1521                 goto out;
1522         }
1523         memset(local, 0, QENTRY_LEN);
1524
1525         /*
1526          * We're either moving data or completing a command here.
1527          */
1528         if (IS_24XX(isp)) {
1529                 ct7_entry_t *cto = (ct7_entry_t *) local;
1530
1531                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
1532                 cto->ct_header.rqs_entry_count = 1;
1533                 cto->ct_header.rqs_seqno = 1;
1534                 cto->ct_nphdl = atp->nphdl;
1535                 cto->ct_rxid = atp->tag;
1536                 cto->ct_iid_lo = atp->portid;
1537                 cto->ct_iid_hi = atp->portid >> 16;
1538                 cto->ct_oxid = atp->oxid;
1539                 cto->ct_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(ccb));
1540                 cto->ct_scsi_status = cso->scsi_status;
1541                 cto->ct_timeout = 120;
1542                 cto->ct_flags = atp->tattr << CT7_TASK_ATTR_SHIFT;
1543                 if (ccb->ccb_h.flags & CAM_SEND_STATUS) {
1544                         cto->ct_flags |= CT7_SENDSTATUS;
1545                 }
1546                 if (cso->dxfer_len == 0) {
1547                         cto->ct_flags |= CT7_FLAG_MODE1 | CT7_NO_DATA;
1548                         if ((ccb->ccb_h.flags & CAM_SEND_SENSE) != 0) {
1549                                 int m = min(cso->sense_len, sizeof (struct scsi_sense_data));
1550                                 cto->rsp.m1.ct_resplen = cto->ct_senselen = min(m, MAXRESPLEN_24XX);
1551                                 memcpy(cto->rsp.m1.ct_resp, &cso->sense_data, cto->ct_senselen);
1552                                 cto->ct_scsi_status |= (FCP_SNSLEN_VALID << 8);
1553                         }
1554                 } else {
1555                         cto->ct_flags |= CT7_FLAG_MODE0;
1556                         if ((cso->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1557                                 cto->ct_flags |= CT7_DATA_IN;
1558                         } else {
1559                                 cto->ct_flags |= CT7_DATA_OUT;
1560                         }
1561                         cto->rsp.m0.reloff = atp->bytes_xfered;
1562                         /*
1563                          * Don't overrun the limits placed on us
1564                          */
1565                         if (atp->bytes_xfered + cso->dxfer_len > atp->orig_datalen) {
1566                                 cso->dxfer_len = atp->orig_datalen - atp->bytes_xfered;
1567                         }
1568                         atp->last_xframt = cso->dxfer_len;
1569                         cto->rsp.m0.ct_xfrlen = cso->dxfer_len;
1570                 }
1571                 if (cto->ct_flags & CT7_SENDSTATUS) {
1572                         int lvl = (cso->scsi_status)? ISP_LOGTINFO : ISP_LOGTDEBUG0;
1573                         cto->ct_resid = atp->orig_datalen - (atp->bytes_xfered + cso->dxfer_len);
1574                         if (cto->ct_resid < 0) {
1575                                 cto->ct_scsi_status |= (FCP_RESID_OVERFLOW << 8);
1576                         } else if (cto->ct_resid > 0) {
1577                                 cto->ct_scsi_status |= (FCP_RESID_UNDERFLOW << 8);
1578                         }
1579                         atp->state = ATPD_STATE_LAST_CTIO;
1580                         ISP_PATH_PRT(isp, lvl, cso->ccb_h.path, "%s: CTIO7[%x] CDB0=%x scsi status %x flags %x resid %d xfrlen %u offset %u\n", __func__, cto->ct_rxid,
1581                             atp->cdb0, cto->ct_scsi_status, cto->ct_flags, cto->ct_resid, cso->dxfer_len, atp->bytes_xfered);
1582                 } else {
1583                         cto->ct_resid = 0;
1584                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, cso->ccb_h.path, "%s: CTIO7[%x] flags %x xfrlen %u offset %u\n", __func__, cto->ct_rxid, cto->ct_flags,
1585                             cso->dxfer_len, atp->bytes_xfered);
1586                         atp->state = ATPD_STATE_CTIO;
1587                 }
1588         } else if (IS_FC(isp)) {
1589                 ct2_entry_t *cto = (ct2_entry_t *) local;
1590
1591                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
1592                 cto->ct_header.rqs_entry_count = 1;
1593                 cto->ct_header.rqs_seqno = 1;
1594                 if (ISP_CAP_2KLOGIN(isp) == 0) {
1595                         ((ct2e_entry_t *)cto)->ct_iid = cso->init_id;
1596                 } else {
1597                         cto->ct_iid = cso->init_id;
1598                         if (ISP_CAP_SCCFW(isp) == 0) {
1599                                 cto->ct_lun = ccb->ccb_h.target_lun;
1600                         }
1601                 }
1602
1603
1604                 cto->ct_rxid = cso->tag_id;
1605                 if (cso->dxfer_len == 0) {
1606                         cto->ct_flags |= CT2_FLAG_MODE1 | CT2_NO_DATA | CT2_SENDSTATUS;
1607                         cto->rsp.m1.ct_scsi_status = cso->scsi_status;
1608                         cto->ct_resid = atp->orig_datalen - atp->bytes_xfered;
1609                         if (cto->ct_resid < 0) {
1610                                 cto->rsp.m1.ct_scsi_status |= CT2_DATA_OVER;
1611                         } else if (cto->ct_resid > 0) {
1612                                 cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
1613                         }
1614                         if ((ccb->ccb_h.flags & CAM_SEND_SENSE) != 0) {
1615                                 int m = min(cso->sense_len, MAXRESPLEN);
1616                                 memcpy(cto->rsp.m1.ct_resp, &cso->sense_data, m);
1617                                 cto->rsp.m1.ct_senselen = m;
1618                                 cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
1619                         } else if (cso->scsi_status == SCSI_STATUS_CHECK_COND) {
1620                                 /*
1621                                  * XXX: DEBUG
1622                                  */
1623                                 xpt_print(ccb->ccb_h.path, "CHECK CONDITION being sent without associated SENSE DATA for CDB=0x%x\n", atp->cdb0);
1624                         }
1625                 } else {
1626                         cto->ct_flags |= CT2_FLAG_MODE0;
1627                         if ((cso->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1628                                 cto->ct_flags |= CT2_DATA_IN;
1629                         } else {
1630                                 cto->ct_flags |= CT2_DATA_OUT;
1631                         }
1632                         cto->ct_reloff = atp->bytes_xfered;
1633                         cto->rsp.m0.ct_xfrlen = cso->dxfer_len;
1634                         /*
1635                          * Don't overrun the limits placed on us
1636                          */
1637                         if (atp->bytes_xfered + cso->dxfer_len > atp->orig_datalen) {
1638                                 cso->dxfer_len = atp->orig_datalen - atp->bytes_xfered;
1639                         }
1640                         if ((ccb->ccb_h.flags & CAM_SEND_STATUS) != 0) {
1641                                 cto->ct_flags |= CT2_SENDSTATUS;
1642                                 cto->rsp.m0.ct_scsi_status = cso->scsi_status;
1643                                 cto->ct_resid = atp->orig_datalen - (atp->bytes_xfered + cso->dxfer_len);
1644                                 if (cto->ct_resid < 0) {
1645                                         cto->rsp.m0.ct_scsi_status |= CT2_DATA_OVER;
1646                                 } else if (cto->ct_resid > 0) {
1647                                         cto->rsp.m0.ct_scsi_status |= CT2_DATA_UNDER;
1648                                 }
1649                         } else {
1650                                 atp->last_xframt = cso->dxfer_len;
1651                         }
1652                         /*
1653                          * If we're sending data and status back together,
1654                          * we can't also send back sense data as well.
1655                          */
1656                         ccb->ccb_h.flags &= ~CAM_SEND_SENSE;
1657                 }
1658
1659                 if (cto->ct_flags & CT2_SENDSTATUS) {
1660                         int lvl = (cso->scsi_status)? ISP_LOGTINFO : ISP_LOGTDEBUG0;
1661                         cto->ct_flags |= CT2_CCINCR;
1662                         atp->state = ATPD_STATE_LAST_CTIO;
1663                         ISP_PATH_PRT(isp, lvl, cso->ccb_h.path, "%s: CTIO2[%x] CDB0=%x scsi status %x flags %x resid %d xfrlen %u offset %u\n", __func__, cto->ct_rxid,
1664                             atp->cdb0, cto->rsp.m0.ct_scsi_status, cto->ct_flags, cto->ct_resid, cso->dxfer_len, atp->bytes_xfered);
1665                 } else {
1666                         cto->ct_resid = 0;
1667                         atp->state = ATPD_STATE_CTIO;
1668                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: CTIO2[%x] flags %x xfrlen %u offset %u\n", __func__, cto->ct_rxid, cto->ct_flags,
1669                             cso->dxfer_len, atp->bytes_xfered);
1670                 }
1671                 cto->ct_timeout = 10;
1672         } else {
1673                 ct_entry_t *cto = (ct_entry_t *) local;
1674
1675                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO;
1676                 cto->ct_header.rqs_entry_count = 1;
1677                 cto->ct_header.rqs_seqno = 1;
1678                 cto->ct_iid = cso->init_id;
1679                 cto->ct_iid |= XS_CHANNEL(ccb) << 7;
1680                 cto->ct_tgt = ccb->ccb_h.target_id;
1681                 cto->ct_lun = ccb->ccb_h.target_lun;
1682                 cto->ct_fwhandle = cso->tag_id >> 16;
1683                 if (AT_HAS_TAG(cso->tag_id)) {
1684                         cto->ct_tag_val = cso->tag_id;
1685                         cto->ct_flags |= CT_TQAE;
1686                 }
1687                 if (ccb->ccb_h.flags & CAM_DIS_DISCONNECT) {
1688                         cto->ct_flags |= CT_NODISC;
1689                 }
1690                 if (cso->dxfer_len == 0) {
1691                         cto->ct_flags |= CT_NO_DATA;
1692                 } else if ((cso->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1693                         cto->ct_flags |= CT_DATA_IN;
1694                 } else {
1695                         cto->ct_flags |= CT_DATA_OUT;
1696                 }
1697                 if (ccb->ccb_h.flags & CAM_SEND_STATUS) {
1698                         cto->ct_flags |= CT_SENDSTATUS|CT_CCINCR;
1699                         cto->ct_scsi_status = cso->scsi_status;
1700                         cto->ct_resid = cso->resid;
1701                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: CTIO[%x] scsi status %x resid %d tag_id %x\n", __func__,
1702                             cto->ct_fwhandle, cso->scsi_status, cso->resid, cso->tag_id);
1703                 }
1704                 ccb->ccb_h.flags &= ~CAM_SEND_SENSE;
1705                 cto->ct_timeout = 10;
1706         }
1707
1708         if (isp_allocate_xs_tgt(isp, ccb, &handle)) {
1709                 xpt_print(ccb->ccb_h.path, "No XFLIST pointers for %s\n", __func__);
1710                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1711                 goto out;
1712         }
1713
1714
1715         /*
1716          * Call the dma setup routines for this entry (and any subsequent
1717          * CTIOs) if there's data to move, and then tell the f/w it's got
1718          * new things to play with. As with isp_start's usage of DMA setup,
1719          * any swizzling is done in the machine dependent layer. Because
1720          * of this, we put the request onto the queue area first in native
1721          * format.
1722          */
1723
1724         if (IS_24XX(isp)) {
1725                 ct7_entry_t *cto = (ct7_entry_t *) local;
1726                 cto->ct_syshandle = handle;
1727         } else if (IS_FC(isp)) {
1728                 ct2_entry_t *cto = (ct2_entry_t *) local;
1729                 cto->ct_syshandle = handle;
1730         } else {
1731                 ct_entry_t *cto = (ct_entry_t *) local;
1732                 cto->ct_syshandle = handle;
1733         }
1734
1735         dmaresult = ISP_DMASETUP(isp, cso, (ispreq_t *) local);
1736         if (dmaresult == CMD_QUEUED) {
1737                 isp->isp_nactive++;
1738                 ccb->ccb_h.status |= CAM_SIM_QUEUED;
1739                 rls_lun_statep(isp, tptr);
1740                 return;
1741         }
1742         if (dmaresult == CMD_EAGAIN) {
1743                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1744         } else {
1745                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
1746         }
1747         isp_destroy_tgt_handle(isp, handle);
1748 out:
1749         rls_lun_statep(isp, tptr);
1750         isp_free_pcmd(isp, ccb);
1751         xpt_done(ccb);
1752 }
1753
1754 static void
1755 isp_refire_putback_atio(void *arg)
1756 {
1757         union ccb *ccb = arg;
1758         ispsoftc_t *isp = XS_ISP(ccb);
1759         ISP_LOCK(isp);
1760         isp_target_putback_atio(ccb);
1761         ISP_UNLOCK(isp);
1762 }
1763
1764 static void
1765 isp_target_putback_atio(union ccb *ccb)
1766 {
1767         ispsoftc_t *isp;
1768         struct ccb_scsiio *cso;
1769         void *qe;
1770
1771         isp = XS_ISP(ccb);
1772
1773         qe = isp_getrqentry(isp);
1774         if (qe == NULL) {
1775                 xpt_print(ccb->ccb_h.path, rqo, __func__);
1776                 (void) timeout(isp_refire_putback_atio, ccb, 10);
1777                 return;
1778         }
1779         memset(qe, 0, QENTRY_LEN);
1780         cso = &ccb->csio;
1781         if (IS_FC(isp)) {
1782                 at2_entry_t local, *at = &local;
1783                 ISP_MEMZERO(at, sizeof (at2_entry_t));
1784                 at->at_header.rqs_entry_type = RQSTYPE_ATIO2;
1785                 at->at_header.rqs_entry_count = 1;
1786                 if (ISP_CAP_SCCFW(isp)) {
1787                         at->at_scclun = (uint16_t) ccb->ccb_h.target_lun;
1788                 } else {
1789                         at->at_lun = (uint8_t) ccb->ccb_h.target_lun;
1790                 }
1791                 at->at_status = CT_OK;
1792                 at->at_rxid = cso->tag_id;
1793                 at->at_iid = cso->ccb_h.target_id;
1794                 isp_put_atio2(isp, at, qe);
1795         } else {
1796                 at_entry_t local, *at = &local;
1797                 ISP_MEMZERO(at, sizeof (at_entry_t));
1798                 at->at_header.rqs_entry_type = RQSTYPE_ATIO;
1799                 at->at_header.rqs_entry_count = 1;
1800                 at->at_iid = cso->init_id;
1801                 at->at_iid |= XS_CHANNEL(ccb) << 7;
1802                 at->at_tgt = cso->ccb_h.target_id;
1803                 at->at_lun = cso->ccb_h.target_lun;
1804                 at->at_status = CT_OK;
1805                 at->at_tag_val = AT_GET_TAG(cso->tag_id);
1806                 at->at_handle = AT_GET_HANDLE(cso->tag_id);
1807                 isp_put_atio(isp, at, qe);
1808         }
1809         ISP_TDQE(isp, "isp_target_putback_atio", isp->isp_reqidx, qe);
1810         ISP_SYNC_REQUEST(isp);
1811         isp_complete_ctio(ccb);
1812 }
1813
1814 static void
1815 isp_complete_ctio(union ccb *ccb)
1816 {
1817         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) {
1818                 ccb->ccb_h.status |= CAM_REQ_CMP;
1819         }
1820         ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
1821         isp_free_pcmd(XS_ISP(ccb), ccb);
1822         xpt_done(ccb);
1823 }
1824
1825 /*
1826  * Handle ATIO stuff that the generic code can't.
1827  * This means handling CDBs.
1828  */
1829
1830 static void
1831 isp_handle_platform_atio(ispsoftc_t *isp, at_entry_t *aep)
1832 {
1833         tstate_t *tptr;
1834         int status, bus;
1835         struct ccb_accept_tio *atiop;
1836         atio_private_data_t *atp;
1837
1838         /*
1839          * The firmware status (except for the QLTM_SVALID bit)
1840          * indicates why this ATIO was sent to us.
1841          *
1842          * If QLTM_SVALID is set, the firmware has recommended Sense Data.
1843          *
1844          * If the DISCONNECTS DISABLED bit is set in the flags field,
1845          * we're still connected on the SCSI bus.
1846          */
1847         status = aep->at_status;
1848         if ((status & ~QLTM_SVALID) == AT_PHASE_ERROR) {
1849                 /*
1850                  * Bus Phase Sequence error. We should have sense data
1851                  * suggested by the f/w. I'm not sure quite yet what
1852                  * to do about this for CAM.
1853                  */
1854                 isp_prt(isp, ISP_LOGWARN, "PHASE ERROR");
1855                 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1856                 return;
1857         }
1858         if ((status & ~QLTM_SVALID) != AT_CDB) {
1859                 isp_prt(isp, ISP_LOGWARN, "bad atio (0x%x) leaked to platform", status);
1860                 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1861                 return;
1862         }
1863
1864         bus = GET_BUS_VAL(aep->at_iid);
1865         tptr = get_lun_statep(isp, bus, aep->at_lun);
1866         if (tptr == NULL) {
1867                 tptr = get_lun_statep(isp, bus, CAM_LUN_WILDCARD);
1868                 if (tptr == NULL) {
1869                         /*
1870                          * Because we can't autofeed sense data back with
1871                          * a command for parallel SCSI, we can't give back
1872                          * a CHECK CONDITION. We'll give back a BUSY status
1873                          * instead. This works out okay because the only
1874                          * time we should, in fact, get this, is in the
1875                          * case that somebody configured us without the
1876                          * blackhole driver, so they get what they deserve.
1877                          */
1878                         isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1879                         return;
1880                 }
1881         }
1882
1883         atp = isp_get_atpd(isp, tptr, 0);
1884         atiop = (struct ccb_accept_tio *) SLIST_FIRST(&tptr->atios);
1885         if (atiop == NULL || atp == NULL) {
1886                 /*
1887                  * Because we can't autofeed sense data back with
1888                  * a command for parallel SCSI, we can't give back
1889                  * a CHECK CONDITION. We'll give back a QUEUE FULL status
1890                  * instead. This works out okay because the only time we
1891                  * should, in fact, get this, is in the case that we've
1892                  * run out of ATIOS.
1893                  */
1894                 xpt_print(tptr->owner, "no %s for lun %d from initiator %d\n", (atp == NULL && atiop == NULL)? "ATIOs *or* ATPS" :
1895                     ((atp == NULL)? "ATPs" : "ATIOs"), aep->at_lun, aep->at_iid);
1896                 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1897                 if (atp) {
1898                         isp_put_atpd(isp, tptr, atp);
1899                 }
1900                 rls_lun_statep(isp, tptr);
1901                 return;
1902         }
1903         atp->tag = aep->at_tag_val;
1904         if (atp->tag == 0) {
1905                 atp->tag = ~0;
1906         }
1907         atp->state = ATPD_STATE_ATIO;
1908         SLIST_REMOVE_HEAD(&tptr->atios, sim_links.sle);
1909         tptr->atio_count--;
1910         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, atiop->ccb_h.path, "Take FREE ATIO count now %d\n", tptr->atio_count);
1911         atiop->ccb_h.target_id = aep->at_tgt;
1912         atiop->ccb_h.target_lun = aep->at_lun;
1913         if (aep->at_flags & AT_NODISC) {
1914                 atiop->ccb_h.flags = CAM_DIS_DISCONNECT;
1915         } else {
1916                 atiop->ccb_h.flags = 0;
1917         }
1918
1919         if (status & QLTM_SVALID) {
1920                 size_t amt = ISP_MIN(QLTM_SENSELEN, sizeof (atiop->sense_data));
1921                 atiop->sense_len = amt;
1922                 ISP_MEMCPY(&atiop->sense_data, aep->at_sense, amt);
1923         } else {
1924                 atiop->sense_len = 0;
1925         }
1926
1927         atiop->init_id = GET_IID_VAL(aep->at_iid);
1928         atiop->cdb_len = aep->at_cdblen;
1929         ISP_MEMCPY(atiop->cdb_io.cdb_bytes, aep->at_cdb, aep->at_cdblen);
1930         atiop->ccb_h.status = CAM_CDB_RECVD;
1931         /*
1932          * Construct a tag 'id' based upon tag value (which may be 0..255)
1933          * and the handle (which we have to preserve).
1934          */
1935         atiop->tag_id = atp->tag;
1936         if (aep->at_flags & AT_TQAE) {
1937                 atiop->tag_action = aep->at_tag_type;
1938                 atiop->ccb_h.status |= CAM_TAG_ACTION_VALID;
1939         }
1940         atp->orig_datalen = 0;
1941         atp->bytes_xfered = 0;
1942         atp->last_xframt = 0;
1943         atp->lun = aep->at_lun;
1944         atp->nphdl = aep->at_iid;
1945         atp->portid = PORT_NONE;
1946         atp->oxid = 0;
1947         atp->cdb0 = atiop->cdb_io.cdb_bytes[0];
1948         atp->tattr = aep->at_tag_type;
1949         atp->state = ATPD_STATE_CAM;
1950         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, tptr->owner, "ATIO[%x] CDB=0x%x lun %d\n", aep->at_tag_val, atp->cdb0, atp->lun);
1951         rls_lun_statep(isp, tptr);
1952 }
1953
1954 static void
1955 isp_handle_platform_atio2(ispsoftc_t *isp, at2_entry_t *aep)
1956 {
1957         lun_id_t lun;
1958         fcportdb_t *lp;
1959         tstate_t *tptr;
1960         struct ccb_accept_tio *atiop;
1961         uint16_t nphdl;
1962         atio_private_data_t *atp;
1963         inot_private_data_t *ntp;
1964
1965         /*
1966          * The firmware status (except for the QLTM_SVALID bit)
1967          * indicates why this ATIO was sent to us.
1968          *
1969          * If QLTM_SVALID is set, the firmware has recommended Sense Data.
1970          */
1971         if ((aep->at_status & ~QLTM_SVALID) != AT_CDB) {
1972                 isp_prt(isp, ISP_LOGWARN, "bogus atio (0x%x) leaked to platform", aep->at_status);
1973                 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0);
1974                 return;
1975         }
1976
1977         if (ISP_CAP_SCCFW(isp)) {
1978                 lun = aep->at_scclun;
1979         } else {
1980                 lun = aep->at_lun;
1981         }
1982         if (ISP_CAP_2KLOGIN(isp)) {
1983                 nphdl = ((at2e_entry_t *)aep)->at_iid;
1984         } else {
1985                 nphdl = aep->at_iid;
1986         }
1987         tptr = get_lun_statep(isp, 0, lun);
1988         if (tptr == NULL) {
1989                 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
1990                 if (tptr == NULL) {
1991                         isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] no state pointer for lun %d", aep->at_rxid, lun);
1992                         isp_endcmd(isp, aep, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
1993                         return;
1994                 }
1995         }
1996
1997         /*
1998          * Start any commands pending resources first.
1999          */
2000         if (tptr->restart_queue) {
2001                 inot_private_data_t *restart_queue = tptr->restart_queue;
2002                 tptr->restart_queue = NULL;
2003                 while (restart_queue) {
2004                         ntp = restart_queue;
2005                         restart_queue = ntp->rd.nt.nt_hba;
2006                         isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at2_entry_t *)ntp->rd.data)->at_rxid);
2007                         isp_handle_platform_atio2(isp, (at2_entry_t *) ntp->rd.data);
2008                         isp_put_ntpd(isp, tptr, ntp);
2009                         /*
2010                          * If a recursion caused the restart queue to start to fill again,
2011                          * stop and splice the new list on top of the old list and restore
2012                          * it and go to noresrc.
2013                          */
2014                         if (tptr->restart_queue) {
2015                                 ntp = tptr->restart_queue;
2016                                 tptr->restart_queue = restart_queue;
2017                                 while (restart_queue->rd.nt.nt_hba) {
2018                                         restart_queue = restart_queue->rd.nt.nt_hba;
2019                                 }
2020                                 restart_queue->rd.nt.nt_hba = ntp;
2021                                 goto noresrc;
2022                         }
2023                 }
2024         }
2025
2026         atiop = (struct ccb_accept_tio *) SLIST_FIRST(&tptr->atios);
2027         if (atiop == NULL) {
2028                 goto noresrc;
2029         }
2030
2031         atp = isp_get_atpd(isp, tptr, 0);
2032         if (atp == NULL) {
2033                 goto noresrc;
2034         }
2035
2036         atp->tag = aep->at_rxid;
2037         atp->state = ATPD_STATE_ATIO;
2038         SLIST_REMOVE_HEAD(&tptr->atios, sim_links.sle);
2039         tptr->atio_count--;
2040         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, atiop->ccb_h.path, "Take FREE ATIO count now %d\n", tptr->atio_count);
2041         atiop->ccb_h.target_id = FCPARAM(isp, 0)->isp_loopid;
2042         atiop->ccb_h.target_lun = lun;
2043
2044         /*
2045          * We don't get 'suggested' sense data as we do with SCSI cards.
2046          */
2047         atiop->sense_len = 0;
2048         if (ISP_CAP_2KLOGIN(isp)) {
2049                 /*
2050                  * NB: We could not possibly have 2K logins if we
2051                  * NB: also did not have SCC FW.
2052                  */
2053                 atiop->init_id = ((at2e_entry_t *)aep)->at_iid;
2054         } else {
2055                 atiop->init_id = aep->at_iid;
2056         }
2057
2058         /*
2059          * If we're not in the port database, add ourselves.
2060          */
2061         if (!IS_2100(isp) && isp_find_pdb_by_loopid(isp, 0, atiop->init_id, &lp) == 0) {
2062                 uint64_t iid =
2063                         (((uint64_t) aep->at_wwpn[0]) << 48) |
2064                         (((uint64_t) aep->at_wwpn[1]) << 32) |
2065                         (((uint64_t) aep->at_wwpn[2]) << 16) |
2066                         (((uint64_t) aep->at_wwpn[3]) <<  0);
2067                 /*
2068                  * However, make sure we delete ourselves if otherwise
2069                  * we were there but at a different loop id.
2070                  */
2071                 if (isp_find_pdb_by_wwn(isp, 0, iid, &lp)) {
2072                         isp_del_wwn_entry(isp, 0, iid, lp->handle, lp->portid);
2073                 }
2074                 isp_add_wwn_entry(isp, 0, iid, atiop->init_id, PORT_ANY);
2075         }
2076         atiop->cdb_len = ATIO2_CDBLEN;
2077         ISP_MEMCPY(atiop->cdb_io.cdb_bytes, aep->at_cdb, ATIO2_CDBLEN);
2078         atiop->ccb_h.status = CAM_CDB_RECVD;
2079         atiop->tag_id = atp->tag;
2080         switch (aep->at_taskflags & ATIO2_TC_ATTR_MASK) {
2081         case ATIO2_TC_ATTR_SIMPLEQ:
2082                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2083                 atiop->tag_action = MSG_SIMPLE_Q_TAG;
2084                 break;
2085         case ATIO2_TC_ATTR_HEADOFQ:
2086                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2087                 atiop->tag_action = MSG_HEAD_OF_Q_TAG;
2088                 break;
2089         case ATIO2_TC_ATTR_ORDERED:
2090                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2091                 atiop->tag_action = MSG_ORDERED_Q_TAG;
2092                 break;
2093         case ATIO2_TC_ATTR_ACAQ:                /* ?? */
2094         case ATIO2_TC_ATTR_UNTAGGED:
2095         default:
2096                 atiop->tag_action = 0;
2097                 break;
2098         }
2099
2100         atp->orig_datalen = aep->at_datalen;
2101         atp->bytes_xfered = 0;
2102         atp->last_xframt = 0;
2103         atp->lun = lun;
2104         atp->nphdl = atiop->init_id;
2105         atp->sid = PORT_ANY;
2106         atp->oxid = aep->at_oxid;
2107         atp->cdb0 = aep->at_cdb[0];
2108         atp->tattr = aep->at_taskflags & ATIO2_TC_ATTR_MASK;
2109         atp->state = ATPD_STATE_CAM;
2110         xpt_done((union ccb *)atiop);
2111         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, tptr->owner, "ATIO2[%x] CDB=0x%x lun %d datalen %u\n", aep->at_rxid, atp->cdb0, lun, atp->orig_datalen);
2112         rls_lun_statep(isp, tptr);
2113         return;
2114 noresrc:
2115         ntp = isp_get_ntpd(isp, tptr);
2116         if (ntp == NULL) {
2117                 rls_lun_statep(isp, tptr);
2118                 isp_endcmd(isp, aep, nphdl, 0, SCSI_STATUS_BUSY, 0);
2119                 return;
2120         }
2121         memcpy(ntp->rd.data, aep, QENTRY_LEN);
2122         ntp->rd.nt.nt_hba = tptr->restart_queue;
2123         tptr->restart_queue = ntp;
2124         rls_lun_statep(isp, tptr);
2125 }
2126
2127 static void
2128 isp_handle_platform_atio7(ispsoftc_t *isp, at7_entry_t *aep)
2129 {
2130         int cdbxlen;
2131         uint16_t lun, chan, nphdl = NIL_HANDLE;
2132         uint32_t did, sid;
2133         uint64_t wwn = INI_NONE;
2134         fcportdb_t *lp;
2135         tstate_t *tptr;
2136         struct ccb_accept_tio *atiop;
2137         atio_private_data_t *atp = NULL;
2138         inot_private_data_t *ntp;
2139
2140         did = (aep->at_hdr.d_id[0] << 16) | (aep->at_hdr.d_id[1] << 8) | aep->at_hdr.d_id[2];
2141         sid = (aep->at_hdr.s_id[0] << 16) | (aep->at_hdr.s_id[1] << 8) | aep->at_hdr.s_id[2];
2142         lun = (aep->at_cmnd.fcp_cmnd_lun[0] << 8) | aep->at_cmnd.fcp_cmnd_lun[1];
2143
2144         /*
2145          * Find the N-port handle, and Virtual Port Index for this command.
2146          *
2147          * If we can't, we're somewhat in trouble because we can't actually respond w/o that information.
2148          * We also, as a matter of course, need to know the WWN of the initiator too.
2149          */
2150         if (ISP_CAP_MULTI_ID(isp)) {
2151                 /*
2152                  * Find the right channel based upon D_ID
2153                  */
2154                 isp_find_chan_by_did(isp, did, &chan);
2155
2156                 if (chan == ISP_NOCHAN) {
2157                         NANOTIME_T now;
2158
2159                         /*
2160                          * If we don't recognizer our own D_DID, terminate the exchange, unless we're within 2 seconds of startup
2161                          * It's a bit tricky here as we need to stash this command *somewhere*.
2162                          */
2163                         GET_NANOTIME(&now);
2164                         if (NANOTIME_SUB(&isp->isp_init_time, &now) > 2000000000ULL) {
2165                                 isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel- dropping", __func__, aep->at_rxid, did);
2166                                 isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN, ECMD_TERMINATE, 0);
2167                                 return;
2168                         }
2169                         tptr = get_lun_statep(isp, 0, 0);
2170                         if (tptr == NULL) {
2171                                 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
2172                                 if (tptr == NULL) {
2173                                         isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel and no tptr- dropping", __func__, aep->at_rxid, did);
2174                                         isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN, ECMD_TERMINATE, 0);
2175                                         return;
2176                                 }
2177                         }
2178                         isp_prt(isp, ISP_LOGWARN, "%s: [RX_ID 0x%x] D_ID %x not found on any channel- deferring", __func__, aep->at_rxid, did);
2179                         goto noresrc;
2180                 }
2181                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: [RX_ID 0x%x] D_ID 0x%06x found on Chan %d for S_ID 0x%06x", __func__, aep->at_rxid, did, chan, sid);
2182         } else {
2183                 chan = 0;
2184         }
2185
2186         /*
2187          * Find the PDB entry for this initiator
2188          */
2189         if (isp_find_pdb_by_sid(isp, chan, sid, &lp) == 0) {
2190                 /*
2191                  * If we're not in the port database terminate the exchange.
2192                  */
2193                 isp_prt(isp, ISP_LOGTINFO, "%s: [RX_ID 0x%x] D_ID 0x%06x found on Chan %d for S_ID 0x%06x wasn't in PDB already",
2194                     __func__, aep->at_rxid, did, chan, sid);
2195                 isp_endcmd(isp, aep, NIL_HANDLE, chan, ECMD_TERMINATE, 0);
2196                 return;
2197         }
2198         nphdl = lp->handle;
2199         wwn = lp->port_wwn;
2200
2201         /*
2202          * Get the tstate pointer
2203          */
2204         tptr = get_lun_statep(isp, chan, lun);
2205         if (tptr == NULL) {
2206                 tptr = get_lun_statep(isp, chan, CAM_LUN_WILDCARD);
2207                 if (tptr == NULL) {
2208                         isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] no state pointer for lun %d or wildcard", aep->at_rxid, lun);
2209                         isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_CHECK_COND | ECMD_SVALID | (0x5 << 12) | (0x25 << 16), 0);
2210                         return;
2211                 }
2212         }
2213
2214         /*
2215          * Start any commands pending resources first.
2216          */
2217         if (tptr->restart_queue) {
2218                 inot_private_data_t *restart_queue = tptr->restart_queue;
2219                 tptr->restart_queue = NULL;
2220                 while (restart_queue) {
2221                         ntp = restart_queue;
2222                         restart_queue = ntp->rd.nt.nt_hba;
2223                         isp_prt(isp, ISP_LOGTDEBUG0, "%s: restarting resrc deprived %x", __func__, ((at7_entry_t *)ntp->rd.data)->at_rxid);
2224                         isp_handle_platform_atio7(isp, (at7_entry_t *) ntp->rd.data);
2225                         isp_put_ntpd(isp, tptr, ntp);
2226                         /*
2227                          * If a recursion caused the restart queue to start to fill again,
2228                          * stop and splice the new list on top of the old list and restore
2229                          * it and go to noresrc.
2230                          */
2231                         if (tptr->restart_queue) {
2232                                 if (restart_queue) {
2233                                         ntp = tptr->restart_queue;
2234                                         tptr->restart_queue = restart_queue;
2235                                         while (restart_queue->rd.nt.nt_hba) {
2236                                                 restart_queue = restart_queue->rd.nt.nt_hba;
2237                                         }
2238                                         restart_queue->rd.nt.nt_hba = ntp;
2239                                 }
2240                                 goto noresrc;
2241                         }
2242                 }
2243         }
2244
2245         /*
2246          * If the f/w is out of resources, just send a BUSY status back.
2247          */
2248         if (aep->at_rxid == AT7_NORESRC_RXID) {
2249                 rls_lun_statep(isp, tptr);
2250                 isp_endcmd(isp, aep, nphdl, chan, SCSI_BUSY, 0);
2251                 return;
2252         }
2253
2254         /*
2255          * If we're out of resources, just send a BUSY status back.
2256          */
2257         atiop = (struct ccb_accept_tio *) SLIST_FIRST(&tptr->atios);
2258         if (atiop == NULL) {
2259                 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atios", aep->at_rxid);
2260                 goto noresrc;
2261         }
2262
2263         atp = isp_get_atpd(isp, tptr, 0);
2264         if (atp == NULL) {
2265                 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] out of atps", aep->at_rxid);
2266                 goto noresrc;
2267         }
2268         if (isp_get_atpd(isp, tptr, aep->at_rxid)) {
2269                 isp_prt(isp, ISP_LOGTDEBUG0, "[0x%x] tag wraparound in isp_handle_platforms_atio7 (N-Port Handle 0x%04x S_ID 0x%04x OX_ID 0x%04x)\n",
2270                     aep->at_rxid, nphdl, sid, aep->at_hdr.ox_id);
2271                 /*
2272                  * It's not a "no resource" condition- but we can treat it like one
2273                  */
2274                 goto noresrc;
2275         }
2276
2277         atp->tag = aep->at_rxid;
2278         atp->state = ATPD_STATE_ATIO;
2279         SLIST_REMOVE_HEAD(&tptr->atios, sim_links.sle);
2280         tptr->atio_count--;
2281         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, atiop->ccb_h.path, "Take FREE ATIO count now %d\n", tptr->atio_count);
2282         atiop->init_id = nphdl;
2283         atiop->ccb_h.target_id = FCPARAM(isp, chan)->isp_loopid;
2284         atiop->ccb_h.target_lun = lun;
2285         atiop->sense_len = 0;
2286         cdbxlen = aep->at_cmnd.fcp_cmnd_alen_datadir >> FCP_CMND_ADDTL_CDBLEN_SHIFT;
2287         if (cdbxlen) {
2288                 isp_prt(isp, ISP_LOGWARN, "additional CDBLEN ignored");
2289         }
2290         cdbxlen = sizeof (aep->at_cmnd.cdb_dl.sf.fcp_cmnd_cdb);
2291         ISP_MEMCPY(atiop->cdb_io.cdb_bytes, aep->at_cmnd.cdb_dl.sf.fcp_cmnd_cdb, cdbxlen);
2292         atiop->cdb_len = cdbxlen;
2293         atiop->ccb_h.status = CAM_CDB_RECVD;
2294         atiop->tag_id = atp->tag;
2295         switch (aep->at_cmnd.fcp_cmnd_task_attribute & FCP_CMND_TASK_ATTR_MASK) {
2296         case FCP_CMND_TASK_ATTR_SIMPLE:
2297                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2298                 atiop->tag_action = MSG_SIMPLE_Q_TAG;
2299                 break;
2300         case FCP_CMND_TASK_ATTR_HEAD:
2301                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2302                 atiop->tag_action = MSG_HEAD_OF_Q_TAG;
2303                 break;
2304         case FCP_CMND_TASK_ATTR_ORDERED:
2305                 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID;
2306                 atiop->tag_action = MSG_ORDERED_Q_TAG;
2307                 break;
2308         default:
2309                 /* FALLTHROUGH */
2310         case FCP_CMND_TASK_ATTR_ACA:
2311         case FCP_CMND_TASK_ATTR_UNTAGGED:
2312                 atiop->tag_action = 0;
2313                 break;
2314         }
2315         atp->orig_datalen = aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl;
2316         atp->bytes_xfered = 0;
2317         atp->last_xframt = 0;
2318         atp->lun = lun;
2319         atp->nphdl = nphdl;
2320         atp->portid = sid;
2321         atp->oxid = aep->at_hdr.ox_id;
2322         atp->cdb0 = atiop->cdb_io.cdb_bytes[0];
2323         atp->tattr = aep->at_cmnd.fcp_cmnd_task_attribute & FCP_CMND_TASK_ATTR_MASK;
2324         atp->state = ATPD_STATE_CAM;
2325         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, tptr->owner, "ATIO7[%x] CDB=0x%x lun %d datalen %u\n", aep->at_rxid, atp->cdb0, lun, atp->orig_datalen);
2326         xpt_done((union ccb *)atiop);
2327         rls_lun_statep(isp, tptr);
2328         return;
2329 noresrc:
2330         if (atp) {
2331                 isp_put_atpd(isp, tptr, atp);
2332         }
2333         ntp = isp_get_ntpd(isp, tptr);
2334         if (ntp == NULL) {
2335                 rls_lun_statep(isp, tptr);
2336                 isp_endcmd(isp, aep, nphdl, chan, SCSI_STATUS_BUSY, 0);
2337                 return;
2338         }
2339         memcpy(ntp->rd.data, aep, QENTRY_LEN);
2340         ntp->rd.nt.nt_hba = tptr->restart_queue;
2341         tptr->restart_queue = ntp;
2342         rls_lun_statep(isp, tptr);
2343 }
2344
2345 static void
2346 isp_handle_platform_ctio(ispsoftc_t *isp, void *arg)
2347 {
2348         union ccb *ccb;
2349         int sentstatus, ok, notify_cam, resid = 0;
2350         tstate_t *tptr = NULL;
2351         atio_private_data_t *atp = NULL;
2352         int bus;
2353         uint32_t tval, handle;
2354
2355         /*
2356          * CTIO handles are 16 bits.
2357          * CTIO2 and CTIO7 are 32 bits.
2358          */
2359
2360         if (IS_SCSI(isp)) {
2361                 handle = ((ct_entry_t *)arg)->ct_syshandle;
2362         } else {
2363                 handle = ((ct2_entry_t *)arg)->ct_syshandle;
2364         }
2365         ccb = isp_find_xs_tgt(isp, handle);
2366         if (ccb == NULL) {
2367                 isp_print_bytes(isp, "null ccb in isp_handle_platform_ctio", QENTRY_LEN, arg);
2368                 return;
2369         }
2370         isp_destroy_tgt_handle(isp, handle);
2371         bus = XS_CHANNEL(ccb);
2372         tptr = get_lun_statep(isp, bus, XS_LUN(ccb));
2373         if (tptr == NULL) {
2374                 tptr = get_lun_statep(isp, bus, CAM_LUN_WILDCARD);
2375         }
2376         KASSERT((tptr != NULL), ("cannot get state pointer"));
2377         if (isp->isp_nactive) {
2378                 isp->isp_nactive++;
2379         }
2380         if (IS_24XX(isp)) {
2381                 ct7_entry_t *ct = arg;
2382
2383                 atp = isp_get_atpd(isp, tptr, ct->ct_rxid);
2384                 if (atp == NULL) {
2385                         rls_lun_statep(isp, tptr);
2386                         isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x after I/O", __func__, ct->ct_rxid);
2387                         return;
2388                 }
2389
2390                 sentstatus = ct->ct_flags & CT7_SENDSTATUS;
2391                 ok = (ct->ct_nphdl == CT7_OK);
2392                 if (ok && sentstatus && (ccb->ccb_h.flags & CAM_SEND_SENSE)) {
2393                         ccb->ccb_h.status |= CAM_SENT_SENSE;
2394                 }
2395                 notify_cam = ct->ct_header.rqs_seqno & 0x1;
2396                 if ((ct->ct_flags & CT7_DATAMASK) != CT7_NO_DATA) {
2397                         resid = ct->ct_resid;
2398                         atp->bytes_xfered += (atp->last_xframt - resid);
2399                         atp->last_xframt = 0;
2400                 }
2401                 if (ct->ct_nphdl == CT_HBA_RESET) {
2402                         ok = 0;
2403                         notify_cam = 1;
2404                         sentstatus = 1;
2405                         ccb->ccb_h.status |= CAM_UNREC_HBA_ERROR;
2406                 } else if (!ok) {
2407                         ccb->ccb_h.status |= CAM_REQ_CMP_ERR;
2408                 }
2409                 tval = atp->tag;
2410                 isp_prt(isp, ok? ISP_LOGTDEBUG0 : ISP_LOGWARN, "%s: CTIO7[%x] sts 0x%x flg 0x%x sns %d resid %d %s", __func__,
2411                     ct->ct_rxid, ct->ct_nphdl, ct->ct_flags, (ccb->ccb_h.status & CAM_SENT_SENSE) != 0, resid, sentstatus? "FIN" : "MID");
2412                 atp->state = ATPD_STATE_PDON; /* XXX: should really come after isp_complete_ctio */
2413         } else if (IS_FC(isp)) {
2414                 ct2_entry_t *ct = arg;
2415
2416                 atp = isp_get_atpd(isp, tptr, ct->ct_rxid);
2417                 if (atp == NULL) {
2418                         rls_lun_statep(isp, tptr);
2419                         isp_prt(isp, ISP_LOGERR, "%s: cannot find adjunct for %x after I/O", __func__, ct->ct_rxid);
2420                         return;
2421                 }
2422                 sentstatus = ct->ct_flags & CT2_SENDSTATUS;
2423                 ok = (ct->ct_status & ~QLTM_SVALID) == CT_OK;
2424                 if (ok && sentstatus && (ccb->ccb_h.flags & CAM_SEND_SENSE)) {
2425                         ccb->ccb_h.status |= CAM_SENT_SENSE;
2426                 }
2427                 notify_cam = ct->ct_header.rqs_seqno & 0x1;
2428                 if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
2429                         resid = ct->ct_resid;
2430                         atp->bytes_xfered += (atp->last_xframt - resid);
2431                         atp->last_xframt = 0;
2432                 }
2433                 if (ct->ct_status == CT_HBA_RESET) {
2434                         ok = 0;
2435                         notify_cam = 1;
2436                         sentstatus = 1;
2437                         ccb->ccb_h.status |= CAM_UNREC_HBA_ERROR;
2438                 } else if (!ok) {
2439                         ccb->ccb_h.status |= CAM_REQ_CMP_ERR;
2440                 }
2441                 isp_prt(isp, ok? ISP_LOGTDEBUG0 : ISP_LOGWARN, "%s: CTIO2[%x] sts 0x%x flg 0x%x sns %d resid %d %s", __func__,
2442                     ct->ct_rxid, ct->ct_status, ct->ct_flags, (ccb->ccb_h.status & CAM_SENT_SENSE) != 0, resid, sentstatus? "FIN" : "MID");
2443                 tval = atp->tag;
2444                 atp->state = ATPD_STATE_PDON; /* XXX: should really come after isp_complete_ctio */
2445         } else {
2446                 ct_entry_t *ct = arg;
2447                 sentstatus = ct->ct_flags & CT_SENDSTATUS;
2448                 ok = (ct->ct_status  & ~QLTM_SVALID) == CT_OK;
2449                 /*
2450                  * We *ought* to be able to get back to the original ATIO
2451                  * here, but for some reason this gets lost. It's just as
2452                  * well because it's squirrelled away as part of periph
2453                  * private data.
2454                  *
2455                  * We can live without it as long as we continue to use
2456                  * the auto-replenish feature for CTIOs.
2457                  */
2458                 notify_cam = ct->ct_header.rqs_seqno & 0x1;
2459                 if (ct->ct_status == (CT_HBA_RESET & 0xff)) {
2460                         ok = 0;
2461                         notify_cam = 1;
2462                         sentstatus = 1;
2463                         ccb->ccb_h.status |= CAM_UNREC_HBA_ERROR;
2464                 } else if (!ok) {
2465                         ccb->ccb_h.status |= CAM_REQ_CMP_ERR;
2466                 } else if (ct->ct_status & QLTM_SVALID) {
2467                         char *sp = (char *)ct;
2468                         sp += CTIO_SENSE_OFFSET;
2469                         ccb->csio.sense_len = min(sizeof (ccb->csio.sense_data), QLTM_SENSELEN);
2470                         ISP_MEMCPY(&ccb->csio.sense_data, sp, ccb->csio.sense_len);
2471                         ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
2472                 }
2473                 if ((ct->ct_flags & CT_DATAMASK) != CT_NO_DATA) {
2474                         resid = ct->ct_resid;
2475                 }
2476                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO[%x] tag %x S_ID 0x%x lun %d sts %x flg %x resid %d %s", __func__,
2477                     ct->ct_fwhandle, ct->ct_tag_val, ct->ct_iid, ct->ct_lun, ct->ct_status, ct->ct_flags, resid, sentstatus? "FIN" : "MID");
2478                 tval = ct->ct_fwhandle;
2479         }
2480         ccb->csio.resid += resid;
2481
2482         /*
2483          * We're here either because intermediate data transfers are done
2484          * and/or the final status CTIO (which may have joined with a
2485          * Data Transfer) is done.
2486          *
2487          * In any case, for this platform, the upper layers figure out
2488          * what to do next, so all we do here is collect status and
2489          * pass information along. Any DMA handles have already been
2490          * freed.
2491          */
2492         if (notify_cam == 0) {
2493                 isp_prt(isp, ISP_LOGTDEBUG0, "  INTER CTIO[0x%x] done", tval);
2494                 return;
2495         }
2496         if (tptr) {
2497                 rls_lun_statep(isp, tptr);
2498         }
2499         isp_prt(isp, ISP_LOGTDEBUG0, "%s CTIO[0x%x] done", (sentstatus)? "  FINAL " : "MIDTERM ", tval);
2500
2501         if (!ok && !IS_24XX(isp)) {
2502                 isp_target_putback_atio(ccb);
2503         } else {
2504                 isp_complete_ctio(ccb);
2505         }
2506 }
2507
2508 static void
2509 isp_handle_platform_notify_scsi(ispsoftc_t *isp, in_entry_t *inot)
2510 {
2511         (void) isp_notify_ack(isp, inot);
2512 }
2513
2514 static void
2515 isp_handle_platform_notify_fc(ispsoftc_t *isp, in_fcentry_t *inp)
2516 {
2517         int needack = 1;
2518         switch (inp->in_status) {
2519         case IN_PORT_LOGOUT:
2520                 /*
2521                  * XXX: Need to delete this initiator's WWN from the database
2522                  * XXX: Need to send this LOGOUT upstream
2523                  */
2524                 isp_prt(isp, ISP_LOGWARN, "port logout of S_ID 0x%x", inp->in_iid);
2525                 break;
2526         case IN_PORT_CHANGED:
2527                 isp_prt(isp, ISP_LOGWARN, "port changed for S_ID 0x%x", inp->in_iid);
2528                 break;
2529         case IN_GLOBAL_LOGO:
2530                 isp_del_all_wwn_entries(isp, 0);
2531                 isp_prt(isp, ISP_LOGINFO, "all ports logged out");
2532                 break;
2533         case IN_ABORT_TASK:
2534         {
2535                 tstate_t *tptr;
2536                 uint16_t lun;
2537                 uint32_t loopid;
2538                 uint64_t wwn;
2539                 atio_private_data_t *atp;
2540                 fcportdb_t *lp;
2541                 struct ccb_immediate_notify *inot = NULL;
2542
2543                 if (ISP_CAP_SCCFW(isp)) {
2544                         lun = inp->in_scclun;
2545                 } else {
2546                         lun = inp->in_lun;
2547                 }
2548                 if (ISP_CAP_2KLOGIN(isp)) {
2549                         loopid = ((in_fcentry_e_t *)inp)->in_iid;
2550                 } else {
2551                         loopid = inp->in_iid;
2552                 }
2553                 if (isp_find_pdb_by_loopid(isp, 0, loopid, &lp)) {
2554                         wwn = lp->port_wwn;
2555                 } else {
2556                         wwn = INI_ANY;
2557                 }
2558                 tptr = get_lun_statep(isp, 0, lun);
2559                 if (tptr == NULL) {
2560                         tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD);
2561                         if (tptr == NULL) {
2562                                 isp_prt(isp, ISP_LOGWARN, "ABORT TASK for lun %u- but no tstate", lun);
2563                                 return;
2564                         }
2565                 }
2566                 atp = isp_get_atpd(isp, tptr, inp->in_seqid);
2567
2568                 if (atp) {
2569                         inot = (struct ccb_immediate_notify *) SLIST_FIRST(&tptr->inots);
2570                         isp_prt(isp, ISP_LOGTDEBUG0, "ABORT TASK RX_ID %x WWN 0x%016llx state %d", inp->in_seqid, (unsigned long long) wwn, atp->state);
2571                         if (inot) {
2572                                 tptr->inot_count--;
2573                                 SLIST_REMOVE_HEAD(&tptr->inots, sim_links.sle);
2574                                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, inot->ccb_h.path, "%s: Take FREE INOT count now %d\n", __func__, tptr->inot_count);
2575                         } else {
2576                                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, tptr->owner, "out of INOT structures\n");
2577                         }
2578                 } else {
2579                         ISP_PATH_PRT(isp, ISP_LOGWARN, tptr->owner, "abort task RX_ID %x from wwn 0x%016llx, state unknown\n", inp->in_seqid, wwn);
2580                 }
2581                 if (inot) {
2582                         isp_notify_t tmp, *nt = &tmp;
2583                         ISP_MEMZERO(nt, sizeof (isp_notify_t));
2584                         nt->nt_hba = isp;
2585                         nt->nt_tgt = FCPARAM(isp, 0)->isp_wwpn;
2586                         nt->nt_wwn = wwn;
2587                         nt->nt_nphdl = loopid;
2588                         nt->nt_sid = PORT_ANY;
2589                         nt->nt_did = PORT_ANY;
2590                         nt->nt_lun = lun;
2591                         nt->nt_need_ack = 1;
2592                         nt->nt_channel = 0;
2593                         nt->nt_ncode = NT_ABORT_TASK;
2594                         nt->nt_lreserved = inot;
2595                         isp_handle_platform_target_tmf(isp, nt);
2596                         needack = 0;
2597                 }
2598                 rls_lun_statep(isp, tptr);
2599                 break;
2600         }
2601         default:
2602                 break;
2603         }
2604         if (needack) {
2605                 (void) isp_notify_ack(isp, inp);
2606         }
2607 }
2608
2609 static void
2610 isp_handle_platform_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *inot)
2611 {
2612         uint16_t nphdl;
2613         uint32_t portid;
2614         fcportdb_t *lp;
2615         uint8_t *ptr = NULL;
2616         uint64_t wwn;
2617
2618         nphdl = inot->in_nphdl;
2619         if (nphdl != NIL_HANDLE) {
2620                 portid = inot->in_portid_hi << 16 | inot->in_portid_lo;
2621         } else {
2622                 portid = PORT_ANY;
2623         }
2624
2625         switch (inot->in_status) {
2626         case IN24XX_ELS_RCVD:
2627         {
2628                 char buf[16], *msg;
2629                 int chan = ISP_GET_VPIDX(isp, inot->in_vpidx);
2630
2631                 /*
2632                  * Note that we're just getting notification that an ELS was received
2633                  * (possibly with some associated information sent upstream). This is
2634                  * *not* the same as being given the ELS frame to accept or reject.
2635                  */
2636                 switch (inot->in_status_subcode) {
2637                 case LOGO:
2638                         msg = "LOGO";
2639                         if (ISP_FW_NEWER_THAN(isp, 4, 0, 25)) {
2640                                 ptr = (uint8_t *)inot;  /* point to unswizzled entry! */
2641                                 wwn =   (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF])   << 56) |
2642                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+1]) << 48) |
2643                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+2]) << 40) |
2644                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+3]) << 32) |
2645                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+4]) << 24) |
2646                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+5]) << 16) |
2647                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+6]) <<  8) |
2648                                         (((uint64_t) ptr[IN24XX_LOGO_WWPN_OFF+7]));
2649                         } else {
2650                                 wwn = INI_ANY;
2651                         }
2652                         isp_del_wwn_entry(isp, chan, wwn, nphdl, portid);
2653                         break;
2654                 case PRLO:
2655                         msg = "PRLO";
2656                         break;
2657                 case PLOGI:
2658                 case PRLI:
2659                         /*
2660                          * Treat PRLI the same as PLOGI and make a database entry for it.
2661                          */
2662                         if (inot->in_status_subcode == PLOGI)
2663                                 msg = "PLOGI";
2664                         else
2665                                 msg = "PRLI";
2666                         if (ISP_FW_NEWER_THAN(isp, 4, 0, 25)) {
2667                                 ptr = (uint8_t *)inot;  /* point to unswizzled entry! */
2668                                 wwn =   (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF])   << 56) |
2669                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+1]) << 48) |
2670                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+2]) << 40) |
2671                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+3]) << 32) |
2672                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+4]) << 24) |
2673                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+5]) << 16) |
2674                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+6]) <<  8) |
2675                                         (((uint64_t) ptr[IN24XX_PLOGI_WWPN_OFF+7]));
2676                         } else {
2677                                 wwn = INI_NONE;
2678                         }
2679                         isp_add_wwn_entry(isp, chan, wwn, nphdl, portid);
2680                         break;
2681                 case PDISC:
2682                         msg = "PDISC";
2683                         break;
2684                 case ADISC:
2685                         msg = "ADISC";
2686                         break;
2687                 default:
2688                         ISP_SNPRINTF(buf, sizeof (buf), "ELS 0x%x", inot->in_status_subcode);
2689                         msg = buf;
2690                         break;
2691                 }
2692                 if (inot->in_flags & IN24XX_FLAG_PUREX_IOCB) {
2693                         isp_prt(isp, ISP_LOGERR, "%s Chan %d ELS N-port handle %x PortID 0x%06x marked as needing a PUREX response", msg, chan, nphdl, portid);
2694                         break;
2695                 }
2696                 isp_prt(isp, ISP_LOGTDEBUG0, "%s Chan %d ELS N-port handle %x PortID 0x%06x RX_ID 0x%x OX_ID 0x%x", msg, chan, nphdl, portid,
2697                     inot->in_rxid, inot->in_oxid);
2698                 (void) isp_notify_ack(isp, inot);
2699                 break;
2700         }
2701
2702         case IN24XX_PORT_LOGOUT:
2703                 ptr = "PORT LOGOUT";
2704                 if (isp_find_pdb_by_loopid(isp, ISP_GET_VPIDX(isp, inot->in_vpidx), nphdl, &lp)) {
2705                         isp_del_wwn_entry(isp, ISP_GET_VPIDX(isp, inot->in_vpidx), lp->port_wwn, nphdl, lp->portid);
2706                 }
2707                 /* FALLTHROUGH */
2708         case IN24XX_PORT_CHANGED:
2709                 if (ptr == NULL) {
2710                         ptr = "PORT CHANGED";
2711                 }
2712                 /* FALLTHROUGH */
2713         case IN24XX_LIP_RESET:
2714                 if (ptr == NULL) {
2715                         ptr = "LIP RESET";
2716                 }
2717                 isp_prt(isp, ISP_LOGINFO, "Chan %d %s (sub-status 0x%x) for N-port handle 0x%x", ISP_GET_VPIDX(isp, inot->in_vpidx), ptr, inot->in_status_subcode, nphdl);
2718
2719                 /*
2720                  * All subcodes here are irrelevant. What is relevant
2721                  * is that we need to terminate all active commands from
2722                  * this initiator (known by N-port handle).
2723                  */
2724                 /* XXX IMPLEMENT XXX */
2725                 (void) isp_notify_ack(isp, inot);
2726                 break;
2727
2728         case IN24XX_LINK_RESET:
2729         case IN24XX_LINK_FAILED:
2730         case IN24XX_SRR_RCVD:
2731         default:
2732                 (void) isp_notify_ack(isp, inot);
2733                 break;
2734         }
2735 }
2736
2737 static int
2738 isp_handle_platform_target_notify_ack(ispsoftc_t *isp, isp_notify_t *mp)
2739 {
2740
2741         if (isp->isp_state != ISP_RUNSTATE) {
2742                 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) acked- h/w not ready (dropping)", mp->nt_ncode, mp->nt_lreserved != NULL);
2743                 return (0);
2744         }
2745
2746         /*
2747          * This case is for a Task Management Function, which shows up as an ATIO7 entry.
2748          */
2749         if (IS_24XX(isp) && mp->nt_lreserved && ((isphdr_t *)mp->nt_lreserved)->rqs_entry_type == RQSTYPE_ATIO) {
2750                 ct7_entry_t local, *cto = &local;
2751                 at7_entry_t *aep = (at7_entry_t *)mp->nt_lreserved;
2752                 fcportdb_t *lp;
2753                 uint32_t sid;
2754                 uint16_t nphdl;
2755
2756                 sid = (aep->at_hdr.s_id[0] << 16) | (aep->at_hdr.s_id[1] << 8) | aep->at_hdr.s_id[2];
2757                 if (isp_find_pdb_by_sid(isp, mp->nt_channel, sid, &lp)) {
2758                         nphdl = lp->handle;
2759                 } else {
2760                         nphdl = NIL_HANDLE;
2761                 }
2762                 ISP_MEMZERO(&local, sizeof (local));
2763                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
2764                 cto->ct_header.rqs_entry_count = 1;
2765                 cto->ct_nphdl = nphdl;
2766                 cto->ct_rxid = aep->at_rxid;
2767                 cto->ct_vpidx = mp->nt_channel;
2768                 cto->ct_iid_lo = sid;
2769                 cto->ct_iid_hi = sid >> 16;
2770                 cto->ct_oxid = aep->at_hdr.ox_id;
2771                 cto->ct_flags = CT7_SENDSTATUS|CT7_NOACK|CT7_NO_DATA|CT7_FLAG_MODE1;
2772                 cto->ct_flags |= (aep->at_ta_len >> 12) << CT7_TASK_ATTR_SHIFT;
2773                 return (isp_target_put_entry(isp, &local));
2774         }
2775
2776         /*
2777          * This case is for a responding to an ABTS frame
2778          */
2779         if (IS_24XX(isp) && mp->nt_lreserved && ((isphdr_t *)mp->nt_lreserved)->rqs_entry_type == RQSTYPE_ABTS_RCVD) {
2780
2781                 /*
2782                  * Overload nt_need_ack here to mark whether we've terminated the associated command.
2783                  */
2784                 if (mp->nt_need_ack) {
2785                         uint8_t storage[QENTRY_LEN];
2786                         ct7_entry_t *cto = (ct7_entry_t *) storage;
2787                         abts_t *abts = (abts_t *)mp->nt_lreserved;
2788
2789                         ISP_MEMZERO(cto, sizeof (ct7_entry_t));
2790                         isp_prt(isp, ISP_LOGTDEBUG0, "%s: [%x] terminating after ABTS received", __func__, abts->abts_rxid_task);
2791                         cto->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
2792                         cto->ct_header.rqs_entry_count = 1;
2793                         cto->ct_nphdl = mp->nt_nphdl;
2794                         cto->ct_rxid = abts->abts_rxid_task;
2795                         cto->ct_iid_lo = mp->nt_sid;
2796                         cto->ct_iid_hi = mp->nt_sid >> 16;
2797                         cto->ct_oxid = abts->abts_ox_id;
2798                         cto->ct_vpidx = mp->nt_channel;
2799                         cto->ct_flags = CT7_NOACK|CT7_TERMINATE;
2800                         if (isp_target_put_entry(isp, cto)) {
2801                                 return (ENOMEM);
2802                         }
2803                         mp->nt_need_ack = 0;
2804                 }
2805                 if (isp_acknak_abts(isp, mp->nt_lreserved, 0) == ENOMEM) {
2806                         return (ENOMEM);
2807                 } else {
2808                         return (0);
2809                 }
2810         }
2811
2812         /*
2813          * Handle logout cases here
2814          */
2815         if (mp->nt_ncode == NT_GLOBAL_LOGOUT) {
2816                 isp_del_all_wwn_entries(isp, mp->nt_channel);
2817         }
2818
2819         if (mp->nt_ncode == NT_LOGOUT) {
2820                 if (!IS_2100(isp) && IS_FC(isp)) {
2821                         isp_del_wwn_entries(isp, mp);
2822                 }
2823         }
2824
2825         /*
2826          * General purpose acknowledgement
2827          */
2828         if (mp->nt_need_ack) {
2829                 isp_prt(isp, ISP_LOGTINFO, "Notify Code 0x%x (qevalid=%d) being acked", mp->nt_ncode, mp->nt_lreserved != NULL);
2830                 return (isp_notify_ack(isp, mp->nt_lreserved));
2831         }
2832         return (0);
2833 }
2834
2835 /*
2836  * Handle task management functions.
2837  *
2838  * We show up here with a notify structure filled out.
2839  *
2840  * The nt_lreserved tag points to the original queue entry
2841  */
2842 static void
2843 isp_handle_platform_target_tmf(ispsoftc_t *isp, isp_notify_t *notify)
2844 {
2845         tstate_t *tptr;
2846         fcportdb_t *lp;
2847         struct ccb_immediate_notify *inot;
2848         inot_private_data_t *ntp = NULL;
2849         lun_id_t lun;
2850
2851         isp_prt(isp, ISP_LOGTDEBUG0, "%s: code 0x%x sid  0x%x tagval 0x%016llx chan %d lun 0x%x", __func__, notify->nt_ncode,
2852             notify->nt_sid, (unsigned long long) notify->nt_tagval, notify->nt_channel, notify->nt_lun);
2853         /*
2854          * NB: This assignment is necessary because of tricky type conversion.
2855          * XXX: This is tricky and I need to check this. If the lun isn't known
2856          * XXX: for the task management function, it does not of necessity follow
2857          * XXX: that it should go up stream to the wildcard listener.
2858          */
2859         if (notify->nt_lun == LUN_ANY) {
2860                 lun = CAM_LUN_WILDCARD;
2861         } else {
2862                 lun = notify->nt_lun;
2863         }
2864         tptr = get_lun_statep(isp, notify->nt_channel, lun);
2865         if (tptr == NULL) {
2866                 tptr = get_lun_statep(isp, notify->nt_channel, CAM_LUN_WILDCARD);
2867                 if (tptr == NULL) {
2868                         isp_prt(isp, ISP_LOGWARN, "%s: no state pointer found for chan %d lun 0x%x", __func__, notify->nt_channel, lun);
2869                         goto bad;
2870                 }
2871         }
2872         inot = (struct ccb_immediate_notify *) SLIST_FIRST(&tptr->inots);
2873         if (inot == NULL) {
2874                 isp_prt(isp, ISP_LOGWARN, "%s: out of immediate notify structures for chan %d lun 0x%x", __func__, notify->nt_channel, lun);
2875                 goto bad;
2876         }
2877
2878         if (isp_find_pdb_by_sid(isp, notify->nt_channel, notify->nt_sid, &lp) == 0) {
2879                 inot->initiator_id = CAM_TARGET_WILDCARD;
2880         } else {
2881                 inot->initiator_id = lp->handle;
2882         }
2883         inot->seq_id = notify->nt_tagval;
2884         inot->tag_id = notify->nt_tagval >> 32;
2885
2886         switch (notify->nt_ncode) {
2887         case NT_ABORT_TASK:
2888                 isp_target_mark_aborted_early(isp, tptr, inot->tag_id);
2889                 inot->arg = MSG_ABORT_TASK;
2890                 break;
2891         case NT_ABORT_TASK_SET:
2892                 isp_target_mark_aborted_early(isp, tptr, TAG_ANY);
2893                 inot->arg = MSG_ABORT_TASK_SET;
2894                 break;
2895         case NT_CLEAR_ACA:
2896                 inot->arg = MSG_CLEAR_ACA;
2897                 break;
2898         case NT_CLEAR_TASK_SET:
2899                 inot->arg = MSG_CLEAR_TASK_SET;
2900                 break;
2901         case NT_LUN_RESET:
2902                 inot->arg = MSG_LOGICAL_UNIT_RESET;
2903                 break;
2904         case NT_TARGET_RESET:
2905                 inot->arg = MSG_TARGET_RESET;
2906                 break;
2907         default:
2908                 isp_prt(isp, ISP_LOGWARN, "%s: unknown TMF code 0x%x for chan %d lun 0x%x", __func__, notify->nt_ncode, notify->nt_channel, lun);
2909                 goto bad;
2910         }
2911
2912         ntp = isp_get_ntpd(isp, tptr);
2913         if (ntp == NULL) {
2914                 isp_prt(isp, ISP_LOGWARN, "%s: out of inotify private structures", __func__);
2915                 goto bad;
2916         }
2917         ISP_MEMCPY(&ntp->rd.nt, notify, sizeof (isp_notify_t));
2918         if (notify->nt_lreserved) {
2919                 ISP_MEMCPY(&ntp->rd.data, notify->nt_lreserved, QENTRY_LEN);
2920                 ntp->rd.nt.nt_lreserved = &ntp->rd.data;
2921         }
2922         ntp->rd.seq_id = notify->nt_tagval;
2923         ntp->rd.tag_id = notify->nt_tagval >> 32;
2924
2925         tptr->inot_count--;
2926         SLIST_REMOVE_HEAD(&tptr->inots, sim_links.sle);
2927         rls_lun_statep(isp, tptr);
2928         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, inot->ccb_h.path, "%s: Take FREE INOT count now %d\n", __func__, tptr->inot_count);
2929         inot->ccb_h.status = CAM_MESSAGE_RECV;
2930         xpt_done((union ccb *)inot);
2931         return;
2932 bad:
2933         if (tptr) {
2934                 rls_lun_statep(isp, tptr);
2935         }
2936         if (notify->nt_need_ack && notify->nt_lreserved) {
2937                 if (((isphdr_t *)notify->nt_lreserved)->rqs_entry_type == RQSTYPE_ABTS_RCVD) {
2938                         (void) isp_acknak_abts(isp, notify->nt_lreserved, ENOMEM);
2939                 } else {
2940                         (void) isp_notify_ack(isp, notify->nt_lreserved);
2941                 }
2942         }
2943 }
2944
2945 /*
2946  * Find the associated private data and mark it as dead so
2947  * we don't try to work on it any further.
2948  */
2949 static void
2950 isp_target_mark_aborted(ispsoftc_t *isp, union ccb *ccb)
2951 {
2952         tstate_t *tptr;
2953         atio_private_data_t *atp;
2954
2955         tptr = get_lun_statep(isp, XS_CHANNEL(ccb), XS_LUN(ccb));
2956         if (tptr == NULL) {
2957                 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), CAM_LUN_WILDCARD);
2958                 if (tptr == NULL) {
2959                         ccb->ccb_h.status = CAM_REQ_INVALID;
2960                         return;
2961                 }
2962         }
2963
2964         atp = isp_get_atpd(isp, tptr, ccb->atio.tag_id);
2965         if (atp == NULL) {
2966                 ccb->ccb_h.status = CAM_REQ_INVALID;
2967                 return;
2968         }
2969         atp->dead = 1;
2970         ccb->ccb_h.status = CAM_REQ_CMP;
2971 }
2972
2973 static void
2974 isp_target_mark_aborted_early(ispsoftc_t *isp, tstate_t *tptr, uint32_t tag_id)
2975 {
2976         atio_private_data_t *atp;
2977         inot_private_data_t *restart_queue = tptr->restart_queue;
2978
2979         /*
2980          * First, clean any commands pending restart
2981          */
2982         tptr->restart_queue = NULL;
2983         while (restart_queue) {
2984                 uint32_t this_tag_id;
2985                 inot_private_data_t *ntp = restart_queue;
2986
2987                 restart_queue = ntp->rd.nt.nt_hba;
2988
2989                 if (IS_24XX(isp)) {
2990                         this_tag_id = ((at7_entry_t *)ntp->rd.data)->at_rxid;
2991                 } else {
2992                         this_tag_id = ((at2_entry_t *)ntp->rd.data)->at_rxid;
2993                 }
2994                 if ((uint64_t)tag_id == TAG_ANY || tag_id == this_tag_id) {
2995                         isp_put_ntpd(isp, tptr, ntp);
2996                 } else {
2997                         ntp->rd.nt.nt_hba = tptr->restart_queue;
2998                         tptr->restart_queue = ntp;
2999                 }
3000         }
3001
3002         /*
3003          * Now mark other ones dead as well.
3004          */
3005         for (atp = tptr->atpool; atp < &tptr->atpool[ATPDPSIZE]; atp++) {
3006                 if ((uint64_t)tag_id == TAG_ANY || atp->tag == tag_id) {
3007                         atp->dead = 1;
3008                 }
3009         }
3010 }
3011
3012
3013 #ifdef  ISP_INTERNAL_TARGET
3014 // #define      ISP_FORCE_TIMEOUT               1
3015 // #define      ISP_TEST_WWNS                   1
3016 // #define      ISP_TEST_SEPARATE_STATUS        1
3017
3018 #define ccb_data_offset         ppriv_field0
3019 #define ccb_atio                ppriv_ptr1
3020 #define ccb_inot                ppriv_ptr1
3021
3022 #define MAX_ISP_TARG_TRANSFER   (2 << 20)
3023 #define NISP_TARG_CMDS          1024
3024 #define NISP_TARG_NOTIFIES      1024
3025 #define DISK_SHIFT              9
3026 #define JUNK_SIZE               256
3027
3028 #ifndef VERIFY_10
3029 #define VERIFY_10       0x2f
3030 #endif
3031
3032 TAILQ_HEAD(ccb_queue, ccb_hdr);
3033 extern u_int vm_kmem_size;
3034 static int ca;
3035 static uint32_t disk_size;
3036 static uint8_t *disk_data = NULL;
3037 static uint8_t *junk_data;
3038 static MALLOC_DEFINE(M_ISPTARG, "ISPTARG", "ISP TARGET data");
3039 struct isptarg_softc {
3040         /* CCBs (CTIOs, ATIOs, INOTs) pending on the controller */
3041         struct ccb_queue        work_queue;
3042         struct ccb_queue        rework_queue;
3043         struct ccb_queue        running_queue;
3044         struct ccb_queue        inot_queue;
3045         struct cam_periph       *periph;
3046         struct cam_path         *path;
3047         ispsoftc_t              *isp;
3048 };
3049 static periph_ctor_t    isptargctor;
3050 static periph_dtor_t    isptargdtor;
3051 static periph_start_t   isptargstart;
3052 static periph_init_t    isptarginit;
3053 static void             isptarg_done(struct cam_periph *, union ccb *);
3054 static void             isptargasync(void *, u_int32_t, struct cam_path *, void *);
3055
3056
3057 static int isptarg_rwparm(uint8_t *, uint8_t *, uint64_t, uint32_t, uint8_t **, uint32_t *, int *);
3058
3059 static struct periph_driver isptargdriver =
3060 {
3061         isptarginit, "isptarg", TAILQ_HEAD_INITIALIZER(isptargdriver.units), /* generation */ 0
3062 };
3063
3064 static void
3065 isptarginit(void)
3066 {
3067 }
3068
3069 static void
3070 isptargnotify(ispsoftc_t *isp, union ccb *iccb, struct ccb_immediate_notify *inot)
3071 {
3072         struct ccb_notify_acknowledge *ack = &iccb->cna2;
3073
3074         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, inot->ccb_h.path, "%s: [0x%x] immediate notify for 0x%x from 0x%x status 0x%x arg 0x%x\n", __func__,
3075             inot->tag_id, inot->initiator_id, inot->seq_id, inot->ccb_h.status, inot->arg);
3076         ack->ccb_h.func_code = XPT_NOTIFY_ACKNOWLEDGE;
3077         ack->ccb_h.flags = 0;
3078         ack->ccb_h.retry_count = 0;
3079         ack->ccb_h.cbfcnp = isptarg_done;
3080         ack->ccb_h.timeout = 0;
3081         ack->ccb_h.ccb_inot = inot;
3082         ack->tag_id = inot->tag_id;
3083         ack->seq_id = inot->seq_id;
3084         ack->initiator_id = inot->initiator_id;
3085         xpt_action(iccb);
3086 }
3087
3088 static void
3089 isptargstart(struct cam_periph *periph, union ccb *iccb)
3090 {
3091         const uint8_t niliqd[SHORT_INQUIRY_LENGTH] = {
3092                 0x7f, 0x0, 0x5, 0x2, 32, 0, 0, 0x32,
3093                 'F', 'R', 'E', 'E', 'B', 'S', 'D', ' ',
3094                 'S', 'C', 'S', 'I', ' ', 'N', 'U', 'L',
3095                 'L', ' ', 'D', 'E', 'V', 'I', 'C', 'E',
3096                 '0', '0', '0', '1'
3097         };
3098         const uint8_t iqd[SHORT_INQUIRY_LENGTH] = {
3099                 0, 0x0, 0x5, 0x2, 32, 0, 0, 0x32,
3100                 'F', 'R', 'E', 'E', 'B', 'S', 'D', ' ',
3101                 'S', 'C', 'S', 'I', ' ', 'M', 'E', 'M',
3102                 'O', 'R', 'Y', ' ', 'D', 'I', 'S', 'K',
3103                 '0', '0', '0', '1'
3104         };
3105         int i, more = 0, last;
3106         struct isptarg_softc *softc = periph->softc;
3107         struct ccb_scsiio *csio;
3108         lun_id_t return_lun;
3109         struct ccb_accept_tio *atio;
3110         uint8_t *cdb, *ptr, status;
3111         uint8_t *data_ptr;
3112         uint32_t data_len, flags;
3113         struct ccb_hdr *ccbh;
3114
3115         KKASSERT(lockstatus(periph->sim->mtx, curthread) != 0);
3116         ISP_PATH_PRT(softc->isp, ISP_LOGTDEBUG0, iccb->ccb_h.path, "%s: function code 0x%x INOTQ=%c WORKQ=%c REWORKQ=%c\n", __func__, iccb->ccb_h.func_code,
3117             TAILQ_FIRST(&softc->inot_queue)? 'y' : 'n', TAILQ_FIRST(&softc->work_queue)? 'y' : 'n', TAILQ_FIRST(&softc->rework_queue)? 'y' : 'n');
3118         /*
3119          * Check for immediate notifies first
3120          */
3121         ccbh = TAILQ_FIRST(&softc->inot_queue);
3122         if (ccbh) {
3123                 TAILQ_REMOVE(&softc->inot_queue, ccbh, periph_links.tqe);
3124                 if (TAILQ_FIRST(&softc->inot_queue) || TAILQ_FIRST(&softc->work_queue) || TAILQ_FIRST(&softc->rework_queue)) {
3125                         xpt_schedule(periph, 1);
3126                 }
3127                 isptargnotify(softc->isp, iccb, (struct ccb_immediate_notify *)ccbh);
3128                 return;
3129         }
3130
3131         /*
3132          * Check the rework (continuation) work queue first.
3133          */
3134         ccbh = TAILQ_FIRST(&softc->rework_queue);
3135         if (ccbh) {
3136                 atio = (struct ccb_accept_tio *)ccbh;
3137                 TAILQ_REMOVE(&softc->rework_queue, ccbh, periph_links.tqe);
3138                 more = TAILQ_FIRST(&softc->work_queue) || TAILQ_FIRST(&softc->rework_queue);
3139         } else {
3140                 ccbh = TAILQ_FIRST(&softc->work_queue);
3141                 if (ccbh == NULL) {
3142                         ISP_PATH_PRT(softc->isp, ISP_LOGTDEBUG0, iccb->ccb_h.path, "%s: woken up but no work?\n", __func__);
3143                         xpt_release_ccb(iccb);
3144                         return;
3145                 }
3146                 atio = (struct ccb_accept_tio *)ccbh;
3147                 TAILQ_REMOVE(&softc->work_queue, ccbh, periph_links.tqe);
3148                 more = TAILQ_FIRST(&softc->work_queue) != NULL;
3149                 atio->ccb_h.ccb_data_offset = 0;
3150         }
3151
3152         if (atio->tag_id == 0xffffffff || atio->ccb_h.func_code != XPT_ACCEPT_TARGET_IO) {
3153                 panic("BAD ATIO");
3154         }
3155
3156         data_ptr = NULL;
3157         data_len = 0;
3158         csio = &iccb->csio;
3159         status = SCSI_STATUS_OK;
3160         flags = CAM_SEND_STATUS;
3161         memset(&atio->sense_data, 0, sizeof (atio->sense_data));
3162         cdb = atio->cdb_io.cdb_bytes;
3163         ISP_PATH_PRT(softc->isp, ISP_LOGTDEBUG0, ccbh->path, "%s: [0x%x] processing ATIO from 0x%x CDB=0x%x data_offset=%u\n", __func__, atio->tag_id, atio->init_id,
3164             cdb[0], atio->ccb_h.ccb_data_offset);
3165
3166         return_lun = XS_LUN(atio);
3167         if (return_lun != 0) {
3168                 xpt_print(atio->ccb_h.path, "[0x%x] Non-Zero Lun %d: cdb0=0x%x\n", atio->tag_id, return_lun, cdb[0]);
3169                 if (cdb[0] != INQUIRY && cdb[0] != REPORT_LUNS && cdb[0] != REQUEST_SENSE) {
3170                         status = SCSI_STATUS_CHECK_COND;
3171                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_ILLEGAL_REQUEST;
3172                         atio->sense_data.add_sense_code = 0x25;
3173                         atio->sense_data.add_sense_code_qual = 0x0;
3174                         atio->sense_len = sizeof (atio->sense_data);
3175                 }
3176                 return_lun = CAM_LUN_WILDCARD;
3177         }
3178
3179         switch (cdb[0]) {
3180         case REQUEST_SENSE:
3181                 flags |= CAM_DIR_IN;
3182                 data_len = sizeof (atio->sense_data);
3183                 junk_data[0] = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_NO_SENSE;
3184                 memset(junk_data+1, 0, data_len-1);
3185                 if (data_len > cdb[4]) {
3186                         data_len = cdb[4];
3187                 }
3188                 if (data_len) {
3189                         data_ptr = junk_data;
3190                 }
3191                 break;
3192         case READ_6:
3193         case READ_10:
3194         case READ_12:
3195         case READ_16:
3196                 if (isptarg_rwparm(cdb, disk_data, disk_size, atio->ccb_h.ccb_data_offset, &data_ptr, &data_len, &last)) {
3197                         status = SCSI_STATUS_CHECK_COND;
3198                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3199                         atio->sense_data.add_sense_code = 0x5;
3200                         atio->sense_data.add_sense_code_qual = 0x24;
3201                         atio->sense_len = sizeof (atio->sense_data);
3202                 } else {
3203 #ifdef  ISP_FORCE_TIMEOUT
3204                         {
3205                                 static int foo;
3206                                 if (foo++ == 500) {
3207                                         if (more) {
3208                                                 xpt_schedule(periph, 1);
3209                                         }
3210                                         foo = 0;
3211                                         return;
3212                                 }
3213                         }
3214 #endif
3215 #ifdef  ISP_TEST_SEPARATE_STATUS
3216                         if (last && data_len) {
3217                                 last = 0;
3218                         }
3219 #endif
3220                         if (last == 0) {
3221                                 flags &= ~CAM_SEND_STATUS;
3222                         }
3223                         if (data_len) {
3224                                 atio->ccb_h.ccb_data_offset += data_len;
3225                                 flags |= CAM_DIR_IN;
3226                         } else {
3227                                 flags |= CAM_DIR_NONE;
3228                         }
3229                 }
3230                 break;
3231         case WRITE_6:
3232         case WRITE_10:
3233         case WRITE_12:
3234         case WRITE_16:
3235                 if (isptarg_rwparm(cdb, disk_data, disk_size, atio->ccb_h.ccb_data_offset, &data_ptr, &data_len, &last)) {
3236                         status = SCSI_STATUS_CHECK_COND;
3237                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3238                         atio->sense_data.add_sense_code = 0x5;
3239                         atio->sense_data.add_sense_code_qual = 0x24;
3240                         atio->sense_len = sizeof (atio->sense_data);
3241                 } else {
3242 #ifdef  ISP_FORCE_TIMEOUT
3243                         {
3244                                 static int foo;
3245                                 if (foo++ == 500) {
3246                                         if (more) {
3247                                                 xpt_schedule(periph, 1);
3248                                         }
3249                                         foo = 0;
3250                                         return;
3251                                 }
3252                         }
3253 #endif
3254 #ifdef  ISP_TEST_SEPARATE_STATUS
3255                         if (last && data_len) {
3256                                 last = 0;
3257                         }
3258 #endif
3259                         if (last == 0) {
3260                                 flags &= ~CAM_SEND_STATUS;
3261                         }
3262                         if (data_len) {
3263                                 atio->ccb_h.ccb_data_offset += data_len;
3264                                 flags |= CAM_DIR_OUT;
3265                         } else {
3266                                 flags |= CAM_DIR_NONE;
3267                         }
3268                 }
3269                 break;
3270         case INQUIRY:
3271                 flags |= CAM_DIR_IN;
3272                 if (cdb[1] || cdb[2] || cdb[3]) {
3273                         status = SCSI_STATUS_CHECK_COND;
3274                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3275                         atio->sense_data.add_sense_code = 0x5;
3276                         atio->sense_data.add_sense_code_qual = 0x20;
3277                         atio->sense_len = sizeof (atio->sense_data);
3278                         break;
3279                 }
3280                 data_len = sizeof (iqd);
3281                 if (data_len > cdb[4]) {
3282                         data_len = cdb[4];
3283                 }
3284                 if (data_len) {
3285                         if (XS_LUN(iccb) != 0) {
3286                                 memcpy(junk_data, niliqd, sizeof (iqd));
3287                         } else {
3288                                 memcpy(junk_data, iqd, sizeof (iqd));
3289                         }
3290                         data_ptr = junk_data;
3291                 }
3292                 break;
3293         case TEST_UNIT_READY:
3294                 flags |= CAM_DIR_NONE;
3295                 if (ca) {
3296                         ca = 0;
3297                         status = SCSI_STATUS_CHECK_COND;
3298                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3299                         atio->sense_data.add_sense_code = 0x28;
3300                         atio->sense_data.add_sense_code_qual = 0x0;
3301                         atio->sense_len = sizeof (atio->sense_data);
3302                 }
3303                 break;
3304         case SYNCHRONIZE_CACHE:
3305         case START_STOP:
3306         case RESERVE:
3307         case RELEASE:
3308         case VERIFY_10:
3309                 flags |= CAM_DIR_NONE;
3310                 break;
3311
3312         case READ_CAPACITY:
3313                 flags |= CAM_DIR_IN;
3314                 if (cdb[2] || cdb[3] || cdb[4] || cdb[5]) {
3315                         status = SCSI_STATUS_CHECK_COND;
3316                         atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3317                         atio->sense_data.add_sense_code = 0x5;
3318                         atio->sense_data.add_sense_code_qual = 0x24;
3319                         atio->sense_len = sizeof (atio->sense_data);
3320                         break;
3321                 }
3322                 if (cdb[8] & 0x1) { /* PMI */
3323                         junk_data[0] = 0xff;
3324                         junk_data[1] = 0xff;
3325                         junk_data[2] = 0xff;
3326                         junk_data[3] = 0xff;
3327                 } else {
3328                         uint64_t last_blk = (disk_size >> DISK_SHIFT) - 1;
3329                         if (last_blk < 0xffffffffULL) {
3330                             junk_data[0] = (last_blk >> 24) & 0xff;
3331                             junk_data[1] = (last_blk >> 16) & 0xff;
3332                             junk_data[2] = (last_blk >>  8) & 0xff;
3333                             junk_data[3] = (last_blk) & 0xff;
3334                         } else {
3335                             junk_data[0] = 0xff;
3336                             junk_data[1] = 0xff;
3337                             junk_data[2] = 0xff;
3338                             junk_data[3] = 0xff;
3339                         }
3340                 }
3341                 junk_data[4] = ((1 << DISK_SHIFT) >> 24) & 0xff;
3342                 junk_data[5] = ((1 << DISK_SHIFT) >> 16) & 0xff;
3343                 junk_data[6] = ((1 << DISK_SHIFT) >>  8) & 0xff;
3344                 junk_data[7] = ((1 << DISK_SHIFT)) & 0xff;
3345                 data_ptr = junk_data;
3346                 data_len = 8;
3347                 break;
3348         case REPORT_LUNS:
3349                 flags |= CAM_DIR_IN;
3350                 memset(junk_data, 0, JUNK_SIZE);
3351                 junk_data[0] = (1 << 3) >> 24;
3352                 junk_data[1] = (1 << 3) >> 16;
3353                 junk_data[2] = (1 << 3) >> 8;
3354                 junk_data[3] = (1 << 3);
3355                 ptr = NULL;
3356                 for (i = 0; i < 1; i++) {
3357                         ptr = &junk_data[8 + (1 << 3)];
3358                         if (i >= 256) {
3359                                 ptr[0] = 0x40 | ((i >> 8) & 0x3f);
3360                         }
3361                         ptr[1] = i;
3362                 }
3363                 data_ptr = junk_data;
3364                 data_len = (ptr + 8) - junk_data;
3365                 break;
3366
3367         default:
3368                 flags |= CAM_DIR_NONE;
3369                 status = SCSI_STATUS_CHECK_COND;
3370                 atio->sense_data.error_code = SSD_ERRCODE_VALID|SSD_CURRENT_ERROR|SSD_KEY_UNIT_ATTENTION;
3371                 atio->sense_data.add_sense_code = 0x5;
3372                 atio->sense_data.add_sense_code_qual = 0x20;
3373                 atio->sense_len = sizeof (atio->sense_data);
3374                 break;
3375         }
3376
3377         /*
3378          * If we are done with the transaction, tell the
3379          * controller to send status and perform a CMD_CMPLT.
3380          * If we have associated sense data, see if we can
3381          * send that too.
3382          */
3383         if (status == SCSI_STATUS_CHECK_COND) {
3384                 flags |= CAM_SEND_SENSE;
3385                 csio->sense_len = atio->sense_len;
3386                 csio->sense_data = atio->sense_data;
3387                 flags &= ~CAM_DIR_MASK;
3388                 data_len = 0;
3389                 data_ptr = NULL;
3390         }
3391         cam_fill_ctio(csio, 0, isptarg_done, flags, MSG_SIMPLE_Q_TAG, atio->tag_id, atio->init_id, status, data_ptr, data_len, 0);
3392         iccb->ccb_h.target_id = atio->ccb_h.target_id;
3393         iccb->ccb_h.target_lun = return_lun;
3394         iccb->ccb_h.ccb_atio = atio;
3395         xpt_action(iccb);
3396
3397         if ((atio->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3398                 cam_release_devq(periph->path, 0, 0, 0, 0);
3399                 atio->ccb_h.status &= ~CAM_DEV_QFRZN;
3400         }
3401         if (more) {
3402                 xpt_schedule(periph, 1);
3403         }
3404 }
3405
3406 static cam_status
3407 isptargctor(struct cam_periph *periph, void *arg)
3408 {
3409         struct isptarg_softc *softc;
3410
3411         softc = (struct isptarg_softc *)arg;
3412         periph->softc = softc;
3413         softc->periph = periph;
3414         softc->path = periph->path;
3415         ISP_PATH_PRT(softc->isp, ISP_LOGTDEBUG0, periph->path, "%s called\n", __func__);
3416         return (CAM_REQ_CMP);
3417 }
3418
3419 static void
3420 isptargdtor(struct cam_periph *periph)
3421 {
3422         struct isptarg_softc *softc;
3423         softc = (struct isptarg_softc *)periph->softc;
3424         ISP_PATH_PRT(softc->isp, ISP_LOGTDEBUG0, periph->path, "%s called\n", __func__);
3425         softc->periph = NULL;
3426         softc->path = NULL;
3427         periph->softc = NULL;
3428 }
3429
3430 static void
3431 isptarg_done(struct cam_periph *periph, union ccb *ccb)
3432 {
3433         struct isptarg_softc *softc;
3434         ispsoftc_t *isp;
3435         struct ccb_accept_tio *atio;
3436         struct ccb_immediate_notify *inot;
3437         cam_status status;
3438
3439         softc = (struct isptarg_softc *)periph->softc;
3440         isp = softc->isp;
3441         status = ccb->ccb_h.status & CAM_STATUS_MASK;
3442
3443         switch (ccb->ccb_h.func_code) {
3444         case XPT_ACCEPT_TARGET_IO:
3445                 atio = (struct ccb_accept_tio *) ccb;
3446                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "[0x%x] ATIO seen in %s\n", atio->tag_id, __func__);
3447                 TAILQ_INSERT_TAIL(&softc->work_queue, &ccb->ccb_h, periph_links.tqe);
3448                 xpt_schedule(periph, 1);
3449                 break;
3450         case XPT_IMMEDIATE_NOTIFY:
3451                 inot = (struct ccb_immediate_notify *) ccb;
3452                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "[0x%x] INOT for 0x%x seen in %s\n", inot->tag_id, inot->seq_id, __func__);
3453                 TAILQ_INSERT_TAIL(&softc->inot_queue, &ccb->ccb_h, periph_links.tqe);
3454                 xpt_schedule(periph, 1);
3455                 break;
3456         case XPT_CONT_TARGET_IO:
3457                 if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3458                         cam_release_devq(ccb->ccb_h.path, 0, 0, 0, 0);
3459                         ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
3460                 }
3461                 atio = ccb->ccb_h.ccb_atio;
3462                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3463                         cam_error_print(ccb, CAM_ESF_ALL, CAM_EPF_ALL);
3464                         xpt_action((union ccb *)atio);
3465                 } else if ((ccb->ccb_h.flags & CAM_SEND_STATUS) == 0) {
3466                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "[0x%x] MID CTIO seen in %s\n", atio->tag_id, __func__);
3467                         TAILQ_INSERT_TAIL(&softc->rework_queue, &atio->ccb_h, periph_links.tqe);
3468                         xpt_schedule(periph, 1);
3469                 } else {
3470                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "[0x%x] FINAL CTIO seen in %s\n", atio->tag_id, __func__);
3471                         xpt_action((union ccb *)atio);
3472                 }
3473                 xpt_release_ccb(ccb);
3474                 break;
3475         case XPT_NOTIFY_ACKNOWLEDGE:
3476                 if ((ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
3477                         cam_release_devq(ccb->ccb_h.path, 0, 0, 0, 0);
3478                         ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
3479                 }
3480                 inot = ccb->ccb_h.ccb_inot;
3481                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, inot->ccb_h.path, "[0x%x] recycle notify for tag 0x%x\n", inot->tag_id, inot->seq_id);
3482                 xpt_release_ccb(ccb);
3483                 xpt_action((union ccb *)inot);
3484                 break;
3485         default:
3486                 xpt_print(ccb->ccb_h.path, "unexpected code 0x%x\n", ccb->ccb_h.func_code);
3487                 break;
3488         }
3489 }
3490
3491 static void
3492 isptargasync(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg)
3493 {
3494         struct ac_contract *acp = arg;
3495         struct ac_device_changed *fc = (struct ac_device_changed *) acp->contract_data;
3496
3497         if (code != AC_CONTRACT) {
3498                 return;
3499         }
3500         xpt_print(path, "0x%016llx Port ID 0x%06x %s\n", (unsigned long long) fc->wwpn, fc->port, fc->arrived? "arrived" : "departed");
3501 }
3502
3503 static void
3504 isp_target_thread(ispsoftc_t *isp, int chan)
3505 {
3506         union ccb *ccb = NULL;
3507         int i;
3508         void *wchan;
3509         cam_status status;
3510         struct isptarg_softc *softc = NULL;
3511         struct cam_periph *periph = NULL, *wperiph = NULL;
3512         struct cam_path *path, *wpath;
3513         struct cam_sim *sim;
3514
3515         if (disk_data == NULL) {
3516                 disk_size = roundup2(vm_kmem_size >> 1, (1ULL << 20));
3517                 if (disk_size < (50 << 20)) {
3518                         disk_size = 50 << 20;
3519                 }
3520                 disk_data = kmalloc(disk_size, M_ISPTARG, M_WAITOK | M_ZERO);
3521                 isp_prt(isp, ISP_LOGINFO, "allocated a %ju MiB disk", (uintmax_t) (disk_size >> 20));
3522         }
3523         junk_data = kmalloc(JUNK_SIZE, M_ISPTARG, M_WAITOK | M_ZERO);
3524
3525
3526         softc = kmalloc(sizeof (*softc), M_ISPTARG, M_WAITOK | M_ZERO);
3527         TAILQ_INIT(&softc->work_queue);
3528         TAILQ_INIT(&softc->rework_queue);
3529         TAILQ_INIT(&softc->running_queue);
3530         TAILQ_INIT(&softc->inot_queue);
3531         softc->isp = isp;
3532
3533         periphdriver_register(&isptargdriver);
3534         ISP_GET_PC(isp, chan, sim, sim);
3535         ISP_GET_PC(isp, chan, path,  path);
3536         status = xpt_create_path_unlocked(&wpath, NULL, cam_sim_path(sim), CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
3537         if (status != CAM_REQ_CMP) {
3538                 isp_prt(isp, ISP_LOGERR, "%s: could not allocate wildcard path", __func__);
3539                 return;
3540         }
3541         status = xpt_create_path_unlocked(&path, NULL, cam_sim_path(sim), 0, 0);
3542         if (status != CAM_REQ_CMP) {
3543                 xpt_free_path(wpath);
3544                 isp_prt(isp, ISP_LOGERR, "%s: could not allocate path", __func__);
3545                 return;
3546         }
3547
3548         ccb = xpt_alloc_ccb();
3549
3550         ISP_LOCK(isp);
3551         status = cam_periph_alloc(isptargctor, NULL, isptargdtor, isptargstart, "isptarg", CAM_PERIPH_BIO, wpath, NULL, 0, softc);
3552         if (status != CAM_REQ_CMP) {
3553                 ISP_UNLOCK(isp);
3554                 isp_prt(isp, ISP_LOGERR, "%s: cam_periph_alloc for wildcard failed", __func__);
3555                 goto out;
3556         }
3557         wperiph = cam_periph_find(wpath, "isptarg");
3558         if (wperiph == NULL) {
3559                 ISP_UNLOCK(isp);
3560                 isp_prt(isp, ISP_LOGERR, "%s: wildcard periph already allocated but doesn't exist", __func__);
3561                 goto out;
3562         }
3563
3564         status = cam_periph_alloc(isptargctor, NULL, isptargdtor, isptargstart, "isptarg", CAM_PERIPH_BIO, path, NULL, 0, softc);
3565         if (status != CAM_REQ_CMP) {
3566                 ISP_UNLOCK(isp);
3567                 isp_prt(isp, ISP_LOGERR, "%s: cam_periph_alloc failed", __func__);
3568                 goto out;
3569         }
3570
3571         periph = cam_periph_find(path, "isptarg");
3572         if (periph == NULL) {
3573                 ISP_UNLOCK(isp);
3574                 isp_prt(isp, ISP_LOGERR, "%s: periph already allocated but doesn't exist", __func__);
3575                 goto out;
3576         }
3577
3578         status = xpt_register_async(AC_CONTRACT, isptargasync, isp, wpath);
3579         if (status != CAM_REQ_CMP) {
3580                 ISP_UNLOCK(isp);
3581                 isp_prt(isp, ISP_LOGERR, "%s: xpt_register_async failed", __func__);
3582                 goto out;
3583         }
3584
3585         ISP_UNLOCK(isp);
3586
3587         ccb = xpt_alloc_ccb();
3588
3589         /*
3590          * Make sure role is none.
3591          */
3592         xpt_setup_ccb(&ccb->ccb_h, periph->path, 10);
3593         ccb->ccb_h.func_code = XPT_SET_SIM_KNOB;
3594         ccb->knob.xport_specific.fc.role = KNOB_ROLE_NONE;
3595 #ifdef  ISP_TEST_WWNS
3596         ccb->knob.xport_specific.fc.valid = KNOB_VALID_ROLE | KNOB_VALID_ADDRESS;
3597         ccb->knob.xport_specific.fc.wwnn = 0x508004d000000000ULL | (device_get_unit(isp->isp_osinfo.dev) << 8) | (chan << 16);
3598         ccb->knob.xport_specific.fc.wwpn = 0x508004d000000001ULL | (device_get_unit(isp->isp_osinfo.dev) << 8) | (chan << 16);
3599 #else
3600         ccb->knob.xport_specific.fc.valid = KNOB_VALID_ROLE;
3601 #endif
3602
3603         ISP_LOCK(isp);
3604         xpt_action(ccb);
3605         ISP_UNLOCK(isp);
3606
3607         /*
3608          * Now enable luns
3609          */
3610         xpt_setup_ccb(&ccb->ccb_h, periph->path, 10);
3611         ccb->ccb_h.func_code = XPT_EN_LUN;
3612         ccb->cel.enable = 1;
3613         ISP_LOCK(isp);
3614         xpt_action(ccb);
3615         ISP_UNLOCK(isp);
3616         if (ccb->ccb_h.status != CAM_REQ_CMP) {
3617                 xpt_free_ccb(ccb);
3618                 xpt_print(periph->path, "failed to enable lun (0x%x)\n", ccb->ccb_h.status);
3619                 goto out;
3620         }
3621
3622         xpt_setup_ccb(&ccb->ccb_h, wperiph->path, 10);
3623         ccb->ccb_h.func_code = XPT_EN_LUN;
3624         ccb->cel.enable = 1;
3625         ISP_LOCK(isp);
3626         xpt_action(ccb);
3627         ISP_UNLOCK(isp);
3628         if (ccb->ccb_h.status != CAM_REQ_CMP) {
3629                 xpt_free_ccb(ccb);
3630                 xpt_print(wperiph->path, "failed to enable lun (0x%x)\n", ccb->ccb_h.status);
3631                 goto out;
3632         }
3633         xpt_free_ccb(ccb);
3634
3635         /*
3636          * Add resources
3637          */
3638         ISP_GET_PC_ADDR(isp, chan, target_proc, wchan);
3639         for (i = 0; i < 4; i++) {
3640                 ccb = kmalloc(sizeof (*ccb), M_ISPTARG, M_WAITOK | M_ZERO);
3641                 xpt_setup_ccb(&ccb->ccb_h, wperiph->path, 1);
3642                 ccb->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
3643                 ccb->ccb_h.cbfcnp = isptarg_done;
3644                 ISP_LOCK(isp);
3645                 xpt_action(ccb);
3646                 ISP_UNLOCK(isp);
3647         }
3648         for (i = 0; i < NISP_TARG_CMDS; i++) {
3649                 ccb = kmalloc(sizeof (*ccb), M_ISPTARG, M_WAITOK | M_ZERO);
3650                 xpt_setup_ccb(&ccb->ccb_h, periph->path, 1);
3651                 ccb->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
3652                 ccb->ccb_h.cbfcnp = isptarg_done;
3653                 ISP_LOCK(isp);
3654                 xpt_action(ccb);
3655                 ISP_UNLOCK(isp);
3656         }
3657         for (i = 0; i < 4; i++) {
3658                 ccb = kmalloc(sizeof (*ccb), M_ISPTARG, M_WAITOK | M_ZERO);
3659                 xpt_setup_ccb(&ccb->ccb_h, wperiph->path, 1);
3660                 ccb->ccb_h.func_code = XPT_IMMEDIATE_NOTIFY;
3661                 ccb->ccb_h.cbfcnp = isptarg_done;
3662                 ISP_LOCK(isp);
3663                 xpt_action(ccb);
3664                 ISP_UNLOCK(isp);
3665         }
3666         for (i = 0; i < NISP_TARG_NOTIFIES; i++) {
3667                 ccb = kmalloc(sizeof (*ccb), M_ISPTARG, M_WAITOK | M_ZERO);
3668                 xpt_setup_ccb(&ccb->ccb_h, periph->path, 1);
3669                 ccb->ccb_h.func_code = XPT_IMMEDIATE_NOTIFY;
3670                 ccb->ccb_h.cbfcnp = isptarg_done;
3671                 ISP_LOCK(isp);
3672                 xpt_action(ccb);
3673                 ISP_UNLOCK(isp);
3674         }
3675
3676         /*
3677          * Now turn it all back on
3678          */
3679         xpt_setup_ccb(&ccb->ccb_h, periph->path, 10);
3680         ccb->ccb_h.func_code = XPT_SET_SIM_KNOB;
3681         ccb->knob.xport_specific.fc.valid = KNOB_VALID_ROLE;
3682         ccb->knob.xport_specific.fc.role = KNOB_ROLE_TARGET;
3683         ISP_LOCK(isp);
3684         xpt_action(ccb);
3685         ISP_UNLOCK(isp);
3686
3687         /*
3688          * Okay, while things are still active, sleep...
3689          */
3690         ISP_LOCK(isp);
3691         for (;;) {
3692                 ISP_GET_PC(isp, chan, proc_active, i);
3693                 if (i == 0) {
3694                         break;
3695                 }
3696                 lksleep(wchan, &isp->isp_lock, PUSER, "tsnooze", 0);
3697         }
3698         ISP_UNLOCK(isp);
3699
3700 out:
3701         if (wperiph) {
3702                 cam_periph_invalidate(wperiph);
3703         }
3704         if (periph) {
3705                 cam_periph_invalidate(periph);
3706         }
3707         if (junk_data) {
3708                 kfree(junk_data, M_ISPTARG);
3709         }
3710         if (disk_data) {
3711                 kfree(disk_data, M_ISPTARG);
3712         }
3713         if (softc) {
3714                 kfree(softc, M_ISPTARG);
3715         }
3716         xpt_free_path(path);
3717         xpt_free_path(wpath);
3718 }
3719
3720 static void
3721 isp_target_thread_pi(void *arg)
3722 {
3723         struct isp_spi *pi = arg;
3724         isp_target_thread(cam_sim_softc(pi->sim), cam_sim_bus(pi->sim));
3725 }
3726
3727 static void
3728 isp_target_thread_fc(void *arg)
3729 {
3730         struct isp_fc *fc = arg;
3731         isp_target_thread(cam_sim_softc(fc->sim), cam_sim_bus(fc->sim));
3732 }
3733
3734 static int
3735 isptarg_rwparm(uint8_t *cdb, uint8_t *dp, uint64_t dl, uint32_t offset, uint8_t **kp, uint32_t *tl, int *lp)
3736 {
3737         uint32_t cnt, curcnt;
3738         uint64_t lba;
3739
3740         switch (cdb[0]) {
3741         case WRITE_16:
3742         case READ_16:
3743                 cnt =   (((uint32_t)cdb[10]) <<  24) |
3744                         (((uint32_t)cdb[11]) <<  16) |
3745                         (((uint32_t)cdb[12]) <<   8) |
3746                         ((uint32_t)cdb[13]);
3747
3748                 lba =   (((uint64_t)cdb[2]) << 56) |
3749                         (((uint64_t)cdb[3]) << 48) |
3750                         (((uint64_t)cdb[4]) << 40) |
3751                         (((uint64_t)cdb[5]) << 32) |
3752                         (((uint64_t)cdb[6]) << 24) |
3753                         (((uint64_t)cdb[7]) << 16) |
3754                         (((uint64_t)cdb[8]) <<  8) |
3755                         ((uint64_t)cdb[9]);
3756                 break;
3757         case WRITE_12:
3758         case READ_12:
3759                 cnt =   (((uint32_t)cdb[6]) <<  16) |
3760                         (((uint32_t)cdb[7]) <<   8) |
3761                         ((u_int32_t)cdb[8]);
3762
3763                 lba =   (((uint32_t)cdb[2]) << 24) |
3764                         (((uint32_t)cdb[3]) << 16) |
3765                         (((uint32_t)cdb[4]) <<  8) |
3766                         ((uint32_t)cdb[5]);
3767                 break;
3768         case WRITE_10:
3769         case READ_10:
3770                 cnt =   (((uint32_t)cdb[7]) <<  8) |
3771                         ((u_int32_t)cdb[8]);
3772
3773                 lba =   (((uint32_t)cdb[2]) << 24) |
3774                         (((uint32_t)cdb[3]) << 16) |
3775                         (((uint32_t)cdb[4]) <<  8) |
3776                         ((uint32_t)cdb[5]);
3777                 break;
3778         case WRITE_6:
3779         case READ_6:
3780                 cnt = cdb[4];
3781                 if (cnt == 0) {
3782                         cnt = 256;
3783                 }
3784                 lba =   (((uint32_t)cdb[1] & 0x1f) << 16) |
3785                         (((uint32_t)cdb[2]) << 8) |
3786                         ((uint32_t)cdb[3]);
3787                 break;
3788         default:
3789                 return (-1);
3790         }
3791
3792         cnt <<= DISK_SHIFT;
3793         lba <<= DISK_SHIFT;
3794
3795         if (offset == cnt) {
3796                 *lp = 1;
3797                 return (0);
3798         }
3799
3800         if (lba + cnt > dl) {
3801                 return (-1);
3802         }
3803
3804
3805         curcnt = MAX_ISP_TARG_TRANSFER;
3806         if (offset + curcnt >= cnt) {
3807                 curcnt = cnt - offset;
3808                 *lp = 1;
3809         } else {
3810                 *lp = 0;
3811         }
3812         *tl = curcnt;
3813         *kp = &dp[lba + offset];
3814         return (0);
3815 }
3816
3817 #endif
3818 #endif
3819
3820 static void
3821 isp_cam_async(void *cbarg, uint32_t code, struct cam_path *path, void *arg)
3822 {
3823         struct cam_sim *sim;
3824         int bus, tgt;
3825         ispsoftc_t *isp;
3826
3827         sim = (struct cam_sim *)cbarg;
3828         isp = (ispsoftc_t *) cam_sim_softc(sim);
3829         bus = cam_sim_bus(sim);
3830         tgt = xpt_path_target_id(path);
3831
3832         switch (code) {
3833         case AC_LOST_DEVICE:
3834                 if (IS_SCSI(isp)) {
3835                         uint16_t oflags, nflags;
3836                         sdparam *sdp = SDPARAM(isp, bus);
3837
3838                         if (tgt >= 0) {
3839                                 nflags = sdp->isp_devparam[tgt].nvrm_flags;
3840 #ifndef ISP_TARGET_MODE
3841                                 nflags &= DPARM_SAFE_DFLT;
3842                                 if (isp->isp_loaded_fw) {
3843                                         nflags |= DPARM_NARROW | DPARM_ASYNC;
3844                                 }
3845 #else
3846                                 nflags = DPARM_DEFAULT;
3847 #endif
3848                                 oflags = sdp->isp_devparam[tgt].goal_flags;
3849                                 sdp->isp_devparam[tgt].goal_flags = nflags;
3850                                 sdp->isp_devparam[tgt].dev_update = 1;
3851                                 sdp->update = 1;
3852                                 (void) isp_control(isp, ISPCTL_UPDATE_PARAMS, bus);
3853                                 sdp->isp_devparam[tgt].goal_flags = oflags;
3854                         }
3855                 }
3856                 break;
3857         default:
3858                 isp_prt(isp, ISP_LOGWARN, "isp_cam_async: Code 0x%x", code);
3859                 break;
3860         }
3861 }
3862
3863 static void
3864 isp_poll(struct cam_sim *sim)
3865 {
3866         ispsoftc_t *isp = cam_sim_softc(sim);
3867         uint32_t isr;
3868         uint16_t sema, mbox;
3869
3870         if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
3871                 isp_intr(isp, isr, sema, mbox);
3872         }
3873 }
3874
3875
3876 static void
3877 isp_watchdog(void *arg)
3878 {
3879         struct ccb_scsiio *xs = arg;
3880         ispsoftc_t *isp;
3881         uint32_t ohandle = ISP_HANDLE_FREE, handle;
3882
3883         isp = XS_ISP(xs);
3884         ISP_LOCK(isp);
3885
3886         handle = isp_find_handle(isp, xs);
3887
3888         if (handle != ISP_HANDLE_FREE && !XS_CMD_WPEND_P(xs)) {
3889                 isp_xs_prt(isp, xs, ISP_LOGWARN, "first watchdog (handle 0x%x) timed out- deferring for grace period", handle);
3890                 callout_reset(&PISP_PCMD(xs)->wdog, 2 * hz, isp_watchdog, xs);
3891                 XS_CMD_S_WPEND(xs);
3892                 ISP_UNLOCK(isp);
3893                 return;
3894         }
3895         XS_C_TACTIVE(xs);
3896
3897         /*
3898          * Hand crank the interrupt code just to be sure the command isn't stuck somewhere.
3899          */
3900         if (handle != ISP_HANDLE_FREE) {
3901                 uint32_t isr;
3902                 uint16_t sema, mbox;
3903                 if (ISP_READ_ISR(isp, &isr, &sema, &mbox) != 0) {
3904                         isp_intr(isp, isr, sema, mbox);
3905                 }
3906                 ohandle = handle;
3907                 handle = isp_find_handle(isp, xs);
3908         }
3909         if (handle != ISP_HANDLE_FREE) {
3910                 /*
3911                  * Try and make sure the command is really dead before
3912                  * we release the handle (and DMA resources) for reuse.
3913                  *
3914                  * If we are successful in aborting the command then
3915                  * we're done here because we'll get the command returned
3916                  * back separately.
3917                  */
3918                 if (isp_control(isp, ISPCTL_ABORT_CMD, xs) == 0) {
3919                         ISP_UNLOCK(isp);
3920                         return;
3921                 }
3922
3923                 /*
3924                  * Note that after calling the above, the command may in
3925                  * fact have been completed.
3926                  */
3927                 xs = isp_find_xs(isp, handle);
3928
3929                 /*
3930                  * If the command no longer exists, then we won't
3931                  * be able to find the xs again with this handle.
3932                  */
3933                 if (xs == NULL) {
3934                         ISP_UNLOCK(isp);
3935                         return;
3936                 }
3937
3938                 /*
3939                  * After this point, the command is really dead.
3940                  */
3941                 if (XS_XFRLEN(xs)) {
3942                         ISP_DMAFREE(isp, xs, handle);
3943                 }
3944                 isp_destroy_handle(isp, handle);
3945                 isp_prt(isp, ISP_LOGERR, "%s: timeout for handle 0x%x", __func__, handle);
3946                 XS_SETERR(xs, CAM_CMD_TIMEOUT);
3947                 isp_prt_endcmd(isp, xs);
3948                 isp_done(xs);
3949         } else {
3950                 if (ohandle != ISP_HANDLE_FREE) {
3951                         isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle 0x%x, recovered during interrupt", __func__, ohandle);
3952                 } else {
3953                         isp_prt(isp, ISP_LOGWARN, "%s: timeout for handle already free", __func__);
3954                 }
3955         }
3956         ISP_UNLOCK(isp);
3957 }
3958
3959 static void
3960 isp_bus_scan_cb(struct cam_periph *periph, union ccb *ccb)
3961 {
3962         if (ccb->ccb_h.status != CAM_REQ_CMP)
3963                 kprintf("cam_scan_callback: failure status = %x\n",
3964                         ccb->ccb_h.status);
3965
3966         xpt_free_path(ccb->ccb_h.path);
3967         kfree(ccb, M_TEMP);
3968 }
3969
3970 static void
3971 isp_make_here(ispsoftc_t *isp, int chan, int tgt)
3972 {
3973         union ccb *ccb;
3974         struct isp_fc *fc = ISP_FC_PC(isp, chan);
3975
3976         if (isp_autoconfig == 0) {
3977                 return;
3978         }
3979
3980         /*
3981          * Allocate a CCB, create a wildcard path for this target and schedule a rescan.
3982          */
3983         ccb = xpt_alloc_ccb();
3984         if (ccb == NULL) {
3985                 isp_prt(isp, ISP_LOGWARN, "Chan %d unable to alloc CCB for rescan", chan);
3986                 return;
3987         }
3988         if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, cam_sim_path(fc->sim), tgt, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
3989                 isp_prt(isp, ISP_LOGWARN, "unable to create path for rescan");
3990                 xpt_free_ccb(ccb);
3991                 return;
3992         }
3993         xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path, 5/*priority (low)*/);
3994         ccb->ccb_h.func_code = XPT_SCAN_BUS;
3995         ccb->ccb_h.cbfcnp = isp_bus_scan_cb;
3996         ccb->crcn.flags = CAM_FLAG_NONE;
3997         xpt_action(ccb);
3998 }
3999
4000 static void
4001 isp_make_gone(ispsoftc_t *isp, int chan, int tgt)
4002 {
4003         struct cam_path *tp;
4004         struct isp_fc *fc = ISP_FC_PC(isp, chan);
4005
4006         if (isp_autoconfig == 0) {
4007                 return;
4008         }
4009         if (xpt_create_path(&tp, NULL, cam_sim_path(fc->sim), tgt, CAM_LUN_WILDCARD) == CAM_REQ_CMP) {
4010                 xpt_async(AC_LOST_DEVICE, tp, NULL);
4011                 xpt_free_path(tp);
4012         }
4013 }
4014
4015 /*
4016  * Gone Device Timer Function- when we have decided that a device has gone
4017  * away, we wait a specific period of time prior to telling the OS it has
4018  * gone away.
4019  *
4020  * This timer function fires once a second and then scans the port database
4021  * for devices that are marked dead but still have a virtual target assigned.
4022  * We decrement a counter for that port database entry, and when it hits zero,
4023  * we tell the OS the device has gone away.
4024  */
4025 static void
4026 isp_gdt(void *arg)
4027 {
4028         struct isp_fc *fc = arg;
4029
4030         ISP_LOCK(fc->isp);
4031         taskqueue_enqueue(taskqueue_swi, &fc->gtask);
4032         ISP_UNLOCK(fc->isp);
4033 }
4034
4035 static void
4036 isp_gdt_task(void *arg, int pending)
4037 {
4038         struct isp_fc *fc = arg;
4039         ispsoftc_t *isp = fc->isp;
4040         int chan = fc - isp->isp_osinfo.pc.fc;
4041         fcportdb_t *lp;
4042         int dbidx, tgt, more_to_do = 0;
4043
4044         ISP_LOCK(isp);
4045         isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GDT timer expired", chan);
4046         for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
4047                 lp = &FCPARAM(isp, chan)->portdb[dbidx];
4048
4049                 if (lp->state != FC_PORTDB_STATE_ZOMBIE) {
4050                         continue;
4051                 }
4052                 if (lp->dev_map_idx == 0 || lp->target_mode) {
4053                         continue;
4054                 }
4055                 if (lp->gone_timer != 0) {
4056                         isp_prt(isp, ISP_LOGSANCFG, "%s: Chan %d more to do for target %u (timer=%u)", __func__, chan, lp->dev_map_idx - 1, lp->gone_timer);
4057                         lp->gone_timer -= 1;
4058                         more_to_do++;
4059                         continue;
4060                 }
4061                 tgt = lp->dev_map_idx - 1;
4062                 FCPARAM(isp, chan)->isp_dev_map[tgt] = 0;
4063                 lp->dev_map_idx = 0;
4064                 lp->state = FC_PORTDB_STATE_NIL;
4065                 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, lp->portid, tgt, "Gone Device Timeout");
4066                 isp_make_gone(isp, chan, tgt);
4067         }
4068         if (fc->ready) {
4069                 if (more_to_do) {
4070                         callout_reset(&fc->gdt, hz, isp_gdt, fc);
4071                 } else {
4072                         callout_deactivate(&fc->gdt);
4073                         isp_prt(isp, ISP_LOGSANCFG, "Chan %d Stopping Gone Device Timer @ %lu", chan, (unsigned long) time_second);
4074                 }
4075         }
4076         ISP_UNLOCK(isp);
4077 }
4078
4079 /*
4080  * Loop Down Timer Function- when loop goes down, a timer is started and
4081  * and after it expires we come here and take all probational devices that
4082  * the OS knows about and the tell the OS that they've gone away.
4083  *
4084  * We don't clear the devices out of our port database because, when loop
4085  * come back up, we have to do some actual cleanup with the chip at that
4086  * point (implicit PLOGO, e.g., to get the chip's port database state right).
4087  */
4088 static void
4089 isp_ldt(void *arg)
4090 {
4091         struct isp_fc *fc = arg;
4092
4093         ISP_LOCK(fc->isp);
4094         taskqueue_enqueue(taskqueue_swi, &fc->ltask);
4095         ISP_UNLOCK(fc->isp);
4096 }
4097
4098 static void
4099 isp_ldt_task(void *arg, int pending)
4100 {
4101         struct isp_fc *fc = arg;
4102         ispsoftc_t *isp = fc->isp;
4103         int chan = fc - isp->isp_osinfo.pc.fc;
4104         fcportdb_t *lp;
4105         int dbidx, tgt, i;
4106
4107         ISP_LOCK(isp);
4108         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d Loop Down Timer expired @ %lu", chan, (unsigned long) time_second);
4109         callout_deactivate(&fc->ldt);
4110
4111         /*
4112          * Notify to the OS all targets who we now consider have departed.
4113          */
4114         for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
4115                 lp = &FCPARAM(isp, chan)->portdb[dbidx];
4116
4117                 if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
4118                         continue;
4119                 }
4120                 if (lp->dev_map_idx == 0 || lp->target_mode) {
4121                         continue;
4122                 }
4123
4124                 /*
4125                  * XXX: CLEAN UP AND COMPLETE ANY PENDING COMMANDS FIRST!
4126                  */
4127
4128
4129                 for (i = 0; i < isp->isp_maxcmds; i++) {
4130                         struct ccb_scsiio *xs;
4131
4132                         if (!ISP_VALID_HANDLE(isp, isp->isp_xflist[i].handle)) {
4133                                 continue;
4134                         }
4135                         if ((xs = isp->isp_xflist[i].cmd) == NULL) {
4136                                 continue;
4137                         }
4138                         if (dbidx != (FCPARAM(isp, chan)->isp_dev_map[XS_TGT(xs)] - 1)) {
4139                                 continue;
4140                         }
4141                         isp_prt(isp, ISP_LOGWARN, "command handle 0x%08x for %d.%d.%d orphaned by loop down timeout",
4142                             isp->isp_xflist[i].handle, chan, XS_TGT(xs), XS_LUN(xs));
4143                 }
4144
4145                 /*
4146                  * Mark that we've announced that this device is gone....
4147                  */
4148                 lp->reserved = 1;
4149
4150                 /*
4151                  * but *don't* change the state of the entry. Just clear
4152                  * any target id stuff and announce to CAM that the
4153                  * device is gone. This way any necessary PLOGO stuff
4154                  * will happen when loop comes back up.
4155                  */
4156
4157                 tgt = lp->dev_map_idx - 1;
4158                 FCPARAM(isp, chan)->isp_dev_map[tgt] = 0;
4159                 lp->dev_map_idx = 0;
4160                 lp->state = FC_PORTDB_STATE_NIL;
4161                 isp_prt(isp, ISP_LOGCONFIG, prom3, chan, lp->portid, tgt, "Loop Down Timeout");
4162                 isp_make_gone(isp, chan, tgt);
4163         }
4164
4165         if (FCPARAM(isp, chan)->role & ISP_ROLE_INITIATOR) {
4166                 isp_unfreeze_loopdown(isp, chan);
4167         }
4168         /*
4169          * The loop down timer has expired. Wake up the kthread
4170          * to notice that fact (or make it false).
4171          */
4172         fc->loop_dead = 1;
4173         fc->loop_down_time = fc->loop_down_limit+1;
4174         wakeup(fc);
4175         ISP_UNLOCK(isp);
4176 }
4177
4178 static void
4179 isp_kthread(void *arg)
4180 {
4181         struct isp_fc *fc = arg;
4182         ispsoftc_t *isp = fc->isp;
4183         int chan = fc - isp->isp_osinfo.pc.fc;
4184         int slp = 0;
4185
4186         lockmgr(&isp->isp_osinfo.lock, LK_EXCLUSIVE);
4187
4188         for (;;) {
4189                 int lb, lim;
4190
4191                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d checking FC state", __func__, chan);
4192                 lb = isp_fc_runstate(isp, chan, 250000);
4193
4194                 /*
4195                  * Our action is different based upon whether we're supporting
4196                  * Initiator mode or not. If we are, we might freeze the simq
4197                  * when loop is down and set all sorts of different delays to
4198                  * check again.
4199                  *
4200                  * If not, we simply just wait for loop to come up.
4201                  */
4202                 if (lb && (FCPARAM(isp, chan)->role & ISP_ROLE_INITIATOR)) {
4203                         /*
4204                          * Increment loop down time by the last sleep interval
4205                          */
4206                         fc->loop_down_time += slp;
4207
4208                         if (lb < 0) {
4209                                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d FC loop not up (down count %d)", __func__, chan, fc->loop_down_time);
4210                         } else {
4211                                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d FC got to %d (down count %d)", __func__, chan, lb, fc->loop_down_time);
4212                         }
4213
4214                         /*
4215                          * If we've never seen loop up and we've waited longer
4216                          * than quickboot time, or we've seen loop up but we've
4217                          * waited longer than loop_down_limit, give up and go
4218                          * to sleep until loop comes up.
4219                          */
4220                         if (FCPARAM(isp, chan)->loop_seen_once == 0) {
4221                                 lim = isp_quickboot_time;
4222                         } else {
4223                                 lim = fc->loop_down_limit;
4224                         }
4225                         if (fc->loop_down_time >= lim) {
4226                                 isp_freeze_loopdown(isp, chan, "loop limit hit");
4227                                 slp = 0;
4228                         } else if (fc->loop_down_time < 10) {
4229                                 slp = 1;
4230                         } else if (fc->loop_down_time < 30) {
4231                                 slp = 5;
4232                         } else if (fc->loop_down_time < 60) {
4233                                 slp = 10;
4234                         } else if (fc->loop_down_time < 120) {
4235                                 slp = 20;
4236                         } else {
4237                                 slp = 30;
4238                         }
4239
4240                 } else if (lb) {
4241                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d FC Loop Down", __func__, chan);
4242                         fc->loop_down_time += slp;
4243                         slp = 60;
4244                 } else {
4245                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d FC state OK", __func__, chan);
4246                         fc->loop_down_time = 0;
4247                         slp = 0;
4248                 }
4249
4250
4251                 /*
4252                  * If this is past the first loop up or the loop is dead and if we'd frozen the simq, unfreeze it
4253                  * now so that CAM can start sending us commands.
4254                  *
4255                  * If the FC state isn't okay yet, they'll hit that in isp_start which will freeze the queue again
4256                  * or kill the commands, as appropriate.
4257                  */
4258
4259                 if (FCPARAM(isp, chan)->loop_seen_once || fc->loop_dead) {
4260                         isp_unfreeze_loopdown(isp, chan);
4261                 }
4262
4263                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d sleep time %d", __func__, chan, slp);
4264
4265                 lksleep(fc, &isp->isp_osinfo.lock, 0, "ispf", slp * hz);
4266
4267                 /*
4268                  * If slp is zero, we're waking up for the first time after
4269                  * things have been okay. In this case, we set a deferral state
4270                  * for all commands and delay hysteresis seconds before starting
4271                  * the FC state evaluation. This gives the loop/fabric a chance
4272                  * to settle.
4273                  */
4274                 if (slp == 0 && fc->hysteresis) {
4275                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "%s: Chan %d sleep hysteresis ticks %d", __func__, chan, fc->hysteresis * hz);
4276                         lockmgr(&isp->isp_osinfo.lock, LK_RELEASE);
4277                         tsleep(isp_kthread, 0, "ispt", fc->hysteresis * hz);
4278                         lockmgr(&isp->isp_osinfo.lock, LK_EXCLUSIVE);
4279                 }
4280         }
4281         lockmgr(&isp->isp_osinfo.lock, LK_RELEASE);
4282 }
4283
4284 static void
4285 isp_action(struct cam_sim *sim, union ccb *ccb)
4286 {
4287         int bus, tgt, ts, error, lim;
4288         ispsoftc_t *isp;
4289         struct ccb_trans_settings *cts;
4290
4291         CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("isp_action\n"));
4292
4293         isp = (ispsoftc_t *)cam_sim_softc(sim);
4294         KKASSERT(lockstatus(&isp->isp_lock, curthread) != 0);
4295
4296         if (isp->isp_state != ISP_RUNSTATE && ccb->ccb_h.func_code == XPT_SCSI_IO) {
4297                 isp_init(isp);
4298                 if (isp->isp_state != ISP_INITSTATE) {
4299                         /*
4300                          * Lie. Say it was a selection timeout.
4301                          */
4302                         ccb->ccb_h.status = CAM_SEL_TIMEOUT | CAM_DEV_QFRZN;
4303                         xpt_freeze_devq(ccb->ccb_h.path, 1);
4304                         xpt_done(ccb);
4305                         return;
4306                 }
4307                 isp->isp_state = ISP_RUNSTATE;
4308         }
4309         isp_prt(isp, ISP_LOGDEBUG2, "isp_action code %x", ccb->ccb_h.func_code);
4310         ISP_PCMD(ccb) = NULL;
4311
4312         switch (ccb->ccb_h.func_code) {
4313         case XPT_SCSI_IO:       /* Execute the requested I/O operation */
4314                 bus = XS_CHANNEL(ccb);
4315                 /*
4316                  * Do a couple of preliminary checks...
4317                  */
4318                 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) {
4319                         if ((ccb->ccb_h.flags & CAM_CDB_PHYS) != 0) {
4320                                 ccb->ccb_h.status = CAM_REQ_INVALID;
4321                                 xpt_done(ccb);
4322                                 break;
4323                         }
4324                 }
4325 #ifdef  DIAGNOSTIC
4326                 if (ccb->ccb_h.target_id > (ISP_MAX_TARGETS(isp) - 1)) {
4327                         xpt_print(ccb->ccb_h.path, "invalid target\n");
4328                         ccb->ccb_h.status = CAM_PATH_INVALID;
4329                 } else if (ccb->ccb_h.target_lun > (ISP_MAX_LUNS(isp) - 1)) {
4330                         xpt_print(ccb->ccb_h.path, "invalid lun\n");
4331                         ccb->ccb_h.status = CAM_PATH_INVALID;
4332                 }
4333                 if (ccb->ccb_h.status == CAM_PATH_INVALID) {
4334                         xpt_done(ccb);
4335                         break;
4336                 }
4337 #endif
4338                 ccb->csio.scsi_status = SCSI_STATUS_OK;
4339                 if (isp_get_pcmd(isp, ccb)) {
4340                         isp_prt(isp, ISP_LOGWARN, "out of PCMDs");
4341                         cam_freeze_devq(ccb->ccb_h.path);
4342                         cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 250, 0);
4343                         xpt_done(ccb);
4344                         break;
4345                 }
4346                 error = isp_start((XS_T *) ccb);
4347                 switch (error) {
4348                 case CMD_QUEUED:
4349                         XS_CMD_S_CLEAR(ccb);
4350                         ccb->ccb_h.status |= CAM_SIM_QUEUED;
4351                         if (ccb->ccb_h.timeout == CAM_TIME_INFINITY) {
4352                                 break;
4353                         }
4354                         ts = ccb->ccb_h.timeout;
4355                         if (ts == CAM_TIME_DEFAULT) {
4356                                 ts = 60*1000;
4357                         }
4358                         ts = isp_mstohz(ts);
4359                         XS_S_TACTIVE(ccb);
4360                         callout_reset(&PISP_PCMD(ccb)->wdog, ts, isp_watchdog, ccb);
4361                         break;
4362                 case CMD_RQLATER:
4363                         /*
4364                          * We get this result for FC devices if the loop state isn't ready yet
4365                          * or if the device in question has gone zombie on us.
4366                          *
4367                          * If we've never seen Loop UP at all, we requeue this request and wait
4368                          * for the initial loop up delay to expire.
4369                          */
4370                         lim = ISP_FC_PC(isp, bus)->loop_down_limit;
4371                         if (FCPARAM(isp, bus)->loop_seen_once == 0 || ISP_FC_PC(isp, bus)->loop_down_time >= lim) {
4372                                 if (FCPARAM(isp, bus)->loop_seen_once == 0) {
4373                                         isp_prt(isp, ISP_LOGDEBUG0, "%d.%d loop not seen yet @ %lu", XS_TGT(ccb), XS_LUN(ccb), (unsigned long) time_second);
4374                                 } else {
4375                                         isp_prt(isp, ISP_LOGDEBUG0, "%d.%d downtime (%d) > lim (%d)", XS_TGT(ccb), XS_LUN(ccb), ISP_FC_PC(isp, bus)->loop_down_time, lim);
4376                                 }
4377                                 ccb->ccb_h.status = CAM_SEL_TIMEOUT|CAM_DEV_QFRZN;
4378                                 xpt_freeze_devq(ccb->ccb_h.path, 1);
4379                                 isp_free_pcmd(isp, ccb);
4380                                 xpt_done(ccb);
4381                                 break;
4382                         }
4383                         isp_prt(isp, ISP_LOGDEBUG0, "%d.%d retry later", XS_TGT(ccb), XS_LUN(ccb));
4384                         cam_freeze_devq(ccb->ccb_h.path);
4385                         cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 1000, 0);
4386                         XS_SETERR(ccb, CAM_REQUEUE_REQ);
4387                         isp_free_pcmd(isp, ccb);
4388                         xpt_done(ccb);
4389                         break;
4390                 case CMD_EAGAIN:
4391                         isp_free_pcmd(isp, ccb);
4392                         cam_freeze_devq(ccb->ccb_h.path);
4393                         cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 100, 0);
4394                         XS_SETERR(ccb, CAM_REQUEUE_REQ);
4395                         xpt_done(ccb);
4396                         break;
4397                 case CMD_COMPLETE:
4398                         isp_done((struct ccb_scsiio *) ccb);
4399                         break;
4400                 default:
4401                         isp_prt(isp, ISP_LOGERR, "What's this? 0x%x at %d in file %s", error, __LINE__, __FILE__);
4402                         XS_SETERR(ccb, CAM_REQ_CMP_ERR);
4403                         isp_free_pcmd(isp, ccb);
4404                         xpt_done(ccb);
4405                 }
4406                 break;
4407
4408 #ifdef  ISP_TARGET_MODE
4409         case XPT_EN_LUN:                /* Enable/Disable LUN as a target */
4410                 if (ccb->cel.enable) {
4411                         isp_enable_lun(isp, ccb);
4412                 } else {
4413                         isp_disable_lun(isp, ccb);
4414                 }
4415                 break;
4416         case XPT_IMMED_NOTIFY:
4417         case XPT_IMMEDIATE_NOTIFY:      /* Add Immediate Notify Resource */
4418         case XPT_ACCEPT_TARGET_IO:      /* Add Accept Target IO Resource */
4419         {
4420                 tstate_t *tptr = get_lun_statep(isp, XS_CHANNEL(ccb), ccb->ccb_h.target_lun);
4421                 if (tptr == NULL) {
4422                         tptr = get_lun_statep(isp, XS_CHANNEL(ccb), CAM_LUN_WILDCARD);
4423                 }
4424                 if (tptr == NULL) {
4425                         const char *str;
4426                         uint32_t tag;
4427
4428                         if (ccb->ccb_h.func_code == XPT_IMMEDIATE_NOTIFY) {
4429                                 str = "XPT_IMMEDIATE_NOTIFY";
4430                                 tag = ccb->cin1.seq_id;
4431                         } else {
4432                                 tag = ccb->atio.tag_id;
4433                                 str = "XPT_ACCEPT_TARGET_IO";
4434                         }
4435                         ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "%s: [0x%x] no state pointer found for %s\n", __func__, tag, str);
4436                         dump_tstates(isp, XS_CHANNEL(ccb));
4437                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
4438                         break;
4439                 }
4440                 ccb->ccb_h.sim_priv.entries[0].field = 0;
4441                 ccb->ccb_h.sim_priv.entries[1].ptr = isp;
4442                 ccb->ccb_h.flags = 0;
4443
4444                 if (ccb->ccb_h.func_code == XPT_ACCEPT_TARGET_IO) {
4445                         if (ccb->atio.tag_id) {
4446                                 atio_private_data_t *atp = isp_get_atpd(isp, tptr, ccb->atio.tag_id);
4447                                 if (atp) {
4448                                         isp_put_atpd(isp, tptr, atp);
4449                                 }
4450                         }
4451                         tptr->atio_count++;
4452                         SLIST_INSERT_HEAD(&tptr->atios, &ccb->ccb_h, sim_links.sle);
4453                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "Put FREE ATIO (tag id 0x%x), count now %d\n",
4454                             ((struct ccb_accept_tio *)ccb)->tag_id, tptr->atio_count);
4455                 } else if (ccb->ccb_h.func_code == XPT_IMMEDIATE_NOTIFY) {
4456                         if (ccb->cin1.tag_id) {
4457                                 inot_private_data_t *ntp = isp_find_ntpd(isp, tptr, ccb->cin1.tag_id, ccb->cin1.seq_id);
4458                                 if (ntp) {
4459                                         isp_put_ntpd(isp, tptr, ntp);
4460                                 }
4461                         }
4462                         tptr->inot_count++;
4463                         SLIST_INSERT_HEAD(&tptr->inots, &ccb->ccb_h, sim_links.sle);
4464                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "Put FREE INOT, (seq id 0x%x) count now %d\n",
4465                             ((struct ccb_immediate_notify *)ccb)->seq_id, tptr->inot_count);
4466                 } else if (ccb->ccb_h.func_code == XPT_IMMED_NOTIFY) {
4467                         tptr->inot_count++;
4468                         SLIST_INSERT_HEAD(&tptr->inots, &ccb->ccb_h, sim_links.sle);
4469                         ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "Put FREE INOT, (seq id 0x%x) count now %d\n",
4470                             ((struct ccb_immediate_notify *)ccb)->seq_id, tptr->inot_count);
4471                 }
4472                 rls_lun_statep(isp, tptr);
4473                 ccb->ccb_h.status = CAM_REQ_INPROG;
4474                 break;
4475         }
4476         case XPT_NOTIFY_ACK:
4477                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
4478                 break;
4479         case XPT_NOTIFY_ACKNOWLEDGE:            /* notify ack */
4480         {
4481                 tstate_t *tptr;
4482                 inot_private_data_t *ntp;
4483
4484                 /*
4485                  * XXX: Because we cannot guarantee that the path information in the notify acknowledge ccb
4486                  * XXX: matches that for the immediate notify, we have to *search* for the notify structure
4487                  */
4488                 /*
4489                  * All the relevant path information is in the associated immediate notify
4490                  */
4491                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: [0x%x] NOTIFY ACKNOWLEDGE for 0x%x seen\n", __func__, ccb->cna2.tag_id, ccb->cna2.seq_id);
4492                 ntp = get_ntp_from_tagdata(isp, ccb->cna2.tag_id, ccb->cna2.seq_id, &tptr);
4493                 if (ntp == NULL) {
4494                         ISP_PATH_PRT(isp, ISP_LOGWARN, ccb->ccb_h.path, "%s: [0x%x] XPT_NOTIFY_ACKNOWLEDGE of 0x%x cannot find ntp private data\n", __func__,
4495                              ccb->cna2.tag_id, ccb->cna2.seq_id);
4496                         ccb->ccb_h.status = CAM_DEV_NOT_THERE;
4497                         xpt_done(ccb);
4498                         break;
4499                 }
4500                 if (isp_handle_platform_target_notify_ack(isp, &ntp->rd.nt)) {
4501                         rls_lun_statep(isp, tptr);
4502                         cam_freeze_devq(ccb->ccb_h.path);
4503                         cam_release_devq(ccb->ccb_h.path, RELSIM_RELEASE_AFTER_TIMEOUT, 0, 1000, 0);
4504                         XS_SETERR(ccb, CAM_REQUEUE_REQ);
4505                         break;
4506                 }
4507                 isp_put_ntpd(isp, tptr, ntp);
4508                 rls_lun_statep(isp, tptr);
4509                 ccb->ccb_h.status = CAM_REQ_CMP;
4510                 ISP_PATH_PRT(isp, ISP_LOGTDEBUG0, ccb->ccb_h.path, "%s: [0x%x] calling xpt_done for tag 0x%x\n", __func__, ccb->cna2.tag_id, ccb->cna2.seq_id);
4511                 xpt_done(ccb);
4512                 break;
4513         }
4514         case XPT_CONT_TARGET_IO:
4515                 isp_target_start_ctio(isp, ccb);
4516                 break;
4517 #endif
4518         case XPT_RESET_DEV:             /* BDR the specified SCSI device */
4519
4520                 bus = cam_sim_bus(xpt_path_sim(ccb->ccb_h.path));
4521                 tgt = ccb->ccb_h.target_id;
4522                 tgt |= (bus << 16);
4523
4524                 error = isp_control(isp, ISPCTL_RESET_DEV, bus, tgt);
4525                 if (error) {
4526                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
4527                 } else {
4528                         ccb->ccb_h.status = CAM_REQ_CMP;
4529                 }
4530                 xpt_done(ccb);
4531                 break;
4532         case XPT_ABORT:                 /* Abort the specified CCB */
4533         {
4534                 union ccb *accb = ccb->cab.abort_ccb;
4535                 switch (accb->ccb_h.func_code) {
4536 #ifdef  ISP_TARGET_MODE
4537                 case XPT_ACCEPT_TARGET_IO:
4538                         isp_target_mark_aborted(isp, accb);
4539                         break;
4540 #endif
4541                 case XPT_SCSI_IO:
4542                         error = isp_control(isp, ISPCTL_ABORT_CMD, ccb);
4543                         if (error) {
4544                                 ccb->ccb_h.status = CAM_UA_ABORT;
4545                         } else {
4546                                 ccb->ccb_h.status = CAM_REQ_CMP;
4547                         }
4548                         break;
4549                 default:
4550                         ccb->ccb_h.status = CAM_REQ_INVALID;
4551                         break;
4552                 }
4553                 /*
4554                  * This is not a queued CCB, so the caller expects it to be
4555                  * complete when control is returned.
4556                  */
4557                 break;
4558         }
4559 #define IS_CURRENT_SETTINGS(c)  (c->type == CTS_TYPE_CURRENT_SETTINGS)
4560         case XPT_SET_TRAN_SETTINGS:     /* Nexus Settings */
4561                 cts = &ccb->cts;
4562                 if (!IS_CURRENT_SETTINGS(cts)) {
4563                         ccb->ccb_h.status = CAM_REQ_INVALID;
4564                         xpt_done(ccb);
4565                         break;
4566                 }
4567                 tgt = cts->ccb_h.target_id;
4568                 bus = cam_sim_bus(xpt_path_sim(cts->ccb_h.path));
4569                 if (IS_SCSI(isp)) {
4570                         struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
4571                         struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
4572                         sdparam *sdp = SDPARAM(isp, bus);
4573                         uint16_t *dptr;
4574
4575                         if (spi->valid == 0 && scsi->valid == 0) {
4576                                 ccb->ccb_h.status = CAM_REQ_CMP;
4577                                 xpt_done(ccb);
4578                                 break;
4579                         }
4580
4581                         /*
4582                          * We always update (internally) from goal_flags
4583                          * so any request to change settings just gets
4584                          * vectored to that location.
4585                          */
4586                         dptr = &sdp->isp_devparam[tgt].goal_flags;
4587
4588                         if ((spi->valid & CTS_SPI_VALID_DISC) != 0) {
4589                                 if ((spi->flags & CTS_SPI_FLAGS_DISC_ENB) != 0)
4590                                         *dptr |= DPARM_DISC;
4591                                 else
4592                                         *dptr &= ~DPARM_DISC;
4593                         }
4594
4595                         if ((scsi->valid & CTS_SCSI_VALID_TQ) != 0) {
4596                                 if ((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0)
4597                                         *dptr |= DPARM_TQING;
4598                                 else
4599                                         *dptr &= ~DPARM_TQING;
4600                         }
4601
4602                         if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) {
4603                                 if (spi->bus_width == MSG_EXT_WDTR_BUS_16_BIT)
4604                                         *dptr |= DPARM_WIDE;
4605                                 else
4606                                         *dptr &= ~DPARM_WIDE;
4607                         }
4608
4609                         /*
4610                          * XXX: FIX ME
4611                          */
4612                         if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) && (spi->valid & CTS_SPI_VALID_SYNC_RATE) && (spi->sync_period && spi->sync_offset)) {
4613                                 *dptr |= DPARM_SYNC;
4614                                 /*
4615                                  * XXX: CHECK FOR LEGALITY
4616                                  */
4617                                 sdp->isp_devparam[tgt].goal_period = spi->sync_period;
4618                                 sdp->isp_devparam[tgt].goal_offset = spi->sync_offset;
4619                         } else {
4620                                 *dptr &= ~DPARM_SYNC;
4621                         }
4622                         isp_prt(isp, ISP_LOGDEBUG0, "SET (%d.%d.%d) to flags %x off %x per %x", bus, tgt, cts->ccb_h.target_lun, sdp->isp_devparam[tgt].goal_flags,
4623                             sdp->isp_devparam[tgt].goal_offset, sdp->isp_devparam[tgt].goal_period);
4624                         sdp->isp_devparam[tgt].dev_update = 1;
4625                         sdp->update = 1;
4626                 }
4627                 ccb->ccb_h.status = CAM_REQ_CMP;
4628                 xpt_done(ccb);
4629                 break;
4630         case XPT_GET_TRAN_SETTINGS:
4631                 cts = &ccb->cts;
4632                 tgt = cts->ccb_h.target_id;
4633                 bus = cam_sim_bus(xpt_path_sim(cts->ccb_h.path));
4634                 if (IS_FC(isp)) {
4635                         fcparam *fcp = FCPARAM(isp, bus);
4636                         struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
4637                         struct ccb_trans_settings_fc *fc = &cts->xport_specific.fc;
4638                         unsigned int hdlidx;
4639
4640                         cts->protocol = PROTO_SCSI;
4641                         cts->protocol_version = SCSI_REV_2;
4642                         cts->transport = XPORT_FC;
4643                         cts->transport_version = 0;
4644
4645                         scsi->valid = CTS_SCSI_VALID_TQ;
4646                         scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
4647                         fc->valid = CTS_FC_VALID_SPEED;
4648                         fc->bitrate = 100000;
4649                         fc->bitrate *= fcp->isp_gbspeed;
4650                         hdlidx = fcp->isp_dev_map[tgt] - 1;
4651                         if (hdlidx < MAX_FC_TARG) {
4652                                 fcportdb_t *lp = &fcp->portdb[hdlidx];
4653                                 fc->wwnn = lp->node_wwn;
4654                                 fc->wwpn = lp->port_wwn;
4655                                 fc->port = lp->portid;
4656                                 fc->valid |= CTS_FC_VALID_WWNN | CTS_FC_VALID_WWPN | CTS_FC_VALID_PORT;
4657                         }
4658                 } else {
4659                         struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
4660                         struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
4661                         sdparam *sdp = SDPARAM(isp, bus);
4662                         uint16_t dval, pval, oval;
4663
4664                         if (IS_CURRENT_SETTINGS(cts)) {
4665                                 sdp->isp_devparam[tgt].dev_refresh = 1;
4666                                 sdp->update = 1;
4667                                 (void) isp_control(isp, ISPCTL_UPDATE_PARAMS, bus);
4668                                 dval = sdp->isp_devparam[tgt].actv_flags;
4669                                 oval = sdp->isp_devparam[tgt].actv_offset;
4670                                 pval = sdp->isp_devparam[tgt].actv_period;
4671                         } else {
4672                                 dval = sdp->isp_devparam[tgt].nvrm_flags;
4673                                 oval = sdp->isp_devparam[tgt].nvrm_offset;
4674                                 pval = sdp->isp_devparam[tgt].nvrm_period;
4675                         }
4676
4677                         cts->protocol = PROTO_SCSI;
4678                         cts->protocol_version = SCSI_REV_2;
4679                         cts->transport = XPORT_SPI;
4680                         cts->transport_version = 2;
4681
4682                         spi->valid = 0;
4683                         scsi->valid = 0;
4684                         spi->flags = 0;
4685                         scsi->flags = 0;
4686                         if (dval & DPARM_DISC) {
4687                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
4688                         }
4689                         if ((dval & DPARM_SYNC) && oval && pval) {
4690                                 spi->sync_offset = oval;
4691                                 spi->sync_period = pval;
4692                         } else {
4693                                 spi->sync_offset = 0;
4694                                 spi->sync_period = 0;
4695                         }
4696                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
4697                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
4698                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
4699                         if (dval & DPARM_WIDE) {
4700                                 spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
4701                         } else {
4702                                 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
4703                         }
4704                         if (cts->ccb_h.target_lun != CAM_LUN_WILDCARD) {
4705                                 scsi->valid = CTS_SCSI_VALID_TQ;
4706                                 if (dval & DPARM_TQING) {
4707                                         scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
4708                                 }
4709                                 spi->valid |= CTS_SPI_VALID_DISC;
4710                         }
4711                         isp_prt(isp, ISP_LOGDEBUG0, "GET %s (%d.%d.%d) to flags %x off %x per %x", IS_CURRENT_SETTINGS(cts)? "ACTIVE" : "NVRAM",
4712                             bus, tgt, cts->ccb_h.target_lun, dval, oval, pval);
4713                 }
4714                 ccb->ccb_h.status = CAM_REQ_CMP;
4715                 xpt_done(ccb);
4716                 break;
4717
4718         case XPT_CALC_GEOMETRY:
4719                 cam_calc_geometry(&ccb->ccg, 1);
4720                 xpt_done(ccb);
4721                 break;
4722
4723         case XPT_RESET_BUS:             /* Reset the specified bus */
4724                 bus = cam_sim_bus(sim);
4725                 error = isp_control(isp, ISPCTL_RESET_BUS, bus);
4726                 if (error) {
4727                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
4728                         xpt_done(ccb);
4729                         break;
4730                 }
4731                 if (bootverbose) {
4732                         xpt_print(ccb->ccb_h.path, "reset bus on channel %d\n", bus);
4733                 }
4734                 if (IS_FC(isp)) {
4735                         xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, 0);
4736                 } else {
4737                         xpt_async(AC_BUS_RESET, ISP_SPI_PC(isp, bus)->path, 0);
4738                 }
4739                 ccb->ccb_h.status = CAM_REQ_CMP;
4740                 xpt_done(ccb);
4741                 break;
4742
4743         case XPT_TERM_IO:               /* Terminate the I/O process */
4744                 ccb->ccb_h.status = CAM_REQ_INVALID;
4745                 xpt_done(ccb);
4746                 break;
4747
4748 #if 0
4749         case XPT_SET_SIM_KNOB:          /* Set SIM knobs */
4750         {
4751                 struct ccb_sim_knob *kp = &ccb->knob;
4752                 fcparam *fcp;
4753
4754
4755                 if (!IS_FC(isp)) {
4756                         ccb->ccb_h.status = CAM_REQ_INVALID;
4757                         xpt_done(ccb);
4758                         break;
4759                 }
4760
4761                 bus = cam_sim_bus(xpt_path_sim(kp->ccb_h.path));
4762                 fcp = FCPARAM(isp, bus);
4763
4764                 if (kp->xport_specific.fc.valid & KNOB_VALID_ADDRESS) {
4765                         fcp->isp_wwnn = ISP_FC_PC(isp, bus)->def_wwnn = kp->xport_specific.fc.wwnn;
4766                         fcp->isp_wwpn = ISP_FC_PC(isp, bus)->def_wwpn = kp->xport_specific.fc.wwpn;
4767                         isp_prt(isp, ISP_LOGALL, "Setting Channel %d wwns to 0x%jx 0x%jx", bus, fcp->isp_wwnn, fcp->isp_wwpn);
4768                 }
4769                 ccb->ccb_h.status = CAM_REQ_CMP;
4770                 if (kp->xport_specific.fc.valid & KNOB_VALID_ROLE) {
4771                         int rchange = 0;
4772                         int newrole = 0;
4773
4774                         switch (kp->xport_specific.fc.role) {
4775                         case KNOB_ROLE_NONE:
4776                                 if (fcp->role != ISP_ROLE_NONE) {
4777                                         rchange = 1;
4778                                         newrole = ISP_ROLE_NONE;
4779                                 }
4780                                 break;
4781                         case KNOB_ROLE_TARGET:
4782                                 if (fcp->role != ISP_ROLE_TARGET) {
4783                                         rchange = 1;
4784                                         newrole = ISP_ROLE_TARGET;
4785                                 }
4786                                 break;
4787                         case KNOB_ROLE_INITIATOR:
4788                                 if (fcp->role != ISP_ROLE_INITIATOR) {
4789                                         rchange = 1;
4790                                         newrole = ISP_ROLE_INITIATOR;
4791                                 }
4792                                 break;
4793                         case KNOB_ROLE_BOTH:
4794 #if 0
4795                                 if (fcp->role != ISP_ROLE_BOTH) {
4796                                         rchange = 1;
4797                                         newrole = ISP_ROLE_BOTH;
4798                                 }
4799 #else
4800                                 /*
4801                                  * We don't really support dual role at present on FC cards.
4802                                  *
4803                                  * We should, but a bunch of things are currently broken,
4804                                  * so don't allow it.
4805                                  */
4806                                 isp_prt(isp, ISP_LOGERR, "cannot support dual role at present");
4807                                 ccb->ccb_h.status = CAM_REQ_INVALID;
4808 #endif
4809                                 break;
4810                         }
4811                         if (rchange) {
4812                                 if (isp_fc_change_role(isp, bus, newrole) != 0) {
4813                                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
4814 #ifdef  ISP_TARGET_MODE
4815                                 } else if (newrole == ISP_ROLE_TARGET || newrole == ISP_ROLE_BOTH) {
4816                                         isp_enable_deferred_luns(isp, bus);
4817 #endif
4818                                 }
4819                         }
4820                 }
4821                 xpt_done(ccb);
4822                 break;
4823         }
4824         case XPT_GET_SIM_KNOB:          /* Set SIM knobs */
4825         {
4826                 struct ccb_sim_knob *kp = &ccb->knob;
4827
4828                 if (IS_FC(isp)) {
4829                         fcparam *fcp;
4830
4831                         bus = cam_sim_bus(xpt_path_sim(kp->ccb_h.path));
4832                         fcp = FCPARAM(isp, bus);
4833
4834                         kp->xport_specific.fc.wwnn = fcp->isp_wwnn;
4835                         kp->xport_specific.fc.wwpn = fcp->isp_wwpn;
4836                         switch (fcp->role) {
4837                         case ISP_ROLE_NONE:
4838                                 kp->xport_specific.fc.role = KNOB_ROLE_NONE;
4839                                 break;
4840                         case ISP_ROLE_TARGET:
4841                                 kp->xport_specific.fc.role = KNOB_ROLE_TARGET;
4842                                 break;
4843                         case ISP_ROLE_INITIATOR:
4844                                 kp->xport_specific.fc.role = KNOB_ROLE_INITIATOR;
4845                                 break;
4846                         case ISP_ROLE_BOTH:
4847                                 kp->xport_specific.fc.role = KNOB_ROLE_BOTH;
4848                                 break;
4849                         }
4850                         kp->xport_specific.fc.valid = KNOB_VALID_ADDRESS | KNOB_VALID_ROLE;
4851                         ccb->ccb_h.status = CAM_REQ_CMP;
4852                 } else {
4853                         ccb->ccb_h.status = CAM_REQ_INVALID;
4854                 }
4855                 xpt_done(ccb);
4856                 break;
4857         }
4858 #endif
4859         case XPT_PATH_INQ:              /* Path routing inquiry */
4860         {
4861                 struct ccb_pathinq *cpi = &ccb->cpi;
4862
4863                 cpi->version_num = 1;
4864 #ifdef  ISP_TARGET_MODE
4865                 cpi->target_sprt = PIT_PROCESSOR | PIT_DISCONNECT | PIT_TERM_IO;
4866 #else
4867                 cpi->target_sprt = 0;
4868 #endif
4869                 cpi->hba_eng_cnt = 0;
4870                 cpi->max_target = ISP_MAX_TARGETS(isp) - 1;
4871                 cpi->max_lun = ISP_MAX_LUNS(isp) - 1;
4872                 cpi->bus_id = cam_sim_bus(sim);
4873                 bus = cam_sim_bus(xpt_path_sim(cpi->ccb_h.path));
4874                 if (IS_FC(isp)) {
4875                         fcparam *fcp = FCPARAM(isp, bus);
4876
4877                         cpi->hba_misc = PIM_NOBUSRESET;
4878
4879                         /*
4880                          * Because our loop ID can shift from time to time,
4881                          * make our initiator ID out of range of our bus.
4882                          */
4883                         cpi->initiator_id = cpi->max_target + 1;
4884
4885                         /*
4886                          * Set base transfer capabilities for Fibre Channel, for this HBA.
4887                          */
4888                         if (IS_25XX(isp)) {
4889                                 cpi->base_transfer_speed = 8000000;
4890                         } else if (IS_24XX(isp)) {
4891                                 cpi->base_transfer_speed = 4000000;
4892                         } else if (IS_23XX(isp)) {
4893                                 cpi->base_transfer_speed = 2000000;
4894                         } else {
4895                                 cpi->base_transfer_speed = 1000000;
4896                         }
4897                         cpi->hba_inquiry = PI_TAG_ABLE;
4898                         cpi->transport = XPORT_FC;
4899                         cpi->transport_version = 0;
4900                         cpi->xport_specific.fc.wwnn = fcp->isp_wwnn;
4901                         cpi->xport_specific.fc.wwpn = fcp->isp_wwpn;
4902                         cpi->xport_specific.fc.port = fcp->isp_portid;
4903                         cpi->xport_specific.fc.bitrate = fcp->isp_gbspeed * 1000;
4904                 } else {
4905                         sdparam *sdp = SDPARAM(isp, bus);
4906                         cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16;
4907                         cpi->hba_misc = 0;
4908                         cpi->initiator_id = sdp->isp_initiator_id;
4909                         cpi->base_transfer_speed = 3300;
4910                         cpi->transport = XPORT_SPI;
4911                         cpi->transport_version = 2;
4912                 }
4913                 cpi->protocol = PROTO_SCSI;
4914                 cpi->protocol_version = SCSI_REV_2;
4915                 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
4916                 strncpy(cpi->hba_vid, "Qlogic", HBA_IDLEN);
4917                 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
4918                 cpi->unit_number = cam_sim_unit(sim);
4919                 cpi->ccb_h.status = CAM_REQ_CMP;
4920                 xpt_done(ccb);
4921                 break;
4922         }
4923         default:
4924                 ccb->ccb_h.status = CAM_REQ_INVALID;
4925                 xpt_done(ccb);
4926                 break;
4927         }
4928 }
4929
4930 #define ISPDDB  (CAM_DEBUG_INFO|CAM_DEBUG_TRACE|CAM_DEBUG_CDB)
4931
4932 void
4933 isp_done(XS_T *sccb)
4934 {
4935         ispsoftc_t *isp = XS_ISP(sccb);
4936         uint32_t status;
4937
4938         if (XS_NOERR(sccb))
4939                 XS_SETERR(sccb, CAM_REQ_CMP);
4940
4941         if ((sccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP && (sccb->scsi_status != SCSI_STATUS_OK)) {
4942                 sccb->ccb_h.status &= ~CAM_STATUS_MASK;
4943                 if ((sccb->scsi_status == SCSI_STATUS_CHECK_COND) && (sccb->ccb_h.status & CAM_AUTOSNS_VALID) == 0) {
4944                         sccb->ccb_h.status |= CAM_AUTOSENSE_FAIL;
4945                 } else {
4946                         sccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
4947                 }
4948         }
4949
4950         sccb->ccb_h.status &= ~CAM_SIM_QUEUED;
4951         status = sccb->ccb_h.status & CAM_STATUS_MASK;
4952         if (status != CAM_REQ_CMP) {
4953                 if (status != CAM_SEL_TIMEOUT)
4954                         isp_prt(isp, ISP_LOGDEBUG0, "target %d lun %d CAM status 0x%x SCSI status 0x%x", XS_TGT(sccb), XS_LUN(sccb), sccb->ccb_h.status, sccb->scsi_status);
4955                 if ((sccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
4956                         sccb->ccb_h.status |= CAM_DEV_QFRZN;
4957                         xpt_freeze_devq(sccb->ccb_h.path, 1);
4958                 }
4959         }
4960
4961         if ((CAM_DEBUGGED(sccb->ccb_h.path, ISPDDB)) && (sccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4962                 xpt_print(sccb->ccb_h.path, "cam completion status 0x%x\n", sccb->ccb_h.status);
4963         }
4964
4965         XS_CMD_S_DONE(sccb);
4966         if (XS_TACTIVE_P(sccb))
4967                 callout_stop(&PISP_PCMD(sccb)->wdog);
4968         XS_CMD_S_CLEAR(sccb);
4969         isp_free_pcmd(isp, (union ccb *) sccb);
4970         xpt_done((union ccb *) sccb);
4971 }
4972
4973 void
4974 isp_async(ispsoftc_t *isp, ispasync_t cmd, ...)
4975 {
4976         int bus;
4977         static const char prom[] = "Chan %d PortID 0x%06x handle 0x%x role %s %s WWPN 0x%08x%08x";
4978         static const char prom2[] = "Chan %d PortID 0x%06x handle 0x%x role %s %s tgt %u WWPN 0x%08x%08x";
4979         char *msg = NULL;
4980         target_id_t tgt;
4981         fcportdb_t *lp;
4982         struct isp_fc *fc;
4983         struct cam_path *tmppath;
4984         __va_list ap;
4985
4986         switch (cmd) {
4987         case ISPASYNC_NEW_TGT_PARAMS:
4988         {
4989                 struct ccb_trans_settings_scsi *scsi;
4990                 struct ccb_trans_settings_spi *spi;
4991                 int flags, tgt;
4992                 sdparam *sdp;
4993                 struct ccb_trans_settings cts;
4994
4995                 memset(&cts, 0, sizeof (struct ccb_trans_settings));
4996
4997                 __va_start(ap, cmd);
4998                 bus = __va_arg(ap, int);
4999                 tgt = __va_arg(ap, int);
5000                 __va_end(ap);
5001                 sdp = SDPARAM(isp, bus);
5002
5003                 if (xpt_create_path(&tmppath, NULL, cam_sim_path(ISP_SPI_PC(isp, bus)->sim), tgt, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
5004                         isp_prt(isp, ISP_LOGWARN, "isp_async cannot make temp path for %d.%d", tgt, bus);
5005                         break;
5006                 }
5007                 flags = sdp->isp_devparam[tgt].actv_flags;
5008                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
5009                 cts.protocol = PROTO_SCSI;
5010                 cts.transport = XPORT_SPI;
5011
5012                 scsi = &cts.proto_specific.scsi;
5013                 spi = &cts.xport_specific.spi;
5014
5015                 if (flags & DPARM_TQING) {
5016                         scsi->valid |= CTS_SCSI_VALID_TQ;
5017                         scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
5018                 }
5019
5020                 if (flags & DPARM_DISC) {
5021                         spi->valid |= CTS_SPI_VALID_DISC;
5022                         spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
5023                 }
5024                 spi->flags |= CTS_SPI_VALID_BUS_WIDTH;
5025                 if (flags & DPARM_WIDE) {
5026                         spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
5027                 } else {
5028                         spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
5029                 }
5030                 if (flags & DPARM_SYNC) {
5031                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
5032                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
5033                         spi->sync_period = sdp->isp_devparam[tgt].actv_period;
5034                         spi->sync_offset = sdp->isp_devparam[tgt].actv_offset;
5035                 }
5036                 isp_prt(isp, ISP_LOGDEBUG2, "NEW_TGT_PARAMS bus %d tgt %d period %x offset %x flags %x", bus, tgt, sdp->isp_devparam[tgt].actv_period, sdp->isp_devparam[tgt].actv_offset, flags);
5037                 xpt_setup_ccb(&cts.ccb_h, tmppath, 1);
5038                 xpt_async(AC_TRANSFER_NEG, tmppath, &cts);
5039                 xpt_free_path(tmppath);
5040                 break;
5041         }
5042         case ISPASYNC_BUS_RESET:
5043         {
5044                 __va_start(ap, cmd);
5045                 bus = __va_arg(ap, int);
5046                 __va_end(ap);
5047                 isp_prt(isp, ISP_LOGINFO, "SCSI bus reset on bus %d detected", bus);
5048                 if (IS_FC(isp)) {
5049                         xpt_async(AC_BUS_RESET, ISP_FC_PC(isp, bus)->path, NULL);
5050                 } else {
5051                         xpt_async(AC_BUS_RESET, ISP_SPI_PC(isp, bus)->path, NULL);
5052                 }
5053                 break;
5054         }
5055         case ISPASYNC_LIP:
5056                 if (msg == NULL) {
5057                         msg = "LIP Received";
5058                 }
5059                 /* FALLTHROUGH */
5060         case ISPASYNC_LOOP_RESET:
5061                 if (msg == NULL) {
5062                         msg = "LOOP Reset";
5063                 }
5064                 /* FALLTHROUGH */
5065         case ISPASYNC_LOOP_DOWN:
5066         {
5067                 if (msg == NULL) {
5068                         msg = "LOOP Down";
5069                 }
5070                 __va_start(ap, cmd);
5071                 bus = __va_arg(ap, int);
5072                 __va_end(ap);
5073
5074                 FCPARAM(isp, bus)->link_active = 0;
5075
5076                 fc = ISP_FC_PC(isp, bus);
5077                 if (cmd == ISPASYNC_LOOP_DOWN && fc->ready) {
5078                         /*
5079                          * We don't do any simq freezing if we are only in target mode
5080                          */
5081                         if (FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) {
5082                                 if (fc->path) {
5083                                         isp_freeze_loopdown(isp, bus, msg);
5084                                 }
5085                                 if (!callout_active(&fc->ldt)) {
5086                                         callout_reset(&fc->ldt, fc->loop_down_limit * hz, isp_ldt, fc);
5087                                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Starting Loop Down Timer @ %lu", (unsigned long) time_second);
5088                                 }
5089                         }
5090                 }
5091                 isp_prt(isp, ISP_LOGINFO, "Chan %d: %s", bus, msg);
5092                 break;
5093         }
5094         case ISPASYNC_LOOP_UP:
5095                 __va_start(ap, cmd);
5096                 bus = __va_arg(ap, int);
5097                 __va_end(ap);
5098                 fc = ISP_FC_PC(isp, bus);
5099                 /*
5100                  * Now we just note that Loop has come up. We don't
5101                  * actually do anything because we're waiting for a
5102                  * Change Notify before activating the FC cleanup
5103                  * thread to look at the state of the loop again.
5104                  */
5105                 FCPARAM(isp, bus)->link_active = 1;
5106                 fc->loop_dead = 0;
5107                 fc->loop_down_time = 0;
5108                 isp_prt(isp, ISP_LOGINFO, "Chan %d Loop UP", bus);
5109                 break;
5110         case ISPASYNC_DEV_ARRIVED:
5111                 __va_start(ap, cmd);
5112                 bus = __va_arg(ap, int);
5113                 lp = __va_arg(ap, fcportdb_t *);
5114                 __va_end(ap);
5115                 fc = ISP_FC_PC(isp, bus);
5116                 lp->reserved = 0;
5117                 lp->gone_timer = 0;
5118                 if ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) && (lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT))) {
5119                         int dbidx = lp - FCPARAM(isp, bus)->portdb;
5120                         int i;
5121
5122                         for (i = 0; i < MAX_FC_TARG; i++) {
5123                                 if (i >= FL_ID && i <= SNS_ID) {
5124                                         continue;
5125                                 }
5126                                 if (FCPARAM(isp, bus)->isp_dev_map[i] == 0) {
5127                                         break;
5128                                 }
5129                         }
5130                         if (i < MAX_FC_TARG) {
5131                                 FCPARAM(isp, bus)->isp_dev_map[i] = dbidx + 1;
5132                                 lp->dev_map_idx = i + 1;
5133                         } else {
5134                                 isp_prt(isp, ISP_LOGWARN, "out of target ids");
5135                                 isp_dump_portdb(isp, bus);
5136                         }
5137                 }
5138                 if (lp->dev_map_idx) {
5139                         tgt = lp->dev_map_idx - 1;
5140                         isp_prt(isp, ISP_LOGCONFIG, prom2, bus, lp->portid, lp->handle, roles[lp->roles], "arrived at", tgt, (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5141                         isp_make_here(isp, bus, tgt);
5142                 } else {
5143                         isp_prt(isp, ISP_LOGCONFIG, prom, bus, lp->portid, lp->handle, roles[lp->roles], "arrived", (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5144                 }
5145                 break;
5146         case ISPASYNC_DEV_CHANGED:
5147                 __va_start(ap, cmd);
5148                 bus = __va_arg(ap, int);
5149                 lp = __va_arg(ap, fcportdb_t *);
5150                 __va_end(ap);
5151                 fc = ISP_FC_PC(isp, bus);
5152                 lp->reserved = 0;
5153                 lp->gone_timer = 0;
5154                 if (isp_change_is_bad) {
5155                         lp->state = FC_PORTDB_STATE_NIL;
5156                         if (lp->dev_map_idx) {
5157                                 tgt = lp->dev_map_idx - 1;
5158                                 FCPARAM(isp, bus)->isp_dev_map[tgt] = 0;
5159                                 lp->dev_map_idx = 0;
5160                                 isp_prt(isp, ISP_LOGCONFIG, prom3, bus, lp->portid, tgt, "change is bad");
5161                                 isp_make_gone(isp, bus, tgt);
5162                         } else {
5163                                 isp_prt(isp, ISP_LOGCONFIG, prom, bus, lp->portid, lp->handle, roles[lp->roles], "changed and departed",
5164                                     (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5165                         }
5166                 } else {
5167                         lp->portid = lp->new_portid;
5168                         lp->roles = lp->new_roles;
5169                         if (lp->dev_map_idx) {
5170                                 int t = lp->dev_map_idx - 1;
5171                                 FCPARAM(isp, bus)->isp_dev_map[t] = (lp - FCPARAM(isp, bus)->portdb) + 1;
5172                                 tgt = lp->dev_map_idx - 1;
5173                                 isp_prt(isp, ISP_LOGCONFIG, prom2, bus, lp->portid, lp->handle, roles[lp->roles], "changed at", tgt,
5174                                     (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5175                         } else {
5176                                 isp_prt(isp, ISP_LOGCONFIG, prom, bus, lp->portid, lp->handle, roles[lp->roles], "changed", (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5177                         }
5178                 }
5179                 break;
5180         case ISPASYNC_DEV_STAYED:
5181                 __va_start(ap, cmd);
5182                 bus = __va_arg(ap, int);
5183                 lp = __va_arg(ap, fcportdb_t *);
5184                 __va_end(ap);
5185                 if (lp->dev_map_idx) {
5186                         tgt = lp->dev_map_idx - 1;
5187                         isp_prt(isp, ISP_LOGCONFIG, prom2, bus, lp->portid, lp->handle, roles[lp->roles], "stayed at", tgt,
5188                             (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5189                 } else {
5190                         isp_prt(isp, ISP_LOGCONFIG, prom, bus, lp->portid, lp->handle, roles[lp->roles], "stayed",
5191                             (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5192                 }
5193                 break;
5194         case ISPASYNC_DEV_GONE:
5195                 __va_start(ap, cmd);
5196                 bus = __va_arg(ap, int);
5197                 lp = __va_arg(ap, fcportdb_t *);
5198                 __va_end(ap);
5199                 fc = ISP_FC_PC(isp, bus);
5200                 /*
5201                  * If this has a virtual target and we haven't marked it
5202                  * that we're going to have isp_gdt tell the OS it's gone,
5203                  * set the isp_gdt timer running on it.
5204                  *
5205                  * If it isn't marked that isp_gdt is going to get rid of it,
5206                  * announce that it's gone.
5207                  *
5208                  */
5209                 if (lp->dev_map_idx && lp->reserved == 0) {
5210                         lp->reserved = 1;
5211                         lp->state = FC_PORTDB_STATE_ZOMBIE;
5212                         lp->gone_timer = ISP_FC_PC(isp, bus)->gone_device_time;
5213                         if (fc->ready && !callout_active(&fc->gdt)) {
5214                                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d Starting Gone Device Timer with %u seconds time now %lu", bus, lp->gone_timer, (unsigned long)time_second);
5215                                 callout_reset(&fc->gdt, hz, isp_gdt, fc);
5216                         }
5217                         tgt = lp->dev_map_idx - 1;
5218                         isp_prt(isp, ISP_LOGCONFIG, prom2, bus, lp->portid, lp->handle, roles[lp->roles], "gone zombie at", tgt, (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5219                 } else if (lp->reserved == 0) {
5220                         isp_prt(isp, ISP_LOGCONFIG, prom, bus, lp->portid, lp->handle, roles[lp->roles], "departed", (uint32_t) (lp->port_wwn >> 32), (uint32_t) lp->port_wwn);
5221                 }
5222                 break;
5223         case ISPASYNC_CHANGE_NOTIFY:
5224         {
5225                 char *msg;
5226                 int evt, nphdl, nlstate, reason;
5227
5228                 __va_start(ap, cmd);
5229                 bus = __va_arg(ap, int);
5230                 evt = __va_arg(ap, int);
5231                 if (IS_24XX(isp) && evt == ISPASYNC_CHANGE_PDB) {
5232                         nphdl = __va_arg(ap, int);
5233                         nlstate = __va_arg(ap, int);
5234                         reason = __va_arg(ap, int);
5235                 } else {
5236                         nphdl = NIL_HANDLE;
5237                         nlstate = reason = 0;
5238                 }
5239                 __va_end(ap);
5240                 fc = ISP_FC_PC(isp, bus);
5241
5242                 if (evt == ISPASYNC_CHANGE_PDB) {
5243                         msg = "Chan %d Port Database Changed";
5244                 } else if (evt == ISPASYNC_CHANGE_SNS) {
5245                         msg = "Chan %d Name Server Database Changed";
5246                 } else {
5247                         msg = "Chan %d Other Change Notify";
5248                 }
5249
5250                 /*
5251                  * If the loop down timer is running, cancel it.
5252                  */
5253                 if (fc->ready && callout_active(&fc->ldt)) {
5254                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Stopping Loop Down Timer @ %lu", (unsigned long) time_second);
5255                         callout_stop(&fc->ldt);
5256                 }
5257                 isp_prt(isp, ISP_LOGINFO, msg, bus);
5258                 if (FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) {
5259                         isp_freeze_loopdown(isp, bus, msg);
5260                 }
5261                 wakeup(fc);
5262                 break;
5263         }
5264 #ifdef  ISP_TARGET_MODE
5265         case ISPASYNC_TARGET_NOTIFY:
5266         {
5267                 isp_notify_t *notify;
5268                 __va_start(ap, cmd);
5269                 notify = __va_arg(ap, isp_notify_t *);
5270                 __va_end(ap);
5271                 switch (notify->nt_ncode) {
5272                 case NT_ABORT_TASK:
5273                 case NT_ABORT_TASK_SET:
5274                 case NT_CLEAR_ACA:
5275                 case NT_CLEAR_TASK_SET:
5276                 case NT_LUN_RESET:
5277                 case NT_TARGET_RESET:
5278                         /*
5279                          * These are task management functions.
5280                          */
5281                         isp_handle_platform_target_tmf(isp, notify);
5282                         break;
5283                 case NT_BUS_RESET:
5284                 case NT_LIP_RESET:
5285                 case NT_LINK_UP:
5286                 case NT_LINK_DOWN:
5287                         /*
5288                          * No action need be taken here.
5289                          */
5290                         break;
5291                 case NT_HBA_RESET:
5292                         isp_del_all_wwn_entries(isp, ISP_NOCHAN);
5293                         break;
5294                 case NT_LOGOUT:
5295                         /*
5296                          * This is device arrival/departure notification
5297                          */
5298                         isp_handle_platform_target_notify_ack(isp, notify);
5299                         break;
5300                 case NT_ARRIVED:
5301                 {
5302                         struct ac_contract ac;
5303                         struct ac_device_changed *fc;
5304
5305                         ac.contract_number = AC_CONTRACT_DEV_CHG;
5306                         fc = (struct ac_device_changed *) ac.contract_data;
5307                         fc->wwpn = notify->nt_wwn;
5308                         fc->port = notify->nt_sid;
5309                         fc->target = notify->nt_nphdl;
5310                         fc->arrived = 1;
5311                         xpt_async(AC_CONTRACT, ISP_FC_PC(isp, notify->nt_channel)->path, &ac);
5312                         break;
5313                 }
5314                 case NT_DEPARTED:
5315                 {
5316                         struct ac_contract ac;
5317                         struct ac_device_changed *fc;
5318
5319                         ac.contract_number = AC_CONTRACT_DEV_CHG;
5320                         fc = (struct ac_device_changed *) ac.contract_data;
5321                         fc->wwpn = notify->nt_wwn;
5322                         fc->port = notify->nt_sid;
5323                         fc->target = notify->nt_nphdl;
5324                         fc->arrived = 0;
5325                         xpt_async(AC_CONTRACT, ISP_FC_PC(isp, notify->nt_channel)->path, &ac);
5326                         break;
5327                 }
5328                 default:
5329                         isp_prt(isp, ISP_LOGALL, "target notify code 0x%x", notify->nt_ncode);
5330                         isp_handle_platform_target_notify_ack(isp, notify);
5331                         break;
5332                 }
5333                 break;
5334         }
5335         case ISPASYNC_TARGET_ACTION:
5336         {
5337                 isphdr_t *hp;
5338
5339                 __va_start(ap, cmd);
5340                 hp = __va_arg(ap, isphdr_t *);
5341                 __va_end(ap);
5342                 switch (hp->rqs_entry_type) {
5343                 default:
5344                         isp_prt(isp, ISP_LOGWARN, "%s: unhandled target action 0x%x", __func__, hp->rqs_entry_type);
5345                         break;
5346                 case RQSTYPE_NOTIFY:
5347                         if (IS_SCSI(isp)) {
5348                                 isp_handle_platform_notify_scsi(isp, (in_entry_t *) hp);
5349                         } else if (IS_24XX(isp)) {
5350                                 isp_handle_platform_notify_24xx(isp, (in_fcentry_24xx_t *) hp);
5351                         } else {
5352                                 isp_handle_platform_notify_fc(isp, (in_fcentry_t *) hp);
5353                         }
5354                         break;
5355                 case RQSTYPE_ATIO:
5356                         if (IS_24XX(isp)) {
5357                                 isp_handle_platform_atio7(isp, (at7_entry_t *) hp);
5358                         } else {
5359                                 isp_handle_platform_atio(isp, (at_entry_t *) hp);
5360                         }
5361                         break;
5362                 case RQSTYPE_ATIO2:
5363                         isp_handle_platform_atio2(isp, (at2_entry_t *) hp);
5364                         break;
5365                 case RQSTYPE_CTIO7:
5366                 case RQSTYPE_CTIO3:
5367                 case RQSTYPE_CTIO2:
5368                 case RQSTYPE_CTIO:
5369                         isp_handle_platform_ctio(isp, hp);
5370                         break;
5371                 case RQSTYPE_ABTS_RCVD:
5372                 {
5373                         abts_t *abts = (abts_t *)hp;
5374                         isp_notify_t notify, *nt = &notify;
5375                         tstate_t *tptr;
5376                         fcportdb_t *lp;
5377                         uint16_t chan;
5378                         uint32_t sid, did;
5379
5380                         did = (abts->abts_did_hi << 16) | abts->abts_did_lo;
5381                         sid = (abts->abts_sid_hi << 16) | abts->abts_sid_lo;
5382                         ISP_MEMZERO(nt, sizeof (isp_notify_t));
5383
5384                         nt->nt_hba = isp;
5385                         nt->nt_did = did;
5386                         nt->nt_nphdl = abts->abts_nphdl;
5387                         nt->nt_sid = sid;
5388                         isp_find_chan_by_did(isp, did, &chan);
5389                         if (chan == ISP_NOCHAN) {
5390                                 nt->nt_tgt = TGT_ANY;
5391                         } else {
5392                                 nt->nt_tgt = FCPARAM(isp, chan)->isp_wwpn;
5393                                 if (isp_find_pdb_by_loopid(isp, chan, abts->abts_nphdl, &lp)) {
5394                                         nt->nt_wwn = lp->port_wwn;
5395                                 } else {
5396                                         nt->nt_wwn = INI_ANY;
5397                                 }
5398                         }
5399                         /*
5400                          * Try hard to find the lun for this command.
5401                          */
5402                         tptr = get_lun_statep_from_tag(isp, chan, abts->abts_rxid_task);
5403                         if (tptr) {
5404                                 nt->nt_lun = xpt_path_lun_id(tptr->owner);
5405                                 rls_lun_statep(isp, tptr);
5406                         } else {
5407                                 nt->nt_lun = LUN_ANY;
5408                         }
5409                         nt->nt_need_ack = 1;
5410                         nt->nt_tagval = abts->abts_rxid_task;
5411                         nt->nt_tagval |= (((uint64_t) abts->abts_rxid_abts) << 32);
5412                         if (abts->abts_rxid_task == ISP24XX_NO_TASK) {
5413                                 isp_prt(isp, ISP_LOGTINFO, "[0x%x] ABTS from N-Port handle 0x%x Port 0x%06x has no task id (rx_id 0x%04x ox_id 0x%04x)",
5414                                     abts->abts_rxid_abts, abts->abts_nphdl, sid, abts->abts_rx_id, abts->abts_ox_id);
5415                         } else {
5416                                 isp_prt(isp, ISP_LOGTINFO, "[0x%x] ABTS from N-Port handle 0x%x Port 0x%06x for task 0x%x (rx_id 0x%04x ox_id 0x%04x)",
5417                                     abts->abts_rxid_abts, abts->abts_nphdl, sid, abts->abts_rxid_task, abts->abts_rx_id, abts->abts_ox_id);
5418                         }
5419                         nt->nt_channel = chan;
5420                         nt->nt_ncode = NT_ABORT_TASK;
5421                         nt->nt_lreserved = hp;
5422                         isp_handle_platform_target_tmf(isp, nt);
5423                         break;
5424                 }
5425                 case RQSTYPE_ENABLE_LUN:
5426                 case RQSTYPE_MODIFY_LUN:
5427                         isp_ledone(isp, (lun_entry_t *) hp);
5428                         break;
5429                 }
5430                 break;
5431         }
5432 #endif
5433         case ISPASYNC_FW_CRASH:
5434         {
5435                 uint16_t mbox1, mbox6;
5436                 mbox1 = ISP_READ(isp, OUTMAILBOX1);
5437                 if (IS_DUALBUS(isp)) {
5438                         mbox6 = ISP_READ(isp, OUTMAILBOX6);
5439                 } else {
5440                         mbox6 = 0;
5441                 }
5442                 isp_prt(isp, ISP_LOGERR, "Internal Firmware Error on bus %d @ RISC Address 0x%x", mbox6, mbox1);
5443                 mbox1 = isp->isp_osinfo.mbox_sleep_ok;
5444                 isp->isp_osinfo.mbox_sleep_ok = 0;
5445                 isp_reinit(isp, 1);
5446                 isp->isp_osinfo.mbox_sleep_ok = mbox1;
5447                 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
5448                 break;
5449         }
5450         default:
5451                 isp_prt(isp, ISP_LOGERR, "unknown isp_async event %d", cmd);
5452                 break;
5453         }
5454 }
5455
5456
5457 /*
5458  * Locks are held before coming here.
5459  */
5460 void
5461 isp_uninit(ispsoftc_t *isp)
5462 {
5463         if (IS_24XX(isp)) {
5464                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
5465         } else {
5466                 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
5467         }
5468         ISP_DISABLE_INTS(isp);
5469 }
5470
5471 /*
5472  * When we want to get the 'default' WWNs (when lacking NVRAM), we pick them
5473  * up from our platform default (defww{p|n}n) and morph them based upon
5474  * channel.
5475  *
5476  * When we want to get the 'active' WWNs, we get NVRAM WWNs and then morph them
5477  * based upon channel.
5478  */
5479
5480 uint64_t
5481 isp_default_wwn(ispsoftc_t * isp, int chan, int isactive, int iswwnn)
5482 {
5483         uint64_t seed;
5484         struct isp_fc *fc = ISP_FC_PC(isp, chan);
5485
5486         /*
5487          * If we're asking for a active WWN, the default overrides get
5488          * returned, otherwise the NVRAM value is picked.
5489          *
5490          * If we're asking for a default WWN, we just pick the default override.
5491          */
5492         if (isactive) {
5493                 seed = iswwnn ? fc->def_wwnn : fc->def_wwpn;
5494                 if (seed) {
5495                         return (seed);
5496                 }
5497                 seed = iswwnn ? FCPARAM(isp, chan)->isp_wwnn_nvram : FCPARAM(isp, chan)->isp_wwpn_nvram;
5498                 if (seed) {
5499                         return (seed);
5500                 }
5501                 return (0x400000007F000009ull);
5502         } else {
5503                 seed = iswwnn ? fc->def_wwnn : fc->def_wwpn;
5504         }
5505
5506
5507         /*
5508          * For channel zero just return what we have. For either ACTIVE or
5509          * DEFAULT cases, we depend on default override of NVRAM values for
5510          * channel zero.
5511          */
5512         if (chan == 0) {
5513                 return (seed);
5514         }
5515
5516         /*
5517          * For other channels, we are doing one of three things:
5518          *
5519          * 1. If what we have now is non-zero, return it. Otherwise we morph
5520          * values from channel 0. 2. If we're here for a WWPN we synthesize
5521          * it if Channel 0's wwpn has a type 2 NAA. 3. If we're here for a
5522          * WWNN we synthesize it if Channel 0's wwnn has a type 2 NAA.
5523          */
5524
5525         if (seed) {
5526                 return (seed);
5527         }
5528         if (isactive) {
5529                 seed = iswwnn ? FCPARAM(isp, 0)->isp_wwnn_nvram : FCPARAM(isp, 0)->isp_wwpn_nvram;
5530         } else {
5531                 seed = iswwnn ? ISP_FC_PC(isp, 0)->def_wwnn : ISP_FC_PC(isp, 0)->def_wwpn;
5532         }
5533
5534         if (((seed >> 60) & 0xf) == 2) {
5535                 /*
5536                  * The type 2 NAA fields for QLogic cards appear be laid out
5537                  * thusly:
5538                  *
5539                  * bits 63..60 NAA == 2 bits 59..57 unused/zero bit 56
5540                  * port (1) or node (0) WWN distinguishor bit 48
5541                  * physical port on dual-port chips (23XX/24XX)
5542                  *
5543                  * This is somewhat nutty, particularly since bit 48 is
5544                  * irrelevant as they assign separate serial numbers to
5545                  * different physical ports anyway.
5546                  *
5547                  * We'll stick our channel number plus one first into bits
5548                  * 57..59 and thence into bits 52..55 which allows for 8 bits
5549                  * of channel which is comfortably more than our maximum
5550                  * (126) now.
5551                  */
5552                 seed &= ~0x0FF0000000000000ULL;
5553                 if (iswwnn == 0) {
5554                         seed |= ((uint64_t) (chan + 1) & 0xf) << 56;
5555                         seed |= ((uint64_t) ((chan + 1) >> 4) & 0xf) << 52;
5556                 }
5557         } else {
5558                 seed = 0;
5559         }
5560         return (seed);
5561 }
5562
5563 void
5564 isp_prt(ispsoftc_t *isp, int level, const char *fmt, ...)
5565 {
5566         int loc;
5567         char lbuf[128];
5568         __va_list ap;
5569
5570         if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
5571                 return;
5572         }
5573         ksprintf(lbuf, "%s: ", device_get_nameunit(isp->isp_dev));
5574         loc = strlen(lbuf);
5575         __va_start(ap, fmt);
5576         kvsnprintf(&lbuf[loc], sizeof (lbuf) - loc - 1, fmt, ap);
5577         __va_end(ap);
5578         kprintf("%s\n", lbuf);
5579 }
5580
5581 void
5582 isp_xs_prt(ispsoftc_t *isp, XS_T *xs, int level, const char *fmt, ...)
5583 {
5584         __va_list ap;
5585         if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
5586                 return;
5587         }
5588         xpt_print_path(xs->ccb_h.path);
5589         __va_start(ap, fmt);
5590         kvprintf(fmt, ap);
5591         __va_end(ap);
5592         kprintf("\n");
5593 }
5594
5595 uint64_t
5596 isp_nanotime_sub(struct timespec *b, struct timespec *a)
5597 {
5598         uint64_t elapsed;
5599         struct timespec x = *b;
5600         timespecsub(&x, a);
5601         elapsed = GET_NANOSEC(&x);
5602         if (elapsed == 0)
5603                 elapsed++;
5604         return (elapsed);
5605 }
5606
5607 int
5608 isp_mbox_acquire(ispsoftc_t *isp)
5609 {
5610         if (isp->isp_osinfo.mboxbsy) {
5611                 return (1);
5612         } else {
5613                 isp->isp_osinfo.mboxcmd_done = 0;
5614                 isp->isp_osinfo.mboxbsy = 1;
5615                 return (0);
5616         }
5617 }
5618
5619 void
5620 isp_mbox_wait_complete(ispsoftc_t *isp, mbreg_t *mbp)
5621 {
5622         unsigned int usecs = mbp->timeout;
5623         unsigned int max, olim, ilim;
5624
5625         if (usecs == 0) {
5626                 usecs = MBCMD_DEFAULT_TIMEOUT;
5627         }
5628         max = isp->isp_mbxwrk0 + 1;
5629
5630         if (isp->isp_osinfo.mbox_sleep_ok) {
5631                 unsigned int ms = (usecs + 999) / 1000;
5632
5633                 isp->isp_osinfo.mbox_sleep_ok = 0;
5634                 isp->isp_osinfo.mbox_sleeping = 1;
5635                 for (olim = 0; olim < max; olim++) {
5636                         lksleep(&isp->isp_mbxworkp, &isp->isp_osinfo.lock, 0, "ispmbx_sleep", isp_mstohz(ms));
5637                         if (isp->isp_osinfo.mboxcmd_done) {
5638                                 break;
5639                         }
5640                 }
5641                 isp->isp_osinfo.mbox_sleep_ok = 1;
5642                 isp->isp_osinfo.mbox_sleeping = 0;
5643         } else {
5644                 for (olim = 0; olim < max; olim++) {
5645                         for (ilim = 0; ilim < usecs; ilim += 100) {
5646                                 uint32_t isr;
5647                                 uint16_t sema, mbox;
5648                                 if (isp->isp_osinfo.mboxcmd_done) {
5649                                         break;
5650                                 }
5651                                 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
5652                                         isp_intr(isp, isr, sema, mbox);
5653                                         if (isp->isp_osinfo.mboxcmd_done) {
5654                                                 break;
5655                                         }
5656                                 }
5657                                 ISP_DELAY(100);
5658                         }
5659                         if (isp->isp_osinfo.mboxcmd_done) {
5660                                 break;
5661                         }
5662                 }
5663         }
5664         if (isp->isp_osinfo.mboxcmd_done == 0) {
5665                 isp_prt(isp, ISP_LOGWARN, "%s Mailbox Command (0x%x) Timeout (%uus) (started @ %s:%d)",
5666                     isp->isp_osinfo.mbox_sleep_ok? "Interrupting" : "Polled", isp->isp_lastmbxcmd, usecs, mbp->func, mbp->lineno);
5667                 mbp->param[0] = MBOX_TIMEOUT;
5668                 isp->isp_osinfo.mboxcmd_done = 1;
5669         }
5670 }
5671
5672 void
5673 isp_mbox_notify_done(ispsoftc_t *isp)
5674 {
5675         if (isp->isp_osinfo.mbox_sleeping) {
5676                 wakeup(&isp->isp_mbxworkp);
5677         }
5678         isp->isp_osinfo.mboxcmd_done = 1;
5679 }
5680
5681 void
5682 isp_mbox_release(ispsoftc_t *isp)
5683 {
5684         isp->isp_osinfo.mboxbsy = 0;
5685 }
5686
5687 int
5688 isp_fc_scratch_acquire(ispsoftc_t *isp, int chan)
5689 {
5690         int ret = 0;
5691         if (isp->isp_osinfo.pc.fc[chan].fcbsy) {
5692                 ret = -1;
5693         } else {
5694                 isp->isp_osinfo.pc.fc[chan].fcbsy = 1;
5695         }
5696         return (ret);
5697 }
5698
5699 int
5700 isp_mstohz(int ms)
5701 {
5702         int hz;
5703         struct timeval t;
5704         t.tv_sec = ms / 1000;
5705         t.tv_usec = (ms % 1000) * 1000;
5706         hz = tvtohz_high(&t);
5707         if (hz < 0) {
5708                 hz = 0x7fffffff;
5709         }
5710         if (hz == 0) {
5711                 hz = 1;
5712         }
5713         return (hz);
5714 }
5715
5716 void
5717 isp_platform_intr(void *arg)
5718 {
5719         ispsoftc_t *isp = arg;
5720         uint32_t isr;
5721         uint16_t sema, mbox;
5722
5723         ISP_LOCK(isp);
5724         isp->isp_intcnt++;
5725         if (ISP_READ_ISR(isp, &isr, &sema, &mbox) == 0) {
5726                 isp->isp_intbogus++;
5727         } else {
5728                 isp_intr(isp, isr, sema, mbox);
5729         }
5730         ISP_UNLOCK(isp);
5731 }
5732
5733 void
5734 isp_common_dmateardown(ispsoftc_t *isp, struct ccb_scsiio *csio, uint32_t hdl)
5735 {
5736         if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
5737                 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_POSTREAD);
5738         } else {
5739                 bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_POSTWRITE);
5740         }
5741         bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
5742 }
5743
5744 void
5745 isp_timer(void *arg)
5746 {
5747         ispsoftc_t *isp = arg;
5748
5749         ISP_LOCK(isp);
5750 #ifdef  ISP_TARGET_MODE
5751         isp_tmcmd_restart(isp);
5752 #endif
5753         ISP_UNLOCK(isp);
5754         callout_reset(&isp->isp_osinfo.tmo, hz, isp_timer, isp);
5755 }