isp_netbsd.c revision 1.27 1 1.27 mjacob /* $NetBSD: isp_netbsd.c,v 1.27 2000/07/07 03:14:53 mjacob Exp $ */
2 1.1 mjacob /*
3 1.1 mjacob * Platform (NetBSD) dependent common attachment code for Qlogic adapters.
4 1.15 mjacob * Matthew Jacob <mjacob (at) nas.nasa.gov>
5 1.15 mjacob */
6 1.15 mjacob /*
7 1.15 mjacob * Copyright (C) 1997, 1998, 1999 National Aeronautics & Space Administration
8 1.1 mjacob * All rights reserved.
9 1.1 mjacob *
10 1.1 mjacob * Redistribution and use in source and binary forms, with or without
11 1.1 mjacob * modification, are permitted provided that the following conditions
12 1.1 mjacob * are met:
13 1.1 mjacob * 1. Redistributions of source code must retain the above copyright
14 1.15 mjacob * notice, this list of conditions and the following disclaimer.
15 1.1 mjacob * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 mjacob * notice, this list of conditions and the following disclaimer in the
17 1.1 mjacob * documentation and/or other materials provided with the distribution.
18 1.1 mjacob * 3. The name of the author may not be used to endorse or promote products
19 1.15 mjacob * derived from this software without specific prior written permission
20 1.1 mjacob *
21 1.15 mjacob * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 1.15 mjacob * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 1.15 mjacob * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 1.15 mjacob * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 1.15 mjacob * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 1.15 mjacob * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 1.15 mjacob * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 1.15 mjacob * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 1.15 mjacob * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 1.15 mjacob * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 1.1 mjacob */
32 1.1 mjacob
33 1.1 mjacob #include <dev/ic/isp_netbsd.h>
34 1.17 mjacob #include <sys/scsiio.h>
35 1.1 mjacob
36 1.27 mjacob
37 1.27 mjacob /*
38 1.27 mjacob * Set a timeout for the watchdogging of a command.
39 1.27 mjacob *
40 1.27 mjacob * The dimensional analysis is
41 1.27 mjacob *
42 1.27 mjacob * milliseconds * (seconds/millisecond) * (ticks/second) = ticks
43 1.27 mjacob *
44 1.27 mjacob * =
45 1.27 mjacob *
46 1.27 mjacob * (milliseconds / 1000) * hz = ticks
47 1.27 mjacob *
48 1.27 mjacob *
49 1.27 mjacob * For timeouts less than 1 second, we'll get zero. Because of this, and
50 1.27 mjacob * because we want to establish *our* timeout to be longer than what the
51 1.27 mjacob * firmware might do, we just add 3 seconds at the back end.
52 1.27 mjacob */
53 1.27 mjacob #define _XT(xs) ((((xs)->timeout/1000) * hz) + (3 * hz))
54 1.26 mjacob
55 1.1 mjacob static void ispminphys __P((struct buf *));
56 1.17 mjacob static int32_t ispcmd_slow __P((ISP_SCSI_XFER_T *));
57 1.1 mjacob static int32_t ispcmd __P((ISP_SCSI_XFER_T *));
58 1.17 mjacob static int
59 1.17 mjacob ispioctl __P((struct scsipi_link *, u_long, caddr_t, int, struct proc *));
60 1.1 mjacob
61 1.1 mjacob static struct scsipi_device isp_dev = { NULL, NULL, NULL, NULL };
62 1.26 mjacob static int isp_polled_cmd __P((struct ispsoftc *, ISP_SCSI_XFER_T *));
63 1.26 mjacob static void isp_dog __P((void *));
64 1.17 mjacob static void isp_command_requeue __P((void *));
65 1.10 mjacob static void isp_internal_restart __P((void *));
66 1.10 mjacob
67 1.1 mjacob /*
68 1.1 mjacob * Complete attachment of hardware, include subdevices.
69 1.1 mjacob */
70 1.1 mjacob void
71 1.1 mjacob isp_attach(isp)
72 1.1 mjacob struct ispsoftc *isp;
73 1.1 mjacob {
74 1.26 mjacob int maxluns = isp->isp_maxluns - 1;
75 1.6 thorpej
76 1.6 thorpej isp->isp_osinfo._adapter.scsipi_minphys = ispminphys;
77 1.17 mjacob isp->isp_osinfo._adapter.scsipi_ioctl = ispioctl;
78 1.6 thorpej
79 1.1 mjacob isp->isp_state = ISP_RUNSTATE;
80 1.21 mjacob isp->isp_osinfo._link.scsipi_scsi.channel =
81 1.21 mjacob (IS_DUALBUS(isp))? 0 : SCSI_CHANNEL_ONLY_ONE;
82 1.1 mjacob isp->isp_osinfo._link.adapter_softc = isp;
83 1.1 mjacob isp->isp_osinfo._link.device = &isp_dev;
84 1.6 thorpej isp->isp_osinfo._link.adapter = &isp->isp_osinfo._adapter;
85 1.17 mjacob isp->isp_osinfo._link.openings = isp->isp_maxcmds;
86 1.26 mjacob isp->isp_osinfo._link.scsipi_scsi.max_lun = maxluns;
87 1.18 mjacob TAILQ_INIT(&isp->isp_osinfo.waitq); /* XXX 2nd Bus? */
88 1.1 mjacob
89 1.15 mjacob if (IS_FC(isp)) {
90 1.11 mjacob /*
91 1.11 mjacob * Give it another chance here to come alive...
92 1.11 mjacob */
93 1.17 mjacob isp->isp_osinfo._adapter.scsipi_cmd = ispcmd;
94 1.1 mjacob isp->isp_osinfo._link.scsipi_scsi.max_target = MAX_FC_TARG-1;
95 1.7 mjacob /*
96 1.26 mjacob * But we have to be reasonable until the midlayer is fixed.
97 1.7 mjacob */
98 1.26 mjacob if (maxluns > 255)
99 1.26 mjacob isp->isp_osinfo._link.scsipi_scsi.max_lun = 255;
100 1.1 mjacob } else {
101 1.14 mjacob sdparam *sdp = isp->isp_param;
102 1.17 mjacob isp->isp_osinfo._adapter.scsipi_cmd = ispcmd_slow;
103 1.1 mjacob isp->isp_osinfo._link.scsipi_scsi.max_target = MAX_TARGETS-1;
104 1.1 mjacob isp->isp_osinfo._link.scsipi_scsi.adapter_target =
105 1.14 mjacob sdp->isp_initiator_id;
106 1.17 mjacob isp->isp_osinfo.discovered[0] = 1 << sdp->isp_initiator_id;
107 1.26 mjacob /*
108 1.26 mjacob * But we have to be reasonable until the midlayer is fixed.
109 1.26 mjacob */
110 1.26 mjacob if (maxluns > 7)
111 1.26 mjacob isp->isp_osinfo._link.scsipi_scsi.max_lun = 7;
112 1.21 mjacob if (IS_DUALBUS(isp)) {
113 1.14 mjacob isp->isp_osinfo._link_b = isp->isp_osinfo._link;
114 1.14 mjacob sdp++;
115 1.18 mjacob isp->isp_osinfo.discovered[1] =
116 1.18 mjacob 1 << sdp->isp_initiator_id;
117 1.14 mjacob isp->isp_osinfo._link_b.scsipi_scsi.adapter_target =
118 1.14 mjacob sdp->isp_initiator_id;
119 1.14 mjacob isp->isp_osinfo._link_b.scsipi_scsi.channel = 1;
120 1.26 mjacob isp->isp_osinfo._link_b.scsipi_scsi.max_lun =
121 1.26 mjacob isp->isp_osinfo._link.scsipi_scsi.max_lun;
122 1.14 mjacob }
123 1.1 mjacob }
124 1.1 mjacob isp->isp_osinfo._link.type = BUS_SCSI;
125 1.8 mjacob
126 1.8 mjacob /*
127 1.25 he * Send a SCSI Bus Reset.
128 1.10 mjacob */
129 1.14 mjacob if (IS_SCSI(isp)) {
130 1.14 mjacob int bus = 0;
131 1.14 mjacob (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
132 1.21 mjacob if (IS_DUALBUS(isp)) {
133 1.14 mjacob bus++;
134 1.14 mjacob (void) isp_control(isp, ISPCTL_RESET_BUS, &bus);
135 1.14 mjacob }
136 1.19 mjacob } else {
137 1.19 mjacob int i, j;
138 1.19 mjacob fcparam *fcp = isp->isp_param;
139 1.19 mjacob delay(2 * 1000000);
140 1.19 mjacob for (j = 0; j < 5; j++) {
141 1.19 mjacob for (i = 0; i < 5; i++) {
142 1.19 mjacob if (isp_control(isp, ISPCTL_FCLINK_TEST, NULL))
143 1.19 mjacob continue;
144 1.19 mjacob #ifdef ISP2100_FABRIC
145 1.19 mjacob /*
146 1.19 mjacob * Wait extra time to see if the f/w
147 1.19 mjacob * eventually completed an FLOGI that
148 1.19 mjacob * will allow us to know we're on a
149 1.19 mjacob * fabric.
150 1.19 mjacob */
151 1.19 mjacob if (fcp->isp_onfabric == 0) {
152 1.19 mjacob delay(1 * 1000000);
153 1.19 mjacob continue;
154 1.19 mjacob }
155 1.19 mjacob #endif
156 1.19 mjacob break;
157 1.19 mjacob }
158 1.19 mjacob if (fcp->isp_fwstate == FW_READY &&
159 1.19 mjacob fcp->isp_loopstate >= LOOP_PDB_RCVD) {
160 1.19 mjacob break;
161 1.19 mjacob }
162 1.19 mjacob }
163 1.19 mjacob isp->isp_osinfo._link.scsipi_scsi.adapter_target =
164 1.19 mjacob fcp->isp_loopid;
165 1.11 mjacob }
166 1.10 mjacob
167 1.10 mjacob /*
168 1.8 mjacob * And attach children (if any).
169 1.8 mjacob */
170 1.1 mjacob config_found((void *)isp, &isp->isp_osinfo._link, scsiprint);
171 1.21 mjacob if (IS_DUALBUS(isp)) {
172 1.14 mjacob config_found((void *)isp, &isp->isp_osinfo._link_b, scsiprint);
173 1.14 mjacob }
174 1.1 mjacob }
175 1.1 mjacob
176 1.1 mjacob /*
177 1.1 mjacob * minphys our xfers
178 1.1 mjacob *
179 1.1 mjacob * Unfortunately, the buffer pointer describes the target device- not the
180 1.1 mjacob * adapter device, so we can't use the pointer to find out what kind of
181 1.1 mjacob * adapter we are and adjust accordingly.
182 1.1 mjacob */
183 1.1 mjacob
184 1.1 mjacob static void
185 1.1 mjacob ispminphys(bp)
186 1.1 mjacob struct buf *bp;
187 1.1 mjacob {
188 1.1 mjacob /*
189 1.1 mjacob * XX: Only the 1020 has a 24 bit limit.
190 1.1 mjacob */
191 1.1 mjacob if (bp->b_bcount >= (1 << 24)) {
192 1.1 mjacob bp->b_bcount = (1 << 24);
193 1.1 mjacob }
194 1.1 mjacob minphys(bp);
195 1.1 mjacob }
196 1.1 mjacob
197 1.17 mjacob static int32_t
198 1.17 mjacob ispcmd_slow(xs)
199 1.1 mjacob ISP_SCSI_XFER_T *xs;
200 1.1 mjacob {
201 1.19 mjacob sdparam *sdp;
202 1.20 mjacob int tgt, chan, s;
203 1.21 mjacob u_int16_t flags;
204 1.19 mjacob struct ispsoftc *isp = XS_ISP(xs);
205 1.19 mjacob
206 1.19 mjacob /*
207 1.19 mjacob * Have we completed discovery for this target on this adapter?
208 1.19 mjacob */
209 1.20 mjacob tgt = XS_TGT(xs);
210 1.20 mjacob chan = XS_CHANNEL(xs);
211 1.19 mjacob if ((xs->xs_control & XS_CTL_DISCOVERY) != 0 ||
212 1.19 mjacob (isp->isp_osinfo.discovered[chan] & (1 << tgt)) != 0) {
213 1.19 mjacob return (ispcmd(xs));
214 1.19 mjacob }
215 1.19 mjacob
216 1.21 mjacob flags = DPARM_DEFAULT;
217 1.19 mjacob if (xs->sc_link->quirks & SDEV_NOSYNC) {
218 1.21 mjacob flags ^= DPARM_SYNC;
219 1.19 mjacob #ifdef DEBUG
220 1.19 mjacob } else {
221 1.19 mjacob printf("%s: channel %d target %d can do SYNC xfers\n",
222 1.19 mjacob isp->isp_name, chan, tgt);
223 1.19 mjacob #endif
224 1.19 mjacob }
225 1.19 mjacob if (xs->sc_link->quirks & SDEV_NOWIDE) {
226 1.21 mjacob flags ^= DPARM_WIDE;
227 1.19 mjacob #ifdef DEBUG
228 1.19 mjacob } else {
229 1.19 mjacob printf("%s: channel %d target %d can do WIDE xfers\n",
230 1.19 mjacob isp->isp_name, chan, tgt);
231 1.19 mjacob #endif
232 1.19 mjacob }
233 1.19 mjacob if (xs->sc_link->quirks & SDEV_NOTAG) {
234 1.21 mjacob flags ^= DPARM_TQING;
235 1.19 mjacob #ifdef DEBUG
236 1.19 mjacob } else {
237 1.19 mjacob printf("%s: channel %d target %d can do TAGGED xfers\n",
238 1.19 mjacob isp->isp_name, chan, tgt);
239 1.19 mjacob #endif
240 1.19 mjacob }
241 1.19 mjacob /*
242 1.19 mjacob * Okay, we know about this device now,
243 1.19 mjacob * so mark parameters to be updated for it.
244 1.19 mjacob */
245 1.20 mjacob s = splbio();
246 1.21 mjacob isp->isp_osinfo.discovered[chan] |= (1 << tgt);
247 1.21 mjacob sdp = isp->isp_param;
248 1.21 mjacob sdp += chan;
249 1.21 mjacob sdp->isp_devparam[tgt].dev_flags = flags;
250 1.19 mjacob sdp->isp_devparam[tgt].dev_update = 1;
251 1.19 mjacob isp->isp_update |= (1 << chan);
252 1.20 mjacob splx(s);
253 1.17 mjacob return (ispcmd(xs));
254 1.17 mjacob }
255 1.17 mjacob
256 1.17 mjacob static int
257 1.17 mjacob ispioctl(sc_link, cmd, addr, flag, p)
258 1.17 mjacob struct scsipi_link *sc_link;
259 1.17 mjacob u_long cmd;
260 1.17 mjacob caddr_t addr;
261 1.17 mjacob int flag;
262 1.17 mjacob struct proc *p;
263 1.17 mjacob {
264 1.17 mjacob struct ispsoftc *isp = sc_link->adapter_softc;
265 1.17 mjacob int s, chan, retval = ENOTTY;
266 1.17 mjacob
267 1.17 mjacob switch (cmd) {
268 1.17 mjacob case SCBUSIORESET:
269 1.17 mjacob chan = sc_link->scsipi_scsi.channel;
270 1.17 mjacob s = splbio();
271 1.17 mjacob if (isp_control(isp, ISPCTL_RESET_BUS, &chan))
272 1.17 mjacob retval = EIO;
273 1.17 mjacob else
274 1.17 mjacob retval = 0;
275 1.17 mjacob (void) splx(s);
276 1.17 mjacob break;
277 1.17 mjacob default:
278 1.17 mjacob break;
279 1.3 mjacob }
280 1.17 mjacob return (retval);
281 1.17 mjacob }
282 1.17 mjacob
283 1.17 mjacob
284 1.17 mjacob static int32_t
285 1.17 mjacob ispcmd(xs)
286 1.17 mjacob ISP_SCSI_XFER_T *xs;
287 1.17 mjacob {
288 1.17 mjacob struct ispsoftc *isp;
289 1.17 mjacob int result, s;
290 1.11 mjacob
291 1.17 mjacob isp = XS_ISP(xs);
292 1.17 mjacob s = splbio();
293 1.11 mjacob if (isp->isp_state < ISP_RUNSTATE) {
294 1.11 mjacob DISABLE_INTS(isp);
295 1.11 mjacob isp_init(isp);
296 1.11 mjacob if (isp->isp_state != ISP_INITSTATE) {
297 1.11 mjacob ENABLE_INTS(isp);
298 1.11 mjacob (void) splx(s);
299 1.11 mjacob XS_SETERR(xs, HBA_BOTCH);
300 1.17 mjacob return (COMPLETE);
301 1.11 mjacob }
302 1.11 mjacob isp->isp_state = ISP_RUNSTATE;
303 1.11 mjacob ENABLE_INTS(isp);
304 1.11 mjacob }
305 1.11 mjacob
306 1.10 mjacob /*
307 1.10 mjacob * Check for queue blockage...
308 1.10 mjacob */
309 1.10 mjacob if (isp->isp_osinfo.blocked) {
310 1.16 thorpej if (xs->xs_control & XS_CTL_POLL) {
311 1.10 mjacob xs->error = XS_DRIVER_STUFFUP;
312 1.10 mjacob splx(s);
313 1.10 mjacob return (TRY_AGAIN_LATER);
314 1.10 mjacob }
315 1.10 mjacob TAILQ_INSERT_TAIL(&isp->isp_osinfo.waitq, xs, adapter_q);
316 1.10 mjacob splx(s);
317 1.17 mjacob return (SUCCESSFULLY_QUEUED);
318 1.10 mjacob }
319 1.17 mjacob
320 1.26 mjacob if (xs->xs_control & XS_CTL_POLL) {
321 1.26 mjacob result = isp_polled_cmd(isp, xs);
322 1.10 mjacob (void) splx(s);
323 1.3 mjacob return (result);
324 1.1 mjacob }
325 1.1 mjacob
326 1.26 mjacob result = ispscsicmd(xs);
327 1.26 mjacob switch (result) {
328 1.26 mjacob case CMD_QUEUED:
329 1.26 mjacob result = SUCCESSFULLY_QUEUED;
330 1.26 mjacob if (xs->timeout) {
331 1.26 mjacob callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
332 1.26 mjacob }
333 1.26 mjacob break;
334 1.26 mjacob case CMD_EAGAIN:
335 1.26 mjacob result = TRY_AGAIN_LATER;
336 1.26 mjacob break;
337 1.26 mjacob case CMD_RQLATER:
338 1.26 mjacob result = SUCCESSFULLY_QUEUED;
339 1.26 mjacob callout_reset(&xs->xs_callout, hz, isp_command_requeue, xs);
340 1.26 mjacob break;
341 1.26 mjacob case CMD_COMPLETE:
342 1.26 mjacob result = COMPLETE;
343 1.26 mjacob break;
344 1.26 mjacob }
345 1.26 mjacob (void) splx(s);
346 1.26 mjacob return (result);
347 1.26 mjacob }
348 1.26 mjacob
349 1.26 mjacob static int
350 1.26 mjacob isp_polled_cmd(isp, xs)
351 1.26 mjacob struct ispsoftc *isp;
352 1.26 mjacob ISP_SCSI_XFER_T *xs;
353 1.26 mjacob {
354 1.26 mjacob int result;
355 1.26 mjacob int infinite = 0, mswait;
356 1.26 mjacob
357 1.26 mjacob result = ispscsicmd(xs);
358 1.26 mjacob
359 1.17 mjacob switch (result) {
360 1.17 mjacob case CMD_QUEUED:
361 1.17 mjacob result = SUCCESSFULLY_QUEUED;
362 1.17 mjacob break;
363 1.17 mjacob case CMD_RQLATER:
364 1.17 mjacob case CMD_EAGAIN:
365 1.17 mjacob if (XS_NOERR(xs)) {
366 1.17 mjacob xs->error = XS_DRIVER_STUFFUP;
367 1.17 mjacob }
368 1.17 mjacob result = TRY_AGAIN_LATER;
369 1.17 mjacob break;
370 1.17 mjacob case CMD_COMPLETE:
371 1.17 mjacob result = COMPLETE;
372 1.17 mjacob break;
373 1.17 mjacob
374 1.17 mjacob }
375 1.26 mjacob
376 1.26 mjacob if (result != SUCCESSFULLY_QUEUED) {
377 1.26 mjacob return (result);
378 1.26 mjacob }
379 1.26 mjacob
380 1.1 mjacob /*
381 1.1 mjacob * If we can't use interrupts, poll on completion.
382 1.1 mjacob */
383 1.26 mjacob if ((mswait = XS_TIME(xs)) == 0)
384 1.26 mjacob infinite = 1;
385 1.26 mjacob
386 1.26 mjacob while (mswait || infinite) {
387 1.26 mjacob if (isp_intr((void *)isp)) {
388 1.26 mjacob if (XS_CMD_DONE_P(xs)) {
389 1.26 mjacob break;
390 1.1 mjacob }
391 1.1 mjacob }
392 1.26 mjacob SYS_DELAY(1000);
393 1.26 mjacob mswait -= 1;
394 1.26 mjacob }
395 1.26 mjacob
396 1.26 mjacob /*
397 1.26 mjacob * If no other error occurred but we didn't finish,
398 1.26 mjacob * something bad happened.
399 1.26 mjacob */
400 1.26 mjacob if (XS_CMD_DONE_P(xs) == 0) {
401 1.26 mjacob if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
402 1.26 mjacob isp_restart(isp);
403 1.26 mjacob }
404 1.26 mjacob if (XS_NOERR(xs)) {
405 1.26 mjacob XS_SETERR(xs, HBA_BOTCH);
406 1.26 mjacob }
407 1.1 mjacob }
408 1.26 mjacob result = COMPLETE;
409 1.17 mjacob return (result);
410 1.1 mjacob }
411 1.1 mjacob
412 1.26 mjacob void
413 1.26 mjacob isp_done(xs)
414 1.1 mjacob ISP_SCSI_XFER_T *xs;
415 1.1 mjacob {
416 1.26 mjacob XS_CMD_S_DONE(xs);
417 1.26 mjacob if (XS_CMD_WDOG_P(xs) == 0) {
418 1.26 mjacob struct ispsoftc *isp = XS_ISP(xs);
419 1.26 mjacob callout_stop(&xs->xs_callout);
420 1.26 mjacob if (XS_CMD_GRACE_P(xs)) {
421 1.26 mjacob PRINTF("%s: finished command on borrowed time\n",
422 1.26 mjacob isp->isp_name);
423 1.1 mjacob }
424 1.26 mjacob XS_CMD_S_CLEAR(xs);
425 1.26 mjacob scsipi_done(xs);
426 1.1 mjacob }
427 1.8 mjacob }
428 1.8 mjacob
429 1.8 mjacob static void
430 1.26 mjacob isp_dog(arg)
431 1.8 mjacob void *arg;
432 1.8 mjacob {
433 1.26 mjacob ISP_SCSI_XFER_T *xs = arg;
434 1.26 mjacob struct ispsoftc *isp = XS_ISP(xs);
435 1.26 mjacob u_int32_t handle;
436 1.26 mjacob int s = splbio();
437 1.8 mjacob
438 1.8 mjacob /*
439 1.26 mjacob * We've decided this command is dead. Make sure we're not trying
440 1.26 mjacob * to kill a command that's already dead by getting it's handle and
441 1.26 mjacob * and seeing whether it's still alive.
442 1.26 mjacob */
443 1.26 mjacob handle = isp_find_handle(isp, xs);
444 1.26 mjacob if (handle) {
445 1.26 mjacob u_int16_t r, r1, i;
446 1.26 mjacob
447 1.26 mjacob if (XS_CMD_DONE_P(xs)) {
448 1.26 mjacob PRINTF("%s: watchdog found done cmd (handle 0x%x)\n",
449 1.26 mjacob isp->isp_name, handle);
450 1.26 mjacob (void) splx(s);
451 1.26 mjacob return;
452 1.26 mjacob }
453 1.26 mjacob
454 1.26 mjacob if (XS_CMD_WDOG_P(xs)) {
455 1.26 mjacob PRINTF("%s: recursive watchdog (handle 0x%x)\n",
456 1.26 mjacob isp->isp_name, handle);
457 1.26 mjacob (void) splx(s);
458 1.26 mjacob return;
459 1.26 mjacob }
460 1.26 mjacob
461 1.26 mjacob XS_CMD_S_WDOG(xs);
462 1.26 mjacob
463 1.26 mjacob i = 0;
464 1.26 mjacob do {
465 1.26 mjacob r = ISP_READ(isp, BIU_ISR);
466 1.26 mjacob SYS_DELAY(1);
467 1.26 mjacob r1 = ISP_READ(isp, BIU_ISR);
468 1.26 mjacob } while (r != r1 && ++i < 1000);
469 1.26 mjacob
470 1.26 mjacob if (INT_PENDING(isp, r) && isp_intr(isp) && XS_CMD_DONE_P(xs)) {
471 1.26 mjacob IDPRINTF(1, ("%s: watchdog cleanup (%x, %x)\n",
472 1.26 mjacob isp->isp_name, handle, r));
473 1.26 mjacob XS_CMD_C_WDOG(xs);
474 1.26 mjacob isp_done(xs);
475 1.26 mjacob } else if (XS_CMD_GRACE_P(xs)) {
476 1.26 mjacob IDPRINTF(1, ("%s: watchdog timeout (%x, %x)\n",
477 1.26 mjacob isp->isp_name, handle, r));
478 1.26 mjacob /*
479 1.26 mjacob * Make sure the command is *really* dead before we
480 1.26 mjacob * release the handle (and DMA resources) for reuse.
481 1.26 mjacob */
482 1.26 mjacob (void) isp_control(isp, ISPCTL_ABORT_CMD, arg);
483 1.26 mjacob
484 1.26 mjacob /*
485 1.26 mjacob * After this point, the comamnd is really dead.
486 1.26 mjacob */
487 1.26 mjacob if (XS_XFRLEN(xs)) {
488 1.26 mjacob ISP_DMAFREE(isp, xs, handle);
489 1.26 mjacob }
490 1.26 mjacob isp_destroy_handle(isp, handle);
491 1.26 mjacob XS_SETERR(xs, XS_TIMEOUT);
492 1.26 mjacob XS_CMD_S_CLEAR(xs);
493 1.26 mjacob isp_done(xs);
494 1.26 mjacob } else {
495 1.26 mjacob u_int16_t iptr, optr;
496 1.26 mjacob ispreq_t *mp;
497 1.26 mjacob
498 1.26 mjacob IDPRINTF(2, ("%s: possible command timeout (%x, %x)\n",
499 1.26 mjacob isp->isp_name, handle, r));
500 1.26 mjacob
501 1.26 mjacob XS_CMD_C_WDOG(xs);
502 1.26 mjacob callout_reset(&xs->xs_callout, hz, isp_dog, xs);
503 1.26 mjacob if (isp_getrqentry(isp, &iptr, &optr, (void **) &mp)) {
504 1.26 mjacob (void) splx(s);
505 1.26 mjacob return;
506 1.26 mjacob }
507 1.26 mjacob XS_CMD_S_GRACE(xs);
508 1.26 mjacob MEMZERO((void *) mp, sizeof (*mp));
509 1.26 mjacob mp->req_header.rqs_entry_count = 1;
510 1.26 mjacob mp->req_header.rqs_entry_type = RQSTYPE_MARKER;
511 1.26 mjacob mp->req_modifier = SYNC_ALL;
512 1.26 mjacob mp->req_target = XS_CHANNEL(xs) << 7;
513 1.26 mjacob ISP_SWIZZLE_REQUEST(isp, mp);
514 1.26 mjacob MemoryBarrier();
515 1.26 mjacob ISP_ADD_REQUEST(isp, iptr);
516 1.8 mjacob }
517 1.26 mjacob } else if (isp->isp_dblev) {
518 1.26 mjacob PRINTF("%s: watchdog with no command\n", isp->isp_name);
519 1.8 mjacob }
520 1.17 mjacob (void) splx(s);
521 1.8 mjacob }
522 1.8 mjacob
523 1.8 mjacob /*
524 1.8 mjacob * Free any associated resources prior to decommissioning and
525 1.8 mjacob * set the card to a known state (so it doesn't wake up and kick
526 1.8 mjacob * us when we aren't expecting it to).
527 1.8 mjacob *
528 1.8 mjacob * Locks are held before coming here.
529 1.8 mjacob */
530 1.8 mjacob void
531 1.8 mjacob isp_uninit(isp)
532 1.8 mjacob struct ispsoftc *isp;
533 1.8 mjacob {
534 1.8 mjacob ISP_ILOCKVAL_DECL;
535 1.8 mjacob ISP_ILOCK(isp);
536 1.8 mjacob /*
537 1.8 mjacob * Leave with interrupts disabled.
538 1.8 mjacob */
539 1.8 mjacob DISABLE_INTS(isp);
540 1.8 mjacob
541 1.8 mjacob ISP_IUNLOCK(isp);
542 1.9 mjacob }
543 1.9 mjacob
544 1.10 mjacob /*
545 1.17 mjacob * Restart function for a command to be requeued later.
546 1.17 mjacob */
547 1.17 mjacob static void
548 1.17 mjacob isp_command_requeue(arg)
549 1.17 mjacob void *arg;
550 1.17 mjacob {
551 1.17 mjacob struct scsipi_xfer *xs = arg;
552 1.17 mjacob struct ispsoftc *isp = XS_ISP(xs);
553 1.17 mjacob int s = splbio();
554 1.17 mjacob switch (ispcmd_slow(xs)) {
555 1.17 mjacob case SUCCESSFULLY_QUEUED:
556 1.18 mjacob printf("%s: isp_command_requeue: requeued for %d.%d\n",
557 1.17 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
558 1.26 mjacob if (xs->timeout) {
559 1.26 mjacob callout_reset(&xs->xs_callout, _XT(xs), isp_dog, xs);
560 1.26 mjacob }
561 1.17 mjacob break;
562 1.17 mjacob case TRY_AGAIN_LATER:
563 1.17 mjacob printf("%s: EAGAIN for %d.%d\n",
564 1.17 mjacob isp->isp_name, XS_TGT(xs), XS_LUN(xs));
565 1.17 mjacob /* FALLTHROUGH */
566 1.17 mjacob case COMPLETE:
567 1.18 mjacob /* can only be an error */
568 1.26 mjacob XS_CMD_S_DONE(xs);
569 1.26 mjacob callout_stop(&xs->xs_callout);
570 1.17 mjacob if (XS_NOERR(xs)) {
571 1.17 mjacob XS_SETERR(xs, HBA_BOTCH);
572 1.17 mjacob }
573 1.17 mjacob scsipi_done(xs);
574 1.17 mjacob break;
575 1.17 mjacob }
576 1.17 mjacob (void) splx(s);
577 1.17 mjacob }
578 1.18 mjacob
579 1.17 mjacob /*
580 1.10 mjacob * Restart function after a LOOP UP event (e.g.),
581 1.10 mjacob * done as a timeout for some hysteresis.
582 1.10 mjacob */
583 1.10 mjacob static void
584 1.10 mjacob isp_internal_restart(arg)
585 1.10 mjacob void *arg;
586 1.10 mjacob {
587 1.10 mjacob struct ispsoftc *isp = arg;
588 1.11 mjacob int result, nrestarted = 0, s;
589 1.10 mjacob
590 1.11 mjacob s = splbio();
591 1.10 mjacob if (isp->isp_osinfo.blocked == 0) {
592 1.10 mjacob struct scsipi_xfer *xs;
593 1.10 mjacob while ((xs = TAILQ_FIRST(&isp->isp_osinfo.waitq)) != NULL) {
594 1.10 mjacob TAILQ_REMOVE(&isp->isp_osinfo.waitq, xs, adapter_q);
595 1.11 mjacob result = ispscsicmd(xs);
596 1.11 mjacob if (result != CMD_QUEUED) {
597 1.10 mjacob printf("%s: botched command restart (0x%x)\n",
598 1.10 mjacob isp->isp_name, result);
599 1.26 mjacob XS_CMD_S_DONE(xs);
600 1.10 mjacob if (xs->error == XS_NOERROR)
601 1.10 mjacob xs->error = XS_DRIVER_STUFFUP;
602 1.26 mjacob callout_stop(&xs->xs_callout);
603 1.10 mjacob scsipi_done(xs);
604 1.26 mjacob } else if (xs->timeout) {
605 1.26 mjacob callout_reset(&xs->xs_callout,
606 1.26 mjacob _XT(xs), isp_dog, xs);
607 1.10 mjacob }
608 1.10 mjacob nrestarted++;
609 1.10 mjacob }
610 1.10 mjacob printf("%s: requeued %d commands\n", isp->isp_name, nrestarted);
611 1.10 mjacob }
612 1.10 mjacob (void) splx(s);
613 1.10 mjacob }
614 1.18 mjacob
615 1.9 mjacob int
616 1.9 mjacob isp_async(isp, cmd, arg)
617 1.9 mjacob struct ispsoftc *isp;
618 1.9 mjacob ispasync_t cmd;
619 1.9 mjacob void *arg;
620 1.9 mjacob {
621 1.14 mjacob int bus, tgt;
622 1.10 mjacob int s = splbio();
623 1.9 mjacob switch (cmd) {
624 1.9 mjacob case ISPASYNC_NEW_TGT_PARAMS:
625 1.17 mjacob if (IS_SCSI(isp) && isp->isp_dblev) {
626 1.17 mjacob sdparam *sdp = isp->isp_param;
627 1.17 mjacob char *wt;
628 1.17 mjacob int mhz, flags, period;
629 1.17 mjacob
630 1.17 mjacob tgt = *((int *) arg);
631 1.17 mjacob bus = (tgt >> 16) & 0xffff;
632 1.17 mjacob tgt &= 0xffff;
633 1.21 mjacob sdp += bus;
634 1.17 mjacob flags = sdp->isp_devparam[tgt].cur_dflags;
635 1.17 mjacob period = sdp->isp_devparam[tgt].cur_period;
636 1.21 mjacob
637 1.17 mjacob if ((flags & DPARM_SYNC) && period &&
638 1.17 mjacob (sdp->isp_devparam[tgt].cur_offset) != 0) {
639 1.21 mjacob #if 0
640 1.21 mjacob /* CAUSES PANICS */
641 1.21 mjacob static char *m = "%s: bus %d now %s mode\n";
642 1.21 mjacob u_int16_t r, l;
643 1.21 mjacob if (bus == 1)
644 1.21 mjacob r = SXP_PINS_DIFF | SXP_BANK1_SELECT;
645 1.21 mjacob else
646 1.21 mjacob r = SXP_PINS_DIFF;
647 1.21 mjacob l = ISP_READ(isp, r) & ISP1080_MODE_MASK;
648 1.21 mjacob switch (l) {
649 1.21 mjacob case ISP1080_LVD_MODE:
650 1.21 mjacob sdp->isp_lvdmode = 1;
651 1.21 mjacob printf(m, isp->isp_name, bus, "LVD");
652 1.21 mjacob break;
653 1.21 mjacob case ISP1080_HVD_MODE:
654 1.21 mjacob sdp->isp_diffmode = 1;
655 1.21 mjacob printf(m, isp->isp_name, bus, "Differential");
656 1.21 mjacob break;
657 1.21 mjacob case ISP1080_SE_MODE:
658 1.21 mjacob sdp->isp_ultramode = 1;
659 1.21 mjacob printf(m, isp->isp_name, bus, "Single-Ended");
660 1.21 mjacob break;
661 1.21 mjacob default:
662 1.21 mjacob printf("%s: unknown mode on bus %d (0x%x)\n",
663 1.21 mjacob isp->isp_name, bus, l);
664 1.21 mjacob break;
665 1.21 mjacob }
666 1.21 mjacob #endif
667 1.21 mjacob /*
668 1.21 mjacob * There's some ambiguity about our negotiated speed
669 1.21 mjacob * if we haven't detected LVD mode correctly (which
670 1.21 mjacob * seems to happen, unfortunately). If we're in LVD
671 1.21 mjacob * mode, then different rules apply about speed.
672 1.21 mjacob */
673 1.21 mjacob if (sdp->isp_lvdmode || period < 0xc) {
674 1.17 mjacob switch (period) {
675 1.23 mjacob case 0x9:
676 1.23 mjacob mhz = 80;
677 1.23 mjacob break;
678 1.17 mjacob case 0xa:
679 1.17 mjacob mhz = 40;
680 1.17 mjacob break;
681 1.17 mjacob case 0xb:
682 1.17 mjacob mhz = 33;
683 1.17 mjacob break;
684 1.17 mjacob case 0xc:
685 1.17 mjacob mhz = 25;
686 1.17 mjacob break;
687 1.17 mjacob default:
688 1.12 mjacob mhz = 1000 / (period * 4);
689 1.17 mjacob break;
690 1.12 mjacob }
691 1.9 mjacob } else {
692 1.17 mjacob mhz = 1000 / (period * 4);
693 1.9 mjacob }
694 1.17 mjacob } else {
695 1.17 mjacob mhz = 0;
696 1.17 mjacob }
697 1.17 mjacob switch (flags & (DPARM_WIDE|DPARM_TQING)) {
698 1.17 mjacob case DPARM_WIDE:
699 1.17 mjacob wt = ", 16 bit wide\n";
700 1.17 mjacob break;
701 1.17 mjacob case DPARM_TQING:
702 1.17 mjacob wt = ", Tagged Queueing Enabled\n";
703 1.17 mjacob break;
704 1.17 mjacob case DPARM_WIDE|DPARM_TQING:
705 1.17 mjacob wt = ", 16 bit wide, Tagged Queueing Enabled\n";
706 1.17 mjacob break;
707 1.17 mjacob default:
708 1.17 mjacob wt = "\n";
709 1.17 mjacob break;
710 1.17 mjacob }
711 1.17 mjacob if (mhz) {
712 1.19 mjacob CFGPRINTF("%s: Bus %d Target %d at %dMHz Max "
713 1.17 mjacob "Offset %d%s", isp->isp_name, bus, tgt, mhz,
714 1.17 mjacob sdp->isp_devparam[tgt].cur_offset, wt);
715 1.17 mjacob } else {
716 1.19 mjacob CFGPRINTF("%s: Bus %d Target %d Async Mode%s",
717 1.17 mjacob isp->isp_name, bus, tgt, wt);
718 1.9 mjacob }
719 1.11 mjacob break;
720 1.17 mjacob }
721 1.11 mjacob case ISPASYNC_BUS_RESET:
722 1.14 mjacob if (arg)
723 1.14 mjacob bus = *((int *) arg);
724 1.14 mjacob else
725 1.14 mjacob bus = 0;
726 1.14 mjacob printf("%s: SCSI bus %d reset detected\n", isp->isp_name, bus);
727 1.11 mjacob break;
728 1.11 mjacob case ISPASYNC_LOOP_DOWN:
729 1.11 mjacob /*
730 1.11 mjacob * Hopefully we get here in time to minimize the number
731 1.11 mjacob * of commands we are firing off that are sure to die.
732 1.11 mjacob */
733 1.11 mjacob isp->isp_osinfo.blocked = 1;
734 1.11 mjacob printf("%s: Loop DOWN\n", isp->isp_name);
735 1.11 mjacob break;
736 1.11 mjacob case ISPASYNC_LOOP_UP:
737 1.11 mjacob isp->isp_osinfo.blocked = 0;
738 1.24 thorpej callout_reset(&isp->isp_osinfo._restart, 1,
739 1.24 thorpej isp_internal_restart, isp);
740 1.11 mjacob printf("%s: Loop UP\n", isp->isp_name);
741 1.11 mjacob break;
742 1.15 mjacob case ISPASYNC_PDB_CHANGED:
743 1.17 mjacob if (IS_FC(isp) && isp->isp_dblev) {
744 1.15 mjacob const char *fmt = "%s: Target %d (Loop 0x%x) Port ID 0x%x "
745 1.15 mjacob "role %s %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x\n";
746 1.15 mjacob const static char *roles[4] = {
747 1.11 mjacob "No", "Target", "Initiator", "Target/Initiator"
748 1.11 mjacob };
749 1.15 mjacob char *ptr;
750 1.15 mjacob fcparam *fcp = isp->isp_param;
751 1.15 mjacob int tgt = *((int *) arg);
752 1.15 mjacob struct lportdb *lp = &fcp->portdb[tgt];
753 1.15 mjacob
754 1.15 mjacob if (lp->valid) {
755 1.15 mjacob ptr = "arrived";
756 1.15 mjacob } else {
757 1.15 mjacob ptr = "disappeared";
758 1.11 mjacob }
759 1.15 mjacob printf(fmt, isp->isp_name, tgt, lp->loopid, lp->portid,
760 1.15 mjacob roles[lp->roles & 0x3], ptr,
761 1.15 mjacob (u_int32_t) (lp->port_wwn >> 32),
762 1.15 mjacob (u_int32_t) (lp->port_wwn & 0xffffffffLL),
763 1.15 mjacob (u_int32_t) (lp->node_wwn >> 32),
764 1.15 mjacob (u_int32_t) (lp->node_wwn & 0xffffffffLL));
765 1.11 mjacob break;
766 1.11 mjacob }
767 1.15 mjacob #ifdef ISP2100_FABRIC
768 1.11 mjacob case ISPASYNC_CHANGE_NOTIFY:
769 1.11 mjacob printf("%s: Name Server Database Changed\n", isp->isp_name);
770 1.9 mjacob break;
771 1.15 mjacob case ISPASYNC_FABRIC_DEV:
772 1.15 mjacob {
773 1.15 mjacob int target;
774 1.15 mjacob struct lportdb *lp;
775 1.15 mjacob sns_scrsp_t *resp = (sns_scrsp_t *) arg;
776 1.15 mjacob u_int32_t portid;
777 1.15 mjacob u_int64_t wwn;
778 1.15 mjacob fcparam *fcp = isp->isp_param;
779 1.15 mjacob
780 1.15 mjacob portid =
781 1.15 mjacob (((u_int32_t) resp->snscb_port_id[0]) << 16) |
782 1.15 mjacob (((u_int32_t) resp->snscb_port_id[1]) << 8) |
783 1.15 mjacob (((u_int32_t) resp->snscb_port_id[2]));
784 1.15 mjacob wwn =
785 1.15 mjacob (((u_int64_t)resp->snscb_portname[0]) << 56) |
786 1.15 mjacob (((u_int64_t)resp->snscb_portname[1]) << 48) |
787 1.15 mjacob (((u_int64_t)resp->snscb_portname[2]) << 40) |
788 1.15 mjacob (((u_int64_t)resp->snscb_portname[3]) << 32) |
789 1.15 mjacob (((u_int64_t)resp->snscb_portname[4]) << 24) |
790 1.15 mjacob (((u_int64_t)resp->snscb_portname[5]) << 16) |
791 1.15 mjacob (((u_int64_t)resp->snscb_portname[6]) << 8) |
792 1.15 mjacob (((u_int64_t)resp->snscb_portname[7]));
793 1.15 mjacob printf("%s: Fabric Device (Type 0x%x)@PortID 0x%x WWN "
794 1.15 mjacob "0x%08x%08x\n", isp->isp_name, resp->snscb_port_type,
795 1.15 mjacob portid, ((u_int32_t)(wwn >> 32)),
796 1.15 mjacob ((u_int32_t)(wwn & 0xffffffff)));
797 1.15 mjacob if (resp->snscb_port_type != 2)
798 1.15 mjacob break;
799 1.15 mjacob for (target = FC_SNS_ID+1; target < MAX_FC_TARG; target++) {
800 1.15 mjacob lp = &fcp->portdb[target];
801 1.15 mjacob if (lp->port_wwn == wwn)
802 1.15 mjacob break;
803 1.15 mjacob }
804 1.15 mjacob if (target < MAX_FC_TARG) {
805 1.15 mjacob break;
806 1.15 mjacob }
807 1.15 mjacob for (target = FC_SNS_ID+1; target < MAX_FC_TARG; target++) {
808 1.15 mjacob lp = &fcp->portdb[target];
809 1.15 mjacob if (lp->port_wwn == 0)
810 1.15 mjacob break;
811 1.15 mjacob }
812 1.15 mjacob if (target == MAX_FC_TARG) {
813 1.15 mjacob printf("%s: no more space for fabric devices\n",
814 1.15 mjacob isp->isp_name);
815 1.15 mjacob return (-1);
816 1.15 mjacob }
817 1.15 mjacob lp->port_wwn = lp->node_wwn = wwn;
818 1.15 mjacob lp->portid = portid;
819 1.15 mjacob break;
820 1.15 mjacob }
821 1.15 mjacob #endif
822 1.9 mjacob default:
823 1.9 mjacob break;
824 1.9 mjacob }
825 1.10 mjacob (void) splx(s);
826 1.9 mjacob return (0);
827 1.1 mjacob }
828