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