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