isp_netbsd.c revision 1.59 1 /* $NetBSD: isp_netbsd.c,v 1.59 2003/03/21 18:05:16 mjacob Exp $ */
2 /*
3 * This driver, which is contained in NetBSD in the files:
4 *
5 * sys/dev/ic/isp.c
6 * sys/dev/ic/isp_inline.h
7 * sys/dev/ic/isp_netbsd.c
8 * sys/dev/ic/isp_netbsd.h
9 * sys/dev/ic/isp_target.c
10 * sys/dev/ic/isp_target.h
11 * sys/dev/ic/isp_tpublic.h
12 * sys/dev/ic/ispmbox.h
13 * sys/dev/ic/ispreg.h
14 * sys/dev/ic/ispvar.h
15 * sys/microcode/isp/asm_sbus.h
16 * sys/microcode/isp/asm_1040.h
17 * sys/microcode/isp/asm_1080.h
18 * sys/microcode/isp/asm_12160.h
19 * sys/microcode/isp/asm_2100.h
20 * sys/microcode/isp/asm_2200.h
21 * sys/pci/isp_pci.c
22 * sys/sbus/isp_sbus.c
23 *
24 * Is being actively maintained by Matthew Jacob (mjacob (at) netbsd.org).
25 * This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris,
26 * Linux versions. This tends to be an interesting maintenance problem.
27 *
28 * Please coordinate with Matthew Jacob on changes you wish to make here.
29 */
30 /*
31 * Platform (NetBSD) dependent common attachment code for Qlogic adapters.
32 * Matthew Jacob <mjacob (at) nas.nasa.gov>
33 */
34 /*
35 * Copyright (C) 1997, 1998, 1999 National Aeronautics & Space Administration
36 * All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. The name of the author may not be used to endorse or promote products
47 * derived from this software without specific prior written permission
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
50 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
51 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
52 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
53 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
54 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
55 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
56 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
57 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
58 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60
61 #include <sys/cdefs.h>
62 __KERNEL_RCSID(0, "$NetBSD: isp_netbsd.c,v 1.59 2003/03/21 18:05:16 mjacob Exp $");
63
64 #include <dev/ic/isp_netbsd.h>
65 #include <sys/scsiio.h>
66
67
68 /*
69 * Set a timeout for the watchdogging of a command.
70 *
71 * The dimensional analysis is
72 *
73 * milliseconds * (seconds/millisecond) * (ticks/second) = ticks
74 *
75 * =
76 *
77 * (milliseconds / 1000) * hz = ticks
78 *
79 *
80 * For timeouts less than 1 second, we'll get zero. Because of this, and
81 * because we want to establish *our* timeout to be longer than what the
82 * firmware might do, we just add 3 seconds at the back end.
83 */
84 #define _XT(xs) ((((xs)->timeout/1000) * hz) + (3 * hz))
85
86 static void isp_config_interrupts(struct device *);
87 static void ispminphys_1020(struct buf *);
88 static void ispminphys(struct buf *);
89 static INLINE void ispcmd(struct ispsoftc *, XS_T *);
90 static void isprequest(struct scsipi_channel *, scsipi_adapter_req_t, void *);
91 static int
92 ispioctl(struct scsipi_channel *, u_long, caddr_t, int, struct proc *);
93
94 static void isp_polled_cmd(struct ispsoftc *, XS_T *);
95 static void isp_dog(void *);
96 static void isp_create_fc_worker(void *);
97 static void isp_fc_worker(void *);
98
99 /*
100 * Complete attachment of hardware, include subdevices.
101 */
102 void
103 isp_attach(struct ispsoftc *isp)
104 {
105 isp->isp_state = ISP_RUNSTATE;
106
107 isp->isp_osinfo._adapter.adapt_dev = &isp->isp_osinfo._dev;
108 isp->isp_osinfo._adapter.adapt_nchannels = IS_DUALBUS(isp) ? 2 : 1;
109 isp->isp_osinfo._adapter.adapt_openings = isp->isp_maxcmds;
110 /*
111 * It's not stated whether max_periph is limited by SPI
112 * tag uage, but let's assume that it is.
113 */
114 isp->isp_osinfo._adapter.adapt_max_periph = min(isp->isp_maxcmds, 255);
115 isp->isp_osinfo._adapter.adapt_ioctl = ispioctl;
116 isp->isp_osinfo._adapter.adapt_request = isprequest;
117 if (isp->isp_type <= ISP_HA_SCSI_1020A) {
118 isp->isp_osinfo._adapter.adapt_minphys = ispminphys_1020;
119 } else {
120 isp->isp_osinfo._adapter.adapt_minphys = ispminphys;
121 }
122
123 isp->isp_osinfo._chan.chan_adapter = &isp->isp_osinfo._adapter;
124 isp->isp_osinfo._chan.chan_bustype = &scsi_bustype;
125 isp->isp_osinfo._chan.chan_channel = 0;
126
127 /*
128 * Until the midlayer is fixed to use REPORT LUNS, limit to 8 luns.
129 */
130 isp->isp_osinfo._chan.chan_nluns = min(isp->isp_maxluns, 8);
131
132 if (IS_FC(isp)) {
133 isp->isp_osinfo._chan.chan_flags = SCSIPI_CHAN_NOSETTLE;
134 isp->isp_osinfo._chan.chan_ntargets = MAX_FC_TARG;
135 isp->isp_osinfo._chan.chan_id = MAX_FC_TARG;
136 isp->isp_osinfo.threadwork = 1;
137 /*
138 * Note that isp_create_fc_worker won't get called
139 * until much much later (after proc0 is created).
140 */
141 kthread_create(isp_create_fc_worker, isp);
142 #ifdef ISP_FW_CRASH_DUMP
143 if (IS_2200(isp)) {
144 FCPARAM(isp)->isp_dump_data =
145 malloc(QLA2200_RISC_IMAGE_DUMP_SIZE, M_DEVBUF,
146 M_NOWAIT);
147 } else if (IS_23XX(isp)) {
148 FCPARAM(isp)->isp_dump_data =
149 malloc(QLA2300_RISC_IMAGE_DUMP_SIZE, M_DEVBUF,
150 M_NOWAIT);
151 }
152 if (FCPARAM(isp)->isp_dump_data)
153 FCPARAM(isp)->isp_dump_data[0] = 0;
154 #endif
155 } else {
156 int bus = 0;
157 sdparam *sdp = isp->isp_param;
158
159 isp->isp_osinfo._chan.chan_ntargets = MAX_TARGETS;
160 isp->isp_osinfo._chan.chan_id = sdp->isp_initiator_id;
161 isp->isp_osinfo.discovered[0] = 1 << sdp->isp_initiator_id;
162 if (IS_DUALBUS(isp)) {
163 isp->isp_osinfo._chan_b = isp->isp_osinfo._chan;
164 sdp++;
165 isp->isp_osinfo.discovered[1] =
166 1 << sdp->isp_initiator_id;
167 isp->isp_osinfo._chan_b.chan_id = sdp->isp_initiator_id;
168 isp->isp_osinfo._chan_b.chan_channel = 1;
169 }
170 ISP_LOCK(isp);
171 (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
172 if (IS_DUALBUS(isp)) {
173 bus++;
174 (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
175 }
176 ISP_UNLOCK(isp);
177 }
178
179
180 /*
181 * Defer enabling mailbox interrupts until later.
182 */
183 config_interrupts((struct device *) isp, isp_config_interrupts);
184
185 /*
186 * And attach children (if any).
187 */
188 config_found((void *)isp, &isp->isp_chanA, scsiprint);
189 if (IS_DUALBUS(isp)) {
190 config_found((void *)isp, &isp->isp_chanB, scsiprint);
191 }
192 }
193
194
195 static void
196 isp_config_interrupts(struct device *self)
197 {
198 struct ispsoftc *isp = (struct ispsoftc *) self;
199
200 /*
201 * After this point, we'll be doing the new configuration
202 * schema which allows interrupts, so we can do tsleep/wakeup
203 * for mailbox stuff at that point, if that's allowed.
204 */
205 if (IS_FC(isp)) {
206 isp->isp_osinfo.no_mbox_ints = 0;
207 }
208 }
209
210
211 /*
212 * minphys our xfers
213 */
214
215 static void
216 ispminphys_1020(struct buf *bp)
217 {
218 if (bp->b_bcount >= (1 << 24)) {
219 bp->b_bcount = (1 << 24);
220 }
221 minphys(bp);
222 }
223
224 static void
225 ispminphys(struct buf *bp)
226 {
227 if (bp->b_bcount >= (1 << 30)) {
228 bp->b_bcount = (1 << 30);
229 }
230 minphys(bp);
231 }
232
233 static int
234 ispioctl(struct scsipi_channel *chan, u_long cmd, caddr_t addr, int flag,
235 struct proc *p)
236 {
237 struct ispsoftc *isp = (void *)chan->chan_adapter->adapt_dev;
238 int retval = ENOTTY;
239
240 switch (cmd) {
241 #ifdef ISP_FW_CRASH_DUMP
242 case ISP_GET_FW_CRASH_DUMP:
243 {
244 u_int16_t *ptr = FCPARAM(isp)->isp_dump_data;
245 size_t sz;
246
247 retval = 0;
248 if (IS_2200(isp))
249 sz = QLA2200_RISC_IMAGE_DUMP_SIZE;
250 else
251 sz = QLA2300_RISC_IMAGE_DUMP_SIZE;
252 ISP_LOCK(isp);
253 if (ptr && *ptr) {
254 void *uaddr = *((void **) addr);
255 if (copyout(ptr, uaddr, sz)) {
256 retval = EFAULT;
257 } else {
258 *ptr = 0;
259 }
260 } else {
261 retval = ENXIO;
262 }
263 ISP_UNLOCK(isp);
264 break;
265 }
266
267 case ISP_FORCE_CRASH_DUMP:
268 ISP_LOCK(isp);
269 if (isp->isp_osinfo.blocked == 0) {
270 isp->isp_osinfo.blocked = 1;
271 scsipi_channel_freeze(&isp->isp_chanA, 1);
272 }
273 isp_fw_dump(isp);
274 isp_reinit(isp);
275 ISP_UNLOCK(isp);
276 retval = 0;
277 break;
278 #endif
279 case ISP_SDBLEV:
280 {
281 int olddblev = isp->isp_dblev;
282 isp->isp_dblev = *(int *)addr;
283 *(int *)addr = olddblev;
284 retval = 0;
285 break;
286 }
287 case ISP_RESETHBA:
288 ISP_LOCK(isp);
289 isp_reinit(isp);
290 ISP_UNLOCK(isp);
291 retval = 0;
292 break;
293 case ISP_RESCAN:
294 if (IS_FC(isp)) {
295 ISP_LOCK(isp);
296 if (isp_fc_runstate(isp, 5 * 1000000)) {
297 retval = EIO;
298 } else {
299 retval = 0;
300 }
301 ISP_UNLOCK(isp);
302 }
303 break;
304 case ISP_FC_LIP:
305 if (IS_FC(isp)) {
306 ISP_LOCK(isp);
307 if (isp_control(isp, ISPCTL_SEND_LIP, 0)) {
308 retval = EIO;
309 } else {
310 retval = 0;
311 }
312 ISP_UNLOCK(isp);
313 }
314 break;
315 case ISP_FC_GETDINFO:
316 {
317 struct isp_fc_device *ifc = (struct isp_fc_device *) addr;
318 struct lportdb *lp;
319
320 if (ifc->loopid < 0 || ifc->loopid >= MAX_FC_TARG) {
321 retval = EINVAL;
322 break;
323 }
324 ISP_LOCK(isp);
325 lp = &FCPARAM(isp)->portdb[ifc->loopid];
326 if (lp->valid) {
327 ifc->loopid = lp->loopid;
328 ifc->portid = lp->portid;
329 ifc->node_wwn = lp->node_wwn;
330 ifc->port_wwn = lp->port_wwn;
331 retval = 0;
332 } else {
333 retval = ENODEV;
334 }
335 ISP_UNLOCK(isp);
336 break;
337 }
338 case ISP_GET_STATS:
339 {
340 isp_stats_t *sp = (isp_stats_t *) addr;
341
342 MEMZERO(sp, sizeof (*sp));
343 sp->isp_stat_version = ISP_STATS_VERSION;
344 sp->isp_type = isp->isp_type;
345 sp->isp_revision = isp->isp_revision;
346 ISP_LOCK(isp);
347 sp->isp_stats[ISP_INTCNT] = isp->isp_intcnt;
348 sp->isp_stats[ISP_INTBOGUS] = isp->isp_intbogus;
349 sp->isp_stats[ISP_INTMBOXC] = isp->isp_intmboxc;
350 sp->isp_stats[ISP_INGOASYNC] = isp->isp_intoasync;
351 sp->isp_stats[ISP_RSLTCCMPLT] = isp->isp_rsltccmplt;
352 sp->isp_stats[ISP_FPHCCMCPLT] = isp->isp_fphccmplt;
353 sp->isp_stats[ISP_RSCCHIWAT] = isp->isp_rscchiwater;
354 sp->isp_stats[ISP_FPCCHIWAT] = isp->isp_fpcchiwater;
355 ISP_UNLOCK(isp);
356 retval = 0;
357 break;
358 }
359 case ISP_CLR_STATS:
360 ISP_LOCK(isp);
361 isp->isp_intcnt = 0;
362 isp->isp_intbogus = 0;
363 isp->isp_intmboxc = 0;
364 isp->isp_intoasync = 0;
365 isp->isp_rsltccmplt = 0;
366 isp->isp_fphccmplt = 0;
367 isp->isp_rscchiwater = 0;
368 isp->isp_fpcchiwater = 0;
369 ISP_UNLOCK(isp);
370 retval = 0;
371 break;
372 case ISP_FC_GETHINFO:
373 {
374 struct isp_hba_device *hba = (struct isp_hba_device *) addr;
375 MEMZERO(hba, sizeof (*hba));
376 ISP_LOCK(isp);
377 hba->fc_speed = FCPARAM(isp)->isp_gbspeed;
378 hba->fc_scsi_supported = 1;
379 hba->fc_topology = FCPARAM(isp)->isp_topo + 1;
380 hba->fc_loopid = FCPARAM(isp)->isp_loopid;
381 hba->active_node_wwn = FCPARAM(isp)->isp_nodewwn;
382 hba->active_port_wwn = FCPARAM(isp)->isp_portwwn;
383 ISP_UNLOCK(isp);
384 break;
385 }
386 case SCBUSIORESET:
387 ISP_LOCK(isp);
388 if (isp_control(isp, ISPCTL_RESET_BUS, &chan->chan_channel))
389 retval = EIO;
390 else
391 retval = 0;
392 ISP_UNLOCK(isp);
393 break;
394 default:
395 break;
396 }
397 return (retval);
398 }
399
400 static INLINE void
401 ispcmd(struct ispsoftc *isp, XS_T *xs)
402 {
403 ISP_LOCK(isp);
404 if (isp->isp_state < ISP_RUNSTATE) {
405 DISABLE_INTS(isp);
406 isp_init(isp);
407 if (isp->isp_state != ISP_INITSTATE) {
408 ENABLE_INTS(isp);
409 ISP_UNLOCK(isp);
410 isp_prt(isp, ISP_LOGERR, "isp not at init state");
411 XS_SETERR(xs, HBA_BOTCH);
412 scsipi_done(xs);
413 return;
414 }
415 isp->isp_state = ISP_RUNSTATE;
416 ENABLE_INTS(isp);
417 }
418 /*
419 * Handle the case of a FC card where the FC thread hasn't
420 * fired up yet and we have loop state to clean up. If we
421 * can't clear things up and we've never seen loop up, bounce
422 * the command.
423 */
424 if (IS_FC(isp) && isp->isp_osinfo.threadwork &&
425 isp->isp_osinfo.thread == 0) {
426 volatile u_int8_t ombi = isp->isp_osinfo.no_mbox_ints;
427 int delay_time;
428
429 if (xs->xs_control & XS_CTL_POLL) {
430 isp->isp_osinfo.no_mbox_ints = 1;
431 }
432
433 if (isp->isp_osinfo.loop_checked == 0) {
434 delay_time = 10 * 1000000;
435 isp->isp_osinfo.loop_checked = 1;
436 } else {
437 delay_time = 250000;
438 }
439
440 if (isp_fc_runstate(isp, delay_time) != 0) {
441 if (xs->xs_control & XS_CTL_POLL) {
442 isp->isp_osinfo.no_mbox_ints = ombi;
443 }
444 if (FCPARAM(isp)->loop_seen_once == 0) {
445 XS_SETERR(xs, HBA_SELTIMEOUT);
446 scsipi_done(xs);
447 ISP_UNLOCK(isp);
448 return;
449 }
450 /*
451 * Otherwise, fall thru to be queued up for later.
452 */
453 } else {
454 int wasblocked =
455 (isp->isp_osinfo.blocked || isp->isp_osinfo.paused);
456 isp->isp_osinfo.threadwork = 0;
457 isp->isp_osinfo.blocked =
458 isp->isp_osinfo.paused = 0;
459 if (wasblocked) {
460 scsipi_channel_thaw(&isp->isp_chanA, 1);
461 }
462 }
463 if (xs->xs_control & XS_CTL_POLL) {
464 isp->isp_osinfo.no_mbox_ints = ombi;
465 }
466 }
467
468 if (isp->isp_osinfo.paused) {
469 isp_prt(isp, ISP_LOGWARN, "I/O while paused");
470 xs->error = XS_RESOURCE_SHORTAGE;
471 scsipi_done(xs);
472 ISP_UNLOCK(isp);
473 return;
474 }
475 if (isp->isp_osinfo.blocked) {
476 isp_prt(isp, ISP_LOGWARN, "I/O while blocked");
477 xs->error = XS_REQUEUE;
478 scsipi_done(xs);
479 ISP_UNLOCK(isp);
480 return;
481 }
482
483 if (xs->xs_control & XS_CTL_POLL) {
484 volatile u_int8_t ombi = isp->isp_osinfo.no_mbox_ints;
485 isp->isp_osinfo.no_mbox_ints = 1;
486 isp_polled_cmd(isp, xs);
487 isp->isp_osinfo.no_mbox_ints = ombi;
488 ISP_UNLOCK(isp);
489 return;
490 }
491
492 switch (isp_start(xs)) {
493 case CMD_QUEUED:
494 if (xs->timeout) {
495 callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
496 }
497 break;
498 case CMD_EAGAIN:
499 isp->isp_osinfo.paused = 1;
500 xs->error = XS_RESOURCE_SHORTAGE;
501 scsipi_channel_freeze(&isp->isp_chanA, 1);
502 if (IS_DUALBUS(isp)) {
503 scsipi_channel_freeze(&isp->isp_chanB, 1);
504 }
505 scsipi_done(xs);
506 break;
507 case CMD_RQLATER:
508 /*
509 * We can only get RQLATER from FC devices (1 channel only)
510 *
511 * Also, if we've never seen loop up, bounce the command
512 * (somebody has booted with no FC cable connected)
513 */
514 if (FCPARAM(isp)->loop_seen_once == 0) {
515 XS_SETERR(xs, HBA_SELTIMEOUT);
516 scsipi_done(xs);
517 break;
518 }
519 if (isp->isp_osinfo.blocked == 0) {
520 isp->isp_osinfo.blocked = 1;
521 scsipi_channel_freeze(&isp->isp_chanA, 1);
522 }
523 xs->error = XS_REQUEUE;
524 scsipi_done(xs);
525 break;
526 case CMD_COMPLETE:
527 scsipi_done(xs);
528 break;
529 }
530 ISP_UNLOCK(isp);
531 }
532
533 static void
534 isprequest(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg)
535 {
536 struct ispsoftc *isp = (void *)chan->chan_adapter->adapt_dev;
537
538 switch (req) {
539 case ADAPTER_REQ_RUN_XFER:
540 ispcmd(isp, (XS_T *) arg);
541 break;
542
543 case ADAPTER_REQ_GROW_RESOURCES:
544 /* Not supported. */
545 break;
546
547 case ADAPTER_REQ_SET_XFER_MODE:
548 if (IS_SCSI(isp)) {
549 struct scsipi_xfer_mode *xm = arg;
550 int dflags = 0;
551 sdparam *sdp = SDPARAM(isp);
552
553 sdp += chan->chan_channel;
554 if (xm->xm_mode & PERIPH_CAP_TQING)
555 dflags |= DPARM_TQING;
556 if (xm->xm_mode & PERIPH_CAP_WIDE16)
557 dflags |= DPARM_WIDE;
558 if (xm->xm_mode & PERIPH_CAP_SYNC)
559 dflags |= DPARM_SYNC;
560 ISP_LOCK(isp);
561 sdp->isp_devparam[xm->xm_target].goal_flags |= dflags;
562 dflags = sdp->isp_devparam[xm->xm_target].goal_flags;
563 sdp->isp_devparam[xm->xm_target].dev_update = 1;
564 isp->isp_update |= (1 << chan->chan_channel);
565 ISP_UNLOCK(isp);
566 isp_prt(isp, ISP_LOGDEBUG1,
567 "ispioctl: device flags 0x%x for %d.%d.X",
568 dflags, chan->chan_channel, xm->xm_target);
569 break;
570 }
571 default:
572 break;
573 }
574 }
575
576 static void
577 isp_polled_cmd(struct ispsoftc *isp, XS_T *xs)
578 {
579 int result;
580 int infinite = 0, mswait;
581
582 result = isp_start(xs);
583
584 switch (result) {
585 case CMD_QUEUED:
586 break;
587 case CMD_RQLATER:
588 if (XS_NOERR(xs)) {
589 xs->error = XS_REQUEUE;
590 }
591 case CMD_EAGAIN:
592 if (XS_NOERR(xs)) {
593 xs->error = XS_RESOURCE_SHORTAGE;
594 }
595 /* FALLTHROUGH */
596 case CMD_COMPLETE:
597 scsipi_done(xs);
598 return;
599
600 }
601
602 /*
603 * If we can't use interrupts, poll on completion.
604 */
605 if ((mswait = XS_TIME(xs)) == 0)
606 infinite = 1;
607
608 while (mswait || infinite) {
609 u_int16_t isr, sema, mbox;
610 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
611 isp_intr(isp, isr, sema, mbox);
612 if (XS_CMD_DONE_P(xs)) {
613 break;
614 }
615 }
616 USEC_DELAY(1000);
617 mswait -= 1;
618 }
619
620 /*
621 * If no other error occurred but we didn't finish,
622 * something bad happened.
623 */
624 if (XS_CMD_DONE_P(xs) == 0) {
625 if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
626 isp_reinit(isp);
627 }
628 if (XS_NOERR(xs)) {
629 isp_prt(isp, ISP_LOGERR, "polled command timed out");
630 XS_SETERR(xs, HBA_BOTCH);
631 }
632 }
633 scsipi_done(xs);
634 }
635
636 void
637 isp_done(XS_T *xs)
638 {
639 XS_CMD_S_DONE(xs);
640 if (XS_CMD_WDOG_P(xs) == 0) {
641 struct ispsoftc *isp = XS_ISP(xs);
642 callout_stop(&xs->xs_callout);
643 if (XS_CMD_GRACE_P(xs)) {
644 isp_prt(isp, ISP_LOGDEBUG1,
645 "finished command on borrowed time");
646 }
647 XS_CMD_S_CLEAR(xs);
648 /*
649 * Fixup- if we get a QFULL, we need
650 * to set XS_BUSY as the error.
651 */
652 if (xs->status == SCSI_QUEUE_FULL) {
653 xs->error = XS_BUSY;
654 }
655 if (isp->isp_osinfo.paused) {
656 isp->isp_osinfo.paused = 0;
657 scsipi_channel_timed_thaw(&isp->isp_chanA);
658 if (IS_DUALBUS(isp)) {
659 scsipi_channel_timed_thaw(&isp->isp_chanB);
660 }
661 }
662 if (xs->error == XS_DRIVER_STUFFUP) {
663 isp_prt(isp, ISP_LOGERR, "BOTCHED cmd for %d.%d.%d cmd 0x%x datalen %ld",
664 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
665 }
666 scsipi_done(xs);
667 }
668 }
669
670 static void
671 isp_dog(void *arg)
672 {
673 XS_T *xs = arg;
674 struct ispsoftc *isp = XS_ISP(xs);
675 u_int16_t handle;
676
677 ISP_ILOCK(isp);
678 /*
679 * We've decided this command is dead. Make sure we're not trying
680 * to kill a command that's already dead by getting it's handle and
681 * and seeing whether it's still alive.
682 */
683 handle = isp_find_handle(isp, xs);
684 if (handle) {
685 u_int16_t isr, mbox, sema;
686
687 if (XS_CMD_DONE_P(xs)) {
688 isp_prt(isp, ISP_LOGDEBUG1,
689 "watchdog found done cmd (handle 0x%x)", handle);
690 ISP_IUNLOCK(isp);
691 return;
692 }
693
694 if (XS_CMD_WDOG_P(xs)) {
695 isp_prt(isp, ISP_LOGDEBUG1,
696 "recursive watchdog (handle 0x%x)", handle);
697 ISP_IUNLOCK(isp);
698 return;
699 }
700
701 XS_CMD_S_WDOG(xs);
702
703 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
704 isp_intr(isp, isr, sema, mbox);
705
706 }
707 if (XS_CMD_DONE_P(xs)) {
708 isp_prt(isp, ISP_LOGDEBUG1,
709 "watchdog cleanup for handle 0x%x", handle);
710 XS_CMD_C_WDOG(xs);
711 isp_done(xs);
712 } else if (XS_CMD_GRACE_P(xs)) {
713 isp_prt(isp, ISP_LOGDEBUG1,
714 "watchdog timeout for handle 0x%x", handle);
715 /*
716 * Make sure the command is *really* dead before we
717 * release the handle (and DMA resources) for reuse.
718 */
719 (void) isp_control(isp, ISPCTL_ABORT_CMD, arg);
720
721 /*
722 * After this point, the comamnd is really dead.
723 */
724 if (XS_XFRLEN(xs)) {
725 ISP_DMAFREE(isp, xs, handle);
726 }
727 isp_destroy_handle(isp, handle);
728 XS_SETERR(xs, XS_TIMEOUT);
729 XS_CMD_S_CLEAR(xs);
730 isp_done(xs);
731 } else {
732 u_int16_t nxti, optr;
733 ispreq_t local, *mp = &local, *qe;
734 isp_prt(isp, ISP_LOGDEBUG2,
735 "possible command timeout on handle %x", handle);
736 XS_CMD_C_WDOG(xs);
737 callout_reset(&xs->xs_callout, hz, isp_dog, xs);
738 if (isp_getrqentry(isp, &nxti, &optr, (void *) &qe)) {
739 ISP_UNLOCK(isp);
740 return;
741 }
742 XS_CMD_S_GRACE(xs);
743 MEMZERO((void *) mp, sizeof (*mp));
744 mp->req_header.rqs_entry_count = 1;
745 mp->req_header.rqs_entry_type = RQSTYPE_MARKER;
746 mp->req_modifier = SYNC_ALL;
747 mp->req_target = XS_CHANNEL(xs) << 7;
748 isp_put_request(isp, mp, qe);
749 ISP_ADD_REQUEST(isp, nxti);
750 }
751 } else {
752 isp_prt(isp, ISP_LOGDEBUG0, "watchdog with no command");
753 }
754 ISP_IUNLOCK(isp);
755 }
756
757 /*
758 * Fibre Channel state cleanup thread
759 */
760 static void
761 isp_create_fc_worker(void *arg)
762 {
763 struct ispsoftc *isp = arg;
764
765 if (kthread_create1(isp_fc_worker, isp, &isp->isp_osinfo.thread,
766 "%s:fc_thrd", isp->isp_name)) {
767 isp_prt(isp, ISP_LOGERR, "unable to create FC worker thread");
768 panic("isp_create_fc_worker");
769 }
770
771 }
772
773 static void
774 isp_fc_worker(void *arg)
775 {
776 void scsipi_run_queue(struct scsipi_channel *);
777 struct ispsoftc *isp = arg;
778
779 for (;;) {
780 int s;
781
782 /*
783 * Note we do *not* use the ISP_LOCK/ISP_UNLOCK macros here.
784 */
785 s = splbio();
786 while (isp->isp_osinfo.threadwork) {
787 isp->isp_osinfo.threadwork = 0;
788 if (isp_fc_runstate(isp, 10 * 1000000) == 0) {
789 break;
790 }
791 if (isp->isp_osinfo.loop_checked &&
792 FCPARAM(isp)->loop_seen_once == 0) {
793 splx(s);
794 goto skip;
795 }
796 isp->isp_osinfo.threadwork = 1;
797 splx(s);
798 delay(500 * 1000);
799 s = splbio();
800 }
801 if (FCPARAM(isp)->isp_fwstate != FW_READY ||
802 FCPARAM(isp)->isp_loopstate != LOOP_READY) {
803 isp_prt(isp, ISP_LOGINFO, "isp_fc_runstate in vain");
804 isp->isp_osinfo.threadwork = 1;
805 splx(s);
806 continue;
807 }
808
809 if (isp->isp_osinfo.blocked) {
810 isp->isp_osinfo.blocked = 0;
811 isp_prt(isp, ISP_LOGDEBUG0,
812 "restarting queues (freeze count %d)",
813 isp->isp_chanA.chan_qfreeze);
814 scsipi_channel_thaw(&isp->isp_chanA, 1);
815 }
816
817 if (isp->isp_osinfo.thread == NULL)
818 break;
819
820 skip:
821 (void) tsleep(&isp->isp_osinfo.thread, PRIBIO, "fcclnup", 0);
822
823 splx(s);
824 }
825
826 /* In case parent is waiting for us to exit. */
827 wakeup(&isp->isp_osinfo.thread);
828
829 kthread_exit(0);
830 }
831
832 /*
833 * Free any associated resources prior to decommissioning and
834 * set the card to a known state (so it doesn't wake up and kick
835 * us when we aren't expecting it to).
836 *
837 * Locks are held before coming here.
838 */
839 void
840 isp_uninit(struct ispsoftc *isp)
841 {
842 isp_lock(isp);
843 /*
844 * Leave with interrupts disabled.
845 */
846 DISABLE_INTS(isp);
847 isp_unlock(isp);
848 }
849
850 int
851 isp_async(struct ispsoftc *isp, ispasync_t cmd, void *arg)
852 {
853 int bus, tgt;
854
855 switch (cmd) {
856 case ISPASYNC_NEW_TGT_PARAMS:
857 if (IS_SCSI(isp) && isp->isp_dblev) {
858 sdparam *sdp = isp->isp_param;
859 int flags;
860 struct scsipi_xfer_mode xm;
861
862 tgt = *((int *) arg);
863 bus = (tgt >> 16) & 0xffff;
864 tgt &= 0xffff;
865 sdp += bus;
866 flags = sdp->isp_devparam[tgt].actv_flags;
867
868 xm.xm_mode = 0;
869 xm.xm_period = sdp->isp_devparam[tgt].actv_period;
870 xm.xm_offset = sdp->isp_devparam[tgt].actv_offset;
871 xm.xm_target = tgt;
872
873 if ((flags & DPARM_SYNC) && xm.xm_period && xm.xm_offset)
874 xm.xm_mode |= PERIPH_CAP_SYNC;
875 if (flags & DPARM_WIDE)
876 xm.xm_mode |= PERIPH_CAP_WIDE16;
877 if (flags & DPARM_TQING)
878 xm.xm_mode |= PERIPH_CAP_TQING;
879 scsipi_async_event(bus? &isp->isp_chanB : &isp->isp_chanA,
880 ASYNC_EVENT_XFER_MODE, &xm);
881 break;
882 }
883 case ISPASYNC_BUS_RESET:
884 bus = *((int *) arg);
885 scsipi_async_event(bus? &isp->isp_chanB : &isp->isp_chanA,
886 ASYNC_EVENT_RESET, NULL);
887 isp_prt(isp, ISP_LOGINFO, "SCSI bus %d reset detected", bus);
888 break;
889 case ISPASYNC_LIP:
890 /*
891 * Don't do queue freezes or blockage until we have the
892 * thread running that can unfreeze/unblock us.
893 */
894 if (isp->isp_osinfo.blocked == 0) {
895 if (isp->isp_osinfo.thread) {
896 isp->isp_osinfo.blocked = 1;
897 scsipi_channel_freeze(&isp->isp_chanA, 1);
898 }
899 }
900 isp_prt(isp, ISP_LOGINFO, "LIP Received");
901 break;
902 case ISPASYNC_LOOP_RESET:
903 /*
904 * Don't do queue freezes or blockage until we have the
905 * thread running that can unfreeze/unblock us.
906 */
907 if (isp->isp_osinfo.blocked == 0) {
908 if (isp->isp_osinfo.thread) {
909 isp->isp_osinfo.blocked = 1;
910 scsipi_channel_freeze(&isp->isp_chanA, 1);
911 }
912 }
913 isp_prt(isp, ISP_LOGINFO, "Loop Reset Received");
914 break;
915 case ISPASYNC_LOOP_DOWN:
916 /*
917 * Don't do queue freezes or blockage until we have the
918 * thread running that can unfreeze/unblock us.
919 */
920 if (isp->isp_osinfo.blocked == 0) {
921 if (isp->isp_osinfo.thread) {
922 isp->isp_osinfo.blocked = 1;
923 scsipi_channel_freeze(&isp->isp_chanA, 1);
924 }
925 }
926 isp_prt(isp, ISP_LOGINFO, "Loop DOWN");
927 break;
928 case ISPASYNC_LOOP_UP:
929 /*
930 * Let the subsequent ISPASYNC_CHANGE_NOTIFY invoke
931 * the FC worker thread. When the FC worker thread
932 * is done, let *it* call scsipi_channel_thaw...
933 */
934 isp_prt(isp, ISP_LOGINFO, "Loop UP");
935 break;
936 case ISPASYNC_PROMENADE:
937 if (IS_FC(isp) && isp->isp_dblev) {
938 static const char fmt[] = "Target %d (Loop 0x%x) Port ID 0x%x "
939 "(role %s) %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x";
940 const static char *const roles[4] = {
941 "None", "Target", "Initiator", "Target/Initiator"
942 };
943 fcparam *fcp = isp->isp_param;
944 int tgt = *((int *) arg);
945 struct lportdb *lp = &fcp->portdb[tgt];
946
947 isp_prt(isp, ISP_LOGINFO, fmt, tgt, lp->loopid, lp->portid,
948 roles[lp->roles & 0x3],
949 (lp->valid)? "Arrived" : "Departed",
950 (u_int32_t) (lp->port_wwn >> 32),
951 (u_int32_t) (lp->port_wwn & 0xffffffffLL),
952 (u_int32_t) (lp->node_wwn >> 32),
953 (u_int32_t) (lp->node_wwn & 0xffffffffLL));
954 break;
955 }
956 case ISPASYNC_CHANGE_NOTIFY:
957 if (arg == ISPASYNC_CHANGE_PDB) {
958 isp_prt(isp, ISP_LOGINFO, "Port Database Changed");
959 } else if (arg == ISPASYNC_CHANGE_SNS) {
960 isp_prt(isp, ISP_LOGINFO,
961 "Name Server Database Changed");
962 }
963
964 /*
965 * We can set blocked here because we know it's now okay
966 * to try and run isp_fc_runstate (in order to build loop
967 * state). But we don't try and freeze the midlayer's queue
968 * if we have no thread that we can wake to later unfreeze
969 * it.
970 */
971 if (isp->isp_osinfo.blocked == 0) {
972 isp->isp_osinfo.blocked = 1;
973 if (isp->isp_osinfo.thread) {
974 scsipi_channel_freeze(&isp->isp_chanA, 1);
975 }
976 }
977 /*
978 * Note that we have work for the thread to do, and
979 * if the thread is here already, wake it up.
980 */
981 isp->isp_osinfo.threadwork++;
982 if (isp->isp_osinfo.thread) {
983 wakeup(&isp->isp_osinfo.thread);
984 } else {
985 isp_prt(isp, ISP_LOGDEBUG1, "no FC thread yet");
986 }
987 break;
988 case ISPASYNC_FABRIC_DEV:
989 {
990 int target, base, lim;
991 fcparam *fcp = isp->isp_param;
992 struct lportdb *lp = NULL;
993 struct lportdb *clp = (struct lportdb *) arg;
994 char *pt;
995
996 switch (clp->port_type) {
997 case 1:
998 pt = " N_Port";
999 break;
1000 case 2:
1001 pt = " NL_Port";
1002 break;
1003 case 3:
1004 pt = "F/NL_Port";
1005 break;
1006 case 0x7f:
1007 pt = " Nx_Port";
1008 break;
1009 case 0x81:
1010 pt = " F_port";
1011 break;
1012 case 0x82:
1013 pt = " FL_Port";
1014 break;
1015 case 0x84:
1016 pt = " E_port";
1017 break;
1018 default:
1019 pt = " ";
1020 break;
1021 }
1022
1023 isp_prt(isp, ISP_LOGINFO,
1024 "%s Fabric Device @ PortID 0x%x", pt, clp->portid);
1025
1026 /*
1027 * If we don't have an initiator role we bail.
1028 *
1029 * We just use ISPASYNC_FABRIC_DEV for announcement purposes.
1030 */
1031
1032 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
1033 break;
1034 }
1035
1036 /*
1037 * Is this entry for us? If so, we bail.
1038 */
1039
1040 if (fcp->isp_portid == clp->portid) {
1041 break;
1042 }
1043
1044 /*
1045 * Else, the default policy is to find room for it in
1046 * our local port database. Later, when we execute
1047 * the call to isp_pdb_sync either this newly arrived
1048 * or already logged in device will be (re)announced.
1049 */
1050
1051 if (fcp->isp_topo == TOPO_FL_PORT)
1052 base = FC_SNS_ID+1;
1053 else
1054 base = 0;
1055
1056 if (fcp->isp_topo == TOPO_N_PORT)
1057 lim = 1;
1058 else
1059 lim = MAX_FC_TARG;
1060
1061 /*
1062 * Is it already in our list?
1063 */
1064 for (target = base; target < lim; target++) {
1065 if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
1066 continue;
1067 }
1068 lp = &fcp->portdb[target];
1069 if (lp->port_wwn == clp->port_wwn &&
1070 lp->node_wwn == clp->node_wwn) {
1071 lp->fabric_dev = 1;
1072 break;
1073 }
1074 }
1075 if (target < lim) {
1076 break;
1077 }
1078 for (target = base; target < lim; target++) {
1079 if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
1080 continue;
1081 }
1082 lp = &fcp->portdb[target];
1083 if (lp->port_wwn == 0) {
1084 break;
1085 }
1086 }
1087 if (target == lim) {
1088 isp_prt(isp, ISP_LOGWARN,
1089 "out of space for fabric devices");
1090 break;
1091 }
1092 lp->port_type = clp->port_type;
1093 lp->fc4_type = clp->fc4_type;
1094 lp->node_wwn = clp->node_wwn;
1095 lp->port_wwn = clp->port_wwn;
1096 lp->portid = clp->portid;
1097 lp->fabric_dev = 1;
1098 break;
1099 }
1100 case ISPASYNC_FW_CRASH:
1101 {
1102 u_int16_t mbox1, mbox6;
1103 mbox1 = ISP_READ(isp, OUTMAILBOX1);
1104 if (IS_DUALBUS(isp)) {
1105 mbox6 = ISP_READ(isp, OUTMAILBOX6);
1106 } else {
1107 mbox6 = 0;
1108 }
1109 isp_prt(isp, ISP_LOGERR,
1110 "Internal Firmware Error on bus %d @ RISC Address 0x%x",
1111 mbox6, mbox1);
1112 #ifdef ISP_FW_CRASH_DUMP
1113 if (IS_FC(isp)) {
1114 if (isp->isp_osinfo.blocked == 0) {
1115 isp->isp_osinfo.blocked = 1;
1116 scsipi_channel_freeze(&isp->isp_chanA, 1);
1117 }
1118 isp_fw_dump(isp);
1119 }
1120 isp_reinit(isp);
1121 isp_async(isp, ISPASYNC_FW_RESTART, NULL);
1122 #endif
1123 break;
1124 }
1125 default:
1126 break;
1127 }
1128 return (0);
1129 }
1130
1131 #include <machine/stdarg.h>
1132 void
1133 isp_prt(struct ispsoftc *isp, int level, const char *fmt, ...)
1134 {
1135 va_list ap;
1136 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
1137 return;
1138 }
1139 printf("%s: ", isp->isp_name);
1140 va_start(ap, fmt);
1141 vprintf(fmt, ap);
1142 va_end(ap);
1143 printf("\n");
1144 }
1145