isp_target.c revision 1.4
1 /* $NetBSD: isp_target.c,v 1.4 2000/05/13 16:53:04 he Exp $ */ 2 /* 3 * Machine and OS Independent Target Mode Code for the Qlogic SCSI/FC adapters. 4 * 5 * Copyright (c) 1999 by Matthew Jacob 6 * All rights reserved. 7 * mjacob (at) feral.com 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice immediately at the beginning of the file, without modification, 14 * this list of conditions, and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 25 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 /* 35 * Include header file appropriate for platform we're building on. 36 */ 37 38 #ifdef __NetBSD__ 39 #include <dev/ic/isp_netbsd.h> 40 #endif 41 #ifdef __FreeBSD__ 42 #include <dev/isp/isp_freebsd.h> 43 #endif 44 #ifdef __OpenBSD__ 45 #include <dev/ic/isp_openbsd.h> 46 #endif 47 #ifdef __linux__ 48 #include "isp_linux.h" 49 #endif 50 51 #ifdef ISP_TARGET_MODE 52 int isp_tdebug = 0; 53 54 static void isp_got_msg __P((struct ispsoftc *, int, in_entry_t *)); 55 static void isp_got_msg_fc __P((struct ispsoftc *, int, in_fcentry_t *)); 56 static void isp_notify_ack __P((struct ispsoftc *, void *)); 57 static void isp_handle_atio(struct ispsoftc *, at_entry_t *); 58 static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *); 59 static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *); 60 static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *); 61 62 /* 63 * The Qlogic driver gets an interrupt to look at response queue entries. 64 * Some of these are status completions for initiatior mode commands, but 65 * if target mode is enabled, we get a whole wad of response queue entries 66 * to be handled here. 67 * 68 * Basically the split into 3 main groups: Lun Enable/Modification responses, 69 * SCSI Command processing, and Immediate Notification events. 70 * 71 * You start by writing a request queue entry to enable target mode (and 72 * establish some resource limitations which you can modify later). 73 * The f/w responds with a LUN ENABLE or LUN MODIFY response with 74 * the status of this action. If the enable was successful, you can expect... 75 * 76 * Response queue entries with SCSI commands encapsulate show up in an ATIO 77 * (Accept Target IO) type- sometimes with enough info to stop the command at 78 * this level. Ultimately the driver has to feed back to the f/w's request 79 * queue a sequence of CTIOs (continue target I/O) that describe data to 80 * be moved and/or status to be sent) and finally finishing with sending 81 * to the f/w's response queue an ATIO which then completes the handshake 82 * with the f/w for that command. There's a lot of variations on this theme, 83 * including flags you can set in the CTIO for the Qlogic 2X00 fibre channel 84 * cards that 'auto-replenish' the f/w's ATIO count, but this is the basic 85 * gist of it. 86 * 87 * The third group that can show up in the response queue are Immediate 88 * Notification events. These include things like notifications of SCSI bus 89 * resets, or Bus Device Reset messages or other messages received. This 90 * a classic oddbins area. It can get a little wierd because you then turn 91 * around and acknowledge the Immediate Notify by writing an entry onto the 92 * request queue and then the f/w turns around and gives you an acknowledgement 93 * to *your* acknowledgement on the response queue (the idea being to let 94 * the f/w tell you when the event is *really* over I guess). 95 * 96 */ 97 98 99 /* 100 * A new response queue entry has arrived. The interrupt service code 101 * has already swizzled it into the platform dependent from canonical form. 102 * 103 * Because of the way this driver is designed, unfortunately most of the 104 * actual synchronization work has to be done in the platform specific 105 * code- we have no synchroniation primitives in the common code. 106 */ 107 108 int 109 isp_target_notify(isp, vptr, optrp) 110 struct ispsoftc *isp; 111 void *vptr; 112 u_int16_t *optrp; 113 { 114 u_int16_t status, seqid; 115 union { 116 at_entry_t *atiop; 117 at2_entry_t *at2iop; 118 ct_entry_t *ctiop; 119 ct2_entry_t *ct2iop; 120 lun_entry_t *lunenp; 121 in_entry_t *inotp; 122 in_fcentry_t *inot_fcp; 123 na_entry_t *nackp; 124 na_fcentry_t *nack_fcp; 125 isphdr_t *hp; 126 void * *vp; 127 #define atiop unp.atiop 128 #define at2iop unp.at2iop 129 #define ctiop unp.ctiop 130 #define ct2iop unp.ct2iop 131 #define lunenp unp.lunenp 132 #define inotp unp.inotp 133 #define inot_fcp unp.inot_fcp 134 #define nackp unp.nackp 135 #define nack_fcp unp.nack_fcp 136 #define hdrp unp.hp 137 } unp; 138 int bus, rval = 0; 139 140 unp.vp = vptr; 141 142 ISP_TDQE(isp, "isp_target_notify", (int) *optrp, vptr); 143 144 switch(hdrp->rqs_entry_type) { 145 case RQSTYPE_ATIO: 146 isp_handle_atio(isp, atiop); 147 break; 148 case RQSTYPE_CTIO: 149 isp_handle_ctio(isp, ctiop); 150 break; 151 case RQSTYPE_ATIO2: 152 isp_handle_atio2(isp, at2iop); 153 break; 154 case RQSTYPE_CTIO2: 155 isp_handle_ctio2(isp, ct2iop); 156 break; 157 case RQSTYPE_ENABLE_LUN: 158 case RQSTYPE_MODIFY_LUN: 159 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, vptr); 160 break; 161 162 case RQSTYPE_NOTIFY: 163 /* 164 * Either the ISP received a SCSI message it can't 165 * handle, or it's returning an Immed. Notify entry 166 * we sent. We can send Immed. Notify entries to 167 * increment the firmware's resource count for them 168 * (we set this initially in the Enable Lun entry). 169 */ 170 bus = 0; 171 if (IS_FC(isp)) { 172 status = inot_fcp->in_status; 173 seqid = inot_fcp->in_seqid; 174 } else { 175 status = inotp->in_status & 0xff; 176 seqid = inotp->in_seqid; 177 if (IS_DUALBUS(isp)) { 178 bus = (inotp->in_iid & 0x80) >> 7; 179 inotp->in_iid &= ~0x80; 180 } 181 } 182 ITDEBUG(2, ("isp_target_notify: Immediate Notify, " 183 "status=0x%x seqid=0x%x\n", status, seqid)); 184 switch (status) { 185 case IN_RESET: 186 (void) isp_async(isp, ISPASYNC_BUS_RESET, &bus); 187 break; 188 case IN_MSG_RECEIVED: 189 case IN_IDE_RECEIVED: 190 if (IS_FC(isp)) { 191 isp_got_msg_fc(isp, bus, vptr); 192 } else { 193 isp_got_msg(isp, bus, vptr); 194 } 195 break; 196 case IN_RSRC_UNAVAIL: 197 PRINTF("%s: Firmware out of ATIOs\n", isp->isp_name); 198 break; 199 case IN_ABORT_TASK: 200 PRINTF("%s: Abort Task for Initiator %d RX_ID 0x%x\n", 201 isp->isp_name, inot_fcp->in_iid, seqid); 202 break; 203 case IN_PORT_LOGOUT: 204 PRINTF("%s: Port Logout for Initiator %d RX_ID 0x%x\n", 205 isp->isp_name, inot_fcp->in_iid, seqid); 206 break; 207 case IN_PORT_CHANGED: 208 PRINTF("%s: Port Changed for Initiator %d RX_ID 0x%x\n", 209 isp->isp_name, inot_fcp->in_iid, seqid); 210 break; 211 case IN_GLOBAL_LOGO: 212 PRINTF("%s: All ports logged out\n", isp->isp_name); 213 break; 214 default: 215 PRINTF("%s: bad status (0x%x) in isp_target_notify\n", 216 isp->isp_name, status); 217 break; 218 } 219 isp_notify_ack(isp, vptr); 220 break; 221 222 case RQSTYPE_NOTIFY_ACK: 223 /* 224 * The ISP is acknowledging our acknowledgement of an 225 * Immediate Notify entry for some asynchronous event. 226 */ 227 if (IS_FC(isp)) { 228 ITDEBUG(2, ("%s: Notify Ack status=0x%x seqid 0x%x\n", 229 isp->isp_name, nack_fcp->na_status, 230 nack_fcp->na_seqid)); 231 } else { 232 ITDEBUG(2, ("%s: Notify Ack event 0x%x status=0x%x " 233 "seqid 0x%x\n", isp->isp_name, nackp->na_event, 234 nackp->na_status, nackp->na_seqid)); 235 } 236 break; 237 default: 238 PRINTF("%s: Unknown entry type 0x%x in isp_target_notify", 239 isp->isp_name, hdrp->rqs_entry_type); 240 rval = -1; 241 break; 242 } 243 #undef atiop 244 #undef at2iop 245 #undef ctiop 246 #undef ct2iop 247 #undef lunenp 248 #undef inotp 249 #undef inot_fcp 250 #undef nackp 251 #undef nack_fcp 252 #undef hdrp 253 return (rval); 254 } 255 256 257 /* 258 * Toggle (on/off) target mode for bus/target/lun 259 * 260 * The caller has checked for overlap and legality. 261 * 262 * Note that not all of bus, target or lun can be paid attention to. 263 * Note also that this action will not be complete until the f/w writes 264 * response entry. The caller is responsible for synchronizing this. 265 */ 266 int 267 isp_lun_cmd(isp, cmd, bus, tgt, lun, opaque) 268 struct ispsoftc *isp; 269 int cmd; 270 int bus; 271 int tgt; 272 int lun; 273 u_int32_t opaque; 274 { 275 lun_entry_t el; 276 u_int16_t iptr, optr; 277 void *outp; 278 279 280 MEMZERO(&el, sizeof (el)); 281 if (IS_DUALBUS(isp)) { 282 el.le_rsvd = (bus & 0x1) << 7; 283 } 284 el.le_cmd_count = DFLT_CMD_CNT; 285 el.le_in_count = DFLT_INOTIFY; 286 if (cmd == RQSTYPE_ENABLE_LUN) { 287 if (IS_SCSI(isp)) { 288 el.le_flags = LUN_TQAE; 289 el.le_cdb6len = 12; 290 el.le_cdb7len = 12; 291 } 292 } else if (cmd == -RQSTYPE_ENABLE_LUN) { 293 cmd = RQSTYPE_ENABLE_LUN; 294 el.le_cmd_count = 0; 295 el.le_in_count = 0; 296 } else if (cmd == -RQSTYPE_MODIFY_LUN) { 297 cmd = RQSTYPE_MODIFY_LUN; 298 el.le_ops = LUN_CCDECR | LUN_INDECR; 299 } else { 300 el.le_ops = LUN_CCINCR | LUN_ININCR; 301 } 302 el.le_header.rqs_entry_type = cmd; 303 el.le_header.rqs_entry_count = 1; 304 el.le_reserved = opaque; 305 if (IS_SCSI(isp)) { 306 el.le_tgt = tgt; 307 el.le_lun = lun; 308 #ifndef ISP2100_SCCLUN 309 } else { 310 el.le_lun = lun; 311 #endif 312 } 313 314 if (isp_getrqentry(isp, &iptr, &optr, &outp)) { 315 PRINTF("%s: Request Queue Overflow in isp_lun_cmd\n", 316 isp->isp_name); 317 return (-1); 318 } 319 ISP_SWIZ_ENABLE_LUN(isp, outp, &el); 320 ISP_TDQE(isp, "isp_lun_cmd", (int) optr, &el); 321 ISP_ADD_REQUEST(isp, iptr); 322 return (0); 323 } 324 325 326 int 327 isp_target_put_entry(isp, ap) 328 struct ispsoftc *isp; 329 void *ap; 330 { 331 void *outp; 332 u_int16_t iptr, optr; 333 u_int8_t etype = ((isphdr_t *) ap)->rqs_entry_type; 334 335 if (isp_getrqentry(isp, &iptr, &optr, &outp)) { 336 PRINTF("%s: Request Queue Overflow in isp_target_put_entry " 337 "for type 0x%x\n", isp->isp_name, etype); 338 return (-1); 339 } 340 switch (etype) { 341 case RQSTYPE_ATIO: 342 ISP_SWIZ_ATIO(isp, outp, ap); 343 break; 344 case RQSTYPE_ATIO2: 345 ISP_SWIZ_ATIO2(isp, outp, ap); 346 break; 347 case RQSTYPE_CTIO: 348 ISP_SWIZ_CTIO(isp, outp, ap); 349 break; 350 case RQSTYPE_CTIO2: 351 ISP_SWIZ_CTIO2(isp, outp, ap); 352 break; 353 default: 354 PRINTF("%s: Unknown type 0x%x in isp_put_entry\n", 355 isp->isp_name, etype); 356 return (-1); 357 } 358 359 ISP_TDQE(isp, "isp_target_put_entry", (int) optr, ap);; 360 361 ISP_ADD_REQUEST(isp, iptr); 362 return (0); 363 } 364 365 int 366 isp_target_put_atio(isp, iid, tgt, lun, ttype, tval) 367 struct ispsoftc *isp; 368 int iid; 369 int tgt; 370 int lun; 371 int ttype; 372 int tval; 373 { 374 union { 375 at_entry_t _atio; 376 at2_entry_t _atio2; 377 } atun; 378 379 MEMZERO(&atun, sizeof atun); 380 if (IS_FC(isp)) { 381 atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2; 382 atun._atio2.at_header.rqs_entry_count = 1; 383 #ifdef ISP2100_SCCLUN 384 atun._atio2.at_scclun = (uint16_t) lun; 385 #else 386 atun._atio2.at_lun = (uint8_t) lun; 387 #endif 388 atun._atio2.at_status = CT_OK; 389 } else { 390 atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO; 391 atun._atio.at_header.rqs_entry_count = 1; 392 atun._atio.at_iid = iid; 393 atun._atio.at_tgt = tgt; 394 atun._atio.at_lun = lun; 395 atun._atio.at_tag_type = ttype; 396 atun._atio.at_tag_val = tval; 397 atun._atio.at_status = CT_OK; 398 } 399 return (isp_target_put_entry(isp, &atun)); 400 } 401 402 /* 403 * Command completion- both for handling cases of no resources or 404 * no blackhole driver, or other cases where we have to, inline, 405 * finish the command sanely, or for normal command completion. 406 * 407 * The 'completion' code value has the scsi status byte in the low 8 bits. 408 * If status is a CHECK CONDITION and bit 8 is nonzero, then bits 12..15 have 409 * the sense key and bits 16..23 have the ASCQ and bits 24..31 have the ASC 410 * values. 411 * 412 * NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't 413 * NB: inline SCSI sense reporting. 414 * 415 * For both parallel && fibre channel, we use the feature that does 416 * an automatic resource autoreplenish so we don't have then later do 417 * put of an atio to replenish the f/w's resource count. 418 */ 419 420 int 421 isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int32_t hdl) 422 { 423 int sts; 424 union { 425 ct_entry_t _ctio; 426 ct2_entry_t _ctio2; 427 } un; 428 429 MEMZERO(&un, sizeof un); 430 sts = code & 0xff; 431 432 if (IS_FC(isp)) { 433 at2_entry_t *aep = arg; 434 ct2_entry_t *cto = &un._ctio2; 435 436 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2; 437 cto->ct_header.rqs_entry_count = 1; 438 cto->ct_iid = aep->at_iid; 439 #ifndef ISP2100_SCCLUN 440 cto->ct_lun = aep->at_lun; 441 #endif 442 cto->ct_rxid = aep->at_rxid; 443 cto->rsp.m1.ct_scsi_status = sts & 0xff; 444 cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1; 445 if (hdl == 0) { 446 cto->ct_flags |= CT2_CCINCR; 447 } 448 if (aep->at_datalen) { 449 cto->ct_resid = aep->at_datalen; 450 cto->ct_flags |= CT2_DATA_UNDER; 451 } 452 if ((sts & 0xff) == SCSI_CHECK && (sts & ECMD_SVALID)) { 453 cto->rsp.m1.ct_resp[0] = 0xf0; 454 cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf; 455 cto->rsp.m1.ct_resp[7] = 8; 456 cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff; 457 cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff; 458 cto->rsp.m1.ct_senselen = 16; 459 cto->ct_flags |= CT2_SNSLEN_VALID; 460 } 461 cto->ct_reserved = hdl; 462 } else { 463 at_entry_t *aep = arg; 464 ct_entry_t *cto = &un._ctio; 465 466 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO; 467 cto->ct_header.rqs_entry_count = 1; 468 cto->ct_iid = aep->at_iid; 469 cto->ct_tgt = aep->at_tgt; 470 cto->ct_lun = aep->at_lun; 471 cto->ct_tag_type = aep->at_tag_type; 472 cto->ct_tag_val = aep->at_tag_val; 473 cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA; 474 if (hdl == 0) { 475 cto->ct_flags |= CT_CCINCR; 476 } 477 cto->ct_scsi_status = sts; 478 cto->ct_reserved = hdl; 479 } 480 return (isp_target_put_entry(isp, &un)); 481 } 482 483 void 484 isp_target_async(isp, bus, event) 485 struct ispsoftc *isp; 486 int bus; 487 int event; 488 { 489 tmd_event_t evt; 490 tmd_msg_t msg; 491 492 switch (event) { 493 /* 494 * These three we handle here to propagate an effective bus reset 495 * upstream, but these do not require any immediate notify actions 496 * so we return when done. 497 */ 498 case ASYNC_LIP_OCCURRED: 499 case ASYNC_LOOP_UP: 500 case ASYNC_LOOP_DOWN: 501 evt.ev_bus = bus; 502 evt.ev_event = event; 503 (void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt); 504 return; 505 506 case ASYNC_LOOP_RESET: 507 case ASYNC_BUS_RESET: 508 case ASYNC_TIMEOUT_RESET: 509 if (IS_FC(isp)) { 510 return; /* we'll be getting an inotify instead */ 511 } 512 evt.ev_bus = bus; 513 evt.ev_event = event; 514 (void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt); 515 break; 516 case ASYNC_DEVICE_RESET: 517 /* 518 * Bus Device Reset resets a specific target, so 519 * we pass this as a synthesized message. 520 */ 521 MEMZERO(&msg, sizeof msg); 522 if (IS_FC(isp)) { 523 msg.nt_iid = 524 ((fcparam *)isp->isp_param)->isp_loopid; 525 } else { 526 msg.nt_iid = 527 ((sdparam *)isp->isp_param)->isp_initiator_id; 528 } 529 msg.nt_bus = bus; 530 msg.nt_msg[0] = MSG_BUS_DEV_RESET; 531 (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg); 532 break; 533 default: 534 PRINTF("%s: isp_target_async: unknown event 0x%x\n", 535 isp->isp_name, event); 536 break; 537 } 538 isp_notify_ack(isp, NULL); 539 } 540 541 542 /* 543 * Process a received message. 544 * The ISP firmware can handle most messages, there are only 545 * a few that we need to deal with: 546 * - abort: clean up the current command 547 * - abort tag and clear queue 548 */ 549 550 static void 551 isp_got_msg(isp, bus, inp) 552 struct ispsoftc *isp; 553 int bus; 554 in_entry_t *inp; 555 { 556 u_int8_t status = inp->in_status & ~QLTM_SVALID; 557 558 if (status == IN_IDE_RECEIVED || status == IN_MSG_RECEIVED) { 559 tmd_msg_t msg; 560 561 MEMZERO(&msg, sizeof (msg)); 562 msg.nt_bus = bus; 563 msg.nt_iid = inp->in_iid; 564 msg.nt_tgt = inp->in_tgt; 565 msg.nt_lun = inp->in_lun; 566 msg.nt_tagtype = inp->in_tag_type; 567 msg.nt_tagval = inp->in_tag_val; 568 MEMCPY(msg.nt_msg, inp->in_msg, IN_MSGLEN); 569 (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg); 570 } else { 571 PRINTF("%s: unknown immediate notify status 0x%x\n", 572 isp->isp_name, inp->in_status); 573 } 574 } 575 576 /* 577 * Synthesize a message from the task management flags in a FCP_CMND_IU. 578 */ 579 static void 580 isp_got_msg_fc(isp, bus, inp) 581 struct ispsoftc *isp; 582 int bus; 583 in_fcentry_t *inp; 584 { 585 static char *f1 = "%s: %s from iid %d lun %d seq 0x%x\n"; 586 static char *f2 = 587 "%s: unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n"; 588 589 if (inp->in_status != IN_MSG_RECEIVED) { 590 PRINTF(f2, isp->isp_name, "immediate notify status", 591 inp->in_status, inp->in_lun, inp->in_iid, 592 inp->in_task_flags, inp->in_seqid); 593 } else { 594 tmd_msg_t msg; 595 596 MEMZERO(&msg, sizeof (msg)); 597 msg.nt_bus = bus; 598 msg.nt_iid = inp->in_iid; 599 #ifdef ISP2100_SCCLUN 600 msg.nt_lun = inp->in_scclun; 601 #else 602 msg.nt_lun = inp->in_lun; 603 #endif 604 msg.nt_tagval = inp->in_seqid; 605 606 if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK) { 607 PRINTF(f1, isp->isp_name, "ABORT TASK", 608 inp->in_iid, inp->in_lun, inp->in_seqid); 609 msg.nt_msg[0] = MSG_ABORT_TAG; 610 } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) { 611 PRINTF(f1, isp->isp_name, "CLEAR TASK SET", 612 inp->in_iid, inp->in_lun, inp->in_seqid); 613 msg.nt_msg[0] = MSG_CLEAR_QUEUE; 614 } else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) { 615 PRINTF(f1, isp->isp_name, "TARGET RESET", 616 inp->in_iid, inp->in_lun, inp->in_seqid); 617 msg.nt_msg[0] = MSG_BUS_DEV_RESET; 618 } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) { 619 PRINTF(f1, isp->isp_name, "CLEAR ACA", 620 inp->in_iid, inp->in_lun, inp->in_seqid); 621 /* ???? */ 622 msg.nt_msg[0] = MSG_REL_RECOVERY; 623 } else if (inp->in_task_flags & TASK_FLAGS_TERMINATE_TASK) { 624 PRINTF(f1, isp->isp_name, "TERMINATE TASK", 625 inp->in_iid, inp->in_lun, inp->in_seqid); 626 msg.nt_msg[0] = MSG_TERM_IO_PROC; 627 } else { 628 PRINTF(f2, isp->isp_name, "task flag", 629 inp->in_status, inp->in_lun, inp->in_iid, 630 inp->in_task_flags, inp->in_seqid); 631 } 632 if (msg.nt_msg[0]) { 633 (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg); 634 } 635 } 636 } 637 638 static void 639 isp_notify_ack(isp, arg) 640 struct ispsoftc *isp; 641 void *arg; 642 { 643 char storage[QENTRY_LEN]; 644 u_int16_t iptr, optr; 645 void *outp; 646 647 if (isp_getrqentry(isp, &iptr, &optr, &outp)) { 648 PRINTF("%s: Request Queue Overflow For isp_notify_ack\n", 649 isp->isp_name); 650 return; 651 } 652 653 MEMZERO(storage, QENTRY_LEN); 654 655 if (IS_FC(isp)) { 656 na_fcentry_t *na = (na_fcentry_t *) storage; 657 if (arg) { 658 in_fcentry_t *inp = arg; 659 MEMCPY(storage, arg, sizeof (isphdr_t)); 660 na->na_iid = inp->in_iid; 661 #ifdef ISP2100_SCCLUN 662 na->na_lun = inp->in_scclun; 663 #else 664 na->na_lun = inp->in_lun; 665 #endif 666 na->na_task_flags = inp->in_task_flags; 667 na->na_seqid = inp->in_seqid; 668 na->na_flags = NAFC_RCOUNT; 669 if (inp->in_status == IN_RESET) { 670 na->na_flags |= NAFC_RST_CLRD; 671 } 672 } else { 673 na->na_flags = NAFC_RST_CLRD; 674 } 675 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK; 676 na->na_header.rqs_entry_count = 1; 677 ISP_SWIZ_NOT_ACK_FC(isp, outp, na); 678 } else { 679 na_entry_t *na = (na_entry_t *) storage; 680 if (arg) { 681 in_entry_t *inp = arg; 682 MEMCPY(storage, arg, sizeof (isphdr_t)); 683 na->na_iid = inp->in_iid; 684 na->na_lun = inp->in_lun; 685 na->na_tgt = inp->in_tgt; 686 na->na_seqid = inp->in_seqid; 687 if (inp->in_status == IN_RESET) { 688 na->na_event = NA_RST_CLRD; 689 } 690 } else { 691 na->na_event = NA_RST_CLRD; 692 } 693 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK; 694 na->na_header.rqs_entry_count = 1; 695 ISP_SWIZ_NOT_ACK(isp, outp, na); 696 } 697 ISP_TDQE(isp, "isp_notify_ack", (int) optr, storage); 698 ISP_ADD_REQUEST(isp, iptr); 699 } 700 701 static void 702 isp_handle_atio(isp, aep) 703 struct ispsoftc *isp; 704 at_entry_t *aep; 705 { 706 int lun; 707 lun = aep->at_lun; 708 /* 709 * The firmware status (except for the QLTM_SVALID bit) indicates 710 * why this ATIO was sent to us. 711 * 712 * If QLTM_SVALID is set, the firware has recommended Sense Data. 713 * 714 * If the DISCONNECTS DISABLED bit is set in the flags field, 715 * we're still connected on the SCSI bus - i.e. the initiator 716 * did not set DiscPriv in the identify message. We don't care 717 * about this so it's ignored. 718 */ 719 720 switch(aep->at_status & ~QLTM_SVALID) { 721 case AT_PATH_INVALID: 722 /* 723 * ATIO rejected by the firmware due to disabled lun. 724 */ 725 PRINTF("%s: rejected ATIO for disabled lun %d\n", 726 isp->isp_name, lun); 727 break; 728 case AT_NOCAP: 729 /* 730 * Requested Capability not available 731 * We sent an ATIO that overflowed the firmware's 732 * command resource count. 733 */ 734 PRINTF("%s: rejected ATIO for lun %d because of command count" 735 " overflow\n", isp->isp_name, lun); 736 break; 737 738 case AT_BDR_MSG: 739 /* 740 * If we send an ATIO to the firmware to increment 741 * its command resource count, and the firmware is 742 * recovering from a Bus Device Reset, it returns 743 * the ATIO with this status. We set the command 744 * resource count in the Enable Lun entry and no 745 * not increment it. Therefore we should never get 746 * this status here. 747 */ 748 PRINTF("%s: ATIO returned for lun %d because it was in the " 749 " middle of coping with a Bus Device Reset\n", 750 isp->isp_name, lun); 751 break; 752 753 case AT_CDB: /* Got a CDB */ 754 case AT_PHASE_ERROR: /* Bus Phase Sequence Error */ 755 /* 756 * Punt to platform specific layer. 757 */ 758 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep); 759 break; 760 761 case AT_RESET: 762 /* 763 * A bus reset came along an blew away this command. Why 764 * they do this in addition the async event code stuff, 765 * I dunno. 766 * 767 * Ignore it because the async event will clear things 768 * up for us. 769 */ 770 PRINTF("%s: ATIO returned for lun %d from initiator %d because" 771 " a Bus Reset occurred\n", isp->isp_name, lun, 772 aep->at_iid); 773 break; 774 775 776 default: 777 PRINTF("%s: Unknown ATIO status 0x%x from initiator %d for lun" 778 " %d\n", isp->isp_name, aep->at_status, aep->at_iid, lun); 779 (void) isp_target_put_atio(isp, aep->at_iid, aep->at_tgt, 780 lun, aep->at_tag_type, aep->at_tag_val); 781 break; 782 } 783 } 784 785 static void 786 isp_handle_atio2(isp, aep) 787 struct ispsoftc *isp; 788 at2_entry_t *aep; 789 { 790 int lun; 791 #ifdef ISP2100_SCCLUN 792 lun = aep->at_scclun; 793 #else 794 lun = aep->at_lun; 795 #endif 796 /* 797 * The firmware status (except for the QLTM_SVALID bit) indicates 798 * why this ATIO was sent to us. 799 * 800 * If QLTM_SVALID is set, the firware has recommended Sense Data. 801 * 802 * If the DISCONNECTS DISABLED bit is set in the flags field, 803 * we're still connected on the SCSI bus - i.e. the initiator 804 * did not set DiscPriv in the identify message. We don't care 805 * about this so it's ignored. 806 */ 807 808 switch(aep->at_status & ~QLTM_SVALID) { 809 case AT_PATH_INVALID: 810 /* 811 * ATIO rejected by the firmware due to disabled lun. 812 */ 813 PRINTF("%s: rejected ATIO2 for disabled lun %d\n", 814 isp->isp_name, lun); 815 break; 816 case AT_NOCAP: 817 /* 818 * Requested Capability not available 819 * We sent an ATIO that overflowed the firmware's 820 * command resource count. 821 */ 822 PRINTF("%s: rejected ATIO2 for lun %d because of command count" 823 " overflow\n", isp->isp_name, lun); 824 break; 825 826 case AT_BDR_MSG: 827 /* 828 * If we send an ATIO to the firmware to increment 829 * its command resource count, and the firmware is 830 * recovering from a Bus Device Reset, it returns 831 * the ATIO with this status. We set the command 832 * resource count in the Enable Lun entry and no 833 * not increment it. Therefore we should never get 834 * this status here. 835 */ 836 PRINTF("%s: ATIO2 returned for lun %d because it was in the " 837 " middle of coping with a Bus Device Reset\n", 838 isp->isp_name, lun); 839 break; 840 841 case AT_CDB: /* Got a CDB */ 842 /* 843 * Punt to platform specific layer. 844 */ 845 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep); 846 break; 847 848 case AT_RESET: 849 /* 850 * A bus reset came along an blew away this command. Why 851 * they do this in addition the async event code stuff, 852 * I dunno. 853 * 854 * Ignore it because the async event will clear things 855 * up for us. 856 */ 857 PRINTF("%s: ATIO2 returned for lun %d from initiator %d because" 858 " a Bus Reset occurred\n", isp->isp_name, lun, 859 aep->at_iid); 860 break; 861 862 863 default: 864 PRINTF("%s: Unknown ATIO2 status 0x%x from initiator %d for lun" 865 " %d\n", isp->isp_name, aep->at_status, aep->at_iid, lun); 866 (void) isp_target_put_atio(isp, aep->at_iid, 0, lun, 0, 0); 867 break; 868 } 869 } 870 871 static void 872 isp_handle_ctio(isp, ct) 873 struct ispsoftc *isp; 874 ct_entry_t *ct; 875 { 876 ISP_SCSI_XFER_T *xs; 877 int pl = 0; 878 char *fmsg = NULL; 879 880 if (ct->ct_reserved) { 881 xs = isp_find_xs(isp, ct->ct_reserved); 882 if (xs == NULL) 883 pl = 0; 884 } else { 885 pl = 2; 886 xs = NULL; 887 } 888 889 switch(ct->ct_status & ~QLTM_SVALID) { 890 case CT_OK: 891 /* 892 * There are generally 3 possibilities as to why we'd get 893 * this condition: 894 * We disconnected after receiving a CDB. 895 * We sent or received data. 896 * We sent status & command complete. 897 */ 898 899 if (ct->ct_flags & CT_SENDSTATUS) { 900 break; 901 } else if ((ct->ct_flags & CT_DATAMASK) == CT_NO_DATA) { 902 /* 903 * Nothing to do in this case. 904 */ 905 IDPRINTF(pl, ("%s:CTIO- iid %d disconnected OK\n", 906 isp->isp_name, ct->ct_iid)); 907 return; 908 } 909 break; 910 911 case CT_BDR_MSG: 912 /* 913 * Bus Device Reset message received or the SCSI Bus has 914 * been Reset; the firmware has gone to Bus Free. 915 * 916 * The firmware generates an async mailbox interupt to 917 * notify us of this and returns outstanding CTIOs with this 918 * status. These CTIOs are handled in that same way as 919 * CT_ABORTED ones, so just fall through here. 920 */ 921 fmsg = "Bus Device Reset"; 922 /*FALLTHROUGH*/ 923 case CT_RESET: 924 if (fmsg == NULL) 925 fmsg = "Bus Reset"; 926 /*FALLTHROUGH*/ 927 case CT_ABORTED: 928 /* 929 * When an Abort message is received the firmware goes to 930 * Bus Free and returns all outstanding CTIOs with the status 931 * set, then sends us an Immediate Notify entry. 932 */ 933 if (fmsg == NULL) 934 fmsg = "ABORT TASK sent by Initiator"; 935 936 PRINTF("%s: CTIO destroyed by %s\n", isp->isp_name, fmsg); 937 break; 938 939 case CT_INVAL: 940 /* 941 * CTIO rejected by the firmware due to disabled lun. 942 * "Cannot Happen". 943 */ 944 PRINTF("%s: Firmware rejected CTIO for disabled lun %d\n", 945 isp->isp_name, ct->ct_lun); 946 break; 947 948 case CT_NOPATH: 949 /* 950 * CTIO rejected by the firmware due "no path for the 951 * nondisconnecting nexus specified". This means that 952 * we tried to access the bus while a non-disconnecting 953 * command is in process. 954 */ 955 PRINTF("%s: Firmware rejected CTIO for bad nexus %d/%d/%d\n", 956 isp->isp_name, ct->ct_iid, ct->ct_tgt, ct->ct_lun); 957 break; 958 959 case CT_RSELTMO: 960 fmsg = "Reselection"; 961 /*FALLTHROUGH*/ 962 case CT_TIMEOUT: 963 if (fmsg == NULL) 964 fmsg = "Command"; 965 PRINTF("%s: Firmware timed out on %s\n", isp->isp_name, fmsg); 966 break; 967 968 case CT_ERR: 969 fmsg = "Completed with Error"; 970 /*FALLTHROUGH*/ 971 case CT_PHASE_ERROR: 972 if (fmsg == NULL) 973 fmsg = "Phase Sequence Error"; 974 /*FALLTHROUGH*/ 975 case CT_TERMINATED: 976 if (fmsg == NULL) 977 fmsg = "terminated by TERMINATE TRANSFER"; 978 /*FALLTHROUGH*/ 979 case CT_NOACK: 980 if (fmsg == NULL) 981 fmsg = "unacknowledged Immediate Notify pending"; 982 983 PRINTF("%s: CTIO returned by f/w- %s\n", isp->isp_name, fmsg); 984 #if 0 985 if (status & SENSEVALID) { 986 bcopy((caddr_t) (cep + CTIO_SENSE_OFFSET), 987 (caddr_t) &cdp->cd_sensedata, 988 sizeof(scsi_sense_t)); 989 cdp->cd_flags |= CDF_SENSEVALID; 990 } 991 #endif 992 break; 993 default: 994 PRINTF("%s: Unknown CTIO status 0x%x\n", isp->isp_name, 995 ct->ct_status & ~QLTM_SVALID); 996 break; 997 } 998 999 if (xs == NULL) { 1000 /* 1001 * There may be more than one CTIO for a data transfer, 1002 * or this may be a status CTIO we're not monitoring. 1003 * 1004 * The assumption is that they'll all be returned in the 1005 * order we got them. 1006 */ 1007 if (ct->ct_reserved == 0) { 1008 if ((ct->ct_flags & CT_SENDSTATUS) == 0) { 1009 IDPRINTF(pl, 1010 ("%s: intermediate CTIO completed ok\n", 1011 isp->isp_name)); 1012 } else { 1013 IDPRINTF(pl, 1014 ("%s: unmonitored CTIO completed ok\n", 1015 isp->isp_name)); 1016 } 1017 } else { 1018 IDPRINTF(pl, 1019 ("%s: NO xs for CTIO (handle 0x%x) status 0x%x\n", 1020 isp->isp_name, ct->ct_reserved, 1021 ct->ct_status & ~QLTM_SVALID)); 1022 } 1023 } else { 1024 if (ct->ct_flags & CT_SENDSTATUS) { 1025 /* 1026 * Sent status and command complete. 1027 * 1028 * We're now really done with this command, so we 1029 * punt to the platform dependent layers because 1030 * only there can we do the appropriate command 1031 * complete thread synchronization. 1032 */ 1033 IDPRINTF(pl, 1034 ("%s:status CTIO complete\n", isp->isp_name)); 1035 } else { 1036 /* 1037 * Final CTIO completed. Release DMA resources and 1038 * notify platform dependent layers. 1039 */ 1040 IDPRINTF(pl, 1041 ("%s: data CTIO complete\n", isp->isp_name)); 1042 ISP_DMAFREE(isp, xs, ct->ct_reserved); 1043 } 1044 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct); 1045 /* 1046 * The platform layer will destroy the handle if appropriate. 1047 */ 1048 } 1049 } 1050 1051 static void 1052 isp_handle_ctio2(isp, ct) 1053 struct ispsoftc *isp; 1054 ct2_entry_t *ct; 1055 { 1056 ISP_SCSI_XFER_T *xs; 1057 int pl = 3; 1058 char *fmsg = NULL; 1059 1060 if (ct->ct_reserved) { 1061 xs = isp_find_xs(isp, ct->ct_reserved); 1062 if (xs == NULL) 1063 pl = 0; 1064 } else { 1065 pl = 2; 1066 xs = NULL; 1067 } 1068 1069 switch(ct->ct_status & ~QLTM_SVALID) { 1070 case CT_OK: 1071 /* 1072 * There are generally 2 possibilities as to why we'd get 1073 * this condition: 1074 * We sent or received data. 1075 * We sent status & command complete. 1076 */ 1077 1078 break; 1079 1080 case CT_BDR_MSG: 1081 /* 1082 * Bus Device Reset message received or the SCSI Bus has 1083 * been Reset; the firmware has gone to Bus Free. 1084 * 1085 * The firmware generates an async mailbox interupt to 1086 * notify us of this and returns outstanding CTIOs with this 1087 * status. These CTIOs are handled in that same way as 1088 * CT_ABORTED ones, so just fall through here. 1089 */ 1090 fmsg = "Bus Device Reset"; 1091 /*FALLTHROUGH*/ 1092 case CT_RESET: 1093 if (fmsg == NULL) 1094 fmsg = "Bus Reset"; 1095 /*FALLTHROUGH*/ 1096 case CT_ABORTED: 1097 /* 1098 * When an Abort message is received the firmware goes to 1099 * Bus Free and returns all outstanding CTIOs with the status 1100 * set, then sends us an Immediate Notify entry. 1101 */ 1102 if (fmsg == NULL) 1103 fmsg = "ABORT TASK sent by Initiator"; 1104 1105 PRINTF("%s: CTIO2 destroyed by %s\n", isp->isp_name, fmsg); 1106 break; 1107 1108 case CT_INVAL: 1109 /* 1110 * CTIO rejected by the firmware - invalid data direction. 1111 */ 1112 PRINTF("%s: CTIO2 had wrong data directiond\n", isp->isp_name); 1113 break; 1114 1115 case CT_NOPATH: 1116 /* 1117 * CTIO rejected by the firmware due "no path for the 1118 * nondisconnecting nexus specified". This means that 1119 * we tried to access the bus while a non-disconnecting 1120 * command is in process. 1121 */ 1122 PRINTF("%s: Firmware rejected CTIO2 for bad nexus %d->%d\n", 1123 isp->isp_name, ct->ct_iid, ct->ct_lun); 1124 break; 1125 1126 case CT_RSELTMO: 1127 fmsg = "Reselection"; 1128 /*FALLTHROUGH*/ 1129 case CT_TIMEOUT: 1130 if (fmsg == NULL) 1131 fmsg = "Command"; 1132 PRINTF("%s: Firmware timed out on %s\n", isp->isp_name, fmsg); 1133 break; 1134 1135 case CT_ERR: 1136 fmsg = "Completed with Error"; 1137 /*FALLTHROUGH*/ 1138 case CT_PHASE_ERROR: /* Bus phase sequence error */ 1139 if (fmsg == NULL) 1140 fmsg = "Phase Sequence Error"; 1141 /*FALLTHROUGH*/ 1142 case CT_TERMINATED: 1143 if (fmsg == NULL) 1144 fmsg = "terminated by TERMINATE TRANSFER"; 1145 /*FALLTHROUGH*/ 1146 case CT_LOGOUT: 1147 if (fmsg == NULL) 1148 fmsg = "Port Logout"; 1149 /*FALLTHROUGH*/ 1150 case CT_PORTNOTAVAIL: 1151 if (fmsg == NULL) 1152 fmsg = "Port not available"; 1153 case CT_NOACK: 1154 if (fmsg == NULL) 1155 fmsg = "unacknowledged Immediate Notify pending"; 1156 1157 PRINTF("%s: CTIO returned by f/w- %s\n", isp->isp_name, fmsg); 1158 #if 0 1159 if (status & SENSEVALID) { 1160 bcopy((caddr_t) (cep + CTIO_SENSE_OFFSET), 1161 (caddr_t) &cdp->cd_sensedata, 1162 sizeof(scsi_sense_t)); 1163 cdp->cd_flags |= CDF_SENSEVALID; 1164 } 1165 #endif 1166 break; 1167 1168 case CT_INVRXID: 1169 /* 1170 * CTIO rejected by the firmware because an invalid RX_ID. 1171 * Just print a message. 1172 */ 1173 PRINTF("%s: CTIO2 completed with Invalid RX_ID 0x%x\n", 1174 isp->isp_name, ct->ct_rxid); 1175 break; 1176 1177 default: 1178 IDPRINTF(pl, ("%s: Unknown CTIO status 0x%x\n", isp->isp_name, 1179 ct->ct_status & ~QLTM_SVALID)); 1180 break; 1181 } 1182 1183 if (xs == NULL) { 1184 /* 1185 * There may be more than one CTIO for a data transfer, 1186 * or this may be a status CTIO we're not monitoring. 1187 * 1188 * The assumption is that they'll all be returned in the 1189 * order we got them. 1190 */ 1191 if (ct->ct_reserved == 0) { 1192 if ((ct->ct_flags & CT_SENDSTATUS) == 0) { 1193 IDPRINTF(pl, 1194 ("%s: intermediate CTIO completed ok\n", 1195 isp->isp_name)); 1196 } else { 1197 IDPRINTF(pl, 1198 ("%s: unmonitored CTIO completed ok\n", 1199 isp->isp_name)); 1200 } 1201 } else { 1202 IDPRINTF(pl, 1203 ("%s: NO xs for CTIO (handle 0x%x) status 0x%x\n", 1204 isp->isp_name, ct->ct_reserved, 1205 ct->ct_status & ~QLTM_SVALID)); 1206 } 1207 } else { 1208 if (ct->ct_flags & CT_SENDSTATUS) { 1209 /* 1210 * Sent status and command complete. 1211 * 1212 * We're now really done with this command, so we 1213 * punt to the platform dependent layers because 1214 * only there can we do the appropriate command 1215 * complete thread synchronization. 1216 */ 1217 IDPRINTF(pl, 1218 ("%s: status CTIO complete\n", isp->isp_name)); 1219 } else { 1220 /* 1221 * Final CTIO completed. Release DMA resources and 1222 * notify platform dependent layers. 1223 */ 1224 IDPRINTF(pl, 1225 ("%s: data CTIO complete\n", isp->isp_name)); 1226 ISP_DMAFREE(isp, xs, ct->ct_reserved); 1227 } 1228 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct); 1229 /* 1230 * The platform layer will destroy the handle if appropriate. 1231 */ 1232 } 1233 } 1234 #endif 1235
Indexes created Thu Sep 25 08:09:54 GMT 2025