![[BACK]](/icons/back.gif){kind=icon}
Return to isp_openbsd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to isp_openbsd.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: isp_openbsd.c,v 1.30 2007/04/10 17:47:55 miod Exp $ */
2: /*
3: * Platform (OpenBSD) dependent common attachment code for Qlogic adapters.
4: *
5: * Copyright (c) 1999, 2000, 2001 by Matthew Jacob
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice immediately at the beginning of the file, without modification,
13: * this list of conditions, and the following disclaimer.
14: * documentation and/or other materials provided with the distribution.
15: * 2. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
22: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: *
30: * The author may be reached via electronic communications at
31: *
32: * mjacob@feral.com
33: *
34: * or, via United States Postal Address
35: *
36: * Matthew Jacob
37: * Feral Software
38: * PMB#825
39: * 5214-F Diamond Heights Blvd.
40: * San Francisco, CA, 94131
41: */
42:
43: /* expand expensive inline functions here. */
44: #define EXPENSIVE_INLINE
45: #include <dev/ic/isp_openbsd.h>
46:
47: /*
48: * Set a timeout for the watchdogging of a command.
49: *
50: * The dimensional analysis is
51: *
52: * milliseconds * (seconds/millisecond) * (ticks/second) = ticks
53: *
54: * =
55: *
56: * (milliseconds / 1000) * hz = ticks
57: *
58: *
59: * For timeouts less than 1 second, we'll get zero. Because of this, and
60: * because we want to establish *our* timeout to be longer than what the
61: * firmware might do, we just add 3 seconds at the back end.
62: */
63: #define _XT(xs) ((((xs)->timeout/1000) * hz) + (3 * hz))
64:
65: static void ispminphys(struct buf *);
66: static int32_t ispcmd_slow(XS_T *);
67: static int32_t ispcmd(XS_T *);
68:
69: static struct scsi_device isp_dev = { NULL, NULL, NULL, NULL };
70:
71: static int isp_polled_cmd (struct ispsoftc *, XS_T *);
72: static void isp_wdog (void *);
73: static void isp_requeue(void *);
74: static void isp_trestart(void *);
75: static void isp_restart(struct ispsoftc *);
76:
77: struct cfdriver isp_cd = {
78: NULL, "isp", DV_DULL
79: };
80:
81:
82: /*
83: * Complete attachment of hardware, include subdevices.
84: */
85: void
86: isp_attach(struct ispsoftc *isp)
87: {
88: struct scsibus_attach_args saa;
89: struct scsi_link *lptr = &isp->isp_osinfo._link[0];
90: isp->isp_osinfo._adapter.scsi_minphys = ispminphys;
91:
92: isp->isp_state = ISP_RUNSTATE;
93:
94: /*
95: * We only manage a single wait queues for dual bus controllers.
96: * This is arguably broken.
97: */
98: isp->isp_osinfo.wqf = isp->isp_osinfo.wqt = NULL;
99:
100: lptr->adapter_softc = isp;
101: lptr->device = &isp_dev;
102: lptr->adapter = &isp->isp_osinfo._adapter;
103: lptr->openings = imin(isp->isp_maxcmds, MAXISPREQUEST(isp));
104: isp->isp_osinfo._adapter.scsi_cmd = ispcmd_slow;
105: if (IS_FC(isp)) {
106: lptr->adapter_buswidth = MAX_FC_TARG;
107: /* We can set max lun width here */
108: /* loopid set below */
109: } else {
110: sdparam *sdp = isp->isp_param;
111: lptr->adapter_buswidth = MAX_TARGETS;
112: /* We can set max lun width here */
113: lptr->adapter_target = sdp->isp_initiator_id;
114: isp->isp_osinfo.discovered[0] = 1 << sdp->isp_initiator_id;
115: if (IS_DUALBUS(isp)) {
116: struct scsi_link *lptrb = &isp->isp_osinfo._link[1];
117: lptrb->adapter_softc = isp;
118: lptrb->device = &isp_dev;
119: lptrb->adapter = &isp->isp_osinfo._adapter;
120: lptrb->openings = lptr->openings;
121: lptrb->adapter_buswidth = MAX_TARGETS;
122: lptrb->adapter_target = sdp->isp_initiator_id;
123: lptrb->flags = SDEV_2NDBUS;
124: isp->isp_osinfo.discovered[1] =
125: 1 << (sdp+1)->isp_initiator_id;
126: }
127: }
128:
129: /*
130: * Send a SCSI Bus Reset (used to be done as part of attach,
131: * but now left to the OS outer layers).
132: *
133: * We don't do 'bus resets' for FC because the LIP that occurs
134: * when we start the firmware does all that for us.
135: */
136: if (IS_SCSI(isp)) {
137: int bus = 0;
138: ISP_LOCK(isp);
139: (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
140: if (IS_DUALBUS(isp)) {
141: bus++;
142: (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
143: }
144: ISP_UNLOCK(isp);
145: /*
146: * wait for the bus to settle.
147: */
148: delay(4 * 1000000);
149: } else {
150: fcparam *fcp = isp->isp_param;
151: int defid = MAX_FC_TARG;
152: delay(2 * 1000000);
153: ISP_LOCK(isp);
154: isp_fc_runstate(isp, 10 * 1000000);
155: if (fcp->isp_fwstate == FW_READY &&
156: fcp->isp_loopstate >= LOOP_PDB_RCVD) {
157: defid = fcp->isp_loopid;
158: }
159: ISP_UNLOCK(isp);
160: lptr->adapter_target = defid;
161: }
162:
163: bzero(&saa, sizeof(saa));
164: saa.saa_sc_link = lptr;
165:
166: /*
167: * And attach children (if any).
168: */
169: config_found((void *)isp, &saa, scsiprint);
170: if (IS_DUALBUS(isp)) {
171: lptr++;
172: bzero(&saa, sizeof(saa));
173: saa.saa_sc_link = lptr;
174: config_found((void *)isp, &saa, scsiprint);
175: }
176: }
177:
178: /*
179: * minphys our xfers
180: *
181: * Unfortunately, the buffer pointer describes the target device- not the
182: * adapter device, so we can't use the pointer to find out what kind of
183: * adapter we are and adjust accordingly.
184: */
185:
186: static void
187: ispminphys(struct buf *bp)
188: {
189: /*
190: * XX: Only the 1020 has a 24 bit limit.
191: */
192: if (bp->b_bcount >= (1 << 24)) {
193: bp->b_bcount = (1 << 24);
194: }
195: minphys(bp);
196: }
197:
198: static int32_t
199: ispcmd_slow(XS_T *xs)
200: {
201: sdparam *sdp;
202: int tgt, chan;
203: u_int16_t f;
204: struct ispsoftc *isp = XS_ISP(xs);
205:
206: if (IS_FC(isp)) {
207: if (cold == 0) {
208: isp->isp_osinfo.no_mbox_ints = 0;
209: isp->isp_osinfo._adapter.scsi_cmd = ispcmd;
210: }
211: return (ispcmd(xs));
212: }
213:
214: /*
215: * Have we completed discovery for this target on this adapter?
216: */
217: sdp = isp->isp_param;
218: tgt = XS_TGT(xs);
219: chan = XS_CHANNEL(xs);
220: sdp += chan;
221: if ((xs->flags & SCSI_POLL) != 0 ||
222: (isp->isp_osinfo.discovered[chan] & (1 << tgt)) != 0) {
223: return (ispcmd(xs));
224: }
225: if (cold == 0) {
226: isp->isp_osinfo.no_mbox_ints = 0;
227: }
228:
229: f = DPARM_DEFAULT;
230: if (xs->sc_link->quirks & SDEV_NOSYNC) {
231: f &= ~DPARM_SYNC;
232: }
233: if (xs->sc_link->quirks & SDEV_NOWIDE) {
234: f &= ~DPARM_WIDE;
235: }
236: if (xs->sc_link->quirks & SDEV_NOTAGS) {
237: f &= ~DPARM_TQING;
238: }
239:
240: /*
241: * Okay, we know about this device now,
242: * so mark parameters to be updated for it.
243: */
244: sdp->isp_devparam[tgt].goal_flags = f;
245: sdp->isp_devparam[tgt].dev_update = 1;
246: isp->isp_update |= (1 << chan);
247:
248: /*
249: * Now check to see whether we can get out of this checking mode now.
250: * XXX: WE CANNOT AS YET BECAUSE THERE IS NO MECHANISM TO TELL US
251: * XXX: WHEN WE'RE DONE DISCOVERY BECAUSE WE NEED ONE COMMAND AFTER
252: * XXX: DISCOVERY IS DONE FOR EACH TARGET TO TELL US THAT WE'RE DONE
253: * XXX: AND THAT DOESN'T HAPPEN HERE. AT BEST WE CAN MARK OURSELVES
254: * XXX: DONE WITH DISCOVERY FOR THIS TARGET AND SO SAVE MAYBE 20
255: * XXX: LINES OF C CODE.
256: */
257: isp->isp_osinfo.discovered[chan] |= (1 << tgt);
258: /* do not bother with these lines- they'll never execute correctly */
259: #if 0
260: sdp = isp->isp_param;
261: for (chan = 0; chan < (IS_12X0(isp)? 2 : 1); chan++, sdp++) {
262: f = 0xffff & ~(1 << sdp->isp_initiator_id);
263: if (isp->isp_osinfo.discovered[chan] != f) {
264: break;
265: }
266: }
267: if (chan == (IS_12X0(isp)? 2 : 1)) {
268: isp->isp_osinfo._adapter.scsipi_cmd = ispcmd;
269: if (IS_12X0(isp))
270: isp->isp_update |= 2;
271: }
272: #endif
273: return (ispcmd(xs));
274: }
275:
276: static INLINE void isp_add2_blocked_queue(struct ispsoftc *, XS_T *);
277:
278: static INLINE void
279: isp_add2_blocked_queue(struct ispsoftc *isp, XS_T *xs)
280: {
281: if (isp->isp_osinfo.wqf != NULL) {
282: isp->isp_osinfo.wqt->free_list.le_next = xs;
283: } else {
284: isp->isp_osinfo.wqf = xs;
285: }
286: isp->isp_osinfo.wqt = xs;
287: xs->free_list.le_next = NULL;
288: }
289:
290: static int32_t
291: ispcmd(XS_T *xs)
292: {
293: struct ispsoftc *isp;
294: int result;
295:
296:
297: /*
298: * Make sure that there's *some* kind of sane setting.
299: */
300: isp = XS_ISP(xs);
301:
302: timeout_set(&xs->stimeout, isp_wdog, isp);
303:
304: if (XS_LUN(xs) >= isp->isp_maxluns) {
305: xs->error = XS_SELTIMEOUT;
306: return (COMPLETE);
307: }
308:
309: ISP_LOCK(isp);
310: if (isp->isp_state < ISP_RUNSTATE) {
311: DISABLE_INTS(isp);
312: isp_init(isp);
313: if (isp->isp_state != ISP_INITSTATE) {
314: ENABLE_INTS(isp);
315: ISP_UNLOCK(isp);
316: XS_SETERR(xs, HBA_BOTCH);
317: return (CMD_COMPLETE);
318: }
319: isp->isp_state = ISP_RUNSTATE;
320: ENABLE_INTS(isp);
321: }
322:
323: /*
324: * Check for queue blockage...
325: */
326: if (isp->isp_osinfo.blocked) {
327: if (xs->flags & SCSI_POLL) {
328: ISP_UNLOCK(isp);
329: return (TRY_AGAIN_LATER);
330: }
331: if (isp->isp_osinfo.blocked == 2) {
332: isp_restart(isp);
333: }
334: if (isp->isp_osinfo.blocked) {
335: isp_add2_blocked_queue(isp, xs);
336: ISP_UNLOCK(isp);
337: isp_prt(isp, ISP_LOGDEBUG0, "added to blocked queue");
338: return (SUCCESSFULLY_QUEUED);
339: }
340: }
341:
342: if (xs->flags & SCSI_POLL) {
343: volatile u_int8_t ombi = isp->isp_osinfo.no_mbox_ints;
344: isp->isp_osinfo.no_mbox_ints = 1;
345: result = isp_polled_cmd(isp, xs);
346: isp->isp_osinfo.no_mbox_ints = ombi;
347: ISP_UNLOCK(isp);
348: return (result);
349: }
350:
351: result = isp_start(xs);
352:
353: switch (result) {
354: case CMD_QUEUED:
355: result = SUCCESSFULLY_QUEUED;
356: if (xs->timeout) {
357: timeout_add(&xs->stimeout, _XT(xs));
358: XS_CMD_S_TIMER(xs);
359: }
360: if (isp->isp_osinfo.hiwater < isp->isp_nactive) {
361: isp->isp_osinfo.hiwater = isp->isp_nactive;
362: isp_prt(isp, ISP_LOGDEBUG0,
363: "Active Hiwater Mark=%d", isp->isp_nactive);
364: }
365: break;
366: case CMD_EAGAIN:
367: isp->isp_osinfo.blocked |= 2;
368: isp_prt(isp, ISP_LOGDEBUG0, "blocking queue");
369: isp_add2_blocked_queue(isp, xs);
370: result = SUCCESSFULLY_QUEUED;
371: break;
372: case CMD_RQLATER:
373: result = SUCCESSFULLY_QUEUED; /* Lie */
374: isp_prt(isp, ISP_LOGDEBUG1, "retrying later for %d.%d",
375: XS_TGT(xs), XS_LUN(xs));
376: timeout_set(&xs->stimeout, isp_requeue, xs);
377: timeout_add(&xs->stimeout, hz);
378: XS_CMD_S_TIMER(xs);
379: break;
380: case CMD_COMPLETE:
381: result = COMPLETE;
382: break;
383: }
384: ISP_UNLOCK(isp);
385: return (result);
386: }
387:
388: static int
389: isp_polled_cmd(struct ispsoftc *isp, XS_T *xs)
390: {
391: int result;
392: int infinite = 0, mswait;
393:
394: result = isp_start(xs);
395:
396: switch (result) {
397: case CMD_QUEUED:
398: result = SUCCESSFULLY_QUEUED;
399: break;
400: case CMD_RQLATER:
401: case CMD_EAGAIN:
402: result = TRY_AGAIN_LATER;
403: break;
404: case CMD_COMPLETE:
405: result = COMPLETE;
406: break;
407:
408: }
409:
410: if (result != SUCCESSFULLY_QUEUED) {
411: return (result);
412: }
413:
414: /*
415: * If we can't use interrupts, poll on completion.
416: */
417: if ((mswait = XS_TIME(xs)) == 0)
418: infinite = 1;
419:
420: while (mswait || infinite) {
421: u_int16_t isr, sema, mbox;
422: if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
423: isp_intr(isp, isr, sema, mbox);
424: if (XS_CMD_DONE_P(xs)) {
425: break;
426: }
427: }
428: USEC_DELAY(1000);
429: mswait -= 1;
430: }
431:
432: /*
433: * If no other error occurred but we didn't finish,
434: * something bad happened.
435: */
436: if (XS_CMD_DONE_P(xs) == 0) {
437: if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
438: isp_reinit(isp);
439: }
440: if (XS_NOERR(xs)) {
441: XS_SETERR(xs, HBA_BOTCH);
442: }
443: }
444: result = COMPLETE;
445: return (result);
446: }
447:
448: void
449: isp_done(XS_T *xs)
450: {
451: XS_CMD_S_DONE(xs);
452: if (XS_CMD_WDOG_P(xs) == 0) {
453: struct ispsoftc *isp = XS_ISP(xs);
454: if (XS_CMD_TIMER_P(xs)) {
455: timeout_del(&xs->stimeout);
456: XS_CMD_C_TIMER(xs);
457: }
458: if (XS_CMD_GRACE_P(xs)) {
459: struct ispsoftc *isp = XS_ISP(xs);
460: isp_prt(isp, ISP_LOGWARN,
461: "finished command on borrowed time");
462: }
463: XS_CMD_S_CLEAR(xs);
464: scsi_done(xs);
465: if (isp->isp_osinfo.blocked == 2) {
466: isp->isp_osinfo.blocked = 0;
467: isp_prt(isp, ISP_LOGDEBUG0, "restarting blocked queue");
468: isp_restart(isp);
469: }
470: }
471: }
472:
473: static void
474: isp_wdog(void *arg)
475: {
476: XS_T *xs = arg;
477: struct ispsoftc *isp = XS_ISP(xs);
478: u_int32_t handle;
479:
480: /*
481: * We've decided this command is dead. Make sure we're not trying
482: * to kill a command that's already dead by getting its handle and
483: * and seeing whether it's still alive.
484: */
485: ISP_LOCK(isp);
486: handle = isp_find_handle(isp, xs);
487: if (handle) {
488: u_int16_t isr, sema, mbox;
489:
490: if (XS_CMD_DONE_P(xs)) {
491: isp_prt(isp, ISP_LOGDEBUG1,
492: "watchdog found done cmd (handle 0x%x)",
493: handle);
494: ISP_UNLOCK(isp);
495: return;
496: }
497:
498: if (XS_CMD_WDOG_P(xs)) {
499: isp_prt(isp, ISP_LOGDEBUG1,
500: "recursive watchdog (handle 0x%x)",
501: handle);
502: ISP_UNLOCK(isp);
503: return;
504: }
505:
506: XS_CMD_S_WDOG(xs);
507:
508: if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
509: isp_intr(isp, isr, sema, mbox);
510: }
511:
512: if (XS_CMD_DONE_P(xs)) {
513: isp_prt(isp, ISP_LOGINFO,
514: "watchdog cleanup for handle 0x%x", handle);
515: XS_CMD_C_WDOG(xs);
516: isp_done(xs);
517: } else if (XS_CMD_GRACE_P(xs)) {
518: /*
519: * Make sure the command is *really* dead before we
520: * release the handle (and DMA resources) for reuse.
521: */
522: (void) isp_control(isp, ISPCTL_ABORT_CMD, arg);
523:
524: /*
525: * After this point, the command is really dead.
526: */
527: if (XS_XFRLEN(xs)) {
528: ISP_DMAFREE(isp, xs, handle);
529: }
530: isp_prt(isp, ISP_LOGWARN,
531: "watchdog timeout on handle %x", handle);
532: isp_destroy_handle(isp, handle);
533: XS_SETERR(xs, XS_TIMEOUT);
534: XS_CMD_S_CLEAR(xs);
535: isp_done(xs);
536: } else {
537: u_int16_t nxti, optr;
538: ispreq_t local, *mp = &local, *qe;
539:
540: isp_prt(isp, ISP_LOGWARN,
541: "possible command timeout on handle %x", handle);
542:
543: XS_CMD_C_WDOG(xs);
544: timeout_add(&xs->stimeout, _XT(xs));
545: XS_CMD_S_TIMER(xs);
546: if (isp_getrqentry(isp, &nxti, &optr, (void **) &qe)) {
547: ISP_UNLOCK(isp);
548: return;
549: }
550: XS_CMD_S_GRACE(xs);
551: MEMZERO((void *) mp, sizeof (*mp));
552: mp->req_header.rqs_entry_count = 1;
553: mp->req_header.rqs_entry_type = RQSTYPE_MARKER;
554: mp->req_modifier = SYNC_ALL;
555: mp->req_target = XS_CHANNEL(xs) << 7;
556: isp_put_request(isp, mp, qe);
557: ISP_ADD_REQUEST(isp, nxti);
558: }
559: } else if (isp->isp_dblev) {
560: isp_prt(isp, ISP_LOGDEBUG1, "watchdog with no command");
561: }
562: ISP_UNLOCK(isp);
563: }
564:
565: /*
566: * Free any associated resources prior to decommissioning and
567: * set the card to a known state (so it doesn't wake up and kick
568: * us when we aren't expecting it to).
569: *
570: * Locks are held before coming here.
571: */
572: void
573: isp_uninit(struct ispsoftc *isp)
574: {
575: ISP_LOCK(isp);
576: /*
577: * Leave with interrupts disabled.
578: */
579: DISABLE_INTS(isp);
580:
581: ISP_UNLOCK(isp);
582: }
583:
584: /*
585: * Restart function for a command to be requeued later.
586: */
587: static void
588: isp_requeue(void *arg)
589: {
590: int r;
591: struct scsi_xfer *xs = arg;
592: struct ispsoftc *isp = XS_ISP(xs);
593: ISP_LOCK(isp);
594: r = isp_start(xs);
595: switch (r) {
596: case CMD_QUEUED:
597: isp_prt(isp, ISP_LOGDEBUG1, "restarted command for %d.%d",
598: XS_TGT(xs), XS_LUN(xs));
599: if (xs->timeout) {
600: timeout_set(&xs->stimeout, isp_wdog, isp);
601: timeout_add(&xs->stimeout, _XT(xs));
602: XS_CMD_S_TIMER(xs);
603: }
604: break;
605: case CMD_EAGAIN:
606: isp_prt(isp, ISP_LOGDEBUG0, "blocked cmd again");
607: isp->isp_osinfo.blocked |= 2;
608: isp_add2_blocked_queue(isp, xs);
609: break;
610: case CMD_RQLATER:
611: isp_prt(isp, ISP_LOGDEBUG0, "%s for %d.%d",
612: (r == CMD_EAGAIN)? "CMD_EAGAIN" : "CMD_RQLATER",
613: XS_TGT(xs), XS_LUN(xs));
614: timeout_set(&xs->stimeout, isp_requeue, xs);
615: timeout_add(&xs->stimeout, hz);
616: XS_CMD_S_TIMER(xs);
617: break;
618: case CMD_COMPLETE:
619: /* can only be an error */
620: if (XS_NOERR(xs))
621: XS_SETERR(xs, XS_DRIVER_STUFFUP);
622: isp_done(xs);
623: break;
624: }
625: ISP_UNLOCK(isp);
626: }
627:
628: /*
629: * Restart function after a LOOP UP event or a command completing,
630: * sometimes done as a timeout for some hysteresis.
631: */
632: static void
633: isp_trestart(void *arg)
634: {
635: struct ispsoftc *isp = arg;
636: struct scsi_xfer *list;
637:
638: ISP_LOCK(isp);
639: isp->isp_osinfo.rtpend = 0;
640: list = isp->isp_osinfo.wqf;
641: if (isp->isp_osinfo.blocked == 0 && list != NULL) {
642: int nrestarted = 0;
643:
644: isp->isp_osinfo.wqf = NULL;
645: ISP_UNLOCK(isp);
646: do {
647: struct scsi_xfer *xs = list;
648: list = xs->free_list.le_next;
649: xs->free_list.le_next = NULL;
650: isp_requeue(xs);
651: if (isp->isp_osinfo.wqf == NULL)
652: nrestarted++;
653: } while (list != NULL);
654: isp_prt(isp, ISP_LOGDEBUG0, "requeued %d commands", nrestarted);
655: } else {
656: ISP_UNLOCK(isp);
657: }
658: }
659:
660: static void
661: isp_restart(struct ispsoftc *isp)
662: {
663: struct scsi_xfer *list;
664:
665: list = isp->isp_osinfo.wqf;
666: if (isp->isp_osinfo.blocked == 0 && list != NULL) {
667: int nrestarted = 0;
668:
669: isp->isp_osinfo.wqf = NULL;
670: do {
671: struct scsi_xfer *xs = list;
672: list = xs->free_list.le_next;
673: xs->free_list.le_next = NULL;
674: isp_requeue(xs);
675: if (isp->isp_osinfo.wqf == NULL)
676: nrestarted++;
677: } while (list != NULL);
678: isp_prt(isp, ISP_LOGDEBUG0, "requeued %d commands", nrestarted);
679: }
680: }
681:
682: int
683: isp_async(struct ispsoftc *isp, ispasync_t cmd, void *arg)
684: {
685: int bus, tgt;
686:
687: switch (cmd) {
688: case ISPASYNC_NEW_TGT_PARAMS:
689: if (IS_SCSI(isp) && isp->isp_dblev) {
690: sdparam *sdp = isp->isp_param;
691: char *wt;
692: int mhz, flags, period;
693:
694: tgt = *((int *) arg);
695: bus = (tgt >> 16) & 0xffff;
696: tgt &= 0xffff;
697: sdp += bus;
698: flags = sdp->isp_devparam[tgt].actv_flags;
699: period = sdp->isp_devparam[tgt].actv_period;
700:
701: if ((flags & DPARM_SYNC) && period &&
702: (sdp->isp_devparam[tgt].actv_offset) != 0) {
703: /*
704: * There's some ambiguity about our negotiated speed
705: * if we haven't detected LVD mode correctly (which
706: * seems to happen, unfortunately). If we're in LVD
707: * mode, then different rules apply about speed.
708: */
709: if (sdp->isp_lvdmode || period < 0xc) {
710: switch (period) {
711: case 0x9:
712: mhz = 80;
713: break;
714: case 0xa:
715: mhz = 40;
716: break;
717: case 0xb:
718: mhz = 33;
719: break;
720: case 0xc:
721: mhz = 25;
722: break;
723: default:
724: mhz = 1000 / (period * 4);
725: break;
726: }
727: } else {
728: mhz = 1000 / (period * 4);
729: }
730: } else {
731: mhz = 0;
732: }
733: switch (flags & (DPARM_WIDE|DPARM_TQING)) {
734: case DPARM_WIDE:
735: wt = ", 16 bit wide";
736: break;
737: case DPARM_TQING:
738: wt = ", Tagged Queueing Enabled";
739: break;
740: case DPARM_WIDE|DPARM_TQING:
741: wt = ", 16 bit wide, Tagged Queueing Enabled";
742: break;
743: default:
744: wt = " ";
745: break;
746: }
747: if (mhz) {
748: isp_prt(isp, ISP_LOGINFO,
749: "Bus %d Target %d at %dMHz Max Offset %d%s",
750: bus, tgt, mhz, sdp->isp_devparam[tgt].actv_offset,
751: wt);
752: } else {
753: isp_prt(isp, ISP_LOGINFO,
754: "Bus %d Target %d Async Mode%s", bus, tgt, wt);
755: }
756: break;
757: }
758: case ISPASYNC_BUS_RESET:
759: if (arg)
760: bus = *((int *) arg);
761: else
762: bus = 0;
763: isp_prt(isp, ISP_LOGINFO, "SCSI bus %d reset detected", bus);
764: break;
765: case ISPASYNC_LOOP_DOWN:
766: /*
767: * Hopefully we get here in time to minimize the number
768: * of commands we are firing off that are sure to die.
769: */
770: isp->isp_osinfo.blocked |= 1;
771: isp_prt(isp, ISP_LOGINFO, "Loop DOWN");
772: break;
773: case ISPASYNC_LOOP_UP:
774: isp->isp_osinfo.blocked &= ~1;
775: if (isp->isp_osinfo.rtpend == 0) {
776: timeout_set(&isp->isp_osinfo.rqt, isp_trestart, isp);
777: isp->isp_osinfo.rtpend = 1;
778: }
779: timeout_add(&isp->isp_osinfo.rqt, 1);
780: isp_prt(isp, ISP_LOGINFO, "Loop UP");
781: break;
782: case ISPASYNC_PROMENADE:
783: if (IS_FC(isp) && isp->isp_dblev) {
784: const char *fmt = "Target %d (Loop 0x%x) Port ID 0x%x "
785: "role %s %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x";
786: const static char *roles[4] = {
787: "No", "Target", "Initiator", "Target/Initiator"
788: };
789: fcparam *fcp = isp->isp_param;
790: int tgt = *((int *) arg);
791: struct lportdb *lp = &fcp->portdb[tgt];
792:
793: isp_prt(isp, ISP_LOGINFO, fmt, tgt, lp->loopid, lp->portid,
794: roles[lp->roles & 0x3],
795: (lp->valid)? "Arrived" : "Departed",
796: (u_int32_t) (lp->port_wwn >> 32),
797: (u_int32_t) (lp->port_wwn & 0xffffffffLL),
798: (u_int32_t) (lp->node_wwn >> 32),
799: (u_int32_t) (lp->node_wwn & 0xffffffffLL));
800: break;
801: }
802: case ISPASYNC_CHANGE_NOTIFY:
803: if (arg == (void *) 1) {
804: isp_prt(isp, ISP_LOGINFO,
805: "Name Server Database Changed");
806: } else {
807: isp_prt(isp, ISP_LOGINFO,
808: "Name Server Database Changed");
809: }
810: break;
811: case ISPASYNC_FABRIC_DEV:
812: {
813: int target, base, lim;
814: fcparam *fcp = isp->isp_param;
815: struct lportdb *lp = NULL;
816: struct lportdb *clp = (struct lportdb *) arg;
817: char *pt;
818:
819: switch (clp->port_type) {
820: case 1:
821: pt = " N_Port";
822: break;
823: case 2:
824: pt = " NL_Port";
825: break;
826: case 3:
827: pt = "F/NL_Port";
828: break;
829: case 0x7f:
830: pt = " Nx_Port";
831: break;
832: case 0x81:
833: pt = " F_port";
834: break;
835: case 0x82:
836: pt = " FL_Port";
837: break;
838: case 0x84:
839: pt = " E_port";
840: break;
841: default:
842: pt = " ";
843: break;
844: }
845:
846: isp_prt(isp, ISP_LOGINFO,
847: "%s Fabric Device @ PortID 0x%x", pt, clp->portid);
848:
849: /*
850: * If we don't have an initiator role we bail.
851: *
852: * We just use ISPASYNC_FABRIC_DEV for announcement purposes.
853: */
854:
855: if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
856: break;
857: }
858:
859: /*
860: * Is this entry for us? If so, we bail.
861: */
862:
863: if (fcp->isp_portid == clp->portid) {
864: break;
865: }
866:
867: /*
868: * Else, the default policy is to find room for it in
869: * our local port database. Later, when we execute
870: * the call to isp_pdb_sync either this newly arrived
871: * or already logged in device will be (re)announced.
872: */
873:
874: if (fcp->isp_topo == TOPO_FL_PORT)
875: base = FC_SNS_ID+1;
876: else
877: base = 0;
878:
879: if (fcp->isp_topo == TOPO_N_PORT)
880: lim = 1;
881: else
882: lim = MAX_FC_TARG;
883:
884: /*
885: * Is it already in our list?
886: */
887: for (target = base; target < lim; target++) {
888: if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
889: continue;
890: }
891: lp = &fcp->portdb[target];
892: if (lp->port_wwn == clp->port_wwn &&
893: lp->node_wwn == clp->node_wwn) {
894: lp->fabric_dev = 1;
895: break;
896: }
897: }
898: if (target < lim) {
899: break;
900: }
901: for (target = base; target < lim; target++) {
902: if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
903: continue;
904: }
905: lp = &fcp->portdb[target];
906: if (lp->port_wwn == 0) {
907: break;
908: }
909: }
910: if (target == lim) {
911: isp_prt(isp, ISP_LOGWARN,
912: "out of space for fabric devices");
913: break;
914: }
915: lp->port_type = clp->port_type;
916: lp->fc4_type = clp->fc4_type;
917: lp->node_wwn = clp->node_wwn;
918: lp->port_wwn = clp->port_wwn;
919: lp->portid = clp->portid;
920: lp->fabric_dev = 1;
921: break;
922: }
923: case ISPASYNC_FW_CRASH:
924: {
925: u_int16_t mbox1, mbox6;
926: mbox1 = ISP_READ(isp, OUTMAILBOX1);
927: if (IS_DUALBUS(isp)) {
928: mbox6 = ISP_READ(isp, OUTMAILBOX6);
929: } else {
930: mbox6 = 0;
931: }
932: isp_prt(isp, ISP_LOGERR,
933: "Internal Firmware Error on bus %d @ RISC Address 0x%x",
934: mbox6, mbox1);
935: #ifdef ISP_FW_CRASH_DUMP
936: if (IS_FC(isp)) {
937: isp->isp_osinfo.blocked |= 1;
938: isp_fw_dump(isp);
939: }
940: isp_reinit(isp);
941: isp_async(isp, ISPASYNC_FW_RESTART, NULL);
942: #endif
943: break;
944: }
945: default:
946: break;
947: }
948: return (0);
949: }
950:
951: void
952: isp_prt(struct ispsoftc *isp, int level, const char *fmt, ...)
953: {
954: va_list ap;
955: if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
956: return;
957: }
958: printf("%s: ", isp->isp_name);
959: va_start(ap, fmt);
960: vprintf(fmt, ap);
961: va_end(ap);
962: printf("\n");
963: }