?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / dev / ic / isp_netbsd.c
blob075a5d10f4fa590e6ced08a142a9142cfa10738c
1 /* $NetBSD: isp_netbsd.c,v 1.80 2009/06/25 23:44:02 mjacob Exp $ */
2 /*
3 * Platform (NetBSD) dependent common attachment code for Qlogic adapters.
4 */
5 /*
6 * Copyright (C) 1997, 1998, 1999 National Aeronautics & Space Administration
7 * All rights reserved.
8 *
9 * Additional Copyright (C) 2000-2007 by Matthew Jacob
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: isp_netbsd.c,v 1.80 2009/06/25 23:44:02 mjacob Exp $");
37
38 #include <dev/ic/isp_netbsd.h>
39 #include <dev/ic/isp_ioctl.h>
40 #include <sys/scsiio.h>
41
42 #include <sys/timevar.h>
43
44 /*
45 * Set a timeout for the watchdogging of a command.
46 *
47 * The dimensional analysis is
48 *
49 * milliseconds * (seconds/millisecond) * (ticks/second) = ticks
50 *
51 * =
52 *
53 * (milliseconds / 1000) * hz = ticks
54 *
55 *
56 * For timeouts less than 1 second, we'll get zero. Because of this, and
57 * because we want to establish *our* timeout to be longer than what the
58 * firmware might do, we just add 3 seconds at the back end.
59 */
60 #define _XT(xs) ((((xs)->timeout/1000) * hz) + (3 * hz))
61
62 static void isp_config_interrupts(device_t);
63 static void ispminphys_1020(struct buf *);
64 static void ispminphys(struct buf *);
65 static void ispcmd(struct ispsoftc *, XS_T *);
66 static void isprequest(struct scsipi_channel *, scsipi_adapter_req_t, void *);
67 static int
68 ispioctl(struct scsipi_channel *, u_long, void *, int, struct proc *);
69
70 static void isp_polled_cmd_wait(struct ispsoftc *, XS_T *);
71 static void isp_dog(void *);
72 static void isp_gdt(void *);
73 static void isp_ldt(void *);
74 static void isp_make_here(ispsoftc_t *, int);
75 static void isp_make_gone(ispsoftc_t *, int);
76 static void isp_fc_worker(void *);
77
78 static const char *roles[4] = {
79 "(none)", "Target", "Initiator", "Target/Initiator"
80 };
81 static const char prom3[] =
82 "PortID 0x%06x Departed from Target %u because of %s";
83 int isp_change_is_bad = 0; /* "changed" devices are bad */
84 int isp_quickboot_time = 15; /* don't wait more than N secs for loop up */
85 static int isp_fabric_hysteresis = 5;
86 #define isp_change_is_bad 0
87
88 /*
89 * Complete attachment of hardware, include subdevices.
90 */
91
92 void
93 isp_attach(struct ispsoftc *isp)
94 {
95 device_t self = isp->isp_osinfo.dev;
96 int i;
97
98 isp->isp_state = ISP_RUNSTATE;
99
100 isp->isp_osinfo.adapter.adapt_dev = self;
101 isp->isp_osinfo.adapter.adapt_openings = isp->isp_maxcmds;
102 isp->isp_osinfo.loop_down_limit = 300;
103
104 /*
105 * It's not stated whether max_periph is limited by SPI
106 * tag uage, but let's assume that it is.
107 */
108 isp->isp_osinfo.adapter.adapt_max_periph = min(isp->isp_maxcmds, 255);
109 isp->isp_osinfo.adapter.adapt_ioctl = ispioctl;
110 isp->isp_osinfo.adapter.adapt_request = isprequest;
111 if (isp->isp_type <= ISP_HA_SCSI_1020A) {
112 isp->isp_osinfo.adapter.adapt_minphys = ispminphys_1020;
113 } else {
114 isp->isp_osinfo.adapter.adapt_minphys = ispminphys;
115 }
116
117 callout_init(&isp->isp_osinfo.gdt, 0);
118 callout_setfunc(&isp->isp_osinfo.gdt, isp_gdt, isp);
119 callout_init(&isp->isp_osinfo.ldt, 0);
120 callout_setfunc(&isp->isp_osinfo.ldt, isp_ldt, isp);
121 if (IS_FC(isp)) {
122 if (kthread_create(PRI_NONE, 0, NULL, isp_fc_worker, isp,
123 &isp->isp_osinfo.thread, "%s:fc_thrd",
124 device_xname(self))) {
125 isp_prt(isp, ISP_LOGERR,
126 "unable to create FC worker thread");
127 return;
128 }
129 }
130
131 for (i = 0; i != isp->isp_osinfo.adapter.adapt_nchannels; i++) {
132 isp->isp_osinfo.chan[i].chan_adapter =
133 &isp->isp_osinfo.adapter;
134 isp->isp_osinfo.chan[i].chan_bustype = &scsi_bustype;
135 isp->isp_osinfo.chan[i].chan_channel = i;
136 /*
137 * Until the midlayer is fixed to use REPORT LUNS,
138 * limit to 8 luns.
139 */
140 isp->isp_osinfo.chan[i].chan_nluns = min(isp->isp_maxluns, 8);
141 if (IS_FC(isp)) {
142 isp->isp_osinfo.chan[i].chan_ntargets = MAX_FC_TARG;
143 if (ISP_CAP_2KLOGIN(isp) == 0 && MAX_FC_TARG > 256) {
144 isp->isp_osinfo.chan[i].chan_ntargets = 256;
145 }
146 isp->isp_osinfo.chan[i].chan_id = MAX_FC_TARG;
147 } else {
148 isp->isp_osinfo.chan[i].chan_ntargets = MAX_TARGETS;
149 isp->isp_osinfo.chan[i].chan_id =
150 SDPARAM(isp, i)->isp_initiator_id;
151 ISP_LOCK(isp);
152 (void) isp_control(isp, ISPCTL_RESET_BUS, i);
153 ISP_UNLOCK(isp);
154 }
155 }
156
157 /*
158 * Defer enabling mailbox interrupts until later.
159 */
160 config_interrupts(self, isp_config_interrupts);
161 }
162
163 static void
164 isp_config_interrupts(device_t self)
165 {
166 int i;
167 struct ispsoftc *isp = device_private(self);
168
169 isp->isp_osinfo.mbox_sleep_ok = 1;
170
171 if (IS_FC(isp) && (FCPARAM(isp, 0)->isp_fwstate != FW_READY ||
172 FCPARAM(isp, 0)->isp_loopstate != LOOP_READY)) {
173 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
174 "Starting Initial Loop Down Timer");
175 callout_schedule(&isp->isp_osinfo.ldt, isp_quickboot_time * hz);
176 }
177
178 /*
179 * And attach children (if any).
180 */
181 for (i = 0; i < isp->isp_osinfo.adapter.adapt_nchannels; i++) {
182 config_found(self, &isp->isp_osinfo.chan[i], scsiprint);
183 }
184 }
185
186 /*
187 * minphys our xfers
188 */
189 static void
190 ispminphys_1020(struct buf *bp)
191 {
192 if (bp->b_bcount >= (1 << 24)) {
193 bp->b_bcount = (1 << 24);
194 }
195 minphys(bp);
196 }
197
198 static void
199 ispminphys(struct buf *bp)
200 {
201 if (bp->b_bcount >= (1 << 30)) {
202 bp->b_bcount = (1 << 30);
203 }
204 minphys(bp);
205 }
206
207 static int
208 ispioctl(struct scsipi_channel *chan, u_long cmd, void *addr, int flag,
209 struct proc *p)
210 {
211 struct ispsoftc *isp = device_private(chan->chan_adapter->adapt_dev);
212 int nr, bus, retval = ENOTTY;
213
214 switch (cmd) {
215 case ISP_SDBLEV:
216 {
217 int olddblev = isp->isp_dblev;
218 isp->isp_dblev = *(int *)addr;
219 *(int *)addr = olddblev;
220 retval = 0;
221 break;
222 }
223 case ISP_GETROLE:
224 bus = *(int *)addr;
225 if (bus < 0 || bus >= isp->isp_nchan) {
226 retval = -ENXIO;
227 break;
228 }
229 if (IS_FC(isp)) {
230 *(int *)addr = FCPARAM(isp, bus)->role;
231 } else {
232 *(int *)addr = SDPARAM(isp, bus)->role;
233 }
234 retval = 0;
235 break;
236 case ISP_SETROLE:
237
238 nr = *(int *)addr;
239 bus = nr >> 8;
240 if (bus < 0 || bus >= isp->isp_nchan) {
241 retval = -ENXIO;
242 break;
243 }
244 nr &= 0xff;
245 if (nr & ~(ISP_ROLE_INITIATOR|ISP_ROLE_TARGET)) {
246 retval = EINVAL;
247 break;
248 }
249 if (IS_FC(isp)) {
250 *(int *)addr = FCPARAM(isp, bus)->role;
251 FCPARAM(isp, bus)->role = nr;
252 } else {
253 *(int *)addr = SDPARAM(isp, bus)->role;
254 SDPARAM(isp, bus)->role = nr;
255 }
256 retval = 0;
257 break;
258
259 case ISP_RESETHBA:
260 ISP_LOCK(isp);
261 isp_reinit(isp, 0);
262 ISP_UNLOCK(isp);
263 retval = 0;
264 break;
265
266 case ISP_RESCAN:
267 if (IS_FC(isp)) {
268 bus = *(int *)addr;
269 if (bus < 0 || bus >= isp->isp_nchan) {
270 retval = -ENXIO;
271 break;
272 }
273 ISP_LOCK(isp);
274 if (isp_fc_runstate(isp, bus, 5 * 1000000)) {
275 retval = EIO;
276 } else {
277 retval = 0;
278 }
279 ISP_UNLOCK(isp);
280 }
281 break;
282
283 case ISP_FC_LIP:
284 if (IS_FC(isp)) {
285 bus = *(int *)addr;
286 if (bus < 0 || bus >= isp->isp_nchan) {
287 retval = -ENXIO;
288 break;
289 }
290 ISP_LOCK(isp);
291 if (isp_control(isp, ISPCTL_SEND_LIP, bus)) {
292 retval = EIO;
293 } else {
294 retval = 0;
295 }
296 ISP_UNLOCK(isp);
297 }
298 break;
299 case ISP_FC_GETDINFO:
300 {
301 struct isp_fc_device *ifc = (struct isp_fc_device *) addr;
302 fcportdb_t *lp;
303
304 if (IS_SCSI(isp)) {
305 break;
306 }
307 if (ifc->loopid >= MAX_FC_TARG) {
308 retval = EINVAL;
309 break;
310 }
311 lp = &FCPARAM(isp, ifc->chan)->portdb[ifc->loopid];
312 if (lp->state == FC_PORTDB_STATE_VALID) {
313 ifc->role = lp->roles;
314 ifc->loopid = lp->handle;
315 ifc->portid = lp->portid;
316 ifc->node_wwn = lp->node_wwn;
317 ifc->port_wwn = lp->port_wwn;
318 retval = 0;
319 } else {
320 retval = ENODEV;
321 }
322 break;
323 }
324 case ISP_GET_STATS:
325 {
326 isp_stats_t *sp = (isp_stats_t *) addr;
327
328 ISP_MEMZERO(sp, sizeof (*sp));
329 sp->isp_stat_version = ISP_STATS_VERSION;
330 sp->isp_type = isp->isp_type;
331 sp->isp_revision = isp->isp_revision;
332 ISP_LOCK(isp);
333 sp->isp_stats[ISP_INTCNT] = isp->isp_intcnt;
334 sp->isp_stats[ISP_INTBOGUS] = isp->isp_intbogus;
335 sp->isp_stats[ISP_INTMBOXC] = isp->isp_intmboxc;
336 sp->isp_stats[ISP_INGOASYNC] = isp->isp_intoasync;
337 sp->isp_stats[ISP_RSLTCCMPLT] = isp->isp_rsltccmplt;
338 sp->isp_stats[ISP_FPHCCMCPLT] = isp->isp_fphccmplt;
339 sp->isp_stats[ISP_RSCCHIWAT] = isp->isp_rscchiwater;
340 sp->isp_stats[ISP_FPCCHIWAT] = isp->isp_fpcchiwater;
341 ISP_UNLOCK(isp);
342 retval = 0;
343 break;
344 }
345 case ISP_CLR_STATS:
346 ISP_LOCK(isp);
347 isp->isp_intcnt = 0;
348 isp->isp_intbogus = 0;
349 isp->isp_intmboxc = 0;
350 isp->isp_intoasync = 0;
351 isp->isp_rsltccmplt = 0;
352 isp->isp_fphccmplt = 0;
353 isp->isp_rscchiwater = 0;
354 isp->isp_fpcchiwater = 0;
355 ISP_UNLOCK(isp);
356 retval = 0;
357 break;
358 case ISP_FC_GETHINFO:
359 {
360 struct isp_hba_device *hba = (struct isp_hba_device *) addr;
361 bus = hba->fc_channel;
362
363 if (bus < 0 || bus >= isp->isp_nchan) {
364 retval = ENXIO;
365 break;
366 }
367 hba->fc_fw_major = ISP_FW_MAJORX(isp->isp_fwrev);
368 hba->fc_fw_minor = ISP_FW_MINORX(isp->isp_fwrev);
369 hba->fc_fw_micro = ISP_FW_MICROX(isp->isp_fwrev);
370 hba->fc_nchannels = isp->isp_nchan;
371 hba->fc_nports = isp->isp_nchan;/* XXXX 24XX STUFF? XXX */
372 if (IS_FC(isp)) {
373 hba->fc_speed = FCPARAM(isp, bus)->isp_gbspeed;
374 hba->fc_topology = FCPARAM(isp, bus)->isp_topo + 1;
375 hba->fc_loopid = FCPARAM(isp, bus)->isp_loopid;
376 hba->nvram_node_wwn = FCPARAM(isp, bus)->isp_wwnn_nvram;
377 hba->nvram_port_wwn = FCPARAM(isp, bus)->isp_wwpn_nvram;
378 hba->active_node_wwn = FCPARAM(isp, bus)->isp_wwnn;
379 hba->active_port_wwn = FCPARAM(isp, bus)->isp_wwpn;
380 } else {
381 hba->fc_speed = 0;
382 hba->fc_topology = 0;
383 hba->nvram_node_wwn = 0ull;
384 hba->nvram_port_wwn = 0ull;
385 hba->active_node_wwn = 0ull;
386 hba->active_port_wwn = 0ull;
387 }
388 retval = 0;
389 break;
390 }
391 case ISP_TSK_MGMT:
392 {
393 int needmarker;
394 struct isp_fc_tsk_mgmt *fct = (struct isp_fc_tsk_mgmt *) addr;
395 uint16_t loopid;
396 mbreg_t mbs;
397
398 if (IS_SCSI(isp)) {
399 break;
400 }
401
402 bus = fct->chan;
403 if (bus < 0 || bus >= isp->isp_nchan) {
404 retval = -ENXIO;
405 break;
406 }
407
408 memset(&mbs, 0, sizeof (mbs));
409 needmarker = retval = 0;
410 loopid = fct->loopid;
411 if (ISP_CAP_2KLOGIN(isp) == 0) {
412 loopid <<= 8;
413 }
414 switch (fct->action) {
415 case IPT_CLEAR_ACA:
416 mbs.param[0] = MBOX_CLEAR_ACA;
417 mbs.param[1] = loopid;
418 mbs.param[2] = fct->lun;
419 break;
420 case IPT_TARGET_RESET:
421 mbs.param[0] = MBOX_TARGET_RESET;
422 mbs.param[1] = loopid;
423 needmarker = 1;
424 break;
425 case IPT_LUN_RESET:
426 mbs.param[0] = MBOX_LUN_RESET;
427 mbs.param[1] = loopid;
428 mbs.param[2] = fct->lun;
429 needmarker = 1;
430 break;
431 case IPT_CLEAR_TASK_SET:
432 mbs.param[0] = MBOX_CLEAR_TASK_SET;
433 mbs.param[1] = loopid;
434 mbs.param[2] = fct->lun;
435 needmarker = 1;
436 break;
437 case IPT_ABORT_TASK_SET:
438 mbs.param[0] = MBOX_ABORT_TASK_SET;
439 mbs.param[1] = loopid;
440 mbs.param[2] = fct->lun;
441 needmarker = 1;
442 break;
443 default:
444 retval = EINVAL;
445 break;
446 }
447 if (retval == 0) {
448 if (needmarker) {
449 FCPARAM(isp, bus)->sendmarker = 1;
450 }
451 ISP_LOCK(isp);
452 retval = isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
453 ISP_UNLOCK(isp);
454 if (retval) {
455 retval = EIO;
456 }
457 }
458 break;
459 }
460 case ISP_FC_GETDLIST:
461 {
462 isp_dlist_t local, *ua;
463 uint16_t nph, nphe, count, channel, lim;
464 struct wwnpair pair, *uptr;
465
466 if (IS_SCSI(isp)) {
467 retval = EINVAL;
468 break;
469 }
470
471 ua = *(isp_dlist_t **)addr;
472 if (copyin(ua, &local, sizeof (isp_dlist_t))) {
473 retval = EFAULT;
474 break;
475 }
476 lim = local.count;
477 channel = local.channel;
478
479 ua = *(isp_dlist_t **)addr;
480 uptr = &ua->wwns[0];
481
482 if (ISP_CAP_2KLOGIN(isp)) {
483 nphe = NPH_MAX_2K;
484 } else {
485 nphe = NPH_MAX;
486 }
487 for (count = 0, nph = 0; count < lim && nph != nphe; nph++) {
488 ISP_LOCK(isp);
489 retval = isp_control(isp, ISPCTL_GET_NAMES, channel,
490 nph, &pair.wwnn, &pair.wwpn);
491 ISP_UNLOCK(isp);
492 if (retval || (pair.wwpn == INI_NONE &&
493 pair.wwnn == INI_NONE)) {
494 retval = 0;
495 continue;
496 }
497 if (copyout(&pair, (void *)uptr++, sizeof (pair))) {
498 retval = EFAULT;
499 break;
500 }
501 count++;
502 }
503 if (retval == 0) {
504 if (copyout(&count, (void *)&ua->count,
505 sizeof (count))) {
506 retval = EFAULT;
507 }
508 }
509 break;
510 }
511 case SCBUSIORESET:
512 ISP_LOCK(isp);
513 if (isp_control(isp, ISPCTL_RESET_BUS, &chan->chan_channel)) {
514 retval = EIO;
515 } else {
516 retval = 0;
517 }
518 ISP_UNLOCK(isp);
519 break;
520 default:
521 break;
522 }
523 return (retval);
524 }
525
526 static void
527 ispcmd(struct ispsoftc *isp, XS_T *xs)
528 {
529 volatile uint8_t ombi;
530 int lim, chan;
531
532 ISP_LOCK(isp);
533 if (isp->isp_state < ISP_RUNSTATE) {
534 ISP_DISABLE_INTS(isp);
535 isp_init(isp);
536 if (isp->isp_state != ISP_INITSTATE) {
537 ISP_ENABLE_INTS(isp);
538 ISP_UNLOCK(isp);
539 isp_prt(isp, ISP_LOGERR, "isp not at init state");
540 XS_SETERR(xs, HBA_BOTCH);
541 scsipi_done(xs);
542 return;
543 }
544 isp->isp_state = ISP_RUNSTATE;
545 ISP_ENABLE_INTS(isp);
546 }
547 chan = XS_CHANNEL(xs);
548
549 /*
550 * Handle the case of a FC card where the FC thread hasn't
551 * fired up yet and we don't yet have a known loop state.
552 */
553 if (IS_FC(isp) && (FCPARAM(isp, chan)->isp_fwstate != FW_READY ||
554 FCPARAM(isp, chan)->isp_loopstate != LOOP_READY) &&
555 isp->isp_osinfo.thread == NULL) {
556 ombi = isp->isp_osinfo.mbox_sleep_ok != 0;
557 int delay_time;
558
559 if (xs->xs_control & XS_CTL_POLL) {
560 isp->isp_osinfo.mbox_sleep_ok = 0;
561 }
562
563 if (isp->isp_osinfo.loop_checked == 0) {
564 delay_time = 10 * 1000000;
565 isp->isp_osinfo.loop_checked = 1;
566 } else {
567 delay_time = 250000;
568 }
569
570 if (isp_fc_runstate(isp, XS_CHANNEL(xs), delay_time) != 0) {
571 if (xs->xs_control & XS_CTL_POLL) {
572 isp->isp_osinfo.mbox_sleep_ok = ombi;
573 }
574 if (FCPARAM(isp, XS_CHANNEL(xs))->loop_seen_once == 0) {
575 XS_SETERR(xs, HBA_SELTIMEOUT);
576 scsipi_done(xs);
577 ISP_UNLOCK(isp);
578 return;
579 }
580 /*
581 * Otherwise, fall thru to be queued up for later.
582 */
583 } else {
584 int wasblocked =
585 (isp->isp_osinfo.blocked || isp->isp_osinfo.paused);
586 isp->isp_osinfo.blocked = isp->isp_osinfo.paused = 0;
587 if (wasblocked) {
588 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
589 "THAW QUEUES @ LINE %d", __LINE__);
590 scsipi_channel_thaw(&isp->isp_osinfo.chan[chan],
591 1);
592 }
593 }
594 if (xs->xs_control & XS_CTL_POLL) {
595 isp->isp_osinfo.mbox_sleep_ok = ombi;
596 }
597 }
598
599 if (isp->isp_osinfo.paused) {
600 isp_prt(isp, ISP_LOGWARN, "I/O while paused");
601 xs->error = XS_RESOURCE_SHORTAGE;
602 scsipi_done(xs);
603 ISP_UNLOCK(isp);
604 return;
605 }
606 if (isp->isp_osinfo.blocked) {
607 isp_prt(isp, ISP_LOGWARN,
608 "I/O while blocked with retries %d", xs, xs->xs_retries);
609 if (xs->xs_retries) {
610 xs->error = XS_REQUEUE;
611 xs->xs_retries--;
612 } else {
613 XS_SETERR(xs, HBA_SELTIMEOUT);
614 }
615 scsipi_done(xs);
616 ISP_UNLOCK(isp);
617 return;
618 }
619
620 if (xs->xs_control & XS_CTL_POLL) {
621 ombi = isp->isp_osinfo.mbox_sleep_ok;
622 isp->isp_osinfo.mbox_sleep_ok = 0;
623 }
624
625 switch (isp_start(xs)) {
626 case CMD_QUEUED:
627 if (xs->xs_control & XS_CTL_POLL) {
628 isp_polled_cmd_wait(isp, xs);
629 isp->isp_osinfo.mbox_sleep_ok = ombi;
630 } else if (xs->timeout) {
631 callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
632 }
633 break;
634 case CMD_EAGAIN:
635 isp->isp_osinfo.paused = 1;
636 xs->error = XS_RESOURCE_SHORTAGE;
637 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
638 "FREEZE QUEUES @ LINE %d", __LINE__);
639 for (chan = 0; chan < isp->isp_nchan; chan++) {
640 scsipi_channel_freeze(&isp->isp_osinfo.chan[chan], 1);
641 }
642 scsipi_done(xs);
643 break;
644 case CMD_RQLATER:
645 /*
646 * We can only get RQLATER from FC devices (1 channel only)
647 *
648 * If we've never seen loop up see if if we've been down
649 * quickboot time, otherwise wait loop down limit time.
650 * If so, then we start giving up on commands.
651 */
652 if (FCPARAM(isp, XS_CHANNEL(xs))->loop_seen_once == 0) {
653 lim = isp_quickboot_time;
654 } else {
655 lim = isp->isp_osinfo.loop_down_limit;
656 }
657 if (isp->isp_osinfo.loop_down_time >= lim) {
658 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
659 "RQLATER->SELTIMEOUT for %d (%d >= %d)", XS_TGT(xs),
660 isp->isp_osinfo.loop_down_time, lim);
661 XS_SETERR(xs, HBA_SELTIMEOUT);
662 scsipi_done(xs);
663 break;
664 }
665 if (isp->isp_osinfo.blocked == 0) {
666 isp->isp_osinfo.blocked = 1;
667 scsipi_channel_freeze(&isp->isp_osinfo.chan[chan], 1);
668 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
669 "FREEZE QUEUES @ LINE %d", __LINE__);
670 } else {
671 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
672 "RQLATER WITH FROZEN QUEUES @ LINE %d", __LINE__);
673 }
674 xs->error = XS_REQUEUE;
675 scsipi_done(xs);
676 break;
677 case CMD_COMPLETE:
678 scsipi_done(xs);
679 break;
680 }
681 ISP_UNLOCK(isp);
682 }
683
684 static void
685 isprequest(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg)
686 {
687 struct ispsoftc *isp = device_private(chan->chan_adapter->adapt_dev);
688
689 switch (req) {
690 case ADAPTER_REQ_RUN_XFER:
691 ispcmd(isp, (XS_T *) arg);
692 break;
693
694 case ADAPTER_REQ_GROW_RESOURCES:
695 /* Not supported. */
696 break;
697
698 case ADAPTER_REQ_SET_XFER_MODE:
699 if (IS_SCSI(isp)) {
700 struct scsipi_xfer_mode *xm = arg;
701 int dflags = 0;
702 sdparam *sdp = SDPARAM(isp, chan->chan_channel);
703
704 if (xm->xm_mode & PERIPH_CAP_TQING)
705 dflags |= DPARM_TQING;
706 if (xm->xm_mode & PERIPH_CAP_WIDE16)
707 dflags |= DPARM_WIDE;
708 if (xm->xm_mode & PERIPH_CAP_SYNC)
709 dflags |= DPARM_SYNC;
710 ISP_LOCK(isp);
711 sdp->isp_devparam[xm->xm_target].goal_flags |= dflags;
712 dflags = sdp->isp_devparam[xm->xm_target].goal_flags;
713 sdp->isp_devparam[xm->xm_target].dev_update = 1;
714 sdp->update = 1;
715 ISP_UNLOCK(isp);
716 isp_prt(isp, ISP_LOGDEBUG1,
717 "isprequest: device flags 0x%x for %d.%d.X",
718 dflags, chan->chan_channel, xm->xm_target);
719 break;
720 }
721 default:
722 break;
723 }
724 }
725
726 static void
727 isp_polled_cmd_wait(struct ispsoftc *isp, XS_T *xs)
728 {
729 int infinite = 0, mswait;
730
731 /*
732 * If we can't use interrupts, poll on completion.
733 */
734 if ((mswait = XS_TIME(xs)) == 0) {
735 infinite = 1;
736 }
737
738 while (mswait || infinite) {
739 uint32_t isr;
740 uint16_t sema, mbox;
741 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
742 isp_intr(isp, isr, sema, mbox);
743 if (XS_CMD_DONE_P(xs)) {
744 break;
745 }
746 }
747 ISP_DELAY(1000);
748 mswait -= 1;
749 }
750
751 /*
752 * If no other error occurred but we didn't finish
753 * something bad happened, so abort the command.
754 */
755 if (XS_CMD_DONE_P(xs) == 0) {
756 if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
757 isp_reinit(isp, 0);
758 }
759 if (XS_NOERR(xs)) {
760 isp_prt(isp, ISP_LOGERR, "polled command timed out");
761 XS_SETERR(xs, HBA_BOTCH);
762 }
763 }
764 scsipi_done(xs);
765 }
766
767 void
768 isp_done(XS_T *xs)
769 {
770 if (XS_CMD_WDOG_P(xs) == 0) {
771 struct ispsoftc *isp = XS_ISP(xs);
772 callout_stop(&xs->xs_callout);
773 if (XS_CMD_GRACE_P(xs)) {
774 isp_prt(isp, ISP_LOGDEBUG1,
775 "finished command on borrowed time");
776 }
777 XS_CMD_S_CLEAR(xs);
778 /*
779 * Fixup- if we get a QFULL, we need
780 * to set XS_BUSY as the error.
781 */
782 if (xs->status == SCSI_QUEUE_FULL) {
783 xs->error = XS_BUSY;
784 }
785 if (isp->isp_osinfo.paused) {
786 int i;
787 isp->isp_osinfo.paused = 0;
788 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
789 "THAW QUEUES @ LINE %d", __LINE__);
790 for (i = 0; i < isp->isp_nchan; i++) {
791 scsipi_channel_timed_thaw(&isp->isp_osinfo.chan[i]);
792 }
793 }
794 if (xs->error == XS_DRIVER_STUFFUP) {
795 isp_prt(isp, ISP_LOGERR,
796 "BOTCHED cmd for %d.%d.%d cmd 0x%x datalen %ld",
797 XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
798 XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
799 }
800 scsipi_done(xs);
801 }
802 }
803
804 static void
805 isp_dog(void *arg)
806 {
807 XS_T *xs = arg;
808 struct ispsoftc *isp = XS_ISP(xs);
809 uint32_t handle;
810
811
812 ISP_ILOCK(isp);
813 /*
814 * We've decided this command is dead. Make sure we're not trying
815 * to kill a command that's already dead by getting it's handle and
816 * and seeing whether it's still alive.
817 */
818 handle = isp_find_handle(isp, xs);
819 if (handle) {
820 uint32_t isr;
821 uint16_t mbox, sema;
822
823 if (XS_CMD_DONE_P(xs)) {
824 isp_prt(isp, ISP_LOGDEBUG1,
825 "watchdog found done cmd (handle 0x%x)", handle);
826 ISP_IUNLOCK(isp);
827 return;
828 }
829
830 if (XS_CMD_WDOG_P(xs)) {
831 isp_prt(isp, ISP_LOGDEBUG1,
832 "recursive watchdog (handle 0x%x)", handle);
833 ISP_IUNLOCK(isp);
834 return;
835 }
836
837 XS_CMD_S_WDOG(xs);
838
839 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
840 isp_intr(isp, isr, sema, mbox);
841
842 }
843 if (XS_CMD_DONE_P(xs)) {
844 isp_prt(isp, ISP_LOGDEBUG1,
845 "watchdog cleanup for handle 0x%x", handle);
846 XS_CMD_C_WDOG(xs);
847 isp_done(xs);
848 } else if (XS_CMD_GRACE_P(xs)) {
849 isp_prt(isp, ISP_LOGDEBUG1,
850 "watchdog timeout for handle 0x%x", handle);
851 /*
852 * Make sure the command is *really* dead before we
853 * release the handle (and DMA resources) for reuse.
854 */
855 (void) isp_control(isp, ISPCTL_ABORT_CMD, arg);
856
857 /*
858 * After this point, the command is really dead.
859 */
860 if (XS_XFRLEN(xs)) {
861 ISP_DMAFREE(isp, xs, handle);
862 }
863 isp_destroy_handle(isp, handle);
864 XS_SETERR(xs, XS_TIMEOUT);
865 XS_CMD_S_CLEAR(xs);
866 isp_done(xs);
867 } else {
868 void *qe;
869 isp_marker_t local, *mp = &local;
870 isp_prt(isp, ISP_LOGDEBUG2,
871 "possible command timeout on handle %x", handle);
872 XS_CMD_C_WDOG(xs);
873 callout_reset(&xs->xs_callout, hz, isp_dog, xs);
874 qe = isp_getrqentry(isp);
875 if (qe == NULL) {
876 ISP_UNLOCK(isp);
877 return;
878 }
879 XS_CMD_S_GRACE(xs);
880 ISP_MEMZERO((void *) mp, sizeof (*mp));
881 mp->mrk_header.rqs_entry_count = 1;
882 mp->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
883 mp->mrk_modifier = SYNC_ALL;
884 mp->mrk_target = XS_CHANNEL(xs) << 7;
885 isp_put_marker(isp, mp, qe);
886 ISP_SYNC_REQUEST(isp);
887 }
888 } else {
889 isp_prt(isp, ISP_LOGDEBUG0, "watchdog with no command");
890 }
891 ISP_IUNLOCK(isp);
892 }
893
894 /*
895 * Gone Device Timer Function- when we have decided that a device has gone
896 * away, we wait a specific period of time prior to telling the OS it has
897 * gone away.
898 *
899 * This timer function fires once a second and then scans the port database
900 * for devices that are marked dead but still have a virtual target assigned.
901 * We decrement a counter for that port database entry, and when it hits zero,
902 * we tell the OS the device has gone away.
903 */
904 static void
905 isp_gdt(void *arg)
906 {
907 ispsoftc_t *isp = arg;
908 fcportdb_t *lp;
909 int dbidx, tgt, more_to_do = 0;
910
911 isp_prt(isp, ISP_LOGDEBUG0, "GDT timer expired");
912 ISP_LOCK(isp);
913 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
914 lp = &FCPARAM(isp, 0)->portdb[dbidx];
915
916 if (lp->state != FC_PORTDB_STATE_ZOMBIE) {
917 continue;
918 }
919 if (lp->dev_map_idx == 0) {
920 continue;
921 }
922 if (lp->new_reserved == 0) {
923 continue;
924 }
925 lp->new_reserved -= 1;
926 if (lp->new_reserved != 0) {
927 more_to_do++;
928 continue;
929 }
930 tgt = lp->dev_map_idx - 1;
931 FCPARAM(isp, 0)->isp_dev_map[tgt] = 0;
932 lp->dev_map_idx = 0;
933 lp->state = FC_PORTDB_STATE_NIL;
934 isp_prt(isp, ISP_LOGCONFIG, prom3, lp->portid, tgt,
935 "Gone Device Timeout");
936 isp_make_gone(isp, tgt);
937 }
938 if (more_to_do) {
939 callout_schedule(&isp->isp_osinfo.gdt, hz);
940 } else {
941 isp->isp_osinfo.gdt_running = 0;
942 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
943 "stopping Gone Device Timer");
944 }
945 ISP_UNLOCK(isp);
946 }
947
948 /*
949 * Loop Down Timer Function- when loop goes down, a timer is started and
950 * and after it expires we come here and take all probational devices that
951 * the OS knows about and the tell the OS that they've gone away.
952 *
953 * We don't clear the devices out of our port database because, when loop
954 * come back up, we have to do some actual cleanup with the chip at that
955 * point (implicit PLOGO, e.g., to get the chip's port database state right).
956 */
957 static void
958 isp_ldt(void *arg)
959 {
960 ispsoftc_t *isp = arg;
961 fcportdb_t *lp;
962 int dbidx, tgt;
963
964 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Loop Down Timer expired");
965 ISP_LOCK(isp);
966
967 /*
968 * Notify to the OS all targets who we now consider have departed.
969 */
970 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
971 lp = &FCPARAM(isp, 0)->portdb[dbidx];
972
973 if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
974 continue;
975 }
976 if (lp->dev_map_idx == 0) {
977 continue;
978 }
979
980 /*
981 * XXX: CLEAN UP AND COMPLETE ANY PENDING COMMANDS FIRST!
982 */
983
984 /*
985 * Mark that we've announced that this device is gone....
986 */
987 lp->reserved = 1;
988
989 /*
990 * but *don't* change the state of the entry. Just clear
991 * any target id stuff and announce to CAM that the
992 * device is gone. This way any necessary PLOGO stuff
993 * will happen when loop comes back up.
994 */
995
996 tgt = lp->dev_map_idx - 1;
997 FCPARAM(isp, 0)->isp_dev_map[tgt] = 0;
998 lp->dev_map_idx = 0;
999 isp_prt(isp, ISP_LOGCONFIG, prom3, lp->portid, tgt,
1000 "Loop Down Timeout");
1001 isp_make_gone(isp, tgt);
1002 }
1003
1004 /*
1005 * The loop down timer has expired. Wake up the kthread
1006 * to notice that fact (or make it false).
1007 */
1008 isp->isp_osinfo.loop_down_time = isp->isp_osinfo.loop_down_limit+1;
1009 wakeup(&isp->isp_osinfo.thread);
1010 ISP_UNLOCK(isp);
1011 }
1012
1013 static void
1014 isp_make_here(ispsoftc_t *isp, int tgt)
1015 {
1016 isp_prt(isp, ISP_LOGINFO, "target %d has arrived", tgt);
1017 }
1018
1019 static void
1020 isp_make_gone(ispsoftc_t *isp, int tgt)
1021 {
1022 isp_prt(isp, ISP_LOGINFO, "target %d has departed", tgt);
1023 }
1024
1025 static void
1026 isp_fc_worker(void *arg)
1027 {
1028 void scsipi_run_queue(struct scsipi_channel *);
1029 ispsoftc_t *isp = arg;
1030 int slp = 0;
1031 int chan = 0;
1032
1033 int s = splbio();
1034 /*
1035 * The first loop is for our usage where we have yet to have
1036 * gotten good fibre channel state.
1037 */
1038 while (isp->isp_osinfo.thread != NULL) {
1039 int sok, lb, lim;
1040
1041 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "checking FC state");
1042 sok = isp->isp_osinfo.mbox_sleep_ok;
1043 isp->isp_osinfo.mbox_sleep_ok = 1;
1044 lb = isp_fc_runstate(isp, chan, 250000);
1045 isp->isp_osinfo.mbox_sleep_ok = sok;
1046 if (lb) {
1047 /*
1048 * Increment loop down time by the last sleep interval
1049 */
1050 isp->isp_osinfo.loop_down_time += slp;
1051
1052 if (lb < 0) {
1053 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1054 "FC loop not up (down count %d)",
1055 isp->isp_osinfo.loop_down_time);
1056 } else {
1057 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1058 "FC got to %d (down count %d)",
1059 lb, isp->isp_osinfo.loop_down_time);
1060 }
1061
1062
1063 /*
1064 * If we've never seen loop up and we've waited longer
1065 * than quickboot time, or we've seen loop up but we've
1066 * waited longer than loop_down_limit, give up and go
1067 * to sleep until loop comes up.
1068 */
1069 if (FCPARAM(isp, 0)->loop_seen_once == 0) {
1070 lim = isp_quickboot_time;
1071 } else {
1072 lim = isp->isp_osinfo.loop_down_limit;
1073 }
1074 if (isp->isp_osinfo.loop_down_time >= lim) {
1075 /*
1076 * If we're now past our limit, release
1077 * the queues and let them come in and
1078 * either get HBA_SELTIMOUT or cause
1079 * another freeze.
1080 */
1081 isp->isp_osinfo.blocked = 1;
1082 slp = 0;
1083 } else if (isp->isp_osinfo.loop_down_time < 10) {
1084 slp = 1;
1085 } else if (isp->isp_osinfo.loop_down_time < 30) {
1086 slp = 5;
1087 } else if (isp->isp_osinfo.loop_down_time < 60) {
1088 slp = 10;
1089 } else if (isp->isp_osinfo.loop_down_time < 120) {
1090 slp = 20;
1091 } else {
1092 slp = 30;
1093 }
1094
1095 } else {
1096 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1097 "FC state OK");
1098 isp->isp_osinfo.loop_down_time = 0;
1099 slp = 0;
1100 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1101 "THAW QUEUES @ LINE %d", __LINE__);
1102 scsipi_channel_thaw(&isp->isp_osinfo.chan[chan], 1);
1103 }
1104
1105 /*
1106 * If we'd frozen the queues, unfreeze them now so that
1107 * we can start getting commands. If the FC state isn't
1108 * okay yet, they'll hit that in isp_start which will
1109 * freeze the queues again.
1110 */
1111 if (isp->isp_osinfo.blocked) {
1112 isp->isp_osinfo.blocked = 0;
1113 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1114 "THAW QUEUES @ LINE %d", __LINE__);
1115 scsipi_channel_thaw(&isp->isp_osinfo.chan[chan], 1);
1116 }
1117 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "sleep time %d", slp);
1118 tsleep(&isp->isp_osinfo.thread, PRIBIO, "ispf", slp * hz);
1119
1120 /*
1121 * If slp is zero, we're waking up for the first time after
1122 * things have been okay. In this case, we set a deferral state
1123 * for all commands and delay hysteresis seconds before starting
1124 * the FC state evaluation. This gives the loop/fabric a chance
1125 * to settle.
1126 */
1127 if (slp == 0 && isp_fabric_hysteresis) {
1128 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1129 "sleep hysteresis tick time %d",
1130 isp_fabric_hysteresis * hz);
1131 (void) tsleep(&isp_fabric_hysteresis, PRIBIO, "ispT",
1132 (isp_fabric_hysteresis * hz));
1133 }
1134 }
1135 splx(s);
1136
1137 /* In case parent is waiting for us to exit. */
1138 wakeup(&isp->isp_osinfo.thread);
1139 kthread_exit(0);
1140 }
1141
1142 /*
1143 * Free any associated resources prior to decommissioning and
1144 * set the card to a known state (so it doesn't wake up and kick
1145 * us when we aren't expecting it to).
1146 *
1147 * Locks are held before coming here.
1148 */
1149 void
1150 isp_uninit(struct ispsoftc *isp)
1151 {
1152 isp_lock(isp);
1153 /*
1154 * Leave with interrupts disabled.
1155 */
1156 ISP_DISABLE_INTS(isp);
1157 isp_unlock(isp);
1158 }
1159
1160 void
1161 isp_async(struct ispsoftc *isp, ispasync_t cmd, ...)
1162 {
1163 int bus, tgt;
1164 const char *msg = NULL;
1165 static const char prom[] =
1166 "PortID 0x%06x handle 0x%x role %s %s\n"
1167 " WWNN 0x%08x%08x WWPN 0x%08x%08x";
1168 static const char prom2[] =
1169 "PortID 0x%06x handle 0x%x role %s %s tgt %u\n"
1170 " WWNN 0x%08x%08x WWPN 0x%08x%08x";
1171 fcportdb_t *lp;
1172 va_list ap;
1173
1174 switch (cmd) {
1175 case ISPASYNC_NEW_TGT_PARAMS:
1176 if (IS_SCSI(isp)) {
1177 sdparam *sdp;
1178 int flags;
1179 struct scsipi_xfer_mode xm;
1180
1181 va_start(ap, cmd);
1182 bus = va_arg(ap, int);
1183 tgt = va_arg(ap, int);
1184 va_end(ap);
1185 sdp = SDPARAM(isp, bus);
1186 flags = sdp->isp_devparam[tgt].actv_flags;
1187
1188 xm.xm_mode = 0;
1189 xm.xm_period = sdp->isp_devparam[tgt].actv_period;
1190 xm.xm_offset = sdp->isp_devparam[tgt].actv_offset;
1191 xm.xm_target = tgt;
1192
1193 if ((flags & DPARM_SYNC) && xm.xm_period && xm.xm_offset)
1194 xm.xm_mode |= PERIPH_CAP_SYNC;
1195 if (flags & DPARM_WIDE)
1196 xm.xm_mode |= PERIPH_CAP_WIDE16;
1197 if (flags & DPARM_TQING)
1198 xm.xm_mode |= PERIPH_CAP_TQING;
1199 scsipi_async_event(&isp->isp_osinfo.chan[bus],
1200 ASYNC_EVENT_XFER_MODE, &xm);
1201 break;
1202 }
1203 case ISPASYNC_BUS_RESET:
1204 va_start(ap, cmd);
1205 bus = va_arg(ap, int);
1206 va_end(ap);
1207 isp_prt(isp, ISP_LOGINFO, "SCSI bus %d reset detected", bus);
1208 scsipi_async_event(&isp->isp_osinfo.chan[bus],
1209 ASYNC_EVENT_RESET, NULL);
1210 break;
1211 case ISPASYNC_LIP:
1212 if (msg == NULL) {
1213 msg = "LIP Received";
1214 }
1215 /* FALLTHROUGH */
1216 case ISPASYNC_LOOP_RESET:
1217 if (msg == NULL) {
1218 msg = "LOOP Reset Received";
1219 }
1220 /* FALLTHROUGH */
1221 case ISPASYNC_LOOP_DOWN:
1222 if (msg == NULL) {
1223 msg = "Loop DOWN";
1224 }
1225 va_start(ap, cmd);
1226 bus = va_arg(ap, int);
1227 va_end(ap);
1228
1229 /*
1230 * Don't do queue freezes or blockage until we have the
1231 * thread running and interrupts that can unfreeze/unblock us.
1232 */
1233 if (isp->isp_osinfo.mbox_sleep_ok &&
1234 isp->isp_osinfo.blocked == 0 &&
1235 isp->isp_osinfo.thread) {
1236 isp->isp_osinfo.blocked = 1;
1237 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1238 "FREEZE QUEUES @ LINE %d", __LINE__);
1239 scsipi_channel_freeze(&isp->isp_osinfo.chan[bus], 1);
1240 if (callout_pending(&isp->isp_osinfo.ldt) == 0) {
1241 callout_schedule(&isp->isp_osinfo.ldt,
1242 isp->isp_osinfo.loop_down_limit * hz);
1243 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1244 "Starting Loop Down Timer");
1245 }
1246 }
1247 isp_prt(isp, ISP_LOGINFO, msg);
1248 break;
1249 case ISPASYNC_LOOP_UP:
1250 /*
1251 * Let the subsequent ISPASYNC_CHANGE_NOTIFY invoke
1252 * the FC worker thread. When the FC worker thread
1253 * is done, let *it* call scsipi_channel_thaw...
1254 */
1255 isp_prt(isp, ISP_LOGINFO, "Loop UP");
1256 break;
1257 case ISPASYNC_DEV_ARRIVED:
1258 va_start(ap, cmd);
1259 bus = va_arg(ap, int);
1260 lp = va_arg(ap, fcportdb_t *);
1261 va_end(ap);
1262 lp->reserved = 0;
1263 if ((FCPARAM(isp, bus)->role & ISP_ROLE_INITIATOR) &&
1264 (lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT))) {
1265 int dbidx = lp - FCPARAM(isp, bus)->portdb;
1266 int i;
1267
1268 for (i = 0; i < MAX_FC_TARG; i++) {
1269 if (i >= FL_ID && i <= SNS_ID) {
1270 continue;
1271 }
1272 if (FCPARAM(isp, bus)->isp_dev_map[i] == 0) {
1273 break;
1274 }
1275 }
1276 if (i < MAX_FC_TARG) {
1277 FCPARAM(isp, bus)->isp_dev_map[i] = dbidx + 1;
1278 lp->dev_map_idx = i + 1;
1279 } else {
1280 isp_prt(isp, ISP_LOGWARN, "out of target ids");
1281 isp_dump_portdb(isp, bus);
1282 }
1283 }
1284 if (lp->dev_map_idx) {
1285 tgt = lp->dev_map_idx - 1;
1286 isp_prt(isp, ISP_LOGCONFIG, prom2,
1287 lp->portid, lp->handle,
1288 roles[lp->roles], "arrived at", tgt,
1289 (uint32_t) (lp->node_wwn >> 32),
1290 (uint32_t) lp->node_wwn,
1291 (uint32_t) (lp->port_wwn >> 32),
1292 (uint32_t) lp->port_wwn);
1293 isp_make_here(isp, tgt);
1294 } else {
1295 isp_prt(isp, ISP_LOGCONFIG, prom,
1296 lp->portid, lp->handle,
1297 roles[lp->roles], "arrived",
1298 (uint32_t) (lp->node_wwn >> 32),
1299 (uint32_t) lp->node_wwn,
1300 (uint32_t) (lp->port_wwn >> 32),
1301 (uint32_t) lp->port_wwn);
1302 }
1303 break;
1304 case ISPASYNC_DEV_CHANGED:
1305 va_start(ap, cmd);
1306 bus = va_arg(ap, int);
1307 lp = va_arg(ap, fcportdb_t *);
1308 va_end(ap);
1309 if (isp_change_is_bad) {
1310 lp->state = FC_PORTDB_STATE_NIL;
1311 if (lp->dev_map_idx) {
1312 tgt = lp->dev_map_idx - 1;
1313 FCPARAM(isp, bus)->isp_dev_map[tgt] = 0;
1314 lp->dev_map_idx = 0;
1315 isp_prt(isp, ISP_LOGCONFIG, prom3,
1316 lp->portid, tgt, "change is bad");
1317 isp_make_gone(isp, tgt);
1318 } else {
1319 isp_prt(isp, ISP_LOGCONFIG, prom,
1320 lp->portid, lp->handle,
1321 roles[lp->roles],
1322 "changed and departed",
1323 (uint32_t) (lp->node_wwn >> 32),
1324 (uint32_t) lp->node_wwn,
1325 (uint32_t) (lp->port_wwn >> 32),
1326 (uint32_t) lp->port_wwn);
1327 }
1328 } else {
1329 lp->portid = lp->new_portid;
1330 lp->roles = lp->new_roles;
1331 if (lp->dev_map_idx) {
1332 int t = lp->dev_map_idx - 1;
1333 FCPARAM(isp, bus)->isp_dev_map[t] =
1334 (lp - FCPARAM(isp, bus)->portdb) + 1;
1335 tgt = lp->dev_map_idx - 1;
1336 isp_prt(isp, ISP_LOGCONFIG, prom2,
1337 lp->portid, lp->handle,
1338 roles[lp->roles], "changed at", tgt,
1339 (uint32_t) (lp->node_wwn >> 32),
1340 (uint32_t) lp->node_wwn,
1341 (uint32_t) (lp->port_wwn >> 32),
1342 (uint32_t) lp->port_wwn);
1343 } else {
1344 isp_prt(isp, ISP_LOGCONFIG, prom,
1345 lp->portid, lp->handle,
1346 roles[lp->roles], "changed",
1347 (uint32_t) (lp->node_wwn >> 32),
1348 (uint32_t) lp->node_wwn,
1349 (uint32_t) (lp->port_wwn >> 32),
1350 (uint32_t) lp->port_wwn);
1351 }
1352 }
1353 break;
1354 case ISPASYNC_DEV_STAYED:
1355 va_start(ap, cmd);
1356 bus = va_arg(ap, int);
1357 lp = va_arg(ap, fcportdb_t *);
1358 va_end(ap);
1359 if (lp->dev_map_idx) {
1360 tgt = lp->dev_map_idx - 1;
1361 isp_prt(isp, ISP_LOGCONFIG, prom2,
1362 lp->portid, lp->handle,
1363 roles[lp->roles], "stayed at", tgt,
1364 (uint32_t) (lp->node_wwn >> 32),
1365 (uint32_t) lp->node_wwn,
1366 (uint32_t) (lp->port_wwn >> 32),
1367 (uint32_t) lp->port_wwn);
1368 } else {
1369 isp_prt(isp, ISP_LOGCONFIG, prom,
1370 lp->portid, lp->handle,
1371 roles[lp->roles], "stayed",
1372 (uint32_t) (lp->node_wwn >> 32),
1373 (uint32_t) lp->node_wwn,
1374 (uint32_t) (lp->port_wwn >> 32),
1375 (uint32_t) lp->port_wwn);
1376 }
1377 break;
1378 case ISPASYNC_DEV_GONE:
1379 va_start(ap, cmd);
1380 bus = va_arg(ap, int);
1381 lp = va_arg(ap, fcportdb_t *);
1382 va_end(ap);
1383 /*
1384 * If this has a virtual target and we haven't marked it
1385 * that we're going to have isp_gdt tell the OS it's gone,
1386 * set the isp_gdt timer running on it.
1387 *
1388 * If it isn't marked that isp_gdt is going to get rid of it,
1389 * announce that it's gone.
1390 */
1391 if (lp->dev_map_idx && lp->reserved == 0) {
1392 lp->reserved = 1;
1393 lp->new_reserved = isp->isp_osinfo.gone_device_time;
1394 lp->state = FC_PORTDB_STATE_ZOMBIE;
1395 if (isp->isp_osinfo.gdt_running == 0) {
1396 isp->isp_osinfo.gdt_running = 1;
1397 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1398 "starting Gone Device Timer");
1399 callout_schedule(&isp->isp_osinfo.gdt, hz);
1400 }
1401 tgt = lp->dev_map_idx - 1;
1402 isp_prt(isp, ISP_LOGCONFIG, prom2,
1403 lp->portid, lp->handle,
1404 roles[lp->roles], "gone zombie at", tgt,
1405 (uint32_t) (lp->node_wwn >> 32),
1406 (uint32_t) lp->node_wwn,
1407 (uint32_t) (lp->port_wwn >> 32),
1408 (uint32_t) lp->port_wwn);
1409 } else if (lp->reserved == 0) {
1410 isp_prt(isp, ISP_LOGCONFIG, prom,
1411 lp->portid, lp->handle,
1412 roles[lp->roles], "departed",
1413 (uint32_t) (lp->node_wwn >> 32),
1414 (uint32_t) lp->node_wwn,
1415 (uint32_t) (lp->port_wwn >> 32),
1416 (uint32_t) lp->port_wwn);
1417 }
1418 break;
1419 case ISPASYNC_CHANGE_NOTIFY:
1420 {
1421 int opt;
1422
1423 va_start(ap, cmd);
1424 bus = va_arg(ap, int);
1425 opt = va_arg(ap, int);
1426 va_end(ap);
1427
1428 if (opt == ISPASYNC_CHANGE_PDB) {
1429 msg = "Port Database Changed";
1430 } else if (opt == ISPASYNC_CHANGE_SNS) {
1431 msg = "Name Server Database Changed";
1432 } else {
1433 msg = "Other Change Notify";
1434 }
1435 /*
1436 * If the loop down timer is running, cancel it.
1437 */
1438 if (callout_pending(&isp->isp_osinfo.ldt)) {
1439 callout_stop(&isp->isp_osinfo.ldt);
1440 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1441 "Stopping Loop Down Timer");
1442 }
1443 isp_prt(isp, ISP_LOGINFO, msg);
1444 /*
1445 * We can set blocked here because we know it's now okay
1446 * to try and run isp_fc_runstate (in order to build loop
1447 * state). But we don't try and freeze the midlayer's queue
1448 * if we have no thread that we can wake to later unfreeze
1449 * it.
1450 */
1451 if (isp->isp_osinfo.blocked == 0) {
1452 isp->isp_osinfo.blocked = 1;
1453 if (isp->isp_osinfo.thread) {
1454 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1455 "FREEZE QUEUES @ LINE %d", __LINE__);
1456 scsipi_channel_freeze(&isp->isp_osinfo.chan[bus], 1);
1457 }
1458 }
1459 /*
1460 * Note that we have work for the thread to do, and
1461 * if the thread is here already, wake it up.
1462 */
1463 if (isp->isp_osinfo.thread) {
1464 wakeup(&isp->isp_osinfo.thread);
1465 } else {
1466 isp_prt(isp, ISP_LOGDEBUG1, "no FC thread yet");
1467 }
1468 break;
1469 }
1470 case ISPASYNC_FW_CRASH:
1471 {
1472 uint16_t mbox1;
1473 mbox1 = ISP_READ(isp, OUTMAILBOX1);
1474 if (IS_DUALBUS(isp)) {
1475 bus = ISP_READ(isp, OUTMAILBOX6);
1476 } else {
1477 bus = 0;
1478 }
1479 isp_prt(isp, ISP_LOGERR,
1480 "Internal Firmware Error on bus %d @ RISC Address 0x%x",
1481 bus, mbox1);
1482 if (IS_FC(isp)) {
1483 if (isp->isp_osinfo.blocked == 0) {
1484 isp->isp_osinfo.blocked = 1;
1485 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
1486 "FREEZE QUEUES @ LINE %d", __LINE__);
1487 scsipi_channel_freeze(&isp->isp_osinfo.chan[bus], 1);
1488 }
1489 }
1490 mbox1 = isp->isp_osinfo.mbox_sleep_ok;
1491 isp->isp_osinfo.mbox_sleep_ok = 0;
1492 isp_reinit(isp, 0);
1493 isp->isp_osinfo.mbox_sleep_ok = mbox1;
1494 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
1495 break;
1496 }
1497 default:
1498 break;
1499 }
1500 }
1501
1502 void
1503 isp_prt(struct ispsoftc *isp, int level, const char *fmt, ...)
1504 {
1505 va_list ap;
1506 if (level != ISP_LOGALL && (level & isp->isp_dblev) == 0) {
1507 return;
1508 }
1509 printf("%s: ", device_xname(isp->isp_osinfo.dev));
1510 va_start(ap, fmt);
1511 vprintf(fmt, ap);
1512 va_end(ap);
1513 printf("\n");
1514 }
1515
1516 void
1517 isp_lock(struct ispsoftc *isp)
1518 {
1519 int s = splbio();
1520 if (isp->isp_osinfo.islocked++ == 0) {
1521 isp->isp_osinfo.splsaved = s;
1522 } else {
1523 splx(s);
1524 }
1525 }
1526
1527 void
1528 isp_unlock(struct ispsoftc *isp)
1529 {
1530 if (isp->isp_osinfo.islocked-- <= 1) {
1531 isp->isp_osinfo.islocked = 0;
1532 splx(isp->isp_osinfo.splsaved);
1533 }
1534 }
1535
1536 uint64_t
1537 isp_microtime_sub(struct timeval *b, struct timeval *a)
1538 {
1539 struct timeval x;
1540 uint64_t elapsed;
1541 timersub(b, a, &x);
1542 elapsed = GET_NANOSEC(&x);
1543 if (elapsed == 0)
1544 elapsed++;
1545 return (elapsed);
1546 }
1547
1548 int
1549 isp_mbox_acquire(ispsoftc_t *isp)
1550 {
1551 if (isp->isp_osinfo.mboxbsy) {
1552 return (1);
1553 } else {
1554 isp->isp_osinfo.mboxcmd_done = 0;
1555 isp->isp_osinfo.mboxbsy = 1;
1556 return (0);
1557 }
1558 }
1559
1560 void
1561 isp_mbox_wait_complete(struct ispsoftc *isp, mbreg_t *mbp)
1562 {
1563 unsigned int usecs = mbp->timeout;
1564 unsigned int maxc, olim, ilim;
1565 struct timeval start;
1566
1567 if (usecs == 0) {
1568 usecs = MBCMD_DEFAULT_TIMEOUT;
1569 }
1570 maxc = isp->isp_mbxwrk0 + 1;
1571
1572 microtime(&start);
1573 if (isp->isp_osinfo.mbox_sleep_ok) {
1574 int to;
1575 struct timeval tv;
1576
1577 tv.tv_sec = 0;
1578 tv.tv_usec = 0;
1579 for (olim = 0; olim < maxc; olim++) {
1580 tv.tv_sec += (usecs / 1000000);
1581 tv.tv_usec += (usecs % 1000000);
1582 if (tv.tv_usec >= 100000) {
1583 tv.tv_sec++;
1584 tv.tv_usec -= 1000000;
1585 }
1586 }
1587 timeradd(&tv, &start, &tv);
1588 to = tvhzto(&tv);
1589 if (to == 0)
1590 to = 1;
1591
1592 isp->isp_osinfo.mbox_sleep_ok = 0;
1593 isp->isp_osinfo.mbox_sleeping = 1;
1594 tsleep(&isp->isp_mbxworkp, PRIBIO, "ispmbx_sleep", to);
1595 isp->isp_osinfo.mbox_sleeping = 0;
1596 isp->isp_osinfo.mbox_sleep_ok = 1;
1597 } else {
1598 for (olim = 0; olim < maxc; olim++) {
1599 for (ilim = 0; ilim < usecs; ilim += 100) {
1600 uint32_t isr;
1601 uint16_t sema, mbox;
1602 if (isp->isp_osinfo.mboxcmd_done) {
1603 break;
1604 }
1605 if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
1606 isp_intr(isp, isr, sema, mbox);
1607 if (isp->isp_osinfo.mboxcmd_done) {
1608 break;
1609 }
1610 }
1611 ISP_DELAY(100);
1612 }
1613 if (isp->isp_osinfo.mboxcmd_done) {
1614 break;
1615 }
1616 }
1617 }
1618 if (isp->isp_osinfo.mboxcmd_done == 0) {
1619 struct timeval finish, elapsed;
1620
1621 microtime(&finish);
1622 timersub(&finish, &start, &elapsed);
1623 isp_prt(isp, ISP_LOGWARN,
1624 "%s Mailbox Command (0x%x) Timeout (%uus actual)",
1625 isp->isp_osinfo.mbox_sleep_ok? "Interrupting" : "Polled",
1626 isp->isp_lastmbxcmd, (elapsed.tv_sec * 1000000) +
1627 elapsed.tv_usec);
1628 mbp->param[0] = MBOX_TIMEOUT;
1629 isp->isp_osinfo.mboxcmd_done = 1;
1630 }
1631 }
1632
1633 void
1634 isp_mbox_notify_done(ispsoftc_t *isp)
1635 {
1636 if (isp->isp_osinfo.mbox_sleeping) {
1637 wakeup(&isp->isp_mbxworkp);
1638 }
1639 isp->isp_osinfo.mboxcmd_done = 1;
1640 }
1641
1642 void
1643 isp_mbox_release(ispsoftc_t *isp)
1644 {
1645 isp->isp_osinfo.mboxbsy = 0;
1646 }
NetBSD on the FriendlyARM MINI2440