1 /* 2 * Platform (FreeBSD) dependent common attachment code for Qlogic adapters. 3 * 4 * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice immediately at the beginning of the file, without modification, 11 * this list of conditions, and the following disclaimer. 12 * 2. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 19 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <dev/isp/isp_freebsd.h> 32 #include <sys/unistd.h> 33 #include <sys/kthread.h> 34 #include <machine/stdarg.h> /* for use by isp_prt below */ 35 #include <sys/conf.h> 36 #include <sys/module.h> 37 #include <sys/ioccom.h> 38 #include <dev/isp/isp_ioctl.h> 39 40 41 MODULE_VERSION(isp, 1); 42 int isp_announced = 0; 43 ispfwfunc *isp_get_firmware_p = NULL; 44 45 static d_ioctl_t ispioctl; 46 static void isp_intr_enable(void *); 47 static void isp_cam_async(void *, u_int32_t, struct cam_path *, void *); 48 static void isp_poll(struct cam_sim *); 49 static timeout_t isp_watchdog; 50 static void isp_kthread(void *); 51 static void isp_action(struct cam_sim *, union ccb *); 52 53 54 #define ISP_CDEV_MAJOR 248 55 static struct cdevsw isp_cdevsw = { 56 .d_open = nullopen, 57 .d_close = nullclose, 58 .d_ioctl = ispioctl, 59 .d_name = "isp", 60 .d_maj = ISP_CDEV_MAJOR, 61 .d_flags = D_TAPE, 62 }; 63 64 static struct ispsoftc *isplist = NULL; 65 66 void 67 isp_attach(struct ispsoftc *isp) 68 { 69 int primary, secondary; 70 struct ccb_setasync csa; 71 struct cam_devq *devq; 72 struct cam_sim *sim; 73 struct cam_path *path; 74 75 /* 76 * Establish (in case of 12X0) which bus is the primary. 77 */ 78 79 primary = 0; 80 secondary = 1; 81 82 /* 83 * Create the device queue for our SIM(s). 84 */ 85 devq = cam_simq_alloc(isp->isp_maxcmds); 86 if (devq == NULL) { 87 return; 88 } 89 90 /* 91 * Construct our SIM entry. 92 */ 93 ISPLOCK_2_CAMLOCK(isp); 94 sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp, 95 device_get_unit(isp->isp_dev), 1, isp->isp_maxcmds, devq); 96 if (sim == NULL) { 97 cam_simq_free(devq); 98 CAMLOCK_2_ISPLOCK(isp); 99 return; 100 } 101 CAMLOCK_2_ISPLOCK(isp); 102 103 isp->isp_osinfo.ehook.ich_func = isp_intr_enable; 104 isp->isp_osinfo.ehook.ich_arg = isp; 105 ISPLOCK_2_CAMLOCK(isp); 106 if (config_intrhook_establish(&isp->isp_osinfo.ehook) != 0) { 107 cam_sim_free(sim, TRUE); 108 CAMLOCK_2_ISPLOCK(isp); 109 isp_prt(isp, ISP_LOGERR, 110 "could not establish interrupt enable hook"); 111 return; 112 } 113 114 if (xpt_bus_register(sim, primary) != CAM_SUCCESS) { 115 cam_sim_free(sim, TRUE); 116 CAMLOCK_2_ISPLOCK(isp); 117 return; 118 } 119 120 if (xpt_create_path(&path, NULL, cam_sim_path(sim), 121 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 122 xpt_bus_deregister(cam_sim_path(sim)); 123 cam_sim_free(sim, TRUE); 124 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 125 CAMLOCK_2_ISPLOCK(isp); 126 return; 127 } 128 129 xpt_setup_ccb(&csa.ccb_h, path, 5); 130 csa.ccb_h.func_code = XPT_SASYNC_CB; 131 csa.event_enable = AC_LOST_DEVICE; 132 csa.callback = isp_cam_async; 133 csa.callback_arg = sim; 134 xpt_action((union ccb *)&csa); 135 CAMLOCK_2_ISPLOCK(isp); 136 isp->isp_sim = sim; 137 isp->isp_path = path; 138 /* 139 * Create a kernel thread for fibre channel instances. We 140 * don't have dual channel FC cards. 141 */ 142 if (IS_FC(isp)) { 143 ISPLOCK_2_CAMLOCK(isp); 144 /* XXX: LOCK VIOLATION */ 145 cv_init(&isp->isp_osinfo.kthread_cv, "isp_kthread_cv"); 146 if (kthread_create(isp_kthread, isp, &isp->isp_osinfo.kproc, 147 RFHIGHPID, 0, "%s: fc_thrd", 148 device_get_nameunit(isp->isp_dev))) { 149 xpt_bus_deregister(cam_sim_path(sim)); 150 cam_sim_free(sim, TRUE); 151 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 152 CAMLOCK_2_ISPLOCK(isp); 153 isp_prt(isp, ISP_LOGERR, "could not create kthread"); 154 return; 155 } 156 CAMLOCK_2_ISPLOCK(isp); 157 } 158 159 160 /* 161 * If we have a second channel, construct SIM entry for that. 162 */ 163 if (IS_DUALBUS(isp)) { 164 ISPLOCK_2_CAMLOCK(isp); 165 sim = cam_sim_alloc(isp_action, isp_poll, "isp", isp, 166 device_get_unit(isp->isp_dev), 1, isp->isp_maxcmds, devq); 167 if (sim == NULL) { 168 xpt_bus_deregister(cam_sim_path(isp->isp_sim)); 169 xpt_free_path(isp->isp_path); 170 cam_simq_free(devq); 171 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 172 return; 173 } 174 if (xpt_bus_register(sim, secondary) != CAM_SUCCESS) { 175 xpt_bus_deregister(cam_sim_path(isp->isp_sim)); 176 xpt_free_path(isp->isp_path); 177 cam_sim_free(sim, TRUE); 178 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 179 CAMLOCK_2_ISPLOCK(isp); 180 return; 181 } 182 183 if (xpt_create_path(&path, NULL, cam_sim_path(sim), 184 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 185 xpt_bus_deregister(cam_sim_path(isp->isp_sim)); 186 xpt_free_path(isp->isp_path); 187 xpt_bus_deregister(cam_sim_path(sim)); 188 cam_sim_free(sim, TRUE); 189 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 190 CAMLOCK_2_ISPLOCK(isp); 191 return; 192 } 193 194 xpt_setup_ccb(&csa.ccb_h, path, 5); 195 csa.ccb_h.func_code = XPT_SASYNC_CB; 196 csa.event_enable = AC_LOST_DEVICE; 197 csa.callback = isp_cam_async; 198 csa.callback_arg = sim; 199 xpt_action((union ccb *)&csa); 200 CAMLOCK_2_ISPLOCK(isp); 201 isp->isp_sim2 = sim; 202 isp->isp_path2 = path; 203 } 204 205 #ifdef ISP_TARGET_MODE 206 cv_init(&isp->isp_osinfo.tgtcv0[0], "isp_tgcv0a"); 207 cv_init(&isp->isp_osinfo.tgtcv0[1], "isp_tgcv0b"); 208 cv_init(&isp->isp_osinfo.tgtcv1[0], "isp_tgcv1a"); 209 cv_init(&isp->isp_osinfo.tgtcv1[1], "isp_tgcv1b"); 210 #endif 211 /* 212 * Create device nodes 213 */ 214 (void) make_dev(&isp_cdevsw, device_get_unit(isp->isp_dev), UID_ROOT, 215 GID_OPERATOR, 0600, "%s", device_get_nameunit(isp->isp_dev)); 216 217 if (isp->isp_role != ISP_ROLE_NONE) { 218 isp->isp_state = ISP_RUNSTATE; 219 ENABLE_INTS(isp); 220 } 221 if (isplist == NULL) { 222 isplist = isp; 223 } else { 224 struct ispsoftc *tmp = isplist; 225 while (tmp->isp_osinfo.next) { 226 tmp = tmp->isp_osinfo.next; 227 } 228 tmp->isp_osinfo.next = isp; 229 } 230 231 } 232 233 static INLINE void 234 isp_freeze_loopdown(struct ispsoftc *isp, char *msg) 235 { 236 if (isp->isp_osinfo.simqfrozen == 0) { 237 isp_prt(isp, ISP_LOGDEBUG0, "%s: freeze simq (loopdown)", msg); 238 isp->isp_osinfo.simqfrozen |= SIMQFRZ_LOOPDOWN; 239 ISPLOCK_2_CAMLOCK(isp); 240 xpt_freeze_simq(isp->isp_sim, 1); 241 CAMLOCK_2_ISPLOCK(isp); 242 } else { 243 isp_prt(isp, ISP_LOGDEBUG0, "%s: mark frozen (loopdown)", msg); 244 isp->isp_osinfo.simqfrozen |= SIMQFRZ_LOOPDOWN; 245 } 246 } 247 248 static int 249 ispioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) 250 { 251 struct ispsoftc *isp; 252 int retval = ENOTTY; 253 254 isp = isplist; 255 while (isp) { 256 if (minor(dev) == device_get_unit(isp->isp_dev)) { 257 break; 258 } 259 isp = isp->isp_osinfo.next; 260 } 261 if (isp == NULL) 262 return (ENXIO); 263 264 switch (cmd) { 265 #ifdef ISP_FW_CRASH_DUMP 266 case ISP_GET_FW_CRASH_DUMP: 267 { 268 u_int16_t *ptr = FCPARAM(isp)->isp_dump_data; 269 size_t sz; 270 271 retval = 0; 272 if (IS_2200(isp)) 273 sz = QLA2200_RISC_IMAGE_DUMP_SIZE; 274 else 275 sz = QLA2300_RISC_IMAGE_DUMP_SIZE; 276 ISP_LOCK(isp); 277 if (ptr && *ptr) { 278 void *uaddr = *((void **) addr); 279 if (copyout(ptr, uaddr, sz)) { 280 retval = EFAULT; 281 } else { 282 *ptr = 0; 283 } 284 } else { 285 retval = ENXIO; 286 } 287 ISP_UNLOCK(isp); 288 break; 289 } 290 291 case ISP_FORCE_CRASH_DUMP: 292 ISP_LOCK(isp); 293 isp_freeze_loopdown(isp, "ispioctl(ISP_FORCE_CRASH_DUMP)"); 294 isp_fw_dump(isp); 295 isp_reinit(isp); 296 ISP_UNLOCK(isp); 297 retval = 0; 298 break; 299 #endif 300 case ISP_SDBLEV: 301 { 302 int olddblev = isp->isp_dblev; 303 isp->isp_dblev = *(int *)addr; 304 *(int *)addr = olddblev; 305 retval = 0; 306 break; 307 } 308 case ISP_RESETHBA: 309 ISP_LOCK(isp); 310 isp_reinit(isp); 311 ISP_UNLOCK(isp); 312 retval = 0; 313 break; 314 case ISP_RESCAN: 315 if (IS_FC(isp)) { 316 ISP_LOCK(isp); 317 if (isp_fc_runstate(isp, 5 * 1000000)) { 318 retval = EIO; 319 } else { 320 retval = 0; 321 } 322 ISP_UNLOCK(isp); 323 } 324 break; 325 case ISP_FC_LIP: 326 if (IS_FC(isp)) { 327 ISP_LOCK(isp); 328 if (isp_control(isp, ISPCTL_SEND_LIP, 0)) { 329 retval = EIO; 330 } else { 331 retval = 0; 332 } 333 ISP_UNLOCK(isp); 334 } 335 break; 336 case ISP_FC_GETDINFO: 337 { 338 struct isp_fc_device *ifc = (struct isp_fc_device *) addr; 339 struct lportdb *lp; 340 341 if (ifc->loopid < 0 || ifc->loopid >= MAX_FC_TARG) { 342 retval = EINVAL; 343 break; 344 } 345 ISP_LOCK(isp); 346 lp = &FCPARAM(isp)->portdb[ifc->loopid]; 347 if (lp->valid) { 348 ifc->loopid = lp->loopid; 349 ifc->portid = lp->portid; 350 ifc->node_wwn = lp->node_wwn; 351 ifc->port_wwn = lp->port_wwn; 352 retval = 0; 353 } else { 354 retval = ENODEV; 355 } 356 ISP_UNLOCK(isp); 357 break; 358 } 359 case ISP_GET_STATS: 360 { 361 isp_stats_t *sp = (isp_stats_t *) addr; 362 363 MEMZERO(sp, sizeof (*sp)); 364 sp->isp_stat_version = ISP_STATS_VERSION; 365 sp->isp_type = isp->isp_type; 366 sp->isp_revision = isp->isp_revision; 367 ISP_LOCK(isp); 368 sp->isp_stats[ISP_INTCNT] = isp->isp_intcnt; 369 sp->isp_stats[ISP_INTBOGUS] = isp->isp_intbogus; 370 sp->isp_stats[ISP_INTMBOXC] = isp->isp_intmboxc; 371 sp->isp_stats[ISP_INGOASYNC] = isp->isp_intoasync; 372 sp->isp_stats[ISP_RSLTCCMPLT] = isp->isp_rsltccmplt; 373 sp->isp_stats[ISP_FPHCCMCPLT] = isp->isp_fphccmplt; 374 sp->isp_stats[ISP_RSCCHIWAT] = isp->isp_rscchiwater; 375 sp->isp_stats[ISP_FPCCHIWAT] = isp->isp_fpcchiwater; 376 ISP_UNLOCK(isp); 377 retval = 0; 378 break; 379 } 380 case ISP_CLR_STATS: 381 ISP_LOCK(isp); 382 isp->isp_intcnt = 0; 383 isp->isp_intbogus = 0; 384 isp->isp_intmboxc = 0; 385 isp->isp_intoasync = 0; 386 isp->isp_rsltccmplt = 0; 387 isp->isp_fphccmplt = 0; 388 isp->isp_rscchiwater = 0; 389 isp->isp_fpcchiwater = 0; 390 ISP_UNLOCK(isp); 391 retval = 0; 392 break; 393 case ISP_FC_GETHINFO: 394 { 395 struct isp_hba_device *hba = (struct isp_hba_device *) addr; 396 MEMZERO(hba, sizeof (*hba)); 397 ISP_LOCK(isp); 398 hba->fc_speed = FCPARAM(isp)->isp_gbspeed; 399 hba->fc_scsi_supported = 1; 400 hba->fc_topology = FCPARAM(isp)->isp_topo + 1; 401 hba->fc_loopid = FCPARAM(isp)->isp_loopid; 402 hba->active_node_wwn = FCPARAM(isp)->isp_nodewwn; 403 hba->active_port_wwn = FCPARAM(isp)->isp_portwwn; 404 ISP_UNLOCK(isp); 405 retval = 0; 406 break; 407 } 408 case ISP_GET_FC_PARAM: 409 { 410 struct isp_fc_param *f = (struct isp_fc_param *) addr; 411 412 if (!IS_FC(isp)) { 413 retval = EINVAL; 414 break; 415 } 416 f->parameter = 0; 417 if (strcmp(f->param_name, "framelength") == 0) { 418 f->parameter = FCPARAM(isp)->isp_maxfrmlen; 419 retval = 0; 420 break; 421 } 422 if (strcmp(f->param_name, "exec_throttle") == 0) { 423 f->parameter = FCPARAM(isp)->isp_execthrottle; 424 retval = 0; 425 break; 426 } 427 if (strcmp(f->param_name, "fullduplex") == 0) { 428 if (FCPARAM(isp)->isp_fwoptions & ICBOPT_FULL_DUPLEX) 429 f->parameter = 1; 430 retval = 0; 431 break; 432 } 433 if (strcmp(f->param_name, "loopid") == 0) { 434 f->parameter = FCPARAM(isp)->isp_loopid; 435 retval = 0; 436 break; 437 } 438 retval = EINVAL; 439 break; 440 } 441 case ISP_SET_FC_PARAM: 442 { 443 struct isp_fc_param *f = (struct isp_fc_param *) addr; 444 u_int32_t param = f->parameter; 445 446 if (!IS_FC(isp)) { 447 retval = EINVAL; 448 break; 449 } 450 f->parameter = 0; 451 if (strcmp(f->param_name, "framelength") == 0) { 452 if (param != 512 && param != 1024 && param != 1024) { 453 retval = EINVAL; 454 break; 455 } 456 FCPARAM(isp)->isp_maxfrmlen = param; 457 retval = 0; 458 break; 459 } 460 if (strcmp(f->param_name, "exec_throttle") == 0) { 461 if (param < 16 || param > 255) { 462 retval = EINVAL; 463 break; 464 } 465 FCPARAM(isp)->isp_execthrottle = param; 466 retval = 0; 467 break; 468 } 469 if (strcmp(f->param_name, "fullduplex") == 0) { 470 if (param != 0 && param != 1) { 471 retval = EINVAL; 472 break; 473 } 474 if (param) { 475 FCPARAM(isp)->isp_fwoptions |= 476 ICBOPT_FULL_DUPLEX; 477 } else { 478 FCPARAM(isp)->isp_fwoptions &= 479 ~ICBOPT_FULL_DUPLEX; 480 } 481 retval = 0; 482 break; 483 } 484 if (strcmp(f->param_name, "loopid") == 0) { 485 if (param < 0 || param > 125) { 486 retval = EINVAL; 487 break; 488 } 489 FCPARAM(isp)->isp_loopid = param; 490 retval = 0; 491 break; 492 } 493 retval = EINVAL; 494 break; 495 } 496 default: 497 break; 498 } 499 return (retval); 500 } 501 502 static void 503 isp_intr_enable(void *arg) 504 { 505 struct ispsoftc *isp = arg; 506 if (isp->isp_role != ISP_ROLE_NONE) { 507 ENABLE_INTS(isp); 508 isp->isp_osinfo.intsok = 1; 509 } 510 /* Release our hook so that the boot can continue. */ 511 config_intrhook_disestablish(&isp->isp_osinfo.ehook); 512 } 513 514 /* 515 * Put the target mode functions here, because some are inlines 516 */ 517 518 #ifdef ISP_TARGET_MODE 519 520 static INLINE int is_lun_enabled(struct ispsoftc *, int, lun_id_t); 521 static INLINE int are_any_luns_enabled(struct ispsoftc *, int); 522 static INLINE tstate_t *get_lun_statep(struct ispsoftc *, int, lun_id_t); 523 static INLINE void rls_lun_statep(struct ispsoftc *, tstate_t *); 524 static INLINE int isp_psema_sig_rqe(struct ispsoftc *, int); 525 static INLINE int isp_cv_wait_timed_rqe(struct ispsoftc *, int, int); 526 static INLINE void isp_cv_signal_rqe(struct ispsoftc *, int, int); 527 static INLINE void isp_vsema_rqe(struct ispsoftc *, int); 528 static INLINE atio_private_data_t *isp_get_atpd(struct ispsoftc *, int); 529 static cam_status 530 create_lun_state(struct ispsoftc *, int, struct cam_path *, tstate_t **); 531 static void destroy_lun_state(struct ispsoftc *, tstate_t *); 532 static void isp_en_lun(struct ispsoftc *, union ccb *); 533 static cam_status isp_abort_tgt_ccb(struct ispsoftc *, union ccb *); 534 static timeout_t isp_refire_putback_atio; 535 static void isp_complete_ctio(union ccb *); 536 static void isp_target_putback_atio(union ccb *); 537 static cam_status isp_target_start_ctio(struct ispsoftc *, union ccb *); 538 static int isp_handle_platform_atio(struct ispsoftc *, at_entry_t *); 539 static int isp_handle_platform_atio2(struct ispsoftc *, at2_entry_t *); 540 static int isp_handle_platform_ctio(struct ispsoftc *, void *); 541 static int isp_handle_platform_notify_scsi(struct ispsoftc *, in_entry_t *); 542 static int isp_handle_platform_notify_fc(struct ispsoftc *, in_fcentry_t *); 543 544 static INLINE int 545 is_lun_enabled(struct ispsoftc *isp, int bus, lun_id_t lun) 546 { 547 tstate_t *tptr; 548 tptr = isp->isp_osinfo.lun_hash[LUN_HASH_FUNC(isp, bus, lun)]; 549 if (tptr == NULL) { 550 return (0); 551 } 552 do { 553 if (tptr->lun == (lun_id_t) lun && tptr->bus == bus) { 554 return (1); 555 } 556 } while ((tptr = tptr->next) != NULL); 557 return (0); 558 } 559 560 static INLINE int 561 are_any_luns_enabled(struct ispsoftc *isp, int port) 562 { 563 int lo, hi; 564 if (IS_DUALBUS(isp)) { 565 lo = (port * (LUN_HASH_SIZE >> 1)); 566 hi = lo + (LUN_HASH_SIZE >> 1); 567 } else { 568 lo = 0; 569 hi = LUN_HASH_SIZE; 570 } 571 for (lo = 0; lo < hi; lo++) { 572 if (isp->isp_osinfo.lun_hash[lo]) { 573 return (1); 574 } 575 } 576 return (0); 577 } 578 579 static INLINE tstate_t * 580 get_lun_statep(struct ispsoftc *isp, int bus, lun_id_t lun) 581 { 582 tstate_t *tptr = NULL; 583 584 if (lun == CAM_LUN_WILDCARD) { 585 if (isp->isp_osinfo.tmflags[bus] & TM_WILDCARD_ENABLED) { 586 tptr = &isp->isp_osinfo.tsdflt[bus]; 587 tptr->hold++; 588 return (tptr); 589 } 590 } else { 591 tptr = isp->isp_osinfo.lun_hash[LUN_HASH_FUNC(isp, bus, lun)]; 592 if (tptr == NULL) { 593 return (NULL); 594 } 595 } 596 597 do { 598 if (tptr->lun == lun && tptr->bus == bus) { 599 tptr->hold++; 600 return (tptr); 601 } 602 } while ((tptr = tptr->next) != NULL); 603 return (tptr); 604 } 605 606 static INLINE void 607 rls_lun_statep(struct ispsoftc *isp, tstate_t *tptr) 608 { 609 if (tptr->hold) 610 tptr->hold--; 611 } 612 613 static INLINE int 614 isp_psema_sig_rqe(struct ispsoftc *isp, int bus) 615 { 616 while (isp->isp_osinfo.tmflags[bus] & TM_BUSY) { 617 isp->isp_osinfo.tmflags[bus] |= TM_WANTED; 618 #ifdef ISP_SMPLOCK 619 if (cv_wait_sig(&isp->isp_osinfo.tgtcv0[bus], &isp->isp_lock)) { 620 return (-1); 621 } 622 #else 623 if (tsleep(&isp->isp_osinfo.tgtcv0[bus], PZERO, "cv_isp", 0)) { 624 return (-1); 625 } 626 #endif 627 isp->isp_osinfo.tmflags[bus] |= TM_BUSY; 628 } 629 return (0); 630 } 631 632 static INLINE int 633 isp_cv_wait_timed_rqe(struct ispsoftc *isp, int bus, int timo) 634 { 635 #ifdef ISP_SMPLOCK 636 if (cv_timedwait(&isp->isp_osinfo.tgtcv1[bus], &isp->isp_lock, timo)) { 637 return (-1); 638 } 639 #else 640 if (tsleep(&isp->isp_osinfo.tgtcv1[bus], PZERO, "cv_isp1", 0)) { 641 return (-1); 642 } 643 #endif 644 return (0); 645 } 646 647 static INLINE void 648 isp_cv_signal_rqe(struct ispsoftc *isp, int bus, int status) 649 { 650 isp->isp_osinfo.rstatus[bus] = status; 651 #ifdef ISP_SMPLOCK 652 cv_signal(&isp->isp_osinfo.tgtcv1[bus]); 653 #else 654 wakeup(&isp->isp_osinfo.tgtcv1[bus]); 655 #endif 656 } 657 658 static INLINE void 659 isp_vsema_rqe(struct ispsoftc *isp, int bus) 660 { 661 if (isp->isp_osinfo.tmflags[bus] & TM_WANTED) { 662 isp->isp_osinfo.tmflags[bus] &= ~TM_WANTED; 663 #ifdef ISP_SMPLOCK 664 cv_signal(&isp->isp_osinfo.tgtcv0[bus]); 665 #else 666 cv_signal(&isp->isp_osinfo.tgtcv0[bus]); 667 #endif 668 } 669 isp->isp_osinfo.tmflags[bus] &= ~TM_BUSY; 670 } 671 672 static INLINE atio_private_data_t * 673 isp_get_atpd(struct ispsoftc *isp, int tag) 674 { 675 atio_private_data_t *atp; 676 for (atp = isp->isp_osinfo.atpdp; 677 atp < &isp->isp_osinfo.atpdp[ATPDPSIZE]; atp++) { 678 if (atp->tag == tag) 679 return (atp); 680 } 681 return (NULL); 682 } 683 684 static cam_status 685 create_lun_state(struct ispsoftc *isp, int bus, 686 struct cam_path *path, tstate_t **rslt) 687 { 688 cam_status status; 689 lun_id_t lun; 690 int hfx; 691 tstate_t *tptr, *new; 692 693 lun = xpt_path_lun_id(path); 694 if (lun < 0) { 695 return (CAM_LUN_INVALID); 696 } 697 if (is_lun_enabled(isp, bus, lun)) { 698 return (CAM_LUN_ALRDY_ENA); 699 } 700 new = (tstate_t *) malloc(sizeof (tstate_t), M_DEVBUF, M_NOWAIT|M_ZERO); 701 if (new == NULL) { 702 return (CAM_RESRC_UNAVAIL); 703 } 704 705 status = xpt_create_path(&new->owner, NULL, xpt_path_path_id(path), 706 xpt_path_target_id(path), xpt_path_lun_id(path)); 707 if (status != CAM_REQ_CMP) { 708 free(new, M_DEVBUF); 709 return (status); 710 } 711 new->bus = bus; 712 new->lun = lun; 713 SLIST_INIT(&new->atios); 714 SLIST_INIT(&new->inots); 715 new->hold = 1; 716 717 hfx = LUN_HASH_FUNC(isp, new->bus, new->lun); 718 tptr = isp->isp_osinfo.lun_hash[hfx]; 719 if (tptr == NULL) { 720 isp->isp_osinfo.lun_hash[hfx] = new; 721 } else { 722 while (tptr->next) 723 tptr = tptr->next; 724 tptr->next = new; 725 } 726 *rslt = new; 727 return (CAM_REQ_CMP); 728 } 729 730 static INLINE void 731 destroy_lun_state(struct ispsoftc *isp, tstate_t *tptr) 732 { 733 int hfx; 734 tstate_t *lw, *pw; 735 736 hfx = LUN_HASH_FUNC(isp, tptr->bus, tptr->lun); 737 if (tptr->hold) { 738 return; 739 } 740 pw = isp->isp_osinfo.lun_hash[hfx]; 741 if (pw == NULL) { 742 return; 743 } else if (pw->lun == tptr->lun && pw->bus == tptr->bus) { 744 isp->isp_osinfo.lun_hash[hfx] = pw->next; 745 } else { 746 lw = pw; 747 pw = lw->next; 748 while (pw) { 749 if (pw->lun == tptr->lun && pw->bus == tptr->bus) { 750 lw->next = pw->next; 751 break; 752 } 753 lw = pw; 754 pw = pw->next; 755 } 756 if (pw == NULL) { 757 return; 758 } 759 } 760 free(tptr, M_DEVBUF); 761 } 762 763 /* 764 * we enter with our locks held. 765 */ 766 static void 767 isp_en_lun(struct ispsoftc *isp, union ccb *ccb) 768 { 769 const char lfmt[] = "Lun now %sabled for target mode on channel %d"; 770 struct ccb_en_lun *cel = &ccb->cel; 771 tstate_t *tptr; 772 u_int16_t rstat; 773 int bus, cmd, av, wildcard; 774 lun_id_t lun; 775 target_id_t tgt; 776 777 778 bus = XS_CHANNEL(ccb) & 0x1; 779 tgt = ccb->ccb_h.target_id; 780 lun = ccb->ccb_h.target_lun; 781 782 /* 783 * Do some sanity checking first. 784 */ 785 786 if ((lun != CAM_LUN_WILDCARD) && 787 (lun < 0 || lun >= (lun_id_t) isp->isp_maxluns)) { 788 ccb->ccb_h.status = CAM_LUN_INVALID; 789 return; 790 } 791 792 if (IS_SCSI(isp)) { 793 sdparam *sdp = isp->isp_param; 794 sdp += bus; 795 if (tgt != CAM_TARGET_WILDCARD && 796 tgt != sdp->isp_initiator_id) { 797 ccb->ccb_h.status = CAM_TID_INVALID; 798 return; 799 } 800 } else { 801 if (tgt != CAM_TARGET_WILDCARD && 802 tgt != FCPARAM(isp)->isp_iid) { 803 ccb->ccb_h.status = CAM_TID_INVALID; 804 return; 805 } 806 /* 807 * This is as a good a place as any to check f/w capabilities. 808 */ 809 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_TMODE) == 0) { 810 isp_prt(isp, ISP_LOGERR, 811 "firmware does not support target mode"); 812 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 813 return; 814 } 815 /* 816 * XXX: We *could* handle non-SCCLUN f/w, but we'd have to 817 * XXX: dorks with our already fragile enable/disable code. 818 */ 819 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) { 820 isp_prt(isp, ISP_LOGERR, 821 "firmware not SCCLUN capable"); 822 } 823 } 824 825 if (tgt == CAM_TARGET_WILDCARD) { 826 if (lun == CAM_LUN_WILDCARD) { 827 wildcard = 1; 828 } else { 829 ccb->ccb_h.status = CAM_LUN_INVALID; 830 return; 831 } 832 } else { 833 wildcard = 0; 834 } 835 836 /* 837 * Next check to see whether this is a target/lun wildcard action. 838 * 839 * If so, we know that we can accept commands for luns that haven't 840 * been enabled yet and send them upstream. Otherwise, we have to 841 * handle them locally (if we see them at all). 842 */ 843 844 if (wildcard) { 845 tptr = &isp->isp_osinfo.tsdflt[bus]; 846 if (cel->enable) { 847 if (isp->isp_osinfo.tmflags[bus] & 848 TM_WILDCARD_ENABLED) { 849 ccb->ccb_h.status = CAM_LUN_ALRDY_ENA; 850 return; 851 } 852 ccb->ccb_h.status = 853 xpt_create_path(&tptr->owner, NULL, 854 xpt_path_path_id(ccb->ccb_h.path), 855 xpt_path_target_id(ccb->ccb_h.path), 856 xpt_path_lun_id(ccb->ccb_h.path)); 857 if (ccb->ccb_h.status != CAM_REQ_CMP) { 858 return; 859 } 860 SLIST_INIT(&tptr->atios); 861 SLIST_INIT(&tptr->inots); 862 isp->isp_osinfo.tmflags[bus] |= TM_WILDCARD_ENABLED; 863 } else { 864 if ((isp->isp_osinfo.tmflags[bus] & 865 TM_WILDCARD_ENABLED) == 0) { 866 ccb->ccb_h.status = CAM_REQ_CMP; 867 return; 868 } 869 if (tptr->hold) { 870 ccb->ccb_h.status = CAM_SCSI_BUSY; 871 return; 872 } 873 xpt_free_path(tptr->owner); 874 isp->isp_osinfo.tmflags[bus] &= ~TM_WILDCARD_ENABLED; 875 } 876 } 877 878 /* 879 * Now check to see whether this bus needs to be 880 * enabled/disabled with respect to target mode. 881 */ 882 av = bus << 31; 883 if (cel->enable && !(isp->isp_osinfo.tmflags[bus] & TM_TMODE_ENABLED)) { 884 av |= ENABLE_TARGET_FLAG; 885 av = isp_control(isp, ISPCTL_TOGGLE_TMODE, &av); 886 if (av) { 887 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 888 if (wildcard) { 889 isp->isp_osinfo.tmflags[bus] &= 890 ~TM_WILDCARD_ENABLED; 891 xpt_free_path(tptr->owner); 892 } 893 return; 894 } 895 isp->isp_osinfo.tmflags[bus] |= TM_TMODE_ENABLED; 896 isp_prt(isp, ISP_LOGINFO, 897 "Target Mode enabled on channel %d", bus); 898 } else if (cel->enable == 0 && 899 (isp->isp_osinfo.tmflags[bus] & TM_TMODE_ENABLED) && wildcard) { 900 if (are_any_luns_enabled(isp, bus)) { 901 ccb->ccb_h.status = CAM_SCSI_BUSY; 902 return; 903 } 904 av = isp_control(isp, ISPCTL_TOGGLE_TMODE, &av); 905 if (av) { 906 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 907 return; 908 } 909 isp->isp_osinfo.tmflags[bus] &= ~TM_TMODE_ENABLED; 910 isp_prt(isp, ISP_LOGINFO, 911 "Target Mode disabled on channel %d", bus); 912 } 913 914 if (wildcard) { 915 ccb->ccb_h.status = CAM_REQ_CMP; 916 return; 917 } 918 919 if (cel->enable) { 920 ccb->ccb_h.status = 921 create_lun_state(isp, bus, ccb->ccb_h.path, &tptr); 922 if (ccb->ccb_h.status != CAM_REQ_CMP) { 923 return; 924 } 925 } else { 926 tptr = get_lun_statep(isp, bus, lun); 927 if (tptr == NULL) { 928 ccb->ccb_h.status = CAM_LUN_INVALID; 929 return; 930 } 931 } 932 933 if (isp_psema_sig_rqe(isp, bus)) { 934 rls_lun_statep(isp, tptr); 935 if (cel->enable) 936 destroy_lun_state(isp, tptr); 937 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 938 return; 939 } 940 941 if (cel->enable) { 942 u_int32_t seq = isp->isp_osinfo.rollinfo++; 943 int c, n, ulun = lun; 944 945 cmd = RQSTYPE_ENABLE_LUN; 946 c = DFLT_CMND_CNT; 947 n = DFLT_INOT_CNT; 948 if (IS_FC(isp) && lun != 0) { 949 cmd = RQSTYPE_MODIFY_LUN; 950 n = 0; 951 /* 952 * For SCC firmware, we only deal with setting 953 * (enabling or modifying) lun 0. 954 */ 955 ulun = 0; 956 } 957 rstat = LUN_ERR; 958 if (isp_lun_cmd(isp, cmd, bus, tgt, ulun, c, n, seq)) { 959 xpt_print_path(ccb->ccb_h.path); 960 isp_prt(isp, ISP_LOGWARN, "isp_lun_cmd failed"); 961 goto out; 962 } 963 if (isp_cv_wait_timed_rqe(isp, bus, 30 * hz)) { 964 xpt_print_path(ccb->ccb_h.path); 965 isp_prt(isp, ISP_LOGERR, 966 "wait for ENABLE/MODIFY LUN timed out"); 967 goto out; 968 } 969 rstat = isp->isp_osinfo.rstatus[bus]; 970 if (rstat != LUN_OK) { 971 xpt_print_path(ccb->ccb_h.path); 972 isp_prt(isp, ISP_LOGERR, 973 "ENABLE/MODIFY LUN returned 0x%x", rstat); 974 goto out; 975 } 976 } else { 977 int c, n, ulun = lun; 978 u_int32_t seq; 979 980 rstat = LUN_ERR; 981 seq = isp->isp_osinfo.rollinfo++; 982 cmd = -RQSTYPE_MODIFY_LUN; 983 984 c = DFLT_CMND_CNT; 985 n = DFLT_INOT_CNT; 986 if (IS_FC(isp) && lun != 0) { 987 n = 0; 988 /* 989 * For SCC firmware, we only deal with setting 990 * (enabling or modifying) lun 0. 991 */ 992 ulun = 0; 993 } 994 if (isp_lun_cmd(isp, cmd, bus, tgt, ulun, c, n, seq)) { 995 xpt_print_path(ccb->ccb_h.path); 996 isp_prt(isp, ISP_LOGERR, "isp_lun_cmd failed"); 997 goto out; 998 } 999 if (isp_cv_wait_timed_rqe(isp, bus, 30 * hz)) { 1000 xpt_print_path(ccb->ccb_h.path); 1001 isp_prt(isp, ISP_LOGERR, 1002 "wait for MODIFY LUN timed out"); 1003 goto out; 1004 } 1005 rstat = isp->isp_osinfo.rstatus[bus]; 1006 if (rstat != LUN_OK) { 1007 xpt_print_path(ccb->ccb_h.path); 1008 isp_prt(isp, ISP_LOGERR, 1009 "MODIFY LUN returned 0x%x", rstat); 1010 goto out; 1011 } 1012 if (IS_FC(isp) && lun) { 1013 goto out; 1014 } 1015 1016 seq = isp->isp_osinfo.rollinfo++; 1017 1018 rstat = LUN_ERR; 1019 cmd = -RQSTYPE_ENABLE_LUN; 1020 if (isp_lun_cmd(isp, cmd, bus, tgt, lun, 0, 0, seq)) { 1021 xpt_print_path(ccb->ccb_h.path); 1022 isp_prt(isp, ISP_LOGERR, "isp_lun_cmd failed"); 1023 goto out; 1024 } 1025 if (isp_cv_wait_timed_rqe(isp, bus, 30 * hz)) { 1026 xpt_print_path(ccb->ccb_h.path); 1027 isp_prt(isp, ISP_LOGERR, 1028 "wait for DISABLE LUN timed out"); 1029 goto out; 1030 } 1031 rstat = isp->isp_osinfo.rstatus[bus]; 1032 if (rstat != LUN_OK) { 1033 xpt_print_path(ccb->ccb_h.path); 1034 isp_prt(isp, ISP_LOGWARN, 1035 "DISABLE LUN returned 0x%x", rstat); 1036 goto out; 1037 } 1038 if (are_any_luns_enabled(isp, bus) == 0) { 1039 av = isp_control(isp, ISPCTL_TOGGLE_TMODE, &av); 1040 if (av) { 1041 isp_prt(isp, ISP_LOGWARN, 1042 "disable target mode on channel %d failed", 1043 bus); 1044 goto out; 1045 } 1046 isp->isp_osinfo.tmflags[bus] &= ~TM_TMODE_ENABLED; 1047 xpt_print_path(ccb->ccb_h.path); 1048 isp_prt(isp, ISP_LOGINFO, 1049 "Target Mode disabled on channel %d", bus); 1050 } 1051 } 1052 1053 out: 1054 isp_vsema_rqe(isp, bus); 1055 1056 if (rstat != LUN_OK) { 1057 xpt_print_path(ccb->ccb_h.path); 1058 isp_prt(isp, ISP_LOGWARN, 1059 "lun %sable failed", (cel->enable) ? "en" : "dis"); 1060 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1061 rls_lun_statep(isp, tptr); 1062 if (cel->enable) 1063 destroy_lun_state(isp, tptr); 1064 } else { 1065 xpt_print_path(ccb->ccb_h.path); 1066 isp_prt(isp, ISP_LOGINFO, lfmt, 1067 (cel->enable) ? "en" : "dis", bus); 1068 rls_lun_statep(isp, tptr); 1069 if (cel->enable == 0) { 1070 destroy_lun_state(isp, tptr); 1071 } 1072 ccb->ccb_h.status = CAM_REQ_CMP; 1073 } 1074 } 1075 1076 static cam_status 1077 isp_abort_tgt_ccb(struct ispsoftc *isp, union ccb *ccb) 1078 { 1079 tstate_t *tptr; 1080 struct ccb_hdr_slist *lp; 1081 struct ccb_hdr *curelm; 1082 int found; 1083 union ccb *accb = ccb->cab.abort_ccb; 1084 1085 if (accb->ccb_h.target_id != CAM_TARGET_WILDCARD) { 1086 if (IS_FC(isp) && (accb->ccb_h.target_id != 1087 ((fcparam *) isp->isp_param)->isp_loopid)) { 1088 return (CAM_PATH_INVALID); 1089 } else if (IS_SCSI(isp) && (accb->ccb_h.target_id != 1090 ((sdparam *) isp->isp_param)->isp_initiator_id)) { 1091 return (CAM_PATH_INVALID); 1092 } 1093 } 1094 tptr = get_lun_statep(isp, XS_CHANNEL(ccb), accb->ccb_h.target_lun); 1095 if (tptr == NULL) { 1096 return (CAM_PATH_INVALID); 1097 } 1098 if (accb->ccb_h.func_code == XPT_ACCEPT_TARGET_IO) { 1099 lp = &tptr->atios; 1100 } else if (accb->ccb_h.func_code == XPT_IMMED_NOTIFY) { 1101 lp = &tptr->inots; 1102 } else { 1103 rls_lun_statep(isp, tptr); 1104 return (CAM_UA_ABORT); 1105 } 1106 curelm = SLIST_FIRST(lp); 1107 found = 0; 1108 if (curelm == &accb->ccb_h) { 1109 found = 1; 1110 SLIST_REMOVE_HEAD(lp, sim_links.sle); 1111 } else { 1112 while(curelm != NULL) { 1113 struct ccb_hdr *nextelm; 1114 1115 nextelm = SLIST_NEXT(curelm, sim_links.sle); 1116 if (nextelm == &accb->ccb_h) { 1117 found = 1; 1118 SLIST_NEXT(curelm, sim_links.sle) = 1119 SLIST_NEXT(nextelm, sim_links.sle); 1120 break; 1121 } 1122 curelm = nextelm; 1123 } 1124 } 1125 rls_lun_statep(isp, tptr); 1126 if (found) { 1127 accb->ccb_h.status = CAM_REQ_ABORTED; 1128 return (CAM_REQ_CMP); 1129 } 1130 return(CAM_PATH_INVALID); 1131 } 1132 1133 static cam_status 1134 isp_target_start_ctio(struct ispsoftc *isp, union ccb *ccb) 1135 { 1136 void *qe; 1137 struct ccb_scsiio *cso = &ccb->csio; 1138 u_int16_t *hp, save_handle; 1139 u_int16_t nxti, optr; 1140 u_int8_t local[QENTRY_LEN]; 1141 1142 1143 if (isp_getrqentry(isp, &nxti, &optr, &qe)) { 1144 xpt_print_path(ccb->ccb_h.path); 1145 printf("Request Queue Overflow in isp_target_start_ctio\n"); 1146 return (CAM_RESRC_UNAVAIL); 1147 } 1148 bzero(local, QENTRY_LEN); 1149 1150 /* 1151 * We're either moving data or completing a command here. 1152 */ 1153 1154 if (IS_FC(isp)) { 1155 atio_private_data_t *atp; 1156 ct2_entry_t *cto = (ct2_entry_t *) local; 1157 1158 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2; 1159 cto->ct_header.rqs_entry_count = 1; 1160 cto->ct_iid = cso->init_id; 1161 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) { 1162 cto->ct_lun = ccb->ccb_h.target_lun; 1163 } 1164 1165 atp = isp_get_atpd(isp, cso->tag_id); 1166 if (atp == NULL) { 1167 isp_prt(isp, ISP_LOGERR, 1168 "cannot find private data adjunct for tag %x", 1169 cso->tag_id); 1170 return (-1); 1171 } 1172 1173 cto->ct_rxid = cso->tag_id; 1174 if (cso->dxfer_len == 0) { 1175 cto->ct_flags |= CT2_FLAG_MODE1 | CT2_NO_DATA; 1176 if (ccb->ccb_h.flags & CAM_SEND_STATUS) { 1177 cto->ct_flags |= CT2_SENDSTATUS; 1178 cto->rsp.m1.ct_scsi_status = cso->scsi_status; 1179 cto->ct_resid = 1180 atp->orig_datalen - atp->bytes_xfered; 1181 if (cto->ct_resid < 0) { 1182 cto->rsp.m1.ct_scsi_status |= 1183 CT2_DATA_OVER; 1184 } else if (cto->ct_resid > 0) { 1185 cto->rsp.m1.ct_scsi_status |= 1186 CT2_DATA_UNDER; 1187 } 1188 } 1189 if ((ccb->ccb_h.flags & CAM_SEND_SENSE) != 0) { 1190 int m = min(cso->sense_len, MAXRESPLEN); 1191 bcopy(&cso->sense_data, cto->rsp.m1.ct_resp, m); 1192 cto->rsp.m1.ct_senselen = m; 1193 cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID; 1194 } 1195 } else { 1196 cto->ct_flags |= CT2_FLAG_MODE0; 1197 if ((cso->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 1198 cto->ct_flags |= CT2_DATA_IN; 1199 } else { 1200 cto->ct_flags |= CT2_DATA_OUT; 1201 } 1202 cto->ct_reloff = atp->bytes_xfered; 1203 if ((ccb->ccb_h.flags & CAM_SEND_STATUS) != 0) { 1204 cto->ct_flags |= CT2_SENDSTATUS; 1205 cto->rsp.m0.ct_scsi_status = cso->scsi_status; 1206 cto->ct_resid = 1207 atp->orig_datalen - 1208 (atp->bytes_xfered + cso->dxfer_len); 1209 if (cto->ct_resid < 0) { 1210 cto->rsp.m0.ct_scsi_status |= 1211 CT2_DATA_OVER; 1212 } else if (cto->ct_resid > 0) { 1213 cto->rsp.m0.ct_scsi_status |= 1214 CT2_DATA_UNDER; 1215 } 1216 } else { 1217 atp->last_xframt = cso->dxfer_len; 1218 } 1219 /* 1220 * If we're sending data and status back together, 1221 * we can't also send back sense data as well. 1222 */ 1223 ccb->ccb_h.flags &= ~CAM_SEND_SENSE; 1224 } 1225 1226 if (cto->ct_flags & CT2_SENDSTATUS) { 1227 isp_prt(isp, ISP_LOGTDEBUG0, 1228 "CTIO2[%x] STATUS %x origd %u curd %u resid %u", 1229 cto->ct_rxid, cso->scsi_status, atp->orig_datalen, 1230 cso->dxfer_len, cto->ct_resid); 1231 cto->ct_flags |= CT2_CCINCR; 1232 atp->state = ATPD_STATE_LAST_CTIO; 1233 } else 1234 atp->state = ATPD_STATE_CTIO; 1235 cto->ct_timeout = 10; 1236 hp = &cto->ct_syshandle; 1237 } else { 1238 ct_entry_t *cto = (ct_entry_t *) local; 1239 1240 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO; 1241 cto->ct_header.rqs_entry_count = 1; 1242 cto->ct_iid = cso->init_id; 1243 cto->ct_iid |= XS_CHANNEL(ccb) << 7; 1244 cto->ct_tgt = ccb->ccb_h.target_id; 1245 cto->ct_lun = ccb->ccb_h.target_lun; 1246 cto->ct_fwhandle = AT_GET_HANDLE(cso->tag_id); 1247 if (AT_HAS_TAG(cso->tag_id)) { 1248 cto->ct_tag_val = (u_int8_t) AT_GET_TAG(cso->tag_id); 1249 cto->ct_flags |= CT_TQAE; 1250 } 1251 if (ccb->ccb_h.flags & CAM_DIS_DISCONNECT) { 1252 cto->ct_flags |= CT_NODISC; 1253 } 1254 if (cso->dxfer_len == 0) { 1255 cto->ct_flags |= CT_NO_DATA; 1256 } else if ((cso->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 1257 cto->ct_flags |= CT_DATA_IN; 1258 } else { 1259 cto->ct_flags |= CT_DATA_OUT; 1260 } 1261 if (ccb->ccb_h.flags & CAM_SEND_STATUS) { 1262 cto->ct_flags |= CT_SENDSTATUS|CT_CCINCR; 1263 cto->ct_scsi_status = cso->scsi_status; 1264 cto->ct_resid = cso->resid; 1265 isp_prt(isp, ISP_LOGTDEBUG0, 1266 "CTIO[%x] SCSI STATUS 0x%x resid %d tag_id %x", 1267 cto->ct_fwhandle, cso->scsi_status, cso->resid, 1268 cso->tag_id); 1269 } 1270 ccb->ccb_h.flags &= ~CAM_SEND_SENSE; 1271 cto->ct_timeout = 10; 1272 hp = &cto->ct_syshandle; 1273 } 1274 1275 if (isp_save_xs(isp, (XS_T *)ccb, hp)) { 1276 xpt_print_path(ccb->ccb_h.path); 1277 printf("No XFLIST pointers for isp_target_start_ctio\n"); 1278 return (CAM_RESRC_UNAVAIL); 1279 } 1280 1281 1282 /* 1283 * Call the dma setup routines for this entry (and any subsequent 1284 * CTIOs) if there's data to move, and then tell the f/w it's got 1285 * new things to play with. As with isp_start's usage of DMA setup, 1286 * any swizzling is done in the machine dependent layer. Because 1287 * of this, we put the request onto the queue area first in native 1288 * format. 1289 */ 1290 1291 save_handle = *hp; 1292 1293 switch (ISP_DMASETUP(isp, cso, (ispreq_t *) local, &nxti, optr)) { 1294 case CMD_QUEUED: 1295 ISP_ADD_REQUEST(isp, nxti); 1296 return (CAM_REQ_INPROG); 1297 1298 case CMD_EAGAIN: 1299 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1300 isp_destroy_handle(isp, save_handle); 1301 return (CAM_RESRC_UNAVAIL); 1302 1303 default: 1304 isp_destroy_handle(isp, save_handle); 1305 return (XS_ERR(ccb)); 1306 } 1307 } 1308 1309 static void 1310 isp_refire_putback_atio(void *arg) 1311 { 1312 int s = splcam(); 1313 isp_target_putback_atio(arg); 1314 splx(s); 1315 } 1316 1317 static void 1318 isp_target_putback_atio(union ccb *ccb) 1319 { 1320 struct ispsoftc *isp; 1321 struct ccb_scsiio *cso; 1322 u_int16_t nxti, optr; 1323 void *qe; 1324 1325 isp = XS_ISP(ccb); 1326 1327 if (isp_getrqentry(isp, &nxti, &optr, &qe)) { 1328 (void) timeout(isp_refire_putback_atio, ccb, 10); 1329 isp_prt(isp, ISP_LOGWARN, 1330 "isp_target_putback_atio: Request Queue Overflow"); 1331 return; 1332 } 1333 bzero(qe, QENTRY_LEN); 1334 cso = &ccb->csio; 1335 if (IS_FC(isp)) { 1336 at2_entry_t local, *at = &local; 1337 MEMZERO(at, sizeof (at2_entry_t)); 1338 at->at_header.rqs_entry_type = RQSTYPE_ATIO2; 1339 at->at_header.rqs_entry_count = 1; 1340 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) != 0) { 1341 at->at_scclun = (uint16_t) ccb->ccb_h.target_lun; 1342 } else { 1343 at->at_lun = (uint8_t) ccb->ccb_h.target_lun; 1344 } 1345 at->at_status = CT_OK; 1346 at->at_rxid = cso->tag_id; 1347 at->at_iid = cso->ccb_h.target_id; 1348 isp_put_atio2(isp, at, qe); 1349 } else { 1350 at_entry_t local, *at = &local; 1351 MEMZERO(at, sizeof (at_entry_t)); 1352 at->at_header.rqs_entry_type = RQSTYPE_ATIO; 1353 at->at_header.rqs_entry_count = 1; 1354 at->at_iid = cso->init_id; 1355 at->at_iid |= XS_CHANNEL(ccb) << 7; 1356 at->at_tgt = cso->ccb_h.target_id; 1357 at->at_lun = cso->ccb_h.target_lun; 1358 at->at_status = CT_OK; 1359 at->at_tag_val = AT_GET_TAG(cso->tag_id); 1360 at->at_handle = AT_GET_HANDLE(cso->tag_id); 1361 isp_put_atio(isp, at, qe); 1362 } 1363 ISP_TDQE(isp, "isp_target_putback_atio", (int) optr, qe); 1364 ISP_ADD_REQUEST(isp, nxti); 1365 isp_complete_ctio(ccb); 1366 } 1367 1368 static void 1369 isp_complete_ctio(union ccb *ccb) 1370 { 1371 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { 1372 ccb->ccb_h.status |= CAM_REQ_CMP; 1373 } 1374 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1375 xpt_done(ccb); 1376 } 1377 1378 /* 1379 * Handle ATIO stuff that the generic code can't. 1380 * This means handling CDBs. 1381 */ 1382 1383 static int 1384 isp_handle_platform_atio(struct ispsoftc *isp, at_entry_t *aep) 1385 { 1386 tstate_t *tptr; 1387 int status, bus, iswildcard; 1388 struct ccb_accept_tio *atiop; 1389 1390 /* 1391 * The firmware status (except for the QLTM_SVALID bit) 1392 * indicates why this ATIO was sent to us. 1393 * 1394 * If QLTM_SVALID is set, the firware has recommended Sense Data. 1395 * 1396 * If the DISCONNECTS DISABLED bit is set in the flags field, 1397 * we're still connected on the SCSI bus. 1398 */ 1399 status = aep->at_status; 1400 if ((status & ~QLTM_SVALID) == AT_PHASE_ERROR) { 1401 /* 1402 * Bus Phase Sequence error. We should have sense data 1403 * suggested by the f/w. I'm not sure quite yet what 1404 * to do about this for CAM. 1405 */ 1406 isp_prt(isp, ISP_LOGWARN, "PHASE ERROR"); 1407 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1408 return (0); 1409 } 1410 if ((status & ~QLTM_SVALID) != AT_CDB) { 1411 isp_prt(isp, ISP_LOGWARN, "bad atio (0x%x) leaked to platform", 1412 status); 1413 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1414 return (0); 1415 } 1416 1417 bus = GET_BUS_VAL(aep->at_iid); 1418 tptr = get_lun_statep(isp, bus, aep->at_lun); 1419 if (tptr == NULL) { 1420 tptr = get_lun_statep(isp, bus, CAM_LUN_WILDCARD); 1421 iswildcard = 1; 1422 } else { 1423 iswildcard = 0; 1424 } 1425 1426 if (tptr == NULL) { 1427 /* 1428 * Because we can't autofeed sense data back with 1429 * a command for parallel SCSI, we can't give back 1430 * a CHECK CONDITION. We'll give back a BUSY status 1431 * instead. This works out okay because the only 1432 * time we should, in fact, get this, is in the 1433 * case that somebody configured us without the 1434 * blackhole driver, so they get what they deserve. 1435 */ 1436 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1437 return (0); 1438 } 1439 1440 atiop = (struct ccb_accept_tio *) SLIST_FIRST(&tptr->atios); 1441 if (atiop == NULL) { 1442 /* 1443 * Because we can't autofeed sense data back with 1444 * a command for parallel SCSI, we can't give back 1445 * a CHECK CONDITION. We'll give back a QUEUE FULL status 1446 * instead. This works out okay because the only time we 1447 * should, in fact, get this, is in the case that we've 1448 * run out of ATIOS. 1449 */ 1450 xpt_print_path(tptr->owner); 1451 isp_prt(isp, ISP_LOGWARN, 1452 "no ATIOS for lun %d from initiator %d on channel %d", 1453 aep->at_lun, GET_IID_VAL(aep->at_iid), bus); 1454 if (aep->at_flags & AT_TQAE) 1455 isp_endcmd(isp, aep, SCSI_STATUS_QUEUE_FULL, 0); 1456 else 1457 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1458 rls_lun_statep(isp, tptr); 1459 return (0); 1460 } 1461 SLIST_REMOVE_HEAD(&tptr->atios, sim_links.sle); 1462 if (iswildcard) { 1463 atiop->ccb_h.target_id = aep->at_tgt; 1464 atiop->ccb_h.target_lun = aep->at_lun; 1465 } 1466 if (aep->at_flags & AT_NODISC) { 1467 atiop->ccb_h.flags = CAM_DIS_DISCONNECT; 1468 } else { 1469 atiop->ccb_h.flags = 0; 1470 } 1471 1472 if (status & QLTM_SVALID) { 1473 size_t amt = imin(QLTM_SENSELEN, sizeof (atiop->sense_data)); 1474 atiop->sense_len = amt; 1475 MEMCPY(&atiop->sense_data, aep->at_sense, amt); 1476 } else { 1477 atiop->sense_len = 0; 1478 } 1479 1480 atiop->init_id = GET_IID_VAL(aep->at_iid); 1481 atiop->cdb_len = aep->at_cdblen; 1482 MEMCPY(atiop->cdb_io.cdb_bytes, aep->at_cdb, aep->at_cdblen); 1483 atiop->ccb_h.status = CAM_CDB_RECVD; 1484 /* 1485 * Construct a tag 'id' based upon tag value (which may be 0..255) 1486 * and the handle (which we have to preserve). 1487 */ 1488 AT_MAKE_TAGID(atiop->tag_id, aep); 1489 if (aep->at_flags & AT_TQAE) { 1490 atiop->tag_action = aep->at_tag_type; 1491 atiop->ccb_h.status |= CAM_TAG_ACTION_VALID; 1492 } 1493 xpt_done((union ccb*)atiop); 1494 isp_prt(isp, ISP_LOGTDEBUG0, 1495 "ATIO[%x] CDB=0x%x bus %d iid%d->lun%d tag 0x%x ttype 0x%x %s", 1496 aep->at_handle, aep->at_cdb[0] & 0xff, GET_BUS_VAL(aep->at_iid), 1497 GET_IID_VAL(aep->at_iid), aep->at_lun, aep->at_tag_val & 0xff, 1498 aep->at_tag_type, (aep->at_flags & AT_NODISC)? 1499 "nondisc" : "disconnecting"); 1500 rls_lun_statep(isp, tptr); 1501 return (0); 1502 } 1503 1504 static int 1505 isp_handle_platform_atio2(struct ispsoftc *isp, at2_entry_t *aep) 1506 { 1507 lun_id_t lun; 1508 tstate_t *tptr; 1509 struct ccb_accept_tio *atiop; 1510 atio_private_data_t *atp; 1511 1512 /* 1513 * The firmware status (except for the QLTM_SVALID bit) 1514 * indicates why this ATIO was sent to us. 1515 * 1516 * If QLTM_SVALID is set, the firware has recommended Sense Data. 1517 */ 1518 if ((aep->at_status & ~QLTM_SVALID) != AT_CDB) { 1519 isp_prt(isp, ISP_LOGWARN, 1520 "bogus atio (0x%x) leaked to platform", aep->at_status); 1521 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1522 return (0); 1523 } 1524 1525 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) != 0) { 1526 lun = aep->at_scclun; 1527 } else { 1528 lun = aep->at_lun; 1529 } 1530 tptr = get_lun_statep(isp, 0, lun); 1531 if (tptr == NULL) { 1532 isp_prt(isp, ISP_LOGWARN, "no state pointer for lun %d", lun); 1533 tptr = get_lun_statep(isp, 0, CAM_LUN_WILDCARD); 1534 } 1535 1536 if (tptr == NULL) { 1537 /* 1538 * What we'd like to know is whether or not we have a listener 1539 * upstream that really hasn't configured yet. If we do, then 1540 * we can give a more sensible reply here. If not, then we can 1541 * reject this out of hand. 1542 * 1543 * Choices for what to send were 1544 * 1545 * Not Ready, Unit Not Self-Configured Yet 1546 * (0x2,0x3e,0x00) 1547 * 1548 * for the former and 1549 * 1550 * Illegal Request, Logical Unit Not Supported 1551 * (0x5,0x25,0x00) 1552 * 1553 * for the latter. 1554 * 1555 * We used to decide whether there was at least one listener 1556 * based upon whether the black hole driver was configured. 1557 * However, recent config(8) changes have made this hard to do 1558 * at this time. 1559 * 1560 */ 1561 isp_endcmd(isp, aep, SCSI_STATUS_BUSY, 0); 1562 return (0); 1563 } 1564 1565 atp = isp_get_atpd(isp, 0); 1566 atiop = (struct ccb_accept_tio *) SLIST_FIRST(&tptr->atios); 1567 if (atiop == NULL || atp == NULL) { 1568 /* 1569 * Because we can't autofeed sense data back with 1570 * a command for parallel SCSI, we can't give back 1571 * a CHECK CONDITION. We'll give back a QUEUE FULL status 1572 * instead. This works out okay because the only time we 1573 * should, in fact, get this, is in the case that we've 1574 * run out of ATIOS. 1575 */ 1576 xpt_print_path(tptr->owner); 1577 isp_prt(isp, ISP_LOGWARN, 1578 "no %s for lun %d from initiator %d", 1579 (atp == NULL && atiop == NULL)? "ATIO2s *or* ATPS" : 1580 ((atp == NULL)? "ATPs" : "ATIO2s"), lun, aep->at_iid); 1581 rls_lun_statep(isp, tptr); 1582 isp_endcmd(isp, aep, SCSI_STATUS_QUEUE_FULL, 0); 1583 return (0); 1584 } 1585 atp->state = ATPD_STATE_ATIO; 1586 SLIST_REMOVE_HEAD(&tptr->atios, sim_links.sle); 1587 tptr->atio_count--; 1588 isp_prt(isp, ISP_LOGTDEBUG0, "Take FREE ATIO2 lun %d, count now %d", 1589 lun, tptr->atio_count); 1590 1591 if (tptr == &isp->isp_osinfo.tsdflt[0]) { 1592 atiop->ccb_h.target_id = 1593 ((fcparam *)isp->isp_param)->isp_loopid; 1594 atiop->ccb_h.target_lun = lun; 1595 } 1596 /* 1597 * We don't get 'suggested' sense data as we do with SCSI cards. 1598 */ 1599 atiop->sense_len = 0; 1600 1601 atiop->init_id = aep->at_iid; 1602 atiop->cdb_len = ATIO2_CDBLEN; 1603 MEMCPY(atiop->cdb_io.cdb_bytes, aep->at_cdb, ATIO2_CDBLEN); 1604 atiop->ccb_h.status = CAM_CDB_RECVD; 1605 atiop->tag_id = aep->at_rxid; 1606 switch (aep->at_taskflags & ATIO2_TC_ATTR_MASK) { 1607 case ATIO2_TC_ATTR_SIMPLEQ: 1608 atiop->tag_action = MSG_SIMPLE_Q_TAG; 1609 break; 1610 case ATIO2_TC_ATTR_HEADOFQ: 1611 atiop->tag_action = MSG_HEAD_OF_Q_TAG; 1612 break; 1613 case ATIO2_TC_ATTR_ORDERED: 1614 atiop->tag_action = MSG_ORDERED_Q_TAG; 1615 break; 1616 case ATIO2_TC_ATTR_ACAQ: /* ?? */ 1617 case ATIO2_TC_ATTR_UNTAGGED: 1618 default: 1619 atiop->tag_action = 0; 1620 break; 1621 } 1622 atiop->ccb_h.flags = CAM_TAG_ACTION_VALID; 1623 1624 atp->tag = atiop->tag_id; 1625 atp->lun = lun; 1626 atp->orig_datalen = aep->at_datalen; 1627 atp->last_xframt = 0; 1628 atp->bytes_xfered = 0; 1629 atp->state = ATPD_STATE_CAM; 1630 xpt_done((union ccb*)atiop); 1631 1632 isp_prt(isp, ISP_LOGTDEBUG0, 1633 "ATIO2[%x] CDB=0x%x iid%d->lun%d tattr 0x%x datalen %u", 1634 aep->at_rxid, aep->at_cdb[0] & 0xff, aep->at_iid, 1635 lun, aep->at_taskflags, aep->at_datalen); 1636 rls_lun_statep(isp, tptr); 1637 return (0); 1638 } 1639 1640 static int 1641 isp_handle_platform_ctio(struct ispsoftc *isp, void *arg) 1642 { 1643 union ccb *ccb; 1644 int sentstatus, ok, notify_cam, resid = 0; 1645 u_int16_t tval; 1646 1647 /* 1648 * CTIO and CTIO2 are close enough.... 1649 */ 1650 1651 ccb = (union ccb *) isp_find_xs(isp, ((ct_entry_t *)arg)->ct_syshandle); 1652 KASSERT((ccb != NULL), ("null ccb in isp_handle_platform_ctio")); 1653 isp_destroy_handle(isp, ((ct_entry_t *)arg)->ct_syshandle); 1654 1655 if (IS_FC(isp)) { 1656 ct2_entry_t *ct = arg; 1657 atio_private_data_t *atp = isp_get_atpd(isp, ct->ct_rxid); 1658 if (atp == NULL) { 1659 isp_prt(isp, ISP_LOGERR, 1660 "cannot find adjunct for %x after I/O", 1661 ct->ct_rxid); 1662 return (0); 1663 } 1664 sentstatus = ct->ct_flags & CT2_SENDSTATUS; 1665 ok = (ct->ct_status & ~QLTM_SVALID) == CT_OK; 1666 if (ok && sentstatus && (ccb->ccb_h.flags & CAM_SEND_SENSE)) { 1667 ccb->ccb_h.status |= CAM_SENT_SENSE; 1668 } 1669 notify_cam = ct->ct_header.rqs_seqno & 0x1; 1670 if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) { 1671 resid = ct->ct_resid; 1672 atp->bytes_xfered += (atp->last_xframt - resid); 1673 atp->last_xframt = 0; 1674 } 1675 if (sentstatus || !ok) { 1676 atp->tag = 0; 1677 } 1678 isp_prt(isp, ok? ISP_LOGTDEBUG0 : ISP_LOGWARN, 1679 "CTIO2[%x] sts 0x%x flg 0x%x sns %d resid %d %s", 1680 ct->ct_rxid, ct->ct_status, ct->ct_flags, 1681 (ccb->ccb_h.status & CAM_SENT_SENSE) != 0, 1682 resid, sentstatus? "FIN" : "MID"); 1683 tval = ct->ct_rxid; 1684 1685 /* XXX: should really come after isp_complete_ctio */ 1686 atp->state = ATPD_STATE_PDON; 1687 } else { 1688 ct_entry_t *ct = arg; 1689 sentstatus = ct->ct_flags & CT_SENDSTATUS; 1690 ok = (ct->ct_status & ~QLTM_SVALID) == CT_OK; 1691 /* 1692 * We *ought* to be able to get back to the original ATIO 1693 * here, but for some reason this gets lost. It's just as 1694 * well because it's squirrelled away as part of periph 1695 * private data. 1696 * 1697 * We can live without it as long as we continue to use 1698 * the auto-replenish feature for CTIOs. 1699 */ 1700 notify_cam = ct->ct_header.rqs_seqno & 0x1; 1701 if (ct->ct_status & QLTM_SVALID) { 1702 char *sp = (char *)ct; 1703 sp += CTIO_SENSE_OFFSET; 1704 ccb->csio.sense_len = 1705 min(sizeof (ccb->csio.sense_data), QLTM_SENSELEN); 1706 MEMCPY(&ccb->csio.sense_data, sp, ccb->csio.sense_len); 1707 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 1708 } 1709 if ((ct->ct_flags & CT_DATAMASK) != CT_NO_DATA) { 1710 resid = ct->ct_resid; 1711 } 1712 isp_prt(isp, ISP_LOGTDEBUG0, 1713 "CTIO[%x] tag %x iid %d lun %d sts %x flg %x resid %d %s", 1714 ct->ct_fwhandle, ct->ct_tag_val, ct->ct_iid, ct->ct_lun, 1715 ct->ct_status, ct->ct_flags, resid, 1716 sentstatus? "FIN" : "MID"); 1717 tval = ct->ct_fwhandle; 1718 } 1719 ccb->csio.resid += resid; 1720 1721 /* 1722 * We're here either because intermediate data transfers are done 1723 * and/or the final status CTIO (which may have joined with a 1724 * Data Transfer) is done. 1725 * 1726 * In any case, for this platform, the upper layers figure out 1727 * what to do next, so all we do here is collect status and 1728 * pass information along. Any DMA handles have already been 1729 * freed. 1730 */ 1731 if (notify_cam == 0) { 1732 isp_prt(isp, ISP_LOGTDEBUG0, " INTER CTIO[0x%x] done", tval); 1733 return (0); 1734 } 1735 1736 isp_prt(isp, ISP_LOGTDEBUG0, "%s CTIO[0x%x] done", 1737 (sentstatus)? " FINAL " : "MIDTERM ", tval); 1738 1739 if (!ok) { 1740 isp_target_putback_atio(ccb); 1741 } else { 1742 isp_complete_ctio(ccb); 1743 1744 } 1745 return (0); 1746 } 1747 1748 static int 1749 isp_handle_platform_notify_scsi(struct ispsoftc *isp, in_entry_t *inp) 1750 { 1751 return (0); /* XXXX */ 1752 } 1753 1754 static int 1755 isp_handle_platform_notify_fc(struct ispsoftc *isp, in_fcentry_t *inp) 1756 { 1757 1758 switch (inp->in_status) { 1759 case IN_PORT_LOGOUT: 1760 isp_prt(isp, ISP_LOGWARN, "port logout of iid %d", 1761 inp->in_iid); 1762 break; 1763 case IN_PORT_CHANGED: 1764 isp_prt(isp, ISP_LOGWARN, "port changed for iid %d", 1765 inp->in_iid); 1766 break; 1767 case IN_GLOBAL_LOGO: 1768 isp_prt(isp, ISP_LOGINFO, "all ports logged out"); 1769 break; 1770 case IN_ABORT_TASK: 1771 { 1772 atio_private_data_t *atp = isp_get_atpd(isp, inp->in_seqid); 1773 struct ccb_immed_notify *inot = NULL; 1774 1775 if (atp) { 1776 tstate_t *tptr = get_lun_statep(isp, 0, atp->lun); 1777 if (tptr) { 1778 inot = (struct ccb_immed_notify *) 1779 SLIST_FIRST(&tptr->inots); 1780 if (inot) { 1781 SLIST_REMOVE_HEAD(&tptr->inots, 1782 sim_links.sle); 1783 } 1784 } 1785 isp_prt(isp, ISP_LOGWARN, 1786 "abort task RX_ID %x IID %d state %d", 1787 inp->in_seqid, inp->in_iid, atp->state); 1788 } else { 1789 isp_prt(isp, ISP_LOGWARN, 1790 "abort task RX_ID %x from iid %d, state unknown", 1791 inp->in_seqid, inp->in_iid); 1792 } 1793 if (inot) { 1794 inot->initiator_id = inp->in_iid; 1795 inot->sense_len = 0; 1796 inot->message_args[0] = MSG_ABORT_TAG; 1797 inot->message_args[1] = inp->in_seqid & 0xff; 1798 inot->message_args[2] = (inp->in_seqid >> 8) & 0xff; 1799 inot->ccb_h.status = CAM_MESSAGE_RECV|CAM_DEV_QFRZN; 1800 xpt_done((union ccb *)inot); 1801 } 1802 break; 1803 } 1804 default: 1805 break; 1806 } 1807 return (0); 1808 } 1809 #endif 1810 1811 static void 1812 isp_cam_async(void *cbarg, u_int32_t code, struct cam_path *path, void *arg) 1813 { 1814 struct cam_sim *sim; 1815 struct ispsoftc *isp; 1816 1817 sim = (struct cam_sim *)cbarg; 1818 isp = (struct ispsoftc *) cam_sim_softc(sim); 1819 switch (code) { 1820 case AC_LOST_DEVICE: 1821 if (IS_SCSI(isp)) { 1822 u_int16_t oflags, nflags; 1823 sdparam *sdp = isp->isp_param; 1824 int tgt; 1825 1826 tgt = xpt_path_target_id(path); 1827 if (tgt >= 0) { 1828 sdp += cam_sim_bus(sim); 1829 ISP_LOCK(isp); 1830 nflags = sdp->isp_devparam[tgt].nvrm_flags; 1831 #ifndef ISP_TARGET_MODE 1832 nflags &= DPARM_SAFE_DFLT; 1833 if (isp->isp_loaded_fw) { 1834 nflags |= DPARM_NARROW | DPARM_ASYNC; 1835 } 1836 #else 1837 nflags = DPARM_DEFAULT; 1838 #endif 1839 oflags = sdp->isp_devparam[tgt].goal_flags; 1840 sdp->isp_devparam[tgt].goal_flags = nflags; 1841 sdp->isp_devparam[tgt].dev_update = 1; 1842 isp->isp_update |= (1 << cam_sim_bus(sim)); 1843 (void) isp_control(isp, 1844 ISPCTL_UPDATE_PARAMS, NULL); 1845 sdp->isp_devparam[tgt].goal_flags = oflags; 1846 ISP_UNLOCK(isp); 1847 } 1848 } 1849 break; 1850 default: 1851 isp_prt(isp, ISP_LOGWARN, "isp_cam_async: Code 0x%x", code); 1852 break; 1853 } 1854 } 1855 1856 static void 1857 isp_poll(struct cam_sim *sim) 1858 { 1859 struct ispsoftc *isp = cam_sim_softc(sim); 1860 u_int16_t isr, sema, mbox; 1861 1862 ISP_LOCK(isp); 1863 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) { 1864 isp_intr(isp, isr, sema, mbox); 1865 } 1866 ISP_UNLOCK(isp); 1867 } 1868 1869 1870 static void 1871 isp_watchdog(void *arg) 1872 { 1873 XS_T *xs = arg; 1874 struct ispsoftc *isp = XS_ISP(xs); 1875 u_int32_t handle; 1876 int iok; 1877 1878 /* 1879 * We've decided this command is dead. Make sure we're not trying 1880 * to kill a command that's already dead by getting it's handle and 1881 * and seeing whether it's still alive. 1882 */ 1883 ISP_LOCK(isp); 1884 iok = isp->isp_osinfo.intsok; 1885 isp->isp_osinfo.intsok = 0; 1886 handle = isp_find_handle(isp, xs); 1887 if (handle) { 1888 u_int16_t isr, sema, mbox; 1889 1890 if (XS_CMD_DONE_P(xs)) { 1891 isp_prt(isp, ISP_LOGDEBUG1, 1892 "watchdog found done cmd (handle 0x%x)", handle); 1893 ISP_UNLOCK(isp); 1894 return; 1895 } 1896 1897 if (XS_CMD_WDOG_P(xs)) { 1898 isp_prt(isp, ISP_LOGDEBUG2, 1899 "recursive watchdog (handle 0x%x)", handle); 1900 ISP_UNLOCK(isp); 1901 return; 1902 } 1903 1904 XS_CMD_S_WDOG(xs); 1905 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) { 1906 isp_intr(isp, isr, sema, mbox); 1907 } 1908 if (XS_CMD_DONE_P(xs)) { 1909 isp_prt(isp, ISP_LOGDEBUG2, 1910 "watchdog cleanup for handle 0x%x", handle); 1911 xpt_done((union ccb *) xs); 1912 } else if (XS_CMD_GRACE_P(xs)) { 1913 /* 1914 * Make sure the command is *really* dead before we 1915 * release the handle (and DMA resources) for reuse. 1916 */ 1917 (void) isp_control(isp, ISPCTL_ABORT_CMD, arg); 1918 1919 /* 1920 * After this point, the comamnd is really dead. 1921 */ 1922 if (XS_XFRLEN(xs)) { 1923 ISP_DMAFREE(isp, xs, handle); 1924 } 1925 isp_destroy_handle(isp, handle); 1926 xpt_print_path(xs->ccb_h.path); 1927 isp_prt(isp, ISP_LOGWARN, 1928 "watchdog timeout for handle 0x%x", handle); 1929 XS_SETERR(xs, CAM_CMD_TIMEOUT); 1930 XS_CMD_C_WDOG(xs); 1931 isp_done(xs); 1932 } else { 1933 u_int16_t nxti, optr; 1934 ispreq_t local, *mp= &local, *qe; 1935 1936 XS_CMD_C_WDOG(xs); 1937 xs->ccb_h.timeout_ch = timeout(isp_watchdog, xs, hz); 1938 if (isp_getrqentry(isp, &nxti, &optr, (void **) &qe)) { 1939 ISP_UNLOCK(isp); 1940 return; 1941 } 1942 XS_CMD_S_GRACE(xs); 1943 MEMZERO((void *) mp, sizeof (*mp)); 1944 mp->req_header.rqs_entry_count = 1; 1945 mp->req_header.rqs_entry_type = RQSTYPE_MARKER; 1946 mp->req_modifier = SYNC_ALL; 1947 mp->req_target = XS_CHANNEL(xs) << 7; 1948 isp_put_request(isp, mp, qe); 1949 ISP_ADD_REQUEST(isp, nxti); 1950 } 1951 } else { 1952 isp_prt(isp, ISP_LOGDEBUG2, "watchdog with no command"); 1953 } 1954 isp->isp_osinfo.intsok = iok; 1955 ISP_UNLOCK(isp); 1956 } 1957 1958 static void 1959 isp_kthread(void *arg) 1960 { 1961 struct ispsoftc *isp = arg; 1962 1963 #ifdef ISP_SMPLOCK 1964 mtx_lock(&isp->isp_lock); 1965 #else 1966 mtx_lock(&Giant); 1967 #endif 1968 /* 1969 * The first loop is for our usage where we have yet to have 1970 * gotten good fibre channel state. 1971 */ 1972 for (;;) { 1973 int wasfrozen; 1974 1975 isp_prt(isp, ISP_LOGDEBUG0, "kthread: checking FC state"); 1976 while (isp_fc_runstate(isp, 2 * 1000000) != 0) { 1977 isp_prt(isp, ISP_LOGDEBUG0, "kthread: FC state ungood"); 1978 if (FCPARAM(isp)->isp_fwstate != FW_READY || 1979 FCPARAM(isp)->isp_loopstate < LOOP_PDB_RCVD) { 1980 if (FCPARAM(isp)->loop_seen_once == 0 || 1981 isp->isp_osinfo.ktmature == 0) { 1982 break; 1983 } 1984 } 1985 #ifdef ISP_SMPLOCK 1986 msleep(isp_kthread, &isp->isp_lock, 1987 PRIBIO, "isp_fcthrd", hz); 1988 #else 1989 (void) tsleep(isp_kthread, PRIBIO, "isp_fcthrd", hz); 1990 #endif 1991 } 1992 1993 /* 1994 * Even if we didn't get good loop state we may be 1995 * unfreezing the SIMQ so that we can kill off 1996 * commands (if we've never seen loop before, for example). 1997 */ 1998 isp->isp_osinfo.ktmature = 1; 1999 wasfrozen = isp->isp_osinfo.simqfrozen & SIMQFRZ_LOOPDOWN; 2000 isp->isp_osinfo.simqfrozen &= ~SIMQFRZ_LOOPDOWN; 2001 if (wasfrozen && isp->isp_osinfo.simqfrozen == 0) { 2002 isp_prt(isp, ISP_LOGDEBUG0, "kthread: releasing simq"); 2003 ISPLOCK_2_CAMLOCK(isp); 2004 xpt_release_simq(isp->isp_sim, 1); 2005 CAMLOCK_2_ISPLOCK(isp); 2006 } 2007 isp_prt(isp, ISP_LOGDEBUG0, "kthread: waiting until called"); 2008 #ifdef ISP_SMPLOCK 2009 cv_wait(&isp->isp_osinfo.kthread_cv, &isp->isp_lock); 2010 #else 2011 (void) tsleep(&isp->isp_osinfo.kthread_cv, PRIBIO, "fc_cv", 0); 2012 #endif 2013 } 2014 } 2015 2016 static void 2017 isp_action(struct cam_sim *sim, union ccb *ccb) 2018 { 2019 int bus, tgt, error; 2020 struct ispsoftc *isp; 2021 struct ccb_trans_settings *cts; 2022 2023 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("isp_action\n")); 2024 2025 isp = (struct ispsoftc *)cam_sim_softc(sim); 2026 ccb->ccb_h.sim_priv.entries[0].field = 0; 2027 ccb->ccb_h.sim_priv.entries[1].ptr = isp; 2028 if (isp->isp_state != ISP_RUNSTATE && 2029 ccb->ccb_h.func_code == XPT_SCSI_IO) { 2030 CAMLOCK_2_ISPLOCK(isp); 2031 isp_init(isp); 2032 if (isp->isp_state != ISP_INITSTATE) { 2033 ISP_UNLOCK(isp); 2034 /* 2035 * Lie. Say it was a selection timeout. 2036 */ 2037 ccb->ccb_h.status = CAM_SEL_TIMEOUT | CAM_DEV_QFRZN; 2038 xpt_freeze_devq(ccb->ccb_h.path, 1); 2039 xpt_done(ccb); 2040 return; 2041 } 2042 isp->isp_state = ISP_RUNSTATE; 2043 ISPLOCK_2_CAMLOCK(isp); 2044 } 2045 isp_prt(isp, ISP_LOGDEBUG2, "isp_action code %x", ccb->ccb_h.func_code); 2046 2047 2048 switch (ccb->ccb_h.func_code) { 2049 case XPT_SCSI_IO: /* Execute the requested I/O operation */ 2050 /* 2051 * Do a couple of preliminary checks... 2052 */ 2053 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) { 2054 if ((ccb->ccb_h.flags & CAM_CDB_PHYS) != 0) { 2055 ccb->ccb_h.status = CAM_REQ_INVALID; 2056 xpt_done(ccb); 2057 break; 2058 } 2059 } 2060 #ifdef DIAGNOSTIC 2061 if (ccb->ccb_h.target_id > (ISP_MAX_TARGETS(isp) - 1)) { 2062 ccb->ccb_h.status = CAM_PATH_INVALID; 2063 } else if (ccb->ccb_h.target_lun > (ISP_MAX_LUNS(isp) - 1)) { 2064 ccb->ccb_h.status = CAM_PATH_INVALID; 2065 } 2066 if (ccb->ccb_h.status == CAM_PATH_INVALID) { 2067 isp_prt(isp, ISP_LOGERR, 2068 "invalid tgt/lun (%d.%d) in XPT_SCSI_IO", 2069 ccb->ccb_h.target_id, ccb->ccb_h.target_lun); 2070 xpt_done(ccb); 2071 break; 2072 } 2073 #endif 2074 ((struct ccb_scsiio *) ccb)->scsi_status = SCSI_STATUS_OK; 2075 CAMLOCK_2_ISPLOCK(isp); 2076 error = isp_start((XS_T *) ccb); 2077 switch (error) { 2078 case CMD_QUEUED: 2079 ccb->ccb_h.status |= CAM_SIM_QUEUED; 2080 if (ccb->ccb_h.timeout != CAM_TIME_INFINITY) { 2081 u_int64_t ticks = (u_int64_t) hz; 2082 if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) 2083 ticks = 60 * 1000 * ticks; 2084 else 2085 ticks = ccb->ccb_h.timeout * hz; 2086 ticks = ((ticks + 999) / 1000) + hz + hz; 2087 if (ticks >= 0x80000000) { 2088 isp_prt(isp, ISP_LOGERR, 2089 "timeout overflow"); 2090 ticks = 0x7fffffff; 2091 } 2092 ccb->ccb_h.timeout_ch = timeout(isp_watchdog, 2093 (caddr_t)ccb, (int)ticks); 2094 } else { 2095 callout_handle_init(&ccb->ccb_h.timeout_ch); 2096 } 2097 ISPLOCK_2_CAMLOCK(isp); 2098 break; 2099 case CMD_RQLATER: 2100 /* 2101 * This can only happen for Fibre Channel 2102 */ 2103 KASSERT((IS_FC(isp)), ("CMD_RQLATER for FC only")); 2104 if (FCPARAM(isp)->loop_seen_once == 0 && 2105 isp->isp_osinfo.ktmature) { 2106 ISPLOCK_2_CAMLOCK(isp); 2107 XS_SETERR(ccb, CAM_SEL_TIMEOUT); 2108 xpt_done(ccb); 2109 break; 2110 } 2111 #ifdef ISP_SMPLOCK 2112 cv_signal(&isp->isp_osinfo.kthread_cv); 2113 #else 2114 wakeup(&isp->isp_osinfo.kthread_cv); 2115 #endif 2116 isp_freeze_loopdown(isp, "isp_action(RQLATER)"); 2117 XS_SETERR(ccb, CAM_REQUEUE_REQ); 2118 ISPLOCK_2_CAMLOCK(isp); 2119 xpt_done(ccb); 2120 break; 2121 case CMD_EAGAIN: 2122 XS_SETERR(ccb, CAM_REQUEUE_REQ); 2123 ISPLOCK_2_CAMLOCK(isp); 2124 xpt_done(ccb); 2125 break; 2126 case CMD_COMPLETE: 2127 isp_done((struct ccb_scsiio *) ccb); 2128 ISPLOCK_2_CAMLOCK(isp); 2129 break; 2130 default: 2131 isp_prt(isp, ISP_LOGERR, 2132 "What's this? 0x%x at %d in file %s", 2133 error, __LINE__, __FILE__); 2134 XS_SETERR(ccb, CAM_REQ_CMP_ERR); 2135 xpt_done(ccb); 2136 ISPLOCK_2_CAMLOCK(isp); 2137 } 2138 break; 2139 2140 #ifdef ISP_TARGET_MODE 2141 case XPT_EN_LUN: /* Enable LUN as a target */ 2142 { 2143 int iok; 2144 CAMLOCK_2_ISPLOCK(isp); 2145 iok = isp->isp_osinfo.intsok; 2146 isp->isp_osinfo.intsok = 0; 2147 isp_en_lun(isp, ccb); 2148 isp->isp_osinfo.intsok = iok; 2149 ISPLOCK_2_CAMLOCK(isp); 2150 xpt_done(ccb); 2151 break; 2152 } 2153 case XPT_NOTIFY_ACK: /* recycle notify ack */ 2154 case XPT_IMMED_NOTIFY: /* Add Immediate Notify Resource */ 2155 case XPT_ACCEPT_TARGET_IO: /* Add Accept Target IO Resource */ 2156 { 2157 tstate_t *tptr = 2158 get_lun_statep(isp, XS_CHANNEL(ccb), ccb->ccb_h.target_lun); 2159 if (tptr == NULL) { 2160 ccb->ccb_h.status = CAM_LUN_INVALID; 2161 xpt_done(ccb); 2162 break; 2163 } 2164 ccb->ccb_h.sim_priv.entries[0].field = 0; 2165 ccb->ccb_h.sim_priv.entries[1].ptr = isp; 2166 ccb->ccb_h.flags = 0; 2167 2168 CAMLOCK_2_ISPLOCK(isp); 2169 if (ccb->ccb_h.func_code == XPT_ACCEPT_TARGET_IO) { 2170 /* 2171 * Note that the command itself may not be done- 2172 * it may not even have had the first CTIO sent. 2173 */ 2174 tptr->atio_count++; 2175 isp_prt(isp, ISP_LOGTDEBUG0, 2176 "Put FREE ATIO2, lun %d, count now %d", 2177 ccb->ccb_h.target_lun, tptr->atio_count); 2178 SLIST_INSERT_HEAD(&tptr->atios, &ccb->ccb_h, 2179 sim_links.sle); 2180 } else if (ccb->ccb_h.func_code == XPT_IMMED_NOTIFY) { 2181 SLIST_INSERT_HEAD(&tptr->inots, &ccb->ccb_h, 2182 sim_links.sle); 2183 } else { 2184 ; 2185 } 2186 rls_lun_statep(isp, tptr); 2187 ccb->ccb_h.status = CAM_REQ_INPROG; 2188 ISPLOCK_2_CAMLOCK(isp); 2189 break; 2190 } 2191 case XPT_CONT_TARGET_IO: 2192 { 2193 CAMLOCK_2_ISPLOCK(isp); 2194 ccb->ccb_h.status = isp_target_start_ctio(isp, ccb); 2195 if (ccb->ccb_h.status != CAM_REQ_INPROG) { 2196 isp_prt(isp, ISP_LOGWARN, 2197 "XPT_CONT_TARGET_IO: status 0x%x", 2198 ccb->ccb_h.status); 2199 XS_SETERR(ccb, CAM_REQUEUE_REQ); 2200 ISPLOCK_2_CAMLOCK(isp); 2201 xpt_done(ccb); 2202 } else { 2203 ISPLOCK_2_CAMLOCK(isp); 2204 ccb->ccb_h.status |= CAM_SIM_QUEUED; 2205 } 2206 break; 2207 } 2208 #endif 2209 case XPT_RESET_DEV: /* BDR the specified SCSI device */ 2210 2211 bus = cam_sim_bus(xpt_path_sim(ccb->ccb_h.path)); 2212 tgt = ccb->ccb_h.target_id; 2213 tgt |= (bus << 16); 2214 2215 CAMLOCK_2_ISPLOCK(isp); 2216 error = isp_control(isp, ISPCTL_RESET_DEV, &tgt); 2217 ISPLOCK_2_CAMLOCK(isp); 2218 if (error) { 2219 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2220 } else { 2221 ccb->ccb_h.status = CAM_REQ_CMP; 2222 } 2223 xpt_done(ccb); 2224 break; 2225 case XPT_ABORT: /* Abort the specified CCB */ 2226 { 2227 union ccb *accb = ccb->cab.abort_ccb; 2228 CAMLOCK_2_ISPLOCK(isp); 2229 switch (accb->ccb_h.func_code) { 2230 #ifdef ISP_TARGET_MODE 2231 case XPT_ACCEPT_TARGET_IO: 2232 case XPT_IMMED_NOTIFY: 2233 ccb->ccb_h.status = isp_abort_tgt_ccb(isp, ccb); 2234 break; 2235 case XPT_CONT_TARGET_IO: 2236 isp_prt(isp, ISP_LOGERR, "cannot abort CTIOs yet"); 2237 ccb->ccb_h.status = CAM_UA_ABORT; 2238 break; 2239 #endif 2240 case XPT_SCSI_IO: 2241 error = isp_control(isp, ISPCTL_ABORT_CMD, ccb); 2242 if (error) { 2243 ccb->ccb_h.status = CAM_UA_ABORT; 2244 } else { 2245 ccb->ccb_h.status = CAM_REQ_CMP; 2246 } 2247 break; 2248 default: 2249 ccb->ccb_h.status = CAM_REQ_INVALID; 2250 break; 2251 } 2252 ISPLOCK_2_CAMLOCK(isp); 2253 xpt_done(ccb); 2254 break; 2255 } 2256 #ifdef CAM_NEW_TRAN_CODE 2257 #define IS_CURRENT_SETTINGS(c) (c->type == CTS_TYPE_CURRENT_SETTINGS) 2258 #else 2259 #define IS_CURRENT_SETTINGS(c) (c->flags & CCB_TRANS_CURRENT_SETTINGS) 2260 #endif 2261 case XPT_SET_TRAN_SETTINGS: /* Nexus Settings */ 2262 cts = &ccb->cts; 2263 if (!IS_CURRENT_SETTINGS(cts)) { 2264 ccb->ccb_h.status = CAM_REQ_INVALID; 2265 xpt_done(ccb); 2266 break; 2267 } 2268 tgt = cts->ccb_h.target_id; 2269 CAMLOCK_2_ISPLOCK(isp); 2270 if (IS_SCSI(isp)) { 2271 #ifndef CAM_NEW_TRAN_CODE 2272 sdparam *sdp = isp->isp_param; 2273 u_int16_t *dptr; 2274 2275 bus = cam_sim_bus(xpt_path_sim(cts->ccb_h.path)); 2276 2277 sdp += bus; 2278 /* 2279 * We always update (internally) from goal_flags 2280 * so any request to change settings just gets 2281 * vectored to that location. 2282 */ 2283 dptr = &sdp->isp_devparam[tgt].goal_flags; 2284 2285 /* 2286 * Note that these operations affect the 2287 * the goal flags (goal_flags)- not 2288 * the current state flags. Then we mark 2289 * things so that the next operation to 2290 * this HBA will cause the update to occur. 2291 */ 2292 if (cts->valid & CCB_TRANS_DISC_VALID) { 2293 if ((cts->flags & CCB_TRANS_DISC_ENB) != 0) { 2294 *dptr |= DPARM_DISC; 2295 } else { 2296 *dptr &= ~DPARM_DISC; 2297 } 2298 } 2299 if (cts->valid & CCB_TRANS_TQ_VALID) { 2300 if ((cts->flags & CCB_TRANS_TAG_ENB) != 0) { 2301 *dptr |= DPARM_TQING; 2302 } else { 2303 *dptr &= ~DPARM_TQING; 2304 } 2305 } 2306 if (cts->valid & CCB_TRANS_BUS_WIDTH_VALID) { 2307 switch (cts->bus_width) { 2308 case MSG_EXT_WDTR_BUS_16_BIT: 2309 *dptr |= DPARM_WIDE; 2310 break; 2311 default: 2312 *dptr &= ~DPARM_WIDE; 2313 } 2314 } 2315 /* 2316 * Any SYNC RATE of nonzero and SYNC_OFFSET 2317 * of nonzero will cause us to go to the 2318 * selected (from NVRAM) maximum value for 2319 * this device. At a later point, we'll 2320 * allow finer control. 2321 */ 2322 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) && 2323 (cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) && 2324 (cts->sync_offset > 0)) { 2325 *dptr |= DPARM_SYNC; 2326 } else { 2327 *dptr &= ~DPARM_SYNC; 2328 } 2329 *dptr |= DPARM_SAFE_DFLT; 2330 #else 2331 struct ccb_trans_settings_scsi *scsi = 2332 &cts->proto_specific.scsi; 2333 struct ccb_trans_settings_spi *spi = 2334 &cts->xport_specific.spi; 2335 sdparam *sdp = isp->isp_param; 2336 u_int16_t *dptr; 2337 2338 bus = cam_sim_bus(xpt_path_sim(cts->ccb_h.path)); 2339 sdp += bus; 2340 /* 2341 * We always update (internally) from goal_flags 2342 * so any request to change settings just gets 2343 * vectored to that location. 2344 */ 2345 dptr = &sdp->isp_devparam[tgt].goal_flags; 2346 2347 if ((spi->valid & CTS_SPI_VALID_DISC) != 0) { 2348 if ((spi->flags & CTS_SPI_FLAGS_DISC_ENB) != 0) 2349 *dptr |= DPARM_DISC; 2350 else 2351 *dptr &= ~DPARM_DISC; 2352 } 2353 2354 if ((scsi->valid & CTS_SCSI_VALID_TQ) != 0) { 2355 if ((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0) 2356 *dptr |= DPARM_TQING; 2357 else 2358 *dptr &= ~DPARM_TQING; 2359 } 2360 2361 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) { 2362 if (spi->bus_width == MSG_EXT_WDTR_BUS_16_BIT) 2363 *dptr |= DPARM_WIDE; 2364 else 2365 *dptr &= ~DPARM_WIDE; 2366 } 2367 2368 /* 2369 * XXX: FIX ME 2370 */ 2371 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) && 2372 (spi->valid & CTS_SPI_VALID_SYNC_RATE) && 2373 (spi->sync_period && spi->sync_offset)) { 2374 *dptr |= DPARM_SYNC; 2375 /* 2376 * XXX: CHECK FOR LEGALITY 2377 */ 2378 sdp->isp_devparam[tgt].goal_period = 2379 spi->sync_period; 2380 sdp->isp_devparam[tgt].goal_offset = 2381 spi->sync_offset; 2382 } else { 2383 *dptr &= ~DPARM_SYNC; 2384 } 2385 #endif 2386 isp_prt(isp, ISP_LOGDEBUG0, 2387 "SET bus %d targ %d to flags %x off %x per %x", 2388 bus, tgt, sdp->isp_devparam[tgt].goal_flags, 2389 sdp->isp_devparam[tgt].goal_offset, 2390 sdp->isp_devparam[tgt].goal_period); 2391 sdp->isp_devparam[tgt].dev_update = 1; 2392 isp->isp_update |= (1 << bus); 2393 } 2394 ISPLOCK_2_CAMLOCK(isp); 2395 ccb->ccb_h.status = CAM_REQ_CMP; 2396 xpt_done(ccb); 2397 break; 2398 case XPT_GET_TRAN_SETTINGS: 2399 cts = &ccb->cts; 2400 tgt = cts->ccb_h.target_id; 2401 CAMLOCK_2_ISPLOCK(isp); 2402 if (IS_FC(isp)) { 2403 #ifndef CAM_NEW_TRAN_CODE 2404 /* 2405 * a lot of normal SCSI things don't make sense. 2406 */ 2407 cts->flags = CCB_TRANS_TAG_ENB | CCB_TRANS_DISC_ENB; 2408 cts->valid = CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID; 2409 /* 2410 * How do you measure the width of a high 2411 * speed serial bus? Well, in bytes. 2412 * 2413 * Offset and period make no sense, though, so we set 2414 * (above) a 'base' transfer speed to be gigabit. 2415 */ 2416 cts->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 2417 #else 2418 fcparam *fcp = isp->isp_param; 2419 struct ccb_trans_settings_fc *fc = 2420 &cts->xport_specific.fc; 2421 2422 cts->protocol = PROTO_SCSI; 2423 cts->protocol_version = SCSI_REV_2; 2424 cts->transport = XPORT_FC; 2425 cts->transport_version = 0; 2426 2427 fc->valid = CTS_FC_VALID_SPEED; 2428 if (fcp->isp_gbspeed == 2) 2429 fc->bitrate = 200000; 2430 else 2431 fc->bitrate = 100000; 2432 if (tgt > 0 && tgt < MAX_FC_TARG) { 2433 struct lportdb *lp = &fcp->portdb[tgt]; 2434 fc->wwnn = lp->node_wwn; 2435 fc->wwpn = lp->port_wwn; 2436 fc->port = lp->portid; 2437 fc->valid |= CTS_FC_VALID_WWNN | 2438 CTS_FC_VALID_WWPN | CTS_FC_VALID_PORT; 2439 } 2440 #endif 2441 } else { 2442 #ifdef CAM_NEW_TRAN_CODE 2443 struct ccb_trans_settings_scsi *scsi = 2444 &cts->proto_specific.scsi; 2445 struct ccb_trans_settings_spi *spi = 2446 &cts->xport_specific.spi; 2447 #endif 2448 sdparam *sdp = isp->isp_param; 2449 int bus = cam_sim_bus(xpt_path_sim(cts->ccb_h.path)); 2450 u_int16_t dval, pval, oval; 2451 2452 sdp += bus; 2453 2454 if (IS_CURRENT_SETTINGS(cts)) { 2455 sdp->isp_devparam[tgt].dev_refresh = 1; 2456 isp->isp_update |= (1 << bus); 2457 (void) isp_control(isp, ISPCTL_UPDATE_PARAMS, 2458 NULL); 2459 dval = sdp->isp_devparam[tgt].actv_flags; 2460 oval = sdp->isp_devparam[tgt].actv_offset; 2461 pval = sdp->isp_devparam[tgt].actv_period; 2462 } else { 2463 dval = sdp->isp_devparam[tgt].nvrm_flags; 2464 oval = sdp->isp_devparam[tgt].nvrm_offset; 2465 pval = sdp->isp_devparam[tgt].nvrm_period; 2466 } 2467 2468 #ifndef CAM_NEW_TRAN_CODE 2469 cts->flags &= ~(CCB_TRANS_DISC_ENB|CCB_TRANS_TAG_ENB); 2470 2471 if (dval & DPARM_DISC) { 2472 cts->flags |= CCB_TRANS_DISC_ENB; 2473 } 2474 if (dval & DPARM_TQING) { 2475 cts->flags |= CCB_TRANS_TAG_ENB; 2476 } 2477 if (dval & DPARM_WIDE) { 2478 cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT; 2479 } else { 2480 cts->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 2481 } 2482 cts->valid = CCB_TRANS_BUS_WIDTH_VALID | 2483 CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID; 2484 2485 if ((dval & DPARM_SYNC) && oval != 0) { 2486 cts->sync_period = pval; 2487 cts->sync_offset = oval; 2488 cts->valid |= 2489 CCB_TRANS_SYNC_RATE_VALID | 2490 CCB_TRANS_SYNC_OFFSET_VALID; 2491 } 2492 #else 2493 cts->protocol = PROTO_SCSI; 2494 cts->protocol_version = SCSI_REV_2; 2495 cts->transport = XPORT_SPI; 2496 cts->transport_version = 2; 2497 2498 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 2499 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 2500 if (dval & DPARM_DISC) { 2501 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 2502 } 2503 if (dval & DPARM_TQING) { 2504 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 2505 } 2506 if ((dval & DPARM_SYNC) && oval && pval) { 2507 spi->sync_offset = oval; 2508 spi->sync_period = pval; 2509 spi->valid |= CTS_SPI_VALID_SYNC_OFFSET; 2510 spi->valid |= CTS_SPI_VALID_SYNC_RATE; 2511 } 2512 spi->valid |= CTS_SPI_VALID_BUS_WIDTH; 2513 if (dval & DPARM_WIDE) { 2514 spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT; 2515 } else { 2516 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 2517 } 2518 if (cts->ccb_h.target_lun != CAM_LUN_WILDCARD) { 2519 scsi->valid = CTS_SCSI_VALID_TQ; 2520 spi->valid |= CTS_SPI_VALID_DISC; 2521 } else { 2522 scsi->valid = 0; 2523 } 2524 #endif 2525 isp_prt(isp, ISP_LOGDEBUG0, 2526 "GET %s bus %d targ %d to flags %x off %x per %x", 2527 IS_CURRENT_SETTINGS(cts)? "ACTIVE" : "NVRAM", 2528 bus, tgt, dval, oval, pval); 2529 } 2530 ISPLOCK_2_CAMLOCK(isp); 2531 ccb->ccb_h.status = CAM_REQ_CMP; 2532 xpt_done(ccb); 2533 break; 2534 2535 case XPT_CALC_GEOMETRY: 2536 { 2537 struct ccb_calc_geometry *ccg; 2538 2539 ccg = &ccb->ccg; 2540 if (ccg->block_size == 0) { 2541 isp_prt(isp, ISP_LOGERR, 2542 "%d.%d XPT_CALC_GEOMETRY block size 0?", 2543 ccg->ccb_h.target_id, ccg->ccb_h.target_lun); 2544 ccb->ccb_h.status = CAM_REQ_INVALID; 2545 xpt_done(ccb); 2546 break; 2547 } 2548 cam_calc_geometry(ccg, /*extended*/1); 2549 xpt_done(ccb); 2550 break; 2551 } 2552 case XPT_RESET_BUS: /* Reset the specified bus */ 2553 bus = cam_sim_bus(sim); 2554 CAMLOCK_2_ISPLOCK(isp); 2555 error = isp_control(isp, ISPCTL_RESET_BUS, &bus); 2556 ISPLOCK_2_CAMLOCK(isp); 2557 if (error) 2558 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2559 else { 2560 if (cam_sim_bus(sim) && isp->isp_path2 != NULL) 2561 xpt_async(AC_BUS_RESET, isp->isp_path2, NULL); 2562 else if (isp->isp_path != NULL) 2563 xpt_async(AC_BUS_RESET, isp->isp_path, NULL); 2564 ccb->ccb_h.status = CAM_REQ_CMP; 2565 } 2566 xpt_done(ccb); 2567 break; 2568 2569 case XPT_TERM_IO: /* Terminate the I/O process */ 2570 ccb->ccb_h.status = CAM_REQ_INVALID; 2571 xpt_done(ccb); 2572 break; 2573 2574 case XPT_PATH_INQ: /* Path routing inquiry */ 2575 { 2576 struct ccb_pathinq *cpi = &ccb->cpi; 2577 2578 cpi->version_num = 1; 2579 #ifdef ISP_TARGET_MODE 2580 cpi->target_sprt = PIT_PROCESSOR | PIT_DISCONNECT | PIT_TERM_IO; 2581 #else 2582 cpi->target_sprt = 0; 2583 #endif 2584 cpi->hba_eng_cnt = 0; 2585 cpi->max_target = ISP_MAX_TARGETS(isp) - 1; 2586 cpi->max_lun = ISP_MAX_LUNS(isp) - 1; 2587 cpi->bus_id = cam_sim_bus(sim); 2588 if (IS_FC(isp)) { 2589 cpi->hba_misc = PIM_NOBUSRESET; 2590 /* 2591 * Because our loop ID can shift from time to time, 2592 * make our initiator ID out of range of our bus. 2593 */ 2594 cpi->initiator_id = cpi->max_target + 1; 2595 2596 /* 2597 * Set base transfer capabilities for Fibre Channel. 2598 * Technically not correct because we don't know 2599 * what media we're running on top of- but we'll 2600 * look good if we always say 100MB/s. 2601 */ 2602 if (FCPARAM(isp)->isp_gbspeed == 2) 2603 cpi->base_transfer_speed = 200000; 2604 else 2605 cpi->base_transfer_speed = 100000; 2606 cpi->hba_inquiry = PI_TAG_ABLE; 2607 #ifdef CAM_NEW_TRAN_CODE 2608 cpi->transport = XPORT_FC; 2609 cpi->transport_version = 0; /* WHAT'S THIS FOR? */ 2610 #endif 2611 } else { 2612 sdparam *sdp = isp->isp_param; 2613 sdp += cam_sim_bus(xpt_path_sim(cpi->ccb_h.path)); 2614 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16; 2615 cpi->hba_misc = 0; 2616 cpi->initiator_id = sdp->isp_initiator_id; 2617 cpi->base_transfer_speed = 3300; 2618 #ifdef CAM_NEW_TRAN_CODE 2619 cpi->transport = XPORT_SPI; 2620 cpi->transport_version = 2; /* WHAT'S THIS FOR? */ 2621 #endif 2622 } 2623 #ifdef CAM_NEW_TRAN_CODE 2624 cpi->protocol = PROTO_SCSI; 2625 cpi->protocol_version = SCSI_REV_2; 2626 #endif 2627 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2628 strncpy(cpi->hba_vid, "Qlogic", HBA_IDLEN); 2629 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 2630 cpi->unit_number = cam_sim_unit(sim); 2631 cpi->ccb_h.status = CAM_REQ_CMP; 2632 xpt_done(ccb); 2633 break; 2634 } 2635 default: 2636 ccb->ccb_h.status = CAM_REQ_INVALID; 2637 xpt_done(ccb); 2638 break; 2639 } 2640 } 2641 2642 #define ISPDDB (CAM_DEBUG_INFO|CAM_DEBUG_TRACE|CAM_DEBUG_CDB) 2643 void 2644 isp_done(struct ccb_scsiio *sccb) 2645 { 2646 struct ispsoftc *isp = XS_ISP(sccb); 2647 2648 if (XS_NOERR(sccb)) 2649 XS_SETERR(sccb, CAM_REQ_CMP); 2650 2651 if ((sccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP && 2652 (sccb->scsi_status != SCSI_STATUS_OK)) { 2653 sccb->ccb_h.status &= ~CAM_STATUS_MASK; 2654 if ((sccb->scsi_status == SCSI_STATUS_CHECK_COND) && 2655 (sccb->ccb_h.status & CAM_AUTOSNS_VALID) == 0) { 2656 sccb->ccb_h.status |= CAM_AUTOSENSE_FAIL; 2657 } else { 2658 sccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR; 2659 } 2660 } 2661 2662 sccb->ccb_h.status &= ~CAM_SIM_QUEUED; 2663 if ((sccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2664 if ((sccb->ccb_h.status & CAM_DEV_QFRZN) == 0) { 2665 sccb->ccb_h.status |= CAM_DEV_QFRZN; 2666 xpt_freeze_devq(sccb->ccb_h.path, 1); 2667 isp_prt(isp, ISP_LOGDEBUG0, 2668 "freeze devq %d.%d cam sts %x scsi sts %x", 2669 sccb->ccb_h.target_id, sccb->ccb_h.target_lun, 2670 sccb->ccb_h.status, sccb->scsi_status); 2671 } 2672 } 2673 2674 if ((CAM_DEBUGGED(sccb->ccb_h.path, ISPDDB)) && 2675 (sccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2676 xpt_print_path(sccb->ccb_h.path); 2677 isp_prt(isp, ISP_LOGINFO, 2678 "cam completion status 0x%x", sccb->ccb_h.status); 2679 } 2680 2681 XS_CMD_S_DONE(sccb); 2682 if (XS_CMD_WDOG_P(sccb) == 0) { 2683 untimeout(isp_watchdog, (caddr_t)sccb, sccb->ccb_h.timeout_ch); 2684 if (XS_CMD_GRACE_P(sccb)) { 2685 isp_prt(isp, ISP_LOGDEBUG2, 2686 "finished command on borrowed time"); 2687 } 2688 XS_CMD_S_CLEAR(sccb); 2689 ISPLOCK_2_CAMLOCK(isp); 2690 xpt_done((union ccb *) sccb); 2691 CAMLOCK_2_ISPLOCK(isp); 2692 } 2693 } 2694 2695 int 2696 isp_async(struct ispsoftc *isp, ispasync_t cmd, void *arg) 2697 { 2698 int bus, rv = 0; 2699 switch (cmd) { 2700 case ISPASYNC_NEW_TGT_PARAMS: 2701 { 2702 #ifdef CAM_NEW_TRAN_CODE 2703 struct ccb_trans_settings_scsi *scsi; 2704 struct ccb_trans_settings_spi *spi; 2705 #endif 2706 int flags, tgt; 2707 sdparam *sdp = isp->isp_param; 2708 struct ccb_trans_settings cts; 2709 struct cam_path *tmppath; 2710 2711 bzero(&cts, sizeof (struct ccb_trans_settings)); 2712 2713 tgt = *((int *)arg); 2714 bus = (tgt >> 16) & 0xffff; 2715 tgt &= 0xffff; 2716 sdp += bus; 2717 ISPLOCK_2_CAMLOCK(isp); 2718 if (xpt_create_path(&tmppath, NULL, 2719 cam_sim_path(bus? isp->isp_sim2 : isp->isp_sim), 2720 tgt, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 2721 CAMLOCK_2_ISPLOCK(isp); 2722 isp_prt(isp, ISP_LOGWARN, 2723 "isp_async cannot make temp path for %d.%d", 2724 tgt, bus); 2725 rv = -1; 2726 break; 2727 } 2728 CAMLOCK_2_ISPLOCK(isp); 2729 flags = sdp->isp_devparam[tgt].actv_flags; 2730 #ifdef CAM_NEW_TRAN_CODE 2731 cts.type = CTS_TYPE_CURRENT_SETTINGS; 2732 cts.protocol = PROTO_SCSI; 2733 cts.transport = XPORT_SPI; 2734 2735 scsi = &cts.proto_specific.scsi; 2736 spi = &cts.xport_specific.spi; 2737 2738 if (flags & DPARM_TQING) { 2739 scsi->valid |= CTS_SCSI_VALID_TQ; 2740 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 2741 spi->flags |= CTS_SPI_FLAGS_TAG_ENB; 2742 } 2743 2744 if (flags & DPARM_DISC) { 2745 spi->valid |= CTS_SPI_VALID_DISC; 2746 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 2747 } 2748 spi->flags |= CTS_SPI_VALID_BUS_WIDTH; 2749 if (flags & DPARM_WIDE) { 2750 spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT; 2751 } else { 2752 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 2753 } 2754 if (flags & DPARM_SYNC) { 2755 spi->valid |= CTS_SPI_VALID_SYNC_RATE; 2756 spi->valid |= CTS_SPI_VALID_SYNC_OFFSET; 2757 spi->sync_period = sdp->isp_devparam[tgt].actv_period; 2758 spi->sync_offset = sdp->isp_devparam[tgt].actv_offset; 2759 } 2760 #else 2761 cts.flags = CCB_TRANS_CURRENT_SETTINGS; 2762 cts.valid = CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID; 2763 if (flags & DPARM_DISC) { 2764 cts.flags |= CCB_TRANS_DISC_ENB; 2765 } 2766 if (flags & DPARM_TQING) { 2767 cts.flags |= CCB_TRANS_TAG_ENB; 2768 } 2769 cts.valid |= CCB_TRANS_BUS_WIDTH_VALID; 2770 cts.bus_width = (flags & DPARM_WIDE)? 2771 MSG_EXT_WDTR_BUS_8_BIT : MSG_EXT_WDTR_BUS_16_BIT; 2772 cts.sync_period = sdp->isp_devparam[tgt].actv_period; 2773 cts.sync_offset = sdp->isp_devparam[tgt].actv_offset; 2774 if (flags & DPARM_SYNC) { 2775 cts.valid |= 2776 CCB_TRANS_SYNC_RATE_VALID | 2777 CCB_TRANS_SYNC_OFFSET_VALID; 2778 } 2779 #endif 2780 isp_prt(isp, ISP_LOGDEBUG2, 2781 "NEW_TGT_PARAMS bus %d tgt %d period %x offset %x flags %x", 2782 bus, tgt, sdp->isp_devparam[tgt].actv_period, 2783 sdp->isp_devparam[tgt].actv_offset, flags); 2784 xpt_setup_ccb(&cts.ccb_h, tmppath, 1); 2785 ISPLOCK_2_CAMLOCK(isp); 2786 xpt_async(AC_TRANSFER_NEG, tmppath, &cts); 2787 xpt_free_path(tmppath); 2788 CAMLOCK_2_ISPLOCK(isp); 2789 break; 2790 } 2791 case ISPASYNC_BUS_RESET: 2792 bus = *((int *)arg); 2793 isp_prt(isp, ISP_LOGINFO, "SCSI bus reset on bus %d detected", 2794 bus); 2795 if (bus > 0 && isp->isp_path2) { 2796 ISPLOCK_2_CAMLOCK(isp); 2797 xpt_async(AC_BUS_RESET, isp->isp_path2, NULL); 2798 CAMLOCK_2_ISPLOCK(isp); 2799 } else if (isp->isp_path) { 2800 ISPLOCK_2_CAMLOCK(isp); 2801 xpt_async(AC_BUS_RESET, isp->isp_path, NULL); 2802 CAMLOCK_2_ISPLOCK(isp); 2803 } 2804 break; 2805 case ISPASYNC_LIP: 2806 if (isp->isp_path) { 2807 isp_freeze_loopdown(isp, "ISPASYNC_LIP"); 2808 } 2809 isp_prt(isp, ISP_LOGINFO, "LIP Received"); 2810 break; 2811 case ISPASYNC_LOOP_RESET: 2812 if (isp->isp_path) { 2813 isp_freeze_loopdown(isp, "ISPASYNC_LOOP_RESET"); 2814 } 2815 isp_prt(isp, ISP_LOGINFO, "Loop Reset Received"); 2816 break; 2817 case ISPASYNC_LOOP_DOWN: 2818 if (isp->isp_path) { 2819 isp_freeze_loopdown(isp, "ISPASYNC_LOOP_DOWN"); 2820 } 2821 isp_prt(isp, ISP_LOGINFO, "Loop DOWN"); 2822 break; 2823 case ISPASYNC_LOOP_UP: 2824 /* 2825 * Now we just note that Loop has come up. We don't 2826 * actually do anything because we're waiting for a 2827 * Change Notify before activating the FC cleanup 2828 * thread to look at the state of the loop again. 2829 */ 2830 isp_prt(isp, ISP_LOGINFO, "Loop UP"); 2831 break; 2832 case ISPASYNC_PROMENADE: 2833 { 2834 struct cam_path *tmppath; 2835 const char *fmt = "Target %d (Loop 0x%x) Port ID 0x%x " 2836 "(role %s) %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x"; 2837 static const char *roles[4] = { 2838 "(none)", "Target", "Initiator", "Target/Initiator" 2839 }; 2840 fcparam *fcp = isp->isp_param; 2841 int tgt = *((int *) arg); 2842 int is_tgt_mask = (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT); 2843 struct lportdb *lp = &fcp->portdb[tgt]; 2844 2845 isp_prt(isp, ISP_LOGINFO, fmt, tgt, lp->loopid, lp->portid, 2846 roles[lp->roles & 0x3], 2847 (lp->valid)? "Arrived" : "Departed", 2848 (u_int32_t) (lp->port_wwn >> 32), 2849 (u_int32_t) (lp->port_wwn & 0xffffffffLL), 2850 (u_int32_t) (lp->node_wwn >> 32), 2851 (u_int32_t) (lp->node_wwn & 0xffffffffLL)); 2852 2853 ISPLOCK_2_CAMLOCK(isp); 2854 if (xpt_create_path(&tmppath, NULL, cam_sim_path(isp->isp_sim), 2855 (target_id_t)tgt, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 2856 CAMLOCK_2_ISPLOCK(isp); 2857 break; 2858 } 2859 /* 2860 * Policy: only announce targets. 2861 */ 2862 if (lp->roles & is_tgt_mask) { 2863 if (lp->valid) { 2864 xpt_async(AC_FOUND_DEVICE, tmppath, NULL); 2865 } else { 2866 xpt_async(AC_LOST_DEVICE, tmppath, NULL); 2867 } 2868 } 2869 xpt_free_path(tmppath); 2870 CAMLOCK_2_ISPLOCK(isp); 2871 break; 2872 } 2873 case ISPASYNC_CHANGE_NOTIFY: 2874 if (arg == ISPASYNC_CHANGE_PDB) { 2875 isp_prt(isp, ISP_LOGINFO, 2876 "Port Database Changed"); 2877 } else if (arg == ISPASYNC_CHANGE_SNS) { 2878 isp_prt(isp, ISP_LOGINFO, 2879 "Name Server Database Changed"); 2880 } 2881 #ifdef ISP_SMPLOCK 2882 cv_signal(&isp->isp_osinfo.kthread_cv); 2883 #else 2884 wakeup(&isp->isp_osinfo.kthread_cv); 2885 #endif 2886 break; 2887 case ISPASYNC_FABRIC_DEV: 2888 { 2889 int target, base, lim; 2890 fcparam *fcp = isp->isp_param; 2891 struct lportdb *lp = NULL; 2892 struct lportdb *clp = (struct lportdb *) arg; 2893 char *pt; 2894 2895 switch (clp->port_type) { 2896 case 1: 2897 pt = " N_Port"; 2898 break; 2899 case 2: 2900 pt = " NL_Port"; 2901 break; 2902 case 3: 2903 pt = "F/NL_Port"; 2904 break; 2905 case 0x7f: 2906 pt = " Nx_Port"; 2907 break; 2908 case 0x81: 2909 pt = " F_port"; 2910 break; 2911 case 0x82: 2912 pt = " FL_Port"; 2913 break; 2914 case 0x84: 2915 pt = " E_port"; 2916 break; 2917 default: 2918 pt = " "; 2919 break; 2920 } 2921 2922 isp_prt(isp, ISP_LOGINFO, 2923 "%s Fabric Device @ PortID 0x%x", pt, clp->portid); 2924 2925 /* 2926 * If we don't have an initiator role we bail. 2927 * 2928 * We just use ISPASYNC_FABRIC_DEV for announcement purposes. 2929 */ 2930 2931 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) { 2932 break; 2933 } 2934 2935 /* 2936 * Is this entry for us? If so, we bail. 2937 */ 2938 2939 if (fcp->isp_portid == clp->portid) { 2940 break; 2941 } 2942 2943 /* 2944 * Else, the default policy is to find room for it in 2945 * our local port database. Later, when we execute 2946 * the call to isp_pdb_sync either this newly arrived 2947 * or already logged in device will be (re)announced. 2948 */ 2949 2950 if (fcp->isp_topo == TOPO_FL_PORT) 2951 base = FC_SNS_ID+1; 2952 else 2953 base = 0; 2954 2955 if (fcp->isp_topo == TOPO_N_PORT) 2956 lim = 1; 2957 else 2958 lim = MAX_FC_TARG; 2959 2960 /* 2961 * Is it already in our list? 2962 */ 2963 for (target = base; target < lim; target++) { 2964 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 2965 continue; 2966 } 2967 lp = &fcp->portdb[target]; 2968 if (lp->port_wwn == clp->port_wwn && 2969 lp->node_wwn == clp->node_wwn) { 2970 lp->fabric_dev = 1; 2971 break; 2972 } 2973 } 2974 if (target < lim) { 2975 break; 2976 } 2977 for (target = base; target < lim; target++) { 2978 if (target >= FL_PORT_ID && target <= FC_SNS_ID) { 2979 continue; 2980 } 2981 lp = &fcp->portdb[target]; 2982 if (lp->port_wwn == 0) { 2983 break; 2984 } 2985 } 2986 if (target == lim) { 2987 isp_prt(isp, ISP_LOGWARN, 2988 "out of space for fabric devices"); 2989 break; 2990 } 2991 lp->port_type = clp->port_type; 2992 lp->fc4_type = clp->fc4_type; 2993 lp->node_wwn = clp->node_wwn; 2994 lp->port_wwn = clp->port_wwn; 2995 lp->portid = clp->portid; 2996 lp->fabric_dev = 1; 2997 break; 2998 } 2999 #ifdef ISP_TARGET_MODE 3000 case ISPASYNC_TARGET_MESSAGE: 3001 { 3002 tmd_msg_t *mp = arg; 3003 isp_prt(isp, ISP_LOGALL, 3004 "bus %d iid %d tgt %d lun %d ttype %x tval %x msg[0]=%x", 3005 mp->nt_bus, (int) mp->nt_iid, (int) mp->nt_tgt, 3006 (int) mp->nt_lun, mp->nt_tagtype, mp->nt_tagval, 3007 mp->nt_msg[0]); 3008 break; 3009 } 3010 case ISPASYNC_TARGET_EVENT: 3011 { 3012 tmd_event_t *ep = arg; 3013 isp_prt(isp, ISP_LOGALL, 3014 "bus %d event code 0x%x", ep->ev_bus, ep->ev_event); 3015 break; 3016 } 3017 case ISPASYNC_TARGET_ACTION: 3018 switch (((isphdr_t *)arg)->rqs_entry_type) { 3019 default: 3020 isp_prt(isp, ISP_LOGWARN, 3021 "event 0x%x for unhandled target action", 3022 ((isphdr_t *)arg)->rqs_entry_type); 3023 break; 3024 case RQSTYPE_NOTIFY: 3025 if (IS_SCSI(isp)) { 3026 rv = isp_handle_platform_notify_scsi(isp, 3027 (in_entry_t *) arg); 3028 } else { 3029 rv = isp_handle_platform_notify_fc(isp, 3030 (in_fcentry_t *) arg); 3031 } 3032 break; 3033 case RQSTYPE_ATIO: 3034 rv = isp_handle_platform_atio(isp, (at_entry_t *) arg); 3035 break; 3036 case RQSTYPE_ATIO2: 3037 rv = isp_handle_platform_atio2(isp, (at2_entry_t *)arg); 3038 break; 3039 case RQSTYPE_CTIO2: 3040 case RQSTYPE_CTIO: 3041 rv = isp_handle_platform_ctio(isp, arg); 3042 break; 3043 case RQSTYPE_ENABLE_LUN: 3044 case RQSTYPE_MODIFY_LUN: 3045 if (IS_DUALBUS(isp)) { 3046 bus = 3047 GET_BUS_VAL(((lun_entry_t *)arg)->le_rsvd); 3048 } else { 3049 bus = 0; 3050 } 3051 isp_cv_signal_rqe(isp, bus, 3052 ((lun_entry_t *)arg)->le_status); 3053 break; 3054 } 3055 break; 3056 #endif 3057 case ISPASYNC_FW_CRASH: 3058 { 3059 u_int16_t mbox1, mbox6; 3060 mbox1 = ISP_READ(isp, OUTMAILBOX1); 3061 if (IS_DUALBUS(isp)) { 3062 mbox6 = ISP_READ(isp, OUTMAILBOX6); 3063 } else { 3064 mbox6 = 0; 3065 } 3066 isp_prt(isp, ISP_LOGERR, 3067 "Internal Firmware Error on bus %d @ RISC Address 0x%x", 3068 mbox6, mbox1); 3069 #ifdef ISP_FW_CRASH_DUMP 3070 /* 3071 * XXX: really need a thread to do this right. 3072 */ 3073 if (IS_FC(isp)) { 3074 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT; 3075 FCPARAM(isp)->isp_loopstate = LOOP_NIL; 3076 isp_freeze_loopdown(isp, "f/w crash"); 3077 isp_fw_dump(isp); 3078 } 3079 isp_reinit(isp); 3080 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL); 3081 #endif 3082 break; 3083 } 3084 case ISPASYNC_UNHANDLED_RESPONSE: 3085 break; 3086 default: 3087 isp_prt(isp, ISP_LOGERR, "unknown isp_async event %d", cmd); 3088 break; 3089 } 3090 return (rv); 3091 } 3092 3093 3094 /* 3095 * Locks are held before coming here. 3096 */ 3097 void 3098 isp_uninit(struct ispsoftc *isp) 3099 { 3100 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET); 3101 DISABLE_INTS(isp); 3102 } 3103 3104 void 3105 isp_prt(struct ispsoftc *isp, int level, const char *fmt, ...) 3106 { 3107 va_list ap; 3108 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) { 3109 return; 3110 } 3111 printf("%s: ", device_get_nameunit(isp->isp_dev)); 3112 va_start(ap, fmt); 3113 vprintf(fmt, ap); 3114 va_end(ap); 3115 printf("\n"); 3116 } 3117