kernel/mchain: Fix a NULL check.
[dragonfly.git] / sys / dev / disk / isp / isp.c
CommitLineData
984263bc
MD
1/* $FreeBSD: src/sys/dev/isp/isp.c,v 1.41.2.23 2002/10/11 17:34:28 mjacob Exp $ */
2/*
3 * Machine and OS Independent (well, as best as possible)
4 * code for the Qlogic ISP SCSI adapters.
5 *
6 * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob
7 * Feral Software
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice immediately at the beginning of the file, without modification,
15 * this list of conditions, and the following disclaimer.
16 * 2. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * Inspiration and ideas about this driver are from Erik Moe's Linux driver
34 * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
35 * ideas dredged from the Solaris driver.
36 */
37
38/*
39 * Include header file appropriate for platform we're building on.
40 */
41
42#ifdef __NetBSD__
43#include <dev/ic/isp_netbsd.h>
44#endif
84754cd0 45#if defined(__DragonFly__) || defined(__FreeBSD__)
1f2de5d4 46#include "isp_freebsd.h"
984263bc
MD
47#endif
48#ifdef __OpenBSD__
49#include <dev/ic/isp_openbsd.h>
50#endif
51#ifdef __linux__
52#include "isp_linux.h"
53#endif
54#ifdef __svr4__
55#include "isp_solaris.h"
56#endif
57
58/*
59 * General defines
60 */
61
62#define MBOX_DELAY_COUNT 1000000 / 100
63
64/*
65 * Local static data
66 */
67static const char portshift[] =
68 "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
69static const char portdup[] =
70 "Target %d duplicates Target %d- killing off both";
71static const char retained[] =
72 "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
73static const char lretained[] =
74 "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
75static const char plogout[] =
76 "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
77static const char plogierr[] =
78 "Command Error in PLOGI for Port 0x%x (0x%x)";
79static const char nopdb[] =
80 "Could not get PDB for Device @ Port 0x%x";
81static const char pdbmfail1[] =
82 "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
83static const char pdbmfail2[] =
84 "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
85static const char ldumped[] =
86 "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
87static const char notresp[] =
88 "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
89static const char xact1[] =
90 "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
91static const char xact2[] =
92 "HBA attempted queued transaction to target routine %d on target %d bus %d";
93static const char xact3[] =
94 "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
95static const char pskip[] =
96 "SCSI phase skipped for target %d.%d.%d";
97static const char topology[] =
98 "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
99static const char swrej[] =
100 "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x";
101static const char finmsg[] =
102 "(%d.%d.%d): FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
103static const char sc0[] =
104 "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
105static const char sc1[] =
106 "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
107static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
108static const char sc3[] = "Generated";
109static const char sc4[] = "NVRAM";
110static const char bun[] =
111 "bad underrun for %d.%d (count %d, resid %d, status %s)";
112
113/*
114 * Local function prototypes.
115 */
116static int isp_parse_async(struct ispsoftc *, u_int16_t);
117static int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *,
118 u_int16_t *);
119static void
120isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *);
121static void isp_fastpost_complete(struct ispsoftc *, u_int16_t);
122static int isp_mbox_continue(struct ispsoftc *);
123static void isp_scsi_init(struct ispsoftc *);
124static void isp_scsi_channel_init(struct ispsoftc *, int);
125static void isp_fibre_init(struct ispsoftc *);
126static void isp_mark_getpdb_all(struct ispsoftc *);
127static int isp_getmap(struct ispsoftc *, fcpos_map_t *);
128static int isp_getpdb(struct ispsoftc *, int, isp_pdb_t *);
129static u_int64_t isp_get_portname(struct ispsoftc *, int, int);
130static int isp_fclink_test(struct ispsoftc *, int);
131static char *isp2100_fw_statename(int);
132static int isp_pdb_sync(struct ispsoftc *);
133static int isp_scan_loop(struct ispsoftc *);
134static int isp_fabric_mbox_cmd(struct ispsoftc *, mbreg_t *);
135static int isp_scan_fabric(struct ispsoftc *, int);
136static void isp_register_fc4_type(struct ispsoftc *);
137static void isp_fw_state(struct ispsoftc *);
138static void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int);
139static void isp_mboxcmd(struct ispsoftc *, mbreg_t *, int);
140
141static void isp_update(struct ispsoftc *);
142static void isp_update_bus(struct ispsoftc *, int);
143static void isp_setdfltparm(struct ispsoftc *, int);
144static int isp_read_nvram(struct ispsoftc *);
145static void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *);
146static void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *);
147static void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *);
148static void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *);
149static void isp_parse_nvram_2100(struct ispsoftc *, u_int8_t *);
150
151/*
152 * Reset Hardware.
153 *
154 * Hit the chip over the head, download new f/w if available and set it running.
155 *
156 * Locking done elsewhere.
157 */
158
159void
160isp_reset(struct ispsoftc *isp)
161{
162 mbreg_t mbs;
163 u_int16_t code_org;
164 int loops, i, dodnld = 1;
165 char *btype = "????";
166
167 isp->isp_state = ISP_NILSTATE;
168
169 /*
170 * Basic types (SCSI, FibreChannel and PCI or SBus)
171 * have been set in the MD code. We figure out more
172 * here. Possibly more refined types based upon PCI
173 * identification. Chip revision has been gathered.
174 *
175 * After we've fired this chip up, zero out the conf1 register
176 * for SCSI adapters and do other settings for the 2100.
177 */
178
179 /*
180 * Get the current running firmware revision out of the
181 * chip before we hit it over the head (if this is our
182 * first time through). Note that we store this as the
183 * 'ROM' firmware revision- which it may not be. In any
184 * case, we don't really use this yet, but we may in
185 * the future.
186 */
187 if (isp->isp_touched == 0) {
188 /*
189 * First see whether or not we're sitting in the ISP PROM.
190 * If we've just been reset, we'll have the string "ISP "
191 * spread through outgoing mailbox registers 1-3. We do
192 * this for PCI cards because otherwise we really don't
193 * know what state the card is in and we could hang if
194 * we try this command otherwise.
195 *
196 * For SBus cards, we just do this because they almost
197 * certainly will be running firmware by now.
198 */
199 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
200 ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
201 ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
202 /*
203 * Just in case it was paused...
204 */
205 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
206 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
207 isp_mboxcmd(isp, &mbs, MBLOGNONE);
208 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
209 isp->isp_romfw_rev[0] = mbs.param[1];
210 isp->isp_romfw_rev[1] = mbs.param[2];
211 isp->isp_romfw_rev[2] = mbs.param[3];
212 }
213 }
214 isp->isp_touched = 1;
215 }
216
217 DISABLE_INTS(isp);
218
219 /*
220 * Set up default request/response queue in-pointer/out-pointer
221 * register indices.
222 */
223 if (IS_23XX(isp)) {
224 isp->isp_rqstinrp = BIU_REQINP;
225 isp->isp_rqstoutrp = BIU_REQOUTP;
226 isp->isp_respinrp = BIU_RSPINP;
227 isp->isp_respoutrp = BIU_RSPOUTP;
228 } else {
229 isp->isp_rqstinrp = INMAILBOX4;
230 isp->isp_rqstoutrp = OUTMAILBOX4;
231 isp->isp_respinrp = OUTMAILBOX5;
232 isp->isp_respoutrp = INMAILBOX5;
233 }
234
235 /*
236 * Put the board into PAUSE mode (so we can read the SXP registers
237 * or write FPM/FBM registers).
238 */
239 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
240
241 if (IS_FC(isp)) {
242 switch (isp->isp_type) {
243 case ISP_HA_FC_2100:
244 btype = "2100";
245 break;
246 case ISP_HA_FC_2200:
247 btype = "2200";
248 break;
249 case ISP_HA_FC_2300:
250 btype = "2300";
251 break;
252 case ISP_HA_FC_2312:
253 btype = "2312";
254 break;
255 default:
256 break;
257 }
258 /*
259 * While we're paused, reset the FPM module and FBM fifos.
260 */
261 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
262 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
263 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
264 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
265 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
266 } else if (IS_1240(isp)) {
267 sdparam *sdp = isp->isp_param;
268 btype = "1240";
269 isp->isp_clock = 60;
270 sdp->isp_ultramode = 1;
271 sdp++;
272 sdp->isp_ultramode = 1;
273 /*
274 * XXX: Should probably do some bus sensing.
275 */
276 } else if (IS_ULTRA2(isp)) {
277 static const char m[] = "bus %d is in %s Mode";
278 u_int16_t l;
279 sdparam *sdp = isp->isp_param;
280
281 isp->isp_clock = 100;
282
283 if (IS_1280(isp))
284 btype = "1280";
285 else if (IS_1080(isp))
286 btype = "1080";
287 else if (IS_10160(isp))
288 btype = "10160";
289 else if (IS_12160(isp))
290 btype = "12160";
291 else
292 btype = "<UNKLVD>";
293
294 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
295 switch (l) {
296 case ISP1080_LVD_MODE:
297 sdp->isp_lvdmode = 1;
298 isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
299 break;
300 case ISP1080_HVD_MODE:
301 sdp->isp_diffmode = 1;
302 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
303 break;
304 case ISP1080_SE_MODE:
305 sdp->isp_ultramode = 1;
306 isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
307 break;
308 default:
309 isp_prt(isp, ISP_LOGERR,
310 "unknown mode on bus %d (0x%x)", 0, l);
311 break;
312 }
313
314 if (IS_DUALBUS(isp)) {
315 sdp++;
316 l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
317 l &= ISP1080_MODE_MASK;
318 switch(l) {
319 case ISP1080_LVD_MODE:
320 sdp->isp_lvdmode = 1;
321 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
322 break;
323 case ISP1080_HVD_MODE:
324 sdp->isp_diffmode = 1;
325 isp_prt(isp, ISP_LOGCONFIG,
326 m, 1, "Differential");
327 break;
328 case ISP1080_SE_MODE:
329 sdp->isp_ultramode = 1;
330 isp_prt(isp, ISP_LOGCONFIG,
331 m, 1, "Single-Ended");
332 break;
333 default:
334 isp_prt(isp, ISP_LOGERR,
335 "unknown mode on bus %d (0x%x)", 1, l);
336 break;
337 }
338 }
339 } else {
340 sdparam *sdp = isp->isp_param;
341 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
342 switch (i) {
343 default:
344 isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
345 /* FALLTHROUGH */
346 case 1:
347 btype = "1020";
348 isp->isp_type = ISP_HA_SCSI_1020;
349 isp->isp_clock = 40;
350 break;
351 case 2:
352 /*
353 * Some 1020A chips are Ultra Capable, but don't
354 * run the clock rate up for that unless told to
355 * do so by the Ultra Capable bits being set.
356 */
357 btype = "1020A";
358 isp->isp_type = ISP_HA_SCSI_1020A;
359 isp->isp_clock = 40;
360 break;
361 case 3:
362 btype = "1040";
363 isp->isp_type = ISP_HA_SCSI_1040;
364 isp->isp_clock = 60;
365 break;
366 case 4:
367 btype = "1040A";
368 isp->isp_type = ISP_HA_SCSI_1040A;
369 isp->isp_clock = 60;
370 break;
371 case 5:
372 btype = "1040B";
373 isp->isp_type = ISP_HA_SCSI_1040B;
374 isp->isp_clock = 60;
375 break;
376 case 6:
377 btype = "1040C";
378 isp->isp_type = ISP_HA_SCSI_1040C;
379 isp->isp_clock = 60;
380 break;
381 }
382 /*
383 * Now, while we're at it, gather info about ultra
384 * and/or differential mode.
385 */
386 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
387 isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
388 sdp->isp_diffmode = 1;
389 } else {
390 sdp->isp_diffmode = 0;
391 }
392 i = ISP_READ(isp, RISC_PSR);
393 if (isp->isp_bustype == ISP_BT_SBUS) {
394 i &= RISC_PSR_SBUS_ULTRA;
395 } else {
396 i &= RISC_PSR_PCI_ULTRA;
397 }
398 if (i != 0) {
399 isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
400 sdp->isp_ultramode = 1;
401 /*
402 * If we're in Ultra Mode, we have to be 60Mhz clock-
403 * even for the SBus version.
404 */
405 isp->isp_clock = 60;
406 } else {
407 sdp->isp_ultramode = 0;
408 /*
409 * Clock is known. Gronk.
410 */
411 }
412
413 /*
414 * Machine dependent clock (if set) overrides
415 * our generic determinations.
416 */
417 if (isp->isp_mdvec->dv_clock) {
418 if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
419 isp->isp_clock = isp->isp_mdvec->dv_clock;
420 }
421 }
422
423 }
424
425 /*
426 * Clear instrumentation
427 */
428 isp->isp_intcnt = isp->isp_intbogus = 0;
429
430 /*
431 * Do MD specific pre initialization
432 */
433 ISP_RESET0(isp);
434
435again:
436
437 /*
438 * Hit the chip over the head with hammer,
439 * and give the ISP a chance to recover.
440 */
441
442 if (IS_SCSI(isp)) {
443 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
444 /*
445 * A slight delay...
446 */
447 USEC_DELAY(100);
448
449 /*
450 * Clear data && control DMA engines.
451 */
452 ISP_WRITE(isp, CDMA_CONTROL,
453 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
454 ISP_WRITE(isp, DDMA_CONTROL,
455 DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
456
457
458 } else {
459 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
460 /*
461 * A slight delay...
462 */
463 USEC_DELAY(100);
464
465 /*
466 * Clear data && control DMA engines.
467 */
468 ISP_WRITE(isp, CDMA2100_CONTROL,
469 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
470 ISP_WRITE(isp, TDMA2100_CONTROL,
471 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
472 ISP_WRITE(isp, RDMA2100_CONTROL,
473 DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
474 }
475
476 /*
477 * Wait for ISP to be ready to go...
478 */
479 loops = MBOX_DELAY_COUNT;
480 for (;;) {
481 if (IS_SCSI(isp)) {
482 if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
483 break;
484 } else {
485 if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
486 break;
487 }
488 USEC_DELAY(100);
489 if (--loops < 0) {
490 ISP_DUMPREGS(isp, "chip reset timed out");
491 return;
492 }
493 }
494
495 /*
496 * After we've fired this chip up, zero out the conf1 register
497 * for SCSI adapters and other settings for the 2100.
498 */
499
500 if (IS_SCSI(isp)) {
501 ISP_WRITE(isp, BIU_CONF1, 0);
502 } else {
503 ISP_WRITE(isp, BIU2100_CSR, 0);
504 }
505
506 /*
507 * Reset RISC Processor
508 */
509 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
510 USEC_DELAY(100);
511 /* Clear semaphore register (just to be sure) */
512 ISP_WRITE(isp, BIU_SEMA, 0);
513
514 /*
515 * Establish some initial burst rate stuff.
516 * (only for the 1XX0 boards). This really should
517 * be done later after fetching from NVRAM.
518 */
519 if (IS_SCSI(isp)) {
520 u_int16_t tmp = isp->isp_mdvec->dv_conf1;
521 /*
522 * Busted FIFO. Turn off all but burst enables.
523 */
524 if (isp->isp_type == ISP_HA_SCSI_1040A) {
525 tmp &= BIU_BURST_ENABLE;
526 }
527 ISP_SETBITS(isp, BIU_CONF1, tmp);
528 if (tmp & BIU_BURST_ENABLE) {
529 ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
530 ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
531 }
532#ifdef PTI_CARDS
533 if (((sdparam *) isp->isp_param)->isp_ultramode) {
534 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
535 ISP_WRITE(isp, RISC_MTR, 0x1313);
536 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
537 }
538 } else {
539 ISP_WRITE(isp, RISC_MTR, 0x1212);
540 }
541 /*
542 * PTI specific register
543 */
544 ISP_WRITE(isp, RISC_EMB, DUAL_BANK)
545#else
546 ISP_WRITE(isp, RISC_MTR, 0x1212);
547#endif
548 } else {
549 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
550 if (IS_2200(isp) || IS_23XX(isp)) {
551 ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
552 }
553 }
554
555 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
556
557 /*
558 * Do MD specific post initialization
559 */
560 ISP_RESET1(isp);
561
562 /*
563 * Wait for everything to finish firing up.
564 *
565 * Avoid doing this on the 2312 because you can generate a PCI
566 * parity error (chip breakage).
567 */
568 if (IS_23XX(isp)) {
569 USEC_DELAY(5);
570 } else {
571 loops = MBOX_DELAY_COUNT;
572 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
573 USEC_DELAY(100);
574 if (--loops < 0) {
575 isp_prt(isp, ISP_LOGERR,
576 "MBOX_BUSY never cleared on reset");
577 return;
578 }
579 }
580 }
581
582 /*
583 * Up until this point we've done everything by just reading or
584 * setting registers. From this point on we rely on at least *some*
585 * kind of firmware running in the card.
586 */
587
588 /*
589 * Do some sanity checking.
590 */
591 mbs.param[0] = MBOX_NO_OP;
592 isp_mboxcmd(isp, &mbs, MBLOGALL);
593 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
594 return;
595 }
596
597 if (IS_SCSI(isp)) {
598 mbs.param[0] = MBOX_MAILBOX_REG_TEST;
599 mbs.param[1] = 0xdead;
600 mbs.param[2] = 0xbeef;
601 mbs.param[3] = 0xffff;
602 mbs.param[4] = 0x1111;
603 mbs.param[5] = 0xa5a5;
604 isp_mboxcmd(isp, &mbs, MBLOGALL);
605 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
606 return;
607 }
608 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
609 mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
610 mbs.param[5] != 0xa5a5) {
611 isp_prt(isp, ISP_LOGERR,
612 "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
613 mbs.param[1], mbs.param[2], mbs.param[3],
614 mbs.param[4], mbs.param[5]);
615 return;
616 }
617
618 }
619
620 /*
621 * Download new Firmware, unless requested not to do so.
622 * This is made slightly trickier in some cases where the
623 * firmware of the ROM revision is newer than the revision
624 * compiled into the driver. So, where we used to compare
625 * versions of our f/w and the ROM f/w, now we just see
626 * whether we have f/w at all and whether a config flag
627 * has disabled our download.
628 */
629 if ((isp->isp_mdvec->dv_ispfw == NULL) ||
630 (isp->isp_confopts & ISP_CFG_NORELOAD)) {
631 dodnld = 0;
632 }
633
634 if (IS_23XX(isp))
635 code_org = ISP_CODE_ORG_2300;
636 else
637 code_org = ISP_CODE_ORG;
638
639 if (dodnld) {
640 isp->isp_mbxworkp = (void *) &isp->isp_mdvec->dv_ispfw[1];
641 isp->isp_mbxwrk0 = isp->isp_mdvec->dv_ispfw[3] - 1;
642 isp->isp_mbxwrk1 = code_org + 1;
643 mbs.param[0] = MBOX_WRITE_RAM_WORD;
644 mbs.param[1] = code_org;
645 mbs.param[2] = isp->isp_mdvec->dv_ispfw[0];
646 isp_mboxcmd(isp, &mbs, MBLOGNONE);
647 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
648 isp_prt(isp, ISP_LOGERR,
649 "F/W download failed at word %d",
650 isp->isp_mbxwrk1 - code_org);
651 dodnld = 0;
652 goto again;
653 }
654 /*
655 * Verify that it downloaded correctly.
656 */
657 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
658 mbs.param[1] = code_org;
659 isp_mboxcmd(isp, &mbs, MBLOGNONE);
660 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
661 isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
662 return;
663 }
664 isp->isp_loaded_fw = 1;
665 } else {
666 isp->isp_loaded_fw = 0;
667 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
668 }
669
670 /*
671 * Now start it rolling.
672 *
673 * If we didn't actually download f/w,
674 * we still need to (re)start it.
675 */
676
677
678 mbs.param[0] = MBOX_EXEC_FIRMWARE;
679 mbs.param[1] = code_org;
680 isp_mboxcmd(isp, &mbs, MBLOGNONE);
681 /*
682 * Give it a chance to start.
683 */
684 USEC_DELAY(500);
685
686 if (IS_SCSI(isp)) {
687 /*
688 * Set CLOCK RATE, but only if asked to.
689 */
690 if (isp->isp_clock) {
691 mbs.param[0] = MBOX_SET_CLOCK_RATE;
692 mbs.param[1] = isp->isp_clock;
693 isp_mboxcmd(isp, &mbs, MBLOGALL);
694 /* we will try not to care if this fails */
695 }
696 }
697
698 mbs.param[0] = MBOX_ABOUT_FIRMWARE;
699 isp_mboxcmd(isp, &mbs, MBLOGALL);
700 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
701 return;
702 }
703
704 /*
705 * The SBus firmware that we are using apparently does not return
706 * major, minor, micro revisions in the mailbox registers, which
707 * is really, really, annoying.
708 */
709 if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
710 if (dodnld) {
711#ifdef ISP_TARGET_MODE
712 isp->isp_fwrev[0] = 7;
713 isp->isp_fwrev[1] = 55;
714#else
715 isp->isp_fwrev[0] = 1;
716 isp->isp_fwrev[1] = 37;
717#endif
718 isp->isp_fwrev[2] = 0;
719 }
720 } else {
721 isp->isp_fwrev[0] = mbs.param[1];
722 isp->isp_fwrev[1] = mbs.param[2];
723 isp->isp_fwrev[2] = mbs.param[3];
724 }
725 isp_prt(isp, ISP_LOGCONFIG,
726 "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
727 btype, isp->isp_revision, dodnld? "loaded" : "resident",
728 isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
729
730 if (IS_FC(isp)) {
731 /*
732 * We do not believe firmware attributes for 2100 code less
733 * than 1.17.0, unless it's the firmware we specifically
734 * are loading.
735 *
736 * Note that all 22XX and 23XX f/w is greater than 1.X.0.
737 */
738 if (!(ISP_FW_NEWER_THAN(isp, 1, 17, 0))) {
739#ifdef USE_SMALLER_2100_FIRMWARE
740 FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
741#else
742 FCPARAM(isp)->isp_fwattr = 0;
743#endif
744 } else {
745 FCPARAM(isp)->isp_fwattr = mbs.param[6];
746 isp_prt(isp, ISP_LOGDEBUG0,
747 "Firmware Attributes = 0x%x", mbs.param[6]);
748 }
749 if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) {
750 isp_prt(isp, ISP_LOGCONFIG,
751 "Installed in 64-Bit PCI slot");
752 }
753 }
754
755 if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
756 isp->isp_romfw_rev[2]) {
757 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
758 isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
759 isp->isp_romfw_rev[2]);
760 }
761
762 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
763 isp_mboxcmd(isp, &mbs, MBLOGALL);
764 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
765 return;
766 }
767 isp->isp_maxcmds = mbs.param[2];
768 isp_prt(isp, ISP_LOGINFO,
769 "%d max I/O commands supported", mbs.param[2]);
770 isp_fw_state(isp);
771
772 /*
773 * Set up DMA for the request and result mailboxes.
774 */
775 if (ISP_MBOXDMASETUP(isp) != 0) {
776 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
777 return;
778 }
779 isp->isp_state = ISP_RESETSTATE;
780
781 /*
782 * Okay- now that we have new firmware running, we now (re)set our
783 * notion of how many luns we support. This is somewhat tricky because
784 * if we haven't loaded firmware, we sometimes do not have an easy way
785 * of knowing how many luns we support.
786 *
787 * Expanded lun firmware gives you 32 luns for SCSI cards and
788 * 16384 luns for Fibre Channel cards.
789 *
790 * It turns out that even for QLogic 2100s with ROM 1.10 and above
791 * we do get a firmware attributes word returned in mailbox register 6.
792 *
793 * Because the lun is in a a different position in the Request Queue
794 * Entry structure for Fibre Channel with expanded lun firmware, we
795 * can only support one lun (lun zero) when we don't know what kind
796 * of firmware we're running.
797 *
798 * Note that we only do this once (the first time thru isp_reset)
799 * because we may be called again after firmware has been loaded once
800 * and released.
801 */
802 if (IS_SCSI(isp)) {
803 if (dodnld) {
804 if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
805 isp->isp_maxluns = 32;
806 } else {
807 isp->isp_maxluns = 8;
808 }
809 } else {
810 isp->isp_maxluns = 8;
811 }
812 } else {
813 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
814 isp->isp_maxluns = 16384;
815 } else {
816 isp->isp_maxluns = 16;
817 }
818 }
819}
820
821/*
822 * Initialize Parameters of Hardware to a known state.
823 *
824 * Locks are held before coming here.
825 */
826
827void
828isp_init(struct ispsoftc *isp)
829{
830 /*
831 * Must do this first to get defaults established.
832 */
833 isp_setdfltparm(isp, 0);
834 if (IS_DUALBUS(isp)) {
835 isp_setdfltparm(isp, 1);
836 }
837 if (IS_FC(isp)) {
838 isp_fibre_init(isp);
839 } else {
840 isp_scsi_init(isp);
841 }
842}
843
844static void
845isp_scsi_init(struct ispsoftc *isp)
846{
847 sdparam *sdp_chan0, *sdp_chan1;
848 mbreg_t mbs;
849
850 sdp_chan0 = isp->isp_param;
851 sdp_chan1 = sdp_chan0;
852 if (IS_DUALBUS(isp)) {
853 sdp_chan1++;
854 }
855
856 /*
857 * If we have no role (neither target nor initiator), return.
858 */
859 if (isp->isp_role == ISP_ROLE_NONE) {
860 return;
861 }
862
863 /* First do overall per-card settings. */
864
865 /*
866 * If we have fast memory timing enabled, turn it on.
867 */
868 if (sdp_chan0->isp_fast_mttr) {
869 ISP_WRITE(isp, RISC_MTR, 0x1313);
870 }
871
872 /*
873 * Set Retry Delay and Count.
874 * You set both channels at the same time.
875 */
876 mbs.param[0] = MBOX_SET_RETRY_COUNT;
877 mbs.param[1] = sdp_chan0->isp_retry_count;
878 mbs.param[2] = sdp_chan0->isp_retry_delay;
879 mbs.param[6] = sdp_chan1->isp_retry_count;
880 mbs.param[7] = sdp_chan1->isp_retry_delay;
881
882 isp_mboxcmd(isp, &mbs, MBLOGALL);
883 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
884 return;
885 }
886
887 /*
888 * Set ASYNC DATA SETUP time. This is very important.
889 */
890 mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
891 mbs.param[1] = sdp_chan0->isp_async_data_setup;
892 mbs.param[2] = sdp_chan1->isp_async_data_setup;
893 isp_mboxcmd(isp, &mbs, MBLOGALL);
894 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
895 return;
896 }
897
898 /*
899 * Set ACTIVE Negation State.
900 */
901 mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
902 mbs.param[1] =
903 (sdp_chan0->isp_req_ack_active_neg << 4) |
904 (sdp_chan0->isp_data_line_active_neg << 5);
905 mbs.param[2] =
906 (sdp_chan1->isp_req_ack_active_neg << 4) |
907 (sdp_chan1->isp_data_line_active_neg << 5);
908
909 isp_mboxcmd(isp, &mbs, MBLOGNONE);
910 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
911 isp_prt(isp, ISP_LOGERR,
912 "failed to set active negation state (%d,%d), (%d,%d)",
913 sdp_chan0->isp_req_ack_active_neg,
914 sdp_chan0->isp_data_line_active_neg,
915 sdp_chan1->isp_req_ack_active_neg,
916 sdp_chan1->isp_data_line_active_neg);
917 /*
918 * But don't return.
919 */
920 }
921
922 /*
923 * Set the Tag Aging limit
924 */
925 mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
926 mbs.param[1] = sdp_chan0->isp_tag_aging;
927 mbs.param[2] = sdp_chan1->isp_tag_aging;
928 isp_mboxcmd(isp, &mbs, MBLOGALL);
929 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
930 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
931 sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
932 return;
933 }
934
935 /*
936 * Set selection timeout.
937 */
938 mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
939 mbs.param[1] = sdp_chan0->isp_selection_timeout;
940 mbs.param[2] = sdp_chan1->isp_selection_timeout;
941 isp_mboxcmd(isp, &mbs, MBLOGALL);
942 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
943 return;
944 }
945
946 /* now do per-channel settings */
947 isp_scsi_channel_init(isp, 0);
948 if (IS_DUALBUS(isp))
949 isp_scsi_channel_init(isp, 1);
950
951 /*
952 * Now enable request/response queues
953 */
954
955 if (IS_ULTRA2(isp) || IS_1240(isp)) {
956 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
957 mbs.param[1] = RESULT_QUEUE_LEN(isp);
958 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
959 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
960 mbs.param[4] = 0;
961 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
962 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
963 isp_mboxcmd(isp, &mbs, MBLOGALL);
964 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
965 return;
966 }
967 isp->isp_residx = mbs.param[5];
968
969 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
970 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
971 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
972 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
973 mbs.param[5] = 0;
974 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
975 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
976 isp_mboxcmd(isp, &mbs, MBLOGALL);
977 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
978 return;
979 }
980 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
981 } else {
982 mbs.param[0] = MBOX_INIT_RES_QUEUE;
983 mbs.param[1] = RESULT_QUEUE_LEN(isp);
984 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
985 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
986 mbs.param[4] = 0;
987 isp_mboxcmd(isp, &mbs, MBLOGALL);
988 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
989 return;
990 }
991 isp->isp_residx = mbs.param[5];
992
993 mbs.param[0] = MBOX_INIT_REQ_QUEUE;
994 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
995 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
996 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
997 mbs.param[5] = 0;
998 isp_mboxcmd(isp, &mbs, MBLOGALL);
999 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1000 return;
1001 }
1002 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1003 }
1004
1005 /*
1006 * Turn on Fast Posting, LVD transitions
1007 *
1008 * Ultra2 F/W always has had fast posting (and LVD transitions)
1009 *
1010 * Ultra and older (i.e., SBus) cards may not. It's just safer
1011 * to assume not for them.
1012 */
1013
1014 mbs.param[0] = MBOX_SET_FW_FEATURES;
1015 mbs.param[1] = 0;
1016 if (IS_ULTRA2(isp))
1017 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1018#ifndef ISP_NO_RIO
1019 if (IS_ULTRA2(isp) || IS_1240(isp))
1020 mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1021#else
1022#ifndef ISP_NO_FASTPOST
1023 if (IS_ULTRA2(isp) || IS_1240(isp))
1024 mbs.param[1] |= FW_FEATURE_FAST_POST;
1025#endif
1026#endif
1027 if (mbs.param[1] != 0) {
1028 u_int16_t sfeat = mbs.param[1];
1029 isp_mboxcmd(isp, &mbs, MBLOGALL);
1030 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1031 isp_prt(isp, ISP_LOGINFO,
1032 "Enabled FW features (0x%x)", sfeat);
1033 }
1034 }
1035
1036 /*
1037 * Let the outer layers decide whether to issue a SCSI bus reset.
1038 */
1039 isp->isp_state = ISP_INITSTATE;
1040}
1041
1042static void
1043isp_scsi_channel_init(struct ispsoftc *isp, int channel)
1044{
1045 sdparam *sdp;
1046 mbreg_t mbs;
1047 int tgt;
1048
1049 sdp = isp->isp_param;
1050 sdp += channel;
1051
1052 /*
1053 * Set (possibly new) Initiator ID.
1054 */
1055 mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1056 mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1057 isp_mboxcmd(isp, &mbs, MBLOGALL);
1058 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1059 return;
1060 }
1061 isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1062 sdp->isp_initiator_id, channel);
1063
1064
1065 /*
1066 * Set current per-target parameters to an initial safe minimum.
1067 */
1068 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1069 int lun;
1070 u_int16_t sdf;
1071
1072 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1073 continue;
1074 }
1075#ifndef ISP_TARGET_MODE
1076 sdf = sdp->isp_devparam[tgt].goal_flags;
1077 sdf &= DPARM_SAFE_DFLT;
1078 /*
1079 * It is not quite clear when this changed over so that
1080 * we could force narrow and async for 1000/1020 cards,
1081 * but assume that this is only the case for loaded
1082 * firmware.
1083 */
1084 if (isp->isp_loaded_fw) {
1085 sdf |= DPARM_NARROW | DPARM_ASYNC;
1086 }
1087#else
1088 /*
1089 * The !$*!)$!$)* f/w uses the same index into some
1090 * internal table to decide how to respond to negotiations,
1091 * so if we've said "let's be safe" for ID X, and ID X
1092 * selects *us*, the negotiations will back to 'safe'
1093 * (as in narrow/async). What the f/w *should* do is
1094 * use the initiator id settings to decide how to respond.
1095 */
1096 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1097#endif
1098 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1099 mbs.param[1] = (channel << 15) | (tgt << 8);
1100 mbs.param[2] = sdf;
1101 if ((sdf & DPARM_SYNC) == 0) {
1102 mbs.param[3] = 0;
1103 } else {
1104 mbs.param[3] =
1105 (sdp->isp_devparam[tgt].goal_offset << 8) |
1106 (sdp->isp_devparam[tgt].goal_period);
1107 }
1108 isp_prt(isp, ISP_LOGDEBUG0,
1109 "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1110 channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1111 mbs.param[3] & 0xff);
1112 isp_mboxcmd(isp, &mbs, MBLOGNONE);
1113 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1114 sdf = DPARM_SAFE_DFLT;
1115 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1116 mbs.param[1] = (tgt << 8) | (channel << 15);
1117 mbs.param[2] = sdf;
1118 mbs.param[3] = 0;
1119 isp_mboxcmd(isp, &mbs, MBLOGALL);
1120 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1121 continue;
1122 }
1123 }
1124
1125 /*
1126 * We don't update any information directly from the f/w
1127 * because we need to run at least one command to cause a
1128 * new state to be latched up. So, we just assume that we
1129 * converge to the values we just had set.
1130 *
1131 * Ensure that we don't believe tagged queuing is enabled yet.
1132 * It turns out that sometimes the ISP just ignores our
1133 * attempts to set parameters for devices that it hasn't
1134 * seen yet.
1135 */
1136 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1137 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1138 mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1139 mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1140 mbs.param[2] = sdp->isp_max_queue_depth;
1141 mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1142 isp_mboxcmd(isp, &mbs, MBLOGALL);
1143 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1144 break;
1145 }
1146 }
1147 }
1148 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1149 if (sdp->isp_devparam[tgt].dev_refresh) {
1150 isp->isp_sendmarker |= (1 << channel);
1151 isp->isp_update |= (1 << channel);
1152 break;
1153 }
1154 }
1155}
1156
1157/*
1158 * Fibre Channel specific initialization.
1159 *
1160 * Locks are held before coming here.
1161 */
1162static void
1163isp_fibre_init(struct ispsoftc *isp)
1164{
1165 fcparam *fcp;
1166 isp_icb_t local, *icbp = &local;
1167 mbreg_t mbs;
1168 int loopid;
1169 u_int64_t nwwn, pwwn;
1170
1171 fcp = isp->isp_param;
1172
1173 /*
1174 * Do this *before* initializing the firmware.
1175 */
1176 isp_mark_getpdb_all(isp);
1177 fcp->isp_fwstate = FW_CONFIG_WAIT;
1178 fcp->isp_loopstate = LOOP_NIL;
1179
1180 /*
1181 * If we have no role (neither target nor initiator), return.
1182 */
1183 if (isp->isp_role == ISP_ROLE_NONE) {
1184 return;
1185 }
1186
1187 loopid = fcp->isp_loopid;
1188 MEMZERO(icbp, sizeof (*icbp));
1189 icbp->icb_version = ICB_VERSION1;
1190
1191 /*
1192 * Firmware Options are either retrieved from NVRAM or
1193 * are patched elsewhere. We check them for sanity here
1194 * and make changes based on board revision, but otherwise
1195 * let others decide policy.
1196 */
1197
1198 /*
1199 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1200 */
1201 if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
1202 fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
1203 }
1204
1205 /*
1206 * We have to use FULL LOGIN even though it resets the loop too much
1207 * because otherwise port database entries don't get updated after
1208 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1209 */
1210 if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1211 fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
1212 }
1213
1214 /*
1215 * Insist on Port Database Update Async notifications
1216 */
1217 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
1218
1219 /*
1220 * Make sure that target role reflects into fwoptions.
1221 */
1222 if (isp->isp_role & ISP_ROLE_TARGET) {
1223 fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
1224 } else {
1225 fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
1226 }
1227
1228 /*
1229 * Propagate all of this into the ICB structure.
1230 */
1231 icbp->icb_fwoptions = fcp->isp_fwoptions;
1232 icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1233 if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1234 icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1235 isp_prt(isp, ISP_LOGERR,
1236 "bad frame length (%d) from NVRAM- using %d",
1237 fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1238 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1239 }
1240 icbp->icb_maxalloc = fcp->isp_maxalloc;
1241 if (icbp->icb_maxalloc < 1) {
1242 isp_prt(isp, ISP_LOGERR,
1243 "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1244 icbp->icb_maxalloc = 16;
1245 }
1246 icbp->icb_execthrottle = fcp->isp_execthrottle;
1247 if (icbp->icb_execthrottle < 1) {
1248 isp_prt(isp, ISP_LOGERR,
1249 "bad execution throttle of %d- using 16",
1250 fcp->isp_execthrottle);
1251 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1252 }
1253 icbp->icb_retry_delay = fcp->isp_retry_delay;
1254 icbp->icb_retry_count = fcp->isp_retry_count;
1255 icbp->icb_hardaddr = loopid;
1256 /*
1257 * Right now we just set extended options to prefer point-to-point
1258 * over loop based upon some soft config options.
1259 *
1260 * NB: for the 2300, ICBOPT_EXTENDED is required.
1261 */
1262 if (IS_2200(isp) || IS_23XX(isp)) {
1263 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1264 /*
1265 * Prefer or force Point-To-Point instead Loop?
1266 */
1267 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1268 case ISP_CFG_NPORT:
1269 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1270 break;
1271 case ISP_CFG_NPORT_ONLY:
1272 icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1273 break;
1274 case ISP_CFG_LPORT_ONLY:
1275 icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1276 break;
1277 default:
1278 icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1279 break;
1280 }
1281 if (IS_23XX(isp)) {
1282 /*
1283 * QLogic recommends that FAST Posting be turned
1284 * off for 23XX cards and instead allow the HBA
1285 * to write response queue entries and interrupt
1286 * after a delay (ZIO).
1287 *
1288 * If we set ZIO, it will disable fast posting,
1289 * so we don't need to clear it in fwoptions.
1290 */
1291 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1292
1293 if (isp->isp_confopts & ISP_CFG_ONEGB) {
1294 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1295 } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1296 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1297 } else {
1298 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1299 }
1300 }
1301 }
1302
1303#ifndef ISP_NO_RIO_FC
1304 /*
1305 * RIO seems to be enabled in 2100s for fw >= 1.17.0.
1306 *
1307 * I've had some questionable problems with RIO on 2200.
1308 * More specifically, on a 2204 I had problems with RIO
1309 * on a Linux system where I was dropping commands right
1310 * and left. It's not clear to me what the actual problem
1311 * was.
1312 *
1313 * 23XX Cards do not support RIO. Instead they support ZIO.
1314 */
1315#if 0
1316 if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1317 icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
1318 icbp->icb_racctimer = 4;
1319 icbp->icb_idelaytimer = 8;
1320 }
1321#endif
1322#endif
1323
1324 /*
1325 * For 22XX > 2.1.26 && 23XX, set someoptions.
1326 * XXX: Probably okay for newer 2100 f/w too.
1327 */
1328 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1329 /*
1330 * Turn on LIP F8 async event (1)
1331 * Turn on generate AE 8013 on all LIP Resets (2)
1332 * Disable LIP F7 switching (8)
1333 */
1334 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1335 mbs.param[1] = 0xb;
1336 mbs.param[2] = 0;
1337 mbs.param[3] = 0;
1338 isp_mboxcmd(isp, &mbs, MBLOGALL);
1339 }
1340 icbp->icb_logintime = 30; /* 30 second login timeout */
1341
1342 if (IS_23XX(isp)) {
1343 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
1344 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
1345 ISP_WRITE(isp, isp->isp_respinrp, 0);
1346 ISP_WRITE(isp, isp->isp_respoutrp, 0);
1347 }
1348
1349 nwwn = ISP_NODEWWN(isp);
1350 pwwn = ISP_PORTWWN(isp);
1351 if (nwwn && pwwn) {
1352 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1353 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1354 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1355 isp_prt(isp, ISP_LOGDEBUG1,
1356 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1357 ((u_int32_t) (nwwn >> 32)),
1358 ((u_int32_t) (nwwn & 0xffffffff)),
1359 ((u_int32_t) (pwwn >> 32)),
1360 ((u_int32_t) (pwwn & 0xffffffff)));
1361 } else {
1362 isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
1363 icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN);
1364 }
1365 icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1366 icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1367 icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1368 icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1369 icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1370 icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1371 icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1372 icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1373 icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1374 icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1375 isp_prt(isp, ISP_LOGDEBUG0,
1376 "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1377 icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1378
1379 FC_SCRATCH_ACQUIRE(isp);
1380 isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1381
1382 /*
1383 * Init the firmware
1384 */
1385 mbs.param[0] = MBOX_INIT_FIRMWARE;
1386 mbs.param[1] = 0;
1387 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1388 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1389 mbs.param[4] = 0;
1390 mbs.param[5] = 0;
1391 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1392 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1393 isp_mboxcmd(isp, &mbs, MBLOGALL);
1394 FC_SCRATCH_RELEASE(isp);
1395 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1396 return;
1397 }
1398 isp->isp_reqidx = isp->isp_reqodx = 0;
1399 isp->isp_residx = 0;
1400 isp->isp_sendmarker = 1;
1401
1402 /*
1403 * Whatever happens, we're now committed to being here.
1404 */
1405 isp->isp_state = ISP_INITSTATE;
1406}
1407
1408/*
1409 * Fibre Channel Support- get the port database for the id.
1410 *
1411 * Locks are held before coming here. Return 0 if success,
1412 * else failure.
1413 */
1414
1415static int
1416isp_getmap(struct ispsoftc *isp, fcpos_map_t *map)
1417{
1418 fcparam *fcp = (fcparam *) isp->isp_param;
1419 mbreg_t mbs;
1420
1421 mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP;
1422 mbs.param[1] = 0;
1423 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1424 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1425 /*
1426 * Unneeded. For the 2100, except for initializing f/w, registers
1427 * 4/5 have to not be written to.
1428 * mbs.param[4] = 0;
1429 * mbs.param[5] = 0;
1430 *
1431 */
1432 mbs.param[6] = 0;
1433 mbs.param[7] = 0;
1434 FC_SCRATCH_ACQUIRE(isp);
1435 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1436 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1437 MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t));
1438 map->fwmap = mbs.param[1] != 0;
1439 FC_SCRATCH_RELEASE(isp);
1440 return (0);
1441 }
1442 FC_SCRATCH_RELEASE(isp);
1443 return (-1);
1444}
1445
1446static void
1447isp_mark_getpdb_all(struct ispsoftc *isp)
1448{
1449 fcparam *fcp = (fcparam *) isp->isp_param;
1450 int i;
1451 for (i = 0; i < MAX_FC_TARG; i++) {
1452 fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0;
1453 }
1454}
1455
1456static int
1457isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp)
1458{
1459 fcparam *fcp = (fcparam *) isp->isp_param;
1460 mbreg_t mbs;
1461
1462 mbs.param[0] = MBOX_GET_PORT_DB;
1463 mbs.param[1] = id << 8;
1464 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1465 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1466 /*
1467 * Unneeded. For the 2100, except for initializing f/w, registers
1468 * 4/5 have to not be written to.
1469 * mbs.param[4] = 0;
1470 * mbs.param[5] = 0;
1471 *
1472 */
1473 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1474 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1475 FC_SCRATCH_ACQUIRE(isp);
1476 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1477 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1478 isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp);
1479 FC_SCRATCH_RELEASE(isp);
1480 return (0);
1481 }
1482 FC_SCRATCH_RELEASE(isp);
1483 return (-1);
1484}
1485
1486static u_int64_t
1487isp_get_portname(struct ispsoftc *isp, int loopid, int nodename)
1488{
1489 u_int64_t wwn = 0;
1490 mbreg_t mbs;
1491
1492 mbs.param[0] = MBOX_GET_PORT_NAME;
1493 mbs.param[1] = loopid << 8;
1494 if (nodename)
1495 mbs.param[1] |= 1;
1496 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1497 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1498 wwn =
1499 (((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
1500 (((u_int64_t)(mbs.param[2] >> 8)) << 48) |
1501 (((u_int64_t)(mbs.param[3] & 0xff)) << 40) |
1502 (((u_int64_t)(mbs.param[3] >> 8)) << 32) |
1503 (((u_int64_t)(mbs.param[6] & 0xff)) << 24) |
1504 (((u_int64_t)(mbs.param[6] >> 8)) << 16) |
1505 (((u_int64_t)(mbs.param[7] & 0xff)) << 8) |
1506 (((u_int64_t)(mbs.param[7] >> 8)));
1507 }
1508 return (wwn);
1509}
1510
1511/*
1512 * Make sure we have good FC link and know our Loop ID.
1513 */
1514
1515static int
1516isp_fclink_test(struct ispsoftc *isp, int usdelay)
1517{
1518 static char *toponames[] = {
1519 "Private Loop",
1520 "FL Port",
1521 "N-Port to N-Port",
1522 "F Port",
1523 "F Port (no FLOGI_ACC response)"
1524 };
1525 mbreg_t mbs;
1526 int count, check_for_fabric;
1527 u_int8_t lwfs;
1528 fcparam *fcp;
1529 struct lportdb *lp;
1530 isp_pdb_t pdb;
1531
1532 fcp = isp->isp_param;
1533
1534 /*
1535 * XXX: Here is where we would start a 'loop dead' timeout
1536 */
1537
1538 /*
1539 * Wait up to N microseconds for F/W to go to a ready state.
1540 */
1541 lwfs = FW_CONFIG_WAIT;
1542 count = 0;
1543 while (count < usdelay) {
1544 u_int64_t enano;
1545 u_int32_t wrk;
1546 NANOTIME_T hra, hrb;
1547
1548 GET_NANOTIME(&hra);
1549 isp_fw_state(isp);
1550 if (lwfs != fcp->isp_fwstate) {
1551 isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
1552 isp2100_fw_statename((int)lwfs),
1553 isp2100_fw_statename((int)fcp->isp_fwstate));
1554 lwfs = fcp->isp_fwstate;
1555 }
1556 if (fcp->isp_fwstate == FW_READY) {
1557 break;
1558 }
1559 GET_NANOTIME(&hrb);
1560
1561 /*
1562 * Get the elapsed time in nanoseconds.
1563 * Always guaranteed to be non-zero.
1564 */
1565 enano = NANOTIME_SUB(&hrb, &hra);
1566
1567 isp_prt(isp, ISP_LOGDEBUG1,
1568 "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
1569 count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
1570 (u_int32_t)(enano >> 32), (u_int32_t)(enano & 0xffffffff));
1571
1572 /*
1573 * If the elapsed time is less than 1 millisecond,
1574 * delay a period of time up to that millisecond of
1575 * waiting.
1576 *
1577 * This peculiar code is an attempt to try and avoid
1578 * invoking u_int64_t math support functions for some
1579 * platforms where linkage is a problem.
1580 */
1581 if (enano < (1000 * 1000)) {
1582 count += 1000;
1583 enano = (1000 * 1000) - enano;
1584 while (enano > (u_int64_t) 4000000000U) {
1585 USEC_SLEEP(isp, 4000000);
1586 enano -= (u_int64_t) 4000000000U;
1587 }
1588 wrk = enano;
1589 wrk /= 1000;
1590 USEC_SLEEP(isp, wrk);
1591 } else {
1592 while (enano > (u_int64_t) 4000000000U) {
1593 count += 4000000;
1594 enano -= (u_int64_t) 4000000000U;
1595 }
1596 wrk = enano;
1597 count += (wrk / 1000);
1598 }
1599 }
1600
1601 /*
1602 * If we haven't gone to 'ready' state, return.
1603 */
1604 if (fcp->isp_fwstate != FW_READY) {
1605 return (-1);
1606 }
1607
1608 /*
1609 * Get our Loop ID (if possible). We really need to have it.
1610 */
1611 mbs.param[0] = MBOX_GET_LOOP_ID;
1612 isp_mboxcmd(isp, &mbs, MBLOGALL);
1613 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1614 return (-1);
1615 }
1616 fcp->isp_loopid = mbs.param[1];
1617 if (IS_2200(isp) || IS_23XX(isp)) {
1618 int topo = (int) mbs.param[6];
1619 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
1620 topo = TOPO_PTP_STUB;
1621 fcp->isp_topo = topo;
1622 } else {
1623 fcp->isp_topo = TOPO_NL_PORT;
1624 }
1625 fcp->isp_portid = fcp->isp_alpa = mbs.param[2] & 0xff;
1626
1627 /*
1628 * Check to see if we're on a fabric by trying to see if we
1629 * can talk to the fabric name server. This can be a bit
1630 * tricky because if we're a 2100, we should check always
1631 * (in case we're connected to an server doing aliasing).
1632 */
1633 fcp->isp_onfabric = 0;
1634
1635 if (IS_2100(isp)) {
1636 /*
1637 * Don't bother with fabric if we are using really old
1638 * 2100 firmware. It's just not worth it.
1639 */
1640 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
1641 check_for_fabric = 1;
1642 } else {
1643 check_for_fabric = 0;
1644 }
1645 } else if (fcp->isp_topo == TOPO_FL_PORT ||
1646 fcp->isp_topo == TOPO_F_PORT) {
1647 check_for_fabric = 1;
1648 } else
1649 check_for_fabric = 0;
1650
1651 if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
1652 int loopid = FL_PORT_ID;
1653 if (IS_2100(isp)) {
1654 fcp->isp_topo = TOPO_FL_PORT;
1655 }
1656
1657 if (BITS2WORD(pdb.pdb_portid_bits) == 0) {
1658 /*
1659 * Crock.
1660 */
1661 fcp->isp_topo = TOPO_NL_PORT;
1662 goto not_on_fabric;
1663 }
1664 fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16);
1665
1666 /*
1667 * Save the Fabric controller's port database entry.
1668 */
1669 lp = &fcp->portdb[loopid];
1670 lp->node_wwn =
1671 (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1672 (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1673 (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1674 (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1675 (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1676 (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1677 (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1678 (((u_int64_t)pdb.pdb_nodename[7]));
1679 lp->port_wwn =
1680 (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1681 (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1682 (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1683 (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1684 (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1685 (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1686 (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1687 (((u_int64_t)pdb.pdb_portname[7]));
1688 lp->roles =
1689 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1690 lp->portid = BITS2WORD(pdb.pdb_portid_bits);
1691 lp->loopid = pdb.pdb_loopid;
1692 lp->loggedin = lp->valid = 1;
1693 fcp->isp_onfabric = 1;
1694 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1695 isp_register_fc4_type(isp);
1696 } else {
1697not_on_fabric:
1698 fcp->isp_onfabric = 0;
1699 fcp->portdb[FL_PORT_ID].valid = 0;
1700 }
1701
1702 fcp->isp_gbspeed = 1;
1703 if (IS_23XX(isp)) {
1704 mbs.param[0] = MBOX_GET_SET_DATA_RATE;
1705 mbs.param[1] = MBGSD_GET_RATE;
1706 /* mbs.param[2] undefined if we're just getting rate */
1707 isp_mboxcmd(isp, &mbs, MBLOGALL);
1708 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1709 if (mbs.param[1] == MBGSD_TWOGB) {
1710 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
1711 fcp->isp_gbspeed = 2;
1712 }
1713 }
1714 }
1715
1716 isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid, fcp->isp_alpa,
1717 fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
1718
1719 /*
1720 * Announce ourselves, too. This involves synthesizing an entry.
1721 */
1722 if (fcp->isp_iid_set == 0) {
1723 fcp->isp_iid_set = 1;
1724 fcp->isp_iid = fcp->isp_loopid;
1725 lp = &fcp->portdb[fcp->isp_iid];
1726 } else {
1727 lp = &fcp->portdb[fcp->isp_iid];
1728 if (fcp->isp_portid != lp->portid ||
1729 fcp->isp_loopid != lp->loopid ||
1730 fcp->isp_nodewwn != ISP_NODEWWN(isp) ||
1731 fcp->isp_portwwn != ISP_PORTWWN(isp)) {
1732 lp->valid = 0;
1733 count = fcp->isp_iid;
1734 (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1735 }
1736 }
1737 lp->loopid = fcp->isp_loopid;
1738 lp->portid = fcp->isp_portid;
1739 lp->node_wwn = ISP_NODEWWN(isp);
1740 lp->port_wwn = ISP_PORTWWN(isp);
1741 switch (isp->isp_role) {
1742 case ISP_ROLE_NONE:
1743 lp->roles = 0;
1744 break;
1745 case ISP_ROLE_TARGET:
1746 lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
1747 break;
1748 case ISP_ROLE_INITIATOR:
1749 lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
1750 break;
1751 case ISP_ROLE_BOTH:
1752 lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
1753 break;
1754 }
1755 lp->loggedin = lp->valid = 1;
1756 count = fcp->isp_iid;
1757 (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1758 return (0);
1759}
1760
1761static char *
1762isp2100_fw_statename(int state)
1763{
1764 switch(state) {
1765 case FW_CONFIG_WAIT: return "Config Wait";
1766 case FW_WAIT_AL_PA: return "Waiting for AL_PA";
1767 case FW_WAIT_LOGIN: return "Wait Login";
1768 case FW_READY: return "Ready";
1769 case FW_LOSS_OF_SYNC: return "Loss Of Sync";
1770 case FW_ERROR: return "Error";
1771 case FW_REINIT: return "Re-Init";
1772 case FW_NON_PART: return "Nonparticipating";
1773 default: return "?????";
1774 }
1775}
1776
1777/*
1778 * Synchronize our soft copy of the port database with what the f/w thinks
1779 * (with a view toward possibly for a specific target....)
1780 */
1781
1782static int
1783isp_pdb_sync(struct ispsoftc *isp)
1784{
1785 struct lportdb *lp;
1786 fcparam *fcp = isp->isp_param;
1787 isp_pdb_t pdb;
1788 int loopid, base, lim;
1789
1790 /*
1791 * Make sure we're okay for doing this right now.
1792 */
1793 if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
1794 fcp->isp_loopstate != LOOP_FSCAN_DONE &&
1795 fcp->isp_loopstate != LOOP_LSCAN_DONE) {
1796 return (-1);
1797 }
1798
1799 if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT ||
1800 fcp->isp_topo == TOPO_N_PORT) {
1801 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
1802 if (isp_scan_loop(isp) != 0) {
1803 return (-1);
1804 }
1805 }
1806 }
1807 fcp->isp_loopstate = LOOP_SYNCING_PDB;
1808
1809 /*
1810 * If we get this far, we've settled our differences with the f/w
1811 * (for local loop device) and we can say that the loop state is ready.
1812 */
1813
1814 if (fcp->isp_topo == TOPO_NL_PORT) {
1815 fcp->loop_seen_once = 1;
1816 fcp->isp_loopstate = LOOP_READY;
1817 return (0);
1818 }
1819
1820 /*
1821 * Find all Fabric Entities that didn't make it from one scan to the
1822 * next and let the world know they went away. Scan the whole database.
1823 */
1824 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
1825 if (lp->was_fabric_dev && lp->fabric_dev == 0) {
1826 loopid = lp - fcp->portdb;
1827 lp->valid = 0; /* should already be set */
1828 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1829 MEMZERO((void *) lp, sizeof (*lp));
1830 continue;
1831 }
1832 lp->was_fabric_dev = lp->fabric_dev;
1833 }
1834
1835 if (fcp->isp_topo == TOPO_FL_PORT)
1836 base = FC_SNS_ID+1;
1837 else
1838 base = 0;
1839
1840 if (fcp->isp_topo == TOPO_N_PORT)
1841 lim = 1;
1842 else
1843 lim = MAX_FC_TARG;
1844
1845 /*
1846 * Now log in any fabric devices that the outer layer has
1847 * left for us to see. This seems the most sane policy
1848 * for the moment.
1849 */
1850 for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
1851 u_int32_t portid;
1852 mbreg_t mbs;
1853
1854 loopid = lp - fcp->portdb;
1855 if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) {
1856 continue;
1857 }
1858
1859 /*
1860 * Anything here?
1861 */
1862 if (lp->port_wwn == 0) {
1863 continue;
1864 }
1865
1866 /*
1867 * Don't try to log into yourself.
1868 */
1869 if ((portid = lp->portid) == fcp->isp_portid) {
1870 continue;
1871 }
1872
1873
1874 /*
1875 * If we'd been logged in- see if we still are and we haven't
1876 * changed. If so, no need to log ourselves out, etc..
1877 *
1878 * Unfortunately, our charming Qlogic f/w has decided to
1879 * return a valid port database entry for a fabric device
1880 * that has, in fact, gone away. And it hangs trying to
1881 * log it out.
1882 */
1883 if (lp->loggedin && lp->force_logout == 0 &&
1884 isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1885 int nrole;
1886 u_int64_t nwwnn, nwwpn;
1887 nwwnn =
1888 (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1889 (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1890 (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1891 (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1892 (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1893 (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1894 (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1895 (((u_int64_t)pdb.pdb_nodename[7]));
1896 nwwpn =
1897 (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1898 (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1899 (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1900 (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1901 (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1902 (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1903 (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1904 (((u_int64_t)pdb.pdb_portname[7]));
1905 nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
1906 SVC3_ROLE_SHIFT;
1907 if (pdb.pdb_loopid == lp->loopid && lp->portid ==
1908 (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) &&
1909 nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
1910 lp->roles == nrole && lp->force_logout == 0) {
1911 lp->loggedin = lp->valid = 1;
1912 isp_prt(isp, ISP_LOGCONFIG, lretained,
1913 (int) (lp - fcp->portdb),
1914 (int) lp->loopid, lp->portid);
1915 continue;
1916 }
1917 }
1918
1919 if (fcp->isp_fwstate != FW_READY ||
1920 fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1921 return (-1);
1922 }
1923
1924 /*
1925 * Force a logout if we were logged in.
1926 */
1927 if (lp->loggedin) {
1928 if (lp->force_logout ||
1929 isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1930 mbs.param[0] = MBOX_FABRIC_LOGOUT;
1931 mbs.param[1] = lp->loopid << 8;
1932 mbs.param[2] = 0;
1933 mbs.param[3] = 0;
1934 isp_mboxcmd(isp, &mbs, MBLOGNONE);
1935 isp_prt(isp, ISP_LOGINFO, plogout,
1936 (int) (lp - fcp->portdb), lp->loopid,
1937 lp->portid);
1938 }
1939 lp->force_logout = lp->loggedin = 0;
1940 if (fcp->isp_fwstate != FW_READY ||
1941 fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1942 return (-1);
1943 }
1944 }
1945
1946 /*
1947 * And log in....
1948 */
1949 loopid = lp - fcp->portdb;
1950 lp->loopid = FL_PORT_ID;
1951 do {
1952 mbs.param[0] = MBOX_FABRIC_LOGIN;
1953 mbs.param[1] = loopid << 8;
1954 mbs.param[2] = portid >> 16;
1955 mbs.param[3] = portid & 0xffff;
1956 isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
1957 MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
1958 if (fcp->isp_fwstate != FW_READY ||
1959 fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1960 return (-1);
1961 }
1962 switch (mbs.param[0]) {
1963 case MBOX_LOOP_ID_USED:
1964 /*
1965 * Try the next available loop id.
1966 */
1967 loopid++;
1968 break;
1969 case MBOX_PORT_ID_USED:
1970 /*
1971 * This port is already logged in.
1972 * Snaffle the loop id it's using if it's
1973 * nonzero, otherwise we're hosed.
1974 */
1975 if (mbs.param[1] != 0) {
1976 loopid = mbs.param[1];
1977 isp_prt(isp, ISP_LOGINFO, retained,
1978 loopid, (int) (lp - fcp->portdb),
1979 lp->portid);
1980 } else {
1981 loopid = MAX_FC_TARG;
1982 break;
1983 }
1984 /* FALLTHROUGH */
1985 case MBOX_COMMAND_COMPLETE:
1986 lp->loggedin = 1;
1987 lp->loopid = loopid;
1988 break;
1989 case MBOX_COMMAND_ERROR:
1990 isp_prt(isp, ISP_LOGINFO, plogierr,
1991 portid, mbs.param[1]);
1992 /* FALLTHROUGH */
1993 case MBOX_ALL_IDS_USED: /* We're outta IDs */
1994 default:
1995 loopid = MAX_FC_TARG;
1996 break;
1997 }
1998 } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
1999
2000 /*
2001 * If we get here and we haven't set a Loop ID,
2002 * we failed to log into this device.
2003 */
2004
2005 if (lp->loopid == FL_PORT_ID) {
2006 lp->loopid = 0;
2007 continue;
2008 }
2009
2010 /*
2011 * Make sure we can get the approriate port information.
2012 */
2013 if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
2014 isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
2015 goto dump_em;
2016 }
2017
2018 if (fcp->isp_fwstate != FW_READY ||
2019 fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2020 return (-1);
2021 }
2022
2023 if (pdb.pdb_loopid != lp->loopid) {
2024 isp_prt(isp, ISP_LOGWARN, pdbmfail1,
2025 lp->portid, pdb.pdb_loopid);
2026 goto dump_em;
2027 }
2028
2029 if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
2030 isp_prt(isp, ISP_LOGWARN, pdbmfail2,
2031 lp->portid, BITS2WORD(pdb.pdb_portid_bits));
2032 goto dump_em;
2033 }
2034
2035 lp->roles =
2036 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2037 lp->node_wwn =
2038 (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
2039 (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
2040 (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
2041 (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
2042 (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
2043 (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
2044 (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
2045 (((u_int64_t)pdb.pdb_nodename[7]));
2046 lp->port_wwn =
2047 (((u_int64_t)pdb.pdb_portname[0]) << 56) |
2048 (((u_int64_t)pdb.pdb_portname[1]) << 48) |
2049 (((u_int64_t)pdb.pdb_portname[2]) << 40) |
2050 (((u_int64_t)pdb.pdb_portname[3]) << 32) |
2051 (((u_int64_t)pdb.pdb_portname[4]) << 24) |
2052 (((u_int64_t)pdb.pdb_portname[5]) << 16) |
2053 (((u_int64_t)pdb.pdb_portname[6]) << 8) |
2054 (((u_int64_t)pdb.pdb_portname[7]));
2055 /*
2056 * Check to make sure this all makes sense.
2057 */
2058 if (lp->node_wwn && lp->port_wwn) {
2059 lp->valid = 1;
2060 loopid = lp - fcp->portdb;
2061 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2062 continue;
2063 }
2064dump_em:
2065 lp->valid = 0;
2066 isp_prt(isp, ISP_LOGINFO,
2067 ldumped, loopid, lp->loopid, lp->portid);
2068 mbs.param[0] = MBOX_FABRIC_LOGOUT;
2069 mbs.param[1] = lp->loopid << 8;
2070 mbs.param[2] = 0;
2071 mbs.param[3] = 0;
2072 isp_mboxcmd(isp, &mbs, MBLOGNONE);
2073 if (fcp->isp_fwstate != FW_READY ||
2074 fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2075 return (-1);
2076 }
2077 }
2078 /*
2079 * If we get here, we've for sure seen not only a valid loop
2080 * but know what is or isn't on it, so mark this for usage
2081 * in isp_start.
2082 */
2083 fcp->loop_seen_once = 1;
2084 fcp->isp_loopstate = LOOP_READY;
2085 return (0);
2086}
2087
2088static int
2089isp_scan_loop(struct ispsoftc *isp)
2090{
2091 struct lportdb *lp;
2092 fcparam *fcp = isp->isp_param;
2093 isp_pdb_t pdb;
2094 int loopid, lim, hival;
2095
2096 switch (fcp->isp_topo) {
2097 case TOPO_NL_PORT:
2098 hival = FL_PORT_ID;
2099 break;
2100 case TOPO_N_PORT:
2101 hival = 2;
2102 break;
2103 case TOPO_FL_PORT:
2104 hival = FC_PORT_ID;
2105 break;
2106 default:
2107 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2108 return (0);
2109 }
2110 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2111
2112 /*
2113 * make sure the temp port database is clean...
2114 */
2115 MEMZERO((void *)fcp->tport, sizeof (fcp->tport));
2116
2117 /*
2118 * Run through the local loop ports and get port database info
2119 * for each loop ID.
2120 *
2121 * There's a somewhat unexplained situation where the f/w passes back
2122 * the wrong database entity- if that happens, just restart (up to
2123 * FL_PORT_ID times).
2124 */
2125 for (lim = loopid = 0; loopid < hival; loopid++) {
2126 lp = &fcp->tport[loopid];
2127
2128 /*
2129 * Don't even try for ourselves...
2130 */
2131 if (loopid == fcp->isp_loopid)
2132 continue;
2133
2134 lp->node_wwn = isp_get_portname(isp, loopid, 1);
2135 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2136 return (-1);
2137 if (lp->node_wwn == 0)
2138 continue;
2139 lp->port_wwn = isp_get_portname(isp, loopid, 0);
2140 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2141 return (-1);
2142 if (lp->port_wwn == 0) {
2143 lp->node_wwn = 0;
2144 continue;
2145 }
2146
2147 /*
2148 * Get an entry....
2149 */
2150 if (isp_getpdb(isp, loopid, &pdb) != 0) {
2151 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2152 return (-1);
2153 continue;
2154 }
2155 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2156 return (-1);
2157 }
2158
2159 /*
2160 * If the returned database element doesn't match what we
2161 * asked for, restart the process entirely (up to a point...).
2162 */
2163 if (pdb.pdb_loopid != loopid) {
2164 loopid = 0;
2165 if (lim++ < hival) {
2166 continue;
2167 }
2168 isp_prt(isp, ISP_LOGWARN,
2169 "giving up on synchronizing the port database");
2170 return (-1);
2171 }
2172
2173 /*
2174 * Save the pertinent info locally.
2175 */
2176 lp->node_wwn =
2177 (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
2178 (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
2179 (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
2180 (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
2181 (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
2182 (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
2183 (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
2184 (((u_int64_t)pdb.pdb_nodename[7]));
2185 lp->port_wwn =
2186 (((u_int64_t)pdb.pdb_portname[0]) << 56) |
2187 (((u_int64_t)pdb.pdb_portname[1]) << 48) |
2188 (((u_int64_t)pdb.pdb_portname[2]) << 40) |
2189 (((u_int64_t)pdb.pdb_portname[3]) << 32) |
2190 (((u_int64_t)pdb.pdb_portname[4]) << 24) |
2191 (((u_int64_t)pdb.pdb_portname[5]) << 16) |
2192 (((u_int64_t)pdb.pdb_portname[6]) << 8) |
2193 (((u_int64_t)pdb.pdb_portname[7]));
2194 lp->roles =
2195 (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2196 lp->portid = BITS2WORD(pdb.pdb_portid_bits);
2197 lp->loopid = pdb.pdb_loopid;
2198 }
2199
2200 /*
2201 * Mark all of the permanent local loop database entries as invalid
2202 * (except our own entry).
2203 */
2204 for (loopid = 0; loopid < hival; loopid++) {
2205 if (loopid == fcp->isp_iid) {
2206 fcp->portdb[loopid].valid = 1;
2207 fcp->portdb[loopid].loopid = fcp->isp_loopid;
2208 continue;
2209 }
2210 fcp->portdb[loopid].valid = 0;
2211 }
2212
2213 /*
2214 * Now merge our local copy of the port database into our saved copy.
2215 * Notify the outer layers of new devices arriving.
2216 */
2217 for (loopid = 0; loopid < hival; loopid++) {
2218 int i;
2219
2220 /*
2221 * If we don't have a non-zero Port WWN, we're not here.
2222 */
2223 if (fcp->tport[loopid].port_wwn == 0) {
2224 continue;
2225 }
2226
2227 /*
2228 * Skip ourselves.
2229 */
2230 if (loopid == fcp->isp_iid) {
2231 continue;
2232 }
2233
2234 /*
2235 * For the purposes of deciding whether this is the
2236 * 'same' device or not, we only search for an identical
2237 * Port WWN. Node WWNs may or may not be the same as
2238 * the Port WWN, and there may be multiple different
2239 * Port WWNs with the same Node WWN. It would be chaos
2240 * to have multiple identical Port WWNs, so we don't
2241 * allow that.
2242 */
2243
2244 for (i = 0; i < hival; i++) {
2245 int j;
2246 if (fcp->portdb[i].port_wwn == 0)
2247 continue;
2248 if (fcp->portdb[i].port_wwn !=
2249 fcp->tport[loopid].port_wwn)
2250 continue;
2251 /*
2252 * We found this WWN elsewhere- it's changed
2253 * loopids then. We don't change it's actual
2254 * position in our cached port database- we
2255 * just change the actual loop ID we'd use.
2256 */
2257 if (fcp->portdb[i].loopid != loopid) {
2258 isp_prt(isp, ISP_LOGINFO, portshift, i,
2259 fcp->portdb[i].loopid,
2260 fcp->portdb[i].portid, loopid,
2261 fcp->tport[loopid].portid);
2262 }
2263 fcp->portdb[i].portid = fcp->tport[loopid].portid;
2264 fcp->portdb[i].loopid = loopid;
2265 fcp->portdb[i].valid = 1;
2266 fcp->portdb[i].roles = fcp->tport[loopid].roles;
2267
2268 /*
2269 * Now make sure this Port WWN doesn't exist elsewhere
2270 * in the port database.
2271 */
2272 for (j = i+1; j < hival; j++) {
2273 if (fcp->portdb[i].port_wwn !=
2274 fcp->portdb[j].port_wwn) {
2275 continue;
2276 }
2277 isp_prt(isp, ISP_LOGWARN, portdup, j, i);
2278 /*
2279 * Invalidate the 'old' *and* 'new' ones.
2280 * This is really harsh and not quite right,
2281 * but if this happens, we really don't know
2282 * who is what at this point.
2283 */
2284 fcp->portdb[i].valid = 0;
2285 fcp->portdb[j].valid = 0;
2286 }
2287 break;
2288 }
2289
2290 /*
2291 * If we didn't traverse the entire port database,
2292 * then we found (and remapped) an existing entry.
2293 * No need to notify anyone- go for the next one.
2294 */
2295 if (i < hival) {
2296 isp_prt(isp, ISP_LOGINFO, retained,
2297 fcp->portdb[i].loopid, i, fcp->portdb[i].portid);
2298 continue;
2299 }
2300
2301 /*
2302 * We've not found this Port WWN anywhere. It's a new entry.
2303 * See if we can leave it where it is (with target == loopid).
2304 */
2305 if (fcp->portdb[loopid].port_wwn != 0) {
2306 for (lim = 0; lim < hival; lim++) {
2307 if (fcp->portdb[lim].port_wwn == 0)
2308 break;
2309 }
2310 /* "Cannot Happen" */
2311 if (lim == hival) {
2312 isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
2313 continue;
2314 }
2315 i = lim;
2316 } else {
2317 i = loopid;
2318 }
2319
2320 /*
2321 * NB: The actual loopid we use here is loopid- we may
2322 * in fact be at a completely different index (target).
2323 */
2324 fcp->portdb[i].loopid = loopid;
2325 fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn;
2326 fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn;
2327 fcp->portdb[i].roles = fcp->tport[loopid].roles;
2328 fcp->portdb[i].portid = fcp->tport[loopid].portid;
2329 fcp->portdb[i].valid = 1;
2330
2331 /*
2332 * Tell the outside world we've arrived.
2333 */
2334 (void) isp_async(isp, ISPASYNC_PROMENADE, &i);
2335 }
2336
2337 /*
2338 * Now find all previously used targets that are now invalid and
2339 * notify the outer layers that they're gone.
2340 */
2341 for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
2342 if (lp->valid || lp->port_wwn == 0) {
2343 continue;
2344 }
2345
2346 /*
2347 * Tell the outside world we've gone
2348 * away and erase our pdb entry.
2349 *
2350 */
2351 loopid = lp - fcp->portdb;
2352 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2353 MEMZERO((void *) lp, sizeof (*lp));
2354 }
2355 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2356 return (0);
2357}
2358
2359
2360static int
2361isp_fabric_mbox_cmd(struct ispsoftc *isp, mbreg_t *mbp)
2362{
2363 isp_mboxcmd(isp, mbp, MBLOGNONE);
2364 if (mbp->param[0] != MBOX_COMMAND_COMPLETE) {
2365 if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) {
2366 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
2367 }
2368 if (mbp->param[0] == MBOX_COMMAND_ERROR) {
2369 char tbuf[16];
2370 char *m;
2371 switch (mbp->param[1]) {
2372 case 1:
2373 m = "No Loop";
2374 break;
2375 case 2:
2376 m = "Failed to allocate IOCB buffer";
2377 break;
2378 case 3:
2379 m = "Failed to allocate XCB buffer";
2380 break;
2381 case 4:
2382 m = "timeout or transmit failed";
2383 break;
2384 case 5:
2385 m = "no fabric loop";
2386 break;
2387 case 6:
2388 m = "remote device not a target";
2389 break;
2390 default:
2391 SNPRINTF(tbuf, sizeof tbuf, "%x",
2392 mbp->param[1]);
2393 m = tbuf;
2394 break;
2395 }
2396 isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m);
2397 }
2398 return (-1);
2399 }
2400
2401 if (FCPARAM(isp)->isp_fwstate != FW_READY ||
2402 FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) {
2403 return (-1);
2404 }
2405 return(0);
2406}
2407
2408#ifdef ISP_USE_GA_NXT
2409static int
2410isp_scan_fabric(struct ispsoftc *isp, int ftype)
2411{
2412 fcparam *fcp = isp->isp_param;
2413 u_int32_t portid, first_portid, last_portid;
2414 int hicap, last_port_same;
2415
2416 if (fcp->isp_onfabric == 0) {
2417 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2418 return (0);
2419 }
2420
2421 FC_SCRATCH_ACQUIRE(isp);
2422
2423 /*
2424 * Since Port IDs are 24 bits, we can check against having seen
2425 * anything yet with this value.
2426 */
2427 last_port_same = 0;
2428 last_portid = 0xffffffff; /* not a port */
2429 first_portid = portid = fcp->isp_portid;
2430 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2431
2432 for (hicap = 0; hicap < GA_NXT_MAX; hicap++) {
2433 mbreg_t mbs;
2434 sns_screq_t *rq;
2435 sns_ga_nxt_rsp_t *rs0, *rs1;
2436 struct lportdb lcl;
2437 u_int8_t sc[SNS_GA_NXT_RESP_SIZE];
2438
2439 rq = (sns_screq_t *)sc;
2440 MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE);
2441 rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1;
2442 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100);
2443 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100);
2444 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100);
2445 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100);
2446 rq->snscb_sblen = 6;
2447 rq->snscb_data[0] = SNS_GA_NXT;
2448 rq->snscb_data[4] = portid & 0xffff;
2449 rq->snscb_data[5] = (portid >> 16) & 0xff;
2450 isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch);
2451 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE);
2452 mbs.param[0] = MBOX_SEND_SNS;
2453 mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1;
2454 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2455 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2456 /*
2457 * Leave 4 and 5 alone
2458 */
2459 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2460 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2461 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2462 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2463 fcp->isp_loopstate = LOOP_PDB_RCVD;
2464 }
2465 FC_SCRATCH_RELEASE(isp);
2466 return (-1);
2467 }
2468 MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE);
2469 rs1 = (sns_ga_nxt_rsp_t *) sc;
2470 rs0 = (sns_ga_nxt_rsp_t *) ((u_int8_t *)fcp->isp_scratch+0x100);
2471 isp_get_ga_nxt_response(isp, rs0, rs1);
2472 if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2473 int level;
2474 if (rs1->snscb_cthdr.ct_reason == 9 &&
2475 rs1->snscb_cthdr.ct_explanation == 7)
2476 level = ISP_LOGDEBUG0;
2477 else
2478 level = ISP_LOGWARN;
2479 isp_prt(isp, level, swrej, "GA_NXT",
2480 rs1->snscb_cthdr.ct_reason,
2481 rs1->snscb_cthdr.ct_explanation, portid);
2482 FC_SCRATCH_RELEASE(isp);
2483 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2484 return (0);
2485 }
2486 portid =
2487 (((u_int32_t) rs1->snscb_port_id[0]) << 16) |
2488 (((u_int32_t) rs1->snscb_port_id[1]) << 8) |
2489 (((u_int32_t) rs1->snscb_port_id[2]));
2490
2491 /*
2492 * XXX: We should check to make sure that this entry
2493 * XXX: supports the type(s) we are interested in.
2494 */
2495 /*
2496 * Okay, we now have information about a fabric object.
2497 * If it is the type we're interested in, tell the outer layers
2498 * about it. The outer layer needs to know: Port ID, WWNN,
2499 * WWPN, FC4 type, and port type.
2500 *
2501 * The lportdb structure is adequate for this.
2502 */
2503 MEMZERO(&lcl, sizeof (lcl));
2504 lcl.port_type = rs1->snscb_port_type;
2505 lcl.fc4_type = ftype;
2506 lcl.portid = portid;
2507 lcl.node_wwn =
2508 (((u_int64_t)rs1->snscb_nodename[0]) << 56) |
2509 (((u_int64_t)rs1->snscb_nodename[1]) << 48) |
2510 (((u_int64_t)rs1->snscb_nodename[2]) << 40) |
2511 (((u_int64_t)rs1->snscb_nodename[3]) << 32) |
2512 (((u_int64_t)rs1->snscb_nodename[4]) << 24) |
2513 (((u_int64_t)rs1->snscb_nodename[5]) << 16) |
2514 (((u_int64_t)rs1->snscb_nodename[6]) << 8) |
2515 (((u_int64_t)rs1->snscb_nodename[7]));
2516 lcl.port_wwn =
2517 (((u_int64_t)rs1->snscb_portname[0]) << 56) |
2518 (((u_int64_t)rs1->snscb_portname[1]) << 48) |
2519 (((u_int64_t)rs1->snscb_portname[2]) << 40) |
2520 (((u_int64_t)rs1->snscb_portname[3]) << 32) |
2521 (((u_int64_t)rs1->snscb_portname[4]) << 24) |
2522 (((u_int64_t)rs1->snscb_portname[5]) << 16) |
2523 (((u_int64_t)rs1->snscb_portname[6]) << 8) |
2524 (((u_int64_t)rs1->snscb_portname[7]));
2525
2526 /*
2527 * Does this fabric object support the type we want?
2528 * If not, skip it.
2529 */
2530 if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) {
2531 if (first_portid == portid) {
2532 lcl.last_fabric_dev = 1;
2533 } else {
2534 lcl.last_fabric_dev = 0;
2535 }
2536 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2537 } else {
2538 isp_prt(isp, ISP_LOGDEBUG0,
2539 "PortID 0x%x doesn't support FC4 type 0x%x",
2540 portid, ftype);
2541 }
2542 if (first_portid == portid) {
2543 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2544 FC_SCRATCH_RELEASE(isp);
2545 return (0);
2546 }
2547 if (portid == last_portid) {
2548 if (last_port_same++ > 20) {
2549 isp_prt(isp, ISP_LOGWARN,
2550 "tangled fabric database detected");
2551 break;
2552 }
2553 } else {
2554 last_port_same = 0 ;
2555 last_portid = portid;
2556 }
2557 }
2558 FC_SCRATCH_RELEASE(isp);
2559 if (hicap >= GA_NXT_MAX) {
2560 isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX);
2561 }
2562 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2563 return (0);
2564}
2565#else
2566#define GIDLEN ((ISP2100_SCRLEN >> 1) + 16)
2567#define NGENT ((GIDLEN - 16) >> 2)
2568
2569#define IGPOFF (ISP2100_SCRLEN - GIDLEN)
2570#define GXOFF (256)
2571
2572static int
2573isp_scan_fabric(struct ispsoftc *isp, int ftype)
2574{
2575 fcparam *fcp = FCPARAM(isp);
2576 mbreg_t mbs;
2577 int i;
2578 sns_gid_ft_req_t *rq;
2579 sns_gid_ft_rsp_t *rs0, *rs1;
2580
2581 if (fcp->isp_onfabric == 0) {
2582 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2583 return (0);
2584 }
2585
2586 FC_SCRATCH_ACQUIRE(isp);
2587 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2588
2589 rq = (sns_gid_ft_req_t *)fcp->tport;
2590 MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE);
2591 rq->snscb_rblen = GIDLEN >> 1;
2592 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF);
2593 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF);
2594 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF);
2595 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF);
2596 rq->snscb_sblen = 6;
2597 rq->snscb_cmd = SNS_GID_FT;
2598 rq->snscb_mword_div_2 = NGENT;
2599 rq->snscb_fc4_type = ftype;
2600 isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch);
2601 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
2602 mbs.param[0] = MBOX_SEND_SNS;
2603 mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
2604 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2605 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2606
2607 /*
2608 * Leave 4 and 5 alone
2609 */
2610 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2611 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2612 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2613 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2614 fcp->isp_loopstate = LOOP_PDB_RCVD;
2615 }
2616 FC_SCRATCH_RELEASE(isp);
2617 return (-1);
2618 }
2619 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2620 FC_SCRATCH_RELEASE(isp);
2621 return (-1);
2622 }
2623 MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
2624 rs1 = (sns_gid_ft_rsp_t *) fcp->tport;
2625 rs0 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+IGPOFF);
2626 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
2627 if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2628 int level;
2629 if (rs1->snscb_cthdr.ct_reason == 9 &&
2630 rs1->snscb_cthdr.ct_explanation == 7)
2631 level = ISP_LOGDEBUG0;
2632 else
2633 level = ISP_LOGWARN;
2634 isp_prt(isp, level, swrej, "GID_FT",
2635 rs1->snscb_cthdr.ct_reason,
2636 rs1->snscb_cthdr.ct_explanation, 0);
2637 FC_SCRATCH_RELEASE(isp);
2638 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2639 return (0);
2640 }
2641
2642 /*
2643 * Okay, we now have a list of Port IDs for this class of device.
2644 * Go through the list and for each one get the WWPN/WWNN for it
2645 * and tell the outer layers about it. The outer layer needs to
2646 * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type.
2647 *
2648 * The lportdb structure is adequate for this.
2649 */
2650 i = -1;
2651 do {
2652 sns_gxn_id_req_t grqbuf, *gq = &grqbuf;
2653 sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf;
2654 struct lportdb lcl;
2655#if 0
2656 sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf;
2657#endif
2658
2659 i++;
2660 MEMZERO(&lcl, sizeof (lcl));
2661 lcl.fc4_type = ftype;
2662 lcl.portid =
2663 (((u_int32_t) rs1->snscb_ports[i].portid[0]) << 16) |
2664 (((u_int32_t) rs1->snscb_ports[i].portid[1]) << 8) |
2665 (((u_int32_t) rs1->snscb_ports[i].portid[2]));
2666
2667 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2668 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2669 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2670 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2671 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2672 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2673 gq->snscb_sblen = 6;
2674 gq->snscb_cmd = SNS_GPN_ID;
2675 gq->snscb_portid = lcl.portid;
2676 isp_put_gxn_id_request(isp, gq,
2677 (sns_gxn_id_req_t *) fcp->isp_scratch);
2678 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2679 mbs.param[0] = MBOX_SEND_SNS;
2680 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2681 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2682 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2683 /*
2684 * Leave 4 and 5 alone
2685 */
2686 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2687 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2688 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2689 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2690 fcp->isp_loopstate = LOOP_PDB_RCVD;
2691 }
2692 FC_SCRATCH_RELEASE(isp);
2693 return (-1);
2694 }
2695 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2696 FC_SCRATCH_RELEASE(isp);
2697 return (-1);
2698 }
2699 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2700 gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2701 isp_get_gxn_id_response(isp, gs0, gs1);
2702 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2703 isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID",
2704 gs1->snscb_cthdr.ct_reason,
2705 gs1->snscb_cthdr.ct_explanation, lcl.portid);
2706 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2707 FC_SCRATCH_RELEASE(isp);
2708 return (-1);
2709 }
2710 continue;
2711 }
2712 lcl.port_wwn =
2713 (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
2714 (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
2715 (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
2716 (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
2717 (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
2718 (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
2719 (((u_int64_t)gs1->snscb_wwn[6]) << 8) |
2720 (((u_int64_t)gs1->snscb_wwn[7]));
2721
2722 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2723 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2724 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2725 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2726 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2727 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2728 gq->snscb_sblen = 6;
2729 gq->snscb_cmd = SNS_GNN_ID;
2730 gq->snscb_portid = lcl.portid;
2731 isp_put_gxn_id_request(isp, gq,
2732 (sns_gxn_id_req_t *) fcp->isp_scratch);
2733 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2734 mbs.param[0] = MBOX_SEND_SNS;
2735 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2736 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2737 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2738 /*
2739 * Leave 4 and 5 alone
2740 */
2741 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2742 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2743 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2744 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2745 fcp->isp_loopstate = LOOP_PDB_RCVD;
2746 }
2747 FC_SCRATCH_RELEASE(isp);
2748 return (-1);
2749 }
2750 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2751 FC_SCRATCH_RELEASE(isp);
2752 return (-1);
2753 }
2754 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2755 gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2756 isp_get_gxn_id_response(isp, gs0, gs1);
2757 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2758 isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID",
2759 gs1->snscb_cthdr.ct_reason,
2760 gs1->snscb_cthdr.ct_explanation, lcl.portid);
2761 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2762 FC_SCRATCH_RELEASE(isp);
2763 return (-1);
2764 }
2765 continue;
2766 }
2767 lcl.node_wwn =
2768 (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
2769 (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
2770 (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
2771 (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
2772 (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
2773 (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
2774 (((u_int64_t)gs1->snscb_wwn[6]) << 8) |
2775 (((u_int64_t)gs1->snscb_wwn[7]));
2776
2777 /*
2778 * The QLogic f/w is bouncing this with a parameter error.
2779 */
2780#if 0
2781 /*
2782 * Try and get FC4 Features (FC-GS-3 only).
2783 * We can use the sns_gxn_id_req_t for this request.
2784 */
2785 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2786 gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1;
2787 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2788 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2789 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2790 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2791 gq->snscb_sblen = 6;
2792 gq->snscb_cmd = SNS_GFF_ID;
2793 gq->snscb_portid = lcl.portid;
2794 isp_put_gxn_id_request(isp, gq,
2795 (sns_gxn_id_req_t *) fcp->isp_scratch);
2796 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2797 mbs.param[0] = MBOX_SEND_SNS;
2798 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2799 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2800 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2801 /*
2802 * Leave 4 and 5 alone
2803 */
2804 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2805 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2806 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2807 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2808 fcp->isp_loopstate = LOOP_PDB_RCVD;
2809 }
2810 FC_SCRATCH_RELEASE(isp);
2811 return (-1);
2812 }
2813 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2814 FC_SCRATCH_RELEASE(isp);
2815 return (-1);
2816 }
2817 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE);
2818 fs0 = (sns_gff_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2819 isp_get_gff_id_response(isp, fs0, fs1);
2820 if (fs1->snscb_cthdr.ct_response != FS_ACC) {
2821 isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN,
2822 swrej, "GFF_ID",
2823 fs1->snscb_cthdr.ct_reason,
2824 fs1->snscb_cthdr.ct_explanation, lcl.portid);
2825 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2826 FC_SCRATCH_RELEASE(isp);
2827 return (-1);
2828 }
2829 } else {
2830 int index = (ftype >> 3);
2831 int bshft = (ftype & 0x7) * 4;
2832 int fc4_fval =
2833 (fs1->snscb_fc4_features[index] >> bshft) & 0xf;
2834 if (fc4_fval & 0x1) {
2835 lcl.roles |=
2836 (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT);
2837 }
2838 if (fc4_fval & 0x2) {
2839 lcl.roles |=
2840 (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT);
2841 }
2842 }
2843#endif
2844
2845 /*
2846 * If we really want to know what kind of port type this is,
2847 * we have to run another CT command. Otherwise, we'll leave
2848 * it as undefined.
2849 *
2850 lcl.port_type = 0;
2851 */
2852 if (rs1->snscb_ports[i].control & 0x80) {
2853 lcl.last_fabric_dev = 1;
2854 } else {
2855 lcl.last_fabric_dev = 0;
2856 }
2857 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2858
2859 } while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1);
2860
2861 /*
2862 * If we're not at the last entry, our list isn't big enough.
2863 */
2864 if ((rs1->snscb_ports[i].control & 0x80) == 0) {
2865 isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area");
2866 }
2867
2868 FC_SCRATCH_RELEASE(isp);
2869 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2870 return (0);
2871}
2872#endif
2873
2874static void
2875isp_register_fc4_type(struct ispsoftc *isp)
2876{
2877 fcparam *fcp = isp->isp_param;
2878 u_int8_t local[SNS_RFT_ID_REQ_SIZE];
2879 sns_screq_t *reqp = (sns_screq_t *) local;
2880 mbreg_t mbs;
2881
2882 MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
2883 reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
2884 reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
2885 reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
2886 reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
2887 reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
2888 reqp->snscb_sblen = 22;
2889 reqp->snscb_data[0] = SNS_RFT_ID;
2890 reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
2891 reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
2892 reqp->snscb_data[6] = (1 << FC4_SCSI);
2893#if 0
2894 reqp->snscb_data[6] |= (1 << FC4_IP); /* ISO/IEC 8802-2 LLC/SNAP */
2895#endif
2896 FC_SCRATCH_ACQUIRE(isp);
2897 isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
2898 mbs.param[0] = MBOX_SEND_SNS;
2899 mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
2900 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2901 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2902 /*
2903 * Leave 4 and 5 alone
2904 */
2905 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2906 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2907 isp_mboxcmd(isp, &mbs, MBLOGALL);
2908 FC_SCRATCH_RELEASE(isp);
2909 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2910 isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded");
2911 }
2912}
2913
2914/*
2915 * Start a command. Locking is assumed done in the caller.
2916 */
2917
2918int
2919isp_start(XS_T *xs)
2920{
2921 struct ispsoftc *isp;
2922 u_int16_t nxti, optr, handle;
2923 u_int8_t local[QENTRY_LEN];
2924 ispreq_t *reqp, *qep;
2925 int target, i;
2926
2927 XS_INITERR(xs);
2928 isp = XS_ISP(xs);
2929
2930 /*
2931 * Check to make sure we're supporting initiator role.
2932 */
2933 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
2934 XS_SETERR(xs, HBA_SELTIMEOUT);
2935 return (CMD_COMPLETE);
2936 }
2937
2938 /*
2939 * Now make sure we're running.
2940 */
2941
2942 if (isp->isp_state != ISP_RUNSTATE) {
2943 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
2944 XS_SETERR(xs, HBA_BOTCH);
2945 return (CMD_COMPLETE);
2946 }
2947
2948 /*
2949 * Check command CDB length, etc.. We really are limited to 16 bytes
2950 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
2951 * but probably only if we're running fairly new firmware (we'll
2952 * let the old f/w choke on an extended command queue entry).
2953 */
2954
2955 if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
2956 isp_prt(isp, ISP_LOGERR,
2957 "unsupported cdb length (%d, CDB[0]=0x%x)",
2958 XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
2959 XS_SETERR(xs, HBA_BOTCH);
2960 return (CMD_COMPLETE);
2961 }
2962
2963 /*
2964 * Check to see whether we have good firmware state still or
2965 * need to refresh our port database for this target.
2966 */
2967 target = XS_TGT(xs);
2968 if (IS_FC(isp)) {
2969 fcparam *fcp = isp->isp_param;
2970 struct lportdb *lp;
2971#ifdef HANDLE_LOOPSTATE_IN_OUTER_LAYERS
2972 if (fcp->isp_fwstate != FW_READY ||
2973 fcp->isp_loopstate != LOOP_READY) {
2974 return (CMD_RQLATER);
2975 }
2976
2977 /*
2978 * If we're not on a Fabric, we can't have a target
2979 * above FL_PORT_ID-1.
2980 *
2981 * If we're on a fabric and *not* connected as an F-port,
2982 * we can't have a target less than FC_SNS_ID+1. This
2983 * keeps us from having to sort out the difference between
2984 * local public loop devices and those which we might get
2985 * from a switch's database.
2986 */
2987 if (fcp->isp_onfabric == 0) {
2988 if (target >= FL_PORT_ID) {
2989 XS_SETERR(xs, HBA_SELTIMEOUT);
2990 return (CMD_COMPLETE);
2991 }
2992 } else {
2993 if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
2994 XS_SETERR(xs, HBA_SELTIMEOUT);
2995 return (CMD_COMPLETE);
2996 }
2997 /*
2998 * We used to exclude having local loop ports
2999 * at the same time that we have fabric ports.
3000 * That is, we used to exclude having ports
3001 * at < FL_PORT_ID if we're FL-port.
3002 *
3003 * That's wrong. The only thing that could be
3004 * dicey is if the switch you're connected to
3005 * has these local loop ports appear on the
3006 * fabric and we somehow attach them twice.
3007 */
3008 }
3009#else
3010 /*
3011 * Check for f/w being in ready state. If the f/w
3012 * isn't in ready state, then we don't know our
3013 * loop ID and the f/w hasn't completed logging
3014 * into all targets on the loop. If this is the
3015 * case, then bounce the command. We pretend this is
3016 * a SELECTION TIMEOUT error if we've never gone to
3017 * FW_READY state at all- in this case we may not
3018 * be hooked to a loop at all and we shouldn't hang
3019 * the machine for this. Otherwise, defer this command
3020 * until later.
3021 */
3022 if (fcp->isp_fwstate != FW_READY) {
3023 /*
3024 * Give ourselves at most a 250ms delay.
3025 */
3026 if (isp_fclink_test(isp, 250000)) {
3027 XS_SETERR(xs, HBA_SELTIMEOUT);
3028 if (fcp->loop_seen_once) {
3029 return (CMD_RQLATER);
3030 } else {
3031 return (CMD_COMPLETE);
3032 }
3033 }
3034 }
3035
3036 /*
3037 * If we're not on a Fabric, we can't have a target
3038 * above FL_PORT_ID-1.
3039 *
3040 * If we're on a fabric and *not* connected as an F-port,
3041 * we can't have a target less than FC_SNS_ID+1. This
3042 * keeps us from having to sort out the difference between
3043 * local public loop devices and those which we might get
3044 * from a switch's database.
3045 */
3046 if (fcp->isp_onfabric == 0) {
3047 if (target >= FL_PORT_ID) {
3048 XS_SETERR(xs, HBA_SELTIMEOUT);
3049 return (CMD_COMPLETE);
3050 }
3051 } else {
3052 if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
3053 XS_SETERR(xs, HBA_SELTIMEOUT);
3054 return (CMD_COMPLETE);
3055 }
3056 if (fcp->isp_topo != TOPO_F_PORT &&
3057 target < FL_PORT_ID) {
3058 XS_SETERR(xs, HBA_SELTIMEOUT);
3059 return (CMD_COMPLETE);
3060 }
3061 }
3062
3063 /*
3064 * If our loop state is such that we haven't yet received
3065 * a "Port Database Changed" notification (after a LIP or
3066 * a Loop Reset or firmware initialization), then defer
3067 * sending commands for a little while, but only if we've
3068 * seen a valid loop at one point (otherwise we can get
3069 * stuck at initialization time).
3070 */
3071 if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
3072 XS_SETERR(xs, HBA_SELTIMEOUT);
3073 if (fcp->loop_seen_once) {
3074 return (CMD_RQLATER);
3075 } else {
3076 return (CMD_COMPLETE);
3077 }
3078 }
3079
3080 /*
3081 * If we're in the middle of loop or fabric scanning
3082 * or merging the port databases, retry this command later.
3083 */
3084 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC ||
3085 fcp->isp_loopstate == LOOP_SCANNING_LOOP ||
3086 fcp->isp_loopstate == LOOP_SYNCING_PDB) {
3087 return (CMD_RQLATER);
3088 }
3089
3090 /*
3091 * If our loop state is now such that we've just now
3092 * received a Port Database Change notification, then
3093 * we have to go off and (re)scan the fabric. We back
3094 * out and try again later if this doesn't work.
3095 */
3096 if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) {
3097 if (isp_scan_fabric(isp, FC4_SCSI)) {
3098 return (CMD_RQLATER);
3099 }
3100 if (fcp->isp_fwstate != FW_READY ||
3101 fcp->isp_loopstate < LOOP_FSCAN_DONE) {
3102 return (CMD_RQLATER);
3103 }
3104 }
3105
3106 /*
3107 * If our loop state is now such that we've just now
3108 * received a Port Database Change notification, then
3109 * we have to go off and (re)synchronize our port
3110 * database.
3111 */
3112 if (fcp->isp_loopstate < LOOP_READY) {
3113 if (isp_pdb_sync(isp)) {
3114 return (CMD_RQLATER);
3115 }
3116 if (fcp->isp_fwstate != FW_READY ||
3117 fcp->isp_loopstate != LOOP_READY) {
3118 return (CMD_RQLATER);
3119 }
3120 }
3121
3122 /*
3123 * XXX: Here's were we would cancel any loop_dead flag
3124 * XXX: also cancel in dead_loop timeout that's running
3125 */
3126#endif
3127
3128 /*
3129 * Now check whether we should even think about pursuing this.
3130 */
3131 lp = &fcp->portdb[target];
3132 if (lp->valid == 0) {
3133 XS_SETERR(xs, HBA_SELTIMEOUT);
3134 return (CMD_COMPLETE);
3135 }
3136 if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
3137 isp_prt(isp, ISP_LOGDEBUG2,
3138 "Target %d does not have target service", target);
3139 XS_SETERR(xs, HBA_SELTIMEOUT);
3140 return (CMD_COMPLETE);
3141 }
3142 /*
3143 * Now turn target into what the actual Loop ID is.
3144 */
3145 target = lp->loopid;
3146 }
3147
3148 /*
3149 * Next check to see if any HBA or Device
3150 * parameters need to be updated.
3151 */
3152 if (isp->isp_update != 0) {
3153 isp_update(isp);
3154 }
3155
da44240f 3156 if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
984263bc
MD
3157 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
3158 XS_SETERR(xs, HBA_BOTCH);
3159 return (CMD_EAGAIN);
3160 }
3161
3162 /*
3163 * Now see if we need to synchronize the ISP with respect to anything.
3164 * We do dual duty here (cough) for synchronizing for busses other
3165 * than which we got here to send a command to.
3166 */
3167 reqp = (ispreq_t *) local;
3168 if (isp->isp_sendmarker) {
3169 u_int8_t n = (IS_DUALBUS(isp)? 2: 1);
3170 /*
3171 * Check ports to send markers for...
3172 */
3173 for (i = 0; i < n; i++) {
3174 if ((isp->isp_sendmarker & (1 << i)) == 0) {
3175 continue;
3176 }
3177 MEMZERO((void *) reqp, QENTRY_LEN);
3178 reqp->req_header.rqs_entry_count = 1;
3179 reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
3180 reqp->req_modifier = SYNC_ALL;
3181 reqp->req_target = i << 7; /* insert bus number */
3182 isp_put_request(isp, reqp, qep);
3183 ISP_ADD_REQUEST(isp, nxti);
3184 isp->isp_sendmarker &= ~(1 << i);
da44240f 3185 if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) {
984263bc
MD
3186 isp_prt(isp, ISP_LOGDEBUG0,
3187 "Request Queue Overflow+");
3188 XS_SETERR(xs, HBA_BOTCH);
3189 return (CMD_EAGAIN);
3190 }
3191 }
3192 }
3193
3194 MEMZERO((void *)reqp, QENTRY_LEN);
3195 reqp->req_header.rqs_entry_count = 1;
3196 if (IS_FC(isp)) {
3197 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
3198 } else {
3199 if (XS_CDBLEN(xs) > 12)
3200 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
3201 else
3202 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
3203 }
3204 /* reqp->req_header.rqs_flags = 0; */
3205 /* reqp->req_header.rqs_seqno = 0; */
3206 if (IS_FC(isp)) {
3207 /*
3208 * See comment in isp_intr
3209 */
3210 /* XS_RESID(xs) = 0; */
3211
3212 /*
3213 * Fibre Channel always requires some kind of tag.
3214 * The Qlogic drivers seem be happy not to use a tag,
3215 * but this breaks for some devices (IBM drives).
3216 */
3217 if (XS_TAG_P(xs)) {
3218 ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
3219 } else {
3220 /*
3221 * If we don't know what tag to use, use HEAD OF QUEUE
3222 * for Request Sense or Simple.
3223 */
3224 if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
3225 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
3226 else
3227 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
3228 }
3229 } else {
3230 sdparam *sdp = (sdparam *)isp->isp_param;
3231 sdp += XS_CHANNEL(xs);
3232 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
3233 XS_TAG_P(xs)) {
3234 reqp->req_flags = XS_TAG_TYPE(xs);
3235 }
3236 }
3237 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
3238 if (IS_SCSI(isp)) {
3239 reqp->req_lun_trn = XS_LUN(xs);
3240 reqp->req_cdblen = XS_CDBLEN(xs);
3241 } else {
3242 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)
3243 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
3244 else
3245 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
3246 }
3247 MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
3248
3249 reqp->req_time = XS_TIME(xs) / 1000;
3250 if (reqp->req_time == 0 && XS_TIME(xs)) {
3251 reqp->req_time = 1;
3252 }
3253
3254 if (isp_save_xs(isp, xs, &handle)) {
3255 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
3256 XS_SETERR(xs, HBA_BOTCH);
3257 return (CMD_EAGAIN);
3258 }
3259 reqp->req_handle = handle;
3260
3261 /*
3262 * Set up DMA and/or do any bus swizzling of the request entry
3263 * so that the Qlogic F/W understands what is being asked of it.
3264 */
3265 i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
3266 if (i != CMD_QUEUED) {
3267 isp_destroy_handle(isp, handle);
3268 /*
3269 * dmasetup sets actual error in packet, and
3270 * return what we were given to return.
3271 */
3272 return (i);
3273 }
3274 XS_SETERR(xs, HBA_NOERROR);
3275 isp_prt(isp, ISP_LOGDEBUG2,
3276 "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
3277 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
3278 (long) XS_XFRLEN(xs));
3279 ISP_ADD_REQUEST(isp, nxti);
3280 isp->isp_nactive++;
3281 return (CMD_QUEUED);
3282}
3283
3284/*
3285 * isp control
3286 * Locks (ints blocked) assumed held.
3287 */
3288
3289int
3290isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
3291{
3292 XS_T *xs;
3293 mbreg_t mbs;
3294 int bus, tgt;
3295 u_int16_t handle;
3296
3297 switch (ctl) {
3298 default:
3299 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
3300 break;
3301
3302 case ISPCTL_RESET_BUS:
3303 /*
3304 * Issue a bus reset.
3305 */
3306 mbs.param[0] = MBOX_BUS_RESET;
3307 mbs.param[2] = 0;
3308 if (IS_SCSI(isp)) {
3309 mbs.param[1] =
3310 ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
3311 if (mbs.param[1] < 2)
3312 mbs.param[1] = 2;
3313 bus = *((int *) arg);
3314 if (IS_DUALBUS(isp))
3315 mbs.param[2] = bus;
3316 } else {
3317 mbs.param[1] = 10;
3318 bus = 0;
3319 }
3320 isp->isp_sendmarker |= (1 << bus);
3321 isp_mboxcmd(isp, &mbs, MBLOGALL);
3322 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3323 break;
3324 }
3325 isp_prt(isp, ISP_LOGINFO,
3326 "driver initiated bus reset of bus %d", bus);
3327 return (0);
3328
3329 case ISPCTL_RESET_DEV:
3330 tgt = (*((int *) arg)) & 0xffff;
3331 bus = (*((int *) arg)) >> 16;
3332 mbs.param[0] = MBOX_ABORT_TARGET;
3333 mbs.param[1] = (tgt << 8) | (bus << 15);
3334 mbs.param[2] = 3; /* 'delay', in seconds */
3335 isp_mboxcmd(isp, &mbs, MBLOGALL);
3336 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3337 break;
3338 }
3339 isp_prt(isp, ISP_LOGINFO,
3340 "Target %d on Bus %d Reset Succeeded", tgt, bus);
3341 isp->isp_sendmarker |= (1 << bus);
3342 return (0);
3343
3344 case ISPCTL_ABORT_CMD:
3345 xs = (XS_T *) arg;
3346 tgt = XS_TGT(xs);
3347 handle = isp_find_handle(isp, xs);
3348 if (handle == 0) {
3349 isp_prt(isp, ISP_LOGWARN,
3350 "cannot find handle for command to abort");
3351 break;
3352 }
3353 bus = XS_CHANNEL(xs);
3354 mbs.param[0] = MBOX_ABORT;
3355 if (IS_FC(isp)) {
3356 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
3357 mbs.param[1] = tgt << 8;
3358 mbs.param[4] = 0;
3359 mbs.param[5] = 0;
3360 mbs.param[6] = XS_LUN(xs);
3361 } else {
3362 mbs.param[1] = tgt << 8 | XS_LUN(xs);
3363 }
3364 } else {
3365 mbs.param[1] =
3366 (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
3367 }
3368 mbs.param[3] = 0;
3369 mbs.param[2] = handle;
3370 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
3371 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3372 return (0);
3373 }
3374 /*
3375 * XXX: Look for command in the REQUEST QUEUE. That is,
3376 * XXX: It hasen't been picked up by firmware yet.
3377 */
3378 break;
3379
3380 case ISPCTL_UPDATE_PARAMS:
3381
3382 isp_update(isp);
3383 return (0);
3384
3385 case ISPCTL_FCLINK_TEST:
3386
3387 if (IS_FC(isp)) {
3388 int usdelay = (arg)? *((int *) arg) : 250000;
3389 return (isp_fclink_test(isp, usdelay));
3390 }
3391 break;
3392
3393 case ISPCTL_SCAN_FABRIC:
3394
3395 if (IS_FC(isp)) {
3396 int ftype = (arg)? *((int *) arg) : FC4_SCSI;
3397 return (isp_scan_fabric(isp, ftype));
3398 }
3399 break;
3400
3401 case ISPCTL_SCAN_LOOP:
3402
3403 if (IS_FC(isp)) {
3404 return (isp_scan_loop(isp));
3405 }
3406 break;
3407
3408 case ISPCTL_PDB_SYNC:
3409
3410 if (IS_FC(isp)) {
3411 return (isp_pdb_sync(isp));
3412 }
3413 break;
3414
3415 case ISPCTL_SEND_LIP:
3416
3417 if (IS_FC(isp)) {
3418 mbs.param[0] = MBOX_INIT_LIP;
3419 isp_mboxcmd(isp, &mbs, MBLOGALL);
3420 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3421 return (0);
3422 }
3423 }
3424 break;
3425
3426 case ISPCTL_GET_POSMAP:
3427
3428 if (IS_FC(isp) && arg) {
3429 return (isp_getmap(isp, arg));
3430 }
3431 break;
3432
3433 case ISPCTL_RUN_MBOXCMD:
3434
3435 isp_mboxcmd(isp, arg, MBLOGALL);
3436 return(0);
3437
3438#ifdef ISP_TARGET_MODE
3439 case ISPCTL_TOGGLE_TMODE:
3440 {
3441
3442 /*
3443 * We don't check/set against role here- that's the
3444 * responsibility for the outer layer to coordinate.
3445 */
3446 if (IS_SCSI(isp)) {
3447 int param = *(int *)arg;
3448 mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
3449 mbs.param[1] = param & 0xffff;
3450 mbs.param[2] = param >> 16;
3451 isp_mboxcmd(isp, &mbs, MBLOGALL);
3452 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3453 break;
3454 }
3455 }
3456 return (0);
3457 }
3458#endif
3459 }
3460 return (-1);
3461}
3462
3463/*
3464 * Interrupt Service Routine(s).
3465 *
3466 * External (OS) framework has done the appropriate locking,
3467 * and the locking will be held throughout this function.
3468 */
3469
3470/*
3471 * Limit our stack depth by sticking with the max likely number
3472 * of completions on a request queue at any one time.
3473 */
3474#ifndef MAX_REQUESTQ_COMPLETIONS
3475#define MAX_REQUESTQ_COMPLETIONS 64
3476#endif
3477
3478void
3479isp_intr(struct ispsoftc *isp, u_int16_t isr, u_int16_t sema, u_int16_t mbox)
3480{
3481 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
3482 u_int16_t iptr, optr, junk;
3483 int i, nlooked = 0, ndone = 0;
3484
3485again:
3486 /*
3487 * Is this a mailbox related interrupt?
3488 * The mailbox semaphore will be nonzero if so.
3489 */
3490 if (sema) {
3491 if (mbox & 0x4000) {
3492 isp->isp_intmboxc++;
3493 if (isp->isp_mboxbsy) {
3494 int i = 0, obits = isp->isp_obits;
3495 isp->isp_mboxtmp[i++] = mbox;
3496 for (i = 1; i < MAX_MAILBOX; i++) {
3497 if ((obits & (1 << i)) == 0) {
3498 continue;
3499 }
3500 isp->isp_mboxtmp[i] =
3501 ISP_READ(isp, MBOX_OFF(i));
3502 }
3503 if (isp->isp_mbxwrk0) {
3504 if (isp_mbox_continue(isp) == 0) {
3505 return;
3506 }
3507 }
3508 MBOX_NOTIFY_COMPLETE(isp);
3509 } else {
3510 isp_prt(isp, ISP_LOGWARN,
3511 "Mbox Command Async (0x%x) with no waiters",
3512 mbox);
3513 }
3514 } else if (isp_parse_async(isp, mbox) < 0) {
3515 return;
3516 }
3517 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
3518 isp->isp_state != ISP_RUNSTATE) {
3519 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3520 ISP_WRITE(isp, BIU_SEMA, 0);
3521 return;
3522 }
3523 }
3524
3525 /*
3526 * We can't be getting this now.
3527 */
3528 if (isp->isp_state != ISP_RUNSTATE) {
3529 isp_prt(isp, ISP_LOGWARN,
3530 "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
3531 /*
3532 * Thank you very much! *Burrrp*!
3533 */
3534 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp,
3535 READ_RESPONSE_QUEUE_IN_POINTER(isp));
3536
3537 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3538 ISP_WRITE(isp, BIU_SEMA, 0);
3539 return;
3540 }
3541
3542 /*
3543 * Get the current Response Queue Out Pointer.
3544 *
3545 * If we're a 2300, we can ask what hardware what it thinks.
3546 */
3547 if (IS_23XX(isp)) {
3548 optr = ISP_READ(isp, isp->isp_respoutrp);
3549 /*
3550 * Debug: to be taken out eventually
3551 */
3552 if (isp->isp_residx != optr) {
3553 isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x",
3554 optr, isp->isp_residx);
3555 }
3556 } else {
3557 optr = isp->isp_residx;
3558 }
3559
3560 /*
3561 * You *must* read the Response Queue In Pointer
3562 * prior to clearing the RISC interrupt.
3563 *
3564 * Debounce the 2300 if revision less than 2.
3565 */
3566 if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
3567 i = 0;
3568 do {
3569 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3570 junk = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3571 } while (junk != iptr && ++i < 1000);
3572
3573 if (iptr != junk) {
3574 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3575 isp_prt(isp, ISP_LOGWARN,
3576 "Response Queue Out Pointer Unstable (%x, %x)",
3577 iptr, junk);
3578 return;
3579 }
3580 } else {
3581 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3582 }
3583 isp->isp_resodx = iptr;
3584
3585
3586 if (optr == iptr && sema == 0) {
3587 /*
3588 * There are a lot of these- reasons unknown- mostly on
3589 * faster Alpha machines.
3590 *
3591 * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
3592 * make sure the old interrupt went away (to avoid 'ringing'
3593 * effects), but that didn't stop this from occurring.
3594 */
3595 if (IS_23XX(isp)) {
3596 USEC_DELAY(100);
3597 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3598 junk = ISP_READ(isp, BIU_R2HSTSLO);
3599 } else {
3600 junk = ISP_READ(isp, BIU_ISR);
3601 }
3602 if (optr == iptr) {
3603 if (IS_23XX(isp)) {
3604 ;
3605 } else {
3606 sema = ISP_READ(isp, BIU_SEMA);
3607 mbox = ISP_READ(isp, OUTMAILBOX0);
3608 if ((sema & 0x3) && (mbox & 0x8000)) {
3609 goto again;
3610 }
3611 }
3612 isp->isp_intbogus++;
3613 isp_prt(isp, ISP_LOGDEBUG1,
3614 "bogus intr- isr %x (%x) iptr %x optr %x",
3615 isr, junk, iptr, optr);
3616 }
3617 }
3618 isp->isp_resodx = iptr;
3619 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3620 ISP_WRITE(isp, BIU_SEMA, 0);
3621
3622 if (isp->isp_rspbsy) {
3623 return;
3624 }
3625 isp->isp_rspbsy = 1;
3626
3627 while (optr != iptr) {
3628 ispstatusreq_t local, *sp = &local;
3629 isphdr_t *hp;
3630 int type;
3631 u_int16_t oop;
3632 int buddaboom = 0;
3633
3634 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
3635 oop = optr;
3636 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
3637 nlooked++;
3638 /*
3639 * Synchronize our view of this response queue entry.
3640 */
3641 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
3642
3643 type = isp_get_response_type(isp, hp);
3644
3645 if (type == RQSTYPE_RESPONSE) {
3646 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3647 } else if (type == RQSTYPE_RIO2) {
3648 isp_rio2_t rio;
3649 isp_get_rio2(isp, (isp_rio2_t *) hp, &rio);
3650 for (i = 0; i < rio.req_header.rqs_seqno; i++) {
3651 isp_fastpost_complete(isp, rio.req_handles[i]);
3652 }
3653 if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno)
3654 isp->isp_fpcchiwater = rio.req_header.rqs_seqno;
3655 MEMZERO(hp, QENTRY_LEN); /* PERF */
3656 continue;
3657 } else {
3658 /*
3659 * Somebody reachable via isp_handle_other_response
3660 * may have updated the response queue pointers for
3661 * us, so we reload our goal index.
3662 */
3663 if (isp_handle_other_response(isp, type, hp, &optr)) {
3664 iptr = isp->isp_resodx;
3665 MEMZERO(hp, QENTRY_LEN); /* PERF */
3666 continue;
3667 }
3668
3669 /*
3670 * After this point, we'll just look at the header as
3671 * we don't know how to deal with the rest of the
3672 * response.
3673 */
3674 isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3675
3676 /*
3677 * It really has to be a bounced request just copied
3678 * from the request queue to the response queue. If
3679 * not, something bad has happened.
3680 */
3681 if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
3682 isp_prt(isp, ISP_LOGERR, notresp,
3683 sp->req_header.rqs_entry_type, oop, optr,
3684 nlooked);
3685 if (isp->isp_dblev & ISP_LOGDEBUG0) {
3686 isp_print_bytes(isp, "Queue Entry",
3687 QENTRY_LEN, sp);
3688 }
3689 MEMZERO(hp, QENTRY_LEN); /* PERF */
3690 continue;
3691 }
3692 buddaboom = 1;
3693 }
3694
3695 if (sp->req_header.rqs_flags & 0xf) {
3696#define _RQS_OFLAGS \
3697 ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
3698 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
3699 isp_prt(isp, ISP_LOGWARN,
3700 "continuation segment");
3701 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3702 continue;
3703 }
3704 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3705 isp_prt(isp, ISP_LOGDEBUG1,
3706 "internal queues full");
3707 /*
3708 * We'll synthesize a QUEUE FULL message below.
3709 */
3710 }
3711 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
3712 isp_prt(isp, ISP_LOGERR, "bad header flag");
3713 buddaboom++;
3714 }
3715 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
3716 isp_prt(isp, ISP_LOGERR, "bad request packet");
3717 buddaboom++;
3718 }
3719 if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
3720 isp_prt(isp, ISP_LOGERR,
3721 "unknown flags (0x%x) in response",
3722 sp->req_header.rqs_flags);
3723 buddaboom++;
3724 }
3725#undef _RQS_OFLAGS
3726 }
3727 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
3728 MEMZERO(hp, QENTRY_LEN); /* PERF */
3729 isp_prt(isp, ISP_LOGERR,
3730 "bad request handle %d (type 0x%x, flags 0x%x)",
3731 sp->req_handle, sp->req_header.rqs_entry_type,
3732 sp->req_header.rqs_flags);
3733 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3734 continue;
3735 }
3736 xs = isp_find_xs(isp, sp->req_handle);
3737 if (xs == NULL) {
3738 u_int8_t ts = sp->req_completion_status & 0xff;
3739 MEMZERO(hp, QENTRY_LEN); /* PERF */
3740 /*
3741 * Only whine if this isn't the expected fallout of
3742 * aborting the command.
3743 */
3744 if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
3745 isp_prt(isp, ISP_LOGERR,
3746 "cannot find handle 0x%x (type 0x%x)",
3747 sp->req_handle,
3748 sp->req_header.rqs_entry_type);
3749 } else if (ts != RQCS_ABORTED) {
3750 isp_prt(isp, ISP_LOGERR,
3751 "cannot find handle 0x%x (status 0x%x)",
3752 sp->req_handle, ts);
3753 }
3754 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3755 continue;
3756 }
3757 isp_destroy_handle(isp, sp->req_handle);
3758 if (sp->req_status_flags & RQSTF_BUS_RESET) {
3759 XS_SETERR(xs, HBA_BUSRESET);
3760 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
3761 }
3762 if (buddaboom) {
3763 XS_SETERR(xs, HBA_BOTCH);
3764 }
3765
3766 if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
3767 /*
3768 * Fibre Channel F/W doesn't say we got status
3769 * if there's Sense Data instead. I guess they
3770 * think it goes w/o saying.
3771 */
3772 sp->req_state_flags |= RQSF_GOT_STATUS;
3773 }
3774 if (sp->req_state_flags & RQSF_GOT_STATUS) {
3775 *XS_STSP(xs) = sp->req_scsi_status & 0xff;
3776 }
3777
3778 switch (sp->req_header.rqs_entry_type) {
3779 case RQSTYPE_RESPONSE:
3780 XS_SET_STATE_STAT(isp, xs, sp);
3781 isp_parse_status(isp, sp, xs);
3782 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
3783 (*XS_STSP(xs) == SCSI_BUSY)) {
3784 XS_SETERR(xs, HBA_TGTBSY);
3785 }
3786 if (IS_SCSI(isp)) {
3787 XS_RESID(xs) = sp->req_resid;
3788 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3789 (*XS_STSP(xs) == SCSI_CHECK) &&
3790 (sp->req_state_flags & RQSF_GOT_SENSE)) {
3791 XS_SAVE_SENSE(xs, sp);
3792 }
3793 /*
3794 * A new synchronous rate was negotiated for
3795 * this target. Mark state such that we'll go
3796 * look up that which has changed later.
3797 */
3798 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
3799 int t = XS_TGT(xs);
3800 sdparam *sdp = isp->isp_param;
3801 sdp += XS_CHANNEL(xs);
3802 sdp->isp_devparam[t].dev_refresh = 1;
3803 isp->isp_update |=
3804 (1 << XS_CHANNEL(xs));
3805 }
3806 } else {
3807 if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
3808 XS_RESID(xs) = 0;
3809 } else if (sp->req_scsi_status & RQCS_RESID) {
3810 XS_RESID(xs) = sp->req_resid;
3811 } else {
3812 XS_RESID(xs) = 0;
3813 }
3814 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3815 (*XS_STSP(xs) == SCSI_CHECK) &&
3816 (sp->req_scsi_status & RQCS_SV)) {
3817 XS_SAVE_SENSE(xs, sp);
3818 /* solely for the benefit of debug */
3819 sp->req_state_flags |= RQSF_GOT_SENSE;
3820 }
3821 }
3822 isp_prt(isp, ISP_LOGDEBUG2,
3823 "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
3824 (long) sp->req_resid);
3825 break;
3826 case RQSTYPE_REQUEST:
3827 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3828 /*
3829 * Force Queue Full status.
3830 */
3831 *XS_STSP(xs) = SCSI_QFULL;
3832 XS_SETERR(xs, HBA_NOERROR);
3833 } else if (XS_NOERR(xs)) {
3834 /*
3835 * ????
3836 */
3837 isp_prt(isp, ISP_LOGDEBUG0,
3838 "Request Queue Entry bounced back");
3839 XS_SETERR(xs, HBA_BOTCH);
3840 }
3841 XS_RESID(xs) = XS_XFRLEN(xs);
3842 break;
3843 default:
3844 isp_prt(isp, ISP_LOGWARN,
3845 "unhandled response queue type 0x%x",
3846 sp->req_header.rqs_entry_type);
3847 if (XS_NOERR(xs)) {
3848 XS_SETERR(xs, HBA_BOTCH);
3849 }
3850 break;
3851 }
3852
3853 /*
3854 * Free any dma resources. As a side effect, this may
3855 * also do any cache flushing necessary for data coherence. */
3856 if (XS_XFRLEN(xs)) {
3857 ISP_DMAFREE(isp, xs, sp->req_handle);
3858 }
3859
3860 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
3861 ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
3862 (*XS_STSP(xs) != SCSI_GOOD)))) {
3863 char skey;
3864 if (sp->req_state_flags & RQSF_GOT_SENSE) {
3865 skey = XS_SNSKEY(xs) & 0xf;
3866 if (skey < 10)
3867 skey += '0';
3868 else
3869 skey += 'a' - 10;
3870 } else if (*XS_STSP(xs) == SCSI_CHECK) {
3871 skey = '?';
3872 } else {
3873 skey = '.';
3874 }
3875 isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
3876 XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
3877 *XS_STSP(xs), skey, XS_ERR(xs));
3878 }
3879
3880 if (isp->isp_nactive > 0)
3881 isp->isp_nactive--;
3882 complist[ndone++] = xs; /* defer completion call until later */
3883 MEMZERO(hp, QENTRY_LEN); /* PERF */
3884 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
3885 break;
3886 }
3887 }
3888
3889 /*
3890 * If we looked at any commands, then it's valid to find out
3891 * what the outpointer is. It also is a trigger to update the
3892 * ISP's notion of what we've seen so far.
3893 */
3894 if (nlooked) {
3895 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3896 /*
3897 * While we're at it, read the requst queue out pointer.
3898 */
3899 isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
3900 if (isp->isp_rscchiwater < ndone)
3901 isp->isp_rscchiwater = ndone;
3902 }
3903
3904 isp->isp_residx = optr;
3905 isp->isp_rspbsy = 0;
3906 for (i = 0; i < ndone; i++) {
3907 xs = complist[i];
3908 if (xs) {
3909 isp->isp_rsltccmplt++;
3910 isp_done(xs);
3911 }
3912 }
3913}
3914
3915/*
3916 * Support routines.
3917 */
3918
3919static int
3920isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
3921{
3922 int rval = 0;
3923 int bus;
3924
3925 if (IS_DUALBUS(isp)) {
3926 bus = ISP_READ(isp, OUTMAILBOX6);
3927 } else {
3928 bus = 0;
3929 }
3930 isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
3931
3932 switch (mbox) {
3933 case ASYNC_BUS_RESET:
3934 isp->isp_sendmarker |= (1 << bus);
3935#ifdef ISP_TARGET_MODE
3936 if (isp_target_async(isp, bus, mbox))
3937 rval = -1;
3938#endif
3939 isp_async(isp, ISPASYNC_BUS_RESET, &bus);
3940 break;
3941 case ASYNC_SYSTEM_ERROR:
3942#ifdef ISP_FW_CRASH_DUMP
3943 /*
3944 * If we have crash dumps enabled, it's up to the handler
3945 * for isp_async to reinit stuff and restart the firmware
3946 * after performing the crash dump. The reason we do things
3947 * this way is that we may need to activate a kernel thread
3948 * to do all the crash dump goop.
3949 */
3950 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
3951#else
3952 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
3953 isp_reinit(isp);
3954 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
3955#endif
3956 rval = -1;
3957 break;
3958
3959 case ASYNC_RQS_XFER_ERR:
3960 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
3961 break;
3962
3963 case ASYNC_RSP_XFER_ERR:
3964 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
3965 break;
3966
3967 case ASYNC_QWAKEUP:
3968 /*
3969 * We've just been notified that the Queue has woken up.
3970 * We don't need to be chatty about this- just unlatch things
3971 * and move on.
3972 */
3973 mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp);
3974 break;
3975
3976 case ASYNC_TIMEOUT_RESET:
3977 isp_prt(isp, ISP_LOGWARN,
3978 "timeout initiated SCSI bus reset of bus %d", bus);
3979 isp->isp_sendmarker |= (1 << bus);
3980#ifdef ISP_TARGET_MODE
3981 if (isp_target_async(isp, bus, mbox))
3982 rval = -1;
3983#endif
3984 break;
3985
3986 case ASYNC_DEVICE_RESET:
3987 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
3988 isp->isp_sendmarker |= (1 << bus);
3989#ifdef ISP_TARGET_MODE
3990 if (isp_target_async(isp, bus, mbox))
3991 rval = -1;
3992#endif
3993 break;
3994
3995 case ASYNC_EXTMSG_UNDERRUN:
3996 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
3997 break;
3998
3999 case ASYNC_SCAM_INT:
4000 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
4001 break;
4002
4003 case ASYNC_HUNG_SCSI:
4004 isp_prt(isp, ISP_LOGERR,
4005 "stalled SCSI Bus after DATA Overrun");
4006 /* XXX: Need to issue SCSI reset at this point */
4007 break;
4008
4009 case ASYNC_KILLED_BUS:
4010 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
4011 break;
4012
4013 case ASYNC_BUS_TRANSIT:
4014 mbox = ISP_READ(isp, OUTMAILBOX2);
4015 switch (mbox & 0x1c00) {
4016 case SXP_PINS_LVD_MODE:
4017 isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
4018 SDPARAM(isp)->isp_diffmode = 0;
4019 SDPARAM(isp)->isp_ultramode = 0;
4020 SDPARAM(isp)->isp_lvdmode = 1;
4021 break;
4022 case SXP_PINS_HVD_MODE:
4023 isp_prt(isp, ISP_LOGINFO,
4024 "Transition to Differential mode");
4025 SDPARAM(isp)->isp_diffmode = 1;
4026 SDPARAM(isp)->isp_ultramode = 0;
4027 SDPARAM(isp)->isp_lvdmode = 0;
4028 break;
4029 case SXP_PINS_SE_MODE:
4030 isp_prt(isp, ISP_LOGINFO,
4031 "Transition to Single Ended mode");
4032 SDPARAM(isp)->isp_diffmode = 0;
4033 SDPARAM(isp)->isp_ultramode = 1;
4034 SDPARAM(isp)->isp_lvdmode = 0;
4035 break;
4036 default:
4037 isp_prt(isp, ISP_LOGWARN,
4038 "Transition to Unknown Mode 0x%x", mbox);
4039 break;
4040 }
4041 /*
4042 * XXX: Set up to renegotiate again!
4043 */
4044 /* Can only be for a 1080... */
4045 isp->isp_sendmarker |= (1 << bus);
4046 break;
4047
4048 /*
4049 * We can use bus, which will always be zero for FC cards,
4050 * as a mailbox pattern accumulator to be checked below.
4051 */
4052 case ASYNC_RIO5:
4053 bus = 0x1ce; /* outgoing mailbox regs 1-3, 6-7 */
4054 break;
4055
4056 case ASYNC_RIO4:
4057 bus = 0x14e; /* outgoing mailbox regs 1-3, 6 */
4058 break;
4059
4060 case ASYNC_RIO3:
4061 bus = 0x10e; /* outgoing mailbox regs 1-3 */
4062 break;
4063
4064 case ASYNC_RIO2:
4065 bus = 0x106; /* outgoing mailbox regs 1-2 */
4066 break;
4067
4068 case ASYNC_RIO1:
4069 case ASYNC_CMD_CMPLT:
4070 bus = 0x102; /* outgoing mailbox regs 1 */
4071 break;
4072
4073 case ASYNC_RIO_RESP:
4074 return (rval);
4075
4076 case ASYNC_CTIO_DONE:
4077 {
4078#ifdef ISP_TARGET_MODE
4079 int handle =
4080 (ISP_READ(isp, OUTMAILBOX2) << 16) |
4081 (ISP_READ(isp, OUTMAILBOX1));
4082 if (isp_target_async(isp, handle, mbox))
4083 rval = -1;
4084#else