![[BACK]](/icons/back.gif){kind=icon}
Return to isp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to isp.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: isp.c,v 1.39 2007/05/23 01:32:25 ray 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
45: #ifdef __FreeBSD__
46: #include <dev/isp/isp_freebsd.h>
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: */
67: static const char portshift[] =
68: "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
69: static const char portdup[] =
70: "Target %d duplicates Target %d- killing off both";
71: static const char retained[] =
72: "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
73: static const char lretained[] =
74: "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
75: static const char plogout[] =
76: "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
77: static const char plogierr[] =
78: "Command Error in PLOGI for Port 0x%x (0x%x)";
79: static const char nopdb[] =
80: "Could not get PDB for Device @ Port 0x%x";
81: static const char pdbmfail1[] =
82: "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
83: static const char pdbmfail2[] =
84: "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
85: static const char ldumped[] =
86: "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
87: static const char notresp[] =
88: "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
89: static const char xact1[] =
90: "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
91: static const char xact2[] =
92: "HBA attempted queued transaction to target routine %d on target %d bus %d";
93: static const char xact3[] =
94: "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
95: static const char pskip[] =
96: "SCSI phase skipped for target %d.%d.%d";
97: static const char topology[] =
98: "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
99: static const char swrej[] =
100: "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x";
101: static const char finmsg[] =
102: "(%d.%d.%d): FIN dl%d resid %lu STS 0x%x SKEY %c XS_ERR=0x%x";
103: static const char sc0[] =
104: "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
105: static const char sc1[] =
106: "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
107: static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
108: static const char sc3[] = "Generated";
109: static const char sc4[] = "NVRAM";
110: static const char bun[] =
111: "bad underrun for %d.%d (count %d, resid %d, status %s)";
112:
113: /*
114: * Local function prototypes.
115: */
116: static int isp_parse_async(struct ispsoftc *, u_int16_t);
117: static int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *,
118: u_int16_t *);
119: static void
120: isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *);
121: static void isp_fastpost_complete(struct ispsoftc *, u_int16_t);
122: static int isp_mbox_continue(struct ispsoftc *);
123: static void isp_scsi_init(struct ispsoftc *);
124: static void isp_scsi_channel_init(struct ispsoftc *, int);
125: static void isp_fibre_init(struct ispsoftc *);
126: static void isp_mark_getpdb_all(struct ispsoftc *);
127: static int isp_getmap(struct ispsoftc *, fcpos_map_t *);
128: static int isp_getpdb(struct ispsoftc *, int, isp_pdb_t *);
129: static u_int64_t isp_get_portname(struct ispsoftc *, int, int);
130: static int isp_fclink_test(struct ispsoftc *, int);
131: static char *isp2100_fw_statename(int);
132: static int isp_pdb_sync(struct ispsoftc *);
133: static int isp_scan_loop(struct ispsoftc *);
134: static int isp_fabric_mbox_cmd(struct ispsoftc *, mbreg_t *);
135: static int isp_scan_fabric(struct ispsoftc *, int);
136: static void isp_register_fc4_type(struct ispsoftc *);
137: static void isp_fw_state(struct ispsoftc *);
138: static void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int);
139: static void isp_mboxcmd(struct ispsoftc *, mbreg_t *, int);
140:
141: static void isp_update(struct ispsoftc *);
142: static void isp_update_bus(struct ispsoftc *, int);
143: static void isp_setdfltparm(struct ispsoftc *, int);
144: static int isp_read_nvram(struct ispsoftc *);
145: static void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *);
146: static void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *);
147: static void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *);
148: static void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *);
149: static 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:
159: void
160: isp_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:
435: again:
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 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: if (IS_SCSI(isp)) {
799: if (dodnld) {
800: if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
801: isp->isp_maxluns = 32;
802: } else {
803: isp->isp_maxluns = 8;
804: }
805: } else {
806: isp->isp_maxluns = 8;
807: }
808: } else {
809: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
810: isp->isp_maxluns = 16384;
811: } else {
812: isp->isp_maxluns = 16;
813: }
814: }
815: }
816:
817: /*
818: * Initialize Parameters of Hardware to a known state.
819: *
820: * Locks are held before coming here.
821: */
822:
823: void
824: isp_init(struct ispsoftc *isp)
825: {
826: /*
827: * Must do this first to get defaults established.
828: */
829: isp_setdfltparm(isp, 0);
830: if (IS_DUALBUS(isp)) {
831: isp_setdfltparm(isp, 1);
832: }
833: if (IS_FC(isp)) {
834: isp_fibre_init(isp);
835: } else {
836: isp_scsi_init(isp);
837: }
838: }
839:
840: static void
841: isp_scsi_init(struct ispsoftc *isp)
842: {
843: sdparam *sdp_chan0, *sdp_chan1;
844: mbreg_t mbs;
845:
846: sdp_chan0 = isp->isp_param;
847: sdp_chan1 = sdp_chan0;
848: if (IS_DUALBUS(isp)) {
849: sdp_chan1++;
850: }
851:
852: /*
853: * If we have no role (neither target nor initiator), return.
854: */
855: if (isp->isp_role == ISP_ROLE_NONE) {
856: return;
857: }
858:
859: /* First do overall per-card settings. */
860:
861: /*
862: * If we have fast memory timing enabled, turn it on.
863: */
864: if (sdp_chan0->isp_fast_mttr) {
865: ISP_WRITE(isp, RISC_MTR, 0x1313);
866: }
867:
868: /*
869: * Set Retry Delay and Count.
870: * You set both channels at the same time.
871: */
872: mbs.param[0] = MBOX_SET_RETRY_COUNT;
873: mbs.param[1] = sdp_chan0->isp_retry_count;
874: mbs.param[2] = sdp_chan0->isp_retry_delay;
875: mbs.param[6] = sdp_chan1->isp_retry_count;
876: mbs.param[7] = sdp_chan1->isp_retry_delay;
877:
878: isp_mboxcmd(isp, &mbs, MBLOGALL);
879: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
880: return;
881: }
882:
883: /*
884: * Set ASYNC DATA SETUP time. This is very important.
885: */
886: mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
887: mbs.param[1] = sdp_chan0->isp_async_data_setup;
888: mbs.param[2] = sdp_chan1->isp_async_data_setup;
889: isp_mboxcmd(isp, &mbs, MBLOGALL);
890: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
891: return;
892: }
893:
894: /*
895: * Set ACTIVE Negation State.
896: */
897: mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
898: mbs.param[1] =
899: (sdp_chan0->isp_req_ack_active_neg << 4) |
900: (sdp_chan0->isp_data_line_active_neg << 5);
901: mbs.param[2] =
902: (sdp_chan1->isp_req_ack_active_neg << 4) |
903: (sdp_chan1->isp_data_line_active_neg << 5);
904:
905: isp_mboxcmd(isp, &mbs, MBLOGNONE);
906: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
907: isp_prt(isp, ISP_LOGERR,
908: "failed to set active negation state (%d,%d), (%d,%d)",
909: sdp_chan0->isp_req_ack_active_neg,
910: sdp_chan0->isp_data_line_active_neg,
911: sdp_chan1->isp_req_ack_active_neg,
912: sdp_chan1->isp_data_line_active_neg);
913: /*
914: * But don't return.
915: */
916: }
917:
918: /*
919: * Set the Tag Aging limit
920: */
921: mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
922: mbs.param[1] = sdp_chan0->isp_tag_aging;
923: mbs.param[2] = sdp_chan1->isp_tag_aging;
924: isp_mboxcmd(isp, &mbs, MBLOGALL);
925: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
926: isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
927: sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
928: return;
929: }
930:
931: /*
932: * Set selection timeout.
933: */
934: mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
935: mbs.param[1] = sdp_chan0->isp_selection_timeout;
936: mbs.param[2] = sdp_chan1->isp_selection_timeout;
937: isp_mboxcmd(isp, &mbs, MBLOGALL);
938: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
939: return;
940: }
941:
942: /* now do per-channel settings */
943: isp_scsi_channel_init(isp, 0);
944: if (IS_DUALBUS(isp))
945: isp_scsi_channel_init(isp, 1);
946:
947: /*
948: * Now enable request/response queues
949: */
950:
951: if (IS_ULTRA2(isp) || IS_1240(isp)) {
952: mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
953: mbs.param[1] = RESULT_QUEUE_LEN(isp);
954: mbs.param[2] = DMA_WD1(isp->isp_result_dma);
955: mbs.param[3] = DMA_WD0(isp->isp_result_dma);
956: mbs.param[4] = 0;
957: mbs.param[6] = DMA_WD3(isp->isp_result_dma);
958: mbs.param[7] = DMA_WD2(isp->isp_result_dma);
959: isp_mboxcmd(isp, &mbs, MBLOGALL);
960: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
961: return;
962: }
963: isp->isp_residx = mbs.param[5];
964:
965: mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
966: mbs.param[1] = RQUEST_QUEUE_LEN(isp);
967: mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
968: mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
969: mbs.param[5] = 0;
970: mbs.param[6] = DMA_WD3(isp->isp_result_dma);
971: mbs.param[7] = DMA_WD2(isp->isp_result_dma);
972: isp_mboxcmd(isp, &mbs, MBLOGALL);
973: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
974: return;
975: }
976: isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
977: } else {
978: mbs.param[0] = MBOX_INIT_RES_QUEUE;
979: mbs.param[1] = RESULT_QUEUE_LEN(isp);
980: mbs.param[2] = DMA_WD1(isp->isp_result_dma);
981: mbs.param[3] = DMA_WD0(isp->isp_result_dma);
982: mbs.param[4] = 0;
983: isp_mboxcmd(isp, &mbs, MBLOGALL);
984: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
985: return;
986: }
987: isp->isp_residx = mbs.param[5];
988:
989: mbs.param[0] = MBOX_INIT_REQ_QUEUE;
990: mbs.param[1] = RQUEST_QUEUE_LEN(isp);
991: mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
992: mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
993: mbs.param[5] = 0;
994: isp_mboxcmd(isp, &mbs, MBLOGALL);
995: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
996: return;
997: }
998: isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
999: }
1000:
1001: /*
1002: * Turn on Fast Posting, LVD transitions
1003: *
1004: * Ultra2 F/W always has had fast posting (and LVD transitions)
1005: *
1006: * Ultra and older (i.e., SBus) cards may not. It's just safer
1007: * to assume not for them.
1008: */
1009:
1010: mbs.param[0] = MBOX_SET_FW_FEATURES;
1011: mbs.param[1] = 0;
1012: if (IS_ULTRA2(isp))
1013: mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1014: #ifndef ISP_NO_RIO
1015: if (IS_ULTRA2(isp) || IS_1240(isp))
1016: mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1017: #else
1018: #ifndef ISP_NO_FASTPOST
1019: if (IS_ULTRA2(isp) || IS_1240(isp))
1020: mbs.param[1] |= FW_FEATURE_FAST_POST;
1021: #endif
1022: #endif
1023: if (mbs.param[1] != 0) {
1024: u_int16_t sfeat = mbs.param[1];
1025: isp_mboxcmd(isp, &mbs, MBLOGALL);
1026: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1027: isp_prt(isp, ISP_LOGINFO,
1028: "Enabled FW features (0x%x)", sfeat);
1029: }
1030: }
1031:
1032: /*
1033: * Let the outer layers decide whether to issue a SCSI bus reset.
1034: */
1035: isp->isp_state = ISP_INITSTATE;
1036: }
1037:
1038: static void
1039: isp_scsi_channel_init(struct ispsoftc *isp, int channel)
1040: {
1041: sdparam *sdp;
1042: mbreg_t mbs;
1043: int tgt;
1044:
1045: sdp = isp->isp_param;
1046: sdp += channel;
1047:
1048: /*
1049: * Set (possibly new) Initiator ID.
1050: */
1051: mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1052: mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1053: isp_mboxcmd(isp, &mbs, MBLOGALL);
1054: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1055: return;
1056: }
1057: isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1058: sdp->isp_initiator_id, channel);
1059:
1060:
1061: /*
1062: * Set current per-target parameters to an initial safe minimum.
1063: */
1064: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1065: int lun;
1066: u_int16_t sdf;
1067:
1068: if (sdp->isp_devparam[tgt].dev_enable == 0) {
1069: continue;
1070: }
1071: #ifndef ISP_TARGET_MODE
1072: sdf = sdp->isp_devparam[tgt].goal_flags;
1073: sdf &= DPARM_SAFE_DFLT;
1074: /*
1075: * It is not quite clear when this changed over so that
1076: * we could force narrow and async for 1000/1020 cards,
1077: * but assume that this is only the case for loaded
1078: * firmware.
1079: */
1080: if (isp->isp_loaded_fw) {
1081: sdf |= DPARM_NARROW | DPARM_ASYNC;
1082: }
1083: #else
1084: /*
1085: * The !$*!)$!$)* f/w uses the same index into some
1086: * internal table to decide how to respond to negotiations,
1087: * so if we've said "let's be safe" for ID X, and ID X
1088: * selects *us*, the negotiations will back to 'safe'
1089: * (as in narrow/async). What the f/w *should* do is
1090: * use the initiator id settings to decide how to respond.
1091: */
1092: sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1093: #endif
1094: mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1095: mbs.param[1] = (channel << 15) | (tgt << 8);
1096: mbs.param[2] = sdf;
1097: if ((sdf & DPARM_SYNC) == 0) {
1098: mbs.param[3] = 0;
1099: } else {
1100: mbs.param[3] =
1101: (sdp->isp_devparam[tgt].goal_offset << 8) |
1102: (sdp->isp_devparam[tgt].goal_period);
1103: }
1104: isp_prt(isp, ISP_LOGDEBUG0,
1105: "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1106: channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1107: mbs.param[3] & 0xff);
1108: isp_mboxcmd(isp, &mbs, MBLOGNONE);
1109: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1110: sdf = DPARM_SAFE_DFLT;
1111: mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1112: mbs.param[1] = (tgt << 8) | (channel << 15);
1113: mbs.param[2] = sdf;
1114: mbs.param[3] = 0;
1115: isp_mboxcmd(isp, &mbs, MBLOGALL);
1116: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1117: continue;
1118: }
1119: }
1120:
1121: /*
1122: * We don't update any information directly from the f/w
1123: * because we need to run at least one command to cause a
1124: * new state to be latched up. So, we just assume that we
1125: * converge to the values we just had set.
1126: *
1127: * Ensure that we don't believe tagged queuing is enabled yet.
1128: * It turns out that sometimes the ISP just ignores our
1129: * attempts to set parameters for devices that it hasn't
1130: * seen yet.
1131: */
1132: sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1133: for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1134: mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1135: mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1136: mbs.param[2] = sdp->isp_max_queue_depth;
1137: mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1138: isp_mboxcmd(isp, &mbs, MBLOGALL);
1139: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1140: break;
1141: }
1142: }
1143: }
1144: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1145: if (sdp->isp_devparam[tgt].dev_refresh) {
1146: isp->isp_sendmarker |= (1 << channel);
1147: isp->isp_update |= (1 << channel);
1148: break;
1149: }
1150: }
1151: }
1152:
1153: /*
1154: * Fibre Channel specific initialization.
1155: *
1156: * Locks are held before coming here.
1157: */
1158: static void
1159: isp_fibre_init(struct ispsoftc *isp)
1160: {
1161: fcparam *fcp;
1162: isp_icb_t local, *icbp = &local;
1163: mbreg_t mbs;
1164: int loopid;
1165: u_int64_t nwwn, pwwn;
1166:
1167: fcp = isp->isp_param;
1168:
1169: /*
1170: * Do this *before* initializing the firmware.
1171: */
1172: isp_mark_getpdb_all(isp);
1173: fcp->isp_fwstate = FW_CONFIG_WAIT;
1174: fcp->isp_loopstate = LOOP_NIL;
1175:
1176: /*
1177: * If we have no role (neither target nor initiator), return.
1178: */
1179: if (isp->isp_role == ISP_ROLE_NONE) {
1180: return;
1181: }
1182:
1183: loopid = fcp->isp_loopid;
1184: MEMZERO(icbp, sizeof (*icbp));
1185: icbp->icb_version = ICB_VERSION1;
1186:
1187: /*
1188: * Firmware Options are either retrieved from NVRAM or
1189: * are patched elsewhere. We check them for sanity here
1190: * and make changes based on board revision, but otherwise
1191: * let others decide policy.
1192: */
1193:
1194: /*
1195: * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1196: */
1197: if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
1198: fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
1199: }
1200:
1201: /*
1202: * We have to use FULL LOGIN even though it resets the loop too much
1203: * because otherwise port database entries don't get updated after
1204: * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1205: */
1206: if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1207: fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
1208: }
1209:
1210: /*
1211: * Insist on Port Database Update Async notifications
1212: */
1213: fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
1214:
1215: /*
1216: * Make sure that target role reflects into fwoptions.
1217: */
1218: if (isp->isp_role & ISP_ROLE_TARGET) {
1219: fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
1220: } else {
1221: fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
1222: }
1223:
1224: /*
1225: * Propagate all of this into the ICB structure.
1226: */
1227: icbp->icb_fwoptions = fcp->isp_fwoptions;
1228: icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1229: if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1230: icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1231: isp_prt(isp, ISP_LOGERR,
1232: "bad frame length (%d) from NVRAM- using %d",
1233: fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1234: icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1235: }
1236: icbp->icb_maxalloc = fcp->isp_maxalloc;
1237: if (icbp->icb_maxalloc < 1) {
1238: isp_prt(isp, ISP_LOGERR,
1239: "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1240: icbp->icb_maxalloc = 16;
1241: }
1242: icbp->icb_execthrottle = fcp->isp_execthrottle;
1243: if (icbp->icb_execthrottle < 1) {
1244: isp_prt(isp, ISP_LOGERR,
1245: "bad execution throttle of %d- using 16",
1246: fcp->isp_execthrottle);
1247: icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1248: }
1249: icbp->icb_retry_delay = fcp->isp_retry_delay;
1250: icbp->icb_retry_count = fcp->isp_retry_count;
1251: icbp->icb_hardaddr = loopid;
1252: /*
1253: * Right now we just set extended options to prefer point-to-point
1254: * over loop based upon some soft config options.
1255: *
1256: * NB: for the 2300, ICBOPT_EXTENDED is required.
1257: */
1258: if (IS_2200(isp) || IS_23XX(isp)) {
1259: icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1260: /*
1261: * Prefer or force Point-To-Point instead Loop?
1262: */
1263: switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1264: case ISP_CFG_NPORT:
1265: icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1266: break;
1267: case ISP_CFG_NPORT_ONLY:
1268: icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1269: break;
1270: case ISP_CFG_LPORT_ONLY:
1271: icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1272: break;
1273: default:
1274: icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1275: break;
1276: }
1277: if (IS_23XX(isp)) {
1278: /*
1279: * QLogic recommends that FAST Posting be turned
1280: * off for 23XX cards and instead allow the HBA
1281: * to write response queue entries and interrupt
1282: * after a delay (ZIO).
1283: *
1284: * If we set ZIO, it will disable fast posting,
1285: * so we don't need to clear it in fwoptions.
1286: */
1287: icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1288: #if 0
1289: /*
1290: * Values, in 100us increments. The default
1291: * is 2 (200us) if a value 0 (default) is
1292: * selected.
1293: */
1294: icbp->icb_idelaytimer = 2;
1295: #endif
1296:
1297: if (isp->isp_confopts & ISP_CFG_ONEGB) {
1298: icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1299: } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1300: icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1301: } else {
1302: icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1303: }
1304: }
1305: }
1306:
1307: #ifndef ISP_NO_RIO_FC
1308: /*
1309: * RIO seems to be enabled in 2100s for fw >= 1.17.0.
1310: *
1311: * I've had some questionable problems with RIO on 2200.
1312: * More specifically, on a 2204 I had problems with RIO
1313: * on a Linux system where I was dropping commands right
1314: * and left. It's not clear to me what the actual problem
1315: * was.
1316: *
1317: * 23XX Cards do not support RIO. Instead they support ZIO.
1318: */
1319: #if 0
1320: if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1321: icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
1322: icbp->icb_racctimer = 4;
1323: icbp->icb_idelaytimer = 8;
1324: }
1325: #endif
1326: #endif
1327:
1328: /*
1329: * For 22XX > 2.1.26 && 23XX, set someoptions.
1330: * XXX: Probably okay for newer 2100 f/w too.
1331: */
1332: if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1333: /*
1334: * Turn on LIP F8 async event (1)
1335: * Turn on generate AE 8013 on all LIP Resets (2)
1336: * Disable LIP F7 switching (8)
1337: */
1338: mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1339: mbs.param[1] = 0xb;
1340: mbs.param[2] = 0;
1341: mbs.param[3] = 0;
1342: isp_mboxcmd(isp, &mbs, MBLOGALL);
1343: }
1344: icbp->icb_logintime = 30; /* 30 second login timeout */
1345:
1346: if (IS_23XX(isp)) {
1347: ISP_WRITE(isp, isp->isp_rqstinrp, 0);
1348: ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
1349: ISP_WRITE(isp, isp->isp_respinrp, 0);
1350: ISP_WRITE(isp, isp->isp_respoutrp, 0);
1351: }
1352:
1353: nwwn = ISP_NODEWWN(isp);
1354: pwwn = ISP_PORTWWN(isp);
1355: if (nwwn && pwwn) {
1356: icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1357: MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1358: MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1359: isp_prt(isp, ISP_LOGDEBUG1,
1360: "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1361: ((u_int32_t) (nwwn >> 32)),
1362: ((u_int32_t) (nwwn & 0xffffffff)),
1363: ((u_int32_t) (pwwn >> 32)),
1364: ((u_int32_t) (pwwn & 0xffffffff)));
1365: } else {
1366: isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
1367: icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN);
1368: }
1369: icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1370: icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1371: icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1372: icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1373: icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1374: icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1375: icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1376: icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1377: icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1378: icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1379: isp_prt(isp, ISP_LOGDEBUG0,
1380: "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1381: icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1382:
1383: FC_SCRATCH_ACQUIRE(isp);
1384: isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1385:
1386: /*
1387: * Init the firmware
1388: */
1389: mbs.param[0] = MBOX_INIT_FIRMWARE;
1390: mbs.param[1] = 0;
1391: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1392: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1393: mbs.param[4] = 0;
1394: mbs.param[5] = 0;
1395: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1396: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1397: isp_mboxcmd(isp, &mbs, MBLOGALL);
1398: FC_SCRATCH_RELEASE(isp);
1399: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1400: return;
1401: }
1402: isp->isp_reqidx = isp->isp_reqodx = 0;
1403: isp->isp_residx = 0;
1404: isp->isp_sendmarker = 1;
1405:
1406: /*
1407: * Whatever happens, we're now committed to being here.
1408: */
1409: isp->isp_state = ISP_INITSTATE;
1410: }
1411:
1412: /*
1413: * Fibre Channel Support- get the port database for the id.
1414: *
1415: * Locks are held before coming here. Return 0 if success,
1416: * else failure.
1417: */
1418:
1419: static int
1420: isp_getmap(struct ispsoftc *isp, fcpos_map_t *map)
1421: {
1422: fcparam *fcp = (fcparam *) isp->isp_param;
1423: mbreg_t mbs;
1424:
1425: mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP;
1426: mbs.param[1] = 0;
1427: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1428: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1429: /*
1430: * Unneeded. For the 2100, except for initializing f/w, registers
1431: * 4/5 have to not be written to.
1432: * mbs.param[4] = 0;
1433: * mbs.param[5] = 0;
1434: *
1435: */
1436: mbs.param[6] = 0;
1437: mbs.param[7] = 0;
1438: FC_SCRATCH_ACQUIRE(isp);
1439: isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1440: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1441: MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t));
1442: map->fwmap = mbs.param[1] != 0;
1443: FC_SCRATCH_RELEASE(isp);
1444: return (0);
1445: }
1446: FC_SCRATCH_RELEASE(isp);
1447: return (-1);
1448: }
1449:
1450: static void
1451: isp_mark_getpdb_all(struct ispsoftc *isp)
1452: {
1453: fcparam *fcp = (fcparam *) isp->isp_param;
1454: int i;
1455: for (i = 0; i < MAX_FC_TARG; i++) {
1456: fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0;
1457: }
1458: }
1459:
1460: static int
1461: isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp)
1462: {
1463: fcparam *fcp = (fcparam *) isp->isp_param;
1464: mbreg_t mbs;
1465:
1466: mbs.param[0] = MBOX_GET_PORT_DB;
1467: mbs.param[1] = id << 8;
1468: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1469: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1470: /*
1471: * Unneeded. For the 2100, except for initializing f/w, registers
1472: * 4/5 have to not be written to.
1473: * mbs.param[4] = 0;
1474: * mbs.param[5] = 0;
1475: *
1476: */
1477: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1478: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1479: FC_SCRATCH_ACQUIRE(isp);
1480: isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1481: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1482: isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp);
1483: FC_SCRATCH_RELEASE(isp);
1484: return (0);
1485: }
1486: FC_SCRATCH_RELEASE(isp);
1487: return (-1);
1488: }
1489:
1490: static u_int64_t
1491: isp_get_portname(struct ispsoftc *isp, int loopid, int nodename)
1492: {
1493: u_int64_t wwn = 0;
1494: mbreg_t mbs;
1495:
1496: mbs.param[0] = MBOX_GET_PORT_NAME;
1497: mbs.param[1] = loopid << 8;
1498: if (nodename)
1499: mbs.param[1] |= 1;
1500: isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1501: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1502: wwn =
1503: (((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
1504: (((u_int64_t)(mbs.param[2] >> 8)) << 48) |
1505: (((u_int64_t)(mbs.param[3] & 0xff)) << 40) |
1506: (((u_int64_t)(mbs.param[3] >> 8)) << 32) |
1507: (((u_int64_t)(mbs.param[6] & 0xff)) << 24) |
1508: (((u_int64_t)(mbs.param[6] >> 8)) << 16) |
1509: (((u_int64_t)(mbs.param[7] & 0xff)) << 8) |
1510: (((u_int64_t)(mbs.param[7] >> 8)));
1511: }
1512: return (wwn);
1513: }
1514:
1515: /*
1516: * Make sure we have good FC link and know our Loop ID.
1517: */
1518:
1519: static int
1520: isp_fclink_test(struct ispsoftc *isp, int usdelay)
1521: {
1522: static char *toponames[] = {
1523: "Private Loop",
1524: "FL Port",
1525: "N-Port to N-Port",
1526: "F Port",
1527: "F Port (no FLOGI_ACC response)"
1528: };
1529: mbreg_t mbs;
1530: int count, check_for_fabric;
1531: u_int8_t lwfs;
1532: fcparam *fcp;
1533: struct lportdb *lp;
1534: isp_pdb_t pdb;
1535:
1536: fcp = isp->isp_param;
1537:
1538: /*
1539: * XXX: Here is where we would start a 'loop dead' timeout
1540: */
1541:
1542: /*
1543: * Wait up to N microseconds for F/W to go to a ready state.
1544: */
1545: lwfs = FW_CONFIG_WAIT;
1546: count = 0;
1547: while (count < usdelay) {
1548: u_int64_t enano;
1549: u_int32_t wrk;
1550: NANOTIME_T hra, hrb;
1551:
1552: GET_NANOTIME(&hra);
1553: isp_fw_state(isp);
1554: if (lwfs != fcp->isp_fwstate) {
1555: isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
1556: isp2100_fw_statename((int)lwfs),
1557: isp2100_fw_statename((int)fcp->isp_fwstate));
1558: lwfs = fcp->isp_fwstate;
1559: }
1560: if (fcp->isp_fwstate == FW_READY) {
1561: break;
1562: }
1563: GET_NANOTIME(&hrb);
1564:
1565: /*
1566: * Get the elapsed time in nanoseconds.
1567: * Always guaranteed to be non-zero.
1568: */
1569: enano = NANOTIME_SUB(&hrb, &hra);
1570:
1571: isp_prt(isp, ISP_LOGDEBUG1,
1572: "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
1573: count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
1574: (u_int32_t)(enano >> 32), (u_int32_t)(enano & 0xffffffff));
1575:
1576: /*
1577: * If the elapsed time is less than 1 millisecond,
1578: * delay a period of time up to that millisecond of
1579: * waiting.
1580: *
1581: * This peculiar code is an attempt to try and avoid
1582: * invoking u_int64_t math support functions for some
1583: * platforms where linkage is a problem.
1584: */
1585: if (enano < (1000 * 1000)) {
1586: count += 1000;
1587: enano = (1000 * 1000) - enano;
1588: while (enano > (u_int64_t) 4000000000U) {
1589: USEC_SLEEP(isp, 4000000);
1590: enano -= (u_int64_t) 4000000000U;
1591: }
1592: wrk = enano;
1593: wrk /= 1000;
1594: USEC_SLEEP(isp, wrk);
1595: } else {
1596: while (enano > (u_int64_t) 4000000000U) {
1597: count += 4000000;
1598: enano -= (u_int64_t) 4000000000U;
1599: }
1600: wrk = enano;
1601: count += (wrk / 1000);
1602: }
1603: }
1604:
1605: /*
1606: * If we haven't gone to 'ready' state, return.
1607: */
1608: if (fcp->isp_fwstate != FW_READY) {
1609: return (-1);
1610: }
1611:
1612: /*
1613: * Get our Loop ID (if possible). We really need to have it.
1614: */
1615: mbs.param[0] = MBOX_GET_LOOP_ID;
1616: isp_mboxcmd(isp, &mbs, MBLOGALL);
1617: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1618: return (-1);
1619: }
1620: fcp->isp_loopid = mbs.param[1];
1621: if (IS_2200(isp) || IS_23XX(isp)) {
1622: int topo = (int) mbs.param[6];
1623: if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
1624: topo = TOPO_PTP_STUB;
1625: fcp->isp_topo = topo;
1626: } else {
1627: fcp->isp_topo = TOPO_NL_PORT;
1628: }
1629: fcp->isp_portid = fcp->isp_alpa = mbs.param[2] & 0xff;
1630:
1631: /*
1632: * Check to see if we're on a fabric by trying to see if we
1633: * can talk to the fabric name server. This can be a bit
1634: * tricky because if we're a 2100, we should check always
1635: * (in case we're connected to a server doing aliasing).
1636: */
1637: fcp->isp_onfabric = 0;
1638:
1639: if (IS_2100(isp)) {
1640: /*
1641: * Don't bother with fabric if we are using really old
1642: * 2100 firmware. It's just not worth it.
1643: */
1644: if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
1645: check_for_fabric = 1;
1646: } else {
1647: check_for_fabric = 0;
1648: }
1649: } else if (fcp->isp_topo == TOPO_FL_PORT ||
1650: fcp->isp_topo == TOPO_F_PORT) {
1651: check_for_fabric = 1;
1652: } else
1653: check_for_fabric = 0;
1654:
1655: if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
1656: int loopid = FL_PORT_ID;
1657: if (IS_2100(isp)) {
1658: fcp->isp_topo = TOPO_FL_PORT;
1659: }
1660:
1661: if (BITS2WORD(pdb.pdb_portid_bits) == 0) {
1662: /*
1663: * Crock.
1664: */
1665: fcp->isp_topo = TOPO_NL_PORT;
1666: goto not_on_fabric;
1667: }
1668: fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16);
1669:
1670: /*
1671: * Save the Fabric controller's port database entry.
1672: */
1673: lp = &fcp->portdb[loopid];
1674: lp->node_wwn =
1675: (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1676: (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1677: (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1678: (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1679: (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1680: (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1681: (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1682: (((u_int64_t)pdb.pdb_nodename[7]));
1683: lp->port_wwn =
1684: (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1685: (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1686: (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1687: (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1688: (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1689: (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1690: (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1691: (((u_int64_t)pdb.pdb_portname[7]));
1692: lp->roles =
1693: (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1694: lp->portid = BITS2WORD(pdb.pdb_portid_bits);
1695: lp->loopid = pdb.pdb_loopid;
1696: lp->loggedin = lp->valid = 1;
1697: fcp->isp_onfabric = 1;
1698: (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1699: isp_register_fc4_type(isp);
1700: } else {
1701: not_on_fabric:
1702: fcp->isp_onfabric = 0;
1703: fcp->portdb[FL_PORT_ID].valid = 0;
1704: }
1705:
1706: fcp->isp_gbspeed = 1;
1707: if (IS_23XX(isp)) {
1708: mbs.param[0] = MBOX_GET_SET_DATA_RATE;
1709: mbs.param[1] = MBGSD_GET_RATE;
1710: /* mbs.param[2] undefined if we're just getting rate */
1711: isp_mboxcmd(isp, &mbs, MBLOGALL);
1712: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1713: if (mbs.param[1] == MBGSD_TWOGB) {
1714: isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
1715: fcp->isp_gbspeed = 2;
1716: }
1717: }
1718: }
1719:
1720: isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid, fcp->isp_alpa,
1721: fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
1722:
1723: /*
1724: * Announce ourselves, too. This involves synthesizing an entry.
1725: */
1726: if (fcp->isp_iid_set == 0) {
1727: fcp->isp_iid_set = 1;
1728: fcp->isp_iid = fcp->isp_loopid;
1729: lp = &fcp->portdb[fcp->isp_iid];
1730: } else {
1731: lp = &fcp->portdb[fcp->isp_iid];
1732: if (fcp->isp_portid != lp->portid ||
1733: fcp->isp_loopid != lp->loopid ||
1734: fcp->isp_nodewwn != ISP_NODEWWN(isp) ||
1735: fcp->isp_portwwn != ISP_PORTWWN(isp)) {
1736: lp->valid = 0;
1737: count = fcp->isp_iid;
1738: (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1739: }
1740: }
1741: lp->loopid = fcp->isp_loopid;
1742: lp->portid = fcp->isp_portid;
1743: lp->node_wwn = ISP_NODEWWN(isp);
1744: lp->port_wwn = ISP_PORTWWN(isp);
1745: switch (isp->isp_role) {
1746: case ISP_ROLE_NONE:
1747: lp->roles = 0;
1748: break;
1749: case ISP_ROLE_TARGET:
1750: lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
1751: break;
1752: case ISP_ROLE_INITIATOR:
1753: lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
1754: break;
1755: case ISP_ROLE_BOTH:
1756: lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
1757: break;
1758: }
1759: lp->loggedin = lp->valid = 1;
1760: count = fcp->isp_iid;
1761: (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1762: return (0);
1763: }
1764:
1765: static char *
1766: isp2100_fw_statename(int state)
1767: {
1768: switch(state) {
1769: case FW_CONFIG_WAIT: return "Config Wait";
1770: case FW_WAIT_AL_PA: return "Waiting for AL_PA";
1771: case FW_WAIT_LOGIN: return "Wait Login";
1772: case FW_READY: return "Ready";
1773: case FW_LOSS_OF_SYNC: return "Loss Of Sync";
1774: case FW_ERROR: return "Error";
1775: case FW_REINIT: return "Re-Init";
1776: case FW_NON_PART: return "Nonparticipating";
1777: default: return "?????";
1778: }
1779: }
1780:
1781: /*
1782: * Synchronize our soft copy of the port database with what the f/w thinks
1783: * (with a view toward possibly for a specific target....)
1784: */
1785:
1786: static int
1787: isp_pdb_sync(struct ispsoftc *isp)
1788: {
1789: struct lportdb *lp;
1790: fcparam *fcp = isp->isp_param;
1791: isp_pdb_t pdb;
1792: int loopid, base, lim;
1793:
1794: /*
1795: * Make sure we're okay for doing this right now.
1796: */
1797: if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
1798: fcp->isp_loopstate != LOOP_FSCAN_DONE &&
1799: fcp->isp_loopstate != LOOP_LSCAN_DONE) {
1800: return (-1);
1801: }
1802:
1803: if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT ||
1804: fcp->isp_topo == TOPO_N_PORT) {
1805: if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
1806: if (isp_scan_loop(isp) != 0) {
1807: return (-1);
1808: }
1809: }
1810: }
1811: fcp->isp_loopstate = LOOP_SYNCING_PDB;
1812:
1813: /*
1814: * If we get this far, we've settled our differences with the f/w
1815: * (for local loop device) and we can say that the loop state is ready.
1816: */
1817:
1818: if (fcp->isp_topo == TOPO_NL_PORT) {
1819: fcp->loop_seen_once = 1;
1820: fcp->isp_loopstate = LOOP_READY;
1821: return (0);
1822: }
1823:
1824: /*
1825: * Find all Fabric Entities that didn't make it from one scan to the
1826: * next and let the world know they went away. Scan the whole database.
1827: */
1828: for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
1829: if (lp->was_fabric_dev && lp->fabric_dev == 0) {
1830: loopid = lp - fcp->portdb;
1831: lp->valid = 0; /* should already be set */
1832: (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1833: MEMZERO((void *) lp, sizeof (*lp));
1834: continue;
1835: }
1836: lp->was_fabric_dev = lp->fabric_dev;
1837: }
1838:
1839: if (fcp->isp_topo == TOPO_FL_PORT)
1840: base = FC_SNS_ID+1;
1841: else
1842: base = 0;
1843:
1844: if (fcp->isp_topo == TOPO_N_PORT)
1845: lim = 1;
1846: else
1847: lim = MAX_FC_TARG;
1848:
1849: /*
1850: * Now log in any fabric devices that the outer layer has
1851: * left for us to see. This seems the most sane policy
1852: * for the moment.
1853: */
1854: for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
1855: u_int32_t portid;
1856: mbreg_t mbs;
1857:
1858: loopid = lp - fcp->portdb;
1859: if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) {
1860: continue;
1861: }
1862:
1863: /*
1864: * Anything here?
1865: */
1866: if (lp->port_wwn == 0) {
1867: continue;
1868: }
1869:
1870: /*
1871: * Don't try to log into yourself.
1872: */
1873: if ((portid = lp->portid) == fcp->isp_portid) {
1874: continue;
1875: }
1876:
1877:
1878: /*
1879: * If we'd been logged in- see if we still are and we haven't
1880: * changed. If so, no need to log ourselves out, etc..
1881: *
1882: * Unfortunately, our charming Qlogic f/w has decided to
1883: * return a valid port database entry for a fabric device
1884: * that has, in fact, gone away. And it hangs trying to
1885: * log it out.
1886: */
1887: if (lp->loggedin && lp->force_logout == 0 &&
1888: isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1889: int nrole;
1890: u_int64_t nwwnn, nwwpn;
1891: nwwnn =
1892: (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
1893: (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
1894: (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
1895: (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
1896: (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
1897: (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
1898: (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
1899: (((u_int64_t)pdb.pdb_nodename[7]));
1900: nwwpn =
1901: (((u_int64_t)pdb.pdb_portname[0]) << 56) |
1902: (((u_int64_t)pdb.pdb_portname[1]) << 48) |
1903: (((u_int64_t)pdb.pdb_portname[2]) << 40) |
1904: (((u_int64_t)pdb.pdb_portname[3]) << 32) |
1905: (((u_int64_t)pdb.pdb_portname[4]) << 24) |
1906: (((u_int64_t)pdb.pdb_portname[5]) << 16) |
1907: (((u_int64_t)pdb.pdb_portname[6]) << 8) |
1908: (((u_int64_t)pdb.pdb_portname[7]));
1909: nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
1910: SVC3_ROLE_SHIFT;
1911: if (pdb.pdb_loopid == lp->loopid && lp->portid ==
1912: (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) &&
1913: nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
1914: lp->roles == nrole && lp->force_logout == 0) {
1915: lp->loggedin = lp->valid = 1;
1916: isp_prt(isp, ISP_LOGCONFIG, lretained,
1917: (int) (lp - fcp->portdb),
1918: (int) lp->loopid, lp->portid);
1919: continue;
1920: }
1921: }
1922:
1923: if (fcp->isp_fwstate != FW_READY ||
1924: fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1925: return (-1);
1926: }
1927:
1928: /*
1929: * Force a logout if we were logged in.
1930: */
1931: if (lp->loggedin) {
1932: if (lp->force_logout ||
1933: isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1934: mbs.param[0] = MBOX_FABRIC_LOGOUT;
1935: mbs.param[1] = lp->loopid << 8;
1936: mbs.param[2] = 0;
1937: mbs.param[3] = 0;
1938: isp_mboxcmd(isp, &mbs, MBLOGNONE);
1939: isp_prt(isp, ISP_LOGINFO, plogout,
1940: (int) (lp - fcp->portdb), lp->loopid,
1941: lp->portid);
1942: }
1943: lp->force_logout = lp->loggedin = 0;
1944: if (fcp->isp_fwstate != FW_READY ||
1945: fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1946: return (-1);
1947: }
1948: }
1949:
1950: /*
1951: * And log in....
1952: */
1953: loopid = lp - fcp->portdb;
1954: lp->loopid = FL_PORT_ID;
1955: do {
1956: mbs.param[0] = MBOX_FABRIC_LOGIN;
1957: mbs.param[1] = loopid << 8;
1958: mbs.param[2] = portid >> 16;
1959: mbs.param[3] = portid & 0xffff;
1960: isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
1961: MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
1962: if (fcp->isp_fwstate != FW_READY ||
1963: fcp->isp_loopstate != LOOP_SYNCING_PDB) {
1964: return (-1);
1965: }
1966: switch (mbs.param[0]) {
1967: case MBOX_LOOP_ID_USED:
1968: /*
1969: * Try the next available loop id.
1970: */
1971: loopid++;
1972: break;
1973: case MBOX_PORT_ID_USED:
1974: /*
1975: * This port is already logged in.
1976: * Snaffle the loop id it's using if it's
1977: * nonzero, otherwise we're hosed.
1978: */
1979: if (mbs.param[1] != 0) {
1980: loopid = mbs.param[1];
1981: isp_prt(isp, ISP_LOGINFO, retained,
1982: loopid, (int) (lp - fcp->portdb),
1983: lp->portid);
1984: } else {
1985: loopid = MAX_FC_TARG;
1986: break;
1987: }
1988: /* FALLTHROUGH */
1989: case MBOX_COMMAND_COMPLETE:
1990: lp->loggedin = 1;
1991: lp->loopid = loopid;
1992: break;
1993: case MBOX_COMMAND_ERROR:
1994: isp_prt(isp, ISP_LOGINFO, plogierr,
1995: portid, mbs.param[1]);
1996: /* FALLTHROUGH */
1997: case MBOX_ALL_IDS_USED: /* We're outta IDs */
1998: default:
1999: loopid = MAX_FC_TARG;
2000: break;
2001: }
2002: } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
2003:
2004: /*
2005: * If we get here and we haven't set a Loop ID,
2006: * we failed to log into this device.
2007: */
2008:
2009: if (lp->loopid == FL_PORT_ID) {
2010: lp->loopid = 0;
2011: continue;
2012: }
2013:
2014: /*
2015: * Make sure we can get the appropriate port information.
2016: */
2017: if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
2018: isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
2019: goto dump_em;
2020: }
2021:
2022: if (fcp->isp_fwstate != FW_READY ||
2023: fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2024: return (-1);
2025: }
2026:
2027: if (pdb.pdb_loopid != lp->loopid) {
2028: isp_prt(isp, ISP_LOGWARN, pdbmfail1,
2029: lp->portid, pdb.pdb_loopid);
2030: goto dump_em;
2031: }
2032:
2033: if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
2034: isp_prt(isp, ISP_LOGWARN, pdbmfail2,
2035: lp->portid, BITS2WORD(pdb.pdb_portid_bits));
2036: goto dump_em;
2037: }
2038:
2039: lp->roles =
2040: (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2041: lp->node_wwn =
2042: (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
2043: (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
2044: (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
2045: (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
2046: (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
2047: (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
2048: (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
2049: (((u_int64_t)pdb.pdb_nodename[7]));
2050: lp->port_wwn =
2051: (((u_int64_t)pdb.pdb_portname[0]) << 56) |
2052: (((u_int64_t)pdb.pdb_portname[1]) << 48) |
2053: (((u_int64_t)pdb.pdb_portname[2]) << 40) |
2054: (((u_int64_t)pdb.pdb_portname[3]) << 32) |
2055: (((u_int64_t)pdb.pdb_portname[4]) << 24) |
2056: (((u_int64_t)pdb.pdb_portname[5]) << 16) |
2057: (((u_int64_t)pdb.pdb_portname[6]) << 8) |
2058: (((u_int64_t)pdb.pdb_portname[7]));
2059: /*
2060: * Check to make sure this all makes sense.
2061: */
2062: if (lp->node_wwn && lp->port_wwn) {
2063: lp->valid = 1;
2064: loopid = lp - fcp->portdb;
2065: (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2066: continue;
2067: }
2068: dump_em:
2069: lp->valid = 0;
2070: isp_prt(isp, ISP_LOGINFO,
2071: ldumped, loopid, lp->loopid, lp->portid);
2072: mbs.param[0] = MBOX_FABRIC_LOGOUT;
2073: mbs.param[1] = lp->loopid << 8;
2074: mbs.param[2] = 0;
2075: mbs.param[3] = 0;
2076: isp_mboxcmd(isp, &mbs, MBLOGNONE);
2077: if (fcp->isp_fwstate != FW_READY ||
2078: fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2079: return (-1);
2080: }
2081: }
2082: /*
2083: * If we get here, we've for sure seen not only a valid loop
2084: * but know what is or isn't on it, so mark this for usage
2085: * in isp_start.
2086: */
2087: fcp->loop_seen_once = 1;
2088: fcp->isp_loopstate = LOOP_READY;
2089: return (0);
2090: }
2091:
2092: static int
2093: isp_scan_loop(struct ispsoftc *isp)
2094: {
2095: struct lportdb *lp;
2096: fcparam *fcp = isp->isp_param;
2097: isp_pdb_t pdb;
2098: int loopid, lim, hival;
2099:
2100: switch (fcp->isp_topo) {
2101: case TOPO_NL_PORT:
2102: hival = FL_PORT_ID;
2103: break;
2104: case TOPO_N_PORT:
2105: hival = 2;
2106: break;
2107: case TOPO_FL_PORT:
2108: hival = FC_PORT_ID;
2109: break;
2110: default:
2111: fcp->isp_loopstate = LOOP_LSCAN_DONE;
2112: return (0);
2113: }
2114: fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2115:
2116: /*
2117: * make sure the temp port database is clean...
2118: */
2119: MEMZERO((void *)fcp->tport, sizeof (fcp->tport));
2120:
2121: /*
2122: * Run through the local loop ports and get port database info
2123: * for each loop ID.
2124: *
2125: * There's a somewhat unexplained situation where the f/w passes back
2126: * the wrong database entity- if that happens, just restart (up to
2127: * FL_PORT_ID times).
2128: */
2129: for (lim = loopid = 0; loopid < hival; loopid++) {
2130: lp = &fcp->tport[loopid];
2131:
2132: /*
2133: * Don't even try for ourselves...
2134: */
2135: if (loopid == fcp->isp_loopid)
2136: continue;
2137:
2138: lp->node_wwn = isp_get_portname(isp, loopid, 1);
2139: if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2140: return (-1);
2141: if (lp->node_wwn == 0)
2142: continue;
2143: lp->port_wwn = isp_get_portname(isp, loopid, 0);
2144: if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2145: return (-1);
2146: if (lp->port_wwn == 0) {
2147: lp->node_wwn = 0;
2148: continue;
2149: }
2150:
2151: /*
2152: * Get an entry....
2153: */
2154: if (isp_getpdb(isp, loopid, &pdb) != 0) {
2155: if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2156: return (-1);
2157: continue;
2158: }
2159: if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2160: return (-1);
2161: }
2162:
2163: /*
2164: * If the returned database element doesn't match what we
2165: * asked for, restart the process entirely (up to a point...).
2166: */
2167: if (pdb.pdb_loopid != loopid) {
2168: loopid = 0;
2169: if (lim++ < hival) {
2170: continue;
2171: }
2172: isp_prt(isp, ISP_LOGWARN,
2173: "giving up on synchronizing the port database");
2174: return (-1);
2175: }
2176:
2177: /*
2178: * Save the pertinent info locally.
2179: */
2180: lp->node_wwn =
2181: (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
2182: (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
2183: (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
2184: (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
2185: (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
2186: (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
2187: (((u_int64_t)pdb.pdb_nodename[6]) << 8) |
2188: (((u_int64_t)pdb.pdb_nodename[7]));
2189: lp->port_wwn =
2190: (((u_int64_t)pdb.pdb_portname[0]) << 56) |
2191: (((u_int64_t)pdb.pdb_portname[1]) << 48) |
2192: (((u_int64_t)pdb.pdb_portname[2]) << 40) |
2193: (((u_int64_t)pdb.pdb_portname[3]) << 32) |
2194: (((u_int64_t)pdb.pdb_portname[4]) << 24) |
2195: (((u_int64_t)pdb.pdb_portname[5]) << 16) |
2196: (((u_int64_t)pdb.pdb_portname[6]) << 8) |
2197: (((u_int64_t)pdb.pdb_portname[7]));
2198: lp->roles =
2199: (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2200: lp->portid = BITS2WORD(pdb.pdb_portid_bits);
2201: lp->loopid = pdb.pdb_loopid;
2202: }
2203:
2204: /*
2205: * Mark all of the permanent local loop database entries as invalid
2206: * (except our own entry).
2207: */
2208: for (loopid = 0; loopid < hival; loopid++) {
2209: if (loopid == fcp->isp_iid) {
2210: fcp->portdb[loopid].valid = 1;
2211: fcp->portdb[loopid].loopid = fcp->isp_loopid;
2212: continue;
2213: }
2214: fcp->portdb[loopid].valid = 0;
2215: }
2216:
2217: /*
2218: * Now merge our local copy of the port database into our saved copy.
2219: * Notify the outer layers of new devices arriving.
2220: */
2221: for (loopid = 0; loopid < hival; loopid++) {
2222: int i;
2223:
2224: /*
2225: * If we don't have a non-zero Port WWN, we're not here.
2226: */
2227: if (fcp->tport[loopid].port_wwn == 0) {
2228: continue;
2229: }
2230:
2231: /*
2232: * Skip ourselves.
2233: */
2234: if (loopid == fcp->isp_iid) {
2235: continue;
2236: }
2237:
2238: /*
2239: * For the purposes of deciding whether this is the
2240: * 'same' device or not, we only search for an identical
2241: * Port WWN. Node WWNs may or may not be the same as
2242: * the Port WWN, and there may be multiple different
2243: * Port WWNs with the same Node WWN. It would be chaos
2244: * to have multiple identical Port WWNs, so we don't
2245: * allow that.
2246: */
2247:
2248: for (i = 0; i < hival; i++) {
2249: int j;
2250: if (fcp->portdb[i].port_wwn == 0)
2251: continue;
2252: if (fcp->portdb[i].port_wwn !=
2253: fcp->tport[loopid].port_wwn)
2254: continue;
2255: /*
2256: * We found this WWN elsewhere- it's changed
2257: * loopids then. We don't change its actual
2258: * position in our cached port database- we
2259: * just change the actual loop ID we'd use.
2260: */
2261: if (fcp->portdb[i].loopid != loopid) {
2262: isp_prt(isp, ISP_LOGINFO, portshift, i,
2263: fcp->portdb[i].loopid,
2264: fcp->portdb[i].portid, loopid,
2265: fcp->tport[loopid].portid);
2266: }
2267: fcp->portdb[i].portid = fcp->tport[loopid].portid;
2268: fcp->portdb[i].loopid = loopid;
2269: fcp->portdb[i].valid = 1;
2270: fcp->portdb[i].roles = fcp->tport[loopid].roles;
2271:
2272: /*
2273: * Now make sure this Port WWN doesn't exist elsewhere
2274: * in the port database.
2275: */
2276: for (j = i+1; j < hival; j++) {
2277: if (fcp->portdb[i].port_wwn !=
2278: fcp->portdb[j].port_wwn) {
2279: continue;
2280: }
2281: isp_prt(isp, ISP_LOGWARN, portdup, j, i);
2282: /*
2283: * Invalidate the 'old' *and* 'new' ones.
2284: * This is really harsh and not quite right,
2285: * but if this happens, we really don't know
2286: * who is what at this point.
2287: */
2288: fcp->portdb[i].valid = 0;
2289: fcp->portdb[j].valid = 0;
2290: }
2291: break;
2292: }
2293:
2294: /*
2295: * If we didn't traverse the entire port database,
2296: * then we found (and remapped) an existing entry.
2297: * No need to notify anyone- go for the next one.
2298: */
2299: if (i < hival) {
2300: isp_prt(isp, ISP_LOGINFO, retained,
2301: fcp->portdb[i].loopid, i, fcp->portdb[i].portid);
2302: continue;
2303: }
2304:
2305: /*
2306: * We've not found this Port WWN anywhere. It's a new entry.
2307: * See if we can leave it where it is (with target == loopid).
2308: */
2309: if (fcp->portdb[loopid].port_wwn != 0) {
2310: for (lim = 0; lim < hival; lim++) {
2311: if (fcp->portdb[lim].port_wwn == 0)
2312: break;
2313: }
2314: /* "Cannot Happen" */
2315: if (lim == hival) {
2316: isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
2317: continue;
2318: }
2319: i = lim;
2320: } else {
2321: i = loopid;
2322: }
2323:
2324: /*
2325: * NB: The actual loopid we use here is loopid- we may
2326: * in fact be at a completely different index (target).
2327: */
2328: fcp->portdb[i].loopid = loopid;
2329: fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn;
2330: fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn;
2331: fcp->portdb[i].roles = fcp->tport[loopid].roles;
2332: fcp->portdb[i].portid = fcp->tport[loopid].portid;
2333: fcp->portdb[i].valid = 1;
2334:
2335: /*
2336: * Tell the outside world we've arrived.
2337: */
2338: (void) isp_async(isp, ISPASYNC_PROMENADE, &i);
2339: }
2340:
2341: /*
2342: * Now find all previously used targets that are now invalid and
2343: * notify the outer layers that they're gone.
2344: */
2345: for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
2346: if (lp->valid || lp->port_wwn == 0) {
2347: continue;
2348: }
2349:
2350: /*
2351: * Tell the outside world we've gone
2352: * away and erase our pdb entry.
2353: *
2354: */
2355: loopid = lp - fcp->portdb;
2356: (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2357: MEMZERO((void *) lp, sizeof (*lp));
2358: }
2359: fcp->isp_loopstate = LOOP_LSCAN_DONE;
2360: return (0);
2361: }
2362:
2363:
2364: static int
2365: isp_fabric_mbox_cmd(struct ispsoftc *isp, mbreg_t *mbp)
2366: {
2367: isp_mboxcmd(isp, mbp, MBLOGNONE);
2368: if (mbp->param[0] != MBOX_COMMAND_COMPLETE) {
2369: if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) {
2370: FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
2371: }
2372: if (mbp->param[0] == MBOX_COMMAND_ERROR) {
2373: char tbuf[16];
2374: char *m;
2375: switch (mbp->param[1]) {
2376: case 1:
2377: m = "No Loop";
2378: break;
2379: case 2:
2380: m = "Failed to allocate IOCB buffer";
2381: break;
2382: case 3:
2383: m = "Failed to allocate XCB buffer";
2384: break;
2385: case 4:
2386: m = "timeout or transmit failed";
2387: break;
2388: case 5:
2389: m = "no fabric loop";
2390: break;
2391: case 6:
2392: m = "remote device not a target";
2393: break;
2394: default:
2395: SNPRINTF(tbuf, sizeof tbuf, "%x",
2396: mbp->param[1]);
2397: m = tbuf;
2398: break;
2399: }
2400: isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m);
2401: }
2402: return (-1);
2403: }
2404:
2405: if (FCPARAM(isp)->isp_fwstate != FW_READY ||
2406: FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) {
2407: return (-1);
2408: }
2409: return(0);
2410: }
2411:
2412: #ifdef ISP_USE_GA_NXT
2413: static int
2414: isp_scan_fabric(struct ispsoftc *isp, int ftype)
2415: {
2416: fcparam *fcp = isp->isp_param;
2417: u_int32_t portid, first_portid, last_portid;
2418: int hicap, last_port_same;
2419:
2420: if (fcp->isp_onfabric == 0) {
2421: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2422: return (0);
2423: }
2424:
2425: FC_SCRATCH_ACQUIRE(isp);
2426:
2427: /*
2428: * Since Port IDs are 24 bits, we can check against having seen
2429: * anything yet with this value.
2430: */
2431: last_port_same = 0;
2432: last_portid = 0xffffffff; /* not a port */
2433: first_portid = portid = fcp->isp_portid;
2434: fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2435:
2436: for (hicap = 0; hicap < GA_NXT_MAX; hicap++) {
2437: mbreg_t mbs;
2438: sns_screq_t *rq;
2439: sns_ga_nxt_rsp_t *rs0, *rs1;
2440: struct lportdb lcl;
2441: u_int8_t sc[SNS_GA_NXT_RESP_SIZE];
2442:
2443: rq = (sns_screq_t *)sc;
2444: MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE);
2445: rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1;
2446: rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100);
2447: rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100);
2448: rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100);
2449: rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100);
2450: rq->snscb_sblen = 6;
2451: rq->snscb_data[0] = SNS_GA_NXT;
2452: rq->snscb_data[4] = portid & 0xffff;
2453: rq->snscb_data[5] = (portid >> 16) & 0xff;
2454: isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch);
2455: MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE);
2456: mbs.param[0] = MBOX_SEND_SNS;
2457: mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1;
2458: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2459: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2460: /*
2461: * Leave 4 and 5 alone
2462: */
2463: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2464: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2465: if (isp_fabric_mbox_cmd(isp, &mbs)) {
2466: if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2467: fcp->isp_loopstate = LOOP_PDB_RCVD;
2468: }
2469: FC_SCRATCH_RELEASE(isp);
2470: return (-1);
2471: }
2472: MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE);
2473: rs1 = (sns_ga_nxt_rsp_t *) sc;
2474: rs0 = (sns_ga_nxt_rsp_t *) ((u_int8_t *)fcp->isp_scratch+0x100);
2475: isp_get_ga_nxt_response(isp, rs0, rs1);
2476: if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2477: int level;
2478: if (rs1->snscb_cthdr.ct_reason == 9 &&
2479: rs1->snscb_cthdr.ct_explanation == 7)
2480: level = ISP_LOGDEBUG0;
2481: else
2482: level = ISP_LOGWARN;
2483: isp_prt(isp, level, swrej, "GA_NXT",
2484: rs1->snscb_cthdr.ct_reason,
2485: rs1->snscb_cthdr.ct_explanation, portid);
2486: FC_SCRATCH_RELEASE(isp);
2487: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2488: return (0);
2489: }
2490: portid =
2491: (((u_int32_t) rs1->snscb_port_id[0]) << 16) |
2492: (((u_int32_t) rs1->snscb_port_id[1]) << 8) |
2493: (((u_int32_t) rs1->snscb_port_id[2]));
2494:
2495: /*
2496: * XXX: We should check to make sure that this entry
2497: * XXX: supports the type(s) we are interested in.
2498: */
2499: /*
2500: * Okay, we now have information about a fabric object.
2501: * If it is the type we're interested in, tell the outer layers
2502: * about it. The outer layer needs to know: Port ID, WWNN,
2503: * WWPN, FC4 type, and port type.
2504: *
2505: * The lportdb structure is adequate for this.
2506: */
2507: MEMZERO(&lcl, sizeof (lcl));
2508: lcl.port_type = rs1->snscb_port_type;
2509: lcl.fc4_type = ftype;
2510: lcl.portid = portid;
2511: lcl.node_wwn =
2512: (((u_int64_t)rs1->snscb_nodename[0]) << 56) |
2513: (((u_int64_t)rs1->snscb_nodename[1]) << 48) |
2514: (((u_int64_t)rs1->snscb_nodename[2]) << 40) |
2515: (((u_int64_t)rs1->snscb_nodename[3]) << 32) |
2516: (((u_int64_t)rs1->snscb_nodename[4]) << 24) |
2517: (((u_int64_t)rs1->snscb_nodename[5]) << 16) |
2518: (((u_int64_t)rs1->snscb_nodename[6]) << 8) |
2519: (((u_int64_t)rs1->snscb_nodename[7]));
2520: lcl.port_wwn =
2521: (((u_int64_t)rs1->snscb_portname[0]) << 56) |
2522: (((u_int64_t)rs1->snscb_portname[1]) << 48) |
2523: (((u_int64_t)rs1->snscb_portname[2]) << 40) |
2524: (((u_int64_t)rs1->snscb_portname[3]) << 32) |
2525: (((u_int64_t)rs1->snscb_portname[4]) << 24) |
2526: (((u_int64_t)rs1->snscb_portname[5]) << 16) |
2527: (((u_int64_t)rs1->snscb_portname[6]) << 8) |
2528: (((u_int64_t)rs1->snscb_portname[7]));
2529:
2530: /*
2531: * Does this fabric object support the type we want?
2532: * If not, skip it.
2533: */
2534: if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) {
2535: if (first_portid == portid) {
2536: lcl.last_fabric_dev = 1;
2537: } else {
2538: lcl.last_fabric_dev = 0;
2539: }
2540: (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2541: } else {
2542: isp_prt(isp, ISP_LOGDEBUG0,
2543: "PortID 0x%x doesn't support FC4 type 0x%x",
2544: portid, ftype);
2545: }
2546: if (first_portid == portid) {
2547: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2548: FC_SCRATCH_RELEASE(isp);
2549: return (0);
2550: }
2551: if (portid == last_portid) {
2552: if (last_port_same++ > 20) {
2553: isp_prt(isp, ISP_LOGWARN,
2554: "tangled fabric database detected");
2555: break;
2556: }
2557: } else {
2558: last_port_same = 0 ;
2559: last_portid = portid;
2560: }
2561: }
2562: FC_SCRATCH_RELEASE(isp);
2563: if (hicap >= GA_NXT_MAX) {
2564: isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX);
2565: }
2566: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2567: return (0);
2568: }
2569: #else
2570: #define GIDLEN ((ISP2100_SCRLEN >> 1) + 16)
2571: #define NGENT ((GIDLEN - 16) >> 2)
2572:
2573: #define IGPOFF (ISP2100_SCRLEN - GIDLEN)
2574: #define GXOFF (256)
2575:
2576: static int
2577: isp_scan_fabric(struct ispsoftc *isp, int ftype)
2578: {
2579: fcparam *fcp = FCPARAM(isp);
2580: mbreg_t mbs;
2581: int i;
2582: sns_gid_ft_req_t *rq;
2583: sns_gid_ft_rsp_t *rs0, *rs1;
2584:
2585: if (fcp->isp_onfabric == 0) {
2586: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2587: return (0);
2588: }
2589:
2590: FC_SCRATCH_ACQUIRE(isp);
2591: fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2592:
2593: rq = (sns_gid_ft_req_t *)fcp->tport;
2594: MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE);
2595: rq->snscb_rblen = GIDLEN >> 1;
2596: rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF);
2597: rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF);
2598: rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF);
2599: rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF);
2600: rq->snscb_sblen = 6;
2601: rq->snscb_cmd = SNS_GID_FT;
2602: rq->snscb_mword_div_2 = NGENT;
2603: rq->snscb_fc4_type = ftype;
2604: isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch);
2605: MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
2606: mbs.param[0] = MBOX_SEND_SNS;
2607: mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
2608: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2609: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2610:
2611: /*
2612: * Leave 4 and 5 alone
2613: */
2614: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2615: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2616: if (isp_fabric_mbox_cmd(isp, &mbs)) {
2617: if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2618: fcp->isp_loopstate = LOOP_PDB_RCVD;
2619: }
2620: FC_SCRATCH_RELEASE(isp);
2621: return (-1);
2622: }
2623: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2624: FC_SCRATCH_RELEASE(isp);
2625: return (-1);
2626: }
2627: MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
2628: rs1 = (sns_gid_ft_rsp_t *) fcp->tport;
2629: rs0 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+IGPOFF);
2630: isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
2631: if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2632: int level;
2633: if (rs1->snscb_cthdr.ct_reason == 9 &&
2634: rs1->snscb_cthdr.ct_explanation == 7)
2635: level = ISP_LOGDEBUG0;
2636: else
2637: level = ISP_LOGWARN;
2638: isp_prt(isp, level, swrej, "GID_FT",
2639: rs1->snscb_cthdr.ct_reason,
2640: rs1->snscb_cthdr.ct_explanation, 0);
2641: FC_SCRATCH_RELEASE(isp);
2642: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2643: return (0);
2644: }
2645:
2646: /*
2647: * Okay, we now have a list of Port IDs for this class of device.
2648: * Go through the list and for each one get the WWPN/WWNN for it
2649: * and tell the outer layers about it. The outer layer needs to
2650: * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type.
2651: *
2652: * The lportdb structure is adequate for this.
2653: */
2654: i = -1;
2655: do {
2656: sns_gxn_id_req_t grqbuf, *gq = &grqbuf;
2657: sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf;
2658: struct lportdb lcl;
2659: #if 0
2660: sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf;
2661: #endif
2662:
2663: i++;
2664: MEMZERO(&lcl, sizeof (lcl));
2665: lcl.fc4_type = ftype;
2666: lcl.portid =
2667: (((u_int32_t) rs1->snscb_ports[i].portid[0]) << 16) |
2668: (((u_int32_t) rs1->snscb_ports[i].portid[1]) << 8) |
2669: (((u_int32_t) rs1->snscb_ports[i].portid[2]));
2670:
2671: MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2672: gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2673: gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2674: gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2675: gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2676: gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2677: gq->snscb_sblen = 6;
2678: gq->snscb_cmd = SNS_GPN_ID;
2679: gq->snscb_portid = lcl.portid;
2680: isp_put_gxn_id_request(isp, gq,
2681: (sns_gxn_id_req_t *) fcp->isp_scratch);
2682: MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2683: mbs.param[0] = MBOX_SEND_SNS;
2684: mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2685: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2686: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2687: /*
2688: * Leave 4 and 5 alone
2689: */
2690: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2691: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2692: if (isp_fabric_mbox_cmd(isp, &mbs)) {
2693: if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2694: fcp->isp_loopstate = LOOP_PDB_RCVD;
2695: }
2696: FC_SCRATCH_RELEASE(isp);
2697: return (-1);
2698: }
2699: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2700: FC_SCRATCH_RELEASE(isp);
2701: return (-1);
2702: }
2703: MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2704: gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2705: isp_get_gxn_id_response(isp, gs0, gs1);
2706: if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2707: isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID",
2708: gs1->snscb_cthdr.ct_reason,
2709: gs1->snscb_cthdr.ct_explanation, lcl.portid);
2710: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2711: FC_SCRATCH_RELEASE(isp);
2712: return (-1);
2713: }
2714: continue;
2715: }
2716: lcl.port_wwn =
2717: (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
2718: (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
2719: (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
2720: (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
2721: (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
2722: (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
2723: (((u_int64_t)gs1->snscb_wwn[6]) << 8) |
2724: (((u_int64_t)gs1->snscb_wwn[7]));
2725:
2726: MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2727: gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2728: gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2729: gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2730: gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2731: gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2732: gq->snscb_sblen = 6;
2733: gq->snscb_cmd = SNS_GNN_ID;
2734: gq->snscb_portid = lcl.portid;
2735: isp_put_gxn_id_request(isp, gq,
2736: (sns_gxn_id_req_t *) fcp->isp_scratch);
2737: MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2738: mbs.param[0] = MBOX_SEND_SNS;
2739: mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2740: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2741: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2742: /*
2743: * Leave 4 and 5 alone
2744: */
2745: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2746: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2747: if (isp_fabric_mbox_cmd(isp, &mbs)) {
2748: if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2749: fcp->isp_loopstate = LOOP_PDB_RCVD;
2750: }
2751: FC_SCRATCH_RELEASE(isp);
2752: return (-1);
2753: }
2754: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2755: FC_SCRATCH_RELEASE(isp);
2756: return (-1);
2757: }
2758: MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2759: gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2760: isp_get_gxn_id_response(isp, gs0, gs1);
2761: if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2762: isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID",
2763: gs1->snscb_cthdr.ct_reason,
2764: gs1->snscb_cthdr.ct_explanation, lcl.portid);
2765: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2766: FC_SCRATCH_RELEASE(isp);
2767: return (-1);
2768: }
2769: continue;
2770: }
2771: lcl.node_wwn =
2772: (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
2773: (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
2774: (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
2775: (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
2776: (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
2777: (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
2778: (((u_int64_t)gs1->snscb_wwn[6]) << 8) |
2779: (((u_int64_t)gs1->snscb_wwn[7]));
2780:
2781: /*
2782: * The QLogic f/w is bouncing this with a parameter error.
2783: */
2784: #if 0
2785: /*
2786: * Try and get FC4 Features (FC-GS-3 only).
2787: * We can use the sns_gxn_id_req_t for this request.
2788: */
2789: MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2790: gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1;
2791: gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2792: gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2793: gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2794: gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2795: gq->snscb_sblen = 6;
2796: gq->snscb_cmd = SNS_GFF_ID;
2797: gq->snscb_portid = lcl.portid;
2798: isp_put_gxn_id_request(isp, gq,
2799: (sns_gxn_id_req_t *) fcp->isp_scratch);
2800: MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2801: mbs.param[0] = MBOX_SEND_SNS;
2802: mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2803: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2804: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2805: /*
2806: * Leave 4 and 5 alone
2807: */
2808: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2809: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2810: if (isp_fabric_mbox_cmd(isp, &mbs)) {
2811: if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2812: fcp->isp_loopstate = LOOP_PDB_RCVD;
2813: }
2814: FC_SCRATCH_RELEASE(isp);
2815: return (-1);
2816: }
2817: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2818: FC_SCRATCH_RELEASE(isp);
2819: return (-1);
2820: }
2821: MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE);
2822: fs0 = (sns_gff_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
2823: isp_get_gff_id_response(isp, fs0, fs1);
2824: if (fs1->snscb_cthdr.ct_response != FS_ACC) {
2825: isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN,
2826: swrej, "GFF_ID",
2827: fs1->snscb_cthdr.ct_reason,
2828: fs1->snscb_cthdr.ct_explanation, lcl.portid);
2829: if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2830: FC_SCRATCH_RELEASE(isp);
2831: return (-1);
2832: }
2833: } else {
2834: int index = (ftype >> 3);
2835: int bshft = (ftype & 0x7) * 4;
2836: int fc4_fval =
2837: (fs1->snscb_fc4_features[index] >> bshft) & 0xf;
2838: if (fc4_fval & 0x1) {
2839: lcl.roles |=
2840: (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT);
2841: }
2842: if (fc4_fval & 0x2) {
2843: lcl.roles |=
2844: (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT);
2845: }
2846: }
2847: #endif
2848:
2849: /*
2850: * If we really want to know what kind of port type this is,
2851: * we have to run another CT command. Otherwise, we'll leave
2852: * it as undefined.
2853: *
2854: lcl.port_type = 0;
2855: */
2856: if (rs1->snscb_ports[i].control & 0x80) {
2857: lcl.last_fabric_dev = 1;
2858: } else {
2859: lcl.last_fabric_dev = 0;
2860: }
2861: (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2862:
2863: } while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1);
2864:
2865: /*
2866: * If we're not at the last entry, our list isn't big enough.
2867: */
2868: if ((rs1->snscb_ports[i].control & 0x80) == 0) {
2869: isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area");
2870: }
2871:
2872: FC_SCRATCH_RELEASE(isp);
2873: fcp->isp_loopstate = LOOP_FSCAN_DONE;
2874: return (0);
2875: }
2876: #endif
2877:
2878: static void
2879: isp_register_fc4_type(struct ispsoftc *isp)
2880: {
2881: fcparam *fcp = isp->isp_param;
2882: u_int8_t local[SNS_RFT_ID_REQ_SIZE];
2883: sns_screq_t *reqp = (sns_screq_t *) local;
2884: mbreg_t mbs;
2885:
2886: MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
2887: reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
2888: reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
2889: reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
2890: reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
2891: reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
2892: reqp->snscb_sblen = 22;
2893: reqp->snscb_data[0] = SNS_RFT_ID;
2894: reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
2895: reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
2896: reqp->snscb_data[6] = (1 << FC4_SCSI);
2897: #if 0
2898: reqp->snscb_data[6] |= (1 << FC4_IP); /* ISO/IEC 8802-2 LLC/SNAP */
2899: #endif
2900: FC_SCRATCH_ACQUIRE(isp);
2901: isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
2902: mbs.param[0] = MBOX_SEND_SNS;
2903: mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
2904: mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2905: mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2906: /*
2907: * Leave 4 and 5 alone
2908: */
2909: mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2910: mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2911: isp_mboxcmd(isp, &mbs, MBLOGALL);
2912: FC_SCRATCH_RELEASE(isp);
2913: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2914: isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded");
2915: }
2916: }
2917:
2918: /*
2919: * Start a command. Locking is assumed done in the caller.
2920: */
2921:
2922: int
2923: isp_start(XS_T *xs)
2924: {
2925: struct ispsoftc *isp;
2926: u_int16_t nxti, optr, handle;
2927: u_int8_t local[QENTRY_LEN];
2928: ispreq_t *reqp, *qep;
2929: int target, i;
2930:
2931: XS_INITERR(xs);
2932: isp = XS_ISP(xs);
2933:
2934: /*
2935: * Check to make sure we're supporting initiator role.
2936: */
2937: if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
2938: XS_SETERR(xs, HBA_SELTIMEOUT);
2939: return (CMD_COMPLETE);
2940: }
2941:
2942: /*
2943: * Now make sure we're running.
2944: */
2945:
2946: if (isp->isp_state != ISP_RUNSTATE) {
2947: isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
2948: XS_SETERR(xs, HBA_BOTCH);
2949: return (CMD_COMPLETE);
2950: }
2951:
2952: /*
2953: * Check command CDB length, etc.. We really are limited to 16 bytes
2954: * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
2955: * but probably only if we're running fairly new firmware (we'll
2956: * let the old f/w choke on an extended command queue entry).
2957: */
2958:
2959: if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
2960: isp_prt(isp, ISP_LOGERR,
2961: "unsupported cdb length (%d, CDB[0]=0x%x)",
2962: XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
2963: XS_SETERR(xs, HBA_BOTCH);
2964: return (CMD_COMPLETE);
2965: }
2966:
2967: /*
2968: * Check to see whether we have good firmware state still or
2969: * need to refresh our port database for this target.
2970: */
2971: target = XS_TGT(xs);
2972: if (IS_FC(isp)) {
2973: fcparam *fcp = isp->isp_param;
2974: struct lportdb *lp;
2975: #ifdef HANDLE_LOOPSTATE_IN_OUTER_LAYERS
2976: if (fcp->isp_fwstate != FW_READY ||
2977: fcp->isp_loopstate != LOOP_READY) {
2978: return (CMD_RQLATER);
2979: }
2980:
2981: /*
2982: * If we're not on a Fabric, we can't have a target
2983: * above FL_PORT_ID-1.
2984: *
2985: * If we're on a fabric and *not* connected as an F-port,
2986: * we can't have a target less than FC_SNS_ID+1. This
2987: * keeps us from having to sort out the difference between
2988: * local public loop devices and those which we might get
2989: * from a switch's database.
2990: */
2991: if (fcp->isp_onfabric == 0) {
2992: if (target >= FL_PORT_ID) {
2993: XS_SETERR(xs, HBA_SELTIMEOUT);
2994: return (CMD_COMPLETE);
2995: }
2996: } else {
2997: if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
2998: XS_SETERR(xs, HBA_SELTIMEOUT);
2999: return (CMD_COMPLETE);
3000: }
3001: /*
3002: * We used to exclude having local loop ports
3003: * at the same time that we have fabric ports.
3004: * That is, we used to exclude having ports
3005: * at < FL_PORT_ID if we're FL-port.
3006: *
3007: * That's wrong. The only thing that could be
3008: * dicey is if the switch you're connected to
3009: * has these local loop ports appear on the
3010: * fabric and we somehow attach them twice.
3011: */
3012: }
3013: #else
3014: /*
3015: * Check for f/w being in ready state. If the f/w
3016: * isn't in ready state, then we don't know our
3017: * loop ID and the f/w hasn't completed logging
3018: * into all targets on the loop. If this is the
3019: * case, then bounce the command. We pretend this is
3020: * a SELECTION TIMEOUT error if we've never gone to
3021: * FW_READY state at all- in this case we may not
3022: * be hooked to a loop at all and we shouldn't hang
3023: * the machine for this. Otherwise, defer this command
3024: * until later.
3025: */
3026: if (fcp->isp_fwstate != FW_READY) {
3027: /*
3028: * Give ourselves at most a 250ms delay.
3029: */
3030: if (isp_fclink_test(isp, 250000)) {
3031: XS_SETERR(xs, HBA_SELTIMEOUT);
3032: if (fcp->loop_seen_once) {
3033: return (CMD_RQLATER);
3034: } else {
3035: return (CMD_COMPLETE);
3036: }
3037: }
3038: }
3039:
3040: /*
3041: * If we're not on a Fabric, we can't have a target
3042: * above FL_PORT_ID-1.
3043: *
3044: * If we're on a fabric and *not* connected as an F-port,
3045: * we can't have a target less than FC_SNS_ID+1. This
3046: * keeps us from having to sort out the difference between
3047: * local public loop devices and those which we might get
3048: * from a switch's database.
3049: */
3050: if (fcp->isp_onfabric == 0) {
3051: if (target >= FL_PORT_ID) {
3052: XS_SETERR(xs, HBA_SELTIMEOUT);
3053: return (CMD_COMPLETE);
3054: }
3055: } else {
3056: if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
3057: XS_SETERR(xs, HBA_SELTIMEOUT);
3058: return (CMD_COMPLETE);
3059: }
3060: if (fcp->isp_topo != TOPO_F_PORT &&
3061: target < FL_PORT_ID) {
3062: XS_SETERR(xs, HBA_SELTIMEOUT);
3063: return (CMD_COMPLETE);
3064: }
3065: }
3066:
3067: /*
3068: * If our loop state is such that we haven't yet received
3069: * a "Port Database Changed" notification (after a LIP or
3070: * a Loop Reset or firmware initialization), then defer
3071: * sending commands for a little while, but only if we've
3072: * seen a valid loop at one point (otherwise we can get
3073: * stuck at initialization time).
3074: */
3075: if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
3076: XS_SETERR(xs, HBA_SELTIMEOUT);
3077: if (fcp->loop_seen_once) {
3078: return (CMD_RQLATER);
3079: } else {
3080: return (CMD_COMPLETE);
3081: }
3082: }
3083:
3084: /*
3085: * If we're in the middle of loop or fabric scanning
3086: * or merging the port databases, retry this command later.
3087: */
3088: if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC ||
3089: fcp->isp_loopstate == LOOP_SCANNING_LOOP ||
3090: fcp->isp_loopstate == LOOP_SYNCING_PDB) {
3091: return (CMD_RQLATER);
3092: }
3093:
3094: /*
3095: * If our loop state is now such that we've just now
3096: * received a Port Database Change notification, then
3097: * we have to go off and (re)scan the fabric. We back
3098: * out and try again later if this doesn't work.
3099: */
3100: if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) {
3101: if (isp_scan_fabric(isp, FC4_SCSI)) {
3102: return (CMD_RQLATER);
3103: }
3104: if (fcp->isp_fwstate != FW_READY ||
3105: fcp->isp_loopstate < LOOP_FSCAN_DONE) {
3106: return (CMD_RQLATER);
3107: }
3108: }
3109:
3110: /*
3111: * If our loop state is now such that we've just now
3112: * received a Port Database Change notification, then
3113: * we have to go off and (re)synchronize our port
3114: * database.
3115: */
3116: if (fcp->isp_loopstate < LOOP_READY) {
3117: if (isp_pdb_sync(isp)) {
3118: return (CMD_RQLATER);
3119: }
3120: if (fcp->isp_fwstate != FW_READY ||
3121: fcp->isp_loopstate != LOOP_READY) {
3122: return (CMD_RQLATER);
3123: }
3124: }
3125:
3126: /*
3127: * XXX: Here's were we would cancel any loop_dead flag
3128: * XXX: also cancel in dead_loop timeout that's running
3129: */
3130: #endif
3131:
3132: /*
3133: * Now check whether we should even think about pursuing this.
3134: */
3135: lp = &fcp->portdb[target];
3136: if (lp->valid == 0) {
3137: XS_SETERR(xs, HBA_SELTIMEOUT);
3138: return (CMD_COMPLETE);
3139: }
3140: if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
3141: isp_prt(isp, ISP_LOGDEBUG2,
3142: "Target %d does not have target service", target);
3143: XS_SETERR(xs, HBA_SELTIMEOUT);
3144: return (CMD_COMPLETE);
3145: }
3146: /*
3147: * Now turn target into what the actual Loop ID is.
3148: */
3149: target = lp->loopid;
3150: xs->sc_link->node_wwn = lp->node_wwn;
3151: xs->sc_link->port_wwn = lp->port_wwn;
3152:
3153: }
3154:
3155: /*
3156: * Next check to see if any HBA or Device
3157: * parameters need to be updated.
3158: */
3159: if (isp->isp_update != 0) {
3160: isp_update(isp);
3161: }
3162:
3163: if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
3164: isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
3165: XS_SETERR(xs, HBA_BOTCH);
3166: return (CMD_EAGAIN);
3167: }
3168:
3169: /*
3170: * Now see if we need to synchronize the ISP with respect to anything.
3171: * We do dual duty here (cough) for synchronizing for busses other
3172: * than which we got here to send a command to.
3173: */
3174: reqp = (ispreq_t *) local;
3175: if (isp->isp_sendmarker) {
3176: u_int8_t n = (IS_DUALBUS(isp)? 2: 1);
3177: /*
3178: * Check ports to send markers for...
3179: */
3180: for (i = 0; i < n; i++) {
3181: if ((isp->isp_sendmarker & (1 << i)) == 0) {
3182: continue;
3183: }
3184: MEMZERO((void *) reqp, QENTRY_LEN);
3185: reqp->req_header.rqs_entry_count = 1;
3186: reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
3187: reqp->req_modifier = SYNC_ALL;
3188: reqp->req_target = i << 7; /* insert bus number */
3189: isp_put_request(isp, reqp, qep);
3190: ISP_ADD_REQUEST(isp, nxti);
3191: isp->isp_sendmarker &= ~(1 << i);
3192: if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) {
3193: isp_prt(isp, ISP_LOGDEBUG0,
3194: "Request Queue Overflow+");
3195: XS_SETERR(xs, HBA_BOTCH);
3196: return (CMD_EAGAIN);
3197: }
3198: }
3199: }
3200:
3201: MEMZERO((void *)reqp, QENTRY_LEN);
3202: reqp->req_header.rqs_entry_count = 1;
3203: if (IS_FC(isp)) {
3204: reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
3205: } else {
3206: if (XS_CDBLEN(xs) > 12)
3207: reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
3208: else
3209: reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
3210: }
3211: /* reqp->req_header.rqs_flags = 0; */
3212: /* reqp->req_header.rqs_seqno = 0; */
3213: if (IS_FC(isp)) {
3214: /*
3215: * See comment in isp_intr
3216: */
3217: /* XS_RESID(xs) = 0; */
3218:
3219: /*
3220: * Fibre Channel always requires some kind of tag.
3221: * The Qlogic drivers seem be happy not to use a tag,
3222: * but this breaks for some devices (IBM drives).
3223: */
3224: if (XS_TAG_P(xs)) {
3225: ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
3226: } else {
3227: /*
3228: * If we don't know what tag to use, use HEAD OF QUEUE
3229: * for Request Sense or Simple.
3230: */
3231: if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
3232: ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
3233: else
3234: ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
3235: }
3236: } else {
3237: sdparam *sdp = (sdparam *)isp->isp_param;
3238: sdp += XS_CHANNEL(xs);
3239: if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
3240: XS_TAG_P(xs)) {
3241: reqp->req_flags = XS_TAG_TYPE(xs);
3242: }
3243: }
3244: reqp->req_target = target | (XS_CHANNEL(xs) << 7);
3245: if (IS_SCSI(isp)) {
3246: reqp->req_lun_trn = XS_LUN(xs);
3247: reqp->req_cdblen = XS_CDBLEN(xs);
3248: } else {
3249: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)
3250: ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
3251: else
3252: ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
3253: }
3254: MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
3255:
3256: reqp->req_time = XS_TIME(xs) / 1000;
3257: if (reqp->req_time == 0 && XS_TIME(xs)) {
3258: reqp->req_time = 1;
3259: }
3260:
3261: if (isp_save_xs(isp, xs, &handle)) {
3262: isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
3263: XS_SETERR(xs, HBA_BOTCH);
3264: return (CMD_EAGAIN);
3265: }
3266: reqp->req_handle = handle;
3267:
3268: /*
3269: * Set up DMA and/or do any bus swizzling of the request entry
3270: * so that the Qlogic F/W understands what is being asked of it.
3271: */
3272: i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
3273: if (i != CMD_QUEUED) {
3274: isp_destroy_handle(isp, handle);
3275: /*
3276: * dmasetup sets actual error in packet, and
3277: * return what we were given to return.
3278: */
3279: return (i);
3280: }
3281: XS_SETERR(xs, HBA_NOERROR);
3282: isp_prt(isp, ISP_LOGDEBUG2,
3283: "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
3284: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
3285: (long) XS_XFRLEN(xs));
3286: ISP_ADD_REQUEST(isp, nxti);
3287: isp->isp_nactive++;
3288: return (CMD_QUEUED);
3289: }
3290:
3291: /*
3292: * isp control
3293: * Locks (ints blocked) assumed held.
3294: */
3295:
3296: int
3297: isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
3298: {
3299: XS_T *xs;
3300: mbreg_t mbs;
3301: int bus, tgt;
3302: u_int16_t handle;
3303:
3304: switch (ctl) {
3305: default:
3306: isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
3307: break;
3308:
3309: case ISPCTL_RESET_BUS:
3310: /*
3311: * Issue a bus reset.
3312: */
3313: mbs.param[0] = MBOX_BUS_RESET;
3314: mbs.param[2] = 0;
3315: if (IS_SCSI(isp)) {
3316: mbs.param[1] =
3317: ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
3318: if (mbs.param[1] < 2)
3319: mbs.param[1] = 2;
3320: bus = *((int *) arg);
3321: if (IS_DUALBUS(isp))
3322: mbs.param[2] = bus;
3323: } else {
3324: mbs.param[1] = 10;
3325: bus = 0;
3326: }
3327: isp->isp_sendmarker |= (1 << bus);
3328: isp_mboxcmd(isp, &mbs, MBLOGALL);
3329: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3330: break;
3331: }
3332: isp_prt(isp, ISP_LOGINFO,
3333: "driver initiated bus reset of bus %d", bus);
3334: return (0);
3335:
3336: case ISPCTL_RESET_DEV:
3337: tgt = (*((int *) arg)) & 0xffff;
3338: bus = (*((int *) arg)) >> 16;
3339: mbs.param[0] = MBOX_ABORT_TARGET;
3340: mbs.param[1] = (tgt << 8) | (bus << 15);
3341: mbs.param[2] = 3; /* 'delay', in seconds */
3342: isp_mboxcmd(isp, &mbs, MBLOGALL);
3343: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3344: break;
3345: }
3346: isp_prt(isp, ISP_LOGINFO,
3347: "Target %d on Bus %d Reset Succeeded", tgt, bus);
3348: isp->isp_sendmarker |= (1 << bus);
3349: return (0);
3350:
3351: case ISPCTL_ABORT_CMD:
3352: xs = (XS_T *) arg;
3353: tgt = XS_TGT(xs);
3354: handle = isp_find_handle(isp, xs);
3355: if (handle == 0) {
3356: isp_prt(isp, ISP_LOGWARN,
3357: "cannot find handle for command to abort");
3358: break;
3359: }
3360: bus = XS_CHANNEL(xs);
3361: mbs.param[0] = MBOX_ABORT;
3362: if (IS_FC(isp)) {
3363: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
3364: mbs.param[1] = tgt << 8;
3365: mbs.param[4] = 0;
3366: mbs.param[5] = 0;
3367: mbs.param[6] = XS_LUN(xs);
3368: } else {
3369: mbs.param[1] = tgt << 8 | XS_LUN(xs);
3370: }
3371: } else {
3372: mbs.param[1] =
3373: (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
3374: }
3375: mbs.param[3] = 0;
3376: mbs.param[2] = handle;
3377: isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
3378: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3379: return (0);
3380: }
3381: /*
3382: * XXX: Look for command in the REQUEST QUEUE. That is,
3383: * XXX: It hasn't been picked up by firmware yet.
3384: */
3385: break;
3386:
3387: case ISPCTL_UPDATE_PARAMS:
3388:
3389: isp_update(isp);
3390: return (0);
3391:
3392: case ISPCTL_FCLINK_TEST:
3393:
3394: if (IS_FC(isp)) {
3395: int usdelay = (arg)? *((int *) arg) : 250000;
3396: return (isp_fclink_test(isp, usdelay));
3397: }
3398: break;
3399:
3400: case ISPCTL_SCAN_FABRIC:
3401:
3402: if (IS_FC(isp)) {
3403: int ftype = (arg)? *((int *) arg) : FC4_SCSI;
3404: return (isp_scan_fabric(isp, ftype));
3405: }
3406: break;
3407:
3408: case ISPCTL_SCAN_LOOP:
3409:
3410: if (IS_FC(isp)) {
3411: return (isp_scan_loop(isp));
3412: }
3413: break;
3414:
3415: case ISPCTL_PDB_SYNC:
3416:
3417: if (IS_FC(isp)) {
3418: return (isp_pdb_sync(isp));
3419: }
3420: break;
3421:
3422: case ISPCTL_SEND_LIP:
3423:
3424: if (IS_FC(isp)) {
3425: mbs.param[0] = MBOX_INIT_LIP;
3426: isp_mboxcmd(isp, &mbs, MBLOGALL);
3427: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3428: return (0);
3429: }
3430: }
3431: break;
3432:
3433: case ISPCTL_GET_POSMAP:
3434:
3435: if (IS_FC(isp) && arg) {
3436: return (isp_getmap(isp, arg));
3437: }
3438: break;
3439:
3440: case ISPCTL_RUN_MBOXCMD:
3441:
3442: isp_mboxcmd(isp, arg, MBLOGALL);
3443: return(0);
3444:
3445: #ifdef ISP_TARGET_MODE
3446: case ISPCTL_TOGGLE_TMODE:
3447: {
3448:
3449: /*
3450: * We don't check/set against role here- that's the
3451: * responsibility for the outer layer to coordinate.
3452: */
3453: if (IS_SCSI(isp)) {
3454: int param = *(int *)arg;
3455: mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
3456: mbs.param[1] = param & 0xffff;
3457: mbs.param[2] = param >> 16;
3458: isp_mboxcmd(isp, &mbs, MBLOGALL);
3459: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3460: break;
3461: }
3462: }
3463: return (0);
3464: }
3465: #endif
3466: }
3467: return (-1);
3468: }
3469:
3470: /*
3471: * Interrupt Service Routine(s).
3472: *
3473: * External (OS) framework has done the appropriate locking,
3474: * and the locking will be held throughout this function.
3475: */
3476:
3477: /*
3478: * Limit our stack depth by sticking with the max likely number
3479: * of completions on a request queue at any one time.
3480: */
3481: #ifndef MAX_REQUESTQ_COMPLETIONS
3482: #define MAX_REQUESTQ_COMPLETIONS 64
3483: #endif
3484:
3485: void
3486: isp_intr(struct ispsoftc *isp, u_int16_t isr, u_int16_t sema, u_int16_t mbox)
3487: {
3488: XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
3489: u_int16_t iptr, optr, junk;
3490: int i, nlooked = 0, ndone = 0;
3491:
3492: again:
3493: /*
3494: * Is this a mailbox related interrupt?
3495: * The mailbox semaphore will be nonzero if so.
3496: */
3497: if (sema) {
3498: if (mbox & 0x4000) {
3499: isp->isp_intmboxc++;
3500: if (isp->isp_mboxbsy) {
3501: int i = 0, obits = isp->isp_obits;
3502: isp->isp_mboxtmp[i++] = mbox;
3503: for (i = 1; i < MAX_MAILBOX; i++) {
3504: if ((obits & (1 << i)) == 0) {
3505: continue;
3506: }
3507: isp->isp_mboxtmp[i] =
3508: ISP_READ(isp, MBOX_OFF(i));
3509: }
3510: if (isp->isp_mbxwrk0) {
3511: if (isp_mbox_continue(isp) == 0) {
3512: return;
3513: }
3514: }
3515: MBOX_NOTIFY_COMPLETE(isp);
3516: } else {
3517: isp_prt(isp, ISP_LOGWARN,
3518: "Mbox Command Async (0x%x) with no waiters",
3519: mbox);
3520: }
3521: } else if (isp_parse_async(isp, mbox) < 0) {
3522: return;
3523: }
3524: if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
3525: isp->isp_state != ISP_RUNSTATE) {
3526: ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3527: ISP_WRITE(isp, BIU_SEMA, 0);
3528: return;
3529: }
3530: }
3531:
3532: /*
3533: * We can't be getting this now.
3534: */
3535: if (isp->isp_state != ISP_RUNSTATE) {
3536: isp_prt(isp, ISP_LOGWARN,
3537: "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
3538: /*
3539: * Thank you very much! *Burrrp*!
3540: */
3541: WRITE_RESPONSE_QUEUE_OUT_POINTER(isp,
3542: READ_RESPONSE_QUEUE_IN_POINTER(isp));
3543:
3544: ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3545: ISP_WRITE(isp, BIU_SEMA, 0);
3546: return;
3547: }
3548:
3549: /*
3550: * Get the current Response Queue Out Pointer.
3551: *
3552: * If we're a 2300, we can ask what hardware what it thinks.
3553: */
3554: if (IS_23XX(isp)) {
3555: optr = ISP_READ(isp, isp->isp_respoutrp);
3556: /*
3557: * Debug: to be taken out eventually
3558: */
3559: if (isp->isp_residx != optr) {
3560: isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x",
3561: optr, isp->isp_residx);
3562: }
3563: } else {
3564: optr = isp->isp_residx;
3565: }
3566:
3567: /*
3568: * You *must* read the Response Queue In Pointer
3569: * prior to clearing the RISC interrupt.
3570: *
3571: * Debounce the 2300 if revision less than 2.
3572: */
3573: if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
3574: i = 0;
3575: do {
3576: iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3577: junk = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3578: } while (junk != iptr && ++i < 1000);
3579:
3580: if (iptr != junk) {
3581: ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3582: isp_prt(isp, ISP_LOGWARN,
3583: "Response Queue Out Pointer Unstable (%x, %x)",
3584: iptr, junk);
3585: return;
3586: }
3587: } else {
3588: iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3589: }
3590: isp->isp_resodx = iptr;
3591:
3592:
3593: if (optr == iptr && sema == 0) {
3594: /*
3595: * There are a lot of these- reasons unknown- mostly on
3596: * faster Alpha machines.
3597: *
3598: * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
3599: * make sure the old interrupt went away (to avoid 'ringing'
3600: * effects), but that didn't stop this from occurring.
3601: */
3602: if (IS_23XX(isp)) {
3603: USEC_DELAY(100);
3604: iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3605: junk = ISP_READ(isp, BIU_R2HSTSLO);
3606: } else {
3607: junk = ISP_READ(isp, BIU_ISR);
3608: }
3609: if (optr == iptr) {
3610: if (IS_23XX(isp)) {
3611: ;
3612: } else {
3613: sema = ISP_READ(isp, BIU_SEMA);
3614: mbox = ISP_READ(isp, OUTMAILBOX0);
3615: if ((sema & 0x3) && (mbox & 0x8000)) {
3616: goto again;
3617: }
3618: }
3619: isp->isp_intbogus++;
3620: isp_prt(isp, ISP_LOGDEBUG1,
3621: "bogus intr- isr %x (%x) iptr %x optr %x",
3622: isr, junk, iptr, optr);
3623: }
3624: }
3625: isp->isp_resodx = iptr;
3626: ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3627: ISP_WRITE(isp, BIU_SEMA, 0);
3628:
3629: if (isp->isp_rspbsy) {
3630: return;
3631: }
3632: isp->isp_rspbsy = 1;
3633:
3634: while (optr != iptr) {
3635: ispstatusreq_t local, *sp = &local;
3636: isphdr_t *hp;
3637: int type;
3638: u_int16_t oop;
3639: int buddaboom = 0;
3640:
3641: hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
3642: oop = optr;
3643: optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
3644: nlooked++;
3645: /*
3646: * Synchronize our view of this response queue entry.
3647: */
3648: MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
3649:
3650: type = isp_get_response_type(isp, hp);
3651:
3652: if (type == RQSTYPE_RESPONSE) {
3653: isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3654: } else if (type == RQSTYPE_RIO2) {
3655: isp_rio2_t rio;
3656: isp_get_rio2(isp, (isp_rio2_t *) hp, &rio);
3657: for (i = 0; i < rio.req_header.rqs_seqno; i++) {
3658: isp_fastpost_complete(isp, rio.req_handles[i]);
3659: }
3660: if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno)
3661: isp->isp_fpcchiwater = rio.req_header.rqs_seqno;
3662: MEMZERO(hp, QENTRY_LEN); /* PERF */
3663: continue;
3664: } else {
3665: /*
3666: * Somebody reachable via isp_handle_other_response
3667: * may have updated the response queue pointers for
3668: * us, so we reload our goal index.
3669: */
3670: if (isp_handle_other_response(isp, type, hp, &optr)) {
3671: iptr = isp->isp_resodx;
3672: MEMZERO(hp, QENTRY_LEN); /* PERF */
3673: continue;
3674: }
3675:
3676: /*
3677: * After this point, we'll just look at the header as
3678: * we don't know how to deal with the rest of the
3679: * response.
3680: */
3681: isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3682:
3683: /*
3684: * It really has to be a bounced request just copied
3685: * from the request queue to the response queue. If
3686: * not, something bad has happened.
3687: */
3688: if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
3689: isp_prt(isp, ISP_LOGERR, notresp,
3690: sp->req_header.rqs_entry_type, oop, optr,
3691: nlooked);
3692: if (isp->isp_dblev & ISP_LOGDEBUG0) {
3693: isp_print_bytes(isp, "Queue Entry",
3694: QENTRY_LEN, sp);
3695: }
3696: MEMZERO(hp, QENTRY_LEN); /* PERF */
3697: continue;
3698: }
3699: buddaboom = 1;
3700: }
3701:
3702: if (sp->req_header.rqs_flags & 0xf) {
3703: #define _RQS_OFLAGS \
3704: ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
3705: if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
3706: isp_prt(isp, ISP_LOGWARN,
3707: "continuation segment");
3708: WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3709: continue;
3710: }
3711: if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3712: isp_prt(isp, ISP_LOGDEBUG1,
3713: "internal queues full");
3714: /*
3715: * We'll synthesize a QUEUE FULL message below.
3716: */
3717: }
3718: if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
3719: isp_prt(isp, ISP_LOGERR, "bad header flag");
3720: buddaboom++;
3721: }
3722: if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
3723: isp_prt(isp, ISP_LOGERR, "bad request packet");
3724: buddaboom++;
3725: }
3726: if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
3727: isp_prt(isp, ISP_LOGERR,
3728: "unknown flags (0x%x) in response",
3729: sp->req_header.rqs_flags);
3730: buddaboom++;
3731: }
3732: #undef _RQS_OFLAGS
3733: }
3734: if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
3735: MEMZERO(hp, QENTRY_LEN); /* PERF */
3736: isp_prt(isp, ISP_LOGERR,
3737: "bad request handle %d (type 0x%x, flags 0x%x)",
3738: sp->req_handle, sp->req_header.rqs_entry_type,
3739: sp->req_header.rqs_flags);
3740: WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3741: continue;
3742: }
3743: xs = isp_find_xs(isp, sp->req_handle);
3744: if (xs == NULL) {
3745: u_int8_t ts = sp->req_completion_status & 0xff;
3746: MEMZERO(hp, QENTRY_LEN); /* PERF */
3747: /*
3748: * Only whine if this isn't the expected fallout of
3749: * aborting the command.
3750: */
3751: if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
3752: isp_prt(isp, ISP_LOGERR,
3753: "cannot find handle 0x%x (type 0x%x)",
3754: sp->req_handle,
3755: sp->req_header.rqs_entry_type);
3756: } else if (ts != RQCS_ABORTED) {
3757: isp_prt(isp, ISP_LOGERR,
3758: "cannot find handle 0x%x (status 0x%x)",
3759: sp->req_handle, ts);
3760: }
3761: WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3762: continue;
3763: }
3764: isp_destroy_handle(isp, sp->req_handle);
3765: if (sp->req_status_flags & RQSTF_BUS_RESET) {
3766: XS_SETERR(xs, HBA_BUSRESET);
3767: isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
3768: }
3769: if (buddaboom) {
3770: XS_SETERR(xs, HBA_BOTCH);
3771: }
3772:
3773: if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
3774: /*
3775: * Fibre Channel F/W doesn't say we got status
3776: * if there's Sense Data instead. I guess they
3777: * think it goes w/o saying.
3778: */
3779: sp->req_state_flags |= RQSF_GOT_STATUS;
3780: }
3781: if (sp->req_state_flags & RQSF_GOT_STATUS) {
3782: *XS_STSP(xs) = sp->req_scsi_status & 0xff;
3783: }
3784:
3785: switch (sp->req_header.rqs_entry_type) {
3786: case RQSTYPE_RESPONSE:
3787: XS_SET_STATE_STAT(isp, xs, sp);
3788: isp_parse_status(isp, sp, xs);
3789: if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
3790: (*XS_STSP(xs) == SCSI_BUSY)) {
3791: XS_SETERR(xs, HBA_TGTBSY);
3792: }
3793: if (IS_SCSI(isp)) {
3794: XS_RESID(xs) = sp->req_resid;
3795: if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3796: (*XS_STSP(xs) == SCSI_CHECK) &&
3797: (sp->req_state_flags & RQSF_GOT_SENSE)) {
3798: XS_SAVE_SENSE(xs, sp);
3799: }
3800: /*
3801: * A new synchronous rate was negotiated for
3802: * this target. Mark state such that we'll go
3803: * look up that which has changed later.
3804: */
3805: if (sp->req_status_flags & RQSTF_NEGOTIATION) {
3806: int t = XS_TGT(xs);
3807: sdparam *sdp = isp->isp_param;
3808: sdp += XS_CHANNEL(xs);
3809: sdp->isp_devparam[t].dev_refresh = 1;
3810: isp->isp_update |=
3811: (1 << XS_CHANNEL(xs));
3812: }
3813: } else {
3814: if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
3815: XS_RESID(xs) = 0;
3816: } else if (sp->req_scsi_status & RQCS_RESID) {
3817: XS_RESID(xs) = sp->req_resid;
3818: } else {
3819: XS_RESID(xs) = 0;
3820: }
3821: if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3822: (*XS_STSP(xs) == SCSI_CHECK) &&
3823: (sp->req_scsi_status & RQCS_SV)) {
3824: XS_SAVE_SENSE(xs, sp);
3825: /* solely for the benefit of debug */
3826: sp->req_state_flags |= RQSF_GOT_SENSE;
3827: }
3828: }
3829: isp_prt(isp, ISP_LOGDEBUG2,
3830: "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
3831: (long) sp->req_resid);
3832: break;
3833: case RQSTYPE_REQUEST:
3834: if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3835: /*
3836: * Force Queue Full status.
3837: */
3838: *XS_STSP(xs) = SCSI_QFULL;
3839: XS_SETERR(xs, HBA_NOERROR);
3840: } else if (XS_NOERR(xs)) {
3841: /*
3842: * ????
3843: */
3844: isp_prt(isp, ISP_LOGDEBUG0,
3845: "Request Queue Entry bounced back");
3846: XS_SETERR(xs, HBA_BOTCH);
3847: }
3848: XS_RESID(xs) = XS_XFRLEN(xs);
3849: break;
3850: default:
3851: isp_prt(isp, ISP_LOGWARN,
3852: "unhandled response queue type 0x%x",
3853: sp->req_header.rqs_entry_type);
3854: if (XS_NOERR(xs)) {
3855: XS_SETERR(xs, HBA_BOTCH);
3856: }
3857: break;
3858: }
3859:
3860: /*
3861: * Free any dma resources. As a side effect, this may
3862: * also do any cache flushing necessary for data coherence. */
3863: if (XS_XFRLEN(xs)) {
3864: ISP_DMAFREE(isp, xs, sp->req_handle);
3865: }
3866:
3867: if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
3868: ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
3869: (*XS_STSP(xs) != SCSI_GOOD)))) {
3870: char skey;
3871: if (sp->req_state_flags & RQSF_GOT_SENSE) {
3872: skey = XS_SNSKEY(xs) & 0xf;
3873: if (skey < 10)
3874: skey += '0';
3875: else
3876: skey += 'a' - 10;
3877: } else if (*XS_STSP(xs) == SCSI_CHECK) {
3878: skey = '?';
3879: } else {
3880: skey = '.';
3881: }
3882: isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
3883: XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs),
3884: (ulong)XS_RESID(xs),
3885: *XS_STSP(xs), skey, XS_ERR(xs));
3886: }
3887:
3888: if (isp->isp_nactive > 0)
3889: isp->isp_nactive--;
3890: complist[ndone++] = xs; /* defer completion call until later */
3891: MEMZERO(hp, QENTRY_LEN); /* PERF */
3892: if (ndone == MAX_REQUESTQ_COMPLETIONS) {
3893: break;
3894: }
3895: }
3896:
3897: /*
3898: * If we looked at any commands, then it's valid to find out
3899: * what the outpointer is. It also is a trigger to update the
3900: * ISP's notion of what we've seen so far.
3901: */
3902: if (nlooked) {
3903: WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3904: /*
3905: * While we're at it, read the request queue out pointer.
3906: */
3907: isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
3908: if (isp->isp_rscchiwater < ndone)
3909: isp->isp_rscchiwater = ndone;
3910: }
3911:
3912: isp->isp_residx = optr;
3913: isp->isp_rspbsy = 0;
3914: for (i = 0; i < ndone; i++) {
3915: xs = complist[i];
3916: if (xs) {
3917: isp->isp_rsltccmplt++;
3918: isp_done(xs);
3919: }
3920: }
3921: }
3922:
3923: /*
3924: * Support routines.
3925: */
3926:
3927: static int
3928: isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
3929: {
3930: int rval = 0;
3931: int bus;
3932:
3933: if (IS_DUALBUS(isp)) {
3934: bus = ISP_READ(isp, OUTMAILBOX6);
3935: } else {
3936: bus = 0;
3937: }
3938: isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
3939:
3940: switch (mbox) {
3941: case ASYNC_BUS_RESET:
3942: isp->isp_sendmarker |= (1 << bus);
3943: #ifdef ISP_TARGET_MODE
3944: if (isp_target_async(isp, bus, mbox))
3945: rval = -1;
3946: #endif
3947: isp_async(isp, ISPASYNC_BUS_RESET, &bus);
3948: break;
3949: case ASYNC_SYSTEM_ERROR:
3950: #ifdef ISP_FW_CRASH_DUMP
3951: /*
3952: * If we have crash dumps enabled, it's up to the handler
3953: * for isp_async to reinit stuff and restart the firmware
3954: * after performing the crash dump. The reason we do things
3955: * this way is that we may need to activate a kernel thread
3956: * to do all the crash dump goop.
3957: */
3958: isp_async(isp, ISPASYNC_FW_CRASH, NULL);
3959: #else
3960: isp_async(isp, ISPASYNC_FW_CRASH, NULL);
3961: isp_reinit(isp);
3962: isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
3963: #endif
3964: rval = -1;
3965: break;
3966:
3967: case ASYNC_RQS_XFER_ERR:
3968: isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
3969: break;
3970:
3971: case ASYNC_RSP_XFER_ERR:
3972: isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
3973: break;
3974:
3975: case ASYNC_QWAKEUP:
3976: /*
3977: * We've just been notified that the Queue has woken up.
3978: * We don't need to be chatty about this- just unlatch things
3979: * and move on.
3980: */
3981: mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp);
3982: break;
3983:
3984: case ASYNC_TIMEOUT_RESET:
3985: isp_prt(isp, ISP_LOGWARN,
3986: "timeout initiated SCSI bus reset of bus %d", bus);
3987: isp->isp_sendmarker |= (1 << bus);
3988: #ifdef ISP_TARGET_MODE
3989: if (isp_target_async(isp, bus, mbox))
3990: rval = -1;
3991: #endif
3992: break;
3993:
3994: case ASYNC_DEVICE_RESET:
3995: isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
3996: isp->isp_sendmarker |= (1 << bus);
3997: #ifdef ISP_TARGET_MODE
3998: if (isp_target_async(isp, bus, mbox))
3999: rval = -1;
4000: #endif
4001: break;
4002:
4003: case ASYNC_EXTMSG_UNDERRUN:
4004: isp_prt(isp, ISP_LOGWARN, "extended message underrun");
4005: break;
4006:
4007: case ASYNC_SCAM_INT:
4008: isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
4009: break;
4010:
4011: case ASYNC_HUNG_SCSI:
4012: isp_prt(isp, ISP_LOGERR,
4013: "stalled SCSI Bus after DATA Overrun");
4014: /* XXX: Need to issue SCSI reset at this point */
4015: break;
4016:
4017: case ASYNC_KILLED_BUS:
4018: isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
4019: break;
4020:
4021: case ASYNC_BUS_TRANSIT:
4022: mbox = ISP_READ(isp, OUTMAILBOX2);
4023: switch (mbox & 0x1c00) {
4024: case SXP_PINS_LVD_MODE:
4025: isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
4026: SDPARAM(isp)->isp_diffmode = 0;
4027: SDPARAM(isp)->isp_ultramode = 0;
4028: SDPARAM(isp)->isp_lvdmode = 1;
4029: break;
4030: case SXP_PINS_HVD_MODE:
4031: isp_prt(isp, ISP_LOGINFO,
4032: "Transition to Differential mode");
4033: SDPARAM(isp)->isp_diffmode = 1;
4034: SDPARAM(isp)->isp_ultramode = 0;
4035: SDPARAM(isp)->isp_lvdmode = 0;
4036: break;
4037: case SXP_PINS_SE_MODE:
4038: isp_prt(isp, ISP_LOGINFO,
4039: "Transition to Single Ended mode");
4040: SDPARAM(isp)->isp_diffmode = 0;
4041: SDPARAM(isp)->isp_ultramode = 1;
4042: SDPARAM(isp)->isp_lvdmode = 0;
4043: break;
4044: default:
4045: isp_prt(isp, ISP_LOGWARN,
4046: "Transition to Unknown Mode 0x%x", mbox);
4047: break;
4048: }
4049: /*
4050: * XXX: Set up to renegotiate again!
4051: */
4052: /* Can only be for a 1080... */
4053: isp->isp_sendmarker |= (1 << bus);
4054: break;
4055:
4056: /*
4057: * We can use bus, which will always be zero for FC cards,
4058: * as a mailbox pattern accumulator to be checked below.
4059: */
4060: case ASYNC_RIO5:
4061: bus = 0x1ce; /* outgoing mailbox regs 1-3, 6-7 */
4062: break;
4063:
4064: case ASYNC_RIO4:
4065: bus = 0x14e; /* outgoing mailbox regs 1-3, 6 */
4066: break;
4067:
4068: case ASYNC_RIO3:
4069: bus = 0x10e; /* outgoing mailbox regs 1-3 */
4070: break;
4071:
4072: case ASYNC_RIO2:
4073: bus = 0x106; /* outgoing mailbox regs 1-2 */
4074: break;
4075:
4076: case ASYNC_RIO1:
4077: case ASYNC_CMD_CMPLT:
4078: bus = 0x102; /* outgoing mailbox regs 1 */
4079: break;
4080:
4081: case ASYNC_RIO_RESP:
4082: return (rval);
4083:
4084: case ASYNC_CTIO_DONE:
4085: {
4086: #ifdef ISP_TARGET_MODE
4087: int handle =
4088: (ISP_READ(isp, OUTMAILBOX2) << 16) |
4089: (ISP_READ(isp, OUTMAILBOX1));
4090: if (isp_target_async(isp, handle, mbox))
4091: rval = -1;
4092: #else
4093: isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
4094: #endif
4095: isp->isp_fphccmplt++; /* count it as a fast posting intr */
4096: break;
4097: }
4098: case ASYNC_LIP_F8:
4099: case ASYNC_LIP_OCCURRED:
4100: FCPARAM(isp)->isp_lipseq =
4101: ISP_READ(isp, OUTMAILBOX1);
4102: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4103: FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4104: isp->isp_sendmarker = 1;
4105: isp_mark_getpdb_all(isp);
4106: isp_async(isp, ISPASYNC_LIP, NULL);
4107: #ifdef ISP_TARGET_MODE
4108: if (isp_target_async(isp, bus, mbox))
4109: rval = -1;
4110: #endif
4111: /*
4112: * We've had problems with data corruption occurring on
4113: * commands that complete (with no apparent error) after
4114: * we receive a LIP. This has been observed mostly on
4115: * Local Loop topologies. To be safe, let's just mark
4116: * all active commands as dead.
4117: */
4118: if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
4119: FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
4120: int i, j;
4121: for (i = j = 0; i < isp->isp_maxcmds; i++) {
4122: XS_T *xs;
4123: xs = isp->isp_xflist[i];
4124: if (xs != NULL) {
4125: j++;
4126: XS_SETERR(xs, HBA_BUSRESET);
4127: }
4128: }
4129: if (j) {
4130: isp_prt(isp, ISP_LOGERR,
4131: "LIP destroyed %d active commands", j);
4132: }
4133: }
4134: break;
4135:
4136: case ASYNC_LOOP_UP:
4137: isp->isp_sendmarker = 1;
4138: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4139: FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4140: isp_mark_getpdb_all(isp);
4141: isp_async(isp, ISPASYNC_LOOP_UP, NULL);
4142: #ifdef ISP_TARGET_MODE
4143: if (isp_target_async(isp, bus, mbox))
4144: rval = -1;
4145: #endif
4146: break;
4147:
4148: case ASYNC_LOOP_DOWN:
4149: isp->isp_sendmarker = 1;
4150: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4151: FCPARAM(isp)->isp_loopstate = LOOP_NIL;
4152: isp_mark_getpdb_all(isp);
4153: isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
4154: #ifdef ISP_TARGET_MODE
4155: if (isp_target_async(isp, bus, mbox))
4156: rval = -1;
4157: #endif
4158: break;
4159:
4160: case ASYNC_LOOP_RESET:
4161: isp->isp_sendmarker = 1;
4162: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4163: FCPARAM(isp)->isp_loopstate = LOOP_NIL;
4164: isp_mark_getpdb_all(isp);
4165: isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
4166: #ifdef ISP_TARGET_MODE
4167: if (isp_target_async(isp, bus, mbox))
4168: rval = -1;
4169: #endif
4170: break;
4171:
4172: case ASYNC_PDB_CHANGED:
4173: isp->isp_sendmarker = 1;
4174: FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4175: isp_mark_getpdb_all(isp);
4176: isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
4177: break;
4178:
4179: case ASYNC_CHANGE_NOTIFY:
4180: /*
4181: * Not correct, but it will force us to rescan the loop.
4182: */
4183: FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4184: isp_mark_getpdb_all(isp);
4185: isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
4186: break;
4187:
4188: case ASYNC_PTPMODE:
4189: if (FCPARAM(isp)->isp_onfabric)
4190: FCPARAM(isp)->isp_topo = TOPO_F_PORT;
4191: else
4192: FCPARAM(isp)->isp_topo = TOPO_N_PORT;
4193: isp_mark_getpdb_all(isp);
4194: isp->isp_sendmarker = 1;
4195: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4196: FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4197: isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4198: #ifdef ISP_TARGET_MODE
4199: if (isp_target_async(isp, bus, mbox))
4200: rval = -1;
4201: #endif
4202: isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
4203: break;
4204:
4205: case ASYNC_CONNMODE:
4206: mbox = ISP_READ(isp, OUTMAILBOX1);
4207: isp_mark_getpdb_all(isp);
4208: switch (mbox) {
4209: case ISP_CONN_LOOP:
4210: isp_prt(isp, ISP_LOGINFO,
4211: "Point-to-Point -> Loop mode");
4212: break;
4213: case ISP_CONN_PTP:
4214: isp_prt(isp, ISP_LOGINFO,
4215: "Loop -> Point-to-Point mode");
4216: break;
4217: case ISP_CONN_BADLIP:
4218: isp_prt(isp, ISP_LOGWARN,
4219: "Point-to-Point -> Loop mode (BAD LIP)");
4220: break;
4221: case ISP_CONN_FATAL:
4222: isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
4223: #ifdef ISP_FW_CRASH_DUMP
4224: isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4225: #else
4226: isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4227: isp_reinit(isp);
4228: isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
4229: #endif
4230: return (-1);
4231: case ISP_CONN_LOOPBACK:
4232: isp_prt(isp, ISP_LOGWARN,
4233: "Looped Back in Point-to-Point mode");
4234: break;
4235: default:
4236: isp_prt(isp, ISP_LOGWARN,
4237: "Unknown connection mode (0x%x)", mbox);
4238: break;
4239: }
4240: isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4241: isp->isp_sendmarker = 1;
4242: FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4243: FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4244: break;
4245:
4246: default:
4247: isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
4248: break;
4249: }
4250:
4251: if (bus & 0x100) {
4252: int i, nh;
4253: u_int16_t handles[5];
4254:
4255: for (nh = 0, i = 1; i < MAX_MAILBOX; i++) {
4256: if ((bus & (1 << i)) == 0) {
4257: continue;
4258: }
4259: handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
4260: }
4261: for (i = 0; i < nh; i++) {
4262: isp_fastpost_complete(isp, handles[i]);
4263: isp_prt(isp, ISP_LOGDEBUG3,
4264: "fast post completion of %u", handles[i]);
4265: }
4266: if (isp->isp_fpcchiwater < nh)
4267: isp->isp_fpcchiwater = nh;
4268: } else {
4269: isp->isp_intoasync++;
4270: }
4271: return (rval);
4272: }
4273:
4274: /*
4275: * Handle other response entries. A pointer to the request queue output
4276: * index is here in case we want to eat several entries at once, although
4277: * this is not used currently.
4278: */
4279:
4280: static int
4281: isp_handle_other_response(struct ispsoftc *isp, int type,
4282: isphdr_t *hp, u_int16_t *optrp)
4283: {
4284: switch (type) {
4285: case RQSTYPE_STATUS_CONT:
4286: isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response");
4287: return (1);
4288: case RQSTYPE_ATIO:
4289: case RQSTYPE_CTIO:
4290: case RQSTYPE_ENABLE_LUN:
4291: case RQSTYPE_MODIFY_LUN:
4292: case RQSTYPE_NOTIFY:
4293: case RQSTYPE_NOTIFY_ACK:
4294: case RQSTYPE_CTIO1:
4295: case RQSTYPE_ATIO2:
4296: case RQSTYPE_CTIO2:
4297: case RQSTYPE_CTIO3:
4298: isp->isp_rsltccmplt++; /* count as a response completion */
4299: #ifdef ISP_TARGET_MODE
4300: if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
4301: return (1);
4302: }
4303: #endif
4304: /* FALLTHROUGH */
4305: case RQSTYPE_REQUEST:
4306: default:
4307: if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
4308: return (1);
4309: }
4310: isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
4311: isp_get_response_type(isp, hp));
4312: return (0);
4313: }
4314: }
4315:
4316: static void
4317: isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
4318: {
4319: switch (sp->req_completion_status & 0xff) {
4320: case RQCS_COMPLETE:
4321: if (XS_NOERR(xs)) {
4322: XS_SETERR(xs, HBA_NOERROR);
4323: }
4324: return;
4325:
4326: case RQCS_INCOMPLETE:
4327: if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
4328: isp_prt(isp, ISP_LOGDEBUG1,
4329: "Selection Timeout for %d.%d.%d",
4330: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4331: if (XS_NOERR(xs)) {
4332: XS_SETERR(xs, HBA_SELTIMEOUT);
4333: }
4334: return;
4335: }
4336: isp_prt(isp, ISP_LOGERR,
4337: "command incomplete for %d.%d.%d, state 0x%x",
4338: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
4339: sp->req_state_flags);
4340: break;
4341:
4342: case RQCS_DMA_ERROR:
4343: isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
4344: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4345: break;
4346:
4347: case RQCS_TRANSPORT_ERROR:
4348: {
4349: char buf[172];
4350: SNPRINTF(buf, sizeof (buf), "states=>");
4351: if (sp->req_state_flags & RQSF_GOT_BUS) {
4352: SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
4353: }
4354: if (sp->req_state_flags & RQSF_GOT_TARGET) {
4355: SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
4356: }
4357: if (sp->req_state_flags & RQSF_SENT_CDB) {
4358: SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
4359: }
4360: if (sp->req_state_flags & RQSF_XFRD_DATA) {
4361: SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
4362: }
4363: if (sp->req_state_flags & RQSF_GOT_STATUS) {
4364: SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
4365: }
4366: if (sp->req_state_flags & RQSF_GOT_SENSE) {
4367: SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
4368: }
4369: if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
4370: SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
4371: }
4372: SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
4373: if (sp->req_status_flags & RQSTF_DISCONNECT) {
4374: SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
4375: }
4376: if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
4377: SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
4378: }
4379: if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
4380: SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
4381: }
4382: if (sp->req_status_flags & RQSTF_BUS_RESET) {
4383: SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
4384: }
4385: if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
4386: SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
4387: }
4388: if (sp->req_status_flags & RQSTF_ABORTED) {
4389: SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
4390: }
4391: if (sp->req_status_flags & RQSTF_TIMEOUT) {
4392: SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
4393: }
4394: if (sp->req_status_flags & RQSTF_NEGOTIATION) {
4395: SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
4396: }
4397: isp_prt(isp, ISP_LOGERR, "%s", buf);
4398: isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
4399: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
4400: break;
4401: }
4402: case RQCS_RESET_OCCURRED:
4403: isp_prt(isp, ISP_LOGWARN,
4404: "bus reset destroyed command for %d.%d.%d",
4405: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4406: isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4407: if (XS_NOERR(xs)) {
4408: XS_SETERR(xs, HBA_BUSRESET);
4409: }
4410: return;
4411:
4412: case RQCS_ABORTED:
4413: isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
4414: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4415: isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4416: if (XS_NOERR(xs)) {
4417: XS_SETERR(xs, HBA_ABORTED);
4418: }
4419: return;
4420:
4421: case RQCS_TIMEOUT:
4422: isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
4423: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4424: /*
4425: * Check to see if we logged out the device.
4426: */
4427: if (IS_FC(isp)) {
4428: if ((sp->req_completion_status & RQSTF_LOGOUT) &&
4429: FCPARAM(isp)->portdb[XS_TGT(xs)].valid &&
4430: FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) {
4431: FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1;
4432: }
4433: }
4434: if (XS_NOERR(xs)) {
4435: XS_SETERR(xs, HBA_CMDTIMEOUT);
4436: }
4437: return;
4438:
4439: case RQCS_DATA_OVERRUN:
4440: XS_RESID(xs) = sp->req_resid;
4441: isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
4442: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4443: if (XS_NOERR(xs)) {
4444: XS_SETERR(xs, HBA_DATAOVR);
4445: }
4446: return;
4447:
4448: case RQCS_COMMAND_OVERRUN:
4449: isp_prt(isp, ISP_LOGERR,
4450: "command overrun for command on %d.%d.%d",
4451: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4452: break;
4453:
4454: case RQCS_STATUS_OVERRUN:
4455: isp_prt(isp, ISP_LOGERR,
4456: "status overrun for command on %d.%d.%d",
4457: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4458: break;
4459:
4460: case RQCS_BAD_MESSAGE:
4461: isp_prt(isp, ISP_LOGERR,
4462: "msg not COMMAND COMPLETE after status %d.%d.%d",
4463: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4464: break;
4465:
4466: case RQCS_NO_MESSAGE_OUT:
4467: isp_prt(isp, ISP_LOGERR,
4468: "No MESSAGE OUT phase after selection on %d.%d.%d",
4469: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4470: break;
4471:
4472: case RQCS_EXT_ID_FAILED:
4473: isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
4474: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4475: break;
4476:
4477: case RQCS_IDE_MSG_FAILED:
4478: isp_prt(isp, ISP_LOGERR,
4479: "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
4480: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4481: break;
4482:
4483: case RQCS_ABORT_MSG_FAILED:
4484: isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
4485: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4486: break;
4487:
4488: case RQCS_REJECT_MSG_FAILED:
4489: isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
4490: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4491: break;
4492:
4493: case RQCS_NOP_MSG_FAILED:
4494: isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
4495: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4496: break;
4497:
4498: case RQCS_PARITY_ERROR_MSG_FAILED:
4499: isp_prt(isp, ISP_LOGERR,
4500: "MESSAGE PARITY ERROR rejected by %d.%d.%d",
4501: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4502: break;
4503:
4504: case RQCS_DEVICE_RESET_MSG_FAILED:
4505: isp_prt(isp, ISP_LOGWARN,
4506: "BUS DEVICE RESET rejected by %d.%d.%d",
4507: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4508: break;
4509:
4510: case RQCS_ID_MSG_FAILED:
4511: isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
4512: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4513: break;
4514:
4515: case RQCS_UNEXP_BUS_FREE:
4516: isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
4517: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4518: break;
4519:
4520: case RQCS_DATA_UNDERRUN:
4521: {
4522: if (IS_FC(isp)) {
4523: int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
4524: if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
4525: isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
4526: XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
4527: (ru_marked)? "marked" : "not marked");
4528: if (XS_NOERR(xs)) {
4529: XS_SETERR(xs, HBA_BOTCH);
4530: }
4531: return;
4532: }
4533: }
4534: XS_RESID(xs) = sp->req_resid;
4535: if (XS_NOERR(xs)) {
4536: XS_SETERR(xs, HBA_NOERROR);
4537: }
4538: return;
4539: }
4540:
4541: case RQCS_XACT_ERR1:
4542: isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
4543: XS_TGT(xs), XS_LUN(xs));
4544: break;
4545:
4546: case RQCS_XACT_ERR2:
4547: isp_prt(isp, ISP_LOGERR, xact2,
4548: XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
4549: break;
4550:
4551: case RQCS_XACT_ERR3:
4552: isp_prt(isp, ISP_LOGERR, xact3,
4553: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4554: break;
4555:
4556: case RQCS_BAD_ENTRY:
4557: isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
4558: break;
4559:
4560: case RQCS_QUEUE_FULL:
4561: isp_prt(isp, ISP_LOGDEBUG0,
4562: "internal queues full for %d.%d.%d status 0x%x",
4563: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
4564:
4565: /*
4566: * If QFULL or some other status byte is set, then this
4567: * isn't an error, per se.
4568: *
4569: * Unfortunately, some QLogic f/w writers have, in
4570: * some cases, ommitted to *set* status to QFULL.
4571: *
4572:
4573: if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
4574: XS_SETERR(xs, HBA_NOERROR);
4575: return;
4576: }
4577:
4578: *
4579: *
4580: */
4581:
4582: *XS_STSP(xs) = SCSI_QFULL;
4583: XS_SETERR(xs, HBA_NOERROR);
4584: return;
4585:
4586: case RQCS_PHASE_SKIPPED:
4587: isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
4588: XS_TGT(xs), XS_LUN(xs));
4589: break;
4590:
4591: case RQCS_ARQS_FAILED:
4592: isp_prt(isp, ISP_LOGERR,
4593: "Auto Request Sense failed for %d.%d.%d",
4594: XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4595: if (XS_NOERR(xs)) {
4596: XS_SETERR(xs, HBA_ARQFAIL);
4597: }
4598: return;
4599:
4600: case RQCS_WIDE_FAILED:
4601: isp_prt(isp, ISP_LOGERR,
4602: "Wide Negotiation failed for %d.%d.%d",
4603: XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4604: if (IS_SCSI(isp)) {
4605: sdparam *sdp = isp->isp_param;
4606: sdp += XS_CHANNEL(xs);
4607: sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
4608: sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
4609: isp->isp_update |= (1 << XS_CHANNEL(xs));
4610: }
4611: if (XS_NOERR(xs)) {
4612: XS_SETERR(xs, HBA_NOERROR);
4613: }
4614: return;
4615:
4616: case RQCS_SYNCXFER_FAILED:
4617: isp_prt(isp, ISP_LOGERR,
4618: "SDTR Message failed for target %d.%d.%d",
4619: XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4620: if (IS_SCSI(isp)) {
4621: sdparam *sdp = isp->isp_param;
4622: sdp += XS_CHANNEL(xs);
4623: sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
4624: sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
4625: isp->isp_update |= (1 << XS_CHANNEL(xs));
4626: }
4627: break;
4628:
4629: case RQCS_LVD_BUSERR:
4630: isp_prt(isp, ISP_LOGERR,
4631: "Bad LVD condition while talking to %d.%d.%d",
4632: XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4633: break;
4634:
4635: case RQCS_PORT_UNAVAILABLE:
4636: /*
4637: * No such port on the loop. Moral equivalent of SELTIMEO
4638: */
4639: case RQCS_PORT_LOGGED_OUT:
4640: /*
4641: * It was there (maybe)- treat as a selection timeout.
4642: */
4643: if ((sp->req_completion_status & 0xff) == RQCS_PORT_UNAVAILABLE)
4644: isp_prt(isp, ISP_LOGINFO,
4645: "port unavailable for target %d", XS_TGT(xs));
4646: else
4647: isp_prt(isp, ISP_LOGINFO,
4648: "port logout for target %d", XS_TGT(xs));
4649: /*
4650: * If we're on a local loop, force a LIP (which is overkill)
4651: * to force a re-login of this unit. If we're on fabric,
4652: * then we'll have to relogin as a matter of course.
4653: */
4654: if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
4655: FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
4656: mbreg_t mbs;
4657: mbs.param[0] = MBOX_INIT_LIP;
4658: isp_mboxcmd_qnw(isp, &mbs, 1);
4659: }
4660:
4661: /*
4662: * Probably overkill.
4663: */
4664: isp->isp_sendmarker = 1;
4665: FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4666: isp_mark_getpdb_all(isp);
4667: isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4668: if (XS_NOERR(xs)) {
4669: XS_SETERR(xs, HBA_SELTIMEOUT);
4670: }
4671: return;
4672:
4673: case RQCS_PORT_CHANGED:
4674: isp_prt(isp, ISP_LOGWARN,
4675: "port changed for target %d", XS_TGT(xs));
4676: if (XS_NOERR(xs)) {
4677: XS_SETERR(xs, HBA_SELTIMEOUT);
4678: }
4679: return;
4680:
4681: case RQCS_PORT_BUSY:
4682: isp_prt(isp, ISP_LOGWARN,
4683: "port busy for target %d", XS_TGT(xs));
4684: if (XS_NOERR(xs)) {
4685: XS_SETERR(xs, HBA_TGTBSY);
4686: }
4687: return;
4688:
4689: default:
4690: isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
4691: sp->req_completion_status);
4692: break;
4693: }
4694: if (XS_NOERR(xs)) {
4695: XS_SETERR(xs, HBA_BOTCH);
4696: }
4697: }
4698:
4699: static void
4700: isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph)
4701: {
4702: XS_T *xs;
4703:
4704: if (fph == 0) {
4705: return;
4706: }
4707: xs = isp_find_xs(isp, fph);
4708: if (xs == NULL) {
4709: isp_prt(isp, ISP_LOGWARN,
4710: "Command for fast post handle 0x%x not found", fph);
4711: return;
4712: }
4713: isp_destroy_handle(isp, fph);
4714:
4715: /*
4716: * Since we don't have a result queue entry item,
4717: * we must believe that SCSI status is zero and
4718: * that all data transferred.
4719: */
4720: XS_SET_STATE_STAT(isp, xs, NULL);
4721: XS_RESID(xs) = 0;
4722: *XS_STSP(xs) = SCSI_GOOD;
4723: if (XS_XFRLEN(xs)) {
4724: ISP_DMAFREE(isp, xs, fph);
4725: }
4726: if (isp->isp_nactive)
4727: isp->isp_nactive--;
4728: isp->isp_fphccmplt++;
4729: isp_done(xs);
4730: }
4731:
4732: static int
4733: isp_mbox_continue(struct ispsoftc *isp)
4734: {
4735: mbreg_t mbs;
4736: u_int16_t *ptr;
4737:
4738: switch (isp->isp_lastmbxcmd) {
4739: case MBOX_WRITE_RAM_WORD:
4740: case MBOX_READ_RAM_WORD:
4741: case MBOX_READ_RAM_WORD_EXTENDED:
4742: break;
4743: default:
4744: return (1);
4745: }
4746: if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
4747: isp->isp_mbxwrk0 = 0;
4748: return (-1);
4749: }
4750:
4751:
4752: /*
4753: * Clear the previous interrupt.
4754: */
4755: ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
4756: ISP_WRITE(isp, BIU_SEMA, 0);
4757:
4758: /*
4759: * Continue with next word.
4760: */
4761: ptr = isp->isp_mbxworkp;
4762: switch (isp->isp_lastmbxcmd) {
4763: case MBOX_WRITE_RAM_WORD:
4764: mbs.param[2] = *ptr++;
4765: mbs.param[1] = isp->isp_mbxwrk1++;
4766: break;
4767: case MBOX_READ_RAM_WORD:
4768: case MBOX_READ_RAM_WORD_EXTENDED:
4769: *ptr++ = isp->isp_mboxtmp[2];
4770: mbs.param[1] = isp->isp_mbxwrk1++;
4771: break;
4772: }
4773: isp->isp_mbxworkp = ptr;
4774: mbs.param[0] = isp->isp_lastmbxcmd;
4775: isp->isp_mbxwrk0 -= 1;
4776: isp_mboxcmd_qnw(isp, &mbs, 0);
4777: return (0);
4778: }
4779:
4780:
4781: #define HIBYT(x) ((x) >> 0x8)
4782: #define LOBYT(x) ((x) & 0xff)
4783: #define ISPOPMAP(a, b) (((a) << 8) | (b))
4784: static const u_int16_t mbpscsi[] = {
4785: ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
4786: ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
4787: ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
4788: ISPOPMAP(0x1f, 0x01), /* 0x03: MBOX_DUMP_RAM */
4789: ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
4790: ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
4791: ISPOPMAP(0x3f, 0x3f), /* 0x06: MBOX_MAILBOX_REG_TEST */
4792: ISPOPMAP(0x03, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
4793: ISPOPMAP(0x01, 0x0f), /* 0x08: MBOX_ABOUT_FIRMWARE */
4794: ISPOPMAP(0x00, 0x00), /* 0x09: */
4795: ISPOPMAP(0x00, 0x00), /* 0x0a: */
4796: ISPOPMAP(0x00, 0x00), /* 0x0b: */
4797: ISPOPMAP(0x00, 0x00), /* 0x0c: */
4798: ISPOPMAP(0x00, 0x00), /* 0x0d: */
4799: ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
4800: ISPOPMAP(0x00, 0x00), /* 0x0f: */
4801: ISPOPMAP(0x1f, 0x1f), /* 0x10: MBOX_INIT_REQ_QUEUE */
4802: ISPOPMAP(0x3f, 0x3f), /* 0x11: MBOX_INIT_RES_QUEUE */
4803: ISPOPMAP(0x0f, 0x0f), /* 0x12: MBOX_EXECUTE_IOCB */
4804: ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
4805: ISPOPMAP(0x01, 0x3f), /* 0x14: MBOX_STOP_FIRMWARE */
4806: ISPOPMAP(0x0f, 0x0f), /* 0x15: MBOX_ABORT */
4807: ISPOPMAP(0x03, 0x03), /* 0x16: MBOX_ABORT_DEVICE */
4808: ISPOPMAP(0x07, 0x07), /* 0x17: MBOX_ABORT_TARGET */
4809: ISPOPMAP(0x07, 0x07), /* 0x18: MBOX_BUS_RESET */
4810: ISPOPMAP(0x03, 0x07), /* 0x19: MBOX_STOP_QUEUE */
4811: ISPOPMAP(0x03, 0x07), /* 0x1a: MBOX_START_QUEUE */
4812: ISPOPMAP(0x03, 0x07), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
4813: ISPOPMAP(0x03, 0x07), /* 0x1c: MBOX_ABORT_QUEUE */
4814: ISPOPMAP(0x03, 0x4f), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
4815: ISPOPMAP(0x00, 0x00), /* 0x1e: */
4816: ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
4817: ISPOPMAP(0x01, 0x07), /* 0x20: MBOX_GET_INIT_SCSI_ID */
4818: ISPOPMAP(0x01, 0x07), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
4819: ISPOPMAP(0x01, 0xc7), /* 0x22: MBOX_GET_RETRY_COUNT */
4820: ISPOPMAP(0x01, 0x07), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
4821: ISPOPMAP(0x01, 0x03), /* 0x24: MBOX_GET_CLOCK_RATE */
4822: ISPOPMAP(0x01, 0x07), /* 0x25: MBOX_GET_ACT_NEG_STATE */
4823: ISPOPMAP(0x01, 0x07), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
4824: ISPOPMAP(0x01, 0x07), /* 0x27: MBOX_GET_PCI_PARAMS */
4825: ISPOPMAP(0x03, 0x4f), /* 0x28: MBOX_GET_TARGET_PARAMS */
4826: ISPOPMAP(0x03, 0x0f), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
4827: ISPOPMAP(0x01, 0x07), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
4828: ISPOPMAP(0x00, 0x00), /* 0x2b: */
4829: ISPOPMAP(0x00, 0x00), /* 0x2c: */
4830: ISPOPMAP(0x00, 0x00), /* 0x2d: */
4831: ISPOPMAP(0x00, 0x00), /* 0x2e: */
4832: ISPOPMAP(0x00, 0x00), /* 0x2f: */
4833: ISPOPMAP(0x03, 0x03), /* 0x30: MBOX_SET_INIT_SCSI_ID */
4834: ISPOPMAP(0x07, 0x07), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
4835: ISPOPMAP(0xc7, 0xc7), /* 0x32: MBOX_SET_RETRY_COUNT */
4836: ISPOPMAP(0x07, 0x07), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
4837: ISPOPMAP(0x03, 0x03), /* 0x34: MBOX_SET_CLOCK_RATE */
4838: ISPOPMAP(0x07, 0x07), /* 0x35: MBOX_SET_ACT_NEG_STATE */
4839: ISPOPMAP(0x07, 0x07), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
4840: ISPOPMAP(0x07, 0x07), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
4841: ISPOPMAP(0x4f, 0x4f), /* 0x38: MBOX_SET_TARGET_PARAMS */
4842: ISPOPMAP(0x0f, 0x0f), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
4843: ISPOPMAP(0x07, 0x07), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
4844: ISPOPMAP(0x00, 0x00), /* 0x3b: */
4845: ISPOPMAP(0x00, 0x00), /* 0x3c: */
4846: ISPOPMAP(0x00, 0x00), /* 0x3d: */
4847: ISPOPMAP(0x00, 0x00), /* 0x3e: */
4848: ISPOPMAP(0x00, 0x00), /* 0x3f: */
4849: ISPOPMAP(0x01, 0x03), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
4850: ISPOPMAP(0x3f, 0x01), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
4851: ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_EXEC_BIOS_IOCB */
4852: ISPOPMAP(0x00, 0x00), /* 0x43: */
4853: ISPOPMAP(0x00, 0x00), /* 0x44: */
4854: ISPOPMAP(0x03, 0x03), /* 0x45: SET SYSTEM PARAMETER */
4855: ISPOPMAP(0x01, 0x03), /* 0x46: GET SYSTEM PARAMETER */
4856: ISPOPMAP(0x00, 0x00), /* 0x47: */
4857: ISPOPMAP(0x01, 0xcf), /* 0x48: GET SCAM CONFIGURATION */
4858: ISPOPMAP(0xcf, 0xcf), /* 0x49: SET SCAM CONFIGURATION */
4859: ISPOPMAP(0x03, 0x03), /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
4860: ISPOPMAP(0x01, 0x03), /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
4861: ISPOPMAP(0x00, 0x00), /* 0x4c: */
4862: ISPOPMAP(0x00, 0x00), /* 0x4d: */
4863: ISPOPMAP(0x00, 0x00), /* 0x4e: */
4864: ISPOPMAP(0x00, 0x00), /* 0x4f: */
4865: ISPOPMAP(0xdf, 0xdf), /* 0x50: LOAD RAM A64 */
4866: ISPOPMAP(0xdf, 0xdf), /* 0x51: DUMP RAM A64 */
4867: ISPOPMAP(0xdf, 0xff), /* 0x52: INITIALIZE REQUEST QUEUE A64 */
4868: ISPOPMAP(0xef, 0xff), /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
4869: ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
4870: ISPOPMAP(0x07, 0x01), /* 0x55: ENABLE TARGET MODE */
4871: ISPOPMAP(0x03, 0x0f), /* 0x56: GET TARGET STATUS */
4872: ISPOPMAP(0x00, 0x00), /* 0x57: */
4873: ISPOPMAP(0x00, 0x00), /* 0x58: */
4874: ISPOPMAP(0x00, 0x00), /* 0x59: */
4875: ISPOPMAP(0x03, 0x03), /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
4876: ISPOPMAP(0x01, 0x03), /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
4877: ISPOPMAP(0x0f, 0x0f), /* 0x5c: SET HOST DATA */
4878: ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
4879: };
4880:
4881: #ifdef SMALL_KERNEL
4882: #define ISP_STRIPPED
4883: #endif
4884:
4885: #ifndef ISP_STRIPPED
4886: static char *scsi_mbcmd_names[] = {
4887: "NO-OP",
4888: "LOAD RAM",
4889: "EXEC FIRMWARE",
4890: "DUMP RAM",
4891: "WRITE RAM WORD",
4892: "READ RAM WORD",
4893: "MAILBOX REG TEST",
4894: "VERIFY CHECKSUM",
4895: "ABOUT FIRMWARE",
4896: NULL,
4897: NULL,
4898: NULL,
4899: NULL,
4900: NULL,
4901: "CHECK FIRMWARE",
4902: NULL,
4903: "INIT REQUEST QUEUE",
4904: "INIT RESULT QUEUE",
4905: "EXECUTE IOCB",
4906: "WAKE UP",
4907: "STOP FIRMWARE",
4908: "ABORT",
4909: "ABORT DEVICE",
4910: "ABORT TARGET",
4911: "BUS RESET",
4912: "STOP QUEUE",
4913: "START QUEUE",
4914: "SINGLE STEP QUEUE",
4915: "ABORT QUEUE",
4916: "GET DEV QUEUE STATUS",
4917: NULL,
4918: "GET FIRMWARE STATUS",
4919: "GET INIT SCSI ID",
4920: "GET SELECT TIMEOUT",
4921: "GET RETRY COUNT",
4922: "GET TAG AGE LIMIT",
4923: "GET CLOCK RATE",
4924: "GET ACT NEG STATE",
4925: "GET ASYNC DATA SETUP TIME",
4926: "GET PCI PARAMS",
4927: "GET TARGET PARAMS",
4928: "GET DEV QUEUE PARAMS",
4929: "GET RESET DELAY PARAMS",
4930: NULL,
4931: NULL,
4932: NULL,
4933: NULL,
4934: NULL,
4935: "SET INIT SCSI ID",
4936: "SET SELECT TIMEOUT",
4937: "SET RETRY COUNT",
4938: "SET TAG AGE LIMIT",
4939: "SET CLOCK RATE",
4940: "SET ACT NEG STATE",
4941: "SET ASYNC DATA SETUP TIME",
4942: "SET PCI CONTROL PARAMS",
4943: "SET TARGET PARAMS",
4944: "SET DEV QUEUE PARAMS",
4945: "SET RESET DELAY PARAMS",
4946: NULL,
4947: NULL,
4948: NULL,
4949: NULL,
4950: NULL,
4951: "RETURN BIOS BLOCK ADDR",
4952: "WRITE FOUR RAM WORDS",
4953: "EXEC BIOS IOCB",
4954: NULL,
4955: NULL,
4956: "SET SYSTEM PARAMETER",
4957: "GET SYSTEM PARAMETER",
4958: NULL,
4959: "GET SCAM CONFIGURATION",
4960: "SET SCAM CONFIGURATION",
4961: "SET FIRMWARE FEATURES",
4962: "GET FIRMWARE FEATURES",
4963: NULL,
4964: NULL,
4965: NULL,
4966: NULL,
4967: "LOAD RAM A64",
4968: "DUMP RAM A64",
4969: "INITIALIZE REQUEST QUEUE A64",
4970: "INITIALIZE RESPONSE QUEUE A64",
4971: "EXECUTE IOCB A64",
4972: "ENABLE TARGET MODE",
4973: "GET TARGET MODE STATE",
4974: NULL,
4975: NULL,
4976: NULL,
4977: "SET DATA OVERRUN RECOVERY MODE",
4978: "GET DATA OVERRUN RECOVERY MODE",
4979: "SET HOST DATA",
4980: "GET NOST DATA",
4981: };
4982: #endif
4983:
4984: static const u_int16_t mbpfc[] = {
4985: ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
4986: ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
4987: ISPOPMAP(0x03, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
4988: ISPOPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
4989: ISPOPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
4990: ISPOPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
4991: ISPOPMAP(0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
4992: ISPOPMAP(0x03, 0x05), /* 0x07: MBOX_VERIFY_CHECKSUM */
4993: ISPOPMAP(0x01, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */
4994: ISPOPMAP(0xdf, 0x01), /* 0x09: LOAD RAM */
4995: ISPOPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
4996: ISPOPMAP(0x00, 0x00), /* 0x0b: */
4997: ISPOPMAP(0x00, 0x00), /* 0x0c: */
4998: ISPOPMAP(0x00, 0x00), /* 0x0d: */
4999: ISPOPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
5000: ISPOPMAP(0x03, 0x07), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED(1) */
5001: ISPOPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */
5002: ISPOPMAP(0x2f, 0x21), /* 0x11: MBOX_INIT_RES_QUEUE */
5003: ISPOPMAP(0x0f, 0x01), /* 0x12: MBOX_EXECUTE_IOCB */
5004: ISPOPMAP(0x03, 0x03), /* 0x13: MBOX_WAKE_UP */
5005: ISPOPMAP(0x01, 0xff), /* 0x14: MBOX_STOP_FIRMWARE */
5006: ISPOPMAP(0x4f, 0x01), /* 0x15: MBOX_ABORT */
5007: ISPOPMAP(0x07, 0x01), /* 0x16: MBOX_ABORT_DEVICE */
5008: ISPOPMAP(0x07, 0x01), /* 0x17: MBOX_ABORT_TARGET */
5009: ISPOPMAP(0x03, 0x03), /* 0x18: MBOX_BUS_RESET */
5010: ISPOPMAP(0x07, 0x05), /* 0x19: MBOX_STOP_QUEUE */
5011: ISPOPMAP(0x07, 0x05), /* 0x1a: MBOX_START_QUEUE */
5012: ISPOPMAP(0x07, 0x05), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
5013: ISPOPMAP(0x07, 0x05), /* 0x1c: MBOX_ABORT_QUEUE */
5014: ISPOPMAP(0x07, 0x03), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
5015: ISPOPMAP(0x00, 0x00), /* 0x1e: */
5016: ISPOPMAP(0x01, 0x07), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
5017: ISPOPMAP(0x01, 0x4f), /* 0x20: MBOX_GET_LOOP_ID */
5018: ISPOPMAP(0x00, 0x00), /* 0x21: */
5019: ISPOPMAP(0x01, 0x07), /* 0x22: MBOX_GET_RETRY_COUNT */
5020: ISPOPMAP(0x00, 0x00), /* 0x23: */
5021: ISPOPMAP(0x00, 0x00), /* 0x24: */
5022: ISPOPMAP(0x00, 0x00), /* 0x25: */
5023: ISPOPMAP(0x00, 0x00), /* 0x26: */
5024: ISPOPMAP(0x00, 0x00), /* 0x27: */
5025: ISPOPMAP(0x01, 0x03), /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
5026: ISPOPMAP(0x03, 0x07), /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
5027: ISPOPMAP(0x00, 0x00), /* 0x2a: */
5028: ISPOPMAP(0x00, 0x00), /* 0x2b: */
5029: ISPOPMAP(0x00, 0x00), /* 0x2c: */
5030: ISPOPMAP(0x00, 0x00), /* 0x2d: */
5031: ISPOPMAP(0x00, 0x00), /* 0x2e: */
5032: ISPOPMAP(0x00, 0x00), /* 0x2f: */
5033: ISPOPMAP(0x00, 0x00), /* 0x30: */
5034: ISPOPMAP(0x00, 0x00), /* 0x31: */
5035: ISPOPMAP(0x07, 0x07), /* 0x32: MBOX_SET_RETRY_COUNT */
5036: ISPOPMAP(0x00, 0x00), /* 0x33: */
5037: ISPOPMAP(0x00, 0x00), /* 0x34: */
5038: ISPOPMAP(0x00, 0x00), /* 0x35: */
5039: ISPOPMAP(0x00, 0x00), /* 0x36: */
5040: ISPOPMAP(0x00, 0x00), /* 0x37: */
5041: ISPOPMAP(0x0f, 0x01), /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
5042: ISPOPMAP(0x0f, 0x07), /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
5043: ISPOPMAP(0x00, 0x00), /* 0x3a: */
5044: ISPOPMAP(0x00, 0x00), /* 0x3b: */
5045: ISPOPMAP(0x00, 0x00), /* 0x3c: */
5046: ISPOPMAP(0x00, 0x00), /* 0x3d: */
5047: ISPOPMAP(0x00, 0x00), /* 0x3e: */
5048: ISPOPMAP(0x00, 0x00), /* 0x3f: */
5049: ISPOPMAP(0x03, 0x01), /* 0x40: MBOX_LOOP_PORT_BYPASS */
5050: ISPOPMAP(0x03, 0x01), /* 0x41: MBOX_LOOP_PORT_ENABLE */
5051: ISPOPMAP(0x03, 0x07), /* 0x42: MBOX_GET_RESOURCE_COUNTS */
5052: ISPOPMAP(0x01, 0x01), /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */
5053: ISPOPMAP(0x00, 0x00), /* 0x44: */
5054: ISPOPMAP(0x00, 0x00), /* 0x45: */
5055: ISPOPMAP(0x00, 0x00), /* 0x46: */
5056: ISPOPMAP(0xcf, 0x03), /* 0x47: GET PORT_DATABASE ENHANCED */
5057: ISPOPMAP(0x00, 0x00), /* 0x48: */
5058: ISPOPMAP(0x00, 0x00), /* 0x49: */
5059: ISPOPMAP(0x00, 0x00), /* 0x4a: */
5060: ISPOPMAP(0x00, 0x00), /* 0x4b: */
5061: ISPOPMAP(0x00, 0x00), /* 0x4c: */
5062: ISPOPMAP(0x00, 0x00), /* 0x4d: */
5063: ISPOPMAP(0x00, 0x00), /* 0x4e: */
5064: ISPOPMAP(0x00, 0x00), /* 0x4f: */
5065: ISPOPMAP(0x00, 0x00), /* 0x50: */
5066: ISPOPMAP(0x00, 0x00), /* 0x51: */
5067: ISPOPMAP(0x00, 0x00), /* 0x52: */
5068: ISPOPMAP(0x00, 0x00), /* 0x53: */
5069: ISPOPMAP(0xcf, 0x01), /* 0x54: EXECUTE IOCB A64 */
5070: ISPOPMAP(0x00, 0x00), /* 0x55: */
5071: ISPOPMAP(0x00, 0x00), /* 0x56: */
5072: ISPOPMAP(0x00, 0x00), /* 0x57: */
5073: ISPOPMAP(0x00, 0x00), /* 0x58: */
5074: ISPOPMAP(0x00, 0x00), /* 0x59: */
5075: ISPOPMAP(0x00, 0x00), /* 0x5a: */
5076: ISPOPMAP(0x03, 0x01), /* 0x5b: MBOX_DRIVER_HEARTBEAT */
5077: ISPOPMAP(0xcf, 0x01), /* 0x5c: MBOX_FW_HEARTBEAT */
5078: ISPOPMAP(0x07, 0x03), /* 0x5d: MBOX_GET_SET_DATA_RATE */
5079: ISPOPMAP(0x00, 0x00), /* 0x5e: */
5080: ISPOPMAP(0x00, 0x00), /* 0x5f: */
5081: ISPOPMAP(0xfd, 0x31), /* 0x60: MBOX_INIT_FIRMWARE */
5082: ISPOPMAP(0x00, 0x00), /* 0x61: */
5083: ISPOPMAP(0x01, 0x01), /* 0x62: MBOX_INIT_LIP */
5084: ISPOPMAP(0xcd, 0x03), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
5085: ISPOPMAP(0xcf, 0x01), /* 0x64: MBOX_GET_PORT_DB */
5086: ISPOPMAP(0x07, 0x01), /* 0x65: MBOX_CLEAR_ACA */
5087: ISPOPMAP(0x07, 0x01), /* 0x66: MBOX_TARGET_RESET */
5088: ISPOPMAP(0x07, 0x01), /* 0x67: MBOX_CLEAR_TASK_SET */
5089: ISPOPMAP(0x07, 0x01), /* 0x68: MBOX_ABORT_TASK_SET */
5090: ISPOPMAP(0x01, 0x07), /* 0x69: MBOX_GET_FW_STATE */
5091: ISPOPMAP(0x03, 0xcf), /* 0x6a: MBOX_GET_PORT_NAME */
5092: ISPOPMAP(0xcf, 0x01), /* 0x6b: MBOX_GET_LINK_STATUS */
5093: ISPOPMAP(0x0f, 0x01), /* 0x6c: MBOX_INIT_LIP_RESET */
5094: ISPOPMAP(0x00, 0x00), /* 0x6d: */
5095: ISPOPMAP(0xcf, 0x03), /* 0x6e: MBOX_SEND_SNS */
5096: ISPOPMAP(0x0f, 0x07), /* 0x6f: MBOX_FABRIC_LOGIN */
5097: ISPOPMAP(0x03, 0x01), /* 0x70: MBOX_SEND_CHANGE_REQUEST */
5098: ISPOPMAP(0x03, 0x03), /* 0x71: MBOX_FABRIC_LOGOUT */
5099: ISPOPMAP(0x0f, 0x0f), /* 0x72: MBOX_INIT_LIP_LOGIN */
5100: ISPOPMAP(0x00, 0x00), /* 0x73: */
5101: ISPOPMAP(0x07, 0x01), /* 0x74: LOGIN LOOP PORT */
5102: ISPOPMAP(0xcf, 0x03), /* 0x75: GET PORT/NODE NAME LIST */
5103: ISPOPMAP(0x4f, 0x01), /* 0x76: SET VENDOR ID */
5104: ISPOPMAP(0xcd, 0x01), /* 0x77: INITIALIZE IP MAILBOX */
5105: ISPOPMAP(0x00, 0x00), /* 0x78: */
5106: ISPOPMAP(0x00, 0x00), /* 0x79: */
5107: ISPOPMAP(0x00, 0x00), /* 0x7a: */
5108: ISPOPMAP(0x00, 0x00), /* 0x7b: */
5109: ISPOPMAP(0x4f, 0x03), /* 0x7c: Get ID List */
5110: ISPOPMAP(0xcf, 0x01), /* 0x7d: SEND LFA */
5111: ISPOPMAP(0x07, 0x01) /* 0x7e: Lun RESET */
5112: };
5113: /*
5114: * Footnotes
5115: *
5116: * (1): this sets bits 21..16 in mailbox register #8, which we nominally
5117: * do not access at this time in the core driver. The caller is
5118: * responsible for setting this register first (Gross!).
5119: */
5120:
5121: #ifndef ISP_STRIPPED
5122: static char *fc_mbcmd_names[] = {
5123: "NO-OP",
5124: "LOAD RAM",
5125: "EXEC FIRMWARE",
5126: "DUMP RAM",
5127: "WRITE RAM WORD",
5128: "READ RAM WORD",
5129: "MAILBOX REG TEST",
5130: "VERIFY CHECKSUM",
5131: "ABOUT FIRMWARE",
5132: "LOAD RAM",
5133: "DUMP RAM",
5134: NULL,
5135: NULL,
5136: "READ RAM WORD EXTENDED",
5137: "CHECK FIRMWARE",
5138: NULL,
5139: "INIT REQUEST QUEUE",
5140: "INIT RESULT QUEUE",
5141: "EXECUTE IOCB",
5142: "WAKE UP",
5143: "STOP FIRMWARE",
5144: "ABORT",
5145: "ABORT DEVICE",
5146: "ABORT TARGET",
5147: "BUS RESET",
5148: "STOP QUEUE",
5149: "START QUEUE",
5150: "SINGLE STEP QUEUE",
5151: "ABORT QUEUE",
5152: "GET DEV QUEUE STATUS",
5153: NULL,
5154: "GET FIRMWARE STATUS",
5155: "GET LOOP ID",
5156: NULL,
5157: "GET RETRY COUNT",
5158: NULL,
5159: NULL,
5160: NULL,
5161: NULL,
5162: NULL,
5163: "GET FIRMWARE OPTIONS",
5164: "GET PORT QUEUE PARAMS",
5165: NULL,
5166: NULL,
5167: NULL,
5168: NULL,
5169: NULL,
5170: NULL,
5171: NULL,
5172: NULL,
5173: "SET RETRY COUNT",
5174: NULL,
5175: NULL,
5176: NULL,
5177: NULL,
5178: NULL,
5179: "SET FIRMWARE OPTIONS",
5180: "SET PORT QUEUE PARAMS",
5181: NULL,
5182: NULL,
5183: NULL,
5184: NULL,
5185: NULL,
5186: NULL,
5187: "LOOP PORT BYPASS",
5188: "LOOP PORT ENABLE",
5189: "GET RESOURCE COUNTS",
5190: "REQUEST NON PARTICIPATING MODE",
5191: NULL,
5192: NULL,
5193: NULL,
5194: "GET PORT DATABASE,, ENHANCED",
5195: NULL,
5196: NULL,
5197: NULL,
5198: NULL,
5199: NULL,
5200: NULL,
5201: NULL,
5202: NULL,
5203: NULL,
5204: NULL,
5205: NULL,
5206: NULL,
5207: "EXECUTE IOCB A64",
5208: NULL,
5209: NULL,
5210: NULL,
5211: NULL,
5212: NULL,
5213: NULL,
5214: "DRIVER HEARTBEAT",
5215: NULL,
5216: "GET/SET DATA RATE",
5217: NULL,
5218: NULL,
5219: "INIT FIRMWARE",
5220: NULL,
5221: "INIT LIP",
5222: "GET FC-AL POSITION MAP",
5223: "GET PORT DATABASE",
5224: "CLEAR ACA",
5225: "TARGET RESET",
5226: "CLEAR TASK SET",
5227: "ABORT TASK SET",
5228: "GET FW STATE",
5229: "GET PORT NAME",
5230: "GET LINK STATUS",
5231: "INIT LIP RESET",
5232: NULL,
5233: "SEND SNS",
5234: "FABRIC LOGIN",
5235: "SEND CHANGE REQUEST",
5236: "FABRIC LOGOUT",
5237: "INIT LIP LOGIN",
5238: NULL,
5239: "LOGIN LOOP PORT",
5240: "GET PORT/NODE NAME LIST",
5241: "SET VENDOR ID",
5242: "INITIALIZE IP MAILBOX",
5243: NULL,
5244: NULL,
5245: NULL,
5246: NULL,
5247: "Get ID List",
5248: "SEND LFA",
5249: "Lun RESET"
5250: };
5251: #endif
5252:
5253: static void
5254: isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay)
5255: {
5256: unsigned int lim, ibits, obits, box, opcode;
5257: const u_int16_t *mcp;
5258:
5259: if (IS_FC(isp)) {
5260: mcp = mbpfc;
5261: lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
5262: } else {
5263: mcp = mbpscsi;
5264: lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
5265: }
5266: opcode = mbp->param[0];
5267: ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
5268: obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
5269: for (box = 0; box < MAX_MAILBOX; box++) {
5270: if (ibits & (1 << box)) {
5271: ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
5272: }
5273: if (nodelay == 0) {
5274: isp->isp_mboxtmp[box] = mbp->param[box] = 0;
5275: }
5276: }
5277: if (nodelay == 0) {
5278: isp->isp_lastmbxcmd = opcode;
5279: isp->isp_obits = obits;
5280: isp->isp_mboxbsy = 1;
5281: }
5282: ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
5283: /*
5284: * Oddly enough, if we're not delaying for an answer,
5285: * delay a bit to give the f/w a chance to pick up the
5286: * command.
5287: */
5288: if (nodelay) {
5289: USEC_DELAY(1000);
5290: }
5291: }
5292:
5293: static void
5294: isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
5295: {
5296: char *cname, *xname, tname[16], mname[16];
5297: unsigned int lim, ibits, obits, box, opcode;
5298: const u_int16_t *mcp;
5299:
5300: if (IS_FC(isp)) {
5301: mcp = mbpfc;
5302: lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
5303: } else {
5304: mcp = mbpscsi;
5305: lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
5306: }
5307:
5308: if ((opcode = mbp->param[0]) >= lim) {
5309: mbp->param[0] = MBOX_INVALID_COMMAND;
5310: isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
5311: return;
5312: }
5313:
5314: ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
5315: obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
5316:
5317: if (ibits == 0 && obits == 0) {
5318: mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
5319: isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
5320: return;
5321: }
5322:
5323: /*
5324: * Get exclusive usage of mailbox registers.
5325: */
5326: MBOX_ACQUIRE(isp);
5327:
5328: for (box = 0; box < MAX_MAILBOX; box++) {
5329: if (ibits & (1 << box)) {
5330: ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
5331: }
5332: isp->isp_mboxtmp[box] = mbp->param[box] = 0;
5333: }
5334:
5335: isp->isp_lastmbxcmd = opcode;
5336:
5337: /*
5338: * We assume that we can't overwrite a previous command.
5339: */
5340: isp->isp_obits = obits;
5341: isp->isp_mboxbsy = 1;
5342:
5343: /*
5344: * Set Host Interrupt condition so that RISC will pick up mailbox regs.
5345: */
5346: ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
5347:
5348: /*
5349: * While we haven't finished the command, spin our wheels here.
5350: */
5351: MBOX_WAIT_COMPLETE(isp);
5352:
5353: if (isp->isp_mboxbsy) {
5354: /*
5355: * Command timed out.
5356: */
5357: isp->isp_mboxbsy = 0;
5358: MBOX_RELEASE(isp);
5359: return;
5360: }
5361:
5362: /*
5363: * Copy back output registers.
5364: */
5365: for (box = 0; box < MAX_MAILBOX; box++) {
5366: if (obits & (1 << box)) {
5367: mbp->param[box] = isp->isp_mboxtmp[box];
5368: }
5369: }
5370:
5371: MBOX_RELEASE(isp);
5372:
5373: if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
5374: return;
5375: }
5376: #ifdef ISP_STRIPPED
5377: cname = NULL;
5378: #else
5379: cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
5380: #endif
5381: if (cname == NULL) {
5382: cname = tname;
5383: SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
5384: }
5385:
5386: /*
5387: * Just to be chatty here...
5388: */
5389: xname = NULL;
5390: switch (mbp->param[0]) {
5391: case MBOX_COMMAND_COMPLETE:
5392: break;
5393: case MBOX_INVALID_COMMAND:
5394: if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
5395: xname = "INVALID COMMAND";
5396: break;
5397: case MBOX_HOST_INTERFACE_ERROR:
5398: if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
5399: xname = "HOST INTERFACE ERROR";
5400: break;
5401: case MBOX_TEST_FAILED:
5402: if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
5403: xname = "TEST FAILED";
5404: break;
5405: case MBOX_COMMAND_ERROR:
5406: if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
5407: xname = "COMMAND ERROR";
5408: break;
5409: case MBOX_COMMAND_PARAM_ERROR:
5410: if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
5411: xname = "COMMAND PARAMETER ERROR";
5412: break;
5413: case MBOX_LOOP_ID_USED:
5414: if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
5415: xname = "LOOP ID ALREADY IN USE";
5416: break;
5417: case MBOX_PORT_ID_USED:
5418: if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
5419: xname = "PORT ID ALREADY IN USE";
5420: break;
5421: case MBOX_ALL_IDS_USED:
5422: if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
5423: xname = "ALL LOOP IDS IN USE";
5424: break;
5425: case 0: /* special case */
5426: xname = "TIMEOUT";
5427: break;
5428: default:
5429: SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
5430: xname = mname;
5431: break;
5432: }
5433: if (xname)
5434: isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
5435: cname, xname);
5436: }
5437:
5438: static void
5439: isp_fw_state(struct ispsoftc *isp)
5440: {
5441: if (IS_FC(isp)) {
5442: mbreg_t mbs;
5443: fcparam *fcp = isp->isp_param;
5444:
5445: mbs.param[0] = MBOX_GET_FW_STATE;
5446: isp_mboxcmd(isp, &mbs, MBLOGALL);
5447: if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
5448: fcp->isp_fwstate = mbs.param[1];
5449: }
5450: }
5451: }
5452:
5453: static void
5454: isp_update(struct ispsoftc *isp)
5455: {
5456: int bus, upmask;
5457:
5458: for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
5459: if (upmask & (1 << bus)) {
5460: isp_update_bus(isp, bus);
5461: }
5462: upmask &= ~(1 << bus);
5463: }
5464: }
5465:
5466: static void
5467: isp_update_bus(struct ispsoftc *isp, int bus)
5468: {
5469: int tgt;
5470: mbreg_t mbs;
5471: sdparam *sdp;
5472:
5473: isp->isp_update &= ~(1 << bus);
5474: if (IS_FC(isp)) {
5475: /*
5476: * There are no 'per-bus' settings for Fibre Channel.
5477: */
5478: return;
5479: }
5480: sdp = isp->isp_param;
5481: sdp += bus;
5482:
5483: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5484: u_int16_t flags, period, offset;
5485: int get;
5486:
5487: if (sdp->isp_devparam[tgt].dev_enable == 0) {
5488: sdp->isp_devparam[tgt].dev_update = 0;
5489: sdp->isp_devparam[tgt].dev_refresh = 0;
5490: isp_prt(isp, ISP_LOGDEBUG0,
5491: "skipping target %d bus %d update", tgt, bus);
5492: continue;
5493: }
5494: /*
5495: * If the goal is to update the status of the device,
5496: * take what's in goal_flags and try and set the device
5497: * toward that. Otherwise, if we're just refreshing the
5498: * current device state, get the current parameters.
5499: */
5500:
5501: /*
5502: * Refresh overrides set
5503: */
5504: if (sdp->isp_devparam[tgt].dev_refresh) {
5505: mbs.param[0] = MBOX_GET_TARGET_PARAMS;
5506: sdp->isp_devparam[tgt].dev_refresh = 0;
5507: get = 1;
5508: } else if (sdp->isp_devparam[tgt].dev_update) {
5509: mbs.param[0] = MBOX_SET_TARGET_PARAMS;
5510: /*
5511: * Make sure goal_flags has "Renegotiate on Error"
5512: * on and "Freeze Queue on Error" off.
5513: */
5514: sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
5515: sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
5516:
5517: mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
5518:
5519: /*
5520: * Insist that PARITY must be enabled
5521: * if SYNC or WIDE is enabled.
5522: */
5523: if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
5524: mbs.param[2] |= DPARM_PARITY;
5525: }
5526:
5527: if ((mbs.param[2] & DPARM_SYNC) == 0) {
5528: mbs.param[3] = 0;
5529: } else {
5530: mbs.param[3] =
5531: (sdp->isp_devparam[tgt].goal_offset << 8) |
5532: (sdp->isp_devparam[tgt].goal_period);
5533: }
5534: /*
5535: * A command completion later that has
5536: * RQSTF_NEGOTIATION set can cause
5537: * the dev_refresh/announce cycle also.
5538: *
5539: * Note: It is really important to update our current
5540: * flags with at least the state of TAG capabilities-
5541: * otherwise we might try and send a tagged command
5542: * when we have it all turned off. So change it here
5543: * to say that current already matches goal.
5544: */
5545: sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
5546: sdp->isp_devparam[tgt].actv_flags |=
5547: (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
5548: isp_prt(isp, ISP_LOGDEBUG0,
5549: "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
5550: bus, tgt, mbs.param[2], mbs.param[3] >> 8,
5551: mbs.param[3] & 0xff);
5552: sdp->isp_devparam[tgt].dev_update = 0;
5553: sdp->isp_devparam[tgt].dev_refresh = 1;
5554: get = 0;
5555: } else {
5556: continue;
5557: }
5558: mbs.param[1] = (bus << 15) | (tgt << 8);
5559: isp_mboxcmd(isp, &mbs, MBLOGALL);
5560: if (get == 0) {
5561: isp->isp_sendmarker |= (1 << bus);
5562: continue;
5563: }
5564: flags = mbs.param[2];
5565: period = mbs.param[3] & 0xff;
5566: offset = mbs.param[3] >> 8;
5567: sdp->isp_devparam[tgt].actv_flags = flags;
5568: sdp->isp_devparam[tgt].actv_period = period;
5569: sdp->isp_devparam[tgt].actv_offset = offset;
5570: get = (bus << 16) | tgt;
5571: (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
5572: }
5573:
5574: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5575: if (sdp->isp_devparam[tgt].dev_update ||
5576: sdp->isp_devparam[tgt].dev_refresh) {
5577: isp->isp_update |= (1 << bus);
5578: break;
5579: }
5580: }
5581: }
5582:
5583: #ifndef DEFAULT_FRAMESIZE
5584: #define DEFAULT_FRAMESIZE(isp) ICB_DFLT_FRMLEN
5585: #endif
5586: #ifndef DEFAULT_EXEC_THROTTLE
5587: #define DEFAULT_EXEC_THROTTLE(isp) ISP_EXEC_THROTTLE
5588: #endif
5589:
5590: static void
5591: isp_setdfltparm(struct ispsoftc *isp, int channel)
5592: {
5593: int tgt;
5594: mbreg_t mbs;
5595: sdparam *sdp;
5596:
5597: if (IS_FC(isp)) {
5598: fcparam *fcp = (fcparam *) isp->isp_param;
5599: int nvfail;
5600:
5601: fcp += channel;
5602: if (fcp->isp_gotdparms) {
5603: return;
5604: }
5605: fcp->isp_gotdparms = 1;
5606: fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
5607: fcp->isp_maxalloc = ICB_DFLT_ALLOC;
5608: fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
5609: fcp->isp_retry_delay = ICB_DFLT_RDELAY;
5610: fcp->isp_retry_count = ICB_DFLT_RCOUNT;
5611: /* Platform specific.... */
5612: fcp->isp_loopid = DEFAULT_LOOPID(isp);
5613: fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
5614: fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
5615: fcp->isp_fwoptions = 0;
5616: fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
5617: fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
5618: fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
5619: #ifndef ISP_NO_FASTPOST_FC
5620: fcp->isp_fwoptions |= ICBOPT_FAST_POST;
5621: #endif
5622: if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
5623: fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
5624:
5625: /*
5626: * Make sure this is turned off now until we get
5627: * extended options from NVRAM
5628: */
5629: fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
5630:
5631: /*
5632: * Now try and read NVRAM unless told to not do so.
5633: * This will set fcparam's isp_nodewwn && isp_portwwn.
5634: */
5635: if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5636: nvfail = isp_read_nvram(isp);
5637: if (nvfail)
5638: isp->isp_confopts |= ISP_CFG_NONVRAM;
5639: } else {
5640: nvfail = 1;
5641: }
5642: /*
5643: * Set node && port to override platform set defaults
5644: * unless the nvram read failed (or none was done),
5645: * or the platform code wants to use what had been
5646: * set in the defaults.
5647: */
5648: if (nvfail) {
5649: isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
5650: }
5651: if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
5652: isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
5653: (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32),
5654: (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
5655: ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
5656: } else {
5657: /*
5658: * We always start out with values derived
5659: * from NVRAM or our platform default.
5660: */
5661: ISP_NODEWWN(isp) = fcp->isp_nodewwn;
5662: }
5663: if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
5664: isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
5665: (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32),
5666: (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
5667: ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
5668: } else {
5669: /*
5670: * We always start out with values derived
5671: * from NVRAM or our platform default.
5672: */
5673: ISP_PORTWWN(isp) = fcp->isp_portwwn;
5674: }
5675: return;
5676: }
5677:
5678: sdp = (sdparam *) isp->isp_param;
5679: sdp += channel;
5680:
5681: /*
5682: * Been there, done that, got the T-shirt...
5683: */
5684: if (sdp->isp_gotdparms) {
5685: return;
5686: }
5687: sdp->isp_gotdparms = 1;
5688:
5689: /*
5690: * Establish some default parameters.
5691: */
5692: sdp->isp_cmd_dma_burst_enable = 0;
5693: sdp->isp_data_dma_burst_enabl = 1;
5694: sdp->isp_fifo_threshold = 0;
5695: sdp->isp_initiator_id = DEFAULT_IID(isp);
5696: if (isp->isp_type >= ISP_HA_SCSI_1040) {
5697: sdp->isp_async_data_setup = 9;
5698: } else {
5699: sdp->isp_async_data_setup = 6;
5700: }
5701: sdp->isp_selection_timeout = 250;
5702: sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
5703: sdp->isp_tag_aging = 8;
5704: sdp->isp_bus_reset_delay = 5;
5705: /*
5706: * Don't retry selection, busy or queue full automatically- reflect
5707: * these back to us.
5708: */
5709: sdp->isp_retry_count = 0;
5710: sdp->isp_retry_delay = 0;
5711:
5712: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5713: sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
5714: sdp->isp_devparam[tgt].dev_enable = 1;
5715: }
5716:
5717: /*
5718: * If we've not been told to avoid reading NVRAM, try and read it.
5719: * If we're successful reading it, we can then return because NVRAM
5720: * will tell us what the desired settings are. Otherwise, we establish
5721: * some reasonable 'fake' nvram and goal defaults.
5722: */
5723:
5724: if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5725: if (isp_read_nvram(isp) == 0) {
5726: return;
5727: }
5728: }
5729:
5730: /*
5731: * Now try and see whether we have specific values for them.
5732: */
5733: if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5734: mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
5735: isp_mboxcmd(isp, &mbs, MBLOGNONE);
5736: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
5737: sdp->isp_req_ack_active_neg = 1;
5738: sdp->isp_data_line_active_neg = 1;
5739: } else {
5740: sdp->isp_req_ack_active_neg =
5741: (mbs.param[1+channel] >> 4) & 0x1;
5742: sdp->isp_data_line_active_neg =
5743: (mbs.param[1+channel] >> 5) & 0x1;
5744: }
5745: }
5746:
5747: isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
5748: 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
5749: sdp->isp_bus_reset_delay, sdp->isp_retry_count,
5750: sdp->isp_retry_delay, sdp->isp_async_data_setup);
5751: isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
5752: sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
5753: sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
5754: sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
5755:
5756: /*
5757: * The trick here is to establish a default for the default (honk!)
5758: * state (goal_flags). Then try and get the current status from
5759: * the card to fill in the current state. We don't, in fact, set
5760: * the default to the SAFE default state- that's not the goal state.
5761: */
5762: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5763: u_int8_t off, per;
5764: sdp->isp_devparam[tgt].actv_offset = 0;
5765: sdp->isp_devparam[tgt].actv_period = 0;
5766: sdp->isp_devparam[tgt].actv_flags = 0;
5767:
5768: sdp->isp_devparam[tgt].goal_flags =
5769: sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
5770:
5771: /*
5772: * We default to Wide/Fast for versions less than a 1040
5773: * (unless its SBus).
5774: */
5775: if (IS_ULTRA3(isp)) {
5776: off = ISP_80M_SYNCPARMS >> 8;
5777: per = ISP_80M_SYNCPARMS & 0xff;
5778: } else if (IS_ULTRA2(isp)) {
5779: off = ISP_40M_SYNCPARMS >> 8;
5780: per = ISP_40M_SYNCPARMS & 0xff;
5781: } else if (IS_1240(isp)) {
5782: off = ISP_20M_SYNCPARMS >> 8;
5783: per = ISP_20M_SYNCPARMS & 0xff;
5784: } else if ((isp->isp_bustype == ISP_BT_SBUS &&
5785: isp->isp_type < ISP_HA_SCSI_1020A) ||
5786: (isp->isp_bustype == ISP_BT_PCI &&
5787: isp->isp_type < ISP_HA_SCSI_1040) ||
5788: (isp->isp_clock && isp->isp_clock < 60) ||
5789: (sdp->isp_ultramode == 0)) {
5790: off = ISP_10M_SYNCPARMS >> 8;
5791: per = ISP_10M_SYNCPARMS & 0xff;
5792: } else {
5793: off = ISP_20M_SYNCPARMS_1040 >> 8;
5794: per = ISP_20M_SYNCPARMS_1040 & 0xff;
5795: }
5796: sdp->isp_devparam[tgt].goal_offset =
5797: sdp->isp_devparam[tgt].nvrm_offset = off;
5798: sdp->isp_devparam[tgt].goal_period =
5799: sdp->isp_devparam[tgt].nvrm_period = per;
5800:
5801: isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
5802: channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
5803: sdp->isp_devparam[tgt].nvrm_offset,
5804: sdp->isp_devparam[tgt].nvrm_period);
5805: }
5806: }
5807:
5808: /*
5809: * Re-initialize the ISP and complete all orphaned commands
5810: * with a 'botched' notice. The reset/init routines should
5811: * not disturb an already active list of commands.
5812: *
5813: * Locks held prior to coming here.
5814: */
5815:
5816: void
5817: isp_reinit(struct ispsoftc *isp)
5818: {
5819: XS_T *xs;
5820: u_int16_t handle;
5821:
5822: isp_reset(isp);
5823: if (isp->isp_state != ISP_RESETSTATE) {
5824: isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
5825: } else if (isp->isp_role != ISP_ROLE_NONE) {
5826: isp_init(isp);
5827: if (isp->isp_state == ISP_INITSTATE) {
5828: isp->isp_state = ISP_RUNSTATE;
5829: }
5830: if (isp->isp_state != ISP_RUNSTATE) {
5831: isp_prt(isp, ISP_LOGERR,
5832: "isp_reinit cannot restart card");
5833: }
5834: }
5835: isp->isp_nactive = 0;
5836:
5837: for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) {
5838: xs = isp_find_xs(isp, handle);
5839: if (xs == NULL) {
5840: continue;
5841: }
5842: isp_destroy_handle(isp, handle);
5843: if (XS_XFRLEN(xs)) {
5844: ISP_DMAFREE(isp, xs, handle);
5845: XS_RESID(xs) = XS_XFRLEN(xs);
5846: } else {
5847: XS_RESID(xs) = 0;
5848: }
5849: XS_SETERR(xs, HBA_BUSRESET);
5850: isp_done(xs);
5851: }
5852: }
5853:
5854: /*
5855: * NVRAM Routines
5856: */
5857: static int
5858: isp_read_nvram(struct ispsoftc *isp)
5859: {
5860: int i, amt;
5861: u_int8_t csum, minversion;
5862: union {
5863: u_int8_t _x[ISP2100_NVRAM_SIZE];
5864: u_int16_t _s[ISP2100_NVRAM_SIZE>>1];
5865: } _n;
5866: #define nvram_data _n._x
5867: #define nvram_words _n._s
5868:
5869: if (IS_FC(isp)) {
5870: amt = ISP2100_NVRAM_SIZE;
5871: minversion = 1;
5872: } else if (IS_ULTRA2(isp)) {
5873: amt = ISP1080_NVRAM_SIZE;
5874: minversion = 0;
5875: } else {
5876: amt = ISP_NVRAM_SIZE;
5877: minversion = 2;
5878: }
5879:
5880: /*
5881: * Just read the first two words first to see if we have a valid
5882: * NVRAM to continue reading the rest with.
5883: */
5884: for (i = 0; i < 2; i++) {
5885: isp_rdnvram_word(isp, i, &nvram_words[i]);
5886: }
5887: if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
5888: nvram_data[2] != 'P') {
5889: if (isp->isp_bustype != ISP_BT_SBUS) {
5890: isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
5891: isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
5892: nvram_data[0], nvram_data[1], nvram_data[2]);
5893: }
5894: return (-1);
5895: }
5896: for (i = 2; i < amt>>1; i++) {
5897: isp_rdnvram_word(isp, i, &nvram_words[i]);
5898: }
5899: for (csum = 0, i = 0; i < amt; i++) {
5900: csum += nvram_data[i];
5901: }
5902: if (csum != 0) {
5903: isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
5904: return (-1);
5905: }
5906: if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
5907: isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
5908: ISP_NVRAM_VERSION(nvram_data));
5909: return (-1);
5910: }
5911:
5912: if (IS_ULTRA3(isp)) {
5913: isp_parse_nvram_12160(isp, 0, nvram_data);
5914: if (IS_12160(isp))
5915: isp_parse_nvram_12160(isp, 1, nvram_data);
5916: } else if (IS_1080(isp)) {
5917: isp_parse_nvram_1080(isp, 0, nvram_data);
5918: } else if (IS_1280(isp) || IS_1240(isp)) {
5919: isp_parse_nvram_1080(isp, 0, nvram_data);
5920: isp_parse_nvram_1080(isp, 1, nvram_data);
5921: } else if (IS_SCSI(isp)) {
5922: isp_parse_nvram_1020(isp, nvram_data);
5923: } else {
5924: isp_parse_nvram_2100(isp, nvram_data);
5925: }
5926: return (0);
5927: #undef nvram_data
5928: #undef nvram_words
5929: }
5930:
5931: static void
5932: isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp)
5933: {
5934: int i, cbits;
5935: u_int16_t bit, rqst;
5936:
5937: ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
5938: USEC_DELAY(2);
5939: ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
5940: USEC_DELAY(2);
5941:
5942: if (IS_FC(isp)) {
5943: wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
5944: if (IS_2312(isp) && isp->isp_port) {
5945: wo += 128;
5946: }
5947: rqst = (ISP_NVRAM_READ << 8) | wo;
5948: cbits = 10;
5949: } else if (IS_ULTRA2(isp)) {
5950: wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
5951: rqst = (ISP_NVRAM_READ << 8) | wo;
5952: cbits = 10;
5953: } else {
5954: wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
5955: rqst = (ISP_NVRAM_READ << 6) | wo;
5956: cbits = 8;
5957: }
5958:
5959: /*
5960: * Clock the word select request out...
5961: */
5962: for (i = cbits; i >= 0; i--) {
5963: if ((rqst >> i) & 1) {
5964: bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
5965: } else {
5966: bit = BIU_NVRAM_SELECT;
5967: }
5968: ISP_WRITE(isp, BIU_NVRAM, bit);
5969: USEC_DELAY(2);
5970: ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
5971: USEC_DELAY(2);
5972: ISP_WRITE(isp, BIU_NVRAM, bit);
5973: USEC_DELAY(2);
5974: }
5975: /*
5976: * Now read the result back in (bits come back in MSB format).
5977: */
5978: *rp = 0;
5979: for (i = 0; i < 16; i++) {
5980: u_int16_t rv;
5981: *rp <<= 1;
5982: ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
5983: USEC_DELAY(2);
5984: rv = ISP_READ(isp, BIU_NVRAM);
5985: if (rv & BIU_NVRAM_DATAIN) {
5986: *rp |= 1;
5987: }
5988: USEC_DELAY(2);
5989: ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
5990: USEC_DELAY(2);
5991: }
5992: ISP_WRITE(isp, BIU_NVRAM, 0);
5993: USEC_DELAY(2);
5994: ISP_SWIZZLE_NVRAM_WORD(isp, rp);
5995: }
5996:
5997: static void
5998: isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data)
5999: {
6000: sdparam *sdp = (sdparam *) isp->isp_param;
6001: int tgt;
6002:
6003: sdp->isp_fifo_threshold =
6004: ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
6005: (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
6006:
6007: if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6008: sdp->isp_initiator_id =
6009: ISP_NVRAM_INITIATOR_ID(nvram_data);
6010:
6011: sdp->isp_bus_reset_delay =
6012: ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
6013:
6014: sdp->isp_retry_count =
6015: ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
6016:
6017: sdp->isp_retry_delay =
6018: ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
6019:
6020: sdp->isp_async_data_setup =
6021: ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
6022:
6023: if (isp->isp_type >= ISP_HA_SCSI_1040) {
6024: if (sdp->isp_async_data_setup < 9) {
6025: sdp->isp_async_data_setup = 9;
6026: }
6027: } else {
6028: if (sdp->isp_async_data_setup != 6) {
6029: sdp->isp_async_data_setup = 6;
6030: }
6031: }
6032:
6033: sdp->isp_req_ack_active_neg =
6034: ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
6035:
6036: sdp->isp_data_line_active_neg =
6037: ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
6038:
6039: sdp->isp_data_dma_burst_enabl =
6040: ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
6041:
6042: sdp->isp_cmd_dma_burst_enable =
6043: ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
6044:
6045: sdp->isp_tag_aging =
6046: ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
6047:
6048: sdp->isp_selection_timeout =
6049: ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
6050:
6051: sdp->isp_max_queue_depth =
6052: ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
6053:
6054: sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
6055:
6056: isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6057: 0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6058: sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6059: sdp->isp_retry_delay, sdp->isp_async_data_setup);
6060: isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6061: sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6062: sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6063: sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6064:
6065: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6066: sdp->isp_devparam[tgt].dev_enable =
6067: ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
6068: sdp->isp_devparam[tgt].exc_throttle =
6069: ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
6070: sdp->isp_devparam[tgt].nvrm_offset =
6071: ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
6072: sdp->isp_devparam[tgt].nvrm_period =
6073: ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
6074: /*
6075: * We probably shouldn't lie about this, but it
6076: * it makes it much safer if we limit NVRAM values
6077: * to sanity.
6078: */
6079: if (isp->isp_type < ISP_HA_SCSI_1040) {
6080: /*
6081: * If we're not ultra, we can't possibly
6082: * be a shorter period than this.
6083: */
6084: if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
6085: sdp->isp_devparam[tgt].nvrm_period = 0x19;
6086: }
6087: if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
6088: sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
6089: }
6090: } else {
6091: if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
6092: sdp->isp_devparam[tgt].nvrm_offset = 0x8;
6093: }
6094: }
6095: sdp->isp_devparam[tgt].nvrm_flags = 0;
6096: if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
6097: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6098: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6099: if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
6100: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6101: if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
6102: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6103: if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
6104: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6105: if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
6106: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6107: if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
6108: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6109: sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
6110: isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6111: 0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6112: sdp->isp_devparam[tgt].nvrm_offset,
6113: sdp->isp_devparam[tgt].nvrm_period);
6114: sdp->isp_devparam[tgt].goal_offset =
6115: sdp->isp_devparam[tgt].nvrm_offset;
6116: sdp->isp_devparam[tgt].goal_period =
6117: sdp->isp_devparam[tgt].nvrm_period;
6118: sdp->isp_devparam[tgt].goal_flags =
6119: sdp->isp_devparam[tgt].nvrm_flags;
6120: }
6121: }
6122:
6123: static void
6124: isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
6125: {
6126: sdparam *sdp = (sdparam *) isp->isp_param;
6127: int tgt;
6128:
6129: sdp += bus;
6130:
6131: sdp->isp_fifo_threshold =
6132: ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
6133:
6134: if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6135: sdp->isp_initiator_id =
6136: ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
6137:
6138: sdp->isp_bus_reset_delay =
6139: ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
6140:
6141: sdp->isp_retry_count =
6142: ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
6143:
6144: sdp->isp_retry_delay =
6145: ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
6146:
6147: sdp->isp_async_data_setup =
6148: ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
6149:
6150: sdp->isp_req_ack_active_neg =
6151: ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
6152:
6153: sdp->isp_data_line_active_neg =
6154: ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
6155:
6156: sdp->isp_data_dma_burst_enabl =
6157: ISP1080_NVRAM_BURST_ENABLE(nvram_data);
6158:
6159: sdp->isp_cmd_dma_burst_enable =
6160: ISP1080_NVRAM_BURST_ENABLE(nvram_data);
6161:
6162: sdp->isp_selection_timeout =
6163: ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
6164:
6165: sdp->isp_max_queue_depth =
6166: ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
6167:
6168: isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6169: bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6170: sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6171: sdp->isp_retry_delay, sdp->isp_async_data_setup);
6172: isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6173: sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6174: sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6175: sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6176:
6177:
6178: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6179: sdp->isp_devparam[tgt].dev_enable =
6180: ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
6181: sdp->isp_devparam[tgt].exc_throttle =
6182: ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
6183: sdp->isp_devparam[tgt].nvrm_offset =
6184: ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
6185: sdp->isp_devparam[tgt].nvrm_period =
6186: ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
6187: sdp->isp_devparam[tgt].nvrm_flags = 0;
6188: if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
6189: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6190: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6191: if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
6192: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6193: if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
6194: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6195: if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
6196: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6197: if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
6198: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6199: if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
6200: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6201: sdp->isp_devparam[tgt].actv_flags = 0;
6202: isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6203: bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6204: sdp->isp_devparam[tgt].nvrm_offset,
6205: sdp->isp_devparam[tgt].nvrm_period);
6206: sdp->isp_devparam[tgt].goal_offset =
6207: sdp->isp_devparam[tgt].nvrm_offset;
6208: sdp->isp_devparam[tgt].goal_period =
6209: sdp->isp_devparam[tgt].nvrm_period;
6210: sdp->isp_devparam[tgt].goal_flags =
6211: sdp->isp_devparam[tgt].nvrm_flags;
6212: }
6213: }
6214:
6215: static void
6216: isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
6217: {
6218: sdparam *sdp = (sdparam *) isp->isp_param;
6219: int tgt;
6220:
6221: sdp += bus;
6222:
6223: sdp->isp_fifo_threshold =
6224: ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
6225:
6226: if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6227: sdp->isp_initiator_id =
6228: ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
6229:
6230: sdp->isp_bus_reset_delay =
6231: ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
6232:
6233: sdp->isp_retry_count =
6234: ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
6235:
6236: sdp->isp_retry_delay =
6237: ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
6238:
6239: sdp->isp_async_data_setup =
6240: ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
6241:
6242: sdp->isp_req_ack_active_neg =
6243: ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
6244:
6245: sdp->isp_data_line_active_neg =
6246: ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
6247:
6248: sdp->isp_data_dma_burst_enabl =
6249: ISP12160_NVRAM_BURST_ENABLE(nvram_data);
6250:
6251: sdp->isp_cmd_dma_burst_enable =
6252: ISP12160_NVRAM_BURST_ENABLE(nvram_data);
6253:
6254: sdp->isp_selection_timeout =
6255: ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
6256:
6257: sdp->isp_max_queue_depth =
6258: ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
6259:
6260: isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6261: bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6262: sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6263: sdp->isp_retry_delay, sdp->isp_async_data_setup);
6264: isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6265: sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6266: sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6267: sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6268:
6269: for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6270: sdp->isp_devparam[tgt].dev_enable =
6271: ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
6272: sdp->isp_devparam[tgt].exc_throttle =
6273: ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
6274: sdp->isp_devparam[tgt].nvrm_offset =
6275: ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
6276: sdp->isp_devparam[tgt].nvrm_period =
6277: ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
6278: sdp->isp_devparam[tgt].nvrm_flags = 0;
6279: if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
6280: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6281: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6282: if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
6283: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6284: if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
6285: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6286: if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
6287: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6288: if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
6289: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6290: if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
6291: sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6292: sdp->isp_devparam[tgt].actv_flags = 0;
6293: isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6294: bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6295: sdp->isp_devparam[tgt].nvrm_offset,
6296: sdp->isp_devparam[tgt].nvrm_period);
6297: sdp->isp_devparam[tgt].goal_offset =
6298: sdp->isp_devparam[tgt].nvrm_offset;
6299: sdp->isp_devparam[tgt].goal_period =
6300: sdp->isp_devparam[tgt].nvrm_period;
6301: sdp->isp_devparam[tgt].goal_flags =
6302: sdp->isp_devparam[tgt].nvrm_flags;
6303: }
6304: }
6305:
6306: static void
6307: isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
6308: {
6309: fcparam *fcp = (fcparam *) isp->isp_param;
6310: u_int64_t wwn;
6311:
6312: /*
6313: * There is NVRAM storage for both Port and Node entities-
6314: * but the Node entity appears to be unused on all the cards
6315: * I can find. However, we should account for this being set
6316: * at some point in the future.
6317: *
6318: * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
6319: * bits 48..60. In the case of the 2202, it appears that they do
6320: * use bit 48 to distinguish between the two instances on the card.
6321: * The 2204, which I've never seen, *probably* extends this method.
6322: */
6323: wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
6324: if (wwn) {
6325: isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
6326: (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff));
6327: if ((wwn >> 60) == 0) {
6328: wwn |= (((u_int64_t) 2)<< 60);
6329: }
6330: }
6331: fcp->isp_portwwn = wwn;
6332: if (IS_2200(isp) || IS_23XX(isp)) {
6333: wwn = ISP2200_NVRAM_NODE_NAME(nvram_data);
6334: if (wwn) {
6335: isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
6336: (u_int32_t) (wwn >> 32),
6337: (u_int32_t) (wwn & 0xffffffff));
6338: if ((wwn >> 60) == 0) {
6339: wwn |= (((u_int64_t) 2)<< 60);
6340: }
6341: }
6342: } else {
6343: wwn &= ~((u_int64_t) 0xfff << 48);
6344: }
6345: fcp->isp_nodewwn = wwn;
6346:
6347: /*
6348: * Make sure we have both Node and Port as non-zero values.
6349: */
6350: if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) {
6351: fcp->isp_portwwn = fcp->isp_nodewwn;
6352: } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) {
6353: fcp->isp_nodewwn = fcp->isp_portwwn;
6354: }
6355:
6356: /*
6357: * Make the Node and Port values sane if they're NAA == 2.
6358: * This means to clear bits 48..56 for the Node WWN and
6359: * make sure that there's some non-zero value in 48..56
6360: * for the Port WWN.
6361: */
6362: if (fcp->isp_nodewwn && fcp->isp_portwwn) {
6363: if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 &&
6364: (fcp->isp_nodewwn >> 60) == 2) {
6365: fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48);
6366: }
6367: if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 &&
6368: (fcp->isp_portwwn >> 60) == 2) {
6369: fcp->isp_portwwn |= ((u_int64_t) 1 << 56);
6370: }
6371: }
6372:
6373: isp_prt(isp, ISP_LOGDEBUG0,
6374: "NVRAM: maxfrmlen %d execthrottle %d fwoptions 0x%x loopid %x",
6375: ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data),
6376: ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
6377: ISP2100_NVRAM_OPTIONS(nvram_data),
6378: ISP2100_NVRAM_HARDLOOPID(nvram_data));
6379:
6380: fcp->isp_maxalloc =
6381: ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
6382: if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0)
6383: fcp->isp_maxfrmlen =
6384: ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
6385: fcp->isp_retry_delay =
6386: ISP2100_NVRAM_RETRY_DELAY(nvram_data);
6387: fcp->isp_retry_count =
6388: ISP2100_NVRAM_RETRY_COUNT(nvram_data);
6389: if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6390: fcp->isp_loopid =
6391: ISP2100_NVRAM_HARDLOOPID(nvram_data);
6392: if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0)
6393: fcp->isp_execthrottle =
6394: ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
6395: fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
6396: }
6397:
6398: #ifdef ISP_FW_CRASH_DUMP
6399: static void isp2200_fw_dump(struct ispsoftc *);
6400: static void isp2300_fw_dump(struct ispsoftc *);
6401:
6402: static void
6403: isp2200_fw_dump(struct ispsoftc *isp)
6404: {
6405: int i, j;
6406: mbreg_t mbs;
6407: u_int16_t *ptr;
6408:
6409: ptr = FCPARAM(isp)->isp_dump_data;
6410: if (ptr == NULL) {
6411: isp_prt(isp, ISP_LOGERR,
6412: "No place to dump RISC registers and SRAM");
6413: return;
6414: }
6415: if (*ptr++) {
6416: isp_prt(isp, ISP_LOGERR,
6417: "dump area for RISC registers and SRAM already used");
6418: return;
6419: }
6420: ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6421: for (i = 0; i < 100; i++) {
6422: USEC_DELAY(100);
6423: if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6424: break;
6425: }
6426: }
6427: if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6428: /*
6429: * PBIU Registers
6430: */
6431: for (i = 0; i < 8; i++) {
6432: *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
6433: }
6434:
6435: /*
6436: * Mailbox Registers
6437: */
6438: for (i = 0; i < 8; i++) {
6439: *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
6440: }
6441:
6442: /*
6443: * DMA Registers
6444: */
6445: for (i = 0; i < 48; i++) {
6446: *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
6447: }
6448:
6449: /*
6450: * RISC H/W Registers
6451: */
6452: ISP_WRITE(isp, BIU2100_CSR, 0);
6453: for (i = 0; i < 16; i++) {
6454: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
6455: }
6456:
6457: /*
6458: * RISC GP Registers
6459: */
6460: for (j = 0; j < 8; j++) {
6461: ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
6462: for (i = 0; i < 16; i++) {
6463: *ptr++ =
6464: ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6465: }
6466: }
6467:
6468: /*
6469: * Frame Buffer Hardware Registers
6470: */
6471: ISP_WRITE(isp, BIU2100_CSR, 0x10);
6472: for (i = 0; i < 16; i++) {
6473: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6474: }
6475:
6476: /*
6477: * Fibre Protocol Module 0 Hardware Registers
6478: */
6479: ISP_WRITE(isp, BIU2100_CSR, 0x20);
6480: for (i = 0; i < 64; i++) {
6481: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6482: }
6483:
6484: /*
6485: * Fibre Protocol Module 1 Hardware Registers
6486: */
6487: ISP_WRITE(isp, BIU2100_CSR, 0x30);
6488: for (i = 0; i < 64; i++) {
6489: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6490: }
6491: } else {
6492: isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
6493: return;
6494: }
6495: isp_prt(isp, ISP_LOGALL,
6496: "isp_fw_dump: RISC registers dumped successfully");
6497: ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
6498: for (i = 0; i < 100; i++) {
6499: USEC_DELAY(100);
6500: if (ISP_READ(isp, OUTMAILBOX0) == 0) {
6501: break;
6502: }
6503: }
6504: if (ISP_READ(isp, OUTMAILBOX0) != 0) {
6505: isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
6506: return;
6507: }
6508: ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6509: for (i = 0; i < 100; i++) {
6510: USEC_DELAY(100);
6511: if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6512: break;
6513: }
6514: }
6515: if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
6516: isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
6517: return;
6518: }
6519: ISP_WRITE(isp, RISC_EMB, 0xf2);
6520: ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
6521: for (i = 0; i < 100; i++) {
6522: USEC_DELAY(100);
6523: if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
6524: break;
6525: }
6526: }
6527: ENABLE_INTS(isp);
6528: mbs.param[0] = MBOX_READ_RAM_WORD;
6529: mbs.param[1] = 0x1000;
6530: isp->isp_mbxworkp = (void *) ptr;
6531: isp->isp_mbxwrk0 = 0xefff; /* continuation count */
6532: isp->isp_mbxwrk1 = 0x1001; /* next SRAM address */
6533: isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6534: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6535: isp_prt(isp, ISP_LOGWARN,
6536: "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
6537: return;
6538: }
6539: ptr = isp->isp_mbxworkp; /* finish fetch of final word */
6540: *ptr++ = isp->isp_mboxtmp[2];
6541: isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
6542: FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
6543: (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
6544: }
6545:
6546: static void
6547: isp2300_fw_dump(struct ispsoftc *isp)
6548: {
6549: int i, j;
6550: mbreg_t mbs;
6551: u_int16_t *ptr;
6552:
6553: ptr = FCPARAM(isp)->isp_dump_data;
6554: if (ptr == NULL) {
6555: isp_prt(isp, ISP_LOGERR,
6556: "No place to dump RISC registers and SRAM");
6557: return;
6558: }
6559: if (*ptr++) {
6560: isp_prt(isp, ISP_LOGERR,
6561: "dump area for RISC registers and SRAM already used");
6562: return;
6563: }
6564: ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6565: for (i = 0; i < 100; i++) {
6566: USEC_DELAY(100);
6567: if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6568: break;
6569: }
6570: }
6571: if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6572: /*
6573: * PBIU registers
6574: */
6575: for (i = 0; i < 8; i++) {
6576: *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
6577: }
6578:
6579: /*
6580: * ReqQ-RspQ-Risc2Host Status registers
6581: */
6582: for (i = 0; i < 8; i++) {
6583: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
6584: }
6585:
6586: /*
6587: * Mailbox Registers
6588: */
6589: for (i = 0; i < 32; i++) {
6590: *ptr++ =
6591: ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
6592: }
6593:
6594: /*
6595: * Auto Request Response DMA registers
6596: */
6597: ISP_WRITE(isp, BIU2100_CSR, 0x40);
6598: for (i = 0; i < 32; i++) {
6599: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6600: }
6601:
6602: /*
6603: * DMA registers
6604: */
6605: ISP_WRITE(isp, BIU2100_CSR, 0x50);
6606: for (i = 0; i < 48; i++) {
6607: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6608: }
6609:
6610: /*
6611: * RISC hardware registers
6612: */
6613: ISP_WRITE(isp, BIU2100_CSR, 0);
6614: for (i = 0; i < 16; i++) {
6615: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
6616: }
6617:
6618: /*
6619: * RISC GP? registers
6620: */
6621: for (j = 0; j < 8; j++) {
6622: ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
6623: for (i = 0; i < 16; i++) {
6624: *ptr++ =
6625: ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6626: }
6627: }
6628:
6629: /*
6630: * frame buffer hardware registers
6631: */
6632: ISP_WRITE(isp, BIU2100_CSR, 0x10);
6633: for (i = 0; i < 64; i++) {
6634: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6635: }
6636:
6637: /*
6638: * FPM B0 hardware registers
6639: */
6640: ISP_WRITE(isp, BIU2100_CSR, 0x20);
6641: for (i = 0; i < 64; i++) {
6642: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6643: }
6644:
6645: /*
6646: * FPM B1 hardware registers
6647: */
6648: ISP_WRITE(isp, BIU2100_CSR, 0x30);
6649: for (i = 0; i < 64; i++) {
6650: *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6651: }
6652: } else {
6653: isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
6654: return;
6655: }
6656: isp_prt(isp, ISP_LOGALL,
6657: "isp_fw_dump: RISC registers dumped successfully");
6658: ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
6659: for (i = 0; i < 100; i++) {
6660: USEC_DELAY(100);
6661: if (ISP_READ(isp, OUTMAILBOX0) == 0) {
6662: break;
6663: }
6664: }
6665: if (ISP_READ(isp, OUTMAILBOX0) != 0) {
6666: isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
6667: return;
6668: }
6669: ENABLE_INTS(isp);
6670: mbs.param[0] = MBOX_READ_RAM_WORD;
6671: mbs.param[1] = 0x800;
6672: isp->isp_mbxworkp = (void *) ptr;
6673: isp->isp_mbxwrk0 = 0xf7ff; /* continuation count */
6674: isp->isp_mbxwrk1 = 0x801; /* next SRAM address */
6675: isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6676: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6677: isp_prt(isp, ISP_LOGWARN,
6678: "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
6679: return;
6680: }
6681: ptr = isp->isp_mbxworkp; /* finish fetch of final word */
6682: *ptr++ = isp->isp_mboxtmp[2];
6683:
6684: /*
6685: * We don't have access to mailbox registers 8.. onward
6686: * in our 'common' device model- so we have to set it
6687: * here and hope it stays the same!
6688: */
6689: ISP_WRITE(isp, PCI_MBOX_REGS2300_OFF + (8 << 1), 0x1);
6690:
6691: mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
6692: mbs.param[1] = 0;
6693: isp->isp_mbxworkp = (void *) ptr;
6694: isp->isp_mbxwrk0 = 0xffff; /* continuation count */
6695: isp->isp_mbxwrk1 = 0x1; /* next SRAM address */
6696: isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6697: if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6698: isp_prt(isp, ISP_LOGWARN,
6699: "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
6700: return;
6701: }
6702: ptr = isp->isp_mbxworkp; /* finish final word */
6703: *ptr++ = mbs.param[2];
6704: isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
6705: FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
6706: (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
6707: }
6708:
6709: void
6710: isp_fw_dump(struct ispsoftc *isp)
6711: {
6712: if (IS_2200(isp))
6713: isp2200_fw_dump(isp);
6714: else if (IS_23XX(isp))
6715: isp2300_fw_dump(isp);
6716: }
6717: #endif