1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * ISSUES 31 * 32 * - more consistent error messages 33 * - report name of device on errors? 34 * - if wide target renegotiates sync, back to narrow? 35 * - last_msgout is not accurate ???? 36 * - resolve XXXX 37 * - improve msg reject code (use special msg reject handler) 38 * - better use of IDE message 39 * - keep track if ATN remains asserted and target not going into 40 * a msg-out phase 41 * - improve comments 42 * - no slave accesses when start address is odd and dma hasn't started 43 * this affect asserting ATN 44 */ 45 46 /* 47 * fas - QLogic fas366 wide/fast SCSI Processor HBA driver with 48 * tagged and non-tagged queueing support 49 */ 50 #if defined(lint) && !defined(DEBUG) 51 #define DEBUG 1 52 #define FASDEBUG 53 #endif 54 55 #define DMA_REG_TRACING /* enable dma register access tracing */ 56 57 58 /* 59 * standard header files 60 */ 61 #include <sys/note.h> 62 #include <sys/scsi/scsi.h> 63 #include <sys/file.h> 64 #include <sys/vtrace.h> 65 66 /* 67 * private header files 68 */ 69 #include <sys/scsi/adapters/fasdma.h> 70 #include <sys/scsi/adapters/fasreg.h> 71 #include <sys/scsi/adapters/fasvar.h> 72 #include <sys/scsi/adapters/fascmd.h> 73 #include <sys/scsi/impl/scsi_reset_notify.h> 74 75 /* 76 * tunables 77 */ 78 static int fas_selection_timeout = 250; /* 250 milliseconds */ 79 static uchar_t fas_default_offset = DEFAULT_OFFSET; 80 81 /* 82 * needed for presto support, do not remove 83 */ 84 static int fas_enable_sbus64 = 1; 85 86 #ifdef FASDEBUG 87 int fasdebug = 0; 88 int fasdebug_instance = -1; /* debug all instances */ 89 static int fas_burstsizes_limit = -1; 90 static int fas_no_sync_wide_backoff = 0; 91 #endif /* FASDEBUG */ 92 93 /* 94 * Local static data protected by global mutex 95 */ 96 static kmutex_t fas_global_mutex; /* to allow concurrent attach */ 97 98 static int fas_scsi_watchdog_tick; /* in seconds, for all */ 99 /* instances */ 100 static clock_t fas_tick; /* fas_watch() interval in Hz */ 101 static timeout_id_t fas_reset_watch; /* timeout id for reset watch */ 102 static timeout_id_t fas_timeout_id = 0; 103 static int fas_timeout_initted = 0; 104 105 static krwlock_t fas_global_rwlock; 106 107 static void *fas_state; /* soft state ptr */ 108 static struct fas *fas_head; /* link all softstate structures */ 109 static struct fas *fas_tail; /* for fas_watch() */ 110 111 static kmutex_t fas_log_mutex; 112 static char fas_log_buf[256]; 113 _NOTE(MUTEX_PROTECTS_DATA(fas_global_mutex, fas_reset_watch)) 114 _NOTE(DATA_READABLE_WITHOUT_LOCK(fas_state fas_head fas_tail \ 115 fas_scsi_watchdog_tick fas_tick)) 116 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", fas::f_quiesce_timeid)) 117 118 /* 119 * dma attribute structure for scsi engine 120 */ 121 static ddi_dma_attr_t dma_fasattr = { 122 DMA_ATTR_V0, (unsigned long long)0, 123 (unsigned long long)0xffffffff, (unsigned long long)((1<<24)-1), 124 1, DEFAULT_BURSTSIZE, 1, 125 (unsigned long long)0xffffffff, (unsigned long long)0xffffffff, 126 1, 512, 0 127 }; 128 129 /* 130 * optional torture test stuff 131 */ 132 #ifdef FASDEBUG 133 #define FAS_TEST 134 static int fas_ptest_emsgin; 135 static int fas_ptest_msgin; 136 static int fas_ptest_msg = -1; 137 static int fas_ptest_status; 138 static int fas_ptest_data_in; 139 static int fas_atest; 140 static int fas_atest_disc; 141 static int fas_atest_reconn; 142 static void fas_test_abort(struct fas *fas, int slot); 143 static int fas_rtest; 144 static int fas_rtest_type; 145 static void fas_test_reset(struct fas *fas, int slot); 146 static int fas_force_timeout; 147 static int fas_btest; 148 static int fas_test_stop; 149 static int fas_transport_busy; 150 static int fas_transport_busy_rqs; 151 static int fas_transport_reject; 152 static int fas_arqs_failure; 153 static int fas_tran_err; 154 static int fas_test_untagged; 155 static int fas_enable_untagged; 156 #endif 157 158 /* 159 * warlock directives 160 */ 161 _NOTE(DATA_READABLE_WITHOUT_LOCK(dma fasdebug)) 162 _NOTE(SCHEME_PROTECTS_DATA("just test variables", fas_transport_busy)) 163 _NOTE(SCHEME_PROTECTS_DATA("just test variables", fas_transport_busy_rqs)) 164 _NOTE(SCHEME_PROTECTS_DATA("just test variables", fas_transport_reject)) 165 _NOTE(SCHEME_PROTECTS_DATA("just test variables", fas_arqs_failure)) 166 _NOTE(SCHEME_PROTECTS_DATA("just test variables", fas_tran_err)) 167 _NOTE(MUTEX_PROTECTS_DATA(fas_log_mutex, fas_log_buf)) 168 _NOTE(MUTEX_PROTECTS_DATA(fas_global_mutex, fas_reset_watch)) 169 _NOTE(DATA_READABLE_WITHOUT_LOCK(fas_state fas_head fas_tail \ 170 fas_scsi_watchdog_tick fas_tick)) 171 172 /* 173 * function prototypes 174 * 175 * scsa functions are exported by means of the transport table: 176 */ 177 static int fas_scsi_tgt_probe(struct scsi_device *sd, 178 int (*waitfunc)(void)); 179 static int fas_scsi_tgt_init(dev_info_t *, dev_info_t *, 180 scsi_hba_tran_t *, struct scsi_device *); 181 static int fas_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt); 182 static int fas_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt); 183 static int fas_scsi_reset(struct scsi_address *ap, int level); 184 static int fas_scsi_getcap(struct scsi_address *ap, char *cap, int whom); 185 static int fas_scsi_setcap(struct scsi_address *ap, char *cap, int value, 186 int whom); 187 static struct scsi_pkt *fas_scsi_init_pkt(struct scsi_address *ap, 188 struct scsi_pkt *pkt, struct buf *bp, int cmdlen, int statuslen, 189 int tgtlen, int flags, int (*callback)(), caddr_t arg); 190 static void fas_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt); 191 static void fas_scsi_dmafree(struct scsi_address *ap, 192 struct scsi_pkt *pkt); 193 static void fas_scsi_sync_pkt(struct scsi_address *ap, 194 struct scsi_pkt *pkt); 195 196 /* 197 * internal functions: 198 */ 199 static int fas_prepare_pkt(struct fas *fas, struct fas_cmd *sp); 200 static int fas_alloc_tag(struct fas *fas, struct fas_cmd *sp); 201 static int fas_accept_pkt(struct fas *fas, struct fas_cmd *sp, int flag); 202 static void fas_empty_waitQ(struct fas *fas); 203 static void fas_move_waitQ_to_readyQ(struct fas *fas); 204 static void fas_check_waitQ_and_mutex_exit(struct fas *fas); 205 static int fas_istart(struct fas *fas); 206 static int fas_ustart(struct fas *fas); 207 static int fas_startcmd(struct fas *fas, struct fas_cmd *sp); 208 209 static int fas_pkt_alloc_extern(struct fas *fas, struct fas_cmd *sp, 210 int cmdlen, int tgtlen, int statuslen, int kf); 211 static void fas_pkt_destroy_extern(struct fas *fas, struct fas_cmd *sp); 212 static int fas_kmem_cache_constructor(void *buf, void *cdrarg, int kmflags); 213 static void fas_kmem_cache_destructor(void *buf, void *cdrarg); 214 215 static int fas_finish(struct fas *fas); 216 static void fas_handle_qfull(struct fas *fas, struct fas_cmd *sp); 217 static void fas_restart_cmd(void *); 218 static int fas_dopoll(struct fas *fas, int timeout); 219 static void fas_runpoll(struct fas *fas, short slot, struct fas_cmd *sp); 220 static uint_t fas_intr(caddr_t arg); 221 static int fas_intr_svc(struct fas *fas); 222 static int fas_phasemanage(struct fas *fas); 223 static int fas_handle_unknown(struct fas *fas); 224 static int fas_handle_cmd_start(struct fas *fas); 225 static int fas_handle_cmd_done(struct fas *fas); 226 static int fas_handle_msg_out_start(struct fas *fas); 227 static int fas_handle_msg_out_done(struct fas *fas); 228 static int fas_handle_clearing(struct fas *fas); 229 static int fas_handle_data_start(struct fas *fas); 230 static int fas_handle_data_done(struct fas *fas); 231 static int fas_handle_c_cmplt(struct fas *fas); 232 static int fas_handle_msg_in_start(struct fas *fas); 233 static int fas_handle_more_msgin(struct fas *fas); 234 static int fas_handle_msg_in_done(struct fas *fas); 235 static int fas_onebyte_msg(struct fas *fas); 236 static int fas_twobyte_msg(struct fas *fas); 237 static int fas_multibyte_msg(struct fas *fas); 238 static void fas_revert_to_async(struct fas *fas, int tgt); 239 static int fas_finish_select(struct fas *fas); 240 static int fas_reselect_preempt(struct fas *fas); 241 static int fas_reconnect(struct fas *fas); 242 static int fas_handle_selection(struct fas *fas); 243 static void fas_head_of_readyQ(struct fas *fas, struct fas_cmd *sp); 244 static int fas_handle_gross_err(struct fas *fas); 245 static int fas_illegal_cmd_or_bus_reset(struct fas *fas); 246 static int fas_check_dma_error(struct fas *fas); 247 248 static void fas_make_sdtr(struct fas *fas, int msgout_offset, int target); 249 static void fas_make_wdtr(struct fas *fas, int msgout_offset, int target, 250 int width); 251 static void fas_update_props(struct fas *fas, int tgt); 252 static void fas_update_this_prop(struct fas *fas, char *property, int value); 253 254 static int fas_commoncap(struct scsi_address *ap, char *cap, int val, 255 int tgtonly, int doset); 256 257 static void fas_watch(void *arg); 258 static void fas_watchsubr(struct fas *fas); 259 static void fas_cmd_timeout(struct fas *fas, int slot); 260 static void fas_sync_wide_backoff(struct fas *fas, struct fas_cmd *sp, 261 int slot); 262 static void fas_reset_sync_wide(struct fas *fas); 263 static void fas_set_wide_conf3(struct fas *fas, int target, int width); 264 static void fas_force_renegotiation(struct fas *fas, int target); 265 266 static int fas_set_new_window(struct fas *fas, struct fas_cmd *sp); 267 static int fas_restore_pointers(struct fas *fas, struct fas_cmd *sp); 268 static int fas_next_window(struct fas *fas, struct fas_cmd *sp, uint64_t end); 269 270 /*PRINTFLIKE3*/ 271 static void fas_log(struct fas *fas, int level, const char *fmt, ...); 272 /*PRINTFLIKE2*/ 273 static void fas_printf(struct fas *fas, const char *fmt, ...); 274 static void fas_printstate(struct fas *fas, char *msg); 275 static void fas_dump_cmd(struct fas *fas, struct fas_cmd *sp); 276 static void fas_short_dump_cmd(struct fas *fas, struct fas_cmd *sp); 277 static char *fas_state_name(ushort_t state); 278 279 static void fas_makeproxy_cmd(struct fas_cmd *sp, 280 struct scsi_address *ap, struct scsi_pkt *pkt, int nmsg, ...); 281 static int fas_do_proxy_cmd(struct fas *fas, struct fas_cmd *sp, 282 struct scsi_address *ap, char *what); 283 284 static void fas_internal_reset(struct fas *fas, int reset_action); 285 static int fas_alloc_active_slots(struct fas *fas, int slot, int flag); 286 287 static int fas_abort_curcmd(struct fas *fas); 288 static int fas_abort_cmd(struct fas *fas, struct fas_cmd *sp, int slot); 289 static int fas_do_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt); 290 static int fas_do_scsi_reset(struct scsi_address *ap, int level); 291 static int fas_remove_from_readyQ(struct fas *fas, struct fas_cmd *sp, 292 int slot); 293 static void fas_flush_readyQ(struct fas *fas, int slot); 294 static void fas_flush_tagQ(struct fas *fas, int slot); 295 static void fas_flush_cmd(struct fas *fas, struct fas_cmd *sp, 296 uchar_t reason, uint_t stat); 297 static int fas_abort_connected_cmd(struct fas *fas, struct fas_cmd *sp, 298 uchar_t msg); 299 static int fas_abort_disconnected_cmd(struct fas *fas, struct scsi_address *ap, 300 struct fas_cmd *sp, uchar_t msg, int slot); 301 static void fas_mark_packets(struct fas *fas, int slot, uchar_t reason, 302 uint_t stat); 303 static void fas_set_pkt_reason(struct fas *fas, struct fas_cmd *sp, 304 uchar_t reason, uint_t stat); 305 306 static int fas_reset_bus(struct fas *fas); 307 static int fas_reset_recovery(struct fas *fas); 308 static int fas_reset_connected_cmd(struct fas *fas, struct scsi_address *ap); 309 static int fas_reset_disconnected_cmd(struct fas *fas, struct scsi_address *ap); 310 static void fas_start_watch_reset_delay(struct fas *); 311 static void fas_setup_reset_delay(struct fas *fas); 312 static void fas_watch_reset_delay(void *arg); 313 static int fas_watch_reset_delay_subr(struct fas *fas); 314 static void fas_reset_cleanup(struct fas *fas, int slot); 315 static int fas_scsi_reset_notify(struct scsi_address *ap, int flag, 316 void (*callback)(caddr_t), caddr_t arg); 317 static int fas_scsi_quiesce(dev_info_t *hba_dip); 318 static int fas_scsi_unquiesce(dev_info_t *hba_dip); 319 320 static void fas_set_throttles(struct fas *fas, int slot, 321 int n, int what); 322 static void fas_set_all_lun_throttles(struct fas *fas, int slot, int what); 323 static void fas_full_throttle(struct fas *fas, int slot); 324 static void fas_remove_cmd(struct fas *fas, struct fas_cmd *sp, int timeout); 325 static void fas_decrement_ncmds(struct fas *fas, struct fas_cmd *sp); 326 327 static int fas_quiesce_bus(struct fas *fas); 328 static int fas_unquiesce_bus(struct fas *fas); 329 static void fas_ncmds_checkdrain(void *arg); 330 static int fas_check_outstanding(struct fas *fas); 331 332 static int fas_create_arq_pkt(struct fas *fas, struct scsi_address *ap); 333 static int fas_delete_arq_pkt(struct fas *fas, struct scsi_address *ap); 334 static int fas_handle_sts_chk(struct fas *fas, struct fas_cmd *sp); 335 void fas_complete_arq_pkt(struct scsi_pkt *pkt); 336 337 void fas_call_pkt_comp(struct fas *fas, struct fas_cmd *sp); 338 void fas_empty_callbackQ(struct fas *fas); 339 int fas_init_callbacks(struct fas *fas); 340 void fas_destroy_callbacks(struct fas *fas); 341 342 static int fas_check_dma_error(struct fas *fas); 343 static int fas_init_chip(struct fas *fas, uchar_t id); 344 345 static void fas_read_fifo(struct fas *fas); 346 static void fas_write_fifo(struct fas *fas, uchar_t *buf, int length, int pad); 347 348 #ifdef FASDEBUG 349 static void fas_reg_cmd_write(struct fas *fas, uint8_t cmd); 350 static void fas_reg_write(struct fas *fas, volatile uint8_t *p, uint8_t what); 351 static uint8_t fas_reg_read(struct fas *fas, volatile uint8_t *p); 352 353 static void fas_dma_reg_write(struct fas *fas, volatile uint32_t *p, 354 uint32_t what); 355 static uint32_t fas_dma_reg_read(struct fas *fas, volatile uint32_t *p); 356 #else 357 #define fas_reg_cmd_write(fas, cmd) \ 358 fas->f_reg->fas_cmd = (cmd), fas->f_last_cmd = (cmd) 359 #define fas_reg_write(fas, p, what) *(p) = (what) 360 #define fas_reg_read(fas, p) *(p) 361 #define fas_dma_reg_write(fas, p, what) *(p) = (what) 362 #define fas_dma_reg_read(fas, p) *(p) 363 #endif 364 365 /* 366 * autoconfiguration data and routines. 367 */ 368 static int fas_attach(dev_info_t *dev, ddi_attach_cmd_t cmd); 369 static int fas_detach(dev_info_t *dev, ddi_detach_cmd_t cmd); 370 static int fas_dr_detach(dev_info_t *dev); 371 372 static struct dev_ops fas_ops = { 373 DEVO_REV, /* devo_rev, */ 374 0, /* refcnt */ 375 ddi_no_info, /* info */ 376 nulldev, /* identify */ 377 nulldev, /* probe */ 378 fas_attach, /* attach */ 379 fas_detach, /* detach */ 380 nodev, /* reset */ 381 NULL, /* driver operations */ 382 NULL, /* bus operations */ 383 NULL /* power */ 384 }; 385 386 char _depends_on[] = "misc/scsi"; 387 388 static struct modldrv modldrv = { 389 &mod_driverops, /* Type of module. This one is a driver */ 390 "FAS SCSI HBA Driver v%I%", /* Name of the module. */ 391 &fas_ops, /* driver ops */ 392 }; 393 394 static struct modlinkage modlinkage = { 395 MODREV_1, (void *)&modldrv, NULL 396 }; 397 398 int 399 _init(void) 400 { 401 int rval; 402 /* CONSTCOND */ 403 ASSERT(NO_COMPETING_THREADS); 404 405 rval = ddi_soft_state_init(&fas_state, sizeof (struct fas), 406 FAS_INITIAL_SOFT_SPACE); 407 if (rval != 0) { 408 return (rval); 409 } 410 411 if ((rval = scsi_hba_init(&modlinkage)) != 0) { 412 ddi_soft_state_fini(&fas_state); 413 return (rval); 414 } 415 416 mutex_init(&fas_global_mutex, NULL, MUTEX_DRIVER, NULL); 417 rw_init(&fas_global_rwlock, NULL, RW_DRIVER, NULL); 418 419 mutex_init(&fas_log_mutex, NULL, MUTEX_DRIVER, NULL); 420 421 if ((rval = mod_install(&modlinkage)) != 0) { 422 mutex_destroy(&fas_log_mutex); 423 rw_destroy(&fas_global_rwlock); 424 mutex_destroy(&fas_global_mutex); 425 ddi_soft_state_fini(&fas_state); 426 scsi_hba_fini(&modlinkage); 427 return (rval); 428 } 429 430 return (rval); 431 } 432 433 int 434 _fini(void) 435 { 436 int rval; 437 /* CONSTCOND */ 438 ASSERT(NO_COMPETING_THREADS); 439 440 if ((rval = mod_remove(&modlinkage)) == 0) { 441 ddi_soft_state_fini(&fas_state); 442 scsi_hba_fini(&modlinkage); 443 mutex_destroy(&fas_log_mutex); 444 rw_destroy(&fas_global_rwlock); 445 mutex_destroy(&fas_global_mutex); 446 } 447 return (rval); 448 } 449 450 int 451 _info(struct modinfo *modinfop) 452 { 453 /* CONSTCOND */ 454 ASSERT(NO_COMPETING_THREADS); 455 456 return (mod_info(&modlinkage, modinfop)); 457 } 458 459 static int 460 fas_scsi_tgt_probe(struct scsi_device *sd, 461 int (*waitfunc)(void)) 462 { 463 dev_info_t *dip = ddi_get_parent(sd->sd_dev); 464 int rval = SCSIPROBE_FAILURE; 465 scsi_hba_tran_t *tran; 466 struct fas *fas; 467 int tgt = sd->sd_address.a_target; 468 469 tran = ddi_get_driver_private(dip); 470 ASSERT(tran != NULL); 471 fas = TRAN2FAS(tran); 472 473 /* 474 * force renegotiation since inquiry cmds do not cause 475 * check conditions 476 */ 477 mutex_enter(FAS_MUTEX(fas)); 478 fas_force_renegotiation(fas, tgt); 479 mutex_exit(FAS_MUTEX(fas)); 480 rval = scsi_hba_probe(sd, waitfunc); 481 482 /* 483 * the scsi-options precedence is: 484 * target-scsi-options highest 485 * device-type-scsi-options 486 * per bus scsi-options 487 * global scsi-options lowest 488 */ 489 mutex_enter(FAS_MUTEX(fas)); 490 if ((rval == SCSIPROBE_EXISTS) && 491 ((fas->f_target_scsi_options_defined & (1 << tgt)) == 0)) { 492 int options; 493 494 options = scsi_get_device_type_scsi_options(dip, sd, -1); 495 if (options != -1) { 496 fas->f_target_scsi_options[tgt] = options; 497 fas_log(fas, CE_NOTE, 498 "?target%x-scsi-options = 0x%x\n", tgt, 499 fas->f_target_scsi_options[tgt]); 500 fas_force_renegotiation(fas, tgt); 501 } 502 } 503 mutex_exit(FAS_MUTEX(fas)); 504 505 IPRINTF2("target%x-scsi-options= 0x%x\n", 506 tgt, fas->f_target_scsi_options[tgt]); 507 508 return (rval); 509 } 510 511 512 /*ARGSUSED*/ 513 static int 514 fas_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 515 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 516 { 517 return (((sd->sd_address.a_target < NTARGETS_WIDE) && 518 (sd->sd_address.a_lun < NLUNS_PER_TARGET)) ? 519 DDI_SUCCESS : DDI_FAILURE); 520 } 521 522 /*ARGSUSED*/ 523 static int 524 fas_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 525 { 526 struct fas *fas = NULL; 527 volatile struct dma *dmar = NULL; 528 volatile struct fasreg *fasreg; 529 ddi_dma_attr_t *fas_dma_attr; 530 ddi_device_acc_attr_t dev_attr; 531 532 int instance, id, slot, i, hm_rev; 533 size_t rlen; 534 uint_t count; 535 char buf[64]; 536 scsi_hba_tran_t *tran = NULL; 537 char intr_added = 0; 538 char mutex_init_done = 0; 539 char hba_attached = 0; 540 char bound_handle = 0; 541 char *prop_template = "target%d-scsi-options"; 542 char prop_str[32]; 543 544 /* CONSTCOND */ 545 ASSERT(NO_COMPETING_THREADS); 546 547 switch (cmd) { 548 case DDI_ATTACH: 549 break; 550 551 case DDI_RESUME: 552 if ((tran = ddi_get_driver_private(dip)) == NULL) 553 return (DDI_FAILURE); 554 555 fas = TRAN2FAS(tran); 556 if (!fas) { 557 return (DDI_FAILURE); 558 } 559 /* 560 * Reset hardware and softc to "no outstanding commands" 561 * Note that a check condition can result on first command 562 * to a target. 563 */ 564 mutex_enter(FAS_MUTEX(fas)); 565 fas_internal_reset(fas, 566 FAS_RESET_SOFTC|FAS_RESET_FAS|FAS_RESET_DMA); 567 568 (void) fas_reset_bus(fas); 569 570 fas->f_suspended = 0; 571 572 /* make sure that things get started */ 573 (void) fas_istart(fas); 574 fas_check_waitQ_and_mutex_exit(fas); 575 576 mutex_enter(&fas_global_mutex); 577 if (fas_timeout_id == 0) { 578 fas_timeout_id = timeout(fas_watch, NULL, fas_tick); 579 fas_timeout_initted = 1; 580 } 581 mutex_exit(&fas_global_mutex); 582 583 return (DDI_SUCCESS); 584 585 default: 586 return (DDI_FAILURE); 587 } 588 589 instance = ddi_get_instance(dip); 590 591 /* 592 * Since we know that some instantiations of this device can 593 * be plugged into slave-only SBus slots, check to see whether 594 * this is one such. 595 */ 596 if (ddi_slaveonly(dip) == DDI_SUCCESS) { 597 cmn_err(CE_WARN, 598 "fas%d: device in slave-only slot", instance); 599 return (DDI_FAILURE); 600 } 601 602 if (ddi_intr_hilevel(dip, 0)) { 603 /* 604 * Interrupt number '0' is a high-level interrupt. 605 * At this point you either add a special interrupt 606 * handler that triggers a soft interrupt at a lower level, 607 * or - more simply and appropriately here - you just 608 * fail the attach. 609 */ 610 cmn_err(CE_WARN, 611 "fas%d: Device is using a hilevel intr", instance); 612 return (DDI_FAILURE); 613 } 614 615 /* 616 * Allocate softc information. 617 */ 618 if (ddi_soft_state_zalloc(fas_state, instance) != DDI_SUCCESS) { 619 cmn_err(CE_WARN, 620 "fas%d: cannot allocate soft state", instance); 621 goto fail; 622 } 623 624 fas = (struct fas *)ddi_get_soft_state(fas_state, instance); 625 626 if (fas == NULL) { 627 goto fail; 628 } 629 630 /* 631 * map in device registers 632 */ 633 dev_attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 634 dev_attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC; 635 dev_attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 636 637 if (ddi_regs_map_setup(dip, (uint_t)0, (caddr_t *)&dmar, 638 (off_t)0, (off_t)sizeof (struct dma), 639 &dev_attr, &fas->f_dmar_acc_handle) != DDI_SUCCESS) { 640 cmn_err(CE_WARN, "fas%d: cannot map dma", instance); 641 goto fail; 642 } 643 644 if (ddi_regs_map_setup(dip, (uint_t)1, (caddr_t *)&fasreg, 645 (off_t)0, (off_t)sizeof (struct fasreg), 646 &dev_attr, &fas->f_regs_acc_handle) != DDI_SUCCESS) { 647 cmn_err(CE_WARN, 648 "fas%d: unable to map fas366 registers", instance); 649 goto fail; 650 } 651 652 fas_dma_attr = &dma_fasattr; 653 if (ddi_dma_alloc_handle(dip, fas_dma_attr, 654 DDI_DMA_SLEEP, NULL, &fas->f_dmahandle) != DDI_SUCCESS) { 655 cmn_err(CE_WARN, 656 "fas%d: cannot alloc dma handle", instance); 657 goto fail; 658 } 659 660 /* 661 * allocate cmdarea and its dma handle 662 */ 663 if (ddi_dma_mem_alloc(fas->f_dmahandle, 664 (uint_t)2*FIFOSIZE, 665 &dev_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, 666 NULL, (caddr_t *)&fas->f_cmdarea, &rlen, 667 &fas->f_cmdarea_acc_handle) != DDI_SUCCESS) { 668 cmn_err(CE_WARN, 669 "fas%d: cannot alloc cmd area", instance); 670 goto fail; 671 } 672 673 fas->f_reg = fasreg; 674 fas->f_dma = dmar; 675 fas->f_instance = instance; 676 677 if (ddi_dma_addr_bind_handle(fas->f_dmahandle, 678 NULL, (caddr_t)fas->f_cmdarea, 679 rlen, DDI_DMA_RDWR|DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, 680 &fas->f_dmacookie, &count) != DDI_DMA_MAPPED) { 681 cmn_err(CE_WARN, 682 "fas%d: cannot bind cmdarea", instance); 683 goto fail; 684 } 685 bound_handle++; 686 687 ASSERT(count == 1); 688 689 /* 690 * Allocate a transport structure 691 */ 692 tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 693 694 /* 695 * initialize transport structure 696 */ 697 fas->f_tran = tran; 698 fas->f_dev = dip; 699 tran->tran_hba_private = fas; 700 tran->tran_tgt_private = NULL; 701 tran->tran_tgt_init = fas_scsi_tgt_init; 702 tran->tran_tgt_probe = fas_scsi_tgt_probe; 703 tran->tran_tgt_free = NULL; 704 tran->tran_start = fas_scsi_start; 705 tran->tran_abort = fas_scsi_abort; 706 tran->tran_reset = fas_scsi_reset; 707 tran->tran_getcap = fas_scsi_getcap; 708 tran->tran_setcap = fas_scsi_setcap; 709 tran->tran_init_pkt = fas_scsi_init_pkt; 710 tran->tran_destroy_pkt = fas_scsi_destroy_pkt; 711 tran->tran_dmafree = fas_scsi_dmafree; 712 tran->tran_sync_pkt = fas_scsi_sync_pkt; 713 tran->tran_reset_notify = fas_scsi_reset_notify; 714 tran->tran_get_bus_addr = NULL; 715 tran->tran_get_name = NULL; 716 tran->tran_quiesce = fas_scsi_quiesce; 717 tran->tran_unquiesce = fas_scsi_unquiesce; 718 tran->tran_bus_reset = NULL; 719 tran->tran_add_eventcall = NULL; 720 tran->tran_get_eventcookie = NULL; 721 tran->tran_post_event = NULL; 722 tran->tran_remove_eventcall = NULL; 723 724 fas->f_force_async = 0; 725 726 /* 727 * disable tagged queuing and wide for all targets 728 * (will be enabled by target driver if required) 729 * sync is enabled by default 730 */ 731 fas->f_nowide = fas->f_notag = ALL_TARGETS; 732 fas->f_force_narrow = ALL_TARGETS; 733 734 /* 735 * By default we assume embedded devices and save time 736 * checking for timeouts in fas_watch() by skipping 737 * the rest of luns 738 * If we're talking to any non-embedded devices, 739 * we can't cheat and skip over non-zero luns anymore 740 * in fas_watch() and fas_ustart(). 741 */ 742 fas->f_dslot = NLUNS_PER_TARGET; 743 744 /* 745 * f_active is used for saving disconnected cmds; 746 * For tagged targets, we need to increase the size later 747 * Only allocate for Lun == 0, if we probe a lun > 0 then 748 * we allocate an active structure 749 * If TQ gets enabled then we need to increase the size 750 * to hold 256 cmds 751 */ 752 for (slot = 0; slot < N_SLOTS; slot += NLUNS_PER_TARGET) { 753 (void) fas_alloc_active_slots(fas, slot, KM_SLEEP); 754 } 755 756 /* 757 * initialize the qfull retry counts 758 */ 759 for (i = 0; i < NTARGETS_WIDE; i++) { 760 fas->f_qfull_retries[i] = QFULL_RETRIES; 761 fas->f_qfull_retry_interval[i] = 762 drv_usectohz(QFULL_RETRY_INTERVAL * 1000); 763 764 } 765 766 /* 767 * Initialize throttles. 768 */ 769 fas_set_throttles(fas, 0, N_SLOTS, MAX_THROTTLE); 770 771 /* 772 * Initialize mask of deferred property updates 773 */ 774 fas->f_props_update = 0; 775 776 /* 777 * set host ID 778 */ 779 fas->f_fasconf = DEFAULT_HOSTID; 780 id = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0, "initiator-id", -1); 781 if (id == -1) { 782 id = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0, 783 "scsi-initiator-id", -1); 784 } 785 if (id != DEFAULT_HOSTID && id >= 0 && id < NTARGETS_WIDE) { 786 fas_log(fas, CE_NOTE, "?initiator SCSI ID now %d\n", id); 787 fas->f_fasconf = (uchar_t)id; 788 } 789 790 /* 791 * find the burstsize and reduce ours if necessary 792 */ 793 fas->f_dma_attr = fas_dma_attr; 794 fas->f_dma_attr->dma_attr_burstsizes &= 795 ddi_dma_burstsizes(fas->f_dmahandle); 796 797 #ifdef FASDEBUG 798 fas->f_dma_attr->dma_attr_burstsizes &= fas_burstsizes_limit; 799 IPRINTF1("dma burstsize=%x\n", fas->f_dma_attr->dma_attr_burstsizes); 800 #endif 801 /* 802 * Attach this instance of the hba 803 */ 804 if (scsi_hba_attach_setup(dip, fas->f_dma_attr, tran, 0) != 805 DDI_SUCCESS) { 806 fas_log(fas, CE_WARN, "scsi_hba_attach_setup failed"); 807 goto fail; 808 } 809 hba_attached++; 810 811 /* 812 * if scsi-options property exists, use it 813 */ 814 fas->f_scsi_options = ddi_prop_get_int(DDI_DEV_T_ANY, 815 dip, 0, "scsi-options", DEFAULT_SCSI_OPTIONS); 816 817 /* 818 * if scsi-selection-timeout property exists, use it 819 */ 820 fas_selection_timeout = ddi_prop_get_int(DDI_DEV_T_ANY, 821 dip, 0, "scsi-selection-timeout", SCSI_DEFAULT_SELECTION_TIMEOUT); 822 823 /* 824 * if hm-rev property doesn't exist, use old scheme for rev 825 */ 826 hm_rev = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0, 827 "hm-rev", -1); 828 829 if (hm_rev == 0xa0 || hm_rev == -1) { 830 if (DMAREV(dmar) != 0) { 831 fas->f_hm_rev = 0x20; 832 fas_log(fas, CE_WARN, 833 "obsolete rev 2.0 FEPS chip, " 834 "possible data corruption"); 835 } else { 836 fas->f_hm_rev = 0x10; 837 fas_log(fas, CE_WARN, 838 "obsolete and unsupported rev 1.0 FEPS chip"); 839 goto fail; 840 } 841 } else if (hm_rev == 0x20) { 842 fas->f_hm_rev = 0x21; 843 fas_log(fas, CE_WARN, "obsolete rev 2.1 FEPS chip"); 844 } else { 845 fas->f_hm_rev = (uchar_t)hm_rev; 846 fas_log(fas, CE_NOTE, "?rev %x.%x FEPS chip\n", 847 (hm_rev >> 4) & 0xf, hm_rev & 0xf); 848 } 849 850 if ((fas->f_scsi_options & SCSI_OPTIONS_SYNC) == 0) { 851 fas->f_nosync = ALL_TARGETS; 852 } 853 854 if ((fas->f_scsi_options & SCSI_OPTIONS_WIDE) == 0) { 855 fas->f_nowide = ALL_TARGETS; 856 } 857 858 /* 859 * if target<n>-scsi-options property exists, use it; 860 * otherwise use the f_scsi_options 861 */ 862 for (i = 0; i < NTARGETS_WIDE; i++) { 863 (void) sprintf(prop_str, prop_template, i); 864 fas->f_target_scsi_options[i] = ddi_prop_get_int( 865 DDI_DEV_T_ANY, dip, 0, prop_str, -1); 866 867 if (fas->f_target_scsi_options[i] != -1) { 868 fas_log(fas, CE_NOTE, "?target%x-scsi-options=0x%x\n", 869 i, fas->f_target_scsi_options[i]); 870 fas->f_target_scsi_options_defined |= 1 << i; 871 } else { 872 fas->f_target_scsi_options[i] = fas->f_scsi_options; 873 } 874 if (((fas->f_target_scsi_options[i] & 875 SCSI_OPTIONS_DR) == 0) && 876 (fas->f_target_scsi_options[i] & SCSI_OPTIONS_TAG)) { 877 fas->f_target_scsi_options[i] &= ~SCSI_OPTIONS_TAG; 878 fas_log(fas, CE_WARN, 879 "Disabled TQ since disconnects are disabled"); 880 } 881 } 882 883 fas->f_scsi_tag_age_limit = 884 ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0, "scsi-tag-age-limit", 885 DEFAULT_TAG_AGE_LIMIT); 886 887 fas->f_scsi_reset_delay = ddi_prop_get_int(DDI_DEV_T_ANY, 888 dip, 0, "scsi-reset-delay", SCSI_DEFAULT_RESET_DELAY); 889 if (fas->f_scsi_reset_delay == 0) { 890 fas_log(fas, CE_NOTE, 891 "scsi_reset_delay of 0 is not recommended," 892 " resetting to SCSI_DEFAULT_RESET_DELAY\n"); 893 fas->f_scsi_reset_delay = SCSI_DEFAULT_RESET_DELAY; 894 } 895 896 /* 897 * get iblock cookie and initialize mutexes 898 */ 899 if (ddi_get_iblock_cookie(dip, (uint_t)0, &fas->f_iblock) 900 != DDI_SUCCESS) { 901 cmn_err(CE_WARN, "fas_attach: cannot get iblock cookie"); 902 goto fail; 903 } 904 905 mutex_init(&fas->f_mutex, NULL, MUTEX_DRIVER, fas->f_iblock); 906 cv_init(&fas->f_cv, NULL, CV_DRIVER, NULL); 907 908 /* 909 * initialize mutex for waitQ 910 */ 911 mutex_init(&fas->f_waitQ_mutex, NULL, MUTEX_DRIVER, fas->f_iblock); 912 mutex_init_done++; 913 914 /* 915 * initialize callback mechanism (immediate callback) 916 */ 917 mutex_enter(&fas_global_mutex); 918 if (fas_init_callbacks(fas)) { 919 mutex_exit(&fas_global_mutex); 920 goto fail; 921 } 922 mutex_exit(&fas_global_mutex); 923 924 /* 925 * kstat_intr support 926 */ 927 (void) sprintf(buf, "fas%d", instance); 928 fas->f_intr_kstat = kstat_create("fas", instance, buf, "controller", \ 929 KSTAT_TYPE_INTR, 1, KSTAT_FLAG_PERSISTENT); 930 if (fas->f_intr_kstat) 931 kstat_install(fas->f_intr_kstat); 932 933 /* 934 * install interrupt handler 935 */ 936 mutex_enter(FAS_MUTEX(fas)); 937 if (ddi_add_intr(dip, (uint_t)0, &fas->f_iblock, NULL, 938 fas_intr, (caddr_t)fas)) { 939 cmn_err(CE_WARN, "fas: cannot add intr"); 940 mutex_exit(FAS_MUTEX(fas)); 941 goto fail; 942 } 943 intr_added++; 944 945 /* 946 * initialize fas chip 947 */ 948 if (fas_init_chip(fas, id)) { 949 cmn_err(CE_WARN, "fas: cannot initialize"); 950 mutex_exit(FAS_MUTEX(fas)); 951 goto fail; 952 } 953 mutex_exit(FAS_MUTEX(fas)); 954 955 /* 956 * create kmem cache for packets 957 */ 958 (void) sprintf(buf, "fas%d_cache", instance); 959 fas->f_kmem_cache = kmem_cache_create(buf, 960 EXTCMD_SIZE, 8, 961 fas_kmem_cache_constructor, fas_kmem_cache_destructor, 962 NULL, (void *)fas, NULL, 0); 963 if (fas->f_kmem_cache == NULL) { 964 cmn_err(CE_WARN, "fas: cannot create kmem_cache"); 965 goto fail; 966 } 967 968 /* 969 * at this point, we are not going to fail the attach 970 * so there is no need to undo the rest: 971 * 972 * add this fas to the list, this makes debugging easier 973 * and fas_watch() needs it to walk thru all fas's 974 */ 975 rw_enter(&fas_global_rwlock, RW_WRITER); 976 if (fas_head == NULL) { 977 fas_head = fas; 978 } else { 979 fas_tail->f_next = fas; 980 } 981 fas_tail = fas; /* point to last fas in list */ 982 rw_exit(&fas_global_rwlock); 983 984 /* 985 * there is one watchdog handler for all driver instances. 986 * start the watchdog if it hasn't been done yet 987 */ 988 mutex_enter(&fas_global_mutex); 989 if (fas_scsi_watchdog_tick == 0) { 990 fas_scsi_watchdog_tick = ddi_prop_get_int(DDI_DEV_T_ANY, 991 dip, 0, "scsi-watchdog-tick", DEFAULT_WD_TICK); 992 if (fas_scsi_watchdog_tick != DEFAULT_WD_TICK) { 993 fas_log(fas, CE_NOTE, "?scsi-watchdog-tick=%d\n", 994 fas_scsi_watchdog_tick); 995 } 996 fas_tick = drv_usectohz((clock_t) 997 fas_scsi_watchdog_tick * 1000000); 998 IPRINTF2("fas scsi watchdog tick=%x, fas_tick=%lx\n", 999 fas_scsi_watchdog_tick, fas_tick); 1000 if (fas_timeout_id == 0) { 1001 fas_timeout_id = timeout(fas_watch, NULL, fas_tick); 1002 fas_timeout_initted = 1; 1003 } 1004 } 1005 mutex_exit(&fas_global_mutex); 1006 1007 ddi_report_dev(dip); 1008 1009 return (DDI_SUCCESS); 1010 1011 fail: 1012 cmn_err(CE_WARN, "fas%d: cannot attach", instance); 1013 if (fas) { 1014 for (slot = 0; slot < N_SLOTS; slot++) { 1015 struct f_slots *active = fas->f_active[slot]; 1016 if (active) { 1017 kmem_free(active, active->f_size); 1018 fas->f_active[slot] = NULL; 1019 } 1020 } 1021 if (mutex_init_done) { 1022 mutex_destroy(&fas->f_mutex); 1023 mutex_destroy(&fas->f_waitQ_mutex); 1024 cv_destroy(&fas->f_cv); 1025 } 1026 if (intr_added) { 1027 ddi_remove_intr(dip, (uint_t)0, fas->f_iblock); 1028 } 1029 /* 1030 * kstat_intr support 1031 */ 1032 if (fas->f_intr_kstat) { 1033 kstat_delete(fas->f_intr_kstat); 1034 } 1035 if (hba_attached) { 1036 (void) scsi_hba_detach(dip); 1037 } 1038 if (tran) { 1039 scsi_hba_tran_free(tran); 1040 } 1041 if (fas->f_kmem_cache) { 1042 kmem_cache_destroy(fas->f_kmem_cache); 1043 } 1044 if (fas->f_cmdarea) { 1045 if (bound_handle) { 1046 (void) ddi_dma_unbind_handle(fas->f_dmahandle); 1047 } 1048 ddi_dma_mem_free(&fas->f_cmdarea_acc_handle); 1049 } 1050 if (fas->f_dmahandle) { 1051 ddi_dma_free_handle(&fas->f_dmahandle); 1052 } 1053 fas_destroy_callbacks(fas); 1054 if (fas->f_regs_acc_handle) { 1055 ddi_regs_map_free(&fas->f_regs_acc_handle); 1056 } 1057 if (fas->f_dmar_acc_handle) { 1058 ddi_regs_map_free(&fas->f_dmar_acc_handle); 1059 } 1060 ddi_soft_state_free(fas_state, instance); 1061 1062 ddi_remove_minor_node(dip, NULL); 1063 } 1064 return (DDI_FAILURE); 1065 } 1066 1067 /*ARGSUSED*/ 1068 static int 1069 fas_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 1070 { 1071 struct fas *fas, *nfas; 1072 scsi_hba_tran_t *tran; 1073 1074 /* CONSTCOND */ 1075 ASSERT(NO_COMPETING_THREADS); 1076 1077 switch (cmd) { 1078 case DDI_DETACH: 1079 return (fas_dr_detach(dip)); 1080 1081 case DDI_SUSPEND: 1082 if ((tran = ddi_get_driver_private(dip)) == NULL) 1083 return (DDI_FAILURE); 1084 1085 fas = TRAN2FAS(tran); 1086 if (!fas) { 1087 return (DDI_FAILURE); 1088 } 1089 1090 mutex_enter(FAS_MUTEX(fas)); 1091 1092 fas->f_suspended = 1; 1093 1094 if (fas->f_ncmds) { 1095 (void) fas_reset_bus(fas); 1096 (void) fas_dopoll(fas, SHORT_POLL_TIMEOUT); 1097 } 1098 /* 1099 * disable dma and fas interrupt 1100 */ 1101 fas->f_dma_csr &= ~DMA_INTEN; 1102 fas->f_dma_csr &= ~DMA_ENDVMA; 1103 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, fas->f_dma_csr); 1104 1105 mutex_exit(FAS_MUTEX(fas)); 1106 1107 if (fas->f_quiesce_timeid) { 1108 (void) untimeout(fas->f_quiesce_timeid); 1109 fas->f_quiesce_timeid = 0; 1110 } 1111 1112 if (fas->f_restart_cmd_timeid) { 1113 (void) untimeout(fas->f_restart_cmd_timeid); 1114 fas->f_restart_cmd_timeid = 0; 1115 } 1116 1117 /* Last fas? */ 1118 rw_enter(&fas_global_rwlock, RW_WRITER); 1119 for (nfas = fas_head; nfas; nfas = nfas->f_next) { 1120 if (!nfas->f_suspended) { 1121 rw_exit(&fas_global_rwlock); 1122 return (DDI_SUCCESS); 1123 } 1124 } 1125 rw_exit(&fas_global_rwlock); 1126 1127 mutex_enter(&fas_global_mutex); 1128 if (fas_timeout_id != 0) { 1129 timeout_id_t tid = fas_timeout_id; 1130 fas_timeout_id = 0; 1131 fas_timeout_initted = 0; 1132 mutex_exit(&fas_global_mutex); 1133 (void) untimeout(tid); 1134 } else { 1135 mutex_exit(&fas_global_mutex); 1136 } 1137 1138 mutex_enter(&fas_global_mutex); 1139 if (fas_reset_watch) { 1140 timeout_id_t tid = fas_reset_watch; 1141 fas_reset_watch = 0; 1142 mutex_exit(&fas_global_mutex); 1143 (void) untimeout(tid); 1144 } else { 1145 mutex_exit(&fas_global_mutex); 1146 } 1147 1148 return (DDI_SUCCESS); 1149 1150 default: 1151 return (DDI_FAILURE); 1152 } 1153 _NOTE(NOT_REACHED) 1154 /* NOTREACHED */ 1155 } 1156 1157 static int 1158 fas_dr_detach(dev_info_t *dip) 1159 { 1160 struct fas *fas, *f; 1161 scsi_hba_tran_t *tran; 1162 short slot; 1163 int i, j; 1164 1165 if ((tran = ddi_get_driver_private(dip)) == NULL) 1166 return (DDI_FAILURE); 1167 1168 fas = TRAN2FAS(tran); 1169 if (!fas) { 1170 return (DDI_FAILURE); 1171 } 1172 1173 /* 1174 * disable interrupts 1175 */ 1176 fas->f_dma_csr &= ~DMA_INTEN; 1177 fas->f_dma->dma_csr = fas->f_dma_csr; 1178 ddi_remove_intr(dip, (uint_t)0, fas->f_iblock); 1179 1180 /* 1181 * Remove device instance from the global linked list 1182 */ 1183 rw_enter(&fas_global_rwlock, RW_WRITER); 1184 1185 if (fas_head == fas) { 1186 f = fas_head = fas->f_next; 1187 } else { 1188 for (f = fas_head; f != (struct fas *)NULL; f = f->f_next) { 1189 if (f->f_next == fas) { 1190 f->f_next = fas->f_next; 1191 break; 1192 } 1193 } 1194 1195 /* 1196 * Instance not in softc list. Since the 1197 * instance is not there in softc list, don't 1198 * enable interrupts, the instance is effectively 1199 * unusable. 1200 */ 1201 if (f == (struct fas *)NULL) { 1202 cmn_err(CE_WARN, "fas_dr_detach: fas instance not" 1203 " in softc list!"); 1204 rw_exit(&fas_global_rwlock); 1205 return (DDI_FAILURE); 1206 } 1207 1208 1209 } 1210 1211 if (fas_tail == fas) 1212 fas_tail = f; 1213 1214 rw_exit(&fas_global_rwlock); 1215 1216 if (fas->f_intr_kstat) 1217 kstat_delete(fas->f_intr_kstat); 1218 1219 fas_destroy_callbacks(fas); 1220 1221 scsi_hba_reset_notify_tear_down(fas->f_reset_notify_listf); 1222 1223 mutex_enter(&fas_global_mutex); 1224 /* 1225 * destroy any outstanding tagged command info 1226 */ 1227 for (slot = 0; slot < N_SLOTS; slot++) { 1228 struct f_slots *active = fas->f_active[slot]; 1229 if (active) { 1230 ushort_t tag; 1231 for (tag = 0; tag < active->f_n_slots; tag++) { 1232 struct fas_cmd *sp = active->f_slot[tag]; 1233 if (sp) { 1234 struct scsi_pkt *pkt = sp->cmd_pkt; 1235 if (pkt) { 1236 (void) fas_scsi_destroy_pkt( 1237 &pkt->pkt_address, pkt); 1238 } 1239 /* sp freed in fas_scsi_destroy_pkt */ 1240 active->f_slot[tag] = NULL; 1241 } 1242 } 1243 kmem_free(active, active->f_size); 1244 fas->f_active[slot] = NULL; 1245 } 1246 ASSERT(fas->f_tcmds[slot] == 0); 1247 } 1248 1249 /* 1250 * disallow timeout thread rescheduling 1251 */ 1252 fas->f_flags |= FAS_FLG_NOTIMEOUTS; 1253 mutex_exit(&fas_global_mutex); 1254 1255 if (fas->f_quiesce_timeid) { 1256 (void) untimeout(fas->f_quiesce_timeid); 1257 } 1258 1259 /* 1260 * last fas? ... if active, CANCEL watch threads. 1261 */ 1262 mutex_enter(&fas_global_mutex); 1263 if (fas_head == (struct fas *)NULL) { 1264 if (fas_timeout_initted) { 1265 timeout_id_t tid = fas_timeout_id; 1266 fas_timeout_initted = 0; 1267 fas_timeout_id = 0; /* don't resched */ 1268 mutex_exit(&fas_global_mutex); 1269 (void) untimeout(tid); 1270 mutex_enter(&fas_global_mutex); 1271 } 1272 1273 if (fas_reset_watch) { 1274 mutex_exit(&fas_global_mutex); 1275 (void) untimeout(fas_reset_watch); 1276 mutex_enter(&fas_global_mutex); 1277 fas_reset_watch = 0; 1278 } 1279 } 1280 mutex_exit(&fas_global_mutex); 1281 1282 if (fas->f_restart_cmd_timeid) { 1283 (void) untimeout(fas->f_restart_cmd_timeid); 1284 fas->f_restart_cmd_timeid = 0; 1285 } 1286 1287 /* 1288 * destroy outstanding ARQ pkts 1289 */ 1290 for (i = 0; i < NTARGETS_WIDE; i++) { 1291 for (j = 0; j < NLUNS_PER_TARGET; j++) { 1292 int slot = i * NLUNS_PER_TARGET | j; 1293 if (fas->f_arq_pkt[slot]) { 1294 struct scsi_address sa; 1295 sa.a_hba_tran = NULL; /* not used */ 1296 sa.a_target = (ushort_t)i; 1297 sa.a_lun = (uchar_t)j; 1298 (void) fas_delete_arq_pkt(fas, &sa); 1299 } 1300 } 1301 } 1302 1303 /* 1304 * Remove device MT locks and CV 1305 */ 1306 mutex_destroy(&fas->f_waitQ_mutex); 1307 mutex_destroy(&fas->f_mutex); 1308 cv_destroy(&fas->f_cv); 1309 1310 /* 1311 * Release miscellaneous device resources 1312 */ 1313 1314 if (fas->f_kmem_cache) { 1315 kmem_cache_destroy(fas->f_kmem_cache); 1316 } 1317 1318 if (fas->f_cmdarea != (uchar_t *)NULL) { 1319 (void) ddi_dma_unbind_handle(fas->f_dmahandle); 1320 ddi_dma_mem_free(&fas->f_cmdarea_acc_handle); 1321 } 1322 1323 if (fas->f_dmahandle != (ddi_dma_handle_t)NULL) { 1324 ddi_dma_free_handle(&fas->f_dmahandle); 1325 } 1326 1327 if (fas->f_regs_acc_handle) { 1328 ddi_regs_map_free(&fas->f_regs_acc_handle); 1329 } 1330 if (fas->f_dmar_acc_handle) { 1331 ddi_regs_map_free(&fas->f_dmar_acc_handle); 1332 } 1333 1334 /* 1335 * Remove properties created during attach() 1336 */ 1337 ddi_prop_remove_all(dip); 1338 1339 /* 1340 * Delete the DMA limits, transport vectors and remove the device 1341 * links to the scsi_transport layer. 1342 * -- ddi_set_driver_private(dip, NULL) 1343 */ 1344 (void) scsi_hba_detach(dip); 1345 1346 /* 1347 * Free the scsi_transport structure for this device. 1348 */ 1349 scsi_hba_tran_free(tran); 1350 1351 ddi_soft_state_free(fas_state, ddi_get_instance(dip)); 1352 1353 return (DDI_SUCCESS); 1354 } 1355 1356 static int 1357 fas_quiesce_bus(struct fas *fas) 1358 { 1359 mutex_enter(FAS_MUTEX(fas)); 1360 IPRINTF("fas_quiesce: QUIESCEing\n"); 1361 IPRINTF3("fas_quiesce: ncmds (%d) ndisc (%d) state (%d)\n", 1362 fas->f_ncmds, fas->f_ndisc, fas->f_softstate); 1363 fas_set_throttles(fas, 0, N_SLOTS, HOLD_THROTTLE); 1364 if (fas_check_outstanding(fas)) { 1365 fas->f_softstate |= FAS_SS_DRAINING; 1366 fas->f_quiesce_timeid = timeout(fas_ncmds_checkdrain, 1367 fas, (FAS_QUIESCE_TIMEOUT * drv_usectohz(1000000))); 1368 if (cv_wait_sig(FAS_CV(fas), FAS_MUTEX(fas)) == 0) { 1369 /* 1370 * quiesce has been interrupted. 1371 */ 1372 IPRINTF("fas_quiesce: abort QUIESCE\n"); 1373 fas->f_softstate &= ~FAS_SS_DRAINING; 1374 fas_set_throttles(fas, 0, N_SLOTS, MAX_THROTTLE); 1375 (void) fas_istart(fas); 1376 if (fas->f_quiesce_timeid != 0) { 1377 mutex_exit(FAS_MUTEX(fas)); 1378 #ifndef __lock_lint /* warlock complains but there is a NOTE on this */ 1379 (void) untimeout(fas->f_quiesce_timeid); 1380 fas->f_quiesce_timeid = 0; 1381 #endif 1382 return (-1); 1383 } 1384 mutex_exit(FAS_MUTEX(fas)); 1385 return (-1); 1386 } else { 1387 IPRINTF("fas_quiesce: bus is QUIESCED\n"); 1388 ASSERT(fas->f_quiesce_timeid == 0); 1389 fas->f_softstate &= ~FAS_SS_DRAINING; 1390 fas->f_softstate |= FAS_SS_QUIESCED; 1391 mutex_exit(FAS_MUTEX(fas)); 1392 return (0); 1393 } 1394 } 1395 IPRINTF("fas_quiesce: bus was not busy QUIESCED\n"); 1396 mutex_exit(FAS_MUTEX(fas)); 1397 return (0); 1398 } 1399 1400 static int 1401 fas_unquiesce_bus(struct fas *fas) 1402 { 1403 mutex_enter(FAS_MUTEX(fas)); 1404 fas->f_softstate &= ~FAS_SS_QUIESCED; 1405 fas_set_throttles(fas, 0, N_SLOTS, MAX_THROTTLE); 1406 (void) fas_istart(fas); 1407 IPRINTF("fas_quiesce: bus has been UNQUIESCED\n"); 1408 mutex_exit(FAS_MUTEX(fas)); 1409 1410 return (0); 1411 } 1412 1413 /* 1414 * invoked from timeout() to check the number of outstanding commands 1415 */ 1416 static void 1417 fas_ncmds_checkdrain(void *arg) 1418 { 1419 struct fas *fas = arg; 1420 1421 mutex_enter(FAS_MUTEX(fas)); 1422 IPRINTF3("fas_checkdrain: ncmds (%d) ndisc (%d) state (%d)\n", 1423 fas->f_ncmds, fas->f_ndisc, fas->f_softstate); 1424 if (fas->f_softstate & FAS_SS_DRAINING) { 1425 fas->f_quiesce_timeid = 0; 1426 if (fas_check_outstanding(fas) == 0) { 1427 IPRINTF("fas_drain: bus has drained\n"); 1428 cv_signal(FAS_CV(fas)); 1429 } else { 1430 /* 1431 * throttle may have been reset by a bus reset 1432 * or fas_runpoll() 1433 * XXX shouldn't be necessary 1434 */ 1435 fas_set_throttles(fas, 0, N_SLOTS, HOLD_THROTTLE); 1436 IPRINTF("fas_drain: rescheduling timeout\n"); 1437 fas->f_quiesce_timeid = timeout(fas_ncmds_checkdrain, 1438 fas, (FAS_QUIESCE_TIMEOUT * drv_usectohz(1000000))); 1439 } 1440 } 1441 mutex_exit(FAS_MUTEX(fas)); 1442 } 1443 1444 static int 1445 fas_check_outstanding(struct fas *fas) 1446 { 1447 uint_t slot; 1448 uint_t d = ((fas->f_dslot == 0)? 1 : fas->f_dslot); 1449 int ncmds = 0; 1450 1451 ASSERT(mutex_owned(FAS_MUTEX(fas))); 1452 1453 for (slot = 0; slot < N_SLOTS; slot += d) 1454 ncmds += fas->f_tcmds[slot]; 1455 1456 return (ncmds); 1457 } 1458 1459 1460 #ifdef FASDEBUG 1461 /* 1462 * fas register read/write functions with tracing 1463 */ 1464 static void 1465 fas_reg_tracing(struct fas *fas, int type, int regno, uint32_t what) 1466 { 1467 fas->f_reg_trace[fas->f_reg_trace_index++] = type; 1468 fas->f_reg_trace[fas->f_reg_trace_index++] = regno; 1469 fas->f_reg_trace[fas->f_reg_trace_index++] = what; 1470 fas->f_reg_trace[fas->f_reg_trace_index++] = gethrtime(); 1471 fas->f_reg_trace[fas->f_reg_trace_index] = 0xff; 1472 if (fas->f_reg_trace_index >= REG_TRACE_BUF_SIZE) { 1473 fas->f_reg_trace_index = 0; 1474 } 1475 } 1476 1477 static void 1478 fas_reg_cmd_write(struct fas *fas, uint8_t cmd) 1479 { 1480 volatile struct fasreg *fasreg = fas->f_reg; 1481 int regno = (uintptr_t)&fasreg->fas_cmd - (uintptr_t)fasreg; 1482 1483 fasreg->fas_cmd = cmd; 1484 fas->f_last_cmd = cmd; 1485 1486 EPRINTF1("issuing cmd %x\n", (uchar_t)cmd); 1487 fas_reg_tracing(fas, 0, regno, cmd); 1488 1489 fas->f_reg_cmds++; 1490 } 1491 1492 static void 1493 fas_reg_write(struct fas *fas, volatile uint8_t *p, uint8_t what) 1494 { 1495 int regno = (uintptr_t)p - (uintptr_t)fas->f_reg; 1496 1497 *p = what; 1498 1499 EPRINTF2("writing reg%x = %x\n", regno, what); 1500 fas_reg_tracing(fas, 1, regno, what); 1501 1502 fas->f_reg_writes++; 1503 } 1504 1505 static uint8_t 1506 fas_reg_read(struct fas *fas, volatile uint8_t *p) 1507 { 1508 uint8_t what; 1509 int regno = (uintptr_t)p - (uintptr_t)fas->f_reg; 1510 1511 what = *p; 1512 1513 EPRINTF2("reading reg%x => %x\n", regno, what); 1514 fas_reg_tracing(fas, 2, regno, what); 1515 1516 fas->f_reg_reads++; 1517 1518 return (what); 1519 } 1520 1521 /* 1522 * dma register access routines 1523 */ 1524 static void 1525 fas_dma_reg_write(struct fas *fas, volatile uint32_t *p, uint32_t what) 1526 { 1527 *p = what; 1528 fas->f_reg_dma_writes++; 1529 1530 #ifdef DMA_REG_TRACING 1531 { 1532 int regno = (uintptr_t)p - (uintptr_t)fas->f_dma; 1533 EPRINTF2("writing dma reg%x = %x\n", regno, what); 1534 fas_reg_tracing(fas, 3, regno, what); 1535 } 1536 #endif 1537 } 1538 1539 static uint32_t 1540 fas_dma_reg_read(struct fas *fas, volatile uint32_t *p) 1541 { 1542 uint32_t what = *p; 1543 fas->f_reg_dma_reads++; 1544 1545 #ifdef DMA_REG_TRACING 1546 { 1547 int regno = (uintptr_t)p - (uintptr_t)fas->f_dma; 1548 EPRINTF2("reading dma reg%x => %x\n", regno, what); 1549 fas_reg_tracing(fas, 4, regno, what); 1550 } 1551 #endif 1552 return (what); 1553 } 1554 #endif 1555 1556 #define FIFO_EMPTY(fas) (fas_reg_read(fas, &fas->f_reg->fas_stat2) & \ 1557 FAS_STAT2_EMPTY) 1558 #define FIFO_CNT(fas) \ 1559 (fas_reg_read(fas, &fas->f_reg->fas_fifo_flag) & FIFO_CNT_MASK) 1560 1561 #ifdef FASDEBUG 1562 static void 1563 fas_assert_atn(struct fas *fas) 1564 { 1565 fas_reg_cmd_write(fas, CMD_SET_ATN); 1566 #ifdef FAS_TEST 1567 if (fas_test_stop > 1) 1568 debug_enter("asserted atn"); 1569 #endif 1570 } 1571 #else 1572 #define fas_assert_atn(fas) fas_reg_cmd_write(fas, CMD_SET_ATN) 1573 #endif 1574 1575 /* 1576 * DMA macros; we use a shadow copy of the dma_csr to save unnecessary 1577 * reads 1578 */ 1579 #define FAS_DMA_WRITE(fas, count, base, cmd) { \ 1580 volatile struct fasreg *fasreg = fas->f_reg; \ 1581 volatile struct dma *dmar = fas->f_dma; \ 1582 ASSERT((fas_dma_reg_read(fas, &dmar->dma_csr) & DMA_ENDVMA) == 0); \ 1583 SET_FAS_COUNT(fasreg, count); \ 1584 fas_reg_cmd_write(fas, cmd); \ 1585 fas_dma_reg_write(fas, &dmar->dma_count, count); \ 1586 fas->f_dma_csr |= \ 1587 DMA_WRITE | DMA_ENDVMA | DMA_DSBL_DRAIN; \ 1588 fas_dma_reg_write(fas, &dmar->dma_addr, (fas->f_lastdma = base)); \ 1589 fas_dma_reg_write(fas, &dmar->dma_csr, fas->f_dma_csr); \ 1590 } 1591 1592 #define FAS_DMA_WRITE_SETUP(fas, count, base) { \ 1593 volatile struct fasreg *fasreg = fas->f_reg; \ 1594 volatile struct dma *dmar = fas->f_dma; \ 1595 ASSERT((fas_dma_reg_read(fas, &dmar->dma_csr) & DMA_ENDVMA) == 0); \ 1596 SET_FAS_COUNT(fasreg, count); \ 1597 fas_dma_reg_write(fas, &dmar->dma_count, count); \ 1598 fas->f_dma_csr |= \ 1599 DMA_WRITE | DMA_ENDVMA | DMA_DSBL_DRAIN; \ 1600 fas_dma_reg_write(fas, &dmar->dma_addr, (fas->f_lastdma = base)); \ 1601 } 1602 1603 1604 #define FAS_DMA_READ(fas, count, base, dmacount, cmd) { \ 1605 volatile struct fasreg *fasreg = fas->f_reg; \ 1606 volatile struct dma *dmar = fas->f_dma; \ 1607 ASSERT((fas_dma_reg_read(fas, &dmar->dma_csr) & DMA_ENDVMA) == 0); \ 1608 SET_FAS_COUNT(fasreg, count); \ 1609 fas_reg_cmd_write(fas, cmd); \ 1610 fas->f_dma_csr |= \ 1611 (fas->f_dma_csr & ~DMA_WRITE) | DMA_ENDVMA | DMA_DSBL_DRAIN; \ 1612 fas_dma_reg_write(fas, &dmar->dma_count, dmacount); \ 1613 fas_dma_reg_write(fas, &dmar->dma_addr, (fas->f_lastdma = base)); \ 1614 fas_dma_reg_write(fas, &dmar->dma_csr, fas->f_dma_csr); \ 1615 } 1616 1617 static void 1618 FAS_FLUSH_DMA(struct fas *fas) 1619 { 1620 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, DMA_RESET); 1621 fas->f_dma_csr |= (DMA_INTEN|DMA_TWO_CYCLE|DMA_DSBL_PARITY| 1622 DMA_DSBL_DRAIN); 1623 fas->f_dma_csr &= ~(DMA_ENDVMA | DMA_WRITE); 1624 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, 0); 1625 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, fas->f_dma_csr); 1626 fas_dma_reg_write(fas, &fas->f_dma->dma_addr, 0); 1627 } 1628 1629 /* 1630 * FAS_FLUSH_DMA_HARD checks on REQPEND before taking away the reset 1631 */ 1632 static void 1633 FAS_FLUSH_DMA_HARD(struct fas *fas) 1634 { 1635 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, DMA_RESET); 1636 fas->f_dma_csr |= (DMA_INTEN|DMA_TWO_CYCLE|DMA_DSBL_PARITY| 1637 DMA_DSBL_DRAIN); 1638 fas->f_dma_csr &= ~(DMA_ENDVMA | DMA_WRITE); 1639 while (fas_dma_reg_read(fas, &fas->f_dma->dma_csr) & DMA_REQPEND); 1640 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, 0); 1641 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, fas->f_dma_csr); 1642 fas_dma_reg_write(fas, &fas->f_dma->dma_addr, 0); 1643 } 1644 1645 /* 1646 * update period, conf3, offset reg, if necessary 1647 */ 1648 #define FAS_SET_PERIOD_OFFSET_CONF3_REGS(fas, target) \ 1649 { \ 1650 uchar_t period, offset, conf3; \ 1651 period = fas->f_sync_period[target] & SYNC_PERIOD_MASK; \ 1652 offset = fas->f_offset[target]; \ 1653 conf3 = fas->f_fasconf3[target]; \ 1654 if ((period != fas->f_period_reg_last) || \ 1655 (offset != fas->f_offset_reg_last) || \ 1656 (conf3 != fas->f_fasconf3_reg_last)) { \ 1657 fas->f_period_reg_last = period; \ 1658 fas->f_offset_reg_last = offset; \ 1659 fas->f_fasconf3_reg_last = conf3; \ 1660 fas_reg_write(fas, &fasreg->fas_sync_period, period); \ 1661 fas_reg_write(fas, &fasreg->fas_sync_offset, offset); \ 1662 fas_reg_write(fas, &fasreg->fas_conf3, conf3); \ 1663 } \ 1664 } 1665 1666 /* 1667 * fifo read/write routines 1668 * always read the fifo bytes before reading the interrupt register 1669 */ 1670 1671 static void 1672 fas_read_fifo(struct fas *fas) 1673 { 1674 int stat = fas->f_stat; 1675 volatile struct fasreg *fasreg = fas->f_reg; 1676 int i; 1677 1678 i = fas_reg_read(fas, &fasreg->fas_fifo_flag) & FIFO_CNT_MASK; 1679 EPRINTF2("fas_read_fifo: fifo cnt=%x, stat=%x\n", i, stat); 1680 ASSERT(i <= FIFOSIZE); 1681 1682 fas->f_fifolen = 0; 1683 while (i-- > 0) { 1684 fas->f_fifo[fas->f_fifolen++] = fas_reg_read(fas, 1685 &fasreg->fas_fifo_data); 1686 fas->f_fifo[fas->f_fifolen++] = fas_reg_read(fas, 1687 &fasreg->fas_fifo_data); 1688 } 1689 if (fas->f_stat2 & FAS_STAT2_ISHUTTLE) { 1690 1691 /* write pad byte */ 1692 fas_reg_write(fas, &fasreg->fas_fifo_data, 0); 1693 fas->f_fifo[fas->f_fifolen++] = fas_reg_read(fas, 1694 &fasreg->fas_fifo_data); 1695 /* flush pad byte */ 1696 fas_reg_cmd_write(fas, CMD_FLUSH); 1697 } 1698 EPRINTF2("fas_read_fifo: fifo len=%x, stat2=%x\n", 1699 fas->f_fifolen, stat); 1700 } /* fas_read_fifo */ 1701 1702 static void 1703 fas_write_fifo(struct fas *fas, uchar_t *buf, int length, int pad) 1704 { 1705 int i; 1706 volatile struct fasreg *fasreg = fas->f_reg; 1707 1708 EPRINTF1("writing fifo %x bytes\n", length); 1709 ASSERT(length <= 15); 1710 fas_reg_cmd_write(fas, CMD_FLUSH); 1711 for (i = 0; i < length; i++) { 1712 fas_reg_write(fas, &fasreg->fas_fifo_data, buf[i]); 1713 if (pad) { 1714 fas_reg_write(fas, &fasreg->fas_fifo_data, 0); 1715 } 1716 } 1717 } 1718 1719 /* 1720 * Hardware and Software internal reset routines 1721 */ 1722 static int 1723 fas_init_chip(struct fas *fas, uchar_t initiator_id) 1724 { 1725 int i; 1726 uchar_t clock_conv; 1727 uchar_t initial_conf3; 1728 uint_t ticks; 1729 static char *prop_cfreq = "clock-frequency"; 1730 1731 /* 1732 * Determine clock frequency of attached FAS chip. 1733 */ 1734 i = ddi_prop_get_int(DDI_DEV_T_ANY, 1735 fas->f_dev, DDI_PROP_DONTPASS, prop_cfreq, -1); 1736 clock_conv = (i + FIVE_MEG - 1) / FIVE_MEG; 1737 if (clock_conv != CLOCK_40MHZ) { 1738 fas_log(fas, CE_WARN, "Bad clock frequency"); 1739 return (-1); 1740 } 1741 1742 fas->f_clock_conv = clock_conv; 1743 fas->f_clock_cycle = CLOCK_PERIOD(i); 1744 ticks = FAS_CLOCK_TICK(fas); 1745 fas->f_stval = FAS_CLOCK_TIMEOUT(ticks, fas_selection_timeout); 1746 1747 DPRINTF5("%d mhz, clock_conv %d, clock_cycle %d, ticks %d, stval %d\n", 1748 i, fas->f_clock_conv, fas->f_clock_cycle, 1749 ticks, fas->f_stval); 1750 /* 1751 * set up conf registers 1752 */ 1753 fas->f_fasconf |= FAS_CONF_PAREN; 1754 fas->f_fasconf2 = (uchar_t)(FAS_CONF2_FENABLE | FAS_CONF2_XL32); 1755 1756 if (initiator_id < NTARGETS) { 1757 initial_conf3 = FAS_CONF3_FASTCLK | FAS_CONF3_ODDBYTE_AUTO; 1758 } else { 1759 initial_conf3 = FAS_CONF3_FASTCLK | FAS_CONF3_ODDBYTE_AUTO | 1760 FAS_CONF3_IDBIT3; 1761 } 1762 1763 for (i = 0; i < NTARGETS_WIDE; i++) { 1764 fas->f_fasconf3[i] = initial_conf3; 1765 } 1766 1767 /* 1768 * Avoid resetting the scsi bus since this causes a few seconds 1769 * delay per fas in boot and also causes busy conditions in some 1770 * tape devices. 1771 */ 1772 fas_internal_reset(fas, FAS_RESET_SOFTC|FAS_RESET_FAS|FAS_RESET_DMA); 1773 1774 /* 1775 * initialize period and offset for each target 1776 */ 1777 for (i = 0; i < NTARGETS_WIDE; i++) { 1778 if (fas->f_target_scsi_options[i] & SCSI_OPTIONS_SYNC) { 1779 fas->f_offset[i] = fas_default_offset | 1780 fas->f_req_ack_delay; 1781 } else { 1782 fas->f_offset[i] = 0; 1783 } 1784 if (fas->f_target_scsi_options[i] & SCSI_OPTIONS_FAST) { 1785 fas->f_neg_period[i] = 1786 (uchar_t)MIN_SYNC_PERIOD(fas); 1787 } else { 1788 fas->f_neg_period[i] = 1789 (uchar_t)CONVERT_PERIOD(DEFAULT_SYNC_PERIOD); 1790 } 1791 } 1792 return (0); 1793 } 1794 1795 /* 1796 * reset bus, chip, dma, or soft state 1797 */ 1798 static void 1799 fas_internal_reset(struct fas *fas, int reset_action) 1800 { 1801 volatile struct fasreg *fasreg = fas->f_reg; 1802 volatile struct dma *dmar = fas->f_dma; 1803 1804 if (reset_action & FAS_RESET_SCSIBUS) { 1805 fas_reg_cmd_write(fas, CMD_RESET_SCSI); 1806 fas_setup_reset_delay(fas); 1807 } 1808 1809 FAS_FLUSH_DMA_HARD(fas); /* resets and reinits the dma */ 1810 1811 /* 1812 * NOTE: if dma is aborted while active, indefinite hangs 1813 * may occur; it is preferable to stop the target first before 1814 * flushing the dma 1815 */ 1816 if (reset_action & FAS_RESET_DMA) { 1817 int burstsizes = fas->f_dma_attr->dma_attr_burstsizes; 1818 if (burstsizes & BURST64) { 1819 IPRINTF("64 byte burstsize\n"); 1820 fas->f_dma_csr |= DMA_BURST64; 1821 } else if (burstsizes & BURST32) { 1822 IPRINTF("32 byte burstsize\n"); 1823 fas->f_dma_csr |= DMA_BURST32; 1824 } else { 1825 IPRINTF("16 byte burstsize\n"); 1826 } 1827 if ((fas->f_hm_rev > 0x20) && (fas_enable_sbus64) && 1828 (ddi_dma_set_sbus64(fas->f_dmahandle, burstsizes) == 1829 DDI_SUCCESS)) { 1830 IPRINTF("enabled 64 bit sbus\n"); 1831 fas->f_dma_csr |= DMA_WIDE_EN; 1832 } 1833 } 1834 1835 if (reset_action & FAS_RESET_FAS) { 1836 /* 1837 * 2 NOPs with DMA are required here 1838 * id_code is unreliable if we don't do this) 1839 */ 1840 uchar_t idcode, fcode; 1841 int dmarev; 1842 1843 fas_reg_cmd_write(fas, CMD_RESET_FAS); 1844 fas_reg_cmd_write(fas, CMD_NOP | CMD_DMA); 1845 fas_reg_cmd_write(fas, CMD_NOP | CMD_DMA); 1846 1847 /* 1848 * Re-load chip configurations 1849 * Only load registers which are not loaded in fas_startcmd() 1850 */ 1851 fas_reg_write(fas, &fasreg->fas_clock_conv, 1852 (fas->f_clock_conv & CLOCK_MASK)); 1853 1854 fas_reg_write(fas, &fasreg->fas_timeout, fas->f_stval); 1855 1856 /* 1857 * enable default configurations 1858 */ 1859 fas->f_idcode = idcode = 1860 fas_reg_read(fas, &fasreg->fas_id_code); 1861 fcode = (uchar_t)(idcode & FAS_FCODE_MASK) >> (uchar_t)3; 1862 fas->f_type = FAS366; 1863 IPRINTF2("Family code %d, revision %d\n", 1864 fcode, (idcode & FAS_REV_MASK)); 1865 dmarev = fas_dma_reg_read(fas, &dmar->dma_csr); 1866 dmarev = (dmarev >> 11) & 0xf; 1867 IPRINTF1("DMA channel revision %d\n", dmarev); 1868 1869 fas_reg_write(fas, &fasreg->fas_conf, fas->f_fasconf); 1870 fas_reg_write(fas, &fasreg->fas_conf2, fas->f_fasconf2); 1871 1872 fas->f_req_ack_delay = DEFAULT_REQ_ACK_DELAY; 1873 1874 /* 1875 * Just in case... clear interrupt 1876 */ 1877 (void) fas_reg_read(fas, &fasreg->fas_intr); 1878 } 1879 1880 if (reset_action & FAS_RESET_SOFTC) { 1881 fas->f_wdtr_sent = fas->f_sdtr_sent = 0; 1882 fas->f_wide_known = fas->f_sync_known = 0; 1883 fas->f_wide_enabled = fas->f_sync_enabled = 0; 1884 fas->f_omsglen = 0; 1885 fas->f_cur_msgout[0] = fas->f_last_msgout = 1886 fas->f_last_msgin = INVALID_MSG; 1887 fas->f_abort_msg_sent = fas->f_reset_msg_sent = 0; 1888 fas->f_next_slot = 0; 1889 fas->f_current_sp = NULL; 1890 fas->f_fifolen = 0; 1891 fas->f_fasconf3_reg_last = fas->f_offset_reg_last = 1892 fas->f_period_reg_last = 0xff; 1893 1894 New_state(fas, STATE_FREE); 1895 } 1896 } 1897 1898 1899 #ifdef FASDEBUG 1900 /* 1901 * check if ncmds still reflects the truth 1902 * count all cmds for this driver instance and compare with ncmds 1903 */ 1904 static void 1905 fas_check_ncmds(struct fas *fas) 1906 { 1907 int slot = 0; 1908 ushort_t tag, t; 1909 int n, total = 0; 1910 1911 do { 1912 if (fas->f_active[slot]) { 1913 struct fas_cmd *sp = fas->f_readyf[slot]; 1914 t = fas->f_active[slot]->f_n_slots; 1915 while (sp != 0) { 1916 sp = sp->cmd_forw; 1917 total++; 1918 } 1919 for (n = tag = 0; tag < t; tag++) { 1920 if (fas->f_active[slot]->f_slot[tag] != 0) { 1921 n++; 1922 total++; 1923 } 1924 } 1925 ASSERT(n == fas->f_tcmds[slot]); 1926 } 1927 slot = NEXTSLOT(slot, fas->f_dslot); 1928 } while (slot != 0); 1929 1930 if (total != fas->f_ncmds) { 1931 IPRINTF2("fas_check_ncmds: total=%x, ncmds=%x\n", 1932 total, fas->f_ncmds); 1933 } 1934 ASSERT(fas->f_ncmds >= fas->f_ndisc); 1935 } 1936 #else 1937 #define fas_check_ncmds(fas) 1938 #endif 1939 1940 /* 1941 * SCSA Interface functions 1942 * 1943 * Visible to the external world via the transport structure. 1944 * 1945 * fas_scsi_abort: abort a current cmd or all cmds for a target 1946 */ 1947 /*ARGSUSED*/ 1948 static int 1949 fas_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt) 1950 { 1951 struct fas *fas = ADDR2FAS(ap); 1952 int rval; 1953 1954 IPRINTF2("fas_scsi_abort: target %d.%d\n", ap->a_target, ap->a_lun); 1955 1956 mutex_enter(FAS_MUTEX(fas)); 1957 rval = fas_do_scsi_abort(ap, pkt); 1958 fas_check_waitQ_and_mutex_exit(fas); 1959 return (rval); 1960 } 1961 1962 /* 1963 * reset handling: reset bus or target 1964 */ 1965 /*ARGSUSED*/ 1966 static int 1967 fas_scsi_reset(struct scsi_address *ap, int level) 1968 { 1969 struct fas *fas = ADDR2FAS(ap); 1970 int rval; 1971 1972 IPRINTF3("fas_scsi_reset: target %d.%d, level %d\n", 1973 ap->a_target, ap->a_lun, level); 1974 1975 mutex_enter(FAS_MUTEX(fas)); 1976 rval = fas_do_scsi_reset(ap, level); 1977 fas_check_waitQ_and_mutex_exit(fas); 1978 return (rval); 1979 } 1980 1981 /* 1982 * entry point for reset notification setup, to register or to cancel. 1983 */ 1984 static int 1985 fas_scsi_reset_notify(struct scsi_address *ap, int flag, 1986 void (*callback)(caddr_t), caddr_t arg) 1987 { 1988 struct fas *fas = ADDR2FAS(ap); 1989 1990 return (scsi_hba_reset_notify_setup(ap, flag, callback, arg, 1991 &fas->f_mutex, &fas->f_reset_notify_listf)); 1992 } 1993 1994 /* 1995 * capability interface 1996 */ 1997 /*ARGSUSED*/ 1998 static int 1999 fas_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2000 { 2001 struct fas *fas = ADDR2FAS(ap); 2002 DPRINTF3("fas_scsi_getcap: tgt=%x, cap=%s, whom=%x\n", 2003 ap->a_target, cap, whom); 2004 return (fas_commoncap(ap, cap, 0, whom, 0)); 2005 } 2006 2007 /*ARGSUSED*/ 2008 static int 2009 fas_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2010 { 2011 struct fas *fas = ADDR2FAS(ap); 2012 IPRINTF4("fas_scsi_setcap: tgt=%x, cap=%s, value=%x, whom=%x\n", 2013 ap->a_target, cap, value, whom); 2014 return (fas_commoncap(ap, cap, value, whom, 1)); 2015 } 2016 2017 /* 2018 * pkt and dma allocation and deallocation 2019 */ 2020 /*ARGSUSED*/ 2021 static void 2022 fas_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 2023 { 2024 struct fas_cmd *cmd = PKT2CMD(pkt); 2025 2026 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAFREE_START, 2027 "fas_scsi_dmafree_start"); 2028 2029 if (cmd->cmd_flags & CFLAG_DMAVALID) { 2030 /* 2031 * Free the mapping. 2032 */ 2033 (void) ddi_dma_unbind_handle(cmd->cmd_dmahandle); 2034 cmd->cmd_flags ^= CFLAG_DMAVALID; 2035 } 2036 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAFREE_END, 2037 "fas_scsi_dmafree_end"); 2038 } 2039 2040 /*ARGSUSED*/ 2041 static void 2042 fas_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2043 { 2044 struct fas_cmd *sp = PKT2CMD(pkt); 2045 2046 if (sp->cmd_flags & CFLAG_DMAVALID) { 2047 if (ddi_dma_sync(sp->cmd_dmahandle, 0, 0, 2048 (sp->cmd_flags & CFLAG_DMASEND) ? 2049 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU) != 2050 DDI_SUCCESS) { 2051 fas_log(ADDR2FAS(ap), CE_WARN, 2052 "sync of pkt (%p) failed", (void *)pkt); 2053 } 2054 } 2055 } 2056 2057 /* 2058 * initialize pkt and allocate DVMA resources 2059 */ 2060 static struct scsi_pkt * 2061 fas_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2062 struct buf *bp, int cmdlen, int statuslen, int tgtlen, 2063 int flags, int (*callback)(), caddr_t arg) 2064 { 2065 int kf; 2066 int failure = 1; 2067 struct fas_cmd *cmd; 2068 struct fas *fas = ADDR2FAS(ap); 2069 struct fas_cmd *new_cmd; 2070 int rval; 2071 2072 /* #define FAS_TEST_EXTRN_ALLOC */ 2073 #ifdef FAS_TEST_EXTRN_ALLOC 2074 cmdlen *= 4; statuslen *= 4; tgtlen *= 4; 2075 #endif 2076 /* 2077 * if no pkt was passed then allocate a pkt first 2078 */ 2079 if (pkt == NULL) { 2080 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_PKTALLOC_START, 2081 "fas_scsi_impl_pktalloc_start"); 2082 2083 kf = (callback == SLEEP_FUNC)? KM_SLEEP: KM_NOSLEEP; 2084 2085 /* 2086 * only one size of pkt (with arq). 2087 */ 2088 cmd = kmem_cache_alloc(fas->f_kmem_cache, kf); 2089 2090 if (cmd) { 2091 2092 ddi_dma_handle_t save_dma_handle; 2093 2094 save_dma_handle = cmd->cmd_dmahandle; 2095 bzero(cmd, EXTCMD_SIZE); 2096 cmd->cmd_dmahandle = save_dma_handle; 2097 2098 pkt = (struct scsi_pkt *)((uchar_t *)cmd + 2099 sizeof (struct fas_cmd)); 2100 cmd->cmd_pkt = pkt; 2101 pkt->pkt_ha_private = (opaque_t)cmd; 2102 pkt->pkt_scbp = (opaque_t)&cmd->cmd_scb; 2103 pkt->pkt_cdbp = (opaque_t)&cmd->cmd_cdb; 2104 pkt->pkt_address = *ap; 2105 2106 pkt->pkt_cdbp = (opaque_t)&cmd->cmd_cdb; 2107 pkt->pkt_private = cmd->cmd_pkt_private; 2108 2109 cmd->cmd_cdblen = cmdlen; 2110 cmd->cmd_scblen = statuslen; 2111 cmd->cmd_privlen = tgtlen; 2112 cmd->cmd_slot = 2113 (Tgt(cmd) * NLUNS_PER_TARGET) | Lun(cmd); 2114 failure = 0; 2115 } 2116 if (failure || (cmdlen > sizeof (cmd->cmd_cdb)) || 2117 (tgtlen > PKT_PRIV_LEN) || 2118 (statuslen > EXTCMDS_STATUS_SIZE)) { 2119 if (failure == 0) { 2120 /* 2121 * if extern alloc fails, all will be 2122 * deallocated, including cmd 2123 */ 2124 failure = fas_pkt_alloc_extern(fas, cmd, 2125 cmdlen, tgtlen, statuslen, kf); 2126 } 2127 if (failure) { 2128 /* 2129 * nothing to deallocate so just return 2130 */ 2131 TRACE_0(TR_FAC_SCSI_FAS, 2132 TR_FAS_SCSI_IMPL_PKTALLOC_END, 2133 "fas_scsi_impl_pktalloc_end"); 2134 return (NULL); 2135 } 2136 } 2137 2138 new_cmd = cmd; 2139 2140 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_PKTALLOC_END, 2141 "fas_scsi_impl_pktalloc_end"); 2142 } else { 2143 cmd = PKT2CMD(pkt); 2144 new_cmd = NULL; 2145 } 2146 2147 /* 2148 * Second step of fas_scsi_init_pkt: 2149 * bind the buf to the handle 2150 */ 2151 if (bp && bp->b_bcount != 0 && 2152 (cmd->cmd_flags & CFLAG_DMAVALID) == 0) { 2153 2154 int cmd_flags, dma_flags; 2155 uint_t dmacookie_count; 2156 2157 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAGET_START, 2158 "fas_scsi_impl_dmaget_start"); 2159 2160 cmd_flags = cmd->cmd_flags; 2161 2162 if (bp->b_flags & B_READ) { 2163 cmd_flags &= ~CFLAG_DMASEND; 2164 dma_flags = DDI_DMA_READ | DDI_DMA_PARTIAL; 2165 } else { 2166 cmd_flags |= CFLAG_DMASEND; 2167 dma_flags = DDI_DMA_WRITE | DDI_DMA_PARTIAL; 2168 } 2169 if (flags & PKT_CONSISTENT) { 2170 cmd_flags |= CFLAG_CMDIOPB; 2171 dma_flags |= DDI_DMA_CONSISTENT; 2172 } 2173 2174 /* 2175 * bind the handle to the buf 2176 */ 2177 ASSERT(cmd->cmd_dmahandle != NULL); 2178 rval = ddi_dma_buf_bind_handle(cmd->cmd_dmahandle, bp, 2179 dma_flags, callback, arg, &cmd->cmd_dmacookie, 2180 &dmacookie_count); 2181 2182 if (rval && rval != DDI_DMA_PARTIAL_MAP) { 2183 switch (rval) { 2184 case DDI_DMA_NORESOURCES: 2185 bioerror(bp, 0); 2186 break; 2187 case DDI_DMA_BADATTR: 2188 case DDI_DMA_NOMAPPING: 2189 bioerror(bp, EFAULT); 2190 break; 2191 case DDI_DMA_TOOBIG: 2192 default: 2193 bioerror(bp, EINVAL); 2194 break; 2195 } 2196 cmd->cmd_flags = cmd_flags & ~CFLAG_DMAVALID; 2197 if (new_cmd) { 2198 fas_scsi_destroy_pkt(ap, pkt); 2199 } 2200 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAGET_END, 2201 "fas_scsi_impl_dmaget_end"); 2202 return ((struct scsi_pkt *)NULL); 2203 } 2204 ASSERT(dmacookie_count == 1); 2205 cmd->cmd_dmacount = bp->b_bcount; 2206 cmd->cmd_flags = cmd_flags | CFLAG_DMAVALID; 2207 2208 ASSERT(cmd->cmd_dmahandle != NULL); 2209 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAGET_END, 2210 "fas_scsi_impl_dmaget_end"); 2211 } 2212 2213 return (pkt); 2214 } 2215 2216 /* 2217 * unbind dma resources and deallocate the pkt 2218 */ 2219 static void 2220 fas_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2221 { 2222 struct fas_cmd *sp = PKT2CMD(pkt); 2223 struct fas *fas = ADDR2FAS(ap); 2224 2225 /* 2226 * fas_scsi_impl_dmafree inline to speed things up 2227 */ 2228 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAFREE_START, 2229 "fas_scsi_impl_dmafree_start"); 2230 2231 if (sp->cmd_flags & CFLAG_DMAVALID) { 2232 /* 2233 * Free the mapping. 2234 */ 2235 (void) ddi_dma_unbind_handle(sp->cmd_dmahandle); 2236 sp->cmd_flags ^= CFLAG_DMAVALID; 2237 } 2238 2239 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_DMAFREE_END, 2240 "fas_scsi_impl_dmafree_end"); 2241 2242 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_PKTFREE_START, 2243 "fas_scsi_impl_pktfree_start"); 2244 2245 if ((sp->cmd_flags & 2246 (CFLAG_FREE | CFLAG_CDBEXTERN | CFLAG_PRIVEXTERN | 2247 CFLAG_SCBEXTERN)) == 0) { 2248 sp->cmd_flags = CFLAG_FREE; 2249 kmem_cache_free(fas->f_kmem_cache, (void *)sp); 2250 } else { 2251 fas_pkt_destroy_extern(fas, sp); 2252 } 2253 2254 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_SCSI_IMPL_PKTFREE_END, 2255 "fas_scsi_impl_pktfree_end"); 2256 } 2257 2258 /* 2259 * allocate and deallocate external pkt space (ie. not part of fas_cmd) for 2260 * non-standard length cdb, pkt_private, status areas 2261 * if allocation fails, then deallocate all external space and the pkt 2262 */ 2263 /* ARGSUSED */ 2264 static int 2265 fas_pkt_alloc_extern(struct fas *fas, struct fas_cmd *sp, 2266 int cmdlen, int tgtlen, int statuslen, int kf) 2267 { 2268 caddr_t cdbp, scbp, tgt; 2269 int failure = 0; 2270 2271 tgt = cdbp = scbp = NULL; 2272 if (cmdlen > sizeof (sp->cmd_cdb)) { 2273 if ((cdbp = kmem_zalloc((size_t)cmdlen, kf)) == NULL) { 2274 failure++; 2275 } else { 2276 sp->cmd_pkt->pkt_cdbp = (opaque_t)cdbp; 2277 sp->cmd_flags |= CFLAG_CDBEXTERN; 2278 } 2279 } 2280 if (tgtlen > PKT_PRIV_LEN) { 2281 if ((tgt = kmem_zalloc(tgtlen, kf)) == NULL) { 2282 failure++; 2283 } else { 2284 sp->cmd_flags |= CFLAG_PRIVEXTERN; 2285 sp->cmd_pkt->pkt_private = tgt; 2286 } 2287 } 2288 if (statuslen > EXTCMDS_STATUS_SIZE) { 2289 if ((scbp = kmem_zalloc((size_t)statuslen, kf)) == NULL) { 2290 failure++; 2291 } else { 2292 sp->cmd_flags |= CFLAG_SCBEXTERN; 2293 sp->cmd_pkt->pkt_scbp = (opaque_t)scbp; 2294 } 2295 } 2296 if (failure) { 2297 fas_pkt_destroy_extern(fas, sp); 2298 } 2299 return (failure); 2300 } 2301 2302 /* 2303 * deallocate external pkt space and deallocate the pkt 2304 */ 2305 static void 2306 fas_pkt_destroy_extern(struct fas *fas, struct fas_cmd *sp) 2307 { 2308 if (sp->cmd_flags & CFLAG_FREE) { 2309 panic("fas_pkt_destroy_extern: freeing free packet"); 2310 _NOTE(NOT_REACHED) 2311 /* NOTREACHED */ 2312 } 2313 if (sp->cmd_flags & CFLAG_CDBEXTERN) { 2314 kmem_free((caddr_t)sp->cmd_pkt->pkt_cdbp, 2315 (size_t)sp->cmd_cdblen); 2316 } 2317 if (sp->cmd_flags & CFLAG_SCBEXTERN) { 2318 kmem_free((caddr_t)sp->cmd_pkt->pkt_scbp, 2319 (size_t)sp->cmd_scblen); 2320 } 2321 if (sp->cmd_flags & CFLAG_PRIVEXTERN) { 2322 kmem_free((caddr_t)sp->cmd_pkt->pkt_private, 2323 (size_t)sp->cmd_privlen); 2324 } 2325 sp->cmd_flags = CFLAG_FREE; 2326 kmem_cache_free(fas->f_kmem_cache, (void *)sp); 2327 } 2328 2329 /* 2330 * kmem cache constructor and destructor: 2331 * When constructing, we bzero the cmd and allocate the dma handle 2332 * When destructing, just free the dma handle 2333 */ 2334 static int 2335 fas_kmem_cache_constructor(void *buf, void *cdrarg, int kmflags) 2336 { 2337 struct fas_cmd *cmd = buf; 2338 struct fas *fas = cdrarg; 2339 int (*callback)(caddr_t) = (kmflags == KM_SLEEP) ? DDI_DMA_SLEEP: 2340 DDI_DMA_DONTWAIT; 2341 2342 bzero(buf, EXTCMD_SIZE); 2343 2344 /* 2345 * allocate a dma handle 2346 */ 2347 if ((ddi_dma_alloc_handle(fas->f_dev, fas->f_dma_attr, callback, 2348 NULL, &cmd->cmd_dmahandle)) != DDI_SUCCESS) { 2349 return (-1); 2350 } 2351 return (0); 2352 } 2353 2354 /*ARGSUSED*/ 2355 static void 2356 fas_kmem_cache_destructor(void *buf, void *cdrarg) 2357 { 2358 struct fas_cmd *cmd = buf; 2359 if (cmd->cmd_dmahandle) { 2360 ddi_dma_free_handle(&cmd->cmd_dmahandle); 2361 } 2362 } 2363 2364 /* 2365 * fas_scsi_start - Accept commands for transport 2366 */ 2367 static int 2368 fas_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2369 { 2370 struct fas_cmd *sp = PKT2CMD(pkt); 2371 struct fas *fas = ADDR2FAS(ap); 2372 int rval; 2373 int intr = 0; 2374 2375 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_START_START, "fas_scsi_start_start"); 2376 2377 #ifdef FAS_TEST 2378 if (fas_transport_busy > 0) { 2379 fas_transport_busy--; 2380 return (TRAN_BUSY); 2381 } 2382 if ((fas_transport_busy_rqs > 0) && 2383 (*(sp->cmd_pkt->pkt_cdbp) == SCMD_REQUEST_SENSE)) { 2384 fas_transport_busy_rqs--; 2385 return (TRAN_BUSY); 2386 } 2387 if (fas_transport_reject > 0) { 2388 fas_transport_reject--; 2389 return (TRAN_BADPKT); 2390 } 2391 #endif 2392 /* 2393 * prepare packet before taking the mutex 2394 */ 2395 rval = fas_prepare_pkt(fas, sp); 2396 if (rval != TRAN_ACCEPT) { 2397 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_START_PREPARE_PKT_END, 2398 "fas_scsi_start_end (prepare_pkt)"); 2399 return (rval); 2400 } 2401 2402 /* 2403 * fas mutex can be held for a long time; therefore, if the mutex is 2404 * held, we queue the packet in a waitQ; we now should check 2405 * the waitQ on every mutex_exit(FAS_MUTEX(fas)) but we really only 2406 * need to do this when the bus is free 2407 * don't put NOINTR cmds including proxy cmds in waitQ! These 2408 * cmds are handled by fas_runpoll() 2409 * if the waitQ is non-empty, queue the pkt anyway to preserve 2410 * order 2411 * the goal is to queue in waitQ as much as possible so at 2412 * interrupt time, we can move the packets to readyQ or start 2413 * a packet immediately. It helps to do this at interrupt 2414 * time because we can then field more interrupts 2415 */ 2416 if ((sp->cmd_pkt_flags & FLAG_NOINTR) == 0) { 2417 2418 /* 2419 * if the bus is not free, we will get an interrupt shortly 2420 * so we don't want to take the fas mutex but queue up 2421 * the packet in the waitQ 2422 * also, if the waitQ is non-empty or there is an interrupt 2423 * pending then queue up the packet in the waitQ and let the 2424 * interrupt handler empty the waitQ 2425 */ 2426 mutex_enter(&fas->f_waitQ_mutex); 2427 2428 if ((fas->f_state != STATE_FREE) || 2429 fas->f_waitf || (intr = INTPENDING(fas))) { 2430 goto queue_in_waitQ; 2431 } 2432 2433 /* 2434 * we didn't queue up in the waitQ, so now try to accept 2435 * the packet. if we fail to get the fas mutex, go back to 2436 * the waitQ again 2437 * do not release the waitQ mutex yet because that 2438 * leaves a window where the interrupt handler has 2439 * emptied the waitQ but not released the fas mutex yet 2440 * 2441 * the interrupt handler gets the locks in opposite order 2442 * but because we do a tryenter, there is no deadlock 2443 * 2444 * if another thread has the fas mutex then either this 2445 * thread or the other may find the bus free and 2446 * empty the waitQ 2447 */ 2448 if (mutex_tryenter(FAS_MUTEX(fas))) { 2449 mutex_exit(&fas->f_waitQ_mutex); 2450 rval = fas_accept_pkt(fas, sp, TRAN_BUSY_OK); 2451 } else { 2452 /* 2453 * we didn't get the fas mutex so 2454 * the packet has to go in the waitQ now 2455 */ 2456 goto queue_in_waitQ; 2457 } 2458 } else { 2459 /* 2460 * for polled cmds, we have to take the mutex and 2461 * start the packet using fas_runpoll() 2462 */ 2463 mutex_enter(FAS_MUTEX(fas)); 2464 rval = fas_accept_pkt(fas, sp, TRAN_BUSY_OK); 2465 } 2466 2467 /* 2468 * if the bus is free then empty waitQ and release the mutex 2469 * (this should be unlikely that the bus is still free after 2470 * accepting the packet. it may be the relatively unusual case 2471 * that we are throttling) 2472 */ 2473 if (fas->f_state == STATE_FREE) { 2474 FAS_CHECK_WAITQ_AND_FAS_MUTEX_EXIT(fas); 2475 } else { 2476 mutex_exit(FAS_MUTEX(fas)); 2477 } 2478 2479 done: 2480 TRACE_1(TR_FAC_SCSI_FAS, TR_FAS_START_END, 2481 "fas_scsi_start_end: fas 0x%p", fas); 2482 return (rval); 2483 2484 queue_in_waitQ: 2485 if (fas->f_waitf == NULL) { 2486 fas->f_waitb = fas->f_waitf = sp; 2487 sp->cmd_forw = NULL; 2488 } else { 2489 struct fas_cmd *dp = fas->f_waitb; 2490 dp->cmd_forw = fas->f_waitb = sp; 2491 sp->cmd_forw = NULL; 2492 } 2493 2494 /* 2495 * check again the fas mutex 2496 * if there was an interrupt then the interrupt 2497 * handler will eventually empty the waitQ 2498 */ 2499 if ((intr == 0) && (fas->f_state == STATE_FREE) && 2500 mutex_tryenter(FAS_MUTEX(fas))) { 2501 /* 2502 * double check if the bus is still free 2503 * (this actually reduced mutex contention a bit) 2504 */ 2505 if (fas->f_state == STATE_FREE) { 2506 fas_empty_waitQ(fas); 2507 } 2508 mutex_exit(FAS_MUTEX(fas)); 2509 } 2510 mutex_exit(&fas->f_waitQ_mutex); 2511 2512 TRACE_1(TR_FAC_SCSI_FAS, TR_FAS_START_END, 2513 "fas_scsi_start_end: fas 0x%p", fas); 2514 return (rval); 2515 } 2516 2517 /* 2518 * prepare the pkt: 2519 * the pkt may have been resubmitted or just reused so 2520 * initialize some fields, reset the dma window, and do some checks 2521 */ 2522 static int 2523 fas_prepare_pkt(struct fas *fas, struct fas_cmd *sp) 2524 { 2525 struct scsi_pkt *pkt = CMD2PKT(sp); 2526 2527 /* 2528 * Reinitialize some fields that need it; the packet may 2529 * have been resubmitted 2530 */ 2531 pkt->pkt_reason = CMD_CMPLT; 2532 pkt->pkt_state = 0; 2533 pkt->pkt_statistics = 0; 2534 pkt->pkt_resid = 0; 2535 sp->cmd_age = 0; 2536 sp->cmd_pkt_flags = pkt->pkt_flags; 2537 2538 /* 2539 * Copy the cdb pointer to the pkt wrapper area as we 2540 * might modify this pointer. Zero status byte 2541 */ 2542 sp->cmd_cdbp = pkt->pkt_cdbp; 2543 *(pkt->pkt_scbp) = 0; 2544 2545 if (sp->cmd_flags & CFLAG_DMAVALID) { 2546 pkt->pkt_resid = sp->cmd_dmacount; 2547 2548 /* 2549 * if the pkt was resubmitted then the 2550 * windows may be at the wrong number 2551 */ 2552 if (sp->cmd_cur_win) { 2553 sp->cmd_cur_win = 0; 2554 if (fas_set_new_window(fas, sp)) { 2555 IPRINTF("cannot reset window\n"); 2556 return (TRAN_BADPKT); 2557 } 2558 } 2559 sp->cmd_saved_cur_addr = 2560 sp->cmd_cur_addr = sp->cmd_dmacookie.dmac_address; 2561 2562 /* 2563 * the common case is just one window, we worry 2564 * about multiple windows when we run out of the 2565 * current window 2566 */ 2567 sp->cmd_nwin = sp->cmd_saved_win = 0; 2568 sp->cmd_data_count = sp->cmd_saved_data_count = 0; 2569 2570 /* 2571 * consistent packets need to be sync'ed first 2572 * (only for data going out) 2573 */ 2574 if ((sp->cmd_flags & (CFLAG_CMDIOPB | CFLAG_DMASEND)) == 2575 (CFLAG_CMDIOPB | CFLAG_DMASEND)) { 2576 (void) ddi_dma_sync(sp->cmd_dmahandle, 0, (uint_t)0, 2577 DDI_DMA_SYNC_FORDEV); 2578 } 2579 } 2580 2581 sp->cmd_actual_cdblen = sp->cmd_cdblen; 2582 2583 #ifdef FAS_TEST 2584 #ifndef __lock_lint 2585 if (fas_test_untagged > 0) { 2586 if (TAGGED(Tgt(sp))) { 2587 int slot = sp->cmd_slot; 2588 sp->cmd_pkt_flags &= ~FLAG_TAGMASK; 2589 sp->cmd_pkt_flags &= ~FLAG_NODISCON; 2590 sp->cmd_pkt_flags |= 0x80000000; 2591 fas_log(fas, CE_NOTE, 2592 "starting untagged cmd, target=%d," 2593 " tcmds=%d, sp=0x%p, throttle=%d\n", 2594 Tgt(sp), fas->f_tcmds[slot], (void *)sp, 2595 fas->f_throttle[slot]); 2596 fas_test_untagged = -10; 2597 } 2598 } 2599 #endif 2600 #endif 2601 2602 #ifdef FASDEBUG 2603 if (NOTAG(Tgt(sp)) && (pkt->pkt_flags & FLAG_TAGMASK)) { 2604 IPRINTF2("tagged packet for non-tagged target %d.%d\n", 2605 Tgt(sp), Lun(sp)); 2606 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_PREPARE_PKT_TRAN_BADPKT_END, 2607 "fas_prepare_pkt_end (tran_badpkt)"); 2608 return (TRAN_BADPKT); 2609 } 2610 2611 /* 2612 * the SCSA spec states that it is an error to have no 2613 * completion function when FLAG_NOINTR is not set 2614 */ 2615 if ((pkt->pkt_comp == NULL) && 2616 ((pkt->pkt_flags & FLAG_NOINTR) == 0)) { 2617 IPRINTF("intr packet with pkt_comp == 0\n"); 2618 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_PREPARE_PKT_TRAN_BADPKT_END, 2619 "fas_prepare_pkt_end (tran_badpkt)"); 2620 return (TRAN_BADPKT); 2621 } 2622 #endif /* FASDEBUG */ 2623 2624 if ((fas->f_target_scsi_options[Tgt(sp)] & SCSI_OPTIONS_DR) == 0) { 2625 /* 2626 * no need to reset tag bits since tag queueing will 2627 * not be enabled if disconnects are disabled 2628 */ 2629 sp->cmd_pkt_flags |= FLAG_NODISCON; 2630 } 2631 2632 sp->cmd_flags = (sp->cmd_flags & ~CFLAG_TRANFLAG) | 2633 CFLAG_PREPARED | CFLAG_IN_TRANSPORT; 2634 2635 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_PREPARE_PKT_TRAN_ACCEPT_END, 2636 "fas_prepare_pkt_end (tran_accept)"); 2637 return (TRAN_ACCEPT); 2638 } 2639 2640 /* 2641 * emptying the waitQ just before releasing FAS_MUTEX is a bit 2642 * tricky; if we release the waitQ mutex and then the FAS_MUTEX, 2643 * another thread could queue a cmd in the waitQ, just before 2644 * the FAS_MUTEX is released. This cmd is then stuck in the waitQ unless 2645 * another cmd comes in or fas_intr() or fas_watch() checks the waitQ. 2646 * Therefore, by releasing the FAS_MUTEX before releasing the waitQ mutex, 2647 * we prevent fas_scsi_start() filling the waitQ 2648 * 2649 * By setting NO_TRAN_BUSY, we force fas_accept_pkt() to queue up 2650 * the waitQ pkts in the readyQ. 2651 * If a QFull condition occurs, the target driver may set its throttle 2652 * too high because of the requests queued up in the readyQ but this 2653 * is not a big problem. The throttle should be periodically reset anyway. 2654 */ 2655 static void 2656 fas_empty_waitQ(struct fas *fas) 2657 { 2658 struct fas_cmd *sp; 2659 int rval; 2660 struct fas_cmd *waitf, *waitb; 2661 2662 ASSERT(mutex_owned(&fas->f_waitQ_mutex)); 2663 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_EMPTY_WAITQ_START, 2664 "fas_empty_waitQ_start"); 2665 2666 while (fas->f_waitf) { 2667 2668 /* copy waitQ, zero the waitQ and release the mutex */ 2669 waitf = fas->f_waitf; 2670 waitb = fas->f_waitb; 2671 fas->f_waitf = fas->f_waitb = NULL; 2672 mutex_exit(&fas->f_waitQ_mutex); 2673 2674 do { 2675 sp = waitf; 2676 waitf = sp->cmd_forw; 2677 if (waitb == sp) { 2678 waitb = NULL; 2679 } 2680 2681 rval = fas_accept_pkt(fas, sp, NO_TRAN_BUSY); 2682 2683 /* 2684 * If the packet was rejected for other reasons then 2685 * complete it here 2686 */ 2687 if (rval != TRAN_ACCEPT) { 2688 ASSERT(rval != TRAN_BUSY); 2689 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 2690 if (sp->cmd_pkt->pkt_comp) { 2691 sp->cmd_flags |= CFLAG_FINISHED; 2692 fas_call_pkt_comp(fas, sp); 2693 } 2694 } 2695 2696 if (INTPENDING(fas)) { 2697 /* 2698 * stop processing the waitQ and put back 2699 * the remaining packets on the waitQ 2700 */ 2701 mutex_enter(&fas->f_waitQ_mutex); 2702 if (waitf) { 2703 ASSERT(waitb != NULL); 2704 waitb->cmd_forw = fas->f_waitf; 2705 fas->f_waitf = waitf; 2706 if (fas->f_waitb == NULL) { 2707 fas->f_waitb = waitb; 2708 } 2709 } 2710 return; 2711 } 2712 } while (waitf); 2713 2714 mutex_enter(&fas->f_waitQ_mutex); 2715 } 2716 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_EMPTY_WAITQ_END, 2717 "fas_empty_waitQ_end"); 2718 } 2719 2720 static void 2721 fas_move_waitQ_to_readyQ(struct fas *fas) 2722 { 2723 /* 2724 * this may actually start cmds but it is most likely 2725 * that if waitQ is not empty that the bus is not free 2726 */ 2727 ASSERT(mutex_owned(FAS_MUTEX(fas))); 2728 mutex_enter(&fas->f_waitQ_mutex); 2729 fas_empty_waitQ(fas); 2730 mutex_exit(&fas->f_waitQ_mutex); 2731 } 2732 2733 2734 /* 2735 * function wrapper for two frequently used macros. for the non-critical 2736 * path we use the function 2737 */ 2738 static void 2739 fas_check_waitQ_and_mutex_exit(struct fas *fas) 2740 { 2741 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(fas->f_mutex)) 2742 FAS_CHECK_WAITQ_AND_FAS_MUTEX_EXIT(fas); 2743 FAS_EMPTY_CALLBACKQ(fas); 2744 } 2745 2746 /* 2747 * fas_accept_pkt(): 2748 * the flag argument is to force fas_accept_pkt to accept the pkt; 2749 * the caller cannot take the pkt back and it has to be queued up in 2750 * the readyQ 2751 */ 2752 static int 2753 fas_accept_pkt(struct fas *fas, struct fas_cmd *sp, int flag) 2754 { 2755 short slot = sp->cmd_slot; 2756 int rval = TRAN_ACCEPT; 2757 2758 TRACE_0(TR_FAC_SCSI_FAS, TR__FAS_START_START, "fas_accept_pkt_start"); 2759 ASSERT(mutex_owned(FAS_MUTEX(fas))); 2760 ASSERT(fas->f_ncmds >= 0 && fas->f_ndisc >= 0); 2761 ASSERT(fas->f_ncmds >= fas->f_ndisc); 2762 ASSERT(fas->f_tcmds[slot] >= 0); 2763 2764 /* 2765 * prepare packet for transport if this hasn't been done yet and 2766 * do some checks 2767 */ 2768 if ((sp->cmd_flags & CFLAG_PREPARED) == 0) { 2769 rval = fas_prepare_pkt(fas, sp); 2770 if (rval != TRAN_ACCEPT) { 2771 IPRINTF1("prepare pkt failed, slot=%x\n", slot); 2772 sp->cmd_flags &= ~CFLAG_TRANFLAG; 2773 goto done; 2774 } 2775 } 2776 2777 if (Lun(sp)) { 2778 EPRINTF("fas_accept_pkt: switching target and lun slot scan\n"); 2779 fas->f_dslot = 1; 2780 2781 if ((fas->f_active[slot] == NULL) || 2782 ((fas->f_active[slot]->f_n_slots != NTAGS) && 2783 TAGGED(Tgt(sp)))) { 2784 (void) fas_alloc_active_slots(fas, slot, KM_NOSLEEP); 2785 } 2786 if ((fas->f_active[slot] == NULL) || 2787 (NOTAG(Tgt(sp)) && (sp->cmd_pkt_flags & FLAG_TAGMASK))) { 2788 IPRINTF("fatal error on non-zero lun pkt\n"); 2789 return (TRAN_FATAL_ERROR); 2790 } 2791 } 2792 2793 /* 2794 * we accepted the command; increment the count 2795 * (we may still reject later if TRAN_BUSY_OK) 2796 */ 2797 fas_check_ncmds(fas); 2798 fas->f_ncmds++; 2799 2800 /* 2801 * if it is a nointr packet, start it now 2802 * (NO_INTR pkts are not queued in the waitQ) 2803 */ 2804 if (sp->cmd_pkt_flags & FLAG_NOINTR) { 2805 EPRINTF("starting a nointr cmd\n"); 2806 fas_runpoll(fas, slot, sp); 2807 sp->cmd_flags &= ~CFLAG_TRANFLAG; 2808 goto done; 2809 } 2810 2811 /* 2812 * reset the throttle if we were draining 2813 */ 2814 if ((fas->f_tcmds[slot] == 0) && 2815 (fas->f_throttle[slot] == DRAIN_THROTTLE)) { 2816 DPRINTF("reset throttle\n"); 2817 ASSERT(fas->f_reset_delay[Tgt(sp)] == 0); 2818 fas_full_throttle(fas, slot); 2819 } 2820 2821 /* 2822 * accept the command: 2823 * If no readyQ and no bus free, and throttle is OK, 2824 * run cmd immediately. 2825 */ 2826 #ifdef FASDEBUG 2827 fas->f_total_cmds++; 2828 #endif 2829 2830 if ((fas->f_readyf[slot] == NULL) && (fas->f_state == STATE_FREE) && 2831 (fas->f_throttle[slot] > fas->f_tcmds[slot])) { 2832 ASSERT(fas->f_current_sp == 0); 2833 (void) fas_startcmd(fas, sp); 2834 goto exit; 2835 } else { 2836 /* 2837 * If FLAG_HEAD is set, run cmd if target and bus are 2838 * available. if first cmd in ready Q is request sense 2839 * then insert after this command, there shouldn't be more 2840 * than one request sense. 2841 */ 2842 if (sp->cmd_pkt_flags & FLAG_HEAD) { 2843 struct fas_cmd *ssp = fas->f_readyf[slot]; 2844 EPRINTF("que head\n"); 2845 if (ssp && 2846 *(ssp->cmd_pkt->pkt_cdbp) != SCMD_REQUEST_SENSE) { 2847 fas_head_of_readyQ(fas, sp); 2848 } else if (ssp) { 2849 struct fas_cmd *dp = ssp->cmd_forw; 2850 ssp->cmd_forw = sp; 2851 sp->cmd_forw = dp; 2852 if (fas->f_readyb[slot] == ssp) { 2853 fas->f_readyb[slot] = sp; 2854 } 2855 } else { 2856 fas->f_readyf[slot] = fas->f_readyb[slot] = sp; 2857 sp->cmd_forw = NULL; 2858 } 2859 2860 /* 2861 * for tagged targets, check for qfull condition and 2862 * return TRAN_BUSY (if permitted), if throttle has been 2863 * exceeded 2864 */ 2865 } else if (TAGGED(Tgt(sp)) && 2866 (fas->f_tcmds[slot] >= fas->f_throttle[slot]) && 2867 (fas->f_throttle[slot] > HOLD_THROTTLE) && 2868 (flag == TRAN_BUSY_OK)) { 2869 IPRINTF2( 2870 "transport busy, slot=%x, ncmds=%x\n", 2871 slot, fas->f_ncmds); 2872 rval = TRAN_BUSY; 2873 fas->f_ncmds--; 2874 sp->cmd_flags &= 2875 ~(CFLAG_PREPARED | CFLAG_IN_TRANSPORT); 2876 goto done; 2877 /* 2878 * append to readyQ or start a new readyQ 2879 */ 2880 } else if (fas->f_readyf[slot]) { 2881 struct fas_cmd *dp = fas->f_readyb[slot]; 2882 ASSERT(dp != 0); 2883 fas->f_readyb[slot] = sp; 2884 sp->cmd_forw = NULL; 2885 dp->cmd_forw = sp; 2886 } else { 2887 fas->f_readyf[slot] = fas->f_readyb[slot] = sp; 2888 sp->cmd_forw = NULL; 2889 } 2890 2891 } 2892 2893 done: 2894 /* 2895 * just in case that the bus is free and we haven't 2896 * been able to restart for some reason 2897 */ 2898 if (fas->f_state == STATE_FREE) { 2899 (void) fas_istart(fas); 2900 } 2901 2902 exit: 2903 fas_check_ncmds(fas); 2904 ASSERT(mutex_owned(FAS_MUTEX(fas))); 2905 TRACE_0(TR_FAC_SCSI_FAS, TR__FAS_START_END, "fas_accept_pkt_end"); 2906 return (rval); 2907 } 2908 2909 /* 2910 * allocate a tag byte and check for tag aging 2911 */ 2912 static char fas_tag_lookup[] = 2913 {0, MSG_HEAD_QTAG, MSG_ORDERED_QTAG, 0, MSG_SIMPLE_QTAG}; 2914 2915 static int 2916 fas_alloc_tag(struct fas *fas, struct fas_cmd *sp) 2917 { 2918 struct f_slots *tag_slots; 2919 int tag; 2920 short slot = sp->cmd_slot; 2921 2922 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_ALLOC_TAG_START, "fas_alloc_tag_start"); 2923 ASSERT(mutex_owned(FAS_MUTEX(fas))); 2924 2925 tag_slots = fas->f_active[slot]; 2926 ASSERT(tag_slots->f_n_slots == NTAGS); 2927 2928 alloc_tag: 2929 tag = (fas->f_active[slot]->f_tags)++; 2930 if (fas->f_active[slot]->f_tags >= NTAGS) { 2931 /* 2932 * we reserve tag 0 for non-tagged cmds 2933 */ 2934 fas->f_active[slot]->f_tags = 1; 2935 } 2936 EPRINTF1("tagged cmd, tag = %d\n", tag); 2937 2938 /* Validate tag, should never fail. */ 2939 if (tag_slots->f_slot[tag] == 0) { 2940 /* 2941 * Store assigned tag and tag queue type. 2942 * Note, in case of multiple choice, default to simple queue. 2943 */ 2944 ASSERT(tag < NTAGS); 2945 sp->cmd_tag[1] = (uchar_t)tag; 2946 sp->cmd_tag[0] = fas_tag_lookup[((sp->cmd_pkt_flags & 2947 FLAG_TAGMASK) >> 12)]; 2948 EPRINTF1("tag= %d\n", tag); 2949 tag_slots->f_slot[tag] = sp; 2950 (fas->f_tcmds[slot])++; 2951 ASSERT(mutex_owned(FAS_MUTEX(fas))); 2952 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_ALLOC_TAG_END, 2953 "fas_alloc_tag_end"); 2954 return (0); 2955 2956 } else { 2957 int age, i; 2958 2959 /* 2960 * Check tag age. If timeouts enabled and 2961 * tag age greater than 1, print warning msg. 2962 * If timeouts enabled and tag age greater than 2963 * age limit, begin draining tag que to check for 2964 * lost tag cmd. 2965 */ 2966 age = tag_slots->f_slot[tag]->cmd_age++; 2967 if (age >= fas->f_scsi_tag_age_limit && 2968 tag_slots->f_slot[tag]->cmd_pkt->pkt_time) { 2969 IPRINTF2("tag %d in use, age= %d\n", tag, age); 2970 DPRINTF("draining tag queue\n"); 2971 if (fas->f_reset_delay[Tgt(sp)] == 0) { 2972 fas->f_throttle[slot] = DRAIN_THROTTLE; 2973 } 2974 } 2975 2976 /* If tag in use, scan until a free one is found. */ 2977 for (i = 1; i < NTAGS; i++) { 2978 tag = fas->f_active[slot]->f_tags; 2979 if (!tag_slots->f_slot[tag]) { 2980 EPRINTF1("found free tag %d\n", tag); 2981 break; 2982 } 2983 if (++(fas->f_active[slot]->f_tags) >= NTAGS) { 2984 /* 2985 * we reserve tag 0 for non-tagged cmds 2986 */ 2987 fas->f_active[slot]->f_tags = 1; 2988 } 2989 EPRINTF1("found in use tag %d\n", tag); 2990 } 2991 2992 /* 2993 * If no free tags, we're in serious trouble. 2994 * the target driver submitted more than 255 2995 * requests 2996 */ 2997 if (tag_slots->f_slot[tag]) { 2998 IPRINTF1("slot %x: All tags in use!!!\n", slot); 2999 goto fail; 3000 } 3001 goto alloc_tag; 3002 } 3003 3004 fail: 3005 fas_head_of_readyQ(fas, sp); 3006 3007 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_ALLOC_TAG_END, 3008 "fas_alloc_tag_end"); 3009 return (-1); 3010 } 3011 3012 /* 3013 * Internal Search Routine. 3014 * 3015 * Search for a command to start. 3016 */ 3017 static int 3018 fas_istart(struct fas *fas) 3019 { 3020 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_ISTART_START, 3021 "fas_istart_start"); 3022 EPRINTF("fas_istart:\n"); 3023 3024 if (fas->f_state == STATE_FREE && fas->f_ncmds > fas->f_ndisc) { 3025 (void) fas_ustart(fas); 3026 } 3027 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_ISTART_END, 3028 "fas_istart_end"); 3029 return (ACTION_RETURN); 3030 } 3031 3032 static int 3033 fas_ustart(struct fas *fas) 3034 { 3035 struct fas_cmd *sp; 3036 short slot = fas->f_next_slot; 3037 short start_slot = slot; 3038 short dslot = fas->f_dslot; 3039 3040 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_USTART_START, "fas_ustart_start"); 3041 EPRINTF1("fas_ustart: start_slot=%x\n", fas->f_next_slot); 3042 ASSERT(fas->f_current_sp == NULL); 3043 ASSERT(dslot != 0); 3044 if (dslot == NLUNS_PER_TARGET) { 3045 ASSERT((slot % NLUNS_PER_TARGET) == 0); 3046 } 3047 3048 /* 3049 * if readyQ not empty and we are not draining, then we 3050 * can start another cmd 3051 */ 3052 do { 3053 /* 3054 * If all cmds drained from tag Q, back to full throttle and 3055 * start queueing up new cmds again. 3056 */ 3057 if (fas->f_throttle[slot] == DRAIN_THROTTLE && 3058 fas->f_tcmds[slot] == 0) { 3059 fas_full_throttle(fas, slot); 3060 } 3061 3062 if (fas->f_readyf[slot] && 3063 (fas->f_throttle[slot] > fas->f_tcmds[slot])) { 3064 sp = fas->f_readyf[slot]; 3065 fas->f_readyf[slot] = sp->cmd_forw; 3066 if (sp->cmd_forw == NULL) { 3067 fas->f_readyb[slot] = NULL; 3068 } 3069 fas->f_next_slot = NEXTSLOT(slot, dslot); 3070 ASSERT((sp->cmd_pkt_flags & FLAG_NOINTR) == 0); 3071 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_USTART_END, 3072 "fas_ustart_end"); 3073 return (fas_startcmd(fas, sp)); 3074 } else { 3075 slot = NEXTSLOT(slot, dslot); 3076 } 3077 } while (slot != start_slot); 3078 3079 EPRINTF("fas_ustart: no cmds to start\n"); 3080 fas->f_next_slot = NEXTSLOT(slot, dslot); 3081 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_USTART_NOT_FOUND_END, 3082 "fas_ustart_end (not_found)"); 3083 return (FALSE); 3084 } 3085 3086 /* 3087 * Start a command off 3088 */ 3089 static int 3090 fas_startcmd(struct fas *fas, struct fas_cmd *sp) 3091 { 3092 volatile struct fasreg *fasreg = fas->f_reg; 3093 ushort_t nstate; 3094 uchar_t cmd, target, lun; 3095 ushort_t tshift; 3096 volatile uchar_t *tp = fas->f_cmdarea; 3097 struct scsi_pkt *pkt = CMD2PKT(sp); 3098 int slot = sp->cmd_slot; 3099 struct f_slots *slots = fas->f_active[slot]; 3100 int i, cdb_len; 3101 3102 #define LOAD_CMDP *(tp++) 3103 3104 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_STARTCMD_START, "fas_startcmd_start"); 3105 3106 EPRINTF2("fas_startcmd: sp=0x%p flags=%x\n", 3107 (void *)sp, sp->cmd_pkt_flags); 3108 ASSERT((sp->cmd_flags & CFLAG_FREE) == 0); 3109 ASSERT((sp->cmd_flags & CFLAG_COMPLETED) == 0); 3110 ASSERT(fas->f_current_sp == NULL && fas->f_state == STATE_FREE); 3111 if ((sp->cmd_pkt_flags & FLAG_NOINTR) == 0) { 3112 ASSERT(fas->f_throttle[slot] > 0); 3113 ASSERT(fas->f_reset_delay[Tgt(sp)] == 0); 3114 } 3115 3116 target = Tgt(sp); 3117 lun = Lun(sp); 3118 3119 /* 3120 * if a non-tagged cmd is submitted to an active tagged target 3121 * then drain before submitting this cmd; SCSI-2 allows RQSENSE 3122 * to be untagged 3123 */ 3124 if (((sp->cmd_pkt_flags & FLAG_TAGMASK) == 0) && 3125 TAGGED(target) && fas->f_tcmds[slot] && 3126 ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) && 3127 (*(sp->cmd_pkt->pkt_cdbp) != SCMD_REQUEST_SENSE)) { 3128 if ((sp->cmd_pkt_flags & FLAG_NOINTR) == 0) { 3129 struct fas_cmd *dp; 3130 3131 IPRINTF("untagged cmd, start draining\n"); 3132 3133 if (fas->f_reset_delay[Tgt(sp)] == 0) { 3134 fas->f_throttle[slot] = DRAIN_THROTTLE; 3135 } 3136 dp = fas->f_readyf[slot]; 3137 fas->f_readyf[slot] = sp; 3138 sp->cmd_forw = dp; 3139 if (fas->f_readyb[slot] == NULL) { 3140 fas->f_readyb[slot] = sp; 3141 } 3142 } 3143 return (FALSE); 3144 } 3145 3146 /* 3147 * allocate a tag; if no tag available then put request back 3148 * on the ready queue and return; eventually a cmd returns and we 3149 * get going again or we timeout 3150 */ 3151 if (TAGGED(target) && (sp->cmd_pkt_flags & FLAG_TAGMASK)) { 3152 if (fas_alloc_tag(fas, sp)) { 3153 return (FALSE); 3154 } 3155 } else { 3156 /* 3157 * tag slot 0 is reserved for non-tagged cmds 3158 * and should be empty because we have drained 3159 */ 3160 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 3161 ASSERT(fas->f_active[slot]->f_slot[0] == NULL); 3162 fas->f_active[slot]->f_slot[0] = sp; 3163 sp->cmd_tag[1] = 0; 3164 if (*(sp->cmd_pkt->pkt_cdbp) != SCMD_REQUEST_SENSE) { 3165 ASSERT(fas->f_tcmds[slot] == 0); 3166 /* 3167 * don't start any other cmd until this 3168 * one is finished. The throttle is reset 3169 * later in fas_watch() 3170 */ 3171 fas->f_throttle[slot] = 1; 3172 } 3173 (fas->f_tcmds[slot])++; 3174 3175 } 3176 } 3177 3178 fas->f_current_sp = sp; 3179 fas->f_omsglen = 0; 3180 tshift = 1<<target; 3181 fas->f_sdtr_sent = fas->f_wdtr_sent = 0; 3182 cdb_len = sp->cmd_actual_cdblen; 3183 3184 if (sp->cmd_pkt_flags & FLAG_RENEGOTIATE_WIDE_SYNC) { 3185 fas_force_renegotiation(fas, Tgt(sp)); 3186 } 3187 3188 /* 3189 * first send identify message, with or without disconnect priv. 3190 */ 3191 if (sp->cmd_pkt_flags & FLAG_NODISCON) { 3192 LOAD_CMDP = fas->f_last_msgout = MSG_IDENTIFY | lun; 3193 ASSERT((sp->cmd_pkt_flags & FLAG_TAGMASK) == 0); 3194 } else { 3195 LOAD_CMDP = fas->f_last_msgout = MSG_DR_IDENTIFY | lun; 3196 } 3197 3198 /* 3199 * normal case, tagQ and we have negotiated wide and sync 3200 * or we don't need to renegotiate because wide and sync 3201 * have been disabled 3202 * (proxy msg's don't have tag flag set) 3203 */ 3204 if ((sp->cmd_pkt_flags & FLAG_TAGMASK) && 3205 ((fas->f_wide_known | fas->f_nowide) & 3206 (fas->f_sync_known | fas->f_nosync) & tshift)) { 3207 3208 EPRINTF("tag cmd\n"); 3209 ASSERT((sp->cmd_pkt_flags & FLAG_NODISCON) == 0); 3210 3211 fas->f_last_msgout = LOAD_CMDP = sp->cmd_tag[0]; 3212 LOAD_CMDP = sp->cmd_tag[1]; 3213 3214 nstate = STATE_SELECT_NORMAL; 3215 cmd = CMD_SEL_ATN3 | CMD_DMA; 3216 3217 /* 3218 * is this a proxy message 3219 */ 3220 } else if (sp->cmd_flags & CFLAG_CMDPROXY) { 3221 3222 IPRINTF2("proxy cmd, len=%x, msg=%x\n", 3223 sp->cmd_cdb[FAS_PROXY_DATA], 3224 sp->cmd_cdb[FAS_PROXY_DATA+1]); 3225 /* 3226 * This is a proxy command. It will have 3227 * a message to send as part of post-selection 3228 * (e.g, MSG_ABORT or MSG_DEVICE_RESET) 3229 */ 3230 fas->f_omsglen = sp->cmd_cdb[FAS_PROXY_DATA]; 3231 for (i = 0; i < (uint_t)fas->f_omsglen; i++) { 3232 fas->f_cur_msgout[i] = 3233 sp->cmd_cdb[FAS_PROXY_DATA+1+i]; 3234 } 3235 sp->cmd_cdb[FAS_PROXY_RESULT] = FALSE; 3236 cdb_len = 0; 3237 cmd = CMD_SEL_STOP | CMD_DMA; 3238 nstate = STATE_SELECT_N_SENDMSG; 3239 3240 /* 3241 * always negotiate wide first and sync after wide 3242 */ 3243 } else if (((fas->f_wide_known | fas->f_nowide) & tshift) == 0) { 3244 int i = 0; 3245 3246 /* First the tag message bytes */ 3247 if (sp->cmd_pkt_flags & FLAG_TAGMASK) { 3248 fas->f_cur_msgout[i++] = sp->cmd_tag[0]; 3249 fas->f_cur_msgout[i++] = sp->cmd_tag[1]; 3250 } 3251 3252 /* 3253 * Set up to send wide negotiating message. This is getting 3254 * a bit tricky as we dma out the identify message and 3255 * send the other messages via the fifo buffer. 3256 */ 3257 EPRINTF1("cmd with wdtr msg, tag=%x\n", sp->cmd_tag[1]); 3258 3259 fas_make_wdtr(fas, i, target, FAS_XFER_WIDTH); 3260 3261 cdb_len = 0; 3262 nstate = STATE_SELECT_N_SENDMSG; 3263 cmd = CMD_SEL_STOP | CMD_DMA; 3264 3265 /* 3266 * negotiate sync xfer rate 3267 */ 3268 } else if (((fas->f_sync_known | fas->f_nosync) & tshift) == 0) { 3269 int i = 0; 3270 /* 3271 * Set up to send sync negotiating message. This is getting 3272 * a bit tricky as we dma out the identify message and 3273 * send the other messages via the fifo buffer. 3274 */ 3275 if (sp->cmd_pkt_flags & FLAG_TAGMASK) { 3276 fas->f_cur_msgout[i++] = sp->cmd_tag[0]; 3277 fas->f_cur_msgout[i++] = sp->cmd_tag[1]; 3278 } 3279 3280 fas_make_sdtr(fas, i, target); 3281 3282 cdb_len = 0; 3283 cmd = CMD_SEL_STOP | CMD_DMA; 3284 nstate = STATE_SELECT_N_SENDMSG; 3285 3286 /* 3287 * normal cmds, no negotiations and not a proxy and no TQ 3288 */ 3289 } else { 3290 3291 ASSERT((sp->cmd_pkt_flags & FLAG_TAGMASK) == 0); 3292 EPRINTF("std. cmd\n"); 3293 3294 nstate = STATE_SELECT_NORMAL; 3295 cmd = CMD_SEL_ATN | CMD_DMA; 3296 } 3297 3298 /* 3299 * Now load cdb (if any) 3300 */ 3301 for (i = 0; i < cdb_len; i++) { 3302 LOAD_CMDP = sp->cmd_cdbp[i]; 3303 } 3304 3305 /* 3306 * calculate total dma amount: 3307 */ 3308 fas->f_lastcount = (uintptr_t)tp - (uintptr_t)fas->f_cmdarea; 3309 3310 /* 3311 * load target id and enable bus id encoding and 32 bit counter 3312 */ 3313 fas_reg_write(fas, (uchar_t *)&fasreg->fas_busid, 3314 (target & 0xf) | FAS_BUSID_ENCODID | FAS_BUSID_32BIT_COUNTER); 3315 3316 FAS_SET_PERIOD_OFFSET_CONF3_REGS(fas, target); 3317 3318 fas_reg_cmd_write(fas, CMD_FLUSH); 3319 3320 FAS_DMA_READ(fas, fas->f_lastcount, 3321 fas->f_dmacookie.dmac_address, 16, cmd); 3322 3323 New_state(fas, (int)nstate); 3324 3325 #ifdef FASDEBUG 3326 if (DDEBUGGING) { 3327 fas_dump_cmd(fas, sp); 3328 } 3329 #endif /* FASDEBUG */ 3330 3331 /* 3332 * if timeout == 0, then it has no effect on the timeout 3333 * handling; we deal with this when an actual timeout occurs. 3334 */ 3335 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 3336 ASSERT(fas->f_tcmds[slot] >= 1); 3337 } 3338 i = pkt->pkt_time - slots->f_timebase; 3339 3340 if (i == 0) { 3341 EPRINTF("dup timeout\n"); 3342 (slots->f_dups)++; 3343 slots->f_timeout = slots->f_timebase; 3344 } else if (i > 0) { 3345 EPRINTF("new timeout\n"); 3346 slots->f_timeout = slots->f_timebase = pkt->pkt_time; 3347 slots->f_dups = 1; 3348 } 3349 3350 fas_check_ncmds(fas); 3351 3352 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_STARTCMD_END, "fas_startcmd_end"); 3353 3354 return (TRUE); 3355 } 3356 3357 /* 3358 * Interrupt Entry Point. 3359 * Poll interrupts until they go away 3360 */ 3361 static uint_t 3362 fas_intr(caddr_t arg) 3363 { 3364 struct fas *fas = (struct fas *)arg; 3365 int rval = DDI_INTR_UNCLAIMED; 3366 int kstat_updated = 0; 3367 3368 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_POLL_START, "fas_intr_start"); 3369 3370 do { 3371 mutex_enter(FAS_MUTEX(fas)); 3372 3373 do { 3374 if (fas_intr_svc(fas)) { 3375 /* 3376 * do not return immediately here because 3377 * we have to guarantee to always empty 3378 * the waitQ and callbackQ in the interrupt 3379 * handler 3380 */ 3381 if (fas->f_polled_intr) { 3382 rval = DDI_INTR_CLAIMED; 3383 fas->f_polled_intr = 0; 3384 } 3385 } else { 3386 rval = DDI_INTR_CLAIMED; 3387 } 3388 } while (INTPENDING(fas)); 3389 3390 if (!kstat_updated && fas->f_intr_kstat && 3391 rval == DDI_INTR_CLAIMED) { 3392 FAS_KSTAT_INTR(fas); 3393 kstat_updated++; 3394 } 3395 3396 /* 3397 * check and empty the waitQ and the callbackQ 3398 */ 3399 FAS_CHECK_WAITQ_AND_FAS_MUTEX_EXIT(fas); 3400 FAS_EMPTY_CALLBACKQ(fas); 3401 3402 } while (INTPENDING(fas)); 3403 3404 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_POLL_END, "fas_intr_end"); 3405 3406 return (rval); 3407 } 3408 3409 /* 3410 * General interrupt service routine. 3411 */ 3412 static char *dma_bits = DMA_BITS; 3413 3414 static int 3415 fas_intr_svc(struct fas *fas) 3416 { 3417 static int (*evec[])(struct fas *fas) = { 3418 fas_finish_select, 3419 fas_reconnect, 3420 fas_phasemanage, 3421 fas_finish, 3422 fas_reset_recovery, 3423 fas_istart, 3424 fas_abort_curcmd, 3425 fas_reset_bus, 3426 fas_reset_bus, 3427 fas_handle_selection 3428 }; 3429 int action; 3430 uchar_t intr, stat; 3431 volatile struct fasreg *fasreg = fas->f_reg; 3432 int i = 0; 3433 3434 TRACE_0(TR_FAC_SCSI_FAS, TR_FASSVC_START, "fas_intr_svc_start"); 3435 3436 /* 3437 * A read of FAS interrupt register clears interrupt, 3438 * so any other volatile information needs to be latched 3439 * up prior to reading the interrupt register. 3440 */ 3441 fas->f_stat = fas_reg_read(fas, &fasreg->fas_stat); 3442 3443 EPRINTF2("fas_intr_svc: state=%x stat=%x\n", fas->f_state, 3444 fas->f_stat); 3445 3446 /* 3447 * this wasn't our interrupt? 3448 */ 3449 if ((fas->f_stat & FAS_STAT_IPEND) == 0) { 3450 if (fas_check_dma_error(fas)) { 3451 action = ACTION_RESET; 3452 goto start_action; 3453 } 3454 return (-1); 3455 } 3456 3457 /* 3458 * if we are reset state, handle this first 3459 */ 3460 if (fas->f_state == ACTS_RESET) { 3461 action = ACTION_FINRST; 3462 goto start_action; 3463 } 3464 3465 /* 3466 * check for gross error. fas366 hardware seems to register 3467 * the gross error bit when a parity error is found. Make sure 3468 * to ignore the gross error bit when a parity error is detected. 3469 */ 3470 if ((fas->f_stat & FAS_STAT_GERR) && 3471 (fas->f_stat & FAS_STAT_PERR) == 0) { 3472 action = fas_handle_gross_err(fas); 3473 goto start_action; 3474 } 3475 3476 /* 3477 * now it is finally safe to read the interrupt register 3478 * if we haven't done so yet 3479 * Note: we don't read step register here but only in 3480 * fas_finish_select(). It is not entirely safe but saves 3481 * redundant PIOs or extra code in this critical path 3482 */ 3483 fas->f_intr = 3484 intr = fas_reg_read(fas, (uchar_t *)&fasreg->fas_intr); 3485 3486 /* 3487 * read the fifo if there is something there or still in the 3488 * input shuttle 3489 */ 3490 stat = fas->f_stat & FAS_PHASE_MASK; 3491 3492 if ((intr & FAS_INT_RESEL) || 3493 ((stat != FAS_PHASE_DATA_IN) && (stat != FAS_PHASE_DATA_OUT) && 3494 ((fas->f_state & STATE_SELECTING) == 0) && 3495 (fas->f_state != ACTS_DATA_DONE) && 3496 (fas->f_state != ACTS_C_CMPLT))) { 3497 3498 fas->f_stat2 = fas_reg_read(fas, &fasreg->fas_stat2); 3499 3500 if (((fas->f_stat2 & FAS_STAT2_EMPTY) == 0) || 3501 (fas->f_stat2 & FAS_STAT2_ISHUTTLE)) { 3502 fas_read_fifo(fas); 3503 } 3504 } 3505 3506 EPRINTF2("fas_intr_svc: intr=%x, stat=%x\n", fas->f_intr, fas->f_stat); 3507 EPRINTF2("dmacsr=%b\n", fas->f_dma->dma_csr, dma_bits); 3508 3509 /* 3510 * Based upon the current state of the host adapter driver 3511 * we should be able to figure out what to do with an interrupt. 3512 * 3513 * The FAS asserts an interrupt with one or more of 8 possible 3514 * bits set in its interrupt register. These conditions are 3515 * SCSI bus reset detected, an illegal command fed to the FAS, 3516 * one of DISCONNECT, BUS SERVICE, FUNCTION COMPLETE conditions 3517 * for the FAS, a Reselection interrupt, or one of Selection 3518 * or Selection with Attention. 3519 * 3520 * Of these possible interrupts, we can deal with some right 3521 * here and now, irrespective of the current state of the driver. 3522 * 3523 * take care of the most likely interrupts first and call the action 3524 * immediately 3525 */ 3526 if ((intr & (FAS_INT_RESET|FAS_INT_ILLEGAL|FAS_INT_SEL|FAS_INT_SELATN| 3527 FAS_INT_RESEL)) == 0) { 3528 /* 3529 * The rest of the reasons for an interrupt can 3530 * be handled based purely on the state that the driver 3531 * is currently in now. 3532 */ 3533 if (fas->f_state & STATE_SELECTING) { 3534 action = fas_finish_select(fas); 3535 3536 } else if (fas->f_state & STATE_ITPHASES) { 3537 action = fas_phasemanage(fas); 3538 3539 } else { 3540 fas_log(fas, CE_WARN, "spurious interrupt"); 3541 action = ACTION_RETURN; 3542 } 3543 3544 } else if ((intr & FAS_INT_RESEL) && ((intr & 3545 (FAS_INT_RESET|FAS_INT_ILLEGAL|FAS_INT_SEL|FAS_INT_SELATN)) == 0)) { 3546 3547 if ((fas->f_state & STATE_SELECTING) == 0) { 3548 ASSERT(fas->f_state == STATE_FREE); 3549 action = fas_reconnect(fas); 3550 } else { 3551 action = fas_reselect_preempt(fas); 3552 } 3553 3554 } else if (intr & (FAS_INT_RESET | FAS_INT_ILLEGAL)) { 3555 action = fas_illegal_cmd_or_bus_reset(fas); 3556 3557 } else if (intr & (FAS_INT_SEL|FAS_INT_SELATN)) { 3558 action = ACTION_SELECT; 3559 } 3560 3561 start_action: 3562 while (action != ACTION_RETURN) { 3563 ASSERT((action >= 0) && (action <= ACTION_SELECT)); 3564 TRACE_3(TR_FAC_SCSI_FAS, TR_FASSVC_ACTION_CALL, 3565 "fas_intr_svc call: fas 0x%p, action %d (%d)", 3566 fas, action, i); 3567 i++; 3568 action = (*evec[action])(fas); 3569 } 3570 exit: 3571 TRACE_0(TR_FAC_SCSI_FAS, TR_FASSVC_END, "fas_intr_svc_end"); 3572 3573 return (0); 3574 } 3575 3576 /* 3577 * Manage phase transitions. 3578 */ 3579 static int 3580 fas_phasemanage(struct fas *fas) 3581 { 3582 ushort_t state; 3583 int action; 3584 static int (*pvecs[])(struct fas *fas) = { 3585 fas_handle_cmd_start, 3586 fas_handle_cmd_done, 3587 fas_handle_msg_out_start, 3588 fas_handle_msg_out_done, 3589 fas_handle_msg_in_start, 3590 fas_handle_more_msgin, 3591 fas_handle_msg_in_done, 3592 fas_handle_clearing, 3593 fas_handle_data_start, 3594 fas_handle_data_done, 3595 fas_handle_c_cmplt, 3596 fas_reconnect, 3597 fas_handle_unknown, 3598 fas_reset_recovery 3599 }; 3600 int i = 0; 3601 3602 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_PHASEMANAGE_START, 3603 "fas_phasemanage_start"); 3604 3605 do { 3606 EPRINTF1("fas_phasemanage: %s\n", 3607 fas_state_name(fas->f_state & STATE_ITPHASES)); 3608 3609 TRACE_2(TR_FAC_SCSI_FAS, TR_FAS_PHASEMANAGE_CALL, 3610 "fas_phasemanage_call: fas 0x%p (%d)", fas, i++); 3611 3612 state = fas->f_state; 3613 3614 if (!(state == STATE_FREE || state > ACTS_ENDVEC)) { 3615 ASSERT(pvecs[state-1] != NULL); 3616 action = (*pvecs[state-1]) (fas); 3617 } else { 3618 fas_log(fas, CE_WARN, "lost state in phasemanage"); 3619 action = ACTION_ABORT_ALLCMDS; 3620 } 3621 3622 } while (action == ACTION_PHASEMANAGE); 3623 3624 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_PHASEMANAGE_END, 3625 "fas_phasemanage_end"); 3626 return (action); 3627 } 3628 3629 /* 3630 * remove a cmd from active list and if timeout flag is set, then 3631 * adjust timeouts; if a the same cmd will be resubmitted soon, don't 3632 * bother to adjust timeouts (ie. don't set this flag) 3633 */ 3634 static void 3635 fas_remove_cmd(struct fas *fas, struct fas_cmd *sp, int new_timeout_flag) 3636 { 3637 int tag = sp->cmd_tag[1]; 3638 int slot = sp->cmd_slot; 3639 struct f_slots *tag_slots = fas->f_active[slot]; 3640 3641 ASSERT(sp != NULL); 3642 EPRINTF4("remove tag %d slot %d for target %d.%d\n", 3643 tag, slot, Tgt(sp), Lun(sp)); 3644 3645 if (sp == tag_slots->f_slot[tag]) { 3646 tag_slots->f_slot[tag] = NULL; 3647 fas->f_tcmds[slot]--; 3648 } 3649 if (fas->f_current_sp == sp) { 3650 fas->f_current_sp = NULL; 3651 } 3652 3653 ASSERT(sp != fas->f_active[sp->cmd_slot]->f_slot[sp->cmd_tag[1]]); 3654 3655 if (new_timeout_flag != NEW_TIMEOUT) { 3656 return; 3657 } 3658 3659 /* 3660 * Figure out what to set tag Q timeout for... 3661 * 3662 * Optimize: If we have duplicate's of same timeout 3663 * we're using, then we'll use it again until we run 3664 * out of duplicates. This should be the normal case 3665 * for block and raw I/O. 3666 * If no duplicates, we have to scan through tag que and 3667 * find the longest timeout value and use it. This is 3668 * going to take a while... 3669 */ 3670 if (sp->cmd_pkt->pkt_time == tag_slots->f_timebase) { 3671 if (--(tag_slots->f_dups) <= 0) { 3672 if (fas->f_tcmds[slot]) { 3673 struct fas_cmd *ssp; 3674 uint_t n = 0; 3675 ushort_t t = tag_slots->f_n_slots; 3676 ushort_t i; 3677 /* 3678 * This crude check assumes we don't do 3679 * this too often which seems reasonable 3680 * for block and raw I/O. 3681 */ 3682 for (i = 0; i < t; i++) { 3683 ssp = tag_slots->f_slot[i]; 3684 if (ssp && 3685 (ssp->cmd_pkt->pkt_time > n)) { 3686 n = ssp->cmd_pkt->pkt_time; 3687 tag_slots->f_dups = 1; 3688 } else if (ssp && 3689 (ssp->cmd_pkt->pkt_time == n)) { 3690 tag_slots->f_dups++; 3691 } 3692 } 3693 tag_slots->f_timebase = n; 3694 EPRINTF1("searching, new_timeout= %d\n", n); 3695 } else { 3696 tag_slots->f_dups = 0; 3697 tag_slots->f_timebase = 0; 3698 } 3699 } 3700 } 3701 tag_slots->f_timeout = tag_slots->f_timebase; 3702 3703 ASSERT(fas->f_ncmds >= fas->f_ndisc); 3704 } 3705 3706 /* 3707 * decrement f_ncmds and f_ndisc for this cmd before completing 3708 */ 3709 static void 3710 fas_decrement_ncmds(struct fas *fas, struct fas_cmd *sp) 3711 { 3712 ASSERT((sp->cmd_flags & CFLAG_FREE) == 0); 3713 if ((sp->cmd_flags & CFLAG_FINISHED) == 0) { 3714 fas->f_ncmds--; 3715 if (sp->cmd_flags & CFLAG_CMDDISC) { 3716 fas->f_ndisc--; 3717 } 3718 sp->cmd_flags |= CFLAG_FINISHED; 3719 sp->cmd_flags &= ~CFLAG_CMDDISC; 3720 } 3721 ASSERT((fas->f_ncmds >= 0) && (fas->f_ndisc >= 0)); 3722 ASSERT(fas->f_ncmds >= fas->f_ndisc); 3723 } 3724 3725 /* 3726 * Most commonly called phase handlers: 3727 * 3728 * Finish routines 3729 */ 3730 static int 3731 fas_finish(struct fas *fas) 3732 { 3733 struct fas_cmd *sp = fas->f_current_sp; 3734 struct scsi_pkt *pkt = CMD2PKT(sp); 3735 int action = ACTION_SEARCH; 3736 struct scsi_status *status = 3737 (struct scsi_status *)sp->cmd_pkt->pkt_scbp; 3738 3739 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_START, 3740 "fas_finish_start"); 3741 EPRINTF("fas_finish\n"); 3742 3743 #ifdef FAS_TEST 3744 if (fas_test_stop && (sp->cmd_pkt_flags & 0x80000000)) { 3745 debug_enter("untagged cmd completed"); 3746 } 3747 #endif 3748 3749 /* 3750 * immediately enable reselects 3751 */ 3752 fas_reg_cmd_write(fas, CMD_EN_RESEL); 3753 if (status->sts_chk) { 3754 /* 3755 * In the case that we are getting a check condition 3756 * clear our knowledge of synchronous capabilities. 3757 * This will unambiguously force a renegotiation 3758 * prior to any possible data transfer (we hope), 3759 * including the data transfer for a UNIT ATTENTION 3760 * condition generated by somebody powering on and 3761 * off a target. 3762 */ 3763 fas_force_renegotiation(fas, Tgt(sp)); 3764 } 3765 3766 /* 3767 * backoff sync/wide if there were parity errors 3768 */ 3769 if (sp->cmd_pkt->pkt_statistics & STAT_PERR) { 3770 fas_sync_wide_backoff(fas, sp, sp->cmd_slot); 3771 #ifdef FAS_TEST 3772 if (fas_test_stop) { 3773 debug_enter("parity error"); 3774 } 3775 #endif 3776 } 3777 3778 /* 3779 * Free from active list and update counts 3780 * We need to clean up this cmd now, just in case fas_ustart() 3781 * hits a reset or other fatal transport error 3782 */ 3783 fas_check_ncmds(fas); 3784 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 3785 fas_decrement_ncmds(fas, sp); 3786 fas_check_ncmds(fas); 3787 3788 /* 3789 * go to state free and try to start a new cmd now 3790 */ 3791 New_state(fas, STATE_FREE); 3792 3793 if ((fas->f_ncmds > fas->f_ndisc) && (*((char *)status) == 0) && 3794 (INTPENDING(fas) == 0)) { 3795 if (fas_ustart(fas)) { 3796 action = ACTION_RETURN; 3797 } 3798 } 3799 3800 /* 3801 * if there was a data xfer then calculate residue and 3802 * sync data for consistent memory xfers 3803 */ 3804 if (pkt->pkt_state & STATE_XFERRED_DATA) { 3805 pkt->pkt_resid = sp->cmd_dmacount - sp->cmd_data_count; 3806 if (sp->cmd_flags & CFLAG_CMDIOPB) { 3807 (void) ddi_dma_sync(sp->cmd_dmahandle, 0, (uint_t)0, 3808 DDI_DMA_SYNC_FORCPU); 3809 } 3810 if (pkt->pkt_resid) { 3811 IPRINTF3("%d.%d finishes with %ld resid\n", 3812 Tgt(sp), Lun(sp), pkt->pkt_resid); 3813 } 3814 } 3815 3816 if (sp->cmd_pkt_flags & FLAG_NOINTR) { 3817 fas_call_pkt_comp(fas, sp); 3818 action = ACTION_RETURN; 3819 } else { 3820 /* 3821 * start an autorequest sense if there was a check condition. 3822 * if arq has not been enabled, fas_handle_sts_chk will do 3823 * do the callback 3824 */ 3825 if (status->sts_chk) { 3826 if (fas_handle_sts_chk(fas, sp)) { 3827 /* 3828 * we can't start an arq because one is 3829 * already in progress. the target is 3830 * probably confused 3831 */ 3832 action = ACTION_ABORT_CURCMD; 3833 } 3834 } else if ((*((char *)status) & STATUS_MASK) == 3835 STATUS_QFULL) { 3836 fas_handle_qfull(fas, sp); 3837 } else { 3838 #ifdef FAS_TEST 3839 if (fas_arqs_failure && (status->sts_chk == 0)) { 3840 struct scsi_arq_status *arqstat; 3841 status->sts_chk = 1; 3842 arqstat = (struct scsi_arq_status *) 3843 (sp->cmd_pkt->pkt_scbp); 3844 arqstat->sts_rqpkt_reason = CMD_TRAN_ERR; 3845 sp->cmd_pkt->pkt_state |= STATE_ARQ_DONE; 3846 fas_arqs_failure = 0; 3847 } 3848 if (fas_tran_err) { 3849 sp->cmd_pkt->pkt_reason = CMD_TRAN_ERR; 3850 fas_tran_err = 0; 3851 } 3852 #endif 3853 fas_call_pkt_comp(fas, sp); 3854 } 3855 } 3856 3857 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_END, "fas_finish_end"); 3858 return (action); 3859 } 3860 3861 /* 3862 * Complete the process of selecting a target 3863 */ 3864 static int 3865 fas_finish_select(struct fas *fas) 3866 { 3867 volatile struct dma *dmar = fas->f_dma; 3868 struct fas_cmd *sp = fas->f_current_sp; 3869 uchar_t intr = fas->f_intr; 3870 uchar_t step; 3871 3872 step = fas_reg_read(fas, &fas->f_reg->fas_step) & FAS_STEP_MASK; 3873 3874 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_SELECT_START, 3875 "fas_finish_select_start"); 3876 EPRINTF("fas_finish_select:\n"); 3877 ASSERT(sp != 0); 3878 3879 /* 3880 * Check for DMA gate array errors 3881 */ 3882 if ((fas->f_dma_csr = fas_dma_reg_read(fas, &dmar->dma_csr)) 3883 & DMA_ERRPEND) { 3884 /* 3885 * It would be desirable to set the ATN* line and attempt to 3886 * do the whole schmear of INITIATOR DETECTED ERROR here, 3887 * but that is too hard to do at present. 3888 */ 3889 fas_log(fas, CE_WARN, 3890 "Unrecoverable DMA error during selection"); 3891 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 3892 3893 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_SELECT_RESET1_END, 3894 "fas_finish_select_end (ACTION_RESET1)"); 3895 return (ACTION_RESET); 3896 } 3897 3898 /* 3899 * Shut off DMA gate array 3900 */ 3901 FAS_FLUSH_DMA(fas); 3902 3903 /* 3904 * Did something respond to selection? 3905 */ 3906 if (intr == (FAS_INT_BUS|FAS_INT_FCMP)) { 3907 /* 3908 * We succesfully selected a target (we think). 3909 * Now we figure out how botched things are 3910 * based upon the kind of selection we were 3911 * doing and the state of the step register. 3912 */ 3913 switch (step) { 3914 case FAS_STEP_ARBSEL: 3915 /* 3916 * In this case, we selected the target, but went 3917 * neither into MESSAGE OUT nor COMMAND phase. 3918 * However, this isn't a fatal error, so we just 3919 * drive on. 3920 * 3921 * This might be a good point to note that we have 3922 * a target that appears to not accomodate 3923 * disconnecting, 3924 * but it really isn't worth the effort to distinguish 3925 * such targets fasecially from others. 3926 */ 3927 /* FALLTHROUGH */ 3928 3929 case FAS_STEP_SENTID: 3930 /* 3931 * In this case, we selected the target and sent 3932 * message byte and have stopped with ATN* still on. 3933 * This case should only occur if we use the SELECT 3934 * AND STOP command. 3935 */ 3936 /* FALLTHROUGH */ 3937 3938 case FAS_STEP_NOTCMD: 3939 /* 3940 * In this case, we either didn't transition to command 3941 * phase, or, 3942 * if we were using the SELECT WITH ATN3 command, 3943 * we possibly didn't send all message bytes. 3944 */ 3945 break; 3946 3947 case FAS_STEP_PCMD: 3948 /* 3949 * In this case, not all command bytes transferred. 3950 */ 3951 /* FALLTHROUGH */ 3952 3953 case FAS_STEP_DONE: 3954 /* 3955 * This is the usual 'good' completion point. 3956 * If we we sent message byte(s), we subtract 3957 * off the number of message bytes that were 3958 * ahead of the command. 3959 */ 3960 sp->cmd_pkt->pkt_state |= STATE_SENT_CMD; 3961 break; 3962 3963 default: 3964 fas_log(fas, CE_WARN, 3965 "bad sequence step (0x%x) in selection", step); 3966 TRACE_0(TR_FAC_SCSI_FAS, 3967 TR_FAS_FINISH_SELECT_RESET3_END, 3968 "fas_finish_select_end (ACTION_RESET3)"); 3969 return (ACTION_RESET); 3970 } 3971 3972 /* 3973 * OR in common state... 3974 */ 3975 sp->cmd_pkt->pkt_state |= (STATE_GOT_BUS|STATE_GOT_TARGET); 3976 3977 /* 3978 * data pointer initialization has already been done 3979 */ 3980 New_state(fas, ACTS_UNKNOWN); 3981 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_SELECT_ACTION3_END, 3982 "fas_finish_select_end (action3)"); 3983 return (fas_handle_unknown(fas)); 3984 3985 } else if (intr == FAS_INT_DISCON) { 3986 /* 3987 * make sure we negotiate when this target comes 3988 * on line later on 3989 */ 3990 fas_force_renegotiation(fas, Tgt(sp)); 3991 3992 fas->f_sdtr_sent = fas->f_wdtr_sent = 0; 3993 sp->cmd_pkt->pkt_state |= STATE_GOT_BUS; 3994 3995 /* 3996 * Set the throttle to DRAIN_THROTTLE to make 3997 * sure any disconnected commands will get timed out 3998 * incase the drive dies 3999 */ 4000 4001 if (fas->f_reset_delay[Tgt(sp)] == 0) { 4002 fas->f_throttle[sp->cmd_slot] = DRAIN_THROTTLE; 4003 } 4004 4005 fas_set_pkt_reason(fas, sp, CMD_INCOMPLETE, 0); 4006 4007 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_SELECT_FINISH_END, 4008 "fas_finish_select_end (ACTION_FINISH)"); 4009 return (ACTION_FINISH); 4010 } else { 4011 fas_printstate(fas, "undetermined selection failure"); 4012 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_FINISH_SELECT_RESET2_END, 4013 "fas_finish_select_end (ACTION_RESET2)"); 4014 return (ACTION_RESET); 4015 } 4016 _NOTE(NOT_REACHED) 4017 /* NOTREACHED */ 4018 } 4019 4020 /* 4021 * a selection got preempted by a reselection; shut down dma 4022 * and put back cmd in the ready queue unless NOINTR 4023 */ 4024 static int 4025 fas_reselect_preempt(struct fas *fas) 4026 { 4027 int rval; 4028 4029 /* 4030 * A reselection attempt glotzed our selection attempt. 4031 * we put request back in the ready queue 4032 */ 4033 struct fas_cmd *sp = fas->f_current_sp; 4034 4035 /* 4036 * Shut off DMA gate array 4037 */ 4038 FAS_FLUSH_DMA(fas); 4039 4040 /* 4041 * service the reconnect now and clean up later 4042 */ 4043 New_state(fas, STATE_FREE); 4044 rval = fas_reconnect(fas); 4045 4046 /* 4047 * If selection for a non-tagged command is preempted, the 4048 * command could be stuck because throttle was set to DRAIN, 4049 * and a disconnected command timeout follows. 4050 */ 4051 if ((sp->cmd_pkt_flags & FLAG_TAGMASK) == 0) 4052 fas->f_throttle[sp->cmd_slot] = 1; 4053 4054 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 4055 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 4056 } 4057 4058 /* 4059 * if we attempted to renegotiate on this cmd, undo this now 4060 */ 4061 if (fas->f_wdtr_sent) { 4062 fas->f_wide_known &= ~(1<<Tgt(sp)); 4063 fas->f_wdtr_sent = 0; 4064 } 4065 if (fas->f_sdtr_sent) { 4066 fas->f_sync_known &= ~(1<<Tgt(sp)); 4067 fas->f_sdtr_sent = 0; 4068 } 4069 4070 fas_head_of_readyQ(fas, sp); 4071 4072 return (rval); 4073 } 4074 4075 /* 4076 * Handle the reconnection of a target 4077 */ 4078 static int 4079 fas_reconnect(struct fas *fas) 4080 { 4081 volatile struct fasreg *fasreg = fas->f_reg; 4082 struct fas_cmd *sp = NULL; 4083 uchar_t target, lun; 4084 uchar_t tmp; 4085 uchar_t slot; 4086 char *bad_reselect = NULL; 4087 4088 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_RECONNECT_START, 4089 "fas_reconnect_start"); 4090 EPRINTF("fas_reconnect:\n"); 4091 4092 fas_check_ncmds(fas); 4093 4094 switch (fas->f_state) { 4095 default: 4096 /* 4097 * Pick up target id from fifo 4098 * 4099 * There should only be the reselecting target's id 4100 * and an identify message in the fifo. 4101 */ 4102 target = fas->f_fifo[0]; 4103 4104 /* 4105 * we know the target so update period, conf3, 4106 * offset reg, if necessary, and accept the msg 4107 */ 4108 FAS_SET_PERIOD_OFFSET_CONF3_REGS(fas, target); 4109 4110 /* 4111 * now we can accept the message. an untagged 4112 * target will go immediately into data phase so 4113 * the period/offset/conf3 registers need to be 4114 * updated before accepting the message 4115 */ 4116 fas_reg_cmd_write(fas, CMD_MSG_ACPT); 4117 4118 if (fas->f_fifolen != 2) { 4119 bad_reselect = "bad reselect bytes"; 4120 break; 4121 } 4122 4123 /* 4124 * normal initial reconnect; we get another interrupt later 4125 * for the tag 4126 */ 4127 New_state(fas, ACTS_RESEL); 4128 4129 if (fas->f_stat & FAS_STAT_PERR) { 4130 break; 4131 } 4132 4133 /* 4134 * Check sanity of message. 4135 */ 4136 tmp = fas->f_fifo[1]; 4137 fas->f_last_msgin = tmp; 4138 4139 if (!(IS_IDENTIFY_MSG(tmp)) || (tmp & INI_CAN_DISCON)) { 4140 bad_reselect = "bad identify msg"; 4141 break; 4142 } 4143 4144 lun = tmp & (NLUNS_PER_TARGET-1); 4145 4146 EPRINTF2("fas_reconnect: target=%x, idmsg=%x\n", 4147 target, tmp); 4148 4149 fas->f_resel_slot = slot = (target * NLUNS_PER_TARGET) | lun; 4150 4151 fas_reg_write(fas, (uchar_t *)&fasreg->fas_busid, 4152 (target & 0xf) | FAS_BUSID_ENCODID | 4153 FAS_BUSID_32BIT_COUNTER); 4154 4155 /* 4156 * If tag queueing in use, DMA in tag. 4157 * Otherwise, we're ready to go. 4158 * if tag 0 slot is non-empty, a non-tagged cmd is 4159 * reconnecting 4160 */ 4161 if (TAGGED(target) && fas->f_tcmds[slot] && 4162 (fas->f_active[slot]->f_slot[0] == NULL)) { 4163 volatile uchar_t *c = 4164 (uchar_t *)fas->f_cmdarea; 4165 4166 /* 4167 * If we've been doing tagged queueing and this 4168 * request doesn't do it, 4169 * maybe it was disabled for this one. This is rather 4170 * dangerous as it blows all pending tagged cmds away. 4171 * But if target is confused, then we'll blow up 4172 * shortly. 4173 */ 4174 *c++ = INVALID_MSG; 4175 *c = INVALID_MSG; 4176 4177 FAS_DMA_WRITE_SETUP(fas, 2, 4178 fas->f_dmacookie.dmac_address); 4179 4180 /* 4181 * For tagged queuing, we should still be in msgin 4182 * phase. 4183 * If not, then either we aren't running tagged 4184 * queueing like we thought or the target died. 4185 */ 4186 if (INTPENDING(fas) == 0) { 4187 EPRINTF1("slow reconnect, slot=%x\n", slot); 4188 TRACE_0(TR_FAC_SCSI_FAS, 4189 TR_FAS_RECONNECT_RETURN1_END, 4190 "fas_reconnect_end (_RETURN1)"); 4191 return (ACTION_RETURN); 4192 } 4193 4194 fas->f_stat = fas_reg_read(fas, &fasreg->fas_stat); 4195 fas->f_intr = fas_reg_read(fas, &fasreg->fas_intr); 4196 if (fas->f_intr & (FAS_INT_ILLEGAL | FAS_INT_RESET)) { 4197 return (fas_illegal_cmd_or_bus_reset(fas)); 4198 } 4199 4200 if ((fas->f_stat & FAS_PHASE_MASK) != 4201 FAS_PHASE_MSG_IN) { 4202 bad_reselect = "not in msgin phase"; 4203 break; 4204 } 4205 4206 if (fas->f_intr & FAS_INT_DISCON) { 4207 bad_reselect = "unexpected bus free"; 4208 break; 4209 } 4210 } else { 4211 fas->f_current_sp = sp = fas->f_active[slot]->f_slot[0]; 4212 break; 4213 } 4214 /*FALLTHROUGH*/ 4215 4216 case ACTS_RESEL: 4217 { 4218 volatile uchar_t *c = 4219 (uchar_t *)fas->f_cmdarea; 4220 struct f_slots *tag_slots; 4221 int id, tag; 4222 uint_t i; 4223 4224 slot = fas->f_resel_slot; 4225 target = slot/NLUNS_PER_TARGET; 4226 4227 if ((fas->f_stat & FAS_PHASE_MASK) != 4228 FAS_PHASE_MSG_IN) { 4229 IPRINTF1("no tag for slot %x\n", slot); 4230 if (fas->f_intr & ~(FAS_INT_BUS | 4231 FAS_INT_FCMP)) { 4232 New_state(fas, ACTS_UNKNOWN); 4233 TRACE_0(TR_FAC_SCSI_FAS, 4234 TR_FAS_RECONNECT_PHASEMANAGE_END, 4235 "fas_reconnect_end (_PHASEMANAGE)"); 4236 return (ACTION_PHASEMANAGE); 4237 } else { 4238 bad_reselect = "not in msgin phase"; 4239 break; 4240 } 4241 } 4242 fas_reg_cmd_write(fas, CMD_TRAN_INFO|CMD_DMA); 4243 fas_dma_reg_write(fas, &fas->f_dma->dma_csr, 4244 fas->f_dma_csr); 4245 4246 fas_reg_cmd_write(fas, CMD_MSG_ACPT); 4247 4248 for (i = 0; i < (uint_t)RECONNECT_TAG_RCV_TIMEOUT; 4249 i++) { 4250 /* 4251 * timeout is not very accurate but this 4252 * should take no time at all 4253 */ 4254 if (INTPENDING(fas)) { 4255 fas->f_stat = fas_reg_read(fas, 4256 (uchar_t *)&fas->f_reg->fas_stat); 4257 fas->f_intr = fas_reg_read(fas, 4258 (uchar_t *)&fas->f_reg->fas_intr); 4259 if (fas->f_intr & (FAS_INT_RESET | 4260 FAS_INT_ILLEGAL)) { 4261 return ( 4262 fas_illegal_cmd_or_bus_reset(fas)); 4263 } 4264 if (fas->f_intr & FAS_INT_FCMP) { 4265 break; 4266 } 4267 } 4268 } 4269 4270 if (i == (uint_t)RECONNECT_TAG_RCV_TIMEOUT) { 4271 bad_reselect = "timeout on receiving tag msg"; 4272 break; 4273 } 4274 4275 FAS_FLUSH_DMA(fas); 4276 4277 /* 4278 * we should really do a sync here but that 4279 * hurts performance too much; we'll just hang 4280 * around till the tag byte flips 4281 * This is necessary on any system with an 4282 * XBox 4283 */ 4284 if (*c == INVALID_MSG) { 4285 EPRINTF( 4286 "fas_reconnect: invalid msg, polling\n"); 4287 for (i = 0; i < 1000000; i++) { 4288 if (*c != INVALID_MSG) 4289 break; 4290 } 4291 } 4292 4293 if (fas->f_stat & FAS_STAT_PERR) { 4294 break; 4295 } 4296 4297 if ((fas->f_stat & FAS_STAT_XZERO) == 0 || 4298 (id = *c++) < MSG_SIMPLE_QTAG || 4299 id > MSG_ORDERED_QTAG) { 4300 /* 4301 * Target agreed to do tagged queueing 4302 * and lied! 4303 * This problem implies the drive firmware is 4304 * broken. 4305 */ 4306 bad_reselect = "botched tag"; 4307 break; 4308 } 4309 tag = *c; 4310 4311 /* Set ptr to reconnecting scsi pkt */ 4312 tag_slots = fas->f_active[slot]; 4313 if (tag_slots != NULL) { 4314 sp = tag_slots->f_slot[tag]; 4315 } else { 4316 bad_reselect = "Invalid tag"; 4317 break; 4318 } 4319 4320 fas->f_current_sp = sp; 4321 } 4322 } 4323 4324 if (fas->f_stat & FAS_STAT_PERR) { 4325 sp = NULL; 4326 bad_reselect = "Parity error in reconnect msg's"; 4327 } 4328 4329 if ((sp == NULL || 4330 #ifdef FAS_TEST 4331 (fas_atest_reconn & (1<<Tgt(sp))) || 4332 #endif 4333 (sp->cmd_flags & (CFLAG_CMDDISC|CFLAG_CMDPROXY)) == 0)) { 4334 /* 4335 * this shouldn't really happen, so it is better 4336 * to reset the bus; some disks accept the abort 4337 * and then still reconnect 4338 */ 4339 if (bad_reselect == NULL) { 4340 bad_reselect = "no command"; 4341 } 4342 #ifdef FAS_TEST 4343 if (sp && !(fas_atest_reconn & (1<<Tgt(sp))) && 4344 fas_test_stop) { 4345 debug_enter("bad reconnect"); 4346 } else { 4347 fas_atest_reconn = 0; 4348 } 4349 #endif 4350 goto bad; 4351 4352 /* 4353 * XXX remove this case or make it an ASSERT 4354 */ 4355 } else if (sp->cmd_flags & CFLAG_CMDPROXY) { 4356 /* 4357 * If we got here, we were already attempting to 4358 * run a polled proxy command for this target. 4359 * Set ATN and, copy in the message, and drive 4360 * on (ignoring any parity error on the identify). 4361 */ 4362 IPRINTF1("fas_reconnect: fielding proxy cmd for %d\n", 4363 target); 4364 fas_assert_atn(fas); 4365 fas->f_omsglen = sp->cmd_cdb[FAS_PROXY_DATA]; 4366 tmp = 0; 4367 while (tmp < fas->f_omsglen) { 4368 fas->f_cur_msgout[tmp] = 4369 sp->cmd_cdb[FAS_PROXY_DATA+1+tmp]; 4370 tmp++; 4371 } 4372 sp->cmd_cdb[FAS_PROXY_RESULT] = FALSE; 4373 4374 /* 4375 * pretend that the disconnected cmd is still disconnected 4376 * (this prevents ndisc from going negative) 4377 */ 4378 fas->f_ndisc++; 4379 ASSERT((fas->f_ncmds >= 0) && (fas->f_ndisc >= 0)); 4380 ASSERT(fas->f_ncmds >= fas->f_ndisc); 4381 } 4382 4383 ASSERT(fas->f_resel_slot == slot); 4384 ASSERT(fas->f_ndisc > 0); 4385 fas->f_ndisc--; 4386 sp->cmd_flags &= ~CFLAG_CMDDISC; 4387 New_state(fas, ACTS_UNKNOWN); 4388 4389 /* 4390 * A reconnect may imply a restore pointers operation 4391 * Note that some older disks (Micropolis in Pbox) do not 4392 * send a save data ptr on disconnect if all data has been 4393 * xferred. So, we cannot restore ptrs yet here. 4394 */ 4395 if ((sp->cmd_flags & CFLAG_DMAVALID) && 4396 (sp->cmd_data_count != sp->cmd_saved_data_count)) { 4397 sp->cmd_flags |= CFLAG_RESTORE_PTRS; 4398 } 4399 4400 /* 4401 * Return to await the FUNCTION COMPLETE interrupt we 4402 * should get out of accepting the IDENTIFY message. 4403 */ 4404 EPRINTF2("Reconnecting %d.%d\n", target, slot % NLUNS_PER_TARGET); 4405 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_RECONNECT_RETURN2_END, 4406 "fas_reconnect_end (_RETURN2)"); 4407 return (ACTION_RETURN); 4408 4409 bad: 4410 if (sp && (fas->f_stat & FAS_STAT_PERR)) { 4411 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 4412 } 4413 fas_log(fas, CE_WARN, "target %x: failed reselection (%s)", 4414 target, bad_reselect); 4415 4416 #ifdef FASDEBUG 4417 fas_printstate(fas, "failed reselection"); 4418 #endif 4419 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_RECONNECT_RESET5_END, 4420 "fas_reconnect_end (_RESET5)"); 4421 return (ACTION_RESET); 4422 } 4423 4424 /* 4425 * handle unknown bus phase 4426 * we don't know what to expect so check status register for current 4427 * phase 4428 */ 4429 int 4430 fas_handle_unknown(struct fas *fas) 4431 { 4432 TRACE_1(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_UNKNOWN_START, 4433 "fas_handle_unknown_start: fas 0x%p", fas); 4434 EPRINTF("fas_handle_unknown:\n"); 4435 4436 if ((fas->f_intr & FAS_INT_DISCON) == 0) { 4437 /* 4438 * we call actions here rather than returning to phasemanage 4439 * (this is the most frequently called action) 4440 */ 4441 switch (fas->f_stat & FAS_PHASE_MASK) { 4442 case FAS_PHASE_DATA_IN: 4443 case FAS_PHASE_DATA_OUT: 4444 New_state(fas, ACTS_DATA); 4445 TRACE_0(TR_FAC_SCSI_FAS, 4446 TR_FAS_HANDLE_UNKNOWN_PHASE_DATA_END, 4447 "fas_handle_unknown_end (phase_data)"); 4448 return (fas_handle_data_start(fas)); 4449 4450 case FAS_PHASE_MSG_OUT: 4451 New_state(fas, ACTS_MSG_OUT); 4452 TRACE_0(TR_FAC_SCSI_FAS, 4453 TR_FAS_HANDLE_UNKNOWN_PHASE_MSG_OUT_END, 4454 "fas_handle_unknown_end (phase_msg_out)"); 4455 return (fas_handle_msg_out_start(fas)); 4456 4457 case FAS_PHASE_MSG_IN: 4458 New_state(fas, ACTS_MSG_IN); 4459 TRACE_0(TR_FAC_SCSI_FAS, 4460 TR_FAS_HANDLE_UNKNOWN_PHASE_MSG_IN_END, 4461 "fas_handle_unknown_end (phase_msg_in)"); 4462 return (fas_handle_msg_in_start(fas)); 4463 4464 case FAS_PHASE_STATUS: 4465 fas_reg_cmd_write(fas, CMD_FLUSH); 4466 #ifdef FAS_TEST 4467 if (fas_ptest_status & (1<<Tgt(fas->f_current_sp))) { 4468 fas_assert_atn(fas); 4469 } 4470 #endif /* FAS_TEST */ 4471 4472 fas_reg_cmd_write(fas, CMD_COMP_SEQ); 4473 New_state(fas, ACTS_C_CMPLT); 4474 4475 TRACE_0(TR_FAC_SCSI_FAS, 4476 TR_FAS_HANDLE_UNKNOWN_PHASE_STATUS_END, 4477 "fas_handle_unknown_end (phase_status)"); 4478 return (fas_handle_c_cmplt(fas)); 4479 4480 case FAS_PHASE_COMMAND: 4481 New_state(fas, ACTS_CMD_START); 4482 TRACE_0(TR_FAC_SCSI_FAS, 4483 TR_FAS_HANDLE_UNKNOWN_PHASE_CMD_END, 4484 "fas_handle_unknown_end (phase_cmd)"); 4485 return (fas_handle_cmd_start(fas)); 4486 } 4487 4488 fas_printstate(fas, "Unknown bus phase"); 4489 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_UNKNOWN_RESET_END, 4490 "fas_handle_unknown_end (reset)"); 4491 return (ACTION_RESET); 4492 4493 } else { 4494 /* 4495 * Okay. What to do now? Let's try (for the time being) 4496 * assuming that the target went south and dropped busy, 4497 * as a disconnect implies that either we received 4498 * a completion or a disconnect message, or that we 4499 * had sent an ABORT OPERATION or BUS DEVICE RESET 4500 * message. In either case, we expected the disconnect 4501 * and should have fielded it elsewhere. 4502 * 4503 * If we see a chip disconnect here, this is an unexpected 4504 * loss of BSY*. Clean up the state of the chip and return. 4505 * 4506 */ 4507 int msgout = fas->f_cur_msgout[0]; 4508 struct fas_cmd *sp = fas->f_current_sp; 4509 int target = Tgt(sp); 4510 4511 if (msgout == MSG_HEAD_QTAG || msgout == MSG_SIMPLE_QTAG) { 4512 msgout = fas->f_cur_msgout[2]; 4513 } 4514 EPRINTF4("msgout: %x %x %x, last_msgout=%x\n", 4515 fas->f_cur_msgout[0], fas->f_cur_msgout[1], 4516 fas->f_cur_msgout[2], fas->f_last_msgout); 4517 4518 if (msgout == MSG_ABORT || msgout == MSG_ABORT_TAG || 4519 msgout == MSG_DEVICE_RESET) { 4520 IPRINTF2("Successful %s message to target %d\n", 4521 scsi_mname(msgout), Tgt(sp)); 4522 if (sp->cmd_flags & CFLAG_CMDPROXY) { 4523 sp->cmd_cdb[FAS_PROXY_RESULT] = TRUE; 4524 } 4525 if (msgout == MSG_ABORT || msgout == MSG_ABORT_TAG) { 4526 fas->f_abort_msg_sent++; 4527 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 4528 fas_set_pkt_reason(fas, sp, 4529 CMD_ABORTED, STAT_ABORTED); 4530 } 4531 } else if (msgout == MSG_DEVICE_RESET) { 4532 fas->f_reset_msg_sent++; 4533 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 4534 fas_set_pkt_reason(fas, sp, 4535 CMD_RESET, STAT_DEV_RESET); 4536 } 4537 fas_force_renegotiation(fas, target); 4538 } 4539 } else { 4540 if ((fas->f_last_msgout == MSG_EXTENDED) && 4541 (fas->f_last_msgin == MSG_REJECT)) { 4542 /* 4543 * the target rejected the negotiations, 4544 * so resubmit again (no_sync/no_wide 4545 * is now set) 4546 */ 4547 New_state(fas, STATE_FREE); 4548 fas_reg_cmd_write(fas, CMD_EN_RESEL); 4549 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 4550 fas_decrement_ncmds(fas, sp); 4551 fas_check_ncmds(fas); 4552 sp->cmd_flags &= ~CFLAG_TRANFLAG; 4553 (void) fas_accept_pkt(fas, sp, NO_TRAN_BUSY); 4554 fas_check_ncmds(fas); 4555 TRACE_0(TR_FAC_SCSI_FAS, 4556 TR_FAS_HANDLE_UNKNOWN_INT_DISCON_END, 4557 "fas_handle_unknown_end (int_discon)"); 4558 return (ACTION_SEARCH); 4559 4560 } else if (fas->f_last_msgout == MSG_EXTENDED) { 4561 /* 4562 * target dropped off the bus during 4563 * negotiations 4564 */ 4565 fas_reset_sync_wide(fas); 4566 fas->f_sdtr_sent = fas->f_wdtr_sent = 0; 4567 } 4568 4569 fas_set_pkt_reason(fas, sp, CMD_UNX_BUS_FREE, 0); 4570 #ifdef FASDEBUG 4571 fas_printstate(fas, "unexpected bus free"); 4572 #endif 4573 } 4574 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_UNKNOWN_INT_DISCON_END, 4575 "fas_handle_unknown_end (int_discon)"); 4576 return (ACTION_FINISH); 4577 } 4578 _NOTE(NOT_REACHED) 4579 /* NOTREACHED */ 4580 } 4581 4582 /* 4583 * handle target disconnecting 4584 */ 4585 static int 4586 fas_handle_clearing(struct fas *fas) 4587 { 4588 struct fas_cmd *sp = fas->f_current_sp; 4589 4590 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CLEARING_START, 4591 "fas_handle_clearing_start"); 4592 EPRINTF("fas_handle_clearing:\n"); 4593 4594 if (fas->f_laststate == ACTS_C_CMPLT || 4595 fas->f_laststate == ACTS_MSG_IN_DONE) { 4596 if (INTPENDING(fas)) { 4597 volatile struct fasreg *fasreg = fas->f_reg; 4598 4599 fas->f_stat = fas_reg_read(fas, 4600 (uchar_t *)&fasreg->fas_stat); 4601 fas->f_intr = fas_reg_read(fas, 4602 (uchar_t *)&fasreg->fas_intr); 4603 if (fas->f_intr & (FAS_INT_RESET | FAS_INT_ILLEGAL)) { 4604 return (fas_illegal_cmd_or_bus_reset(fas)); 4605 } 4606 } else { 4607 /* 4608 * change e_laststate for the next time around 4609 */ 4610 fas->f_laststate = ACTS_CLEARING; 4611 TRACE_0(TR_FAC_SCSI_FAS, 4612 TR_FAS_HANDLE_CLEARING_RETURN1_END, 4613 "fas_handle_clearing_end (ACTION_RETURN1)"); 4614 return (ACTION_RETURN); 4615 } 4616 } 4617 4618 if (fas->f_intr == FAS_INT_DISCON) { 4619 /* 4620 * At this point the FAS chip has disconnected. The bus should 4621 * be either quiet or someone may be attempting a reselection 4622 * of us (or somebody else). Call the routine that sets the 4623 * chip back to a correct and known state. 4624 * If the last message in was a disconnect, search 4625 * for new work to do, else return to call fas_finish() 4626 */ 4627 fas->f_last_msgout = 0xff; 4628 fas->f_omsglen = 0; 4629 if (fas->f_last_msgin == MSG_DISCONNECT) { 4630 4631 fas_reg_cmd_write(fas, CMD_EN_RESEL); 4632 4633 New_state(fas, STATE_FREE); 4634 4635 ASSERT(fas->f_current_sp != NULL); 4636 EPRINTF2("disconnecting %d.%d\n", Tgt(sp), Lun(sp)); 4637 4638 sp->cmd_pkt->pkt_statistics |= STAT_DISCON; 4639 sp->cmd_flags |= CFLAG_CMDDISC; 4640 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 4641 fas->f_ndisc++; 4642 } 4643 ASSERT((fas->f_ncmds >= 0) && (fas->f_ndisc >= 0)); 4644 ASSERT(fas->f_ncmds >= fas->f_ndisc); 4645 4646 fas->f_current_sp = NULL; 4647 4648 /* 4649 * start a cmd here to save time 4650 */ 4651 if ((fas->f_ncmds > fas->f_ndisc) && fas_ustart(fas)) { 4652 TRACE_0(TR_FAC_SCSI_FAS, 4653 TR_FAS_HANDLE_CLEARING_RETURN2_END, 4654 "fas_handle_clearing_end (ACTION_RETURN2)"); 4655 return (ACTION_RETURN); 4656 } 4657 4658 4659 TRACE_0(TR_FAC_SCSI_FAS, 4660 TR_FAS_HANDLE_CLEARING_RETURN3_END, 4661 "fas_handle_clearing_end (ACTION_RETURN3)"); 4662 return (ACTION_RETURN); 4663 } else { 4664 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CLEARING_END, 4665 "fas_handle_clearing_end"); 4666 return (fas_finish(fas)); 4667 } 4668 } else { 4669 /* 4670 * If the target didn't disconnect from the 4671 * bus, that is a gross fatal error. 4672 * XXX this can be caused by asserting ATN 4673 * XXX check bus phase and if msgout, send a message 4674 */ 4675 fas_log(fas, CE_WARN, 4676 "Target %d didn't disconnect after sending %s", 4677 Tgt(sp), scsi_mname(fas->f_last_msgin)); 4678 4679 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 4680 4681 #ifdef FASDEBUG 4682 IPRINTF4("msgout: %x %x %x, last_msgout=%x\n", 4683 fas->f_cur_msgout[0], fas->f_cur_msgout[1], 4684 fas->f_cur_msgout[2], fas->f_last_msgout); 4685 IPRINTF1("last msgin=%x\n", fas->f_last_msgin); 4686 #endif 4687 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CLEARING_ABORT_END, 4688 "fas_handle_clearing_end (ACTION_ABORT_CURCMD)"); 4689 return (ACTION_ABORT_ALLCMDS); 4690 } 4691 } 4692 4693 /* 4694 * handle data phase start 4695 */ 4696 static int 4697 fas_handle_data_start(struct fas *fas) 4698 { 4699 uint64_t end; 4700 uint32_t amt; 4701 struct fas_cmd *sp = fas->f_current_sp; 4702 int sending, phase; 4703 4704 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_START, 4705 "fas_handle_data_start"); 4706 EPRINTF("fas_handle_data_start:\n"); 4707 4708 if ((sp->cmd_flags & CFLAG_DMAVALID) == 0) { 4709 fas_printstate(fas, "unexpected data phase"); 4710 bad: 4711 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 4712 4713 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_ABORT1_END, 4714 "fas_handle_data_end (ACTION_ABORT_CURCMD1)"); 4715 return (ACTION_ABORT_CURCMD); 4716 } else { 4717 sending = (sp->cmd_flags & CFLAG_DMASEND)? 1 : 0; 4718 } 4719 4720 if (sp->cmd_flags & CFLAG_RESTORE_PTRS) { 4721 if (fas_restore_pointers(fas, sp)) { 4722 return (ACTION_ABORT_CURCMD); 4723 } 4724 sp->cmd_flags &= ~CFLAG_RESTORE_PTRS; 4725 } 4726 4727 /* 4728 * And make sure our DMA pointers are in good shape. 4729 * 4730 * Because SCSI is SCSI, the current DMA pointer has got to be 4731 * greater than or equal to our DMA base address. All other cases 4732 * that might have affected this always set curaddr to be >= 4733 * to the DMA base address. 4734 */ 4735 ASSERT(sp->cmd_cur_addr >= sp->cmd_dmacookie.dmac_address); 4736 end = (uint64_t)sp->cmd_dmacookie.dmac_address + 4737 (uint64_t)sp->cmd_dmacookie.dmac_size; 4738 4739 DPRINTF5( 4740 "cmd_data_count=%x, dmacount=%x, curaddr=%x, end=%" 4741 PRIx64 ", nwin=%x\n", 4742 sp->cmd_data_count, sp->cmd_dmacount, sp->cmd_cur_addr, end, 4743 sp->cmd_nwin); 4744 DPRINTF2("dmac_address = %x, dmac_size=%lx\n", 4745 sp->cmd_dmacookie.dmac_address, sp->cmd_dmacookie.dmac_size); 4746 4747 if (sp->cmd_cur_addr >= end) { 4748 if (fas_next_window(fas, sp, end)) { 4749 goto bad; 4750 } 4751 end = (uint64_t)sp->cmd_dmacookie.dmac_address + 4752 (uint64_t)sp->cmd_dmacookie.dmac_size; 4753 DPRINTF2("dmac_address=%x, dmac_size=%lx\n", 4754 sp->cmd_dmacookie.dmac_address, 4755 sp->cmd_dmacookie.dmac_size); 4756 } 4757 4758 amt = end - sp->cmd_cur_addr; 4759 if (fas->f_dma_attr->dma_attr_count_max < amt) { 4760 amt = fas->f_dma_attr->dma_attr_count_max; 4761 } 4762 DPRINTF3("amt=%x, end=%lx, cur_addr=%x\n", amt, end, sp->cmd_cur_addr); 4763 4764 #ifdef FASDEBUG 4765 /* 4766 * Make sure that we don't cross a boundary we can't handle 4767 */ 4768 end = (uint64_t)sp->cmd_cur_addr + (uint64_t)amt - 1; 4769 if ((end & ~fas->f_dma_attr->dma_attr_seg) != 4770 (sp->cmd_cur_addr & ~fas->f_dma_attr->dma_attr_seg)) { 4771 EPRINTF3("curaddr %x curaddr+amt %" PRIx64 4772 " cntr_max %" PRIx64 "\n", 4773 sp->cmd_cur_addr, end, fas->f_dma_attr->dma_attr_seg); 4774 amt = (end & ~fas->f_dma_attr->dma_attr_seg) - sp->cmd_cur_addr; 4775 if (amt == 0 || amt > fas->f_dma_attr->dma_attr_count_max) { 4776 fas_log(fas, CE_WARN, "illegal dma boundary? %x", amt); 4777 goto bad; 4778 } 4779 } 4780 #endif 4781 4782 end = (uint64_t)sp->cmd_dmacookie.dmac_address + 4783 (uint64_t)sp->cmd_dmacookie.dmac_size - 4784 (uint64_t)sp->cmd_cur_addr; 4785 if (amt > end) { 4786 EPRINTF4("ovflow amt %x s.b. %" PRIx64 " curaddr %x count %x\n", 4787 amt, end, sp->cmd_cur_addr, sp->cmd_dmacount); 4788 amt = (uint32_t)end; 4789 } 4790 4791 fas->f_lastcount = amt; 4792 4793 EPRINTF4("%d.%d cmd 0x%x to xfer %x\n", Tgt(sp), Lun(sp), 4794 sp->cmd_pkt->pkt_cdbp[0], amt); 4795 4796 phase = fas->f_stat & FAS_PHASE_MASK; 4797 4798 if ((phase == FAS_PHASE_DATA_IN) && !sending) { 4799 FAS_DMA_WRITE(fas, amt, sp->cmd_cur_addr, 4800 CMD_TRAN_INFO|CMD_DMA); 4801 } else if ((phase == FAS_PHASE_DATA_OUT) && sending) { 4802 FAS_DMA_READ(fas, amt, sp->cmd_cur_addr, amt, 4803 CMD_TRAN_INFO|CMD_DMA); 4804 } else { 4805 fas_log(fas, CE_WARN, 4806 "unwanted data xfer direction for Target %d", Tgt(sp)); 4807 fas_set_pkt_reason(fas, sp, CMD_DMA_DERR, 0); 4808 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_ABORT2_END, 4809 "fas_handle_data_end (ACTION_ABORT_CURCMD2)"); 4810 return (ACTION_ABORT_CURCMD); 4811 } 4812 4813 #ifdef FAS_TEST 4814 if (!sending && (fas_ptest_data_in & (1<<Tgt(sp)))) { 4815 fas_assert_atn(fas); 4816 } 4817 #endif /* FAS_TEST */ 4818 4819 New_state(fas, ACTS_DATA_DONE); 4820 4821 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_END, 4822 "fas_handle_data_end (ACTION_RETURN)"); 4823 return (ACTION_RETURN); 4824 } 4825 4826 static int 4827 fas_handle_data_done(struct fas *fas) 4828 { 4829 volatile struct fasreg *fasreg = fas->f_reg; 4830 volatile struct dma *dmar = fas->f_dma; 4831 struct fas_cmd *sp = fas->f_current_sp; 4832 uint32_t xfer_amt; 4833 char was_sending; 4834 uchar_t stat, fifoamt, tgt; 4835 4836 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_DONE_START, 4837 "fas_handle_data_done_start"); 4838 EPRINTF("fas_handle_data_done\n"); 4839 4840 tgt = Tgt(sp); 4841 stat = fas->f_stat; 4842 was_sending = (sp->cmd_flags & CFLAG_DMASEND) ? 1 : 0; 4843 4844 /* 4845 * Check for DMA errors (parity or memory fault) 4846 */ 4847 if ((fas->f_dma_csr = fas_dma_reg_read(fas, &dmar->dma_csr)) & 4848 DMA_ERRPEND) { 4849 /* 4850 * It would be desirable to set the ATN* line and attempt to 4851 * do the whole schmear of INITIATOR DETECTED ERROR here, 4852 * but that is too hard to do at present. 4853 */ 4854 fas_log(fas, CE_WARN, "Unrecoverable DMA error on dma %s", 4855 (was_sending) ? "send" : "receive"); 4856 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 4857 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_DONE_RESET_END, 4858 "fas_handle_data_done_end (ACTION_RESET)"); 4859 return (ACTION_RESET); 4860 } 4861 4862 /* 4863 * Data Receive conditions: 4864 * 4865 * Check for parity errors. If we have a parity error upon 4866 * receive, the FAS chip has asserted ATN* for us already. 4867 */ 4868 if (!was_sending) { 4869 #ifdef FAS_TEST 4870 if (fas_ptest_data_in & (1<<tgt)) { 4871 fas_ptest_data_in = 0; 4872 stat |= FAS_STAT_PERR; 4873 if (fas_test_stop > 1) { 4874 debug_enter("ptest_data_in"); 4875 } 4876 } 4877 #endif /* FAS_TEST */ 4878 if (stat & FAS_STAT_PERR) { 4879 fas_log(fas, CE_WARN, 4880 "SCSI bus DATA IN phase parity error"); 4881 fas->f_cur_msgout[0] = MSG_INITIATOR_ERROR; 4882 fas->f_omsglen = 1; 4883 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 4884 sp->cmd_pkt->pkt_reason = CMD_TRAN_ERR; 4885 } 4886 } 4887 4888 FAS_FLUSH_DMA(fas); 4889 4890 /* 4891 * Check to make sure we're still connected to the target. 4892 * If the target dropped the bus, that is a fatal error. 4893 * We don't even attempt to count what we were transferring 4894 * here. Let fas_handle_unknown clean up for us. 4895 */ 4896 if (fas->f_intr != FAS_INT_BUS) { 4897 New_state(fas, ACTS_UNKNOWN); 4898 TRACE_0(TR_FAC_SCSI_FAS, 4899 TR_FAS_HANDLE_DATA_DONE_PHASEMANAGE_END, 4900 "fas_handle_data_done_end (ACTION_PHASEMANAGE)"); 4901 return (ACTION_PHASEMANAGE); 4902 } 4903 4904 /* 4905 * Figure out how far we got. 4906 * Latch up fifo amount first and double if wide has been enabled 4907 */ 4908 fifoamt = FIFO_CNT(fas); 4909 if (fas->f_wide_enabled & (1<<tgt)) { 4910 fifoamt = fifoamt << 1; 4911 } 4912 4913 if (stat & FAS_STAT_XZERO) { 4914 xfer_amt = fas->f_lastcount; 4915 } else { 4916 GET_FAS_COUNT(fasreg, xfer_amt); 4917 xfer_amt = fas->f_lastcount - xfer_amt; 4918 } 4919 DPRINTF4("fifoamt=%x, xfer_amt=%x, lastcount=%x, stat=%x\n", 4920 fifoamt, xfer_amt, fas->f_lastcount, stat); 4921 4922 4923 /* 4924 * Unconditionally knock off by the amount left 4925 * in the fifo if we were sending out the SCSI bus. 4926 * 4927 * If we were receiving from the SCSI bus, believe 4928 * what the chip told us (either XZERO or by the 4929 * value calculated from the counter register). 4930 * The reason we don't look at the fifo for 4931 * incoming data is that in synchronous mode 4932 * the fifo may have further data bytes, and 4933 * for async mode we assume that all data in 4934 * the fifo will have been transferred before 4935 * the fas asserts an interrupt. 4936 */ 4937 if (was_sending) { 4938 xfer_amt -= fifoamt; 4939 } 4940 4941 #ifdef FASDEBUG 4942 { 4943 int phase = stat & FAS_PHASE_MASK; 4944 fas->f_stat2 = fas_reg_read(fas, 4945 (uchar_t *)&fasreg->fas_stat2); 4946 4947 if (((fas->f_stat & FAS_STAT_XZERO) == 0) && 4948 (phase != FAS_PHASE_DATA_IN) && 4949 (phase != FAS_PHASE_DATA_OUT) && 4950 (fas->f_stat2 & FAS_STAT2_ISHUTTLE)) { 4951 fas_log(fas, CE_WARN, 4952 "input shuttle not empty at end of data phase"); 4953 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 4954 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_DONE_RESET_END, 4955 "fas_handle_data_done_end (ACTION_RESET)"); 4956 return (ACTION_RESET); 4957 } 4958 } 4959 #endif /* FASDEBUG */ 4960 4961 /* 4962 * If this was a synchronous transfer, flag it. 4963 * Also check for the errata condition of long 4964 * last REQ/ pulse for some synchronous targets 4965 */ 4966 if (fas->f_offset[tgt]) { 4967 /* 4968 * flag that a synchronous data xfer took place 4969 */ 4970 sp->cmd_pkt->pkt_statistics |= STAT_SYNC; 4971 4972 if (was_sending) 4973 fas_reg_cmd_write(fas, CMD_FLUSH); 4974 } else { 4975 /* 4976 * If we aren't doing Synchronous Data Transfers, 4977 * definitely offload the fifo. 4978 */ 4979 fas_reg_cmd_write(fas, CMD_FLUSH); 4980 } 4981 4982 /* 4983 * adjust pointers... 4984 */ 4985 DPRINTF3("before:cmd_data_count=%x, cmd_cur_addr=%x, xfer_amt=%x\n", 4986 sp->cmd_data_count, sp->cmd_cur_addr, xfer_amt); 4987 sp->cmd_data_count += xfer_amt; 4988 sp->cmd_cur_addr += xfer_amt; 4989 sp->cmd_pkt->pkt_state |= STATE_XFERRED_DATA; 4990 New_state(fas, ACTS_UNKNOWN); 4991 DPRINTF3("after:cmd_data_count=%x, cmd_cur_addr=%x, xfer_amt=%x\n", 4992 sp->cmd_data_count, sp->cmd_cur_addr, xfer_amt); 4993 4994 stat &= FAS_PHASE_MASK; 4995 if (stat == FAS_PHASE_DATA_IN || stat == FAS_PHASE_DATA_OUT) { 4996 fas->f_state = ACTS_DATA; 4997 TRACE_0(TR_FAC_SCSI_FAS, 4998 TR_FAS_HANDLE_DATA_DONE_ACTION1_END, 4999 "fas_handle_data_done_end (action1)"); 5000 return (fas_handle_data_start(fas)); 5001 } 5002 5003 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_DATA_DONE_ACTION2_END, 5004 "fas_handle_data_done_end (action2)"); 5005 return (fas_handle_unknown(fas)); 5006 } 5007 5008 static char msginperr[] = "SCSI bus MESSAGE IN phase parity error"; 5009 5010 static int 5011 fas_handle_c_cmplt(struct fas *fas) 5012 { 5013 struct fas_cmd *sp = fas->f_current_sp; 5014 volatile struct fasreg *fasreg = fas->f_reg; 5015 uchar_t sts, msg, intr, perr; 5016 5017 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_C_CMPLT_START, 5018 "fas_handle_c_cmplt_start"); 5019 EPRINTF("fas_handle_c_cmplt:\n"); 5020 5021 5022 /* 5023 * if target is fast, we can get cmd. completion by the time we get 5024 * here. Otherwise, we'll have to taken an interrupt. 5025 */ 5026 if (fas->f_laststate == ACTS_UNKNOWN) { 5027 if (INTPENDING(fas)) { 5028 fas->f_stat = fas_reg_read(fas, 5029 (uchar_t *)&fasreg->fas_stat); 5030 intr = fas_reg_read(fas, (uchar_t *)&fasreg->fas_intr); 5031 fas->f_intr = intr; 5032 if (fas->f_intr & (FAS_INT_RESET | FAS_INT_ILLEGAL)) { 5033 return (fas_illegal_cmd_or_bus_reset(fas)); 5034 } 5035 } else { 5036 /* 5037 * change f_laststate for the next time around 5038 */ 5039 fas->f_laststate = ACTS_C_CMPLT; 5040 TRACE_0(TR_FAC_SCSI_FAS, 5041 TR_FAS_HANDLE_C_CMPLT_RETURN1_END, 5042 "fas_handle_c_cmplt_end (ACTION_RETURN1)"); 5043 return (ACTION_RETURN); 5044 } 5045 } else { 5046 intr = fas->f_intr; 5047 } 5048 5049 #ifdef FAS_TEST 5050 if (fas_ptest_status & (1<<Tgt(sp))) { 5051 fas_ptest_status = 0; 5052 fas->f_stat |= FAS_STAT_PERR; 5053 if (fas_test_stop > 1) { 5054 debug_enter("ptest_status"); 5055 } 5056 } else if ((fas_ptest_msgin & (1<<Tgt(sp))) && fas_ptest_msg == 0) { 5057 fas_ptest_msgin = 0; 5058 fas_ptest_msg = -1; 5059 fas->f_stat |= FAS_STAT_PERR; 5060 if (fas_test_stop > 1) { 5061 debug_enter("ptest_completion"); 5062 } 5063 } 5064 #endif /* FAS_TEST */ 5065 5066 if (intr == FAS_INT_DISCON) { 5067 New_state(fas, ACTS_UNKNOWN); 5068 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_C_CMPLT_ACTION1_END, 5069 "fas_handle_c_cmplt_end (action1)"); 5070 return (fas_handle_unknown(fas)); 5071 } 5072 5073 if ((perr = (fas->f_stat & FAS_STAT_PERR)) != 0) { 5074 fas_assert_atn(fas); 5075 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 5076 } 5077 5078 /* 5079 * do a msg accept now and read the fifo data 5080 */ 5081 if (intr & FAS_INT_FCMP) { 5082 /* 5083 * The FAS manuals state that this sequence completes 5084 * with a BUS SERVICE interrupt if just the status 5085 * byte was received, else a FUNCTION COMPLETE interrupt 5086 * if both status and a message was received. 5087 * 5088 * if we give the MSG_ACT before reading the msg byte 5089 * we get the status byte again and if the status is zero 5090 * then we won't detect a failure 5091 */ 5092 *(sp->cmd_pkt->pkt_scbp) = 5093 sts = fas_reg_read(fas, (uchar_t *)&fasreg->fas_fifo_data); 5094 fas->f_last_msgin = fas->f_imsgarea[0] = 5095 msg = fas_reg_read(fas, (uchar_t *)&fasreg->fas_fifo_data); 5096 5097 fas_reg_cmd_write(fas, CMD_MSG_ACPT); 5098 sp->cmd_pkt->pkt_state |= STATE_GOT_STATUS; 5099 5100 /* 5101 * The manuals also state that ATN* is asserted if 5102 * bad parity is detected. 5103 * 5104 * The one case that we cannot handle is where we detect 5105 * bad parity for the status byte, but the target refuses 5106 * to go to MESSAGE OUT phase right away. This means that 5107 * if that happens, we will misconstrue the parity error 5108 * to be for the completion message, not the status byte. 5109 */ 5110 if (perr) { 5111 fas_log(fas, CE_WARN, msginperr); 5112 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 5113 5114 fas->f_cur_msgout[0] = MSG_MSG_PARITY; 5115 fas->f_omsglen = 1; 5116 New_state(fas, ACTS_UNKNOWN); 5117 TRACE_0(TR_FAC_SCSI_FAS, 5118 TR_FAS_HANDLE_C_CMPLT_ACTION5_END, 5119 "fas_handle_c_cmplt_end (action5)"); 5120 return (ACTION_RETURN); 5121 } 5122 5123 } else if (intr == FAS_INT_BUS) { 5124 /* 5125 * We only got the status byte. 5126 */ 5127 sts = fas_reg_read(fas, (uchar_t *)&fasreg->fas_fifo_data); 5128 sp->cmd_pkt->pkt_state |= STATE_GOT_STATUS; 5129 *(sp->cmd_pkt->pkt_scbp) = sts; 5130 msg = INVALID_MSG; 5131 5132 IPRINTF1("fas_handle_cmd_cmplt: sts=%x, no msg byte\n", sts); 5133 5134 if (perr) { 5135 /* 5136 * If we get a parity error on a status byte 5137 * assume that it was a CHECK CONDITION 5138 */ 5139 sts = STATUS_CHECK; 5140 fas_log(fas, CE_WARN, 5141 "SCSI bus STATUS phase parity error"); 5142 fas->f_cur_msgout[0] = MSG_INITIATOR_ERROR; 5143 fas->f_omsglen = 1; 5144 New_state(fas, ACTS_UNKNOWN); 5145 TRACE_0(TR_FAC_SCSI_FAS, 5146 TR_FAS_HANDLE_C_CMPLT_ACTION5_END, 5147 "fas_handle_c_cmplt_end (action5)"); 5148 return (fas_handle_unknown(fas)); 5149 } 5150 5151 } else { 5152 msg = sts = INVALID_MSG; 5153 IPRINTF("fas_handle_cmd_cmplt: unexpected intr\n"); 5154 New_state(fas, ACTS_UNKNOWN); 5155 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_C_CMPLT_ACTION2_END, 5156 "fas_handle_c_cmplt_end (action2)"); 5157 return (fas_handle_unknown(fas)); 5158 } 5159 5160 EPRINTF2("fas_handle_c_cmplt: status=%x, msg=%x\n", sts, msg); 5161 5162 EPRINTF1("Completion Message=%s\n", scsi_mname(msg)); 5163 if (msg == MSG_COMMAND_COMPLETE) { 5164 /* 5165 * Actually, if the message was a 'linked command 5166 * complete' message, the target isn't going to be 5167 * clearing the bus. 5168 */ 5169 New_state(fas, ACTS_CLEARING); 5170 TRACE_0(TR_FAC_SCSI_FAS, 5171 TR_FAS_HANDLE_C_CMPLT_ACTION4_END, 5172 "fas_handle_c_cmplt_end (action4)"); 5173 return (fas_handle_clearing(fas)); 5174 } else { 5175 fas->f_imsglen = 1; 5176 fas->f_imsgindex = 1; 5177 New_state(fas, ACTS_MSG_IN_DONE); 5178 TRACE_0(TR_FAC_SCSI_FAS, 5179 TR_FAS_HANDLE_C_CMPLT_ACTION3_END, 5180 "fas_handle_c_cmplt_end (action3)"); 5181 return (fas_handle_msg_in_done(fas)); 5182 } 5183 } 5184 5185 /* 5186 * prepare for accepting a message byte from the fifo 5187 */ 5188 static int 5189 fas_handle_msg_in_start(struct fas *fas) 5190 { 5191 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_START, 5192 "fas_handle_msg_in_start"); 5193 EPRINTF("fas_handle_msg_in_start\n"); 5194 5195 /* 5196 * Pick up a message byte. 5197 * Clear the FIFO so we 5198 * don't get confused. 5199 */ 5200 if (!FIFO_EMPTY(fas)) { 5201 fas_reg_cmd_write(fas, CMD_FLUSH); 5202 } 5203 fas_reg_cmd_write(fas, CMD_TRAN_INFO); 5204 fas->f_imsglen = 1; 5205 fas->f_imsgindex = 0; 5206 New_state(fas, ACTS_MSG_IN_DONE); 5207 5208 /* 5209 * give a little extra time by returning to phasemanage 5210 */ 5211 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_END, 5212 "fas_handle_msg_in_end (ACTION_PHASEMANAGE)"); 5213 return (ACTION_PHASEMANAGE); 5214 } 5215 5216 /* 5217 * We come here after issuing a MSG_ACCEPT 5218 * command and are expecting more message bytes. 5219 * The FAS should be asserting a BUS SERVICE 5220 * interrupt status, but may have asserted 5221 * a different interrupt in the case that 5222 * the target disconnected and dropped BSY*. 5223 * 5224 * In the case that we are eating up message 5225 * bytes (and throwing them away unread) because 5226 * we have ATN* asserted (we are trying to send 5227 * a message), we do not consider it an error 5228 * if the phase has changed out of MESSAGE IN. 5229 */ 5230 static int 5231 fas_handle_more_msgin(struct fas *fas) 5232 { 5233 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MORE_MSGIN_START, 5234 "fas_handle_more_msgin_start"); 5235 EPRINTF("fas_handle_more_msgin\n"); 5236 5237 if (fas->f_intr & FAS_INT_BUS) { 5238 if ((fas->f_stat & FAS_PHASE_MASK) == FAS_PHASE_MSG_IN) { 5239 /* 5240 * Fetch another byte of a message in. 5241 */ 5242 fas_reg_cmd_write(fas, CMD_TRAN_INFO); 5243 New_state(fas, ACTS_MSG_IN_DONE); 5244 TRACE_0(TR_FAC_SCSI_FAS, 5245 TR_FAS_HANDLE_MORE_MSGIN_RETURN1_END, 5246 "fas_handle_more_msgin_end (ACTION_RETURN)"); 5247 return (ACTION_RETURN); 5248 } 5249 5250 /* 5251 * If we were gobbling up a message and we have 5252 * changed phases, handle this silently, else 5253 * complain. In either case, we return to let 5254 * fas_phasemanage() handle things. 5255 * 5256 * If it wasn't a BUS SERVICE interrupt, 5257 * let fas_phasemanage() find out if the 5258 * chip disconnected. 5259 */ 5260 if (fas->f_imsglen != 0) { 5261 fas_log(fas, CE_WARN, 5262 "Premature end of extended message"); 5263 } 5264 } 5265 New_state(fas, ACTS_UNKNOWN); 5266 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MORE_MSGIN_RETURN2_END, 5267 "fas_handle_more_msgin_end (action)"); 5268 return (fas_handle_unknown(fas)); 5269 } 5270 5271 static int 5272 fas_handle_msg_in_done(struct fas *fas) 5273 { 5274 struct fas_cmd *sp = fas->f_current_sp; 5275 volatile struct fasreg *fasreg = fas->f_reg; 5276 int sndmsg = 0; 5277 uchar_t msgin; 5278 5279 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_DONE_START, 5280 "fas_handle_msg_in_done_start"); 5281 EPRINTF("fas_handle_msg_in_done:\n"); 5282 if (fas->f_laststate == ACTS_MSG_IN) { 5283 if (INTPENDING(fas)) { 5284 fas->f_stat = fas_reg_read(fas, 5285 (uchar_t *)&fasreg->fas_stat); 5286 fas->f_stat2 = fas_reg_read(fas, 5287 (uchar_t *)&fasreg->fas_stat2); 5288 5289 fas_read_fifo(fas); 5290 5291 fas->f_intr = fas_reg_read(fas, 5292 (uchar_t *)&fasreg->fas_intr); 5293 if (fas->f_intr & (FAS_INT_RESET | FAS_INT_ILLEGAL)) { 5294 return (fas_illegal_cmd_or_bus_reset(fas)); 5295 } 5296 } else { 5297 /* 5298 * change f_laststate for the next time around 5299 */ 5300 fas->f_laststate = ACTS_MSG_IN_DONE; 5301 TRACE_0(TR_FAC_SCSI_FAS, 5302 TR_FAS_HANDLE_MSG_IN_DONE_RETURN1_END, 5303 "fas_handle_msg_in_done_end (ACTION_RETURN1)"); 5304 return (ACTION_RETURN); 5305 } 5306 } 5307 5308 /* 5309 * the most common case is a disconnect message. we do 5310 * a fast path for this condition and if it fails then 5311 * we go for the detailed error handling 5312 */ 5313 #ifndef FAS_TEST 5314 if (((fas->f_laststate == ACTS_MSG_IN) || 5315 (fas->f_laststate == ACTS_MSG_IN_DONE)) && 5316 ((fas->f_intr & FAS_INT_DISCON) == 0) && 5317 ((fas->f_stat & FAS_STAT_PERR) == 0) && 5318 ((sp->cmd_pkt_flags & FLAG_NODISCON) == 0)) { 5319 5320 if ((fas->f_fifolen == 1) && 5321 (fas->f_imsglen == 1) && 5322 (fas->f_fifo[0] == MSG_DISCONNECT)) { 5323 5324 fas_reg_cmd_write(fas, CMD_MSG_ACPT); 5325 fas->f_imsgarea[fas->f_imsgindex++] = fas->f_fifo[0]; 5326 fas->f_last_msgin = MSG_DISCONNECT; 5327 New_state(fas, ACTS_CLEARING); 5328 5329 TRACE_0(TR_FAC_SCSI_FAS, 5330 TR_FAS_HANDLE_MSG_IN_DONE_ACTION_END, 5331 "fas_handle_msg_in_done_end (action)"); 5332 5333 return (fas_handle_clearing(fas)); 5334 } 5335 } 5336 #endif /* not FAS_TEST */ 5337 5338 /* 5339 * We can be called here for both the case where 5340 * we had requested the FAS chip to fetch a message 5341 * byte from the target (at the target's request). 5342 * We can also be called in the case where we had 5343 * been using the CMD_COMP_SEQ command to pick up 5344 * both a status byte and a completion message from 5345 * a target, but where the message wasn't one of 5346 * COMMAND COMPLETE, LINKED COMMAND COMPLETE, or 5347 * LINKED COMMAND COMPLETE (with flag). This is a 5348 * legal (albeit extremely unusual) SCSI bus trans- 5349 * -ition, so we have to handle it. 5350 */ 5351 if (fas->f_laststate != ACTS_C_CMPLT) { 5352 #ifdef FAS_TEST 5353 reloop: 5354 #endif /* FAS_TEST */ 5355 5356 if (fas->f_intr & FAS_INT_DISCON) { 5357 fas_log(fas, CE_WARN, 5358 "premature end of input message"); 5359 New_state(fas, ACTS_UNKNOWN); 5360 TRACE_0(TR_FAC_SCSI_FAS, 5361 TR_FAS_HANDLE_MSG_IN_DONE_PHASEMANAGE_END, 5362 "fas_handle_msg_in_done_end (ACTION_PHASEMANAGE)"); 5363 return (ACTION_PHASEMANAGE); 5364 } 5365 5366 /* 5367 * Note that if f_imsglen is zero, then we are skipping 5368 * input message bytes, so there is no reason to look for 5369 * parity errors. 5370 */ 5371 if (fas->f_imsglen != 0 && (fas->f_stat & FAS_STAT_PERR)) { 5372 fas_log(fas, CE_WARN, msginperr); 5373 sndmsg = MSG_MSG_PARITY; 5374 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 5375 fas_reg_cmd_write(fas, CMD_FLUSH); 5376 5377 } else if ((msgin = fas->f_fifolen) != 1) { 5378 5379 /* 5380 * If we have got more than one or 0 bytes in the fifo, 5381 * that is a gross screwup, and we should let the 5382 * target know that we have completely fouled up. 5383 */ 5384 fas_printf(fas, "fifocount=%x", msgin); 5385 fas_printstate(fas, "input message botch"); 5386 sndmsg = MSG_INITIATOR_ERROR; 5387 fas_reg_cmd_write(fas, CMD_FLUSH); 5388 fas_log(fas, CE_WARN, "input message botch"); 5389 5390 } else if (fas->f_imsglen == 0) { 5391 /* 5392 * If we are in the middle of gobbling up and throwing 5393 * away a message (due to a previous message input 5394 * error), drive on. 5395 */ 5396 msgin = fas_reg_read(fas, 5397 (uchar_t *)&fasreg->fas_fifo_data); 5398 New_state(fas, ACTS_MSG_IN_MORE); 5399 5400 } else { 5401 msgin = fas->f_fifo[0]; 5402 fas->f_imsgarea[fas->f_imsgindex++] = msgin; 5403 } 5404 5405 } else { 5406 /* 5407 * In this case, we have been called (from 5408 * fas_handle_c_cmplt()) with the message 5409 * already stored in the message array. 5410 */ 5411 msgin = fas->f_imsgarea[0]; 5412 } 5413 5414 /* 5415 * Process this message byte (but not if we are 5416 * going to be trying to send back some error 5417 * anyway) 5418 */ 5419 if (sndmsg == 0 && fas->f_imsglen != 0) { 5420 5421 if (fas->f_imsgindex < fas->f_imsglen) { 5422 5423 EPRINTF2("message byte %d: 0x%x\n", 5424 fas->f_imsgindex-1, 5425 fas->f_imsgarea[fas->f_imsgindex-1]); 5426 5427 New_state(fas, ACTS_MSG_IN_MORE); 5428 5429 } else if (fas->f_imsglen == 1) { 5430 5431 #ifdef FAS_TEST 5432 if ((fas_ptest_msgin & (1<<Tgt(sp))) && 5433 fas_ptest_msg == msgin) { 5434 fas_ptest_msgin = 0; 5435 fas_ptest_msg = -1; 5436 fas_assert_atn(fas); 5437 fas->f_stat |= FAS_STAT_PERR; 5438 fas->f_imsgindex -= 1; 5439 if (fas_test_stop > 1) { 5440 debug_enter("ptest msgin"); 5441 } 5442 goto reloop; 5443 } 5444 #endif /* FAS_TEST */ 5445 5446 sndmsg = fas_onebyte_msg(fas); 5447 5448 } else if (fas->f_imsglen == 2) { 5449 #ifdef FAS_TEST 5450 if (fas_ptest_emsgin & (1<<Tgt(sp))) { 5451 fas_ptest_emsgin = 0; 5452 fas_assert_atn(fas); 5453 fas->f_stat |= FAS_STAT_PERR; 5454 fas->f_imsgindex -= 1; 5455 if (fas_test_stop > 1) { 5456 debug_enter("ptest emsgin"); 5457 } 5458 goto reloop; 5459 } 5460 #endif /* FAS_TEST */ 5461 5462 if (fas->f_imsgarea[0] == MSG_EXTENDED) { 5463 static char *tool = 5464 "Extended message 0x%x is too long"; 5465 5466 /* 5467 * Is the incoming message too long 5468 * to be stored in our local array? 5469 */ 5470 if ((int)(msgin+2) > IMSGSIZE) { 5471 fas_log(fas, CE_WARN, 5472 tool, fas->f_imsgarea[0]); 5473 sndmsg = MSG_REJECT; 5474 } else { 5475 fas->f_imsglen = msgin + 2; 5476 New_state(fas, ACTS_MSG_IN_MORE); 5477 } 5478 } else { 5479 sndmsg = fas_twobyte_msg(fas); 5480 } 5481 5482 } else { 5483 sndmsg = fas_multibyte_msg(fas); 5484 } 5485 } 5486 5487 if (sndmsg < 0) { 5488 /* 5489 * If sndmsg is less than zero, one of the subsidiary 5490 * routines needs to return some other state than 5491 * ACTION_RETURN. 5492 */ 5493 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_DONE_SNDMSG_END, 5494 "fas_handle_msg_in_done_end (-sndmsg)"); 5495 return (-sndmsg); 5496 5497 } else if (sndmsg > 0) { 5498 if (IS_1BYTE_MSG(sndmsg)) { 5499 fas->f_omsglen = 1; 5500 } 5501 fas->f_cur_msgout[0] = (uchar_t)sndmsg; 5502 5503 /* 5504 * The target is not guaranteed to go to message out 5505 * phase, period. Moreover, until the entire incoming 5506 * message is transferred, the target may (and likely 5507 * will) continue to transfer message bytes (which 5508 * we will have to ignore). 5509 * 5510 * In order to do this, we'll go to 'infinite' 5511 * message in handling by setting the current input 5512 * message length to a sentinel of zero. 5513 * 5514 * This works regardless of the message we are trying 5515 * to send out. At the point in time which we want 5516 * to send a message in response to an incoming message 5517 * we do not care any more about the incoming message. 5518 * 5519 * If we are sending a message in response to detecting 5520 * a parity error on input, the FAS chip has already 5521 * set ATN* for us, but it doesn't hurt to set it here 5522 * again anyhow. 5523 */ 5524 fas_assert_atn(fas); 5525 New_state(fas, ACTS_MSG_IN_MORE); 5526 fas->f_imsglen = 0; 5527 } 5528 5529 fas_reg_cmd_write(fas, CMD_FLUSH); 5530 5531 fas_reg_cmd_write(fas, CMD_MSG_ACPT); 5532 5533 if ((fas->f_laststate == ACTS_MSG_IN_DONE) && 5534 (fas->f_state == ACTS_CLEARING)) { 5535 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_DONE_ACTION_END, 5536 "fas_handle_msg_in_done_end (action)"); 5537 return (fas_handle_clearing(fas)); 5538 } 5539 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_IN_DONE_RETURN2_END, 5540 "fas_handle_msg_in_done_end (ACTION_RETURN2)"); 5541 return (ACTION_RETURN); 5542 } 5543 5544 static int 5545 fas_onebyte_msg(struct fas *fas) 5546 { 5547 struct fas_cmd *sp = fas->f_current_sp; 5548 int msgout = 0; 5549 uchar_t msgin = fas->f_last_msgin = fas->f_imsgarea[0]; 5550 int tgt = Tgt(sp); 5551 5552 EPRINTF("fas_onebyte_msg\n"); 5553 5554 if (msgin & MSG_IDENTIFY) { 5555 /* 5556 * How did we get here? We should only see identify 5557 * messages on a reconnection, but we'll handle this 5558 * fine here (just in case we get this) as long as 5559 * we believe that this is a valid identify message. 5560 * 5561 * For this to be a valid incoming message, 5562 * bits 6-4 must must be zero. Also, the 5563 * bit that says that I'm an initiator and 5564 * can support disconnection cannot possibly 5565 * be set here. 5566 */ 5567 5568 char garbled = ((msgin & (BAD_IDENTIFY|INI_CAN_DISCON)) != 0); 5569 5570 fas_log(fas, CE_WARN, "%s message 0x%x from Target %d", 5571 garbled ? "Garbled" : "Identify", msgin, tgt); 5572 5573 if (garbled) { 5574 /* 5575 * If it's a garbled message, 5576 * try and tell the target... 5577 */ 5578 msgout = MSG_INITIATOR_ERROR; 5579 } else { 5580 New_state(fas, ACTS_UNKNOWN); 5581 } 5582 return (msgout); 5583 5584 } else if (IS_2BYTE_MSG(msgin) || IS_EXTENDED_MSG(msgin)) { 5585 fas->f_imsglen = 2; 5586 New_state(fas, ACTS_MSG_IN_MORE); 5587 return (0); 5588 } 5589 5590 New_state(fas, ACTS_UNKNOWN); 5591 5592 switch (msgin) { 5593 case MSG_DISCONNECT: 5594 /* 5595 * If we 'cannot' disconnect- reject this message. 5596 * Note that we only key off of the pkt_flags here- 5597 * the FLAG_NODISCON was set in fas_accept_pkt() if 5598 * no disconnect was enabled in scsi_options 5599 */ 5600 if (sp->cmd_pkt_flags & FLAG_NODISCON) { 5601 msgout = MSG_REJECT; 5602 break; 5603 } 5604 /* FALLTHROUGH */ 5605 case MSG_COMMAND_COMPLETE: 5606 fas->f_state = ACTS_CLEARING; 5607 break; 5608 5609 case MSG_NOP: 5610 break; 5611 5612 /* XXX Make it a MSG_REJECT handler */ 5613 case MSG_REJECT: 5614 { 5615 uchar_t reason = 0; 5616 uchar_t lastmsg = fas->f_last_msgout; 5617 /* 5618 * The target is rejecting the last message we sent. 5619 * 5620 * If the last message we attempted to send out was an 5621 * extended message, we were trying to negotiate sync 5622 * xfers- and we're okay. 5623 * 5624 * Otherwise, a target has rejected a message that 5625 * it should have handled. We will abort the operation 5626 * in progress and set the pkt_reason value here to 5627 * show why we have completed. The process of aborting 5628 * may be via a message or may be via a bus reset (as 5629 * a last resort). 5630 */ 5631 msgout = (TAGGED(tgt)? MSG_ABORT_TAG : MSG_ABORT); 5632 5633 switch (lastmsg) { 5634 case MSG_EXTENDED: 5635 if (fas->f_wdtr_sent) { 5636 /* 5637 * Disable wide, Target rejected 5638 * out WDTR message 5639 */ 5640 fas_set_wide_conf3(fas, tgt, 0); 5641 fas->f_nowide |= (1<<tgt); 5642 fas->f_wdtr_sent = 0; 5643 /* 5644 * we still want to negotiate sync 5645 */ 5646 if ((fas->f_nosync & (1<<tgt)) == 0) { 5647 fas_assert_atn(fas); 5648 fas_make_sdtr(fas, 0, tgt); 5649 } 5650 } else if (fas->f_sdtr_sent) { 5651 fas_reg_cmd_write(fas, CMD_CLR_ATN); 5652 fas_revert_to_async(fas, tgt); 5653 fas->f_nosync |= (1<<tgt); 5654 fas->f_sdtr_sent = 0; 5655 } 5656 msgout = 0; 5657 break; 5658 case MSG_NOP: 5659 reason = CMD_NOP_FAIL; 5660 break; 5661 case MSG_INITIATOR_ERROR: 5662 reason = CMD_IDE_FAIL; 5663 break; 5664 case MSG_MSG_PARITY: 5665 reason = CMD_PER_FAIL; 5666 break; 5667 case MSG_REJECT: 5668 reason = CMD_REJECT_FAIL; 5669 break; 5670 /* XXX - abort not good, queue full handling or drain (?) */ 5671 case MSG_SIMPLE_QTAG: 5672 case MSG_ORDERED_QTAG: 5673 case MSG_HEAD_QTAG: 5674 msgout = MSG_ABORT; 5675 reason = CMD_TAG_REJECT; 5676 break; 5677 case MSG_DEVICE_RESET: 5678 reason = CMD_BDR_FAIL; 5679 msgout = -ACTION_ABORT_CURCMD; 5680 break; 5681 case MSG_ABORT: 5682 case MSG_ABORT_TAG: 5683 /* 5684 * If an RESET/ABORT OPERATION message is rejected 5685 * it is time to yank the chain on the bus... 5686 */ 5687 reason = CMD_ABORT_FAIL; 5688 msgout = -ACTION_ABORT_CURCMD; 5689 break; 5690 default: 5691 if (IS_IDENTIFY_MSG(lastmsg)) { 5692 if (TAGGED(tgt)) { 5693 /* 5694 * this often happens when the 5695 * target rejected our tag 5696 */ 5697 reason = CMD_TAG_REJECT; 5698 } else { 5699 reason = CMD_ID_FAIL; 5700 } 5701 } else { 5702 reason = CMD_TRAN_ERR; 5703 msgout = -ACTION_ABORT_CURCMD; 5704 } 5705 5706 break; 5707 } 5708 5709 if (msgout) { 5710 fas_log(fas, CE_WARN, 5711 "Target %d rejects our message '%s'", 5712 tgt, scsi_mname(lastmsg)); 5713 fas_set_pkt_reason(fas, sp, reason, 0); 5714 } 5715 5716 break; 5717 } 5718 case MSG_RESTORE_PTRS: 5719 sp->cmd_cdbp = sp->cmd_pkt->pkt_cdbp; 5720 if (sp->cmd_data_count != sp->cmd_saved_data_count) { 5721 if (fas_restore_pointers(fas, sp)) { 5722 msgout = -ACTION_ABORT_CURCMD; 5723 } else if ((sp->cmd_pkt->pkt_reason & CMD_TRAN_ERR) && 5724 (sp->cmd_pkt->pkt_statistics & STAT_PERR) && 5725 (sp->cmd_cur_win == 0) && 5726 (sp->cmd_data_count == 0)) { 5727 sp->cmd_pkt->pkt_reason &= ~CMD_TRAN_ERR; 5728 } 5729 } 5730 break; 5731 5732 case MSG_SAVE_DATA_PTR: 5733 sp->cmd_saved_data_count = sp->cmd_data_count; 5734 sp->cmd_saved_win = sp->cmd_cur_win; 5735 sp->cmd_saved_cur_addr = sp->cmd_cur_addr; 5736 break; 5737 5738 /* These don't make sense for us, and */ 5739 /* will be rejected */ 5740 /* case MSG_INITIATOR_ERROR */ 5741 /* case MSG_ABORT */ 5742 /* case MSG_MSG_PARITY */ 5743 /* case MSG_DEVICE_RESET */ 5744 default: 5745 msgout = MSG_REJECT; 5746 fas_log(fas, CE_WARN, 5747 "Rejecting message '%s' from Target %d", 5748 scsi_mname(msgin), tgt); 5749 break; 5750 } 5751 5752 EPRINTF1("Message in: %s\n", scsi_mname(msgin)); 5753 5754 return (msgout); 5755 } 5756 5757 /* 5758 * phase handlers that are rarely used 5759 */ 5760 static int 5761 fas_handle_cmd_start(struct fas *fas) 5762 { 5763 struct fas_cmd *sp = fas->f_current_sp; 5764 volatile uchar_t *tp = fas->f_cmdarea; 5765 int i; 5766 int amt = sp->cmd_cdblen; 5767 5768 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CMD_START_START, 5769 "fas_handle_cmd_start_start"); 5770 EPRINTF("fas_handle_cmd: send cmd\n"); 5771 5772 for (i = 0; i < amt; i++) { 5773 *tp++ = sp->cmd_cdbp[i]; 5774 } 5775 fas_reg_cmd_write(fas, CMD_FLUSH); 5776 5777 FAS_DMA_READ(fas, amt, fas->f_dmacookie.dmac_address, amt, 5778 CMD_TRAN_INFO|CMD_DMA); 5779 fas->f_lastcount = amt; 5780 5781 New_state(fas, ACTS_CMD_DONE); 5782 5783 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CMD_START_END, 5784 "fas_handle_cmd_start_end"); 5785 return (ACTION_RETURN); 5786 } 5787 5788 static int 5789 fas_handle_cmd_done(struct fas *fas) 5790 { 5791 struct fas_cmd *sp = fas->f_current_sp; 5792 uchar_t intr = fas->f_intr; 5793 volatile struct dma *dmar = fas->f_dma; 5794 5795 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CMD_DONE_START, 5796 "fas_handle_cmd_done_start"); 5797 EPRINTF("fas_handle_cmd_done\n"); 5798 5799 /* 5800 * We should have gotten a BUS SERVICE interrupt. 5801 * If it isn't that, and it isn't a DISCONNECT 5802 * interrupt, we have a "cannot happen" situation. 5803 */ 5804 if ((intr & FAS_INT_BUS) == 0) { 5805 if ((intr & FAS_INT_DISCON) == 0) { 5806 fas_printstate(fas, "cmd transmission error"); 5807 TRACE_0(TR_FAC_SCSI_FAS, 5808 TR_FAS_HANDLE_CMD_DONE_ABORT1_END, 5809 "fas_handle_cmd_done_end (abort1)"); 5810 return (ACTION_ABORT_CURCMD); 5811 } 5812 } else { 5813 sp->cmd_pkt->pkt_state |= STATE_SENT_CMD; 5814 } 5815 5816 fas->f_dma_csr = fas_dma_reg_read(fas, &dmar->dma_csr); 5817 FAS_FLUSH_DMA(fas); 5818 5819 New_state(fas, ACTS_UNKNOWN); 5820 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_CMD_DONE_END, 5821 "fas_handle_cmd_done_end"); 5822 return (fas_handle_unknown(fas)); 5823 } 5824 5825 /* 5826 * Begin to send a message out 5827 */ 5828 static int 5829 fas_handle_msg_out_start(struct fas *fas) 5830 { 5831 struct fas_cmd *sp = fas->f_current_sp; 5832 uchar_t *msgout = fas->f_cur_msgout; 5833 uchar_t amt = fas->f_omsglen; 5834 5835 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_OUT_START, 5836 "fas_handle_msg_out_start"); 5837 EPRINTF("fas_handle_msg_out_start\n"); 5838 5839 /* 5840 * Check to make *sure* that we are really 5841 * in MESSAGE OUT phase. If the last state 5842 * was ACTS_MSG_OUT_DONE, then we are trying 5843 * to resend a message that the target stated 5844 * had a parity error in it. 5845 * 5846 * If this is the case, and mark completion reason as CMD_NOMSGOUT. 5847 * XXX: Right now, we just *drive* on. Should we abort the command? 5848 */ 5849 if ((fas->f_stat & FAS_PHASE_MASK) != FAS_PHASE_MSG_OUT && 5850 fas->f_laststate == ACTS_MSG_OUT_DONE) { 5851 fas_log(fas, CE_WARN, 5852 "Target %d refused message resend", Tgt(sp)); 5853 fas_set_pkt_reason(fas, sp, CMD_NOMSGOUT, 0); 5854 New_state(fas, ACTS_UNKNOWN); 5855 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_OUT_PHASEMANAGE_END, 5856 "fas_handle_msg_out_end (ACTION_PHASEMANAGE)"); 5857 return (ACTION_PHASEMANAGE); 5858 } 5859 5860 /* 5861 * Clean the fifo. 5862 */ 5863 fas_reg_cmd_write(fas, CMD_FLUSH); 5864 5865 if (amt == 0) { 5866 /* 5867 * no msg to send 5868 */ 5869 *msgout = MSG_NOP; 5870 amt = fas->f_omsglen = 1; 5871 } 5872 5873 /* 5874 * If msg only 1 byte, just dump it in the fifo and go. For 5875 * multi-byte msgs, dma them to save time. If we have no 5876 * msg to send and we're in msg out phase, send a NOP. 5877 */ 5878 fas->f_last_msgout = *msgout; 5879 5880 /* 5881 * There is a bug in the fas366 that occasionaly 5882 * deasserts the ATN signal prematurely when we send 5883 * the sync/wide negotiation bytes out using DMA. The 5884 * workaround here is to send the negotiation bytes out 5885 * using PIO 5886 */ 5887 fas_write_fifo(fas, msgout, fas->f_omsglen, 1); 5888 fas_reg_cmd_write(fas, CMD_TRAN_INFO); 5889 5890 EPRINTF2("amt=%x, last_msgout=%x\n", amt, fas->f_last_msgout); 5891 5892 New_state(fas, ACTS_MSG_OUT_DONE); 5893 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_OUT_END, 5894 "fas_handle_msg_out_end"); 5895 return (ACTION_RETURN); 5896 } 5897 5898 static int 5899 fas_handle_msg_out_done(struct fas *fas) 5900 { 5901 struct fas_cmd *sp = fas->f_current_sp; 5902 uchar_t msgout, phase; 5903 int target = Tgt(sp); 5904 int amt = fas->f_omsglen; 5905 int action; 5906 5907 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_OUT_DONE_START, 5908 "fas_handle_msg_out_done_start"); 5909 msgout = fas->f_cur_msgout[0]; 5910 if ((msgout == MSG_HEAD_QTAG) || (msgout == MSG_SIMPLE_QTAG)) { 5911 msgout = fas->f_cur_msgout[2]; 5912 } 5913 EPRINTF4("msgout: %x %x %x, last_msgout=%x\n", 5914 fas->f_cur_msgout[0], fas->f_cur_msgout[1], 5915 fas->f_cur_msgout[2], fas->f_last_msgout); 5916 5917 EPRINTF1("fas_handle_msgout_done: msgout=%x\n", msgout); 5918 5919 /* 5920 * flush fifo, just in case some bytes were not sent 5921 */ 5922 fas_reg_cmd_write(fas, CMD_FLUSH); 5923 5924 /* 5925 * If the FAS disconnected, then the message we sent caused 5926 * the target to decide to drop BSY* and clear the bus. 5927 */ 5928 if (fas->f_intr == FAS_INT_DISCON) { 5929 if (msgout == MSG_DEVICE_RESET || msgout == MSG_ABORT || 5930 msgout == MSG_ABORT_TAG) { 5931 /* 5932 * If we sent a device reset msg, then we need to do 5933 * a synch negotiate again unless we have already 5934 * inhibited synch. 5935 */ 5936 if (msgout == MSG_ABORT || msgout == MSG_ABORT_TAG) { 5937 fas->f_abort_msg_sent++; 5938 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 5939 fas_set_pkt_reason(fas, sp, 5940 CMD_ABORTED, STAT_ABORTED); 5941 } 5942 } else if (msgout == MSG_DEVICE_RESET) { 5943 fas->f_reset_msg_sent++; 5944 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 5945 fas_set_pkt_reason(fas, sp, 5946 CMD_RESET, STAT_DEV_RESET); 5947 } 5948 fas_force_renegotiation(fas, Tgt(sp)); 5949 } 5950 EPRINTF2("Successful %s message to target %d\n", 5951 scsi_mname(msgout), target); 5952 5953 if (sp->cmd_flags & CFLAG_CMDPROXY) { 5954 sp->cmd_cdb[FAS_PROXY_RESULT] = TRUE; 5955 } 5956 TRACE_0(TR_FAC_SCSI_FAS, 5957 TR_FAS_HANDLE_MSG_OUT_DONE_FINISH_END, 5958 "fas_handle_msg_out_done_end (ACTION_FINISH)"); 5959 return (ACTION_FINISH); 5960 } 5961 /* 5962 * If the target dropped busy on any other message, it 5963 * wasn't expected. We will let the code in fas_phasemanage() 5964 * handle this unexpected bus free event. 5965 */ 5966 goto out; 5967 } 5968 5969 /* 5970 * What phase have we transitioned to? 5971 */ 5972 phase = fas->f_stat & FAS_PHASE_MASK; 5973 5974 /* 5975 * If we finish sending a message out, and we are 5976 * still in message out phase, then the target has 5977 * detected one or more parity errors in the message 5978 * we just sent and it is asking us to resend the 5979 * previous message. 5980 */ 5981 if ((fas->f_intr & FAS_INT_BUS) && phase == FAS_PHASE_MSG_OUT) { 5982 /* 5983 * As per SCSI-2 specification, if the message to 5984 * be re-sent is greater than one byte, then we 5985 * have to set ATN*. 5986 */ 5987 if (amt > 1) { 5988 fas_assert_atn(fas); 5989 } 5990 fas_log(fas, CE_WARN, 5991 "SCSI bus MESSAGE OUT phase parity error"); 5992 sp->cmd_pkt->pkt_statistics |= STAT_PERR; 5993 New_state(fas, ACTS_MSG_OUT); 5994 TRACE_0(TR_FAC_SCSI_FAS, 5995 TR_FAS_HANDLE_MSG_OUT_DONE_PHASEMANAGE_END, 5996 "fas_handle_msg_out_done_end (ACTION_PHASEMANAGE)"); 5997 return (ACTION_PHASEMANAGE); 5998 } 5999 6000 6001 out: 6002 fas->f_last_msgout = msgout; 6003 fas->f_omsglen = 0; 6004 New_state(fas, ACTS_UNKNOWN); 6005 action = fas_handle_unknown(fas); 6006 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_HANDLE_MSG_OUT_DONE_END, 6007 "fas_handle_msg_out_done_end"); 6008 return (action); 6009 } 6010 6011 static int 6012 fas_twobyte_msg(struct fas *fas) 6013 { 6014 struct fas_cmd *sp = fas->f_current_sp; 6015 6016 if ((fas->f_imsgarea[0] == MSG_IGNORE_WIDE_RESID) && 6017 (fas->f_imsgarea[1] == 1)) { 6018 int xfer_amt; 6019 6020 /* 6021 * Knock off one byte if there 6022 * is a last transfer and is even number of bytes 6023 */ 6024 xfer_amt = sp->cmd_data_count - sp->cmd_saved_data_count; 6025 if (xfer_amt && (!(xfer_amt & 1))) { 6026 ASSERT(sp->cmd_data_count > 0); 6027 sp->cmd_data_count--; 6028 sp->cmd_cur_addr--; 6029 } 6030 IPRINTF1("ignore wide resid %d\n", fas->f_imsgarea[1]); 6031 New_state(fas, ACTS_UNKNOWN); 6032 return (0); 6033 } 6034 6035 fas_log(fas, CE_WARN, 6036 "Two byte message '%s' 0x%x rejected", 6037 scsi_mname(fas->f_imsgarea[0]), fas->f_imsgarea[1]); 6038 return (MSG_REJECT); 6039 } 6040 6041 /* 6042 * handle receiving extended messages 6043 */ 6044 static int 6045 fas_multibyte_msg(struct fas *fas) 6046 { 6047 #ifdef FASDEBUG 6048 static char *mbs = 6049 "Target %d now Synchronous at %d.%d MB/s max transmit rate\n"; 6050 static char *mbs1 = 6051 "Target %d now Synchronous at %d.0%d MB/s max transmit rate\n"; 6052 static char *mbs2 = 6053 "Target %d now Synchronous at %d.00%d MB/s max transmit rate\n"; 6054 #endif 6055 struct fas_cmd *sp = fas->f_current_sp; 6056 volatile struct fasreg *fasreg = fas->f_reg; 6057 uchar_t emsg = fas->f_imsgarea[2]; 6058 int tgt = Tgt(sp); 6059 int msgout = 0; 6060 6061 EPRINTF("fas_multibyte_msg:\n"); 6062 6063 if (emsg == MSG_SYNCHRONOUS) { 6064 uint_t period, offset, regval; 6065 uint_t minsync, maxsync, clockval; 6066 uint_t xfer_freq, xfer_div, xfer_mod, xfer_rate; 6067 6068 period = fas->f_imsgarea[3] & 0xff; 6069 offset = fas->f_imsgarea[4] & 0xff; 6070 minsync = MIN_SYNC_PERIOD(fas); 6071 maxsync = MAX_SYNC_PERIOD(fas); 6072 DPRINTF5("sync msg received: %x %x %x %x %x\n", 6073 fas->f_imsgarea[0], fas->f_imsgarea[1], 6074 fas->f_imsgarea[2], fas->f_imsgarea[3], 6075 fas->f_imsgarea[4]); 6076 DPRINTF3("received period %d offset %d from tgt %d\n", 6077 period, offset, tgt); 6078 DPRINTF3("calculated minsync %d, maxsync %d for tgt %d\n", 6079 minsync, maxsync, tgt); 6080 DPRINTF2("sync period %d, neg period %d\n", 6081 fas->f_sync_period[tgt], fas->f_neg_period[tgt]); 6082 6083 if ((++(fas->f_sdtr_sent)) & 1) { 6084 /* 6085 * In cases where the target negotiates synchronous 6086 * mode before we do, and we either have sync mode 6087 * disabled, or this target is known to be a weak 6088 * signal target, we send back a message indicating 6089 * a desire to stay in asynchronous mode (the SCSI-2 6090 * spec states that if we have synchronous capability 6091 * then we cannot reject a SYNCHRONOUS DATA TRANSFER 6092 * REQUEST message). 6093 */ 6094 IPRINTF1("SYNC negotiation initiated by target %d\n", 6095 tgt); 6096 6097 msgout = MSG_EXTENDED; 6098 6099 period = 6100 period ? max(period, MIN_SYNC_PERIOD(fas)) : 0; 6101 6102 if (fas->f_backoff & (1<<tgt)) { 6103 period = period ? 6104 max(period, fas->f_neg_period[tgt]) : 0; 6105 } 6106 offset = min(offset, fas_default_offset); 6107 } 6108 xfer_freq = regval = 0; 6109 6110 /* 6111 * If the target's offset is bigger than ours, 6112 * the target has violated the scsi protocol. 6113 */ 6114 if (offset > fas_default_offset) { 6115 period = offset = 0; 6116 msgout = MSG_REJECT; 6117 } 6118 6119 if (offset && (period > maxsync)) { 6120 /* 6121 * We cannot transmit data in synchronous 6122 * mode this slow, so convert to asynchronous 6123 * mode. 6124 */ 6125 msgout = MSG_EXTENDED; 6126 period = offset = 0; 6127 6128 } else if (offset && (period < minsync)) { 6129 /* 6130 * If the target's period is less than ours, 6131 * the target has violated the scsi protocol. 6132 */ 6133 period = offset = 0; 6134 msgout = MSG_REJECT; 6135 6136 } else if (offset) { 6137 /* 6138 * Conversion method for received PERIOD value 6139 * to the number of input clock ticks to the FAS. 6140 * 6141 * We adjust the input period value such that 6142 * we always will transmit data *not* faster 6143 * than the period value received. 6144 */ 6145 6146 clockval = fas->f_clock_cycle / 1000; 6147 regval = (((period << 2) + clockval - 1) / clockval); 6148 6149 /* 6150 * correction if xfer rate <= 5MB/sec 6151 * XXX do we need this? 6152 */ 6153 if (regval && (period >= FASTSCSI_THRESHOLD)) { 6154 regval--; 6155 } 6156 } 6157 6158 fas->f_offset[tgt] = offset; 6159 fas->f_neg_period[tgt] = period; 6160 6161 /* 6162 * Is is now safe to produce a responce to a target 6163 * initiated sdtr. period and offset have been checked. 6164 */ 6165 if (msgout == MSG_EXTENDED) { 6166 fas_make_sdtr(fas, 0, tgt); 6167 period = fas->f_neg_period[tgt]; 6168 offset = (fas->f_offset[tgt] & 0xf); 6169 } 6170 6171 if (offset) { 6172 fas->f_sync_period[tgt] = regval & SYNC_PERIOD_MASK; 6173 fas_reg_write(fas, (uchar_t *)&fasreg->fas_sync_period, 6174 fas->f_sync_period[tgt]); 6175 6176 fas->f_offset[tgt] = offset | fas->f_req_ack_delay; 6177 fas_reg_write(fas, (uchar_t *)&fasreg->fas_sync_offset, 6178 fas->f_offset[tgt]); 6179 6180 /* 6181 * if transferring > 5 MB/sec then enable 6182 * fastscsi in conf3 6183 */ 6184 if (period < FASTSCSI_THRESHOLD) { 6185 fas->f_fasconf3[tgt] |= FAS_CONF3_FASTSCSI; 6186 } else { 6187 fas->f_fasconf3[tgt] &= ~FAS_CONF3_FASTSCSI; 6188 } 6189 6190 fas_reg_write(fas, (uchar_t *)&fasreg->fas_conf3, 6191 fas->f_fasconf3[tgt]); 6192 6193 DPRINTF4("period %d (%d), offset %d to tgt %d\n", 6194 period, 6195 fas->f_sync_period[tgt] & SYNC_PERIOD_MASK, 6196 fas->f_offset[tgt] & 0xf, tgt); 6197 DPRINTF1("req/ack delay = %x\n", fas->f_req_ack_delay); 6198 DPRINTF1("conf3 = %x\n", fas->f_fasconf3[tgt]); 6199 #ifdef FASDEBUG 6200 /* 6201 * Convert input clock cycle per 6202 * byte to nanoseconds per byte. 6203 * (ns/b), and convert that to 6204 * k-bytes/second. 6205 */ 6206 xfer_freq = FAS_SYNC_KBPS((regval * 6207 fas->f_clock_cycle) / 1000); 6208 xfer_rate = ((fas->f_nowide & (1<<tgt))? 1 : 2) * 6209 xfer_freq; 6210 xfer_div = xfer_rate / 1000; 6211 xfer_mod = xfer_rate % 1000; 6212 6213 6214 if (xfer_mod > 99) { 6215 IPRINTF3(mbs, tgt, xfer_div, xfer_mod); 6216 } else if (xfer_mod > 9) { 6217 IPRINTF3(mbs1, tgt, xfer_div, xfer_mod); 6218 } else { 6219 IPRINTF3(mbs2, tgt, xfer_div, xfer_mod); 6220 } 6221 #endif 6222 fas->f_sync_enabled |= (1<<tgt); 6223 6224 } else { 6225 /* 6226 * We are converting back to async mode. 6227 */ 6228 fas_revert_to_async(fas, tgt); 6229 } 6230 6231 /* 6232 * If this target violated the scsi spec, reject the 6233 * sdtr msg and don't negotiate sdtr again. 6234 */ 6235 if (msgout == MSG_REJECT) { 6236 fas->f_nosync |= (1<<tgt); 6237 } 6238 6239 fas->f_props_update |= (1<<tgt); 6240 6241 } else if (emsg == MSG_WIDE_DATA_XFER) { 6242 uchar_t width = fas->f_imsgarea[3] & 0xff; 6243 6244 DPRINTF4("wide msg received: %x %x %x %x\n", 6245 fas->f_imsgarea[0], fas->f_imsgarea[1], 6246 fas->f_imsgarea[2], fas->f_imsgarea[3]); 6247 6248 /* always renegotiate sync after wide */ 6249 msgout = MSG_EXTENDED; 6250 6251 if ((++(fas->f_wdtr_sent)) & 1) { 6252 IPRINTF1("Wide negotiation initiated by target %d\n", 6253 tgt); 6254 /* 6255 * allow wide neg even if the target driver hasn't 6256 * enabled wide yet. 6257 */ 6258 fas->f_nowide &= ~(1<<tgt); 6259 fas_make_wdtr(fas, 0, tgt, width); 6260 IPRINTF1("sending wide sync %d back\n", width); 6261 /* 6262 * Let us go back to async mode(SCSI spec) 6263 * and depend on target to do sync 6264 * after wide negotiations. 6265 * If target does not do a sync neg and enters 6266 * async mode we will negotiate sync on next command 6267 */ 6268 fas_revert_to_async(fas, tgt); 6269 fas->f_sync_known &= ~(1<<tgt); 6270 } else { 6271 /* 6272 * renegotiate sync after wide 6273 */ 6274 fas_set_wide_conf3(fas, tgt, width); 6275 ASSERT(width <= 1); 6276 fas->f_wdtr_sent = 0; 6277 if ((fas->f_nosync & (1<<tgt)) == 0) { 6278 fas_make_sdtr(fas, 0, tgt); 6279 } else { 6280 msgout = 0; 6281 } 6282 } 6283 6284 fas->f_props_update |= (1<<tgt); 6285 6286 } else if (emsg == MSG_MODIFY_DATA_PTR) { 6287 msgout = MSG_REJECT; 6288 } else { 6289 fas_log(fas, CE_WARN, 6290 "Rejecting message %s 0x%x from Target %d", 6291 scsi_mname(MSG_EXTENDED), emsg, tgt); 6292 msgout = MSG_REJECT; 6293 } 6294 out: 6295 New_state(fas, ACTS_UNKNOWN); 6296 return (msgout); 6297 } 6298 6299 /* 6300 * Back off sync negotiation 6301 * and got to async mode 6302 */ 6303 static void 6304 fas_revert_to_async(struct fas *fas, int tgt) 6305 { 6306 volatile struct fasreg *fasreg = fas->f_reg; 6307 6308 fas->f_sync_period[tgt] = 0; 6309 fas_reg_write(fas, (uchar_t *)&fasreg->fas_sync_period, 0); 6310 fas->f_offset[tgt] = 0; 6311 fas_reg_write(fas, (uchar_t *)&fasreg->fas_sync_offset, 0); 6312 fas->f_fasconf3[tgt] &= ~FAS_CONF3_FASTSCSI; 6313 fas_reg_write(fas, &fasreg->fas_conf3, fas->f_fasconf3[tgt]); 6314 fas->f_sync_enabled &= ~(1<<tgt); 6315 } 6316 6317 /* 6318 * handle an unexpected selection attempt 6319 * XXX look for better way: msg reject, drop off the bus 6320 */ 6321 static int 6322 fas_handle_selection(struct fas *fas) 6323 { 6324 fas_reg_cmd_write(fas, CMD_DISCONNECT); 6325 fas_reg_cmd_write(fas, CMD_FLUSH); 6326 fas_reg_cmd_write(fas, CMD_EN_RESEL); 6327 return (ACTION_RETURN); 6328 } 6329 6330 /* 6331 * dma window handling 6332 */ 6333 static int 6334 fas_restore_pointers(struct fas *fas, struct fas_cmd *sp) 6335 { 6336 if (sp->cmd_data_count != sp->cmd_saved_data_count) { 6337 sp->cmd_data_count = sp->cmd_saved_data_count; 6338 sp->cmd_cur_addr = sp->cmd_saved_cur_addr; 6339 6340 if (sp->cmd_cur_win != sp->cmd_saved_win) { 6341 sp->cmd_cur_win = sp->cmd_saved_win; 6342 if (fas_set_new_window(fas, sp)) { 6343 return (-1); 6344 } 6345 } 6346 DPRINTF1("curaddr=%x\n", sp->cmd_cur_addr); 6347 } 6348 return (0); 6349 } 6350 6351 static int 6352 fas_set_new_window(struct fas *fas, struct fas_cmd *sp) 6353 { 6354 off_t offset; 6355 size_t len; 6356 uint_t count; 6357 6358 if (ddi_dma_getwin(sp->cmd_dmahandle, sp->cmd_cur_win, 6359 &offset, &len, &sp->cmd_dmacookie, &count) != DDI_SUCCESS) { 6360 return (-1); 6361 } 6362 6363 DPRINTF4("new window %x: off=%lx, len=%lx, count=%x\n", 6364 sp->cmd_cur_win, offset, len, count); 6365 6366 ASSERT(count == 1); 6367 return (0); 6368 } 6369 6370 static int 6371 fas_next_window(struct fas *fas, struct fas_cmd *sp, uint64_t end) 6372 { 6373 6374 /* are there more windows? */ 6375 if (sp->cmd_nwin == 0) { 6376 uint_t nwin = 0; 6377 (void) ddi_dma_numwin(sp->cmd_dmahandle, &nwin); 6378 sp->cmd_nwin = (uchar_t)nwin; 6379 } 6380 6381 DPRINTF5( 6382 "cmd_data_count=%x, dmacount=%x, curaddr=%x, end=%lx, nwin=%x\n", 6383 sp->cmd_data_count, sp->cmd_dmacount, sp->cmd_cur_addr, end, 6384 sp->cmd_nwin); 6385 6386 if (sp->cmd_cur_win < sp->cmd_nwin) { 6387 sp->cmd_cur_win++; 6388 if (fas_set_new_window(fas, sp)) { 6389 fas_printstate(fas, "cannot set new window"); 6390 sp->cmd_cur_win--; 6391 return (-1); 6392 } 6393 /* 6394 * if there are no more windows, we have a data overrun condition 6395 */ 6396 } else { 6397 int slot = sp->cmd_slot; 6398 6399 fas_printstate(fas, "data transfer overrun"); 6400 fas_set_pkt_reason(fas, sp, CMD_DATA_OVR, 0); 6401 6402 /* 6403 * if we get data transfer overruns, assume we have 6404 * a weak scsi bus. Note that this won't catch consistent 6405 * underruns or other noise related syndromes. 6406 */ 6407 fas_sync_wide_backoff(fas, sp, slot); 6408 return (-1); 6409 } 6410 sp->cmd_cur_addr = sp->cmd_dmacookie.dmac_address; 6411 DPRINTF1("cur_addr=%x\n", sp->cmd_cur_addr); 6412 return (0); 6413 } 6414 6415 /* 6416 * dma error handler 6417 */ 6418 static int 6419 fas_check_dma_error(struct fas *fas) 6420 { 6421 /* 6422 * was there a dma error that caused fas_intr_svc() to be called? 6423 */ 6424 if (fas->f_dma->dma_csr & DMA_ERRPEND) { 6425 /* 6426 * It would be desirable to set the ATN* line and attempt to 6427 * do the whole schmear of INITIATOR DETECTED ERROR here, 6428 * but that is too hard to do at present. 6429 */ 6430 fas_log(fas, CE_WARN, "Unrecoverable DMA error"); 6431 fas_printstate(fas, "dma error"); 6432 fas_set_pkt_reason(fas, fas->f_current_sp, CMD_TRAN_ERR, 0); 6433 return (-1); 6434 } 6435 return (0); 6436 } 6437 6438 /* 6439 * check for gross error or spurious interrupt 6440 */ 6441 static int 6442 fas_handle_gross_err(struct fas *fas) 6443 { 6444 volatile struct fasreg *fasreg = fas->f_reg; 6445 6446 fas_log(fas, CE_WARN, 6447 "gross error in fas status (%x)", fas->f_stat); 6448 6449 IPRINTF5("fas_cmd=%x, stat=%x, intr=%x, step=%x, fifoflag=%x\n", 6450 fasreg->fas_cmd, fas->f_stat, fas->f_intr, fasreg->fas_step, 6451 fasreg->fas_fifo_flag); 6452 6453 fas_set_pkt_reason(fas, fas->f_current_sp, CMD_TRAN_ERR, 0); 6454 6455 fas_internal_reset(fas, FAS_RESET_FAS); 6456 return (ACTION_RESET); 6457 } 6458 6459 6460 /* 6461 * handle illegal cmd interrupt or (external) bus reset cleanup 6462 */ 6463 static int 6464 fas_illegal_cmd_or_bus_reset(struct fas *fas) 6465 { 6466 /* 6467 * If we detect a SCSI reset, we blow away the current 6468 * command (if there is one) and all disconnected commands 6469 * because we now don't know the state of them at all. 6470 */ 6471 ASSERT(fas->f_intr & (FAS_INT_ILLEGAL | FAS_INT_RESET)); 6472 6473 if (fas->f_intr & FAS_INT_RESET) { 6474 return (ACTION_FINRST); 6475 } 6476 6477 /* 6478 * Illegal cmd to fas: 6479 * This should not happen. The one situation where 6480 * we can get an ILLEGAL COMMAND interrupt is due to 6481 * a bug in the FAS366 during reselection which we 6482 * should be handling in fas_reconnect(). 6483 */ 6484 if (fas->f_intr & FAS_INT_ILLEGAL) { 6485 IPRINTF1("lastcmd=%x\n", fas->f_reg->fas_cmd); 6486 fas_printstate(fas, "ILLEGAL bit set"); 6487 return (ACTION_RESET); 6488 } 6489 /*NOTREACHED*/ 6490 return (ACTION_RETURN); 6491 } 6492 6493 /* 6494 * set throttles for all luns of this target 6495 */ 6496 static void 6497 fas_set_throttles(struct fas *fas, int slot, int n, int what) 6498 { 6499 int i; 6500 6501 /* 6502 * if the bus is draining/quiesced, no changes to the throttles 6503 * are allowed. Not allowing change of throttles during draining 6504 * limits error recovery but will reduce draining time 6505 * 6506 * all throttles should have been set to HOLD_THROTTLE 6507 */ 6508 if (fas->f_softstate & (FAS_SS_QUIESCED | FAS_SS_DRAINING)) { 6509 return; 6510 } 6511 6512 ASSERT((n == 1) || (n == N_SLOTS) || (n == NLUNS_PER_TARGET)); 6513 ASSERT((slot + n) <= N_SLOTS); 6514 if (n == NLUNS_PER_TARGET) { 6515 slot &= ~(NLUNS_PER_TARGET - 1); 6516 } 6517 6518 for (i = slot; i < (slot + n); i++) { 6519 if (what == HOLD_THROTTLE) { 6520 fas->f_throttle[i] = HOLD_THROTTLE; 6521 } else if ((fas->f_reset_delay[i/NLUNS_PER_TARGET]) == 0) { 6522 if (what == MAX_THROTTLE) { 6523 int tshift = 1 << (i/NLUNS_PER_TARGET); 6524 fas->f_throttle[i] = (short) 6525 ((fas->f_notag & tshift)? 1 : what); 6526 } else { 6527 fas->f_throttle[i] = what; 6528 } 6529 } 6530 } 6531 } 6532 6533 static void 6534 fas_set_all_lun_throttles(struct fas *fas, int slot, int what) 6535 { 6536 /* 6537 * fas_set_throttle will adjust slot to starting at LUN 0 6538 */ 6539 fas_set_throttles(fas, slot, NLUNS_PER_TARGET, what); 6540 } 6541 6542 static void 6543 fas_full_throttle(struct fas *fas, int slot) 6544 { 6545 fas_set_throttles(fas, slot, 1, MAX_THROTTLE); 6546 } 6547 6548 /* 6549 * run a polled cmd 6550 */ 6551 static void 6552 fas_runpoll(struct fas *fas, short slot, struct fas_cmd *sp) 6553 { 6554 int limit, i, n; 6555 int timeout = 0; 6556 6557 DPRINTF4("runpoll: slot=%x, cmd=%x, current_sp=0x%p, tcmds=%x\n", 6558 slot, *((uchar_t *)sp->cmd_pkt->pkt_cdbp), 6559 (void *)fas->f_current_sp, fas->f_tcmds[slot]); 6560 6561 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_RUNPOLL_START, "fas_runpoll_start"); 6562 6563 /* 6564 * wait for cmd to complete 6565 * don't start new cmds so set throttles to HOLD_THROTTLE 6566 */ 6567 while ((sp->cmd_flags & CFLAG_COMPLETED) == 0) { 6568 if (!(sp->cmd_flags & CFLAG_CMDPROXY)) { 6569 fas_set_all_lun_throttles(fas, slot, HOLD_THROTTLE); 6570 } 6571 if ((fas->f_state != STATE_FREE) || INTPENDING(fas)) { 6572 if (fas_dopoll(fas, POLL_TIMEOUT) <= 0) { 6573 IPRINTF("runpoll: timeout on draining\n"); 6574 goto bad; 6575 } 6576 } 6577 6578 ASSERT(fas->f_state == STATE_FREE); 6579 ASSERT(fas->f_current_sp == NULL); 6580 6581 /* 6582 * if this is not a proxy cmd, don't start the cmd 6583 * without draining the active cmd(s) 6584 * for proxy cmds, we zap the active cmd and assume 6585 * that the caller will take care of this 6586 * For tagged cmds, wait with submitting a non-tagged 6587 * cmd until the queue has been drained 6588 * If the cmd is a request sense, then draining won't 6589 * help since we are in contingence allegiance condition 6590 */ 6591 if (!(sp->cmd_flags & CFLAG_CMDPROXY)) { 6592 uchar_t *cmdp = (uchar_t *)sp->cmd_pkt->pkt_cdbp; 6593 6594 if ((fas->f_tcmds[slot]) && 6595 (NOTAG(Tgt(sp)) || 6596 (((sp->cmd_pkt_flags & FLAG_TAGMASK) == 0) && 6597 (*cmdp != SCMD_REQUEST_SENSE)))) { 6598 if (timeout < POLL_TIMEOUT) { 6599 timeout += 100; 6600 drv_usecwait(100); 6601 continue; 6602 } else { 6603 fas_log(fas, CE_WARN, 6604 "polled cmd failed (target busy)"); 6605 goto cleanup; 6606 } 6607 } 6608 } 6609 6610 /* 6611 * If the draining of active commands killed the 6612 * the current polled command, we're done.. 6613 */ 6614 if (sp->cmd_flags & CFLAG_COMPLETED) { 6615 break; 6616 } 6617 6618 /* 6619 * ensure we are not accessing a target too quickly 6620 * after a reset. the throttles get set back later 6621 * by the reset delay watch; hopefully, we don't go 6622 * thru this loop more than once 6623 */ 6624 if (fas->f_reset_delay[slot/NLUNS_PER_TARGET]) { 6625 IPRINTF1("reset delay set for slot %x\n", slot); 6626 drv_usecwait(fas->f_scsi_reset_delay * 1000); 6627 for (i = 0; i < NTARGETS_WIDE; i++) { 6628 if (fas->f_reset_delay[i]) { 6629 int s = i * NLUNS_PER_TARGET; 6630 int e = s + NLUNS_PER_TARGET; 6631 fas->f_reset_delay[i] = 0; 6632 for (; s < e; s++) { 6633 fas_full_throttle(fas, s); 6634 } 6635 } 6636 } 6637 } 6638 6639 /* 6640 * fas_startcmd() will return false if preempted 6641 * or draining 6642 */ 6643 if (fas_startcmd(fas, sp) != TRUE) { 6644 IPRINTF("runpoll: cannot start new cmds\n"); 6645 ASSERT(fas->f_current_sp != sp); 6646 continue; 6647 } 6648 6649 /* 6650 * We're now 'running' this command. 6651 * 6652 * fas_dopoll will always return when 6653 * fas->f_state is STATE_FREE, and 6654 */ 6655 limit = sp->cmd_pkt->pkt_time * 1000000; 6656 if (limit == 0) { 6657 limit = POLL_TIMEOUT; 6658 } 6659 6660 /* 6661 * if the cmd disconnected, the first call to fas_dopoll 6662 * will return with bus free; we go thru the loop one more 6663 * time and wait limit usec for the target to reconnect 6664 */ 6665 for (i = 0; i <= POLL_TIMEOUT; i += 100) { 6666 6667 if ((n = fas_dopoll(fas, limit)) <= 0) { 6668 IPRINTF("runpoll: timeout on polling\n"); 6669 goto bad; 6670 } 6671 6672 /* 6673 * If a preemption occurred that caused this 6674 * command to actually not start, go around 6675 * the loop again. If CFLAG_COMPLETED is set, the 6676 * command completed 6677 */ 6678 if ((sp->cmd_flags & CFLAG_COMPLETED) || 6679 (sp->cmd_pkt->pkt_state == 0)) { 6680 break; 6681 } 6682 6683 /* 6684 * the bus may have gone free because the target 6685 * disconnected; go thru the loop again 6686 */ 6687 ASSERT(fas->f_state == STATE_FREE); 6688 if (n == 0) { 6689 /* 6690 * bump i, we have waited limit usecs in 6691 * fas_dopoll 6692 */ 6693 i += limit - 100; 6694 } 6695 } 6696 6697 if ((sp->cmd_flags & CFLAG_COMPLETED) == 0) { 6698 6699 if (i > POLL_TIMEOUT) { 6700 IPRINTF("polled timeout on disc. cmd\n"); 6701 goto bad; 6702 } 6703 6704 if (sp->cmd_pkt->pkt_state) { 6705 /* 6706 * don't go thru the loop again; the cmd 6707 * was already started 6708 */ 6709 IPRINTF("fas_runpoll: cmd started??\n"); 6710 goto bad; 6711 } 6712 } 6713 } 6714 6715 /* 6716 * blindly restore throttles which is preferable over 6717 * leaving throttle hanging at 0 and noone to clear it 6718 */ 6719 if (!(sp->cmd_flags & CFLAG_CMDPROXY)) { 6720 fas_set_all_lun_throttles(fas, slot, MAX_THROTTLE); 6721 } 6722 6723 /* 6724 * ensure that the cmd is completely removed 6725 */ 6726 fas_remove_cmd(fas, sp, 0); 6727 6728 /* 6729 * If we stored up commands to do, start them off now. 6730 */ 6731 if ((fas->f_state == STATE_FREE) && 6732 (!(sp->cmd_flags & CFLAG_CMDPROXY))) { 6733 (void) fas_ustart(fas); 6734 } 6735 exit: 6736 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_RUNPOLL_END, "fas_runpoll_end"); 6737 return; 6738 6739 bad: 6740 fas_log(fas, CE_WARN, "Polled cmd failed"); 6741 #ifdef FASDEBUG 6742 fas_printstate(fas, "fas_runpoll: polled cmd failed"); 6743 #endif /* FASDEBUG */ 6744 6745 cleanup: 6746 fas_set_all_lun_throttles(fas, slot, MAX_THROTTLE); 6747 6748 /* 6749 * clean up all traces of this sp because fas_runpoll will return 6750 * before fas_reset_recovery() cleans up 6751 */ 6752 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 6753 fas_decrement_ncmds(fas, sp); 6754 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 6755 6756 if ((sp->cmd_flags & CFLAG_CMDPROXY) == 0) { 6757 (void) fas_reset_bus(fas); 6758 } 6759 goto exit; 6760 } 6761 6762 /* 6763 * Poll for command completion (i.e., no interrupts) 6764 * limit is in usec (and will not be very accurate) 6765 * 6766 * the assumption is that we only run polled cmds in interrupt context 6767 * as scsi_transport will filter out FLAG_NOINTR 6768 */ 6769 static int 6770 fas_dopoll(struct fas *fas, int limit) 6771 { 6772 int i, n; 6773 6774 /* 6775 * timeout is not very accurate since we don't know how 6776 * long the poll takes 6777 * also if the packet gets started fairly late, we may 6778 * timeout prematurely 6779 * fas_dopoll always returns if e_state transitions to STATE_FREE 6780 */ 6781 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_DOPOLL_START, "fas_dopoll_start"); 6782 6783 if (limit == 0) { 6784 limit = POLL_TIMEOUT; 6785 } 6786 6787 for (n = i = 0; i < limit; i += 100) { 6788 if (INTPENDING(fas)) { 6789 fas->f_polled_intr = 1; 6790 n++; 6791 (void) fas_intr_svc(fas); 6792 if (fas->f_state == STATE_FREE) 6793 break; 6794 } 6795 drv_usecwait(100); 6796 } 6797 6798 if (i >= limit && fas->f_state != STATE_FREE) { 6799 fas_printstate(fas, "polled command timeout"); 6800 n = -1; 6801 } 6802 TRACE_1(TR_FAC_SCSI_FAS, TR_FAS_DOPOLL_END, 6803 "fas_dopoll_end: rval %x", n); 6804 return (n); 6805 } 6806 6807 /* 6808 * prepare a sync negotiation message 6809 */ 6810 static void 6811 fas_make_sdtr(struct fas *fas, int msgout_offset, int target) 6812 { 6813 uchar_t *p = fas->f_cur_msgout + msgout_offset; 6814 ushort_t tshift = 1<<target; 6815 uchar_t period = MIN_SYNC_PERIOD(fas); 6816 uchar_t offset = fas_default_offset; 6817 6818 /* 6819 * If this target experienced a sync backoff use the 6820 * target's sync speed that was adjusted in 6821 * fas_sync_wide_backoff. For second sync backoff, 6822 * offset will be ajusted below in sanity checks. 6823 */ 6824 if (fas->f_backoff & tshift) { 6825 period = fas->f_neg_period[target]; 6826 } 6827 6828 /* 6829 * If this is a responce to a target initiated sdtr, 6830 * use the agreed upon values. 6831 */ 6832 if (fas->f_sdtr_sent & 1) { 6833 period = fas->f_neg_period[target]; 6834 offset = fas->f_offset[target]; 6835 } 6836 6837 /* 6838 * If the target driver disabled 6839 * sync then make offset = 0 6840 */ 6841 if (fas->f_force_async & tshift) { 6842 offset = 0; 6843 } 6844 6845 /* 6846 * sanity check of period and offset 6847 */ 6848 if (fas->f_target_scsi_options[target] & SCSI_OPTIONS_FAST) { 6849 if (period < (uchar_t)(DEFAULT_FASTSYNC_PERIOD/4)) { 6850 period = (uchar_t)(DEFAULT_FASTSYNC_PERIOD/4); 6851 } 6852 } else if (fas->f_target_scsi_options[target] & SCSI_OPTIONS_SYNC) { 6853 if (period < (uchar_t)(DEFAULT_SYNC_PERIOD/4)) { 6854 period = (uchar_t)(DEFAULT_SYNC_PERIOD/4); 6855 } 6856 } else { 6857 fas->f_nosync |= tshift; 6858 } 6859 6860 if (fas->f_nosync & tshift) { 6861 offset = 0; 6862 } 6863 6864 if ((uchar_t)(offset & 0xf) > fas_default_offset) { 6865 offset = fas_default_offset | fas->f_req_ack_delay; 6866 } 6867 6868 fas->f_neg_period[target] = (uchar_t)period; 6869 fas->f_offset[target] = (uchar_t)offset; 6870 6871 *p++ = (uchar_t)MSG_EXTENDED; 6872 *p++ = (uchar_t)3; 6873 *p++ = (uchar_t)MSG_SYNCHRONOUS; 6874 *p++ = period; 6875 *p++ = offset & 0xf; 6876 fas->f_omsglen = 5 + msgout_offset; 6877 6878 IPRINTF2("fas_make_sdtr: period = %x, offset = %x\n", 6879 period, offset); 6880 /* 6881 * increment sdtr flag, odd value indicates that we initiated 6882 * the negotiation 6883 */ 6884 fas->f_sdtr_sent++; 6885 6886 /* 6887 * the target may reject the optional sync message so 6888 * to avoid negotiating on every cmd, set sync known here 6889 * we should not negotiate wide after sync again 6890 */ 6891 fas->f_sync_known |= 1<<target; 6892 fas->f_wide_known |= 1<<target; 6893 } 6894 6895 /* 6896 * prepare a wide negotiation message 6897 */ 6898 static void 6899 fas_make_wdtr(struct fas *fas, int msgout_offset, int target, int width) 6900 { 6901 uchar_t *p = fas->f_cur_msgout + msgout_offset; 6902 6903 if (((fas->f_target_scsi_options[target] & SCSI_OPTIONS_WIDE) == 0) || 6904 (fas->f_nowide & (1<<target))) { 6905 fas->f_nowide |= 1<<target; 6906 width = 0; 6907 } 6908 if (fas->f_force_narrow & (1<<target)) { 6909 width = 0; 6910 } 6911 width = min(FAS_XFER_WIDTH, width); 6912 6913 *p++ = (uchar_t)MSG_EXTENDED; 6914 *p++ = (uchar_t)2; 6915 *p++ = (uchar_t)MSG_WIDE_DATA_XFER; 6916 *p++ = (uchar_t)width; 6917 fas->f_omsglen = 4 + msgout_offset; 6918 IPRINTF1("fas_make_wdtr: width=%x\n", width); 6919 6920 /* 6921 * increment wdtr flag, odd value indicates that we initiated 6922 * the negotiation 6923 */ 6924 fas->f_wdtr_sent++; 6925 6926 /* 6927 * the target may reject the optional wide message so 6928 * to avoid negotiating on every cmd, set wide known here 6929 */ 6930 fas->f_wide_known |= 1<<target; 6931 6932 fas_set_wide_conf3(fas, target, width); 6933 } 6934 6935 /* 6936 * auto request sense support 6937 * create or destroy an auto request sense packet 6938 */ 6939 static int 6940 fas_create_arq_pkt(struct fas *fas, struct scsi_address *ap) 6941 { 6942 /* 6943 * Allocate a request sense packet using get_pktiopb 6944 */ 6945 struct fas_cmd *rqpktp; 6946 uchar_t slot = ap->a_target * NLUNS_PER_TARGET | ap->a_lun; 6947 struct buf *bp; 6948 struct arq_private_data *arq_data; 6949 6950 /* 6951 * if one exists, don't create another 6952 */ 6953 if (fas->f_arq_pkt[slot] != 0) { 6954 return (0); 6955 } 6956 6957 /* 6958 * it would be nicer if we could allow the target driver 6959 * to specify the size but this is easier and OK for most 6960 * drivers to use SENSE_LENGTH 6961 * Allocate a request sense packet. 6962 */ 6963 bp = scsi_alloc_consistent_buf(ap, (struct buf *)NULL, 6964 SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL); 6965 rqpktp = PKT2CMD(scsi_init_pkt(ap, 6966 NULL, bp, CDB_GROUP0, 1, PKT_PRIV_LEN, 6967 PKT_CONSISTENT, SLEEP_FUNC, NULL)); 6968 arq_data = 6969 (struct arq_private_data *)(rqpktp->cmd_pkt->pkt_private); 6970 arq_data->arq_save_bp = bp; 6971 6972 RQ_MAKECOM_G0((CMD2PKT(rqpktp)), 6973 FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON, 6974 (char)SCMD_REQUEST_SENSE, 0, (char)SENSE_LENGTH); 6975 rqpktp->cmd_flags |= CFLAG_CMDARQ; 6976 rqpktp->cmd_slot = slot; 6977 rqpktp->cmd_pkt->pkt_ha_private = rqpktp; 6978 fas->f_arq_pkt[slot] = rqpktp; 6979 6980 /* 6981 * we need a function ptr here so abort/reset can 6982 * defer callbacks; fas_call_pkt_comp() calls 6983 * fas_complete_arq_pkt() directly without releasing the lock 6984 * However, since we are not calling back directly thru 6985 * pkt_comp, don't check this with warlock 6986 */ 6987 #ifndef __lock_lint 6988 rqpktp->cmd_pkt->pkt_comp = 6989 (void (*)(struct scsi_pkt *))fas_complete_arq_pkt; 6990 #endif 6991 return (0); 6992 } 6993 6994 static int 6995 fas_delete_arq_pkt(struct fas *fas, struct scsi_address *ap) 6996 { 6997 struct fas_cmd *rqpktp; 6998 int slot = ap->a_target * NLUNS_PER_TARGET | ap->a_lun; 6999 7000 /* 7001 * if there is still a pkt saved or no rqpkt 7002 * then we cannot deallocate or there is nothing to do 7003 */ 7004 if ((rqpktp = fas->f_arq_pkt[slot]) != NULL) { 7005 struct arq_private_data *arq_data = 7006 (struct arq_private_data *)(rqpktp->cmd_pkt->pkt_private); 7007 struct buf *bp = arq_data->arq_save_bp; 7008 /* 7009 * is arq pkt in use? 7010 */ 7011 if (arq_data->arq_save_sp) { 7012 return (-1); 7013 } 7014 7015 scsi_destroy_pkt(CMD2PKT(rqpktp)); 7016 scsi_free_consistent_buf(bp); 7017 fas->f_arq_pkt[slot] = 0; 7018 } 7019 return (0); 7020 } 7021 7022 /* 7023 * complete an arq packet by copying over transport info and the actual 7024 * request sense data; called with mutex held from fas_call_pkt_comp() 7025 */ 7026 void 7027 fas_complete_arq_pkt(struct scsi_pkt *pkt) 7028 { 7029 struct fas *fas = ADDR2FAS(&pkt->pkt_address); 7030 struct fas_cmd *sp = pkt->pkt_ha_private; 7031 struct scsi_arq_status *arqstat; 7032 struct arq_private_data *arq_data = 7033 (struct arq_private_data *)sp->cmd_pkt->pkt_private; 7034 struct fas_cmd *ssp = arq_data->arq_save_sp; 7035 struct buf *bp = arq_data->arq_save_bp; 7036 int slot = sp->cmd_slot; 7037 7038 DPRINTF1("completing arq pkt sp=0x%p\n", (void *)sp); 7039 ASSERT(sp == fas->f_arq_pkt[slot]); 7040 ASSERT(arq_data->arq_save_sp != NULL); 7041 ASSERT(ssp != fas->f_active[sp->cmd_slot]->f_slot[sp->cmd_tag[1]]); 7042 7043 arqstat = (struct scsi_arq_status *)(ssp->cmd_pkt->pkt_scbp); 7044 arqstat->sts_rqpkt_status = *((struct scsi_status *) 7045 (sp->cmd_pkt->pkt_scbp)); 7046 arqstat->sts_rqpkt_reason = sp->cmd_pkt->pkt_reason; 7047 arqstat->sts_rqpkt_state = sp->cmd_pkt->pkt_state; 7048 arqstat->sts_rqpkt_statistics = sp->cmd_pkt->pkt_statistics; 7049 arqstat->sts_rqpkt_resid = sp->cmd_pkt->pkt_resid; 7050 arqstat->sts_sensedata = 7051 *((struct scsi_extended_sense *)bp->b_un.b_addr); 7052 ssp->cmd_pkt->pkt_state |= STATE_ARQ_DONE; 7053 arq_data->arq_save_sp = NULL; 7054 7055 /* 7056 * ASC=0x47 is parity error 7057 */ 7058 if (arqstat->sts_sensedata.es_key == KEY_ABORTED_COMMAND && 7059 arqstat->sts_sensedata.es_add_code == 0x47) { 7060 fas_sync_wide_backoff(fas, sp, slot); 7061 } 7062 7063 fas_call_pkt_comp(fas, ssp); 7064 } 7065 7066 /* 7067 * handle check condition and start an arq packet 7068 */ 7069 static int 7070 fas_handle_sts_chk(struct fas *fas, struct fas_cmd *sp) 7071 { 7072 struct fas_cmd *arqsp = fas->f_arq_pkt[sp->cmd_slot]; 7073 struct arq_private_data *arq_data; 7074 struct buf *bp; 7075 7076 if ((arqsp == NULL) || (arqsp == sp) || 7077 (sp->cmd_scblen < sizeof (struct scsi_arq_status))) { 7078 IPRINTF("no arq packet or cannot arq on arq pkt\n"); 7079 fas_call_pkt_comp(fas, sp); 7080 return (0); 7081 } 7082 7083 arq_data = (struct arq_private_data *)arqsp->cmd_pkt->pkt_private; 7084 bp = arq_data->arq_save_bp; 7085 7086 ASSERT(sp->cmd_flags & CFLAG_FINISHED); 7087 ASSERT(sp != fas->f_active[sp->cmd_slot]->f_slot[sp->cmd_tag[1]]); 7088 DPRINTF3("start arq for slot=%x, arqsp=0x%p, rqpkt=0x%p\n", 7089 sp->cmd_slot, (void *)arqsp, (void *)fas->f_arq_pkt[sp->cmd_slot]); 7090 if (arq_data->arq_save_sp != NULL) { 7091 IPRINTF("auto request sense already in progress\n"); 7092 goto fail; 7093 } 7094 7095 arq_data->arq_save_sp = sp; 7096 7097 bzero(bp->b_un.b_addr, sizeof (struct scsi_extended_sense)); 7098 7099 /* 7100 * copy the timeout from the original packet by lack of a better 7101 * value 7102 * we could take the residue of the timeout but that could cause 7103 * premature timeouts perhaps 7104 */ 7105 arqsp->cmd_pkt->pkt_time = sp->cmd_pkt->pkt_time; 7106 arqsp->cmd_flags &= ~CFLAG_TRANFLAG; 7107 ASSERT(arqsp->cmd_pkt->pkt_comp != NULL); 7108 7109 /* 7110 * make sure that auto request sense always goes out 7111 * after queue full and after throttle was set to draining 7112 */ 7113 fas_full_throttle(fas, sp->cmd_slot); 7114 (void) fas_accept_pkt(fas, arqsp, NO_TRAN_BUSY); 7115 return (0); 7116 7117 fail: 7118 fas_set_pkt_reason(fas, sp, CMD_TRAN_ERR, 0); 7119 fas_log(fas, CE_WARN, "auto request sense failed\n"); 7120 fas_dump_cmd(fas, sp); 7121 fas_call_pkt_comp(fas, sp); 7122 return (-1); 7123 } 7124 7125 7126 /* 7127 * handle qfull condition 7128 */ 7129 static void 7130 fas_handle_qfull(struct fas *fas, struct fas_cmd *sp) 7131 { 7132 int slot = sp->cmd_slot; 7133 7134 if ((++sp->cmd_qfull_retries > fas->f_qfull_retries[Tgt(sp)]) || 7135 (fas->f_qfull_retries[Tgt(sp)] == 0)) { 7136 /* 7137 * We have exhausted the retries on QFULL, or, 7138 * the target driver has indicated that it 7139 * wants to handle QFULL itself by setting 7140 * qfull-retries capability to 0. In either case 7141 * we want the target driver's QFULL handling 7142 * to kick in. We do this by having pkt_reason 7143 * as CMD_CMPLT and pkt_scbp as STATUS_QFULL. 7144 */ 7145 IPRINTF2("%d.%d: status queue full, retries over\n", 7146 Tgt(sp), Lun(sp)); 7147 fas_set_all_lun_throttles(fas, slot, DRAIN_THROTTLE); 7148 fas_call_pkt_comp(fas, sp); 7149 } else { 7150 if (fas->f_reset_delay[Tgt(sp)] == 0) { 7151 fas->f_throttle[slot] = 7152 max((fas->f_tcmds[slot] - 2), 0); 7153 } 7154 IPRINTF3("%d.%d: status queue full, new throttle = %d, " 7155 "retrying\n", Tgt(sp), Lun(sp), fas->f_throttle[slot]); 7156 sp->cmd_pkt->pkt_flags |= FLAG_HEAD; 7157 sp->cmd_flags &= ~CFLAG_TRANFLAG; 7158 (void) fas_accept_pkt(fas, sp, NO_TRAN_BUSY); 7159 7160 /* 7161 * when target gives queue full status with no commands 7162 * outstanding (f_tcmds[] == 0), throttle is set to 0 7163 * (HOLD_THROTTLE), and the queue full handling starts 7164 * (see psarc/1994/313); if there are commands outstanding, 7165 * the throttle is set to (f_tcmds[] - 2) 7166 */ 7167 if (fas->f_throttle[slot] == HOLD_THROTTLE) { 7168 /* 7169 * By setting throttle to QFULL_THROTTLE, we 7170 * avoid submitting new commands and in 7171 * fas_restart_cmd find out slots which need 7172 * their throttles to be cleared. 7173 */ 7174 fas_set_all_lun_throttles(fas, slot, QFULL_THROTTLE); 7175 if (fas->f_restart_cmd_timeid == 0) { 7176 fas->f_restart_cmd_timeid = 7177 timeout(fas_restart_cmd, fas, 7178 fas->f_qfull_retry_interval[Tgt(sp)]); 7179 } 7180 } 7181 } 7182 } 7183 7184 /* 7185 * invoked from timeout() to restart qfull cmds with throttle == 0 7186 */ 7187 static void 7188 fas_restart_cmd(void *fas_arg) 7189 { 7190 struct fas *fas = fas_arg; 7191 int i; 7192 7193 IPRINTF("fas_restart_cmd:\n"); 7194 7195 mutex_enter(FAS_MUTEX(fas)); 7196 fas->f_restart_cmd_timeid = 0; 7197 7198 for (i = 0; i < N_SLOTS; i += NLUNS_PER_TARGET) { 7199 if (fas->f_reset_delay[i/NLUNS_PER_TARGET] == 0) { 7200 if (fas->f_throttle[i] == QFULL_THROTTLE) { 7201 fas_set_all_lun_throttles(fas, 7202 i, MAX_THROTTLE); 7203 } 7204 } 7205 } 7206 7207 (void) fas_ustart(fas); 7208 mutex_exit(FAS_MUTEX(fas)); 7209 } 7210 7211 /* 7212 * Timeout handling: 7213 * Command watchdog routines 7214 */ 7215 7216 /*ARGSUSED*/ 7217 static void 7218 fas_watch(void *arg) 7219 { 7220 struct fas *fas; 7221 ushort_t props_update = 0; 7222 7223 rw_enter(&fas_global_rwlock, RW_READER); 7224 7225 for (fas = fas_head; fas != (struct fas *)NULL; fas = fas->f_next) { 7226 7227 mutex_enter(FAS_MUTEX(fas)); 7228 IPRINTF2("ncmds=%x, ndisc=%x\n", fas->f_ncmds, fas->f_ndisc); 7229 7230 #ifdef FAS_PIO_COUNTS 7231 if (fas->f_total_cmds) { 7232 int n = fas->f_total_cmds; 7233 7234 fas_log(fas, CE_NOTE, 7235 "total=%d, cmds=%d fas-rd=%d, fas-wrt=%d, dma-rd=%d, dma-wrt=%d\n", 7236 fas->f_total_cmds, 7237 fas->f_reg_cmds/n, 7238 fas->f_reg_reads/n, fas->f_reg_writes/n, 7239 fas->f_reg_dma_reads/n, fas->f_reg_dma_writes/n); 7240 7241 fas->f_reg_reads = fas->f_reg_writes = 7242 fas->f_reg_dma_reads = fas->f_reg_dma_writes = 7243 fas->f_reg_cmds = fas->f_total_cmds = 0; 7244 } 7245 #endif 7246 if (fas->f_ncmds) { 7247 int i; 7248 fas_watchsubr(fas); 7249 7250 /* 7251 * reset throttle. the throttle may have been 7252 * too low if queue full was caused by 7253 * another initiator 7254 * Only reset throttle if no cmd active in slot 0 7255 * (untagged cmd) 7256 */ 7257 #ifdef FAS_TEST 7258 if (fas_enable_untagged) { 7259 fas_test_untagged++; 7260 } 7261 #endif 7262 for (i = 0; i < N_SLOTS; i++) { 7263 if ((fas->f_throttle[i] > HOLD_THROTTLE) && 7264 (fas->f_active[i] && 7265 (fas->f_active[i]->f_slot[0] == NULL))) { 7266 fas_full_throttle(fas, i); 7267 } 7268 } 7269 } 7270 7271 if (fas->f_props_update) { 7272 int i; 7273 /* 7274 * f_mutex will be released and reentered in 7275 * fas_props_update(). 7276 * Hence we save the fas->f_props_update now and 7277 * set to 0 indicating that property has been 7278 * updated. This will avoid a race condition with 7279 * any thread that runs in interrupt context that 7280 * attempts to set the f_props_update to non-zero value 7281 */ 7282 props_update = fas->f_props_update; 7283 fas->f_props_update = 0; 7284 for (i = 0; i < NTARGETS_WIDE; i++) { 7285 if (props_update & (1<<i)) { 7286 fas_update_props(fas, i); 7287 } 7288 } 7289 } 7290 fas_check_waitQ_and_mutex_exit(fas); 7291 7292 } 7293 rw_exit(&fas_global_rwlock); 7294 7295 again: 7296 mutex_enter(&fas_global_mutex); 7297 if (fas_timeout_initted && fas_timeout_id) { 7298 fas_timeout_id = timeout(fas_watch, NULL, fas_tick); 7299 } 7300 mutex_exit(&fas_global_mutex); 7301 TRACE_0(TR_FAC_SCSI_FAS, TR_FAS_WATCH_END, "fas_watch_end"); 7302 } 7303 7304 static void 7305 fas_watchsubr(struct fas *fas) 7306 { 7307 short slot; 7308 int d = ((fas->f_dslot == 0)? 1 : fas->f_dslot); 7309 struct f_slots *tag_slots; 7310 7311 for (slot = 0; slot < N_SLOTS; slot += d) { 7312 7313 #ifdef FAS_TEST 7314 if (fas_btest) { 7315 fas_btest = 0; 7316 (void) fas_reset_bus(fas); 7317 return; 7318 } 7319 if (fas_force_timeout && fas->f_tcmds[slot]) { 7320 fas_cmd_timeout(fas, slot); 7321 fas_force_timeout = 0; 7322 return; 7323 } 7324 fas_test_reset(fas, slot); 7325 fas_test_abort(fas, slot); 7326 #endif /* FAS_TEST */ 7327 7328 /* 7329 * check tagged cmds first 7330 */ 7331 tag_slots = fas->f_active[slot]; 7332 DPRINTF3( 7333 "fas_watchsubr: slot %x: tcmds=%x, timeout=%x\n", 7334 slot, fas->f_tcmds[slot], tag_slots->f_timeout); 7335 7336 if ((fas->f_tcmds[slot] > 0) && (tag_slots->f_timebase)) { 7337 7338 if (tag_slots->f_timebase <= 7339 fas_scsi_watchdog_tick) { 7340 tag_slots->f_timebase += 7341 fas_scsi_watchdog_tick; 7342 continue; 7343 } 7344 7345 tag_slots->f_timeout -= fas_scsi_watchdog_tick; 7346 7347 if (tag_slots->f_timeout < 0) { 7348 fas_cmd_timeout(fas, slot); 7349 return; 7350 } 7351 if ((tag_slots->f_timeout) <= 7352 fas_scsi_watchdog_tick) { 7353 IPRINTF1("pending timeout on slot=%x\n", 7354 slot); 7355 IPRINTF("draining all queues\n"); 7356 fas_set_throttles(fas, 0, N_SLOTS, 7357 DRAIN_THROTTLE); 7358 } 7359 } 7360 } 7361 } 7362 7363 /* 7364 * timeout recovery 7365 */ 7366 static void 7367 fas_cmd_timeout(struct fas *fas, int slot) 7368 { 7369 int d = ((fas->f_dslot == 0)? 1 : fas->f_dslot); 7370 int target, lun, i, n, tag, ncmds; 7371 struct fas_cmd *sp = NULL; 7372 struct fas_cmd *ssp; 7373 7374 ASSERT(fas->f_tcmds[slot]); 7375 7376 #ifdef FAS_TEST 7377 if (fas_test_stop) { 7378 debug_enter("timeout"); 7379 } 7380 #endif 7381 7382 /* 7383 * set throttle back; no more draining necessary 7384 */ 7385 for (i = 0; i < N_SLOTS; i += d) { 7386 if (fas->f_throttle[i] == DRAIN_THROTTLE) { 7387 fas_full_throttle(fas, i); 7388 } 7389 } 7390 7391 if (NOTAG(slot/NLUNS_PER_TARGET)) { 7392 sp = fas->f_active[slot]->f_slot[0]; 7393 } 7394 7395 /* 7396 * if no interrupt pending for next second then the current 7397 * cmd must be stuck; switch slot and sp to current slot and cmd 7398 */ 7399 if (fas->f_current_sp && fas->f_state != STATE_FREE) { 7400 for (i = 0; (i < 10000) && (INTPENDING(fas) == 0); i++) { 7401 drv_usecwait(100); 7402 } 7403 if (INTPENDING(fas) == 0) { 7404 slot = fas->f_current_sp->cmd_slot; 7405 sp = fas->f_current_sp; 7406 } 7407 } 7408 7409 target = slot / NLUNS_PER_TARGET; 7410 lun = slot % NLUNS_PER_TARGET; 7411 7412 /* 7413 * update all outstanding pkts for this slot 7414 */ 7415 n = fas->f_active[slot]->f_n_slots; 7416 for (ncmds = tag = 0; tag < n; tag++) { 7417 ssp = fas->f_active[slot]->f_slot[tag]; 7418 if (ssp && ssp->cmd_pkt->pkt_time) { 7419 fas_set_pkt_reason(fas, ssp, CMD_TIMEOUT, 7420 STAT_TIMEOUT | STAT_ABORTED); 7421 fas_short_dump_cmd(fas, ssp); 7422 ncmds++; 7423 } 7424 } 7425 7426 /* 7427 * no timed-out cmds here? 7428 */ 7429 if (ncmds == 0) { 7430 return; 7431 } 7432 7433 /* 7434 * dump all we know about this timeout 7435 */ 7436 if (sp) { 7437 if (sp->cmd_flags & CFLAG_CMDDISC) { 7438 fas_log(fas, CE_WARN, 7439 "Disconnected command timeout for Target %d.%d", 7440 target, lun); 7441 } else { 7442 ASSERT(sp == fas->f_current_sp); 7443 fas_log(fas, CE_WARN, 7444 "Connected command timeout for Target %d.%d", 7445 target, lun); 7446 /* 7447 * Current command timeout appears to relate often 7448 * to noisy SCSI in synchronous mode. 7449 */ 7450 if (fas->f_state == ACTS_DATA_DONE) { 7451 fas_sync_wide_backoff(fas, sp, slot); 7452 } 7453 } 7454 #ifdef FASDEBUG 7455 fas_printstate(fas, "timeout"); 7456 #endif 7457 } else { 7458 fas_log(fas, CE_WARN, 7459 "Disconnected tagged cmd(s) (%d) timeout for Target %d.%d", 7460 fas->f_tcmds[slot], target, lun); 7461 } 7462 7463 if (fas_abort_cmd(fas, sp, slot) == ACTION_SEARCH) { 7464 (void) fas_istart(fas); 7465 } 7466 } 7467 7468 /* 7469 * fas_sync_wide_backoff() increases sync period and enables slow 7470 * cable mode. 7471 * the second time, we revert back to narrow/async 7472 * we count on a bus reset to disable wide in the target and will 7473 * never renegotiate wide again 7474 */ 7475 static void 7476 fas_sync_wide_backoff(struct fas *fas, struct fas_cmd *sp, 7477 int slot) 7478 { 7479 char phase; 7480 ushort_t state = fas->f_state; 7481 uchar_t tgt = slot / NLUNS_PER_TARGET; 7482 uint_t tshift = 1 << tgt; 7483 7484 phase = fas_reg_read(fas, &fas->f_reg->fas_stat); 7485 phase &= FAS_PHASE_MASK; 7486 7487 IPRINTF4( 7488 "fas_sync_wide_backoff: target %d: state=%x, phase=%x, sp=0x%p\n", 7489 tgt, state, phase, (void *)sp); 7490 7491 #ifdef FASDEBUG 7492 if (fas_no_sync_wide_backoff) { 7493 return; 7494 } 7495 #endif 7496 7497 /* 7498 * if this not the first time or sync is disabled 7499 * thru scsi_options then disable wide 7500 */ 7501 if ((fas->f_backoff & tshift) || 7502 (fas->f_nosync & tshift)) { 7503 /* 7504 * disable wide for just this target 7505 */ 7506 if ((fas->f_nowide & tshift) == 0) { 7507 fas_log(fas, CE_WARN, 7508 "Target %d disabled wide SCSI mode", tgt); 7509 } 7510 /* 7511 * do not reset the bit in f_nowide because that 7512 * would not force a renegotiation of wide 7513 * and do not change any register value yet because 7514 * we may have reconnects before the renegotiations 7515 */ 7516 fas->f_target_scsi_options[tgt] &= ~SCSI_OPTIONS_WIDE; 7517 } 7518 7519 /* 7520 * reduce xfer rate. if this is the first time, reduce by 7521 * 100%. second time, disable sync and wide. 7522 */ 7523 if (fas->f_offset[tgt] != 0) { 7524 /* 7525 * do not reset the bit in f_nosync because that 7526 * would not force a renegotiation of sync 7527 */ 7528 if (fas->f_backoff & tshift) { 7529 if ((fas->f_nosync & tshift) == 0) { 7530 fas_log(fas, CE_WARN, 7531 "Target %d reverting to async. mode", 7532 tgt); 7533 } 7534 fas->f_target_scsi_options[tgt] &= 7535 ~(SCSI_OPTIONS_SYNC | SCSI_OPTIONS_FAST); 7536 } else { 7537 /* increase period by 100% */ 7538 fas->f_neg_period[tgt] *= 2; 7539 7540 fas_log(fas, CE_WARN, 7541 "Target %d reducing sync. transfer rate", tgt); 7542 } 7543 } 7544 fas->f_backoff |= tshift; 7545 7546 /* 7547 * always enable slow cable mode, if not already enabled 7548 */ 7549 if ((fas->f_fasconf & FAS_CONF_SLOWMODE) == 0) { 7550 fas->f_fasconf |= FAS_CONF_SLOWMODE; 7551 fas_reg_write(fas, &fas->f_reg->fas_conf, fas->f_fasconf); 7552 IPRINTF("Reverting to slow SCSI cable mode\n"); 7553 } 7554 7555 /* 7556 * Force sync renegotiation and update properties 7557 */ 7558 fas_force_renegotiation(fas, tgt); 7559 fas->f_props_update |= (1<<tgt); 7560 } 7561 7562 /* 7563 * handle failed negotiations (either reject or bus free condition) 7564 */ 7565 static void 7566 fas_reset_sync_wide(struct fas *fas) 7567 { 7568 struct fas_cmd *sp = fas->f_current_sp; 7569 int tgt = Tgt(sp); 7570 7571 if (fas->f_wdtr_sent) { 7572 IPRINTF("wide neg message rejected or bus free\n"); 7573 fas->f_nowide |= (1<<tgt); 7574 fas->f_fasconf3[tgt] &= ~FAS_CONF3_WIDE; 7575 fas_reg_write(fas, &fas->f_reg->fas_conf3, 7576 fas->f_fasconf3[tgt]); 7577 /* 7578 * clear offset just in case it goes to 7579 * data phase 7580 */ 7581 fas_reg_write(fas, 7582 (uchar_t *)&fas->f_reg->fas_sync_offset, 0); 7583 } else if (fas->f_sdtr_sent) { 7584 volatile struct fasreg *fasreg = 7585 fas->f_reg; 7586 IPRINTF("sync neg message rejected or bus free\n"); 7587 fas->f_nosync |= (1<<tgt); 7588 fas->f_offset[tgt] = 0; 7589 fas->f_sync_period[tgt] = 0; 7590 fas_reg_write(fas, 7591 (uchar_t *)&fasreg->fas_sync_period, 0); 7592 fas_reg_write(fas, 7593 (uchar_t *)&fasreg->fas_sync_offset, 0); 7594 fas->f_offset[tgt] = 0; 7595 fas->f_fasconf3[tgt] &= ~FAS_CONF3_FASTSCSI; 7596 fas_reg_write(fas, &fasreg->fas_conf3, 7597 fas->f_fasconf3[tgt]); 7598 } 7599 7600 fas_force_renegotiation(fas, tgt); 7601 } 7602 7603 /* 7604 * force wide and sync renegotiation 7605 */ 7606 static void 7607 fas_force_renegotiation(struct fas *fas, int target) 7608 { 7609 ushort_t tshift = 1<<target; 7610 fas->f_sync_known &= ~tshift; 7611 fas->f_sync_enabled &= ~tshift; 7612 fas->f_wide_known &= ~tshift; 7613 fas->f_wide_enabled &= ~tshift; 7614 } 7615 7616 /* 7617 * update conf3 register for wide negotiation 7618 */ 7619 static void 7620 fas_set_wide_conf3(struct fas *fas, int target, int width) 7621 { 7622 ASSERT(width <= 1); 7623 switch (width) { 7624 case 0: 7625 fas->f_fasconf3[target] &= ~FAS_CONF3_WIDE; 7626 break; 7627 case 1: 7628 fas->f_fasconf3[target] |= FAS_CONF3_WIDE; 7629 fas->f_wide_enabled |= (1<<target); 7630 break; 7631 } 7632 7633 fas_reg_write(fas, &fas->f_reg->fas_conf3, fas->f_fasconf3[target]); 7634 fas->f_fasconf3_reg_last = fas->f_fasconf3[target]; 7635 } 7636 7637 /* 7638 * Abort command handling 7639 * 7640 * abort current cmd, either by device reset or immediately with bus reset 7641 * (usually an abort msg doesn't completely solve the problem, therefore 7642 * a device or bus reset is recommended) 7643 */ 7644 static int 7645 fas_abort_curcmd(struct fas *fas) 7646 { 7647 if (fas->f_current_sp) { 7648 return (fas_abort_cmd(fas, fas->f_current_sp, 7649 fas->f_current_sp->cmd_slot)); 7650 } else { 7651 return (fas_reset_bus(fas)); 7652 } 7653 } 7654 7655 static int 7656 fas_abort_cmd(struct fas *fas, struct fas_cmd *sp, int slot) 7657 { 7658 struct scsi_address ap; 7659 7660 ap.a_hba_tran = fas->f_tran; 7661 ap.a_target = slot / NLUNS_PER_TARGET; 7662 ap.a_lun = slot % NLUNS_PER_TARGET; 7663 7664 IPRINTF1("abort cmd 0x%p\n", (void *)sp); 7665 7666 /* 7667 * attempting to abort a connected cmd is usually fruitless, so 7668 * only try disconnected cmds 7669 * a reset is preferable over an abort (see 1161701) 7670 */ 7671 if ((fas->f_current_sp && (fas->f_current_sp->cmd_slot != slot)) || 7672 (fas->f_state == STATE_FREE)) { 7673 IPRINTF2("attempting to reset target %d.%d\n", 7674 ap.a_target, ap.a_lun); 7675 if (fas_do_scsi_reset(&ap, RESET_TARGET)) { 7676 return (ACTION_SEARCH); 7677 } 7678 } 7679 7680 /* 7681 * if the target won't listen, then a retry is useless 7682 * there is also the possibility that the cmd still completed while 7683 * we were trying to reset and the target driver may have done a 7684 * device reset which has blown away this sp. 7685 * well, we've tried, now pull the chain 7686 */ 7687 IPRINTF("aborting all cmds by bus reset\n"); 7688 return (fas_reset_bus(fas)); 7689 } 7690 7691 /* 7692 * fas_do_scsi_abort() assumes that we already have the mutex. 7693 * during the abort, we hold the mutex and prevent callbacks by setting 7694 * completion pointer to NULL. this will also avoid that a target driver 7695 * attempts to do a scsi_abort/reset while we are aborting. 7696 * because the completion pointer is NULL we can still update the 7697 * packet after completion 7698 * the throttle for this slot is cleared either by fas_abort_connected_cmd 7699 * or fas_runpoll which prevents new cmds from starting while aborting 7700 */ 7701 static int 7702 fas_do_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt) 7703 { 7704 struct fas *fas = ADDR2FAS(ap); 7705 struct fas_cmd *sp; 7706 int rval = FALSE; 7707 short slot; 7708 struct fas_cmd *cur_sp = fas->f_current_sp; 7709 void (*cur_savec)(), (*sp_savec)(); 7710 int sp_tagged_flag, abort_msg; 7711 7712 if (pkt) { 7713 sp = PKT2CMD(pkt); 7714 slot = sp->cmd_slot; 7715 ASSERT(slot == ((ap->a_target * NLUNS_PER_TARGET) | ap->a_lun)); 7716 } else { 7717 sp = NULL; 7718 slot = (ap->a_target * NLUNS_PER_TARGET) | ap->a_lun; 7719 } 7720 7721 fas_move_waitQ_to_readyQ(fas); 7722 7723 /* 7724 * If no specific command was passed, all cmds here will be aborted 7725 * If a specific command was passed as an argument (to be aborted) 7726 * only the specified command will be aborted 7727 */ 7728 ASSERT(mutex_owned(FAS_MUTEX(fas))); 7729 IPRINTF4("fas_scsi_abort for slot %x, " 7730 "sp=0x%p, pkt_flags=%x, cur_sp=0x%p\n", 7731 slot, (void *)sp, (sp? sp->cmd_pkt_flags : 0), (void *)cur_sp); 7732 7733 /* 7734 * first check if the cmd is in the ready queue or 7735 * in the active queue 7736 */ 7737 if (sp) { 7738 IPRINTF3("aborting one command 0x%p for %d.%d\n", 7739 (void *)sp, ap->a_target, ap->a_lun); 7740 rval = fas_remove_from_readyQ(fas, sp, slot); 7741 if (rval) { 7742 IPRINTF("aborted one ready cmd\n"); 7743 fas_set_pkt_reason(fas, sp, CMD_ABORTED, STAT_ABORTED); 7744 fas_decrement_ncmds(fas, sp); 7745 fas_call_pkt_comp(fas, sp); 7746 goto exit; 7747 7748 } else if ((sp != 7749 fas->f_active[slot]->f_slot[sp->cmd_tag[1]])) { 7750 IPRINTF("cmd doesn't exist here\n"); 7751 rval = TRUE; 7752 goto exit; 7753 } 7754 } 7755 7756 /* 7757 * hold off any new commands while attempting to abort 7758 * an active cmd 7759 */ 7760 fas_set_throttles(fas, slot, 1, HOLD_THROTTLE); 7761 7762 if (cur_sp) { 7763 /* 7764 * prevent completion on current cmd 7765 */ 7766 cur_savec = cur_sp->cmd_pkt->pkt_comp; 7767 cur_sp->cmd_pkt->pkt_comp = NULL; 7768 } 7769 7770 if (sp) { 7771 /* 7772 * the cmd exists here. is it connected or disconnected? 7773 * if connected but still selecting then can't abort now. 7774 * prevent completion on this cmd 7775 */ 7776 sp_tagged_flag = (sp->cmd_pkt_flags & FLAG_TAGMASK); 7777 abort_msg = (sp_tagged_flag? MSG_ABORT_TAG : MSG_ABORT); 7778 sp_savec = sp->cmd_pkt->pkt_comp; 7779 sp->cmd_pkt->pkt_comp = NULL; 7780 7781 /* connected but not selecting? */ 7782 if ((sp == cur_sp) && (fas->f_state != STATE_FREE) && 7783 (sp->cmd_pkt->pkt_state)) { 7784 rval = fas_abort_connected_cmd(fas, sp, abort_msg); 7785 } 7786 7787 /* if abort connected cmd failed, try abort disconnected */ 7788 if ((rval == 0) && 7789 (sp->cmd_flags & CFLAG_CMDDISC) && 7790 ((sp->cmd_flags & CFLAG_COMPLETED) == 0)) { 7791 rval = fas_abort_disconnected_cmd(fas, ap, sp, 7792 abort_msg, slot); 7793 } 7794 7795 if (rval) { 7796 sp->cmd_flags |= CFLAG_COMPLETED; 7797 fas_set_pkt_reason(fas, sp, CMD_ABORTED, STAT_ABORTED); 7798 } 7799 7800 sp->cmd_pkt->pkt_comp = sp_savec; 7801 7802 } else { 7803 IPRINTF2("aborting all commands for %d.%d\n", 7804 ap->a_target, ap->a_lun); 7805 abort_msg = MSG_ABORT; 7806 7807 /* active and not selecting ? */ 7808 if (cur_sp && (fas->f_state != STATE_FREE) && 7809 (cur_sp->cmd_slot == slot) && 7810 cur_sp->cmd_pkt->pkt_state) { 7811 rval = fas_abort_connected_cmd(fas, cur_sp, 7812 abort_msg); 7813 } 7814 if (rval == 0) { 7815 rval = fas_abort_disconnected_cmd(fas, ap, 7816 NULL, abort_msg, slot); 7817 } 7818 } 7819 7820 done: 7821 /* complete the current sp */ 7822 if (cur_sp) { 7823 cur_sp->cmd_pkt->pkt_comp = cur_savec; 7824 if (cur_sp->cmd_flags & CFLAG_COMPLETED) { 7825 fas_remove_cmd(fas, cur_sp, NEW_TIMEOUT); 7826 cur_sp->cmd_flags &= ~CFLAG_COMPLETED; 7827 fas_decrement_ncmds(fas, cur_sp); 7828 fas_call_pkt_comp(fas, cur_sp); 7829 } 7830 } 7831 7832 /* complete the sp passed as 2nd arg */ 7833 if (sp && (sp != cur_sp) && (sp->cmd_flags & CFLAG_COMPLETED)) { 7834 sp->cmd_flags &= ~CFLAG_COMPLETED; 7835 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 7836 fas_decrement_ncmds(fas, sp); 7837 fas_call_pkt_comp(fas, sp); 7838 } 7839 7840 /* clean up all cmds for this slot */ 7841 if (rval && (abort_msg == MSG_ABORT)) { 7842 /* 7843 * mark all commands here as aborted 7844 * abort msg has been accepted, now cleanup queues; 7845 */ 7846 fas_mark_packets(fas, slot, CMD_ABORTED, STAT_ABORTED); 7847 fas_flush_tagQ(fas, slot); 7848 fas_flush_readyQ(fas, slot); 7849 } 7850 fas_set_throttles(fas, slot, 1, MAX_THROTTLE); 7851 7852 exit: 7853 if (fas->f_state == STATE_FREE) { 7854 (void) fas_ustart(fas); 7855 } 7856 7857 ASSERT(mutex_owned(FAS_MUTEX(fas))); 7858 7859 #ifdef FASDEBUG 7860 if (rval && fas_test_stop) { 7861 debug_enter("abort succeeded"); 7862 } 7863 #endif 7864 return (rval); 7865 } 7866 7867 /* 7868 * mark all packets with new reason and update statistics 7869 */ 7870 static void 7871 fas_mark_packets(struct fas *fas, int slot, uchar_t reason, uint_t stat) 7872 { 7873 struct fas_cmd *sp = fas->f_readyf[slot]; 7874 7875 while (sp != 0) { 7876 fas_set_pkt_reason(fas, sp, reason, STAT_ABORTED); 7877 sp = sp->cmd_forw; 7878 } 7879 if (fas->f_tcmds[slot]) { 7880 int n = 0; 7881 ushort_t tag; 7882 7883 for (tag = 0; tag < fas->f_active[slot]->f_n_slots; tag++) { 7884 if ((sp = fas->f_active[slot]->f_slot[tag]) != 0) { 7885 fas_set_pkt_reason(fas, sp, reason, stat); 7886 n++; 7887 } 7888 } 7889 ASSERT(fas->f_tcmds[slot] == n); 7890 } 7891 } 7892 7893 /* 7894 * set pkt_reason and OR in pkt_statistics flag 7895 */ 7896 static void 7897 fas_set_pkt_reason(struct fas *fas, struct fas_cmd *sp, uchar_t reason, 7898 uint_t stat) 7899 { 7900 if (sp) { 7901 if (sp->cmd_pkt->pkt_reason == CMD_CMPLT) { 7902 sp->cmd_pkt->pkt_reason = reason; 7903 } 7904 sp->cmd_pkt->pkt_statistics |= stat; 7905 IPRINTF3("sp=0x%p, pkt_reason=%x, pkt_stat=%x\n", 7906 (void *)sp, reason, sp->cmd_pkt->pkt_statistics); 7907 } 7908 } 7909 7910 /* 7911 * delete specified cmd from the ready queue 7912 */ 7913 static int 7914 fas_remove_from_readyQ(struct fas *fas, struct fas_cmd *sp, int slot) 7915 { 7916 struct fas_cmd *ssp, *psp; 7917 7918 /* 7919 * command has not been started yet and is still in the ready queue 7920 */ 7921 if (sp) { 7922 ASSERT(fas->f_ncmds > 0); 7923 /* 7924 * find packet on the ready queue and remove it 7925 */ 7926 for (psp = NULL, ssp = fas->f_readyf[slot]; ssp != NULL; 7927 psp = ssp, ssp = ssp->cmd_forw) { 7928 if (ssp == sp) { 7929 if (fas->f_readyf[slot] == sp) { 7930 fas->f_readyf[slot] = sp->cmd_forw; 7931 } else { 7932 psp->cmd_forw = sp->cmd_forw; 7933 } 7934 if (fas->f_readyb[slot] == sp) { 7935 fas->f_readyb[slot] = psp; 7936 } 7937 return (TRUE); 7938 } 7939 } 7940 } 7941 return (FALSE); 7942 } 7943 7944 /* 7945 * add cmd to to head of the readyQ 7946 * due to tag allocation failure or preemption we have to return 7947 * this cmd to the readyQ 7948 */ 7949 static void 7950 fas_head_of_readyQ(struct fas *fas, struct fas_cmd *sp) 7951 { 7952 /* 7953 * never return a NOINTR pkt to the readyQ 7954 * (fas_runpoll will resubmit) 7955 */ 7956 if ((sp->cmd_pkt_flags & FLAG_NOINTR) == 0) { 7957 struct fas_cmd *dp; 7958 int slot = sp->cmd_slot; 7959 7960 dp = fas->f_readyf[slot]; 7961 fas->f_readyf[slot] = sp; 7962 sp->cmd_forw = dp; 7963 if (fas->f_readyb[slot] == NULL) { 7964 fas->f_readyb[slot] = sp; 7965 } 7966 } 7967 } 7968 7969 /* 7970 * flush cmds in ready queue 7971 */ 7972 static void 7973 fas_flush_readyQ(struct fas *fas, int slot) 7974 { 7975 if (fas->f_readyf[slot]) { 7976 struct fas_cmd *sp, *nsp; 7977 7978 IPRINTF1("flushing ready queue, slot=%x\n", slot); 7979 ASSERT(fas->f_ncmds > 0); 7980 7981 sp = fas->f_readyf[slot]; 7982 fas->f_readyf[slot] = fas->f_readyb[slot] = NULL; 7983 7984 while (sp != 0) { 7985 /* 7986 * save the forward pointer before calling 7987 * the completion routine 7988 */ 7989 nsp = sp->cmd_forw; 7990 ASSERT((sp->cmd_flags & CFLAG_FREE) == 0); 7991 ASSERT(Tgt(sp) == slot/NLUNS_PER_TARGET); 7992 fas_decrement_ncmds(fas, sp); 7993 fas_call_pkt_comp(fas, sp); 7994 sp = nsp; 7995 } 7996 fas_check_ncmds(fas); 7997 } 7998 } 7999 8000 /* 8001 * cleanup the tag queue 8002 * preserve some order by starting with the oldest tag 8003 */ 8004 static void 8005 fas_flush_tagQ(struct fas *fas, int slot) 8006 { 8007 ushort_t tag, starttag; 8008 struct fas_cmd *sp; 8009 struct f_slots *tagque = fas->f_active[slot]; 8010 8011 if (tagque == NULL) { 8012 return; 8013 } 8014 8015 DPRINTF2("flushing entire tag queue, slot=%x, tcmds=%x\n", 8016 slot, fas->f_tcmds[slot]); 8017 8018 #ifdef FASDEBUG 8019 { 8020 int n = 0; 8021 for (tag = 0; tag < fas->f_active[slot]->f_n_slots; tag++) { 8022 if ((sp = tagque->f_slot[tag]) != 0) { 8023 n++; 8024 ASSERT((sp->cmd_flags & CFLAG_FREE) == 0); 8025 if (sp->cmd_pkt->pkt_reason == CMD_CMPLT) { 8026 if ((sp->cmd_flags & CFLAG_FINISHED) == 8027 0) { 8028 debug_enter("fas_flush_tagQ"); 8029 } 8030 } 8031 } 8032 } 8033 ASSERT(fas->f_tcmds[slot] == n); 8034 } 8035 #endif 8036 tag = starttag = fas->f_active[slot]->f_tags; 8037 8038 do { 8039 if ((sp = tagque->f_slot[tag]) != 0) { 8040 fas_flush_cmd(fas, sp, 0, 0); 8041 } 8042 tag = ((ushort_t)(tag + 1)) % 8043 (ushort_t)fas->f_active[slot]->f_n_slots; 8044 } while (tag != starttag); 8045 8046 ASSERT(fas->f_tcmds[slot] == 0); 8047 EPRINTF2("ncmds = %x, ndisc=%x\n", fas->f_ncmds, fas->f_ndisc); 8048 fas_check_ncmds(fas); 8049 } 8050 8051 /* 8052 * cleanup one active command 8053 */ 8054 static void 8055 fas_flush_cmd(struct fas *fas, struct fas_cmd *sp, uchar_t reason, 8056 uint_t stat) 8057 { 8058 short slot = sp->cmd_slot; 8059 8060 ASSERT(fas->f_ncmds > 0); 8061 ASSERT((sp->cmd_flags & CFLAG_FREE) == 0); 8062 ASSERT(sp == fas->f_active[slot]->f_slot[sp->cmd_tag[1]]); 8063 8064 fas_remove_cmd(fas, sp, NEW_TIMEOUT); 8065 fas_decrement_ncmds(fas, sp); 8066 fas_set_pkt_reason(fas, sp, reason, stat); 8067 fas_call_pkt_comp(fas, sp); 8068 8069 EPRINTF2("ncmds = %x, ndisc=%x\n", fas->f_ncmds, fas->f_ndisc); 8070 fas_check_ncmds(fas); 8071 } 8072 8073 /* 8074 * prepare a proxy cmd (a cmd sent on behalf of the target driver, 8075 * usually for error recovery or abort/reset) 8076 */ 8077 static void 8078 fas_makeproxy_cmd(struct fas_cmd *sp, struct scsi_address *ap, 8079 struct scsi_pkt *pkt, int nmsgs, ...) 8080 { 8081 va_list vap; 8082 int i; 8083 8084 ASSERT(nmsgs <= (CDB_GROUP5 - CDB_GROUP0 - 3)); 8085 8086 bzero(sp, sizeof (*sp)); 8087 bzero(pkt, sizeof (*pkt)); 8088 8089 pkt->pkt_address = *ap; 8090 pkt->pkt_cdbp = (opaque_t)&sp->cmd_cdb[0]; 8091 pkt->pkt_scbp = (opaque_t)&sp->cmd_scb; 8092 pkt->pkt_ha_private = (opaque_t)sp; 8093 sp->cmd_pkt = pkt; 8094 sp->cmd_scblen = 1; 8095 sp->cmd_pkt_flags = pkt->pkt_flags = FLAG_NOINTR; 8096 sp->cmd_flags = CFLAG_CMDPROXY; 8097 sp->cmd_cdb[FAS_PROXY_TYPE] = FAS_PROXY_SNDMSG; 8098 sp->cmd_cdb[FAS_PROXY_RESULT] = FALSE; 8099 sp->cmd_cdb[FAS_PROXY_DATA] = (char)nmsgs; 8100 8101 va_start(vap, nmsgs); 8102 for (i = 0; i < nmsgs; i++) { 8103 sp->cmd_cdb[FAS_PROXY_DATA + 1 + i] = (uchar_t)va_arg(vap, int); 8104 } 8105 va_end(vap); 8106 } 8107 8108 /* 8109 * send a proxy cmd and check the result 8110 */ 8111 static int 8112 fas_do_proxy_cmd(struct fas *fas, struct fas_cmd *sp, 8113 struct scsi_address *ap, char *what) 8114 { 8115 int rval; 8116 8117 IPRINTF3("Sending proxy %s message to %d.%d\n", what, 8118 ap->a_target, ap->a_lun); 8119 if (fas_accept_pkt(fas, sp, TRAN_BUSY_OK) == TRAN_ACCEPT && 8120 sp->cmd_pkt->pkt_reason == CMD_CMPLT && 8121 sp->cmd_cdb[FAS_PROXY_RESULT] == TRUE) { 8122 IPRINTF3("Proxy %s succeeded for %d.%d\n", what, 8123 ap->a_target, ap->a_lun); 8124 ASSERT(fas->f_current_sp != sp); 8125 rval = TRUE; 8126 } else { 8127 IPRINTF5( 8128 "Proxy %s failed for %d.%d, result=%x, reason=%x\n", what, 8129 ap->a_target, ap->a_lun, sp->cmd_cdb[FAS_PROXY_RESULT], 8130 sp->cmd_pkt->pkt_reason); 8131 ASSERT(fas->f_current_sp != sp); 8132 rval = FALSE; 8133 } 8134 return (rval); 8135 } 8136 8137 /* 8138 * abort a connected command by sending an abort msg; hold off on 8139 * starting new cmds by setting throttles to HOLD_THROTTLE 8140 */ 8141 static int 8142 fas_abort_connected_cmd(struct fas *fas, struct fas_cmd *sp, uchar_t msg) 8143 { 8144 int rval = FALSE; 8145 int flags = sp->cmd_pkt_flags; 8146 8147 /* 8148 * if reset delay active we cannot access the target. 8149 */ 8150 if (fas->f_reset_delay[Tgt(sp)]) { 8151 return (rval); 8152 } 8153 8154 /* 8155 * only abort while in data phase; otherwise we mess up msg phase 8156 */ 8157 if (!((fas->f_state == ACTS_DATA) || 8158 (fas->f_state == ACTS_DATA_DONE))) { 8159 return (rval); 8160 } 8161 8162 8163 IPRINTF3("Sending abort message %s to connected %d.%d\n", 8164 scsi_mname(msg), Tgt(sp), Lun(sp)); 8165 8166 8167 fas->f_abort_msg_sent = 0; 8168 fas->f_omsglen = 1; 8169 fas->f_cur_msgout[0] = msg; 8170 sp->cmd_pkt_flags |= FLAG_NOINTR; 8171 fas_assert_atn(fas); 8172 8173 (void) fas_dopoll(fas, SHORT_POLL_TIMEOUT); 8174 8175 /* 8176 * now check if the msg was taken 8177 * e_abort is set in fas_handle_msg_out_done when the abort 8178 * msg has actually gone out (ie. msg out phase occurred 8179 */ 8180 if (fas->f_abort_msg_sent && (sp->cmd_flags & CFLAG_COMPLETED)) { 8181 IPRINTF2("target %d.%d aborted\n", 8182 Tgt(sp), Lun(sp)); 8183 rval = TRUE; 8184 } else { 8185 IPRINTF2("target %d.%d did not abort\n", 8186 Tgt(sp), Lun(sp)); 8187 } 8188 sp->cmd_pkt_flags = flags; 8189 fas->f_omsglen = 0; 8190 return (rval); 8191 } 8192 8193 /* 8194 * abort a disconnected command; if it is a tagged command, we need 8195 * to include the tag 8196 */ 8197 static int 8198 fas_abort_disconnected_cmd(struct fas *fas, struct scsi_address *ap, 8199 struct fas_cmd *sp, uchar_t msg, int slot) 8200 { 8201 auto struct fas_cmd local; 8202 struct scsi_pkt pkt; 8203 struct fas_cmd *proxy_cmdp = &local; 8204 int target = ap->a_target; 8205 8206 /* 8207 * if reset delay is active, we cannot start a selection 8208 * and there shouldn't be a cmd outstanding 8209 */ 8210 if (fas->f_reset_delay[target] != 0) { 8211 return (FALSE); 8212 } 8213 8214 if (sp) 8215 ASSERT(sp->cmd_slot == slot); 8216 8217 IPRINTF1("aborting disconnected tagged cmd(s) with %s\n", 8218 scsi_mname(msg)); 8219 if (sp && (TAGGED(target) && (msg == MSG_ABORT_TAG))) { 8220 int tag = sp->cmd_tag[1]; 8221 ASSERT(sp == fas->f_active[slot]->f_slot[tag]); 8222 fas_makeproxy_cmd(proxy_cmdp, ap, &pkt, 3, 8223 MSG_SIMPLE_QTAG, tag, msg); 8224 } else { 8225 fas_makeproxy_cmd(proxy_cmdp, ap, &pkt, 1, msg); 8226 } 8227 8228 return (fas_do_proxy_cmd(fas, proxy_cmdp, ap, scsi_mname(msg))); 8229 } 8230 8231 /* 8232 * reset handling: 8233 * fas_do_scsi_reset assumes that we have already entered the mutex 8234 */ 8235 static int 8236 fas_do_scsi_reset(struct scsi_address *ap, int level) 8237 { 8238 int rval = FALSE; 8239 struct fas *fas = ADDR2FAS(ap); 8240 short slot = (ap->a_target * NLUNS_PER_TARGET) | ap->a_lun; 8241 8242 ASSERT(mutex_owned(FAS_MUTEX(fas))); 8243 IPRINTF3("fas_scsi_reset for slot %x, level=%x, tcmds=%x\n", 8244 slot, level, fas->f_tcmds[slot]); 8245 8246 fas_move_waitQ_to_readyQ(fas); 8247 8248 if (level == RESET_ALL) { 8249 /* 8250 * We know that fas_reset_bus() returns ACTION_RETURN. 8251 */ 8252 (void) fas_reset_bus(fas); 8253 8254 /* 8255 * Now call fas_dopoll() to field the reset interrupt 8256 * which will then call fas_reset_recovery which will 8257 * call the completion function for all commands. 8258 */ 8259 if (fas_dopoll(fas, SHORT_POLL_TIMEOUT) <= 0) { 8260 /* 8261 * reset fas 8262 */ 8263 fas_internal_reset(fas, FAS_RESET_FAS); 8264 (void) fas_reset_bus(fas); 8265 if (fas_dopoll(fas, SHORT_POLL_TIMEOUT) <= 0) { 8266 fas_log(fas, 8267 CE_WARN, "reset scsi bus failed"); 8268 New_state(fas, STATE_FREE); 8269 } else { 8270 rval = TRUE; 8271 } 8272 } else { 8273 rval = TRUE; 8274 } 8275 8276 } else { 8277 struct fas_cmd *cur_sp = fas->f_current_sp; 8278 void (*savec)() = NULL; 8279 8280 /* 8281 * prevent new commands from starting 8282 */ 8283 fas_set_all_lun_throttles(fas, slot, HOLD_THROTTLE); 8284 8285 /* 8286 * zero pkt_comp so it won't complete during the reset and 8287 * we can still update the packet after the reset. 8288 */ 8289 if (cur_sp) { 8290 savec = cur_sp->cmd_pkt->pkt_comp; 8291 cur_sp->cmd_pkt->pkt_comp = NULL; 8292 } 8293 8294 /* 8295 * is this a connected cmd but not selecting? 8296 */ 8297 if (cur_sp && (fas->f_state != STATE_FREE) && 8298 (cur_sp->cmd_pkt->pkt_state != 0) && 8299 (ap->a_target == (Tgt(cur_sp)))) { 8300 rval = fas_reset_connected_cmd(fas, ap); 8301 } 8302 8303 /* 8304 * if not connected or fas_reset_connected_cmd() failed, 8305 * attempt a reset_disconnected_cmd 8306 */ 8307 if (rval == FALSE) { 8308 rval = fas_reset_disconnected_cmd(fas, ap); 8309 } 8310 8311 /* 8312 * cleanup if reset was successful 8313 * complete the current sp first. 8314 */ 8315 if (cur_sp) { 8316 cur_sp->cmd_pkt->pkt_comp = savec; 8317 if (cur_sp->cmd_flags & CFLAG_COMPLETED) { 8318 if (ap->a_target == (Tgt(cur_sp))) { 8319 fas_set_pkt_reason(fas, cur_sp, 8320 CMD_RESET, STAT_DEV_RESET); 8321 } 8322 fas_remove_cmd(fas, cur_sp, NEW_TIMEOUT); 8323 cur_sp->cmd_flags &= ~CFLAG_COMPLETED; 8324 fas_decrement_ncmds(fas, cur_sp); 8325 fas_call_pkt_comp(fas, cur_sp); 8326 } 8327 } 8328 8329 if (rval == TRUE) { 8330 fas_reset_cleanup(fas, slot); 8331 } else { 8332 IPRINTF1("fas_scsi_reset failed for slot %x\n", slot); 8333 8334 /* 8335 * restore throttles to max throttle, regardless 8336 * of what it was (fas_set_throttles() will deal 8337 * with reset delay active) 8338 * restoring to the old throttle is not 8339 * a such a good idea 8340 */ 8341 fas_set_all_lun_throttles(fas, slot, MAX_THROTTLE); 8342 8343 } 8344 8345 if (fas->f_state == STATE_FREE) { 8346 (void) fas_ustart(fas); 8347 } 8348 } 8349 exit: 8350 ASSERT(mutex_owned(FAS_MUTEX(fas))); 8351 ASSERT(fas->f_ncmds >= fas->f_ndisc); 8352 8353 #ifdef FASDEBUG 8354 if (rval && fas_test_stop) { 8355 debug_enter("reset succeeded"); 8356 } 8357 #endif 8358 return (rval); 8359 } 8360 8361 /* 8362 * reset delay is handled by a separate watchdog; this ensures that 8363 * regardless of fas_scsi_watchdog_tick, the reset delay will not change 8364 */ 8365 static void 8366 fas_start_watch_reset_delay(struct fas *fas) 8367 { 8368 mutex_enter(&fas_global_mutex); 8369 if ((fas_reset_watch == 0) && FAS_CAN_SCHED) { 8370 fas_reset_watch = timeout(fas_watch_reset_delay, NULL, 8371 drv_usectohz((clock_t)FAS_WATCH_RESET_DELAY_TICK * 1000)); 8372 } 8373 ASSERT((fas_reset_watch != 0) || (fas->f_flags & FAS_FLG_NOTIMEOUTS)); 8374 mutex_exit(&fas_global_mutex); 8375 } 8376 8377 /* 8378 * set throttles to HOLD and set reset_delay for all target/luns 8379 */ 8380 static void 8381 fas_setup_reset_delay(struct fas *fas) 8382 { 8383 if (!ddi_in_panic()) { 8384 int i; 8385 8386 fas_set_throttles(fas, 0, N_SLOTS, HOLD_THROTTLE); 8387 for (i = 0; i < NTARGETS_WIDE; i++) { 8388 fas->f_reset_delay[i] = fas->f_scsi_reset_delay; 8389 } 8390 fas_start_watch_reset_delay(fas); 8391 } else { 8392 drv_usecwait(fas->f_scsi_reset_delay * 1000); 8393 } 8394 } 8395 8396 /* 8397 * fas_watch_reset_delay(_subr) is invoked by timeout() and checks every 8398 * fas instance for active reset delays 8399 */ 8400 /*ARGSUSED*/ 8401 static void 8402 fas_watch_reset_delay(void *arg) 8403 { 8404 struct fas *fas; 8405 struct fas *lfas; /* last not_done fas */ 8406 int not_done = 0; 8407 8408 mutex_enter(&fas_global_mutex); 8409 fas_reset_watch = 0; 8410 mutex_exit(&fas_global_mutex); 8411 8412 rw_enter(&fas_global_rwlock, RW_READER); 8413 for (fas = fas_head; fas != (struct fas *)NULL; fas = fas->f_next) { 8414 if (fas->f_tran == 0) { 8415 continue; 8416 } 8417 mutex_enter(FAS_MUTEX(fas)); 8418 not_done += fas_watch_reset_delay_subr(fas); 8419 lfas = fas; 8420 fas_check_waitQ_and_mutex_exit(fas); 8421 } 8422 rw_exit(&fas_global_rwlock); 8423 if (not_done) { 8424 ASSERT(lfas != NULL); 8425 fas_start_watch_reset_delay(lfas); 8426 } 8427 } 8428 8429 static int 8430 fas_watch_reset_delay_subr(struct fas *fas) 8431 { 8432 short slot, s; 8433 int start_slot = -1; 8434 int done = 0; 8435 8436 for (slot = 0; slot < N_SLOTS; slot += NLUNS_PER_TARGET) { 8437 8438 /* 8439 * check if a reset delay is active; if so back to full throttle 8440 * which will unleash the cmds in the ready Q 8441 */ 8442 s = slot/NLUNS_PER_TARGET; 8443 if (fas->f_reset_delay[s] != 0) { 8444 EPRINTF2("target%d: reset delay=%d\n", s, 8445 fas->f_reset_delay[s]); 8446 fas->f_reset_delay[s] -= FAS_WATCH_RESET_DELAY_TICK; 8447 if (fas->f_reset_delay[s] <= 0) { 8448 /* 8449 * clear throttle for all luns on this target 8450 */ 8451 fas->f_reset_delay[s] = 0; 8452 fas_set_all_lun_throttles(fas, 8453 slot, MAX_THROTTLE); 8454 IPRINTF1("reset delay completed, slot=%x\n", 8455 slot); 8456 if (start_slot == -1) { 8457 start_slot = slot; 8458 } 8459 } else { 8460 done = -1; 8461 } 8462 } 8463 } 8464 8465 /* 8466 * start a cmd if a reset delay expired 8467 */ 8468 if (start_slot != -1 && fas->f_state == STATE_FREE) { 8469 (void) fas_ustart(fas); 8470 } 8471 return (done); 8472 } 8473 8474 /* 8475 * cleanup after a device reset. this affects all target's luns 8476 */ 8477 static void 8478 fas_reset_cleanup(struct fas *fas, int slot) 8479 { 8480 /* 8481 * reset msg has been accepted, now cleanup queues; 8482 * for all luns of this target 8483 */ 8484 int i, start, end; 8485 int target = slot/NLUNS_PER_TARGET; 8486 8487 start = slot & ~(NLUNS_PER_TARGET-1); 8488 end = start + NLUNS_PER_TARGET; 8489 IPRINTF4("fas_reset_cleanup: slot %x, start=%x, end=%x, tcmds=%x\n", 8490 slot, start, end, fas->f_tcmds[slot]); 8491 8492 ASSERT(!(fas->f_current_sp && 8493 (fas->f_current_sp->cmd_slot == slot) && 8494 (fas->f_state & STATE_SELECTING))); 8495 8496 /* 8497 * if we are not in panic set up a reset delay for this target, 8498 * a zero throttle forces all new requests into the ready Q 8499 */ 8500 if (!ddi_in_panic()) { 8501 fas_set_all_lun_throttles(fas, start, HOLD_THROTTLE); 8502 fas->f_reset_delay[target] = fas->f_scsi_reset_delay; 8503 fas_start_watch_reset_delay(fas); 8504 } else { 8505 drv_usecwait(fas->f_scsi_reset_delay * 1000); 8506 } 8507 8508 for (i = start; i < end; i++) { 8509 fas_mark_packets(fas, i, CMD_RESET, STAT_DEV_RESET); 8510 fas_flush_tagQ(fas, i); 8511 fas_flush_readyQ(fas, i); 8512 if (fas->f_arq_pkt[i]) { 8513 struct fas_cmd *sp = fas->f_arq_pkt[i]; 8514 struct arq_private_data *arq_data = 8515 (struct arq_private_data *)(sp->cmd_pkt->pkt_private); 8516 if (sp->cmd_pkt->pkt_comp) { 8517 ASSERT(arq_data->arq_save_sp == NULL); 8518 } 8519 } 8520 ASSERT(fas->f_tcmds[i] == 0); 8521 } 8522 ASSERT(fas->f_ncmds >= fas->f_ndisc); 8523 8524 fas_force_renegotiation(fas, target); 8525 } 8526 8527 /* 8528 * reset a currently disconnected target 8529 */ 8530 static int 8531 fas_reset_disconnected_cmd(struct fas *fas, struct scsi_address *ap) 8532 { 8533 auto struct fas_cmd local; 8534 struct fas_cmd *sp = &local; 8535 struct scsi_pkt pkt; 8536 8537 fas_makeproxy_cmd(sp, ap, &pkt, 1, MSG_DEVICE_RESET); 8538 return (fas_do_proxy_cmd(fas, sp, ap, scsi_mname(MSG_DEVICE_RESET))); 8539 } 8540 8541 /* 8542 * reset a target with a currently connected command 8543 * Assert ATN and send MSG_DEVICE_RESET, zero throttles temporarily 8544 * to prevent new cmds from starting regardless of the outcome 8545 */ 8546 static int 8547 fas_reset_connected_cmd(struct fas *fas, struct scsi_address *ap) 8548 { 8549 int rval = FALSE; 8550 struct fas_cmd *sp = fas->f_current_sp; 8551 int flags = sp->cmd_pkt_flags; 8552 8553 /* 8554 * only attempt to reset in data phase; during other phases 8555 * asserting ATN may just cause confusion 8556 */ 8557 if (!((fas->f_state == ACTS_DATA) || 8558 (fas->f_state == ACTS_DATA_DONE))) { 8559 return (rval); 8560 } 8561 8562 IPRINTF2("Sending reset message to connected %d.%d\n", 8563 ap->a_target, ap->a_lun); 8564 fas->f_reset_msg_sent = 0; 8565 fas->f_omsglen = 1; 8566 fas->f_cur_msgout[0] = MSG_DEVICE_RESET; 8567 sp->cmd_pkt_flags |= FLAG_NOINTR; 8568 8569 fas_assert_atn(fas); 8570 8571 /* 8572 * poll for interrupts until bus free 8573 */ 8574 (void) fas_dopoll(fas, SHORT_POLL_TIMEOUT); 8575 8576 /* 8577 * now check if the msg was taken 8578 * f_reset is set in fas_handle_msg_out_done when 8579 * msg has actually gone out (ie. msg out phase occurred) 8580 */ 8581 if (fas->f_reset_msg_sent && (sp->cmd_flags & CFLAG_COMPLETED)) { 8582 IPRINTF2("target %d.%d reset\n", ap->a_target, ap->a_lun); 8583 rval = TRUE; 8584 } else { 8585 IPRINTF2("target %d.%d did not reset\n", 8586 ap->a_target, ap->a_lun); 8587 } 8588 sp->cmd_pkt_flags = flags; 8589 fas->f_omsglen = 0; 8590 8591 return (rval); 8592 } 8593 8594 /* 8595 * reset the scsi bus to blow all commands away 8596 */ 8597 static int 8598 fas_reset_bus(struct fas *fas) 8599 { 8600 IPRINTF("fas_reset_bus:\n"); 8601 New_state(fas, ACTS_RESET); 8602 8603 fas_internal_reset(fas, FAS_RESET_SCSIBUS); 8604 8605 /* 8606 * Now that we've reset the SCSI bus, we'll take a SCSI RESET 8607 * interrupt and use that to clean up the state of things. 8608 */ 8609 return (ACTION_RETURN); 8610 } 8611 8612 /* 8613 * fas_reset_recovery is called on the reset interrupt and cleans 8614 * up all cmds (active or waiting) 8615 */ 8616 static int 8617 fas_reset_recovery(struct fas *fas) 8618 { 8619 short slot, start_slot; 8620 int i; 8621 int rval = ACTION_SEARCH; 8622 int max_loop = 0; 8623 8624 IPRINTF("fas_reset_recovery:\n"); 8625 fas_check_ncmds(fas); 8626 8627 /* 8628 * renegotiate wide and sync for all targets 8629 */ 8630 fas->f_sync_known = fas->f_wide_known = 0; 8631 8632 /* 8633 * reset dma engine 8634 */ 8635 FAS_FLUSH_DMA_HARD(fas); 8636 8637 /* 8638 * set throttles and reset delay 8639 */ 8640 fas_setup_reset_delay(fas); 8641 8642 /* 8643 * clear interrupts until they go away 8644 */ 8645 while (INTPENDING(fas) && (max_loop < FAS_RESET_SPIN_MAX_LOOP)) { 8646 volatile struct fasreg *fasreg = fas->f_reg; 8647 fas->f_stat = fas_reg_read(fas, &fasreg->fas_stat); 8648 fas->f_stat2 = fas_reg_read(fas, &fasreg->fas_stat2); 8649 fas->f_step = fas_reg_read(fas, &fasreg->fas_step); 8650 fas->f_intr = fas_reg_read(fas, &fasreg->fas_intr); 8651 drv_usecwait(FAS_RESET_SPIN_DELAY_USEC); 8652 max_loop++; 8653 } 8654 8655 if (max_loop >= FAS_RESET_SPIN_MAX_LOOP) { 8656 fas_log(fas, CE_WARN, "Resetting SCSI bus failed"); 8657 } 8658 8659 fas_reg_cmd_write(fas, CMD_FLUSH); 8660 8661 /* 8662 * reset the chip, this shouldn't be necessary but sometimes 8663 * we get a hang in the next data in phase 8664 */ 8665 fas_internal_reset(fas, FAS_RESET_FAS); 8666 8667 /* 8668 * reset was expected? if not, it must be external bus reset 8669 */ 8670 if (fas->f_state != ACTS_RESET) { 8671 if (fas->f_ncmds) { 8672 fas_log(fas, CE_WARN, "external SCSI bus reset"); 8673 } 8674 } 8675 8676 if (fas->f_ncmds == 0) { 8677 rval = ACTION_RETURN; 8678 goto done; 8679 } 8680 8681 /* 8682 * completely reset the state of the softc data. 8683 */ 8684 fas_internal_reset(fas, FAS_RESET_SOFTC); 8685 8686 /* 8687 * Hold the state of the host adapter open 8688 */ 8689 New_state(fas, ACTS_FROZEN); 8690 8691 /* 8692 * for right now just claim that all 8693 * commands have been destroyed by a SCSI reset 8694 * and let already set reason fields or callers 8695 * decide otherwise for specific commands. 8696 */ 8697 start_slot = fas->f_next_slot; 8698 slot = start_slot; 8699 do { 8700 fas_check_ncmds(fas); 8701 fas_mark_packets(fas, slot, CMD_RESET, STAT_BUS_RESET); 8702 fas_flush_tagQ(fas, slot); 8703 fas_flush_readyQ(fas, slot); 8704 if (fas->f_arq_pkt[slot]) { 8705 struct fas_cmd *sp = fas->f_arq_pkt[slot]; 8706 struct arq_private_data *arq_data = 8707 (struct arq_private_data *)(sp->cmd_pkt->pkt_private); 8708 if (sp->cmd_pkt->pkt_comp) { 8709 ASSERT(arq_data->arq_save_sp == NULL); 8710 } 8711 } 8712 slot = NEXTSLOT(slot, fas->f_dslot); 8713 } while (slot != start_slot); 8714 8715 fas_check_ncmds(fas); 8716 8717 /* 8718 * reset timeouts 8719 */ 8720 for (i = 0; i < N_SLOTS; i++) { 8721 if (fas->f_active[i]) { 8722 fas->f_active[i]->f_timebase = 0; 8723 fas->f_active[i]->f_timeout = 0; 8724 fas->f_active[i]->f_dups = 0; 8725 } 8726 } 8727 8728 done: 8729 /* 8730 * Move the state back to free... 8731 */ 8732 New_state(fas, STATE_FREE); 8733 ASSERT(fas->f_ncmds >= fas->f_ndisc); 8734 8735 /* 8736 * perform the reset notification callbacks that are registered. 8737 */ 8738 (void) scsi_hba_reset_notify_callback(&fas->f_mutex, 8739 &fas->f_reset_notify_listf); 8740 8741 /* 8742 * if reset delay is still active a search is meaningless 8743 * but do it anyway 8744 */ 8745 return (rval); 8746 } 8747 8748 /* 8749 * hba_tran ops for quiesce and unquiesce 8750 */ 8751 static int 8752 fas_scsi_quiesce(dev_info_t *dip) 8753 { 8754 struct fas *fas; 8755 scsi_hba_tran_t *tran; 8756 8757 tran = ddi_get_driver_private(dip); 8758 if ((tran == NULL) || ((fas = TRAN2FAS(tran)) == NULL)) { 8759 return (-1); 8760 } 8761 8762 return (fas_quiesce_bus(fas)); 8763 } 8764 8765 static int 8766 fas_scsi_unquiesce(dev_info_t *dip) 8767 { 8768 struct fas *fas; 8769 scsi_hba_tran_t *tran; 8770 8771 tran = ddi_get_driver_private(dip); 8772 if ((tran == NULL) || ((fas = TRAN2FAS(tran)) == NULL)) { 8773 return (-1); 8774 } 8775 8776 return (fas_unquiesce_bus(fas)); 8777 } 8778 8779 #ifdef FAS_TEST 8780 /* 8781 * torture test functions 8782 */ 8783 static void 8784 fas_test_reset(struct fas *fas, int slot) 8785 { 8786 struct scsi_address ap; 8787 char target = slot/NLUNS_PER_TARGET; 8788 8789 if (fas_rtest & (1 << target)) { 8790 ap.a_hba_tran = fas->f_tran; 8791 ap.a_target = target; 8792 ap.a_lun = 0; 8793 if ((fas_rtest_type == 1) && 8794 (fas->f_state == ACTS_DATA_DONE)) { 8795 if (fas_do_scsi_reset(&ap, RESET_TARGET)) { 8796 fas_rtest = 0; 8797 } 8798 } else if ((fas_rtest_type == 2) && 8799 (fas->f_state == ACTS_DATA_DONE)) { 8800 if (fas_do_scsi_reset(&ap, RESET_ALL)) { 8801 fas_rtest = 0; 8802 } 8803 } else { 8804 if (fas_do_scsi_reset(&ap, RESET_TARGET)) { 8805 fas_rtest = 0; 8806 } 8807 } 8808 } 8809 } 8810 8811 static void 8812 fas_test_abort(struct fas *fas, int slot) 8813 { 8814 struct fas_cmd *sp = fas->f_current_sp; 8815 struct scsi_address ap; 8816 char target = slot/NLUNS_PER_TARGET; 8817 struct scsi_pkt *pkt = NULL; 8818 8819 if (fas_atest & (1 << target)) { 8820 ap.a_hba_tran = fas->f_tran; 8821 ap.a_target = target; 8822 ap.a_lun = 0; 8823 8824 if ((fas_atest_disc == 0) && sp && 8825 (sp->cmd_slot == slot) && 8826 ((sp->cmd_flags & CFLAG_CMDDISC) == 0)) { 8827 pkt = sp->cmd_pkt; 8828 } else if ((fas_atest_disc == 1) && NOTAG(target)) { 8829 sp = fas->f_active[slot]->f_slot[0]; 8830 if (sp && (sp->cmd_flags & CFLAG_CMDDISC)) { 8831 pkt = sp->cmd_pkt; 8832 } 8833 } else if ((fas_atest_disc == 1) && (sp == 0) && 8834 TAGGED(target) && 8835 (fas->f_tcmds[slot] != 0)) { 8836 int tag; 8837 /* 8838 * find the oldest tag 8839 */ 8840 for (tag = NTAGS-1; tag >= 0; tag--) { 8841 if ((sp = fas->f_active[slot]->f_slot[tag]) != 0) 8842 break; 8843 } 8844 if (sp) { 8845 pkt = sp->cmd_pkt; 8846 ASSERT(sp->cmd_slot == slot); 8847 } else { 8848 return; 8849 } 8850 } else if (fas_atest_disc == 2 && (sp == 0) && 8851 (fas->f_tcmds[slot] != 0)) { 8852 pkt = NULL; 8853 } else if (fas_atest_disc == 2 && NOTAG(target)) { 8854 pkt = NULL; 8855 } else if (fas_atest_disc == 3 && fas->f_readyf[slot]) { 8856 pkt = fas->f_readyf[slot]->cmd_pkt; 8857 } else if (fas_atest_disc == 4 && 8858 fas->f_readyf[slot] && fas->f_readyf[slot]->cmd_forw) { 8859 pkt = fas->f_readyf[slot]->cmd_forw->cmd_pkt; 8860 } else if (fas_atest_disc == 5 && fas->f_readyb[slot]) { 8861 pkt = fas->f_readyb[slot]->cmd_pkt; 8862 } else if ((fas_atest_disc == 6) && sp && 8863 (sp->cmd_slot == slot) && 8864 (fas->f_state == ACTS_DATA_DONE)) { 8865 pkt = sp->cmd_pkt; 8866 } else if (fas_atest_disc == 7) { 8867 if (fas_do_scsi_abort(&ap, NULL)) { 8868 if (fas_do_scsi_abort(&ap, NULL)) { 8869 if (fas_do_scsi_reset(&ap, 8870 RESET_TARGET)) { 8871 fas_atest = 0; 8872 } 8873 } 8874 } 8875 return; 8876 } else { 8877 return; 8878 } 8879 8880 fas_log(fas, CE_NOTE, "aborting pkt=0x%p state=%x\n", 8881 (void *)pkt, (pkt != NULL? pkt->pkt_state : 0)); 8882 if (fas_do_scsi_abort(&ap, pkt)) { 8883 fas_atest = 0; 8884 } 8885 } 8886 } 8887 #endif /* FAS_TEST */ 8888 8889 /* 8890 * capability interface 8891 */ 8892 static int 8893 fas_commoncap(struct scsi_address *ap, char *cap, int val, 8894 int tgtonly, int doset) 8895 { 8896 struct fas *fas = ADDR2FAS(ap); 8897 int cidx; 8898 int target = ap->a_target; 8899 ushort_t tshift = (1<<target); 8900 ushort_t ntshift = ~tshift; 8901 int rval = FALSE; 8902 8903 mutex_enter(FAS_MUTEX(fas)); 8904 8905 if (cap == (char *)0) { 8906 goto exit; 8907 } 8908 8909 cidx = scsi_hba_lookup_capstr(cap); 8910 if (cidx == -1) { 8911 rval = UNDEFINED; 8912 } else if (doset) { 8913 /* 8914 * we usually don't allow setting capabilities for 8915 * other targets! 8916 */ 8917 if (!tgtonly) { 8918 goto exit; 8919 } 8920 switch (cidx) { 8921 case SCSI_CAP_DMA_MAX: 8922 case SCSI_CAP_MSG_OUT: 8923 case SCSI_CAP_PARITY: 8924 case SCSI_CAP_INITIATOR_ID: 8925 case SCSI_CAP_LINKED_CMDS: 8926 case SCSI_CAP_UNTAGGED_QING: 8927 case SCSI_CAP_RESET_NOTIFICATION: 8928 /* 8929 * None of these are settable via 8930 * the capability interface. 8931 */ 8932 break; 8933 8934 case SCSI_CAP_DISCONNECT: 8935 if (val) 8936 fas->f_target_scsi_options[ap->a_target] |= 8937 SCSI_OPTIONS_DR; 8938 else 8939 fas->f_target_scsi_options[ap->a_target] &= 8940 ~SCSI_OPTIONS_DR; 8941 8942 break; 8943 8944 case SCSI_CAP_SYNCHRONOUS: 8945 if (val) { 8946 fas->f_force_async &= ~tshift; 8947 } else { 8948 fas->f_force_async |= tshift; 8949 } 8950 fas_force_renegotiation(fas, target); 8951 rval = TRUE; 8952 break; 8953 8954 case SCSI_CAP_TAGGED_QING: 8955 { 8956 int slot = target * NLUNS_PER_TARGET | ap->a_lun; 8957 ushort_t old_notag = fas->f_notag; 8958 8959 /* do not allow with active tgt */ 8960 if (fas->f_tcmds[slot]) { 8961 break; 8962 } 8963 8964 slot = target * NLUNS_PER_TARGET | ap->a_lun; 8965 8966 if (val) { 8967 if (fas->f_target_scsi_options[target] & 8968 SCSI_OPTIONS_TAG) { 8969 IPRINTF1("target %d: TQ enabled\n", 8970 target); 8971 fas->f_notag &= ntshift; 8972 } else { 8973 break; 8974 } 8975 } else { 8976 IPRINTF1("target %d: TQ disabled\n", 8977 target); 8978 fas->f_notag |= tshift; 8979 } 8980 8981 if (val && fas_alloc_active_slots(fas, slot, 8982 KM_NOSLEEP)) { 8983 fas->f_notag = old_notag; 8984 break; 8985 } 8986 8987 fas_set_all_lun_throttles(fas, slot, MAX_THROTTLE); 8988 8989 fas_update_props(fas, target); 8990 rval = TRUE; 8991 break; 8992 } 8993 8994 case SCSI_CAP_WIDE_XFER: 8995 if (val) { 8996 if (fas->f_target_scsi_options[target] & 8997 SCSI_OPTIONS_WIDE) { 8998 fas->f_nowide &= ntshift; 8999 fas->f_force_narrow &= ~tshift; 9000 } else { 9001 break; 9002 } 9003 } else { 9004 fas->f_force_narrow |= tshift; 9005 } 9006 fas_force_renegotiation(fas, target); 9007 rval = TRUE; 9008 break; 9009 9010 case SCSI_CAP_ARQ: 9011 if (val) { 9012 if (fas_create_arq_pkt(fas, ap)) { 9013 break; 9014 } 9015 } else { 9016 if (fas_delete_arq_pkt(fas, ap)) { 9017 break; 9018 } 9019 } 9020 rval = TRUE; 9021 break; 9022 9023 case SCSI_CAP_QFULL_RETRIES: 9024 fas->f_qfull_retries[target] = (uchar_t)val; 9025 rval = TRUE; 9026 break; 9027 9028 case SCSI_CAP_QFULL_RETRY_INTERVAL: 9029 fas->f_qfull_retry_interval[target] = 9030 drv_usectohz(val * 1000); 9031 rval = TRUE; 9032 break; 9033 9034 default: 9035 rval = UNDEFINED; 9036 break; 9037 } 9038 9039 } else if (doset == 0) { 9040 int slot = target * NLUNS_PER_TARGET | ap->a_lun; 9041 9042 switch (cidx) { 9043 case SCSI_CAP_DMA_MAX: 9044 /* very high limit because of multiple dma windows */ 9045 rval = 1<<30; 9046 break; 9047 case SCSI_CAP_MSG_OUT: 9048 rval = TRUE; 9049 break; 9050 case SCSI_CAP_DISCONNECT: 9051 if (tgtonly && 9052 (fas->f_target_scsi_options[target] & 9053 SCSI_OPTIONS_DR)) { 9054 rval = TRUE; 9055 } 9056 break; 9057 case SCSI_CAP_SYNCHRONOUS: 9058 if (tgtonly && fas->f_offset[target]) { 9059 rval = TRUE; 9060 } 9061 break; 9062 case SCSI_CAP_PARITY: 9063 rval = TRUE; 9064 break; 9065 case SCSI_CAP_INITIATOR_ID: 9066 rval = MY_ID(fas); 9067 break; 9068 case SCSI_CAP_TAGGED_QING: 9069 if (tgtonly && ((fas->f_notag & tshift) == 0)) { 9070 rval = TRUE; 9071 } 9072 break; 9073 case SCSI_CAP_WIDE_XFER: 9074 if ((tgtonly && (fas->f_nowide & tshift) == 0)) { 9075 rval = TRUE; 9076 } 9077 break; 9078 case SCSI_CAP_UNTAGGED_QING: 9079 rval = TRUE; 9080 break; 9081 case SCSI_CAP_ARQ: 9082 if (tgtonly && fas->f_arq_pkt[slot]) { 9083 rval = TRUE; 9084 } 9085 break; 9086 case SCSI_CAP_LINKED_CMDS: 9087 break; 9088 case SCSI_CAP_RESET_NOTIFICATION: 9089 rval = TRUE; 9090 break; 9091 case SCSI_CAP_QFULL_RETRIES: 9092 rval = fas->f_qfull_retries[target]; 9093 break; 9094 case SCSI_CAP_QFULL_RETRY_INTERVAL: 9095 rval = drv_hztousec( 9096 fas->f_qfull_retry_interval[target]) / 9097 1000; 9098 break; 9099 9100 default: 9101 rval = UNDEFINED; 9102 break; 9103 } 9104 } 9105 exit: 9106 if (val && tgtonly) { 9107 fas_update_props(fas, target); 9108 } 9109 fas_check_waitQ_and_mutex_exit(fas); 9110 9111 if (doset) { 9112 IPRINTF6( 9113 "fas_commoncap:tgt=%x,cap=%s,tgtonly=%x,doset=%x,val=%x,rval=%x\n", 9114 target, cap, tgtonly, doset, val, rval); 9115 } 9116 return (rval); 9117 } 9118 9119 /* 9120 * property management 9121 * fas_update_props: 9122 * create/update sync/wide/TQ/scsi-options properties for this target 9123 */ 9124 static void 9125 fas_update_props(struct fas *fas, int tgt) 9126 { 9127 char property[32]; 9128 uint_t xfer_speed = 0; 9129 uint_t xfer_rate = 0; 9130 int wide_enabled, tq_enabled; 9131 uint_t regval = fas->f_sync_period[tgt]; 9132 int offset = fas->f_offset[tgt]; 9133 9134 wide_enabled = ((fas->f_nowide & (1<<tgt)) == 0); 9135 if (offset && regval) { 9136 xfer_speed = 9137 FAS_SYNC_KBPS((regval * fas->f_clock_cycle) / 1000); 9138 xfer_rate = ((wide_enabled)? 2 : 1) * xfer_speed; 9139 } 9140 (void) sprintf(property, "target%x-sync-speed", tgt); 9141 fas_update_this_prop(fas, property, xfer_rate); 9142 9143 (void) sprintf(property, "target%x-wide", tgt); 9144 fas_update_this_prop(fas, property, wide_enabled); 9145 9146 (void) sprintf(property, "target%x-TQ", tgt); 9147 tq_enabled = ((fas->f_notag & (1<<tgt))? 0 : 1); 9148 fas_update_this_prop(fas, property, tq_enabled); 9149 9150 } 9151 9152 static void 9153 fas_update_this_prop(struct fas *fas, char *property, int value) 9154 { 9155 dev_info_t *dip = fas->f_dev; 9156 9157 IPRINTF2("update prop: %s value=%x\n", property, value); 9158 ASSERT(mutex_owned(FAS_MUTEX(fas))); 9159 /* 9160 * We cannot hold any mutex at this point because the call to 9161 * ddi_prop_update_int() may block. 9162 */ 9163 mutex_exit(FAS_MUTEX(fas)); 9164 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 9165 property, value) != DDI_PROP_SUCCESS) { 9166 IPRINTF1("cannot modify/create %s property\n", property); 9167 } 9168 mutex_enter(FAS_MUTEX(fas)); 9169 } 9170 9171 /* 9172 * allocate active slots array, size is dependent on whether tagQ enabled 9173 */ 9174 static int 9175 fas_alloc_active_slots(struct fas *fas, int slot, int flag) 9176 { 9177 int target = slot / NLUNS_PER_TARGET; 9178 struct f_slots *old_active = fas->f_active[slot]; 9179 struct f_slots *new_active; 9180 ushort_t size; 9181 int rval = -1; 9182 9183 if (fas->f_tcmds[slot]) { 9184 IPRINTF("cannot change size of active slots array\n"); 9185 return (rval); 9186 } 9187 9188 size = ((NOTAG(target)) ? FAS_F_SLOT_SIZE : FAS_F_SLOTS_SIZE_TQ); 9189 EPRINTF4( 9190 "fas_alloc_active_slots: target=%x size=%x, old=0x%p, oldsize=%x\n", 9191 target, size, (void *)old_active, 9192 ((old_active == NULL) ? -1 : old_active->f_size)); 9193 9194 new_active = kmem_zalloc(size, flag); 9195 if (new_active == NULL) { 9196 IPRINTF("new active alloc failed\n"); 9197 } else { 9198 fas->f_active[slot] = new_active; 9199 fas->f_active[slot]->f_n_slots = (NOTAG(target) ? 1 : NTAGS); 9200 fas->f_active[slot]->f_size = size; 9201 /* 9202 * reserve tag 0 for non-tagged cmds to tagged targets 9203 */ 9204 if (TAGGED(target)) { 9205 fas->f_active[slot]->f_tags = 1; 9206 } 9207 if (old_active) { 9208 kmem_free((caddr_t)old_active, old_active->f_size); 9209 } 9210 rval = 0; 9211 } 9212 return (rval); 9213 } 9214 9215 /* 9216 * Error logging, printing, and debug print routines 9217 */ 9218 static char *fas_label = "fas"; 9219 9220 /*PRINTFLIKE3*/ 9221 static void 9222 fas_log(struct fas *fas, int level, const char *fmt, ...) 9223 { 9224 dev_info_t *dev; 9225 va_list ap; 9226 9227 if (fas) { 9228 dev = fas->f_dev; 9229 } else { 9230 dev = 0; 9231 } 9232 9233 mutex_enter(&fas_log_mutex); 9234 9235 va_start(ap, fmt); 9236 (void) vsprintf(fas_log_buf, fmt, ap); 9237 va_end(ap); 9238 9239 if (level == CE_CONT) { 9240 scsi_log(dev, fas_label, level, "%s\n", fas_log_buf); 9241 } else { 9242 scsi_log(dev, fas_label, level, "%s", fas_log_buf); 9243 } 9244 9245 mutex_exit(&fas_log_mutex); 9246 } 9247 9248 /*PRINTFLIKE2*/ 9249 static void 9250 fas_printf(struct fas *fas, const char *fmt, ...) 9251 { 9252 dev_info_t *dev = 0; 9253 va_list ap; 9254 int level = CE_CONT; 9255 9256 mutex_enter(&fas_log_mutex); 9257 9258 va_start(ap, fmt); 9259 (void) vsprintf(fas_log_buf, fmt, ap); 9260 va_end(ap); 9261 9262 if (fas) { 9263 dev = fas->f_dev; 9264 level = CE_NOTE; 9265 scsi_log(dev, fas_label, level, "%s", fas_log_buf); 9266 } else { 9267 scsi_log(dev, fas_label, level, "%s\n", fas_log_buf); 9268 } 9269 9270 mutex_exit(&fas_log_mutex); 9271 } 9272 9273 #ifdef FASDEBUG 9274 /*PRINTFLIKE2*/ 9275 void 9276 fas_dprintf(struct fas *fas, const char *fmt, ...) 9277 { 9278 dev_info_t *dev = 0; 9279 va_list ap; 9280 9281 if (fas) { 9282 dev = fas->f_dev; 9283 } 9284 9285 mutex_enter(&fas_log_mutex); 9286 9287 va_start(ap, fmt); 9288 (void) vsprintf(fas_log_buf, fmt, ap); 9289 va_end(ap); 9290 9291 scsi_log(dev, fas_label, SCSI_DEBUG, "%s", fas_log_buf); 9292 9293 mutex_exit(&fas_log_mutex); 9294 } 9295 #endif 9296 9297 9298 static void 9299 fas_printstate(struct fas *fas, char *msg) 9300 { 9301 volatile struct fasreg *fasreg = fas->f_reg; 9302 volatile struct dma *dmar = fas->f_dma; 9303 uint_t csr = fas_dma_reg_read(fas, &dmar->dma_csr); 9304 uint_t count = fas_dma_reg_read(fas, &dmar->dma_count); 9305 uint_t addr = fas_dma_reg_read(fas, &dmar->dma_addr); 9306 uint_t test = fas_dma_reg_read(fas, &dmar->dma_test); 9307 uint_t fas_cnt; 9308 9309 fas_log(fas, CE_WARN, "%s: current fas state:", msg); 9310 fas_printf(NULL, "Latched stat=0x%b intr=0x%b", 9311 fas->f_stat, FAS_STAT_BITS, fas->f_intr, FAS_INT_BITS); 9312 fas_printf(NULL, "last msgout: %s, last msgin: %s", 9313 scsi_mname(fas->f_last_msgout), scsi_mname(fas->f_last_msgin)); 9314 fas_printf(NULL, "DMA csr=0x%b", csr, dma_bits); 9315 fas_printf(NULL, 9316 "addr=%x dmacnt=%x test=%x last=%x last_cnt=%x", 9317 addr, count, test, fas->f_lastdma, fas->f_lastcount); 9318 9319 GET_FAS_COUNT(fasreg, fas_cnt); 9320 fas_printf(NULL, "fas state:"); 9321 fas_printf(NULL, "\tcount(32)=%x cmd=%x stat=%x stat2=%x intr=%x", 9322 fas_cnt, fasreg->fas_cmd, fasreg->fas_stat, fasreg->fas_stat2, 9323 fasreg->fas_intr); 9324 fas_printf(NULL, 9325 "\tstep=%x fifoflag=%x conf=%x test=%x conf2=%x conf3=%x", 9326 fasreg->fas_step, fasreg->fas_fifo_flag, fasreg->fas_conf, 9327 fasreg->fas_test, fasreg->fas_conf2, fasreg->fas_conf3); 9328 9329 if (fas->f_current_sp) { 9330 fas_dump_cmd(fas, fas->f_current_sp); 9331 } 9332 } 9333 9334 /* 9335 * dump all we know about a cmd 9336 */ 9337 static void 9338 fas_dump_cmd(struct fas *fas, struct fas_cmd *sp) 9339 { 9340 int i; 9341 uchar_t *cp = (uchar_t *)sp->cmd_pkt->pkt_cdbp; 9342 auto char buf[128]; 9343 9344 buf[0] = '\0'; 9345 fas_printf(NULL, "Cmd dump for Target %d Lun %d:", 9346 Tgt(sp), Lun(sp)); 9347 (void) sprintf(&buf[0], " cdb=["); 9348 for (i = 0; i < (int)sp->cmd_actual_cdblen; i++) { 9349 (void) sprintf(&buf[strlen(buf)], " 0x%x", *cp++); 9350 } 9351 (void) sprintf(&buf[strlen(buf)], " ]"); 9352 fas_printf(NULL, buf); 9353 fas_printf(NULL, "State=%s Last State=%s", 9354 fas_state_name(fas->f_state), fas_state_name(fas->f_laststate)); 9355 fas_printf(NULL, 9356 "pkt_state=0x%b pkt_flags=0x%x pkt_statistics=0x%x", 9357 sp->cmd_pkt->pkt_state, scsi_state_bits, sp->cmd_pkt_flags, 9358 sp->cmd_pkt->pkt_statistics); 9359 if (sp->cmd_pkt->pkt_state & STATE_GOT_STATUS) { 9360 fas_printf(NULL, "Status=0x%x\n", sp->cmd_pkt->pkt_scbp[0]); 9361 } 9362 } 9363 9364 /*ARGSUSED*/ 9365 static void 9366 fas_short_dump_cmd(struct fas *fas, struct fas_cmd *sp) 9367 { 9368 int i; 9369 uchar_t *cp = (uchar_t *)sp->cmd_pkt->pkt_cdbp; 9370 auto char buf[128]; 9371 9372 buf[0] = '\0'; 9373 (void) sprintf(&buf[0], "?%d.%d: cdb=[", Tgt(sp), Lun(sp)); 9374 for (i = 0; i < (int)sp->cmd_actual_cdblen; i++) { 9375 (void) sprintf(&buf[strlen(buf)], " 0x%x", *cp++); 9376 } 9377 (void) sprintf(&buf[strlen(buf)], " ]"); 9378 fas_printf(NULL, buf); 9379 } 9380 9381 /* 9382 * state decoding for error messages 9383 */ 9384 static char * 9385 fas_state_name(ushort_t state) 9386 { 9387 if (state == STATE_FREE) { 9388 return ("FREE"); 9389 } else if (state & STATE_SELECTING) { 9390 if (state == STATE_SELECT_NORMAL) 9391 return ("SELECT"); 9392 else if (state == STATE_SELECT_N_STOP) 9393 return ("SEL&STOP"); 9394 else if (state == STATE_SELECT_N_SENDMSG) 9395 return ("SELECT_SNDMSG"); 9396 else 9397 return ("SEL_NO_ATN"); 9398 } else { 9399 static struct { 9400 char *sname; 9401 char state; 9402 } names[] = { 9403 "CMD_START", ACTS_CMD_START, 9404 "CMD_DONE", ACTS_CMD_DONE, 9405 "MSG_OUT", ACTS_MSG_OUT, 9406 "MSG_OUT_DONE", ACTS_MSG_OUT_DONE, 9407 "MSG_IN", ACTS_MSG_IN, 9408 "MSG_IN_MORE", ACTS_MSG_IN_MORE, 9409 "MSG_IN_DONE", ACTS_MSG_IN_DONE, 9410 "CLEARING", ACTS_CLEARING, 9411 "DATA", ACTS_DATA, 9412 "DATA_DONE", ACTS_DATA_DONE, 9413 "CMD_CMPLT", ACTS_C_CMPLT, 9414 "UNKNOWN", ACTS_UNKNOWN, 9415 "RESEL", ACTS_RESEL, 9416 "ENDVEC", ACTS_ENDVEC, 9417 "RESET", ACTS_RESET, 9418 "ABORTING", ACTS_ABORTING, 9419 "FROZEN", ACTS_FROZEN, 9420 0 9421 }; 9422 int i; 9423 for (i = 0; names[i].sname; i++) { 9424 if (names[i].state == state) 9425 return (names[i].sname); 9426 } 9427 } 9428 return ("<BAD>"); 9429 } 9430