iop.c revision 1.86 1 1.86 dholland /* $NetBSD: iop.c,v 1.86 2014/07/25 08:10:37 dholland Exp $ */
2 1.1 ad
3 1.1 ad /*-
4 1.63 ad * Copyright (c) 2000, 2001, 2002, 2007 The NetBSD Foundation, Inc.
5 1.1 ad * All rights reserved.
6 1.1 ad *
7 1.1 ad * This code is derived from software contributed to The NetBSD Foundation
8 1.1 ad * by Andrew Doran.
9 1.1 ad *
10 1.1 ad * Redistribution and use in source and binary forms, with or without
11 1.1 ad * modification, are permitted provided that the following conditions
12 1.1 ad * are met:
13 1.1 ad * 1. Redistributions of source code must retain the above copyright
14 1.1 ad * notice, this list of conditions and the following disclaimer.
15 1.1 ad * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 ad * notice, this list of conditions and the following disclaimer in the
17 1.1 ad * documentation and/or other materials provided with the distribution.
18 1.1 ad *
19 1.1 ad * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 1.1 ad * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 1.1 ad * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 1.1 ad * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 1.1 ad * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 1.1 ad * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 1.1 ad * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 1.1 ad * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 1.1 ad * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 1.1 ad * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 1.1 ad * POSSIBILITY OF SUCH DAMAGE.
30 1.1 ad */
31 1.1 ad
32 1.1 ad /*
33 1.1 ad * Support for I2O IOPs (intelligent I/O processors).
34 1.1 ad */
35 1.20 lukem
36 1.20 lukem #include <sys/cdefs.h>
37 1.86 dholland __KERNEL_RCSID(0, "$NetBSD: iop.c,v 1.86 2014/07/25 08:10:37 dholland Exp $");
38 1.1 ad
39 1.5 ad #include "iop.h"
40 1.1 ad
41 1.1 ad #include <sys/param.h>
42 1.1 ad #include <sys/systm.h>
43 1.1 ad #include <sys/kernel.h>
44 1.1 ad #include <sys/device.h>
45 1.1 ad #include <sys/queue.h>
46 1.1 ad #include <sys/proc.h>
47 1.1 ad #include <sys/malloc.h>
48 1.1 ad #include <sys/ioctl.h>
49 1.1 ad #include <sys/endian.h>
50 1.5 ad #include <sys/conf.h>
51 1.5 ad #include <sys/kthread.h>
52 1.60 elad #include <sys/kauth.h>
53 1.67 ad #include <sys/bus.h>
54 1.1 ad
55 1.1 ad #include <dev/i2o/i2o.h>
56 1.11 ad #include <dev/i2o/iopio.h>
57 1.1 ad #include <dev/i2o/iopreg.h>
58 1.1 ad #include <dev/i2o/iopvar.h>
59 1.1 ad
60 1.44 drochner #include "locators.h"
61 1.44 drochner
62 1.1 ad #define POLL(ms, cond) \
63 1.1 ad do { \
64 1.48 christos int xi; \
65 1.48 christos for (xi = (ms) * 10; xi; xi--) { \
66 1.1 ad if (cond) \
67 1.1 ad break; \
68 1.1 ad DELAY(100); \
69 1.1 ad } \
70 1.1 ad } while (/* CONSTCOND */0);
71 1.1 ad
72 1.1 ad #ifdef I2ODEBUG
73 1.1 ad #define DPRINTF(x) printf x
74 1.1 ad #else
75 1.1 ad #define DPRINTF(x)
76 1.1 ad #endif
77 1.1 ad
78 1.5 ad #define IOP_ICTXHASH_NBUCKETS 16
79 1.5 ad #define IOP_ICTXHASH(ictx) (&iop_ictxhashtbl[(ictx) & iop_ictxhash])
80 1.11 ad
81 1.11 ad #define IOP_MAX_SEGS (((IOP_MAX_XFER + PAGE_SIZE - 1) / PAGE_SIZE) + 1)
82 1.11 ad
83 1.11 ad #define IOP_TCTX_SHIFT 12
84 1.11 ad #define IOP_TCTX_MASK ((1 << IOP_TCTX_SHIFT) - 1)
85 1.5 ad
86 1.5 ad static LIST_HEAD(, iop_initiator) *iop_ictxhashtbl;
87 1.5 ad static u_long iop_ictxhash;
88 1.1 ad static void *iop_sdh;
89 1.5 ad static struct i2o_systab *iop_systab;
90 1.5 ad static int iop_systab_size;
91 1.1 ad
92 1.1 ad extern struct cfdriver iop_cd;
93 1.1 ad
94 1.25 gehenna dev_type_open(iopopen);
95 1.25 gehenna dev_type_close(iopclose);
96 1.25 gehenna dev_type_ioctl(iopioctl);
97 1.25 gehenna
98 1.25 gehenna const struct cdevsw iop_cdevsw = {
99 1.85 dholland .d_open = iopopen,
100 1.85 dholland .d_close = iopclose,
101 1.85 dholland .d_read = noread,
102 1.85 dholland .d_write = nowrite,
103 1.85 dholland .d_ioctl = iopioctl,
104 1.85 dholland .d_stop = nostop,
105 1.85 dholland .d_tty = notty,
106 1.85 dholland .d_poll = nopoll,
107 1.85 dholland .d_mmap = nommap,
108 1.85 dholland .d_kqfilter = nokqfilter,
109 1.86 dholland .d_discard = nodiscard,
110 1.85 dholland .d_flag = D_OTHER,
111 1.25 gehenna };
112 1.25 gehenna
113 1.5 ad #define IC_CONFIGURE 0x01
114 1.11 ad #define IC_PRIORITY 0x02
115 1.1 ad
116 1.57 christos static struct iop_class {
117 1.5 ad u_short ic_class;
118 1.5 ad u_short ic_flags;
119 1.65 ad const char *ic_caption;
120 1.57 christos } const iop_class[] = {
121 1.47 perry {
122 1.1 ad I2O_CLASS_EXECUTIVE,
123 1.1 ad 0,
124 1.65 ad "executive"
125 1.1 ad },
126 1.1 ad {
127 1.1 ad I2O_CLASS_DDM,
128 1.1 ad 0,
129 1.65 ad "device driver module"
130 1.1 ad },
131 1.1 ad {
132 1.1 ad I2O_CLASS_RANDOM_BLOCK_STORAGE,
133 1.11 ad IC_CONFIGURE | IC_PRIORITY,
134 1.65 ad "random block storage"
135 1.1 ad },
136 1.1 ad {
137 1.1 ad I2O_CLASS_SEQUENTIAL_STORAGE,
138 1.11 ad IC_CONFIGURE | IC_PRIORITY,
139 1.65 ad "sequential storage"
140 1.1 ad },
141 1.1 ad {
142 1.1 ad I2O_CLASS_LAN,
143 1.11 ad IC_CONFIGURE | IC_PRIORITY,
144 1.65 ad "LAN port"
145 1.1 ad },
146 1.1 ad {
147 1.1 ad I2O_CLASS_WAN,
148 1.11 ad IC_CONFIGURE | IC_PRIORITY,
149 1.65 ad "WAN port"
150 1.1 ad },
151 1.1 ad {
152 1.1 ad I2O_CLASS_FIBRE_CHANNEL_PORT,
153 1.1 ad IC_CONFIGURE,
154 1.65 ad "fibrechannel port"
155 1.1 ad },
156 1.1 ad {
157 1.1 ad I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL,
158 1.1 ad 0,
159 1.65 ad "fibrechannel peripheral"
160 1.1 ad },
161 1.1 ad {
162 1.1 ad I2O_CLASS_SCSI_PERIPHERAL,
163 1.1 ad 0,
164 1.65 ad "SCSI peripheral"
165 1.1 ad },
166 1.1 ad {
167 1.1 ad I2O_CLASS_ATE_PORT,
168 1.1 ad IC_CONFIGURE,
169 1.65 ad "ATE port"
170 1.1 ad },
171 1.47 perry {
172 1.1 ad I2O_CLASS_ATE_PERIPHERAL,
173 1.1 ad 0,
174 1.65 ad "ATE peripheral"
175 1.1 ad },
176 1.47 perry {
177 1.1 ad I2O_CLASS_FLOPPY_CONTROLLER,
178 1.1 ad IC_CONFIGURE,
179 1.65 ad "floppy controller"
180 1.1 ad },
181 1.1 ad {
182 1.1 ad I2O_CLASS_FLOPPY_DEVICE,
183 1.1 ad 0,
184 1.65 ad "floppy device"
185 1.1 ad },
186 1.1 ad {
187 1.1 ad I2O_CLASS_BUS_ADAPTER_PORT,
188 1.1 ad IC_CONFIGURE,
189 1.65 ad "bus adapter port"
190 1.1 ad },
191 1.1 ad };
192 1.1 ad
193 1.83 joerg #ifdef I2ODEBUG
194 1.11 ad static const char * const iop_status[] = {
195 1.1 ad "success",
196 1.1 ad "abort (dirty)",
197 1.1 ad "abort (no data transfer)",
198 1.1 ad "abort (partial transfer)",
199 1.1 ad "error (dirty)",
200 1.1 ad "error (no data transfer)",
201 1.1 ad "error (partial transfer)",
202 1.1 ad "undefined error code",
203 1.1 ad "process abort (dirty)",
204 1.1 ad "process abort (no data transfer)",
205 1.1 ad "process abort (partial transfer)",
206 1.1 ad "transaction error",
207 1.1 ad };
208 1.83 joerg #endif
209 1.1 ad
210 1.5 ad static inline u_int32_t iop_inl(struct iop_softc *, int);
211 1.5 ad static inline void iop_outl(struct iop_softc *, int, u_int32_t);
212 1.5 ad
213 1.29 msaitoh static inline u_int32_t iop_inl_msg(struct iop_softc *, int);
214 1.30 ad static inline void iop_outl_msg(struct iop_softc *, int, u_int32_t);
215 1.29 msaitoh
216 1.76 cegger static void iop_config_interrupts(device_t);
217 1.11 ad static void iop_configure_devices(struct iop_softc *, int, int);
218 1.43 itojun static void iop_devinfo(int, char *, size_t);
219 1.1 ad static int iop_print(void *, const char *);
220 1.1 ad static void iop_shutdown(void *);
221 1.1 ad
222 1.11 ad static void iop_adjqparam(struct iop_softc *, int);
223 1.11 ad static int iop_handle_reply(struct iop_softc *, u_int32_t);
224 1.1 ad static int iop_hrt_get(struct iop_softc *);
225 1.1 ad static int iop_hrt_get0(struct iop_softc *, struct i2o_hrt *, int);
226 1.76 cegger static void iop_intr_event(device_t, struct iop_msg *, void *);
227 1.5 ad static int iop_lct_get0(struct iop_softc *, struct i2o_lct *, int,
228 1.5 ad u_int32_t);
229 1.11 ad static void iop_msg_poll(struct iop_softc *, struct iop_msg *, int);
230 1.11 ad static void iop_msg_wait(struct iop_softc *, struct iop_msg *, int);
231 1.1 ad static int iop_ofifo_init(struct iop_softc *);
232 1.15 ad static int iop_passthrough(struct iop_softc *, struct ioppt *,
233 1.15 ad struct proc *);
234 1.9 ad static void iop_reconf_thread(void *);
235 1.1 ad static void iop_release_mfa(struct iop_softc *, u_int32_t);
236 1.1 ad static int iop_reset(struct iop_softc *);
237 1.42 ad static int iop_sys_enable(struct iop_softc *);
238 1.1 ad static int iop_systab_set(struct iop_softc *);
239 1.11 ad static void iop_tfn_print(struct iop_softc *, struct i2o_fault_notify *);
240 1.1 ad
241 1.1 ad #ifdef I2ODEBUG
242 1.11 ad static void iop_reply_print(struct iop_softc *, struct i2o_reply *);
243 1.1 ad #endif
244 1.5 ad
245 1.5 ad static inline u_int32_t
246 1.5 ad iop_inl(struct iop_softc *sc, int off)
247 1.5 ad {
248 1.5 ad
249 1.5 ad bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
250 1.5 ad BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
251 1.5 ad return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, off));
252 1.5 ad }
253 1.5 ad
254 1.5 ad static inline void
255 1.5 ad iop_outl(struct iop_softc *sc, int off, u_int32_t val)
256 1.5 ad {
257 1.5 ad
258 1.5 ad bus_space_write_4(sc->sc_iot, sc->sc_ioh, off, val);
259 1.5 ad bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
260 1.5 ad BUS_SPACE_BARRIER_WRITE);
261 1.5 ad }
262 1.5 ad
263 1.29 msaitoh static inline u_int32_t
264 1.29 msaitoh iop_inl_msg(struct iop_softc *sc, int off)
265 1.29 msaitoh {
266 1.29 msaitoh
267 1.32 ad bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, off, 4,
268 1.29 msaitoh BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
269 1.32 ad return (bus_space_read_4(sc->sc_msg_iot, sc->sc_msg_ioh, off));
270 1.29 msaitoh }
271 1.29 msaitoh
272 1.29 msaitoh static inline void
273 1.30 ad iop_outl_msg(struct iop_softc *sc, int off, u_int32_t val)
274 1.29 msaitoh {
275 1.29 msaitoh
276 1.30 ad bus_space_write_4(sc->sc_msg_iot, sc->sc_msg_ioh, off, val);
277 1.30 ad bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, off, 4,
278 1.29 msaitoh BUS_SPACE_BARRIER_WRITE);
279 1.29 msaitoh }
280 1.29 msaitoh
281 1.1 ad /*
282 1.11 ad * Initialise the IOP and our interface.
283 1.1 ad */
284 1.5 ad void
285 1.1 ad iop_init(struct iop_softc *sc, const char *intrstr)
286 1.1 ad {
287 1.11 ad struct iop_msg *im;
288 1.40 mycroft int rv, i, j, state, nsegs;
289 1.1 ad u_int32_t mask;
290 1.1 ad char ident[64];
291 1.1 ad
292 1.15 ad state = 0;
293 1.15 ad
294 1.15 ad printf("I2O adapter");
295 1.15 ad
296 1.68 ad mutex_init(&sc->sc_intrlock, MUTEX_DEFAULT, IPL_VM);
297 1.68 ad mutex_init(&sc->sc_conflock, MUTEX_DEFAULT, IPL_NONE);
298 1.65 ad cv_init(&sc->sc_confcv, "iopconf");
299 1.65 ad
300 1.71 ad if (iop_ictxhashtbl == NULL) {
301 1.5 ad iop_ictxhashtbl = hashinit(IOP_ICTXHASH_NBUCKETS, HASH_LIST,
302 1.71 ad true, &iop_ictxhash);
303 1.71 ad }
304 1.1 ad
305 1.15 ad /* Disable interrupts at the IOP. */
306 1.15 ad mask = iop_inl(sc, IOP_REG_INTR_MASK);
307 1.15 ad iop_outl(sc, IOP_REG_INTR_MASK, mask | IOP_INTR_OFIFO);
308 1.5 ad
309 1.15 ad /* Allocate a scratch DMA map for small miscellaneous shared data. */
310 1.15 ad if (bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0,
311 1.15 ad BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &sc->sc_scr_dmamap) != 0) {
312 1.82 chs aprint_error_dev(sc->sc_dev, "cannot create scratch dmamap\n");
313 1.5 ad return;
314 1.1 ad }
315 1.15 ad
316 1.15 ad if (bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE, PAGE_SIZE, 0,
317 1.15 ad sc->sc_scr_seg, 1, &nsegs, BUS_DMA_NOWAIT) != 0) {
318 1.82 chs aprint_error_dev(sc->sc_dev, "cannot alloc scratch dmamem\n");
319 1.15 ad goto bail_out;
320 1.15 ad }
321 1.15 ad state++;
322 1.15 ad
323 1.15 ad if (bus_dmamem_map(sc->sc_dmat, sc->sc_scr_seg, nsegs, PAGE_SIZE,
324 1.15 ad &sc->sc_scr, 0)) {
325 1.82 chs aprint_error_dev(sc->sc_dev, "cannot map scratch dmamem\n");
326 1.15 ad goto bail_out;
327 1.15 ad }
328 1.15 ad state++;
329 1.15 ad
330 1.15 ad if (bus_dmamap_load(sc->sc_dmat, sc->sc_scr_dmamap, sc->sc_scr,
331 1.15 ad PAGE_SIZE, NULL, BUS_DMA_NOWAIT)) {
332 1.82 chs aprint_error_dev(sc->sc_dev, "cannot load scratch dmamap\n");
333 1.15 ad goto bail_out;
334 1.15 ad }
335 1.15 ad state++;
336 1.15 ad
337 1.21 ad #ifdef I2ODEBUG
338 1.21 ad /* So that our debug checks don't choke. */
339 1.21 ad sc->sc_framesize = 128;
340 1.21 ad #endif
341 1.21 ad
342 1.65 ad /* Avoid syncing the reply map until it's set up. */
343 1.65 ad sc->sc_curib = 0x123;
344 1.65 ad
345 1.15 ad /* Reset the adapter and request status. */
346 1.15 ad if ((rv = iop_reset(sc)) != 0) {
347 1.82 chs aprint_error_dev(sc->sc_dev, "not responding (reset)\n");
348 1.15 ad goto bail_out;
349 1.15 ad }
350 1.15 ad
351 1.15 ad if ((rv = iop_status_get(sc, 1)) != 0) {
352 1.82 chs aprint_error_dev(sc->sc_dev, "not responding (get status)\n");
353 1.15 ad goto bail_out;
354 1.15 ad }
355 1.15 ad
356 1.5 ad sc->sc_flags |= IOP_HAVESTATUS;
357 1.5 ad iop_strvis(sc, sc->sc_status.productid, sizeof(sc->sc_status.productid),
358 1.1 ad ident, sizeof(ident));
359 1.5 ad printf(" <%s>\n", ident);
360 1.5 ad
361 1.5 ad #ifdef I2ODEBUG
362 1.69 cegger printf("%s: orgid=0x%04x version=%d\n",
363 1.82 chs device_xname(sc->sc_dev),
364 1.5 ad le16toh(sc->sc_status.orgid),
365 1.5 ad (le32toh(sc->sc_status.segnumber) >> 12) & 15);
366 1.82 chs printf("%s: type want have cbase\n", device_xname(sc->sc_dev));
367 1.82 chs printf("%s: mem %04x %04x %08x\n", device_xname(sc->sc_dev),
368 1.5 ad le32toh(sc->sc_status.desiredprivmemsize),
369 1.5 ad le32toh(sc->sc_status.currentprivmemsize),
370 1.5 ad le32toh(sc->sc_status.currentprivmembase));
371 1.82 chs printf("%s: i/o %04x %04x %08x\n", device_xname(sc->sc_dev),
372 1.5 ad le32toh(sc->sc_status.desiredpriviosize),
373 1.5 ad le32toh(sc->sc_status.currentpriviosize),
374 1.5 ad le32toh(sc->sc_status.currentpriviobase));
375 1.5 ad #endif
376 1.1 ad
377 1.11 ad sc->sc_maxob = le32toh(sc->sc_status.maxoutboundmframes);
378 1.11 ad if (sc->sc_maxob > IOP_MAX_OUTBOUND)
379 1.11 ad sc->sc_maxob = IOP_MAX_OUTBOUND;
380 1.11 ad sc->sc_maxib = le32toh(sc->sc_status.maxinboundmframes);
381 1.11 ad if (sc->sc_maxib > IOP_MAX_INBOUND)
382 1.11 ad sc->sc_maxib = IOP_MAX_INBOUND;
383 1.19 ad sc->sc_framesize = le16toh(sc->sc_status.inboundmframesize) << 2;
384 1.19 ad if (sc->sc_framesize > IOP_MAX_MSG_SIZE)
385 1.19 ad sc->sc_framesize = IOP_MAX_MSG_SIZE;
386 1.19 ad
387 1.19 ad #if defined(I2ODEBUG) || defined(DIAGNOSTIC)
388 1.19 ad if (sc->sc_framesize < IOP_MIN_MSG_SIZE) {
389 1.82 chs aprint_error_dev(sc->sc_dev, "frame size too small (%d)\n",
390 1.69 cegger sc->sc_framesize);
391 1.23 ad goto bail_out;
392 1.19 ad }
393 1.19 ad #endif
394 1.11 ad
395 1.11 ad /* Allocate message wrappers. */
396 1.22 tsutsui im = malloc(sizeof(*im) * sc->sc_maxib, M_DEVBUF, M_NOWAIT|M_ZERO);
397 1.23 ad if (im == NULL) {
398 1.82 chs aprint_error_dev(sc->sc_dev, "memory allocation failure\n");
399 1.23 ad goto bail_out;
400 1.23 ad }
401 1.23 ad state++;
402 1.11 ad sc->sc_ims = im;
403 1.11 ad SLIST_INIT(&sc->sc_im_freelist);
404 1.11 ad
405 1.40 mycroft for (i = 0; i < sc->sc_maxib; i++, im++) {
406 1.11 ad rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
407 1.11 ad IOP_MAX_SEGS, IOP_MAX_XFER, 0,
408 1.11 ad BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
409 1.11 ad &im->im_xfer[0].ix_map);
410 1.11 ad if (rv != 0) {
411 1.82 chs aprint_error_dev(sc->sc_dev, "couldn't create dmamap (%d)", rv);
412 1.40 mycroft goto bail_out3;
413 1.11 ad }
414 1.11 ad
415 1.11 ad im->im_tctx = i;
416 1.11 ad SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
417 1.65 ad cv_init(&im->im_cv, "iopmsg");
418 1.11 ad }
419 1.1 ad
420 1.17 wiz /* Initialise the IOP's outbound FIFO. */
421 1.5 ad if (iop_ofifo_init(sc) != 0) {
422 1.82 chs aprint_error_dev(sc->sc_dev, "unable to init oubound FIFO\n");
423 1.40 mycroft goto bail_out3;
424 1.5 ad }
425 1.1 ad
426 1.5 ad /*
427 1.5 ad * Defer further configuration until (a) interrupts are working and
428 1.5 ad * (b) we have enough information to build the system table.
429 1.5 ad */
430 1.82 chs config_interrupts(sc->sc_dev, iop_config_interrupts);
431 1.1 ad
432 1.5 ad /* Configure shutdown hook before we start any device activity. */
433 1.1 ad if (iop_sdh == NULL)
434 1.1 ad iop_sdh = shutdownhook_establish(iop_shutdown, NULL);
435 1.1 ad
436 1.1 ad /* Ensure interrupts are enabled at the IOP. */
437 1.5 ad mask = iop_inl(sc, IOP_REG_INTR_MASK);
438 1.5 ad iop_outl(sc, IOP_REG_INTR_MASK, mask & ~IOP_INTR_OFIFO);
439 1.1 ad
440 1.1 ad if (intrstr != NULL)
441 1.82 chs printf("%s: interrupting at %s\n", device_xname(sc->sc_dev),
442 1.1 ad intrstr);
443 1.1 ad
444 1.1 ad #ifdef I2ODEBUG
445 1.1 ad printf("%s: queue depths: inbound %d/%d, outbound %d/%d\n",
446 1.82 chs device_xname(sc->sc_dev), sc->sc_maxib,
447 1.11 ad le32toh(sc->sc_status.maxinboundmframes),
448 1.11 ad sc->sc_maxob, le32toh(sc->sc_status.maxoutboundmframes));
449 1.1 ad #endif
450 1.1 ad
451 1.15 ad return;
452 1.15 ad
453 1.40 mycroft bail_out3:
454 1.15 ad if (state > 3) {
455 1.15 ad for (j = 0; j < i; j++)
456 1.15 ad bus_dmamap_destroy(sc->sc_dmat,
457 1.15 ad sc->sc_ims[j].im_xfer[0].ix_map);
458 1.15 ad free(sc->sc_ims, M_DEVBUF);
459 1.15 ad }
460 1.40 mycroft bail_out:
461 1.15 ad if (state > 2)
462 1.15 ad bus_dmamap_unload(sc->sc_dmat, sc->sc_scr_dmamap);
463 1.15 ad if (state > 1)
464 1.15 ad bus_dmamem_unmap(sc->sc_dmat, sc->sc_scr, PAGE_SIZE);
465 1.15 ad if (state > 0)
466 1.15 ad bus_dmamem_free(sc->sc_dmat, sc->sc_scr_seg, nsegs);
467 1.15 ad bus_dmamap_destroy(sc->sc_dmat, sc->sc_scr_dmamap);
468 1.1 ad }
469 1.1 ad
470 1.1 ad /*
471 1.5 ad * Perform autoconfiguration tasks.
472 1.1 ad */
473 1.1 ad static void
474 1.76 cegger iop_config_interrupts(device_t self)
475 1.1 ad {
476 1.18 ad struct iop_attach_args ia;
477 1.5 ad struct iop_softc *sc, *iop;
478 1.5 ad struct i2o_systab_entry *ste;
479 1.5 ad int rv, i, niop;
480 1.49 drochner int locs[IOPCF_NLOCS];
481 1.1 ad
482 1.54 thorpej sc = device_private(self);
483 1.65 ad mutex_enter(&sc->sc_conflock);
484 1.65 ad
485 1.5 ad LIST_INIT(&sc->sc_iilist);
486 1.5 ad
487 1.82 chs printf("%s: configuring...\n", device_xname(sc->sc_dev));
488 1.1 ad
489 1.5 ad if (iop_hrt_get(sc) != 0) {
490 1.82 chs printf("%s: unable to retrieve HRT\n", device_xname(sc->sc_dev));
491 1.65 ad mutex_exit(&sc->sc_conflock);
492 1.5 ad return;
493 1.5 ad }
494 1.1 ad
495 1.5 ad /*
496 1.5 ad * Build the system table.
497 1.5 ad */
498 1.5 ad if (iop_systab == NULL) {
499 1.5 ad for (i = 0, niop = 0; i < iop_cd.cd_ndevs; i++) {
500 1.73 tsutsui if ((iop = device_lookup_private(&iop_cd, i)) == NULL)
501 1.5 ad continue;
502 1.5 ad if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
503 1.5 ad continue;
504 1.11 ad if (iop_status_get(iop, 1) != 0) {
505 1.82 chs aprint_error_dev(sc->sc_dev, "unable to retrieve status\n");
506 1.5 ad iop->sc_flags &= ~IOP_HAVESTATUS;
507 1.5 ad continue;
508 1.5 ad }
509 1.5 ad niop++;
510 1.5 ad }
511 1.65 ad if (niop == 0) {
512 1.65 ad mutex_exit(&sc->sc_conflock);
513 1.5 ad return;
514 1.65 ad }
515 1.5 ad
516 1.5 ad i = sizeof(struct i2o_systab_entry) * (niop - 1) +
517 1.5 ad sizeof(struct i2o_systab);
518 1.5 ad iop_systab_size = i;
519 1.22 tsutsui iop_systab = malloc(i, M_DEVBUF, M_NOWAIT|M_ZERO);
520 1.5 ad
521 1.5 ad iop_systab->numentries = niop;
522 1.5 ad iop_systab->version = I2O_VERSION_11;
523 1.5 ad
524 1.5 ad for (i = 0, ste = iop_systab->entry; i < iop_cd.cd_ndevs; i++) {
525 1.73 tsutsui if ((iop = device_lookup_private(&iop_cd, i)) == NULL)
526 1.5 ad continue;
527 1.5 ad if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
528 1.5 ad continue;
529 1.5 ad
530 1.5 ad ste->orgid = iop->sc_status.orgid;
531 1.82 chs ste->iopid = device_unit(iop->sc_dev) + 2;
532 1.5 ad ste->segnumber =
533 1.5 ad htole32(le32toh(iop->sc_status.segnumber) & ~4095);
534 1.5 ad ste->iopcaps = iop->sc_status.iopcaps;
535 1.5 ad ste->inboundmsgframesize =
536 1.5 ad iop->sc_status.inboundmframesize;
537 1.5 ad ste->inboundmsgportaddresslow =
538 1.5 ad htole32(iop->sc_memaddr + IOP_REG_IFIFO);
539 1.5 ad ste++;
540 1.5 ad }
541 1.5 ad }
542 1.5 ad
543 1.11 ad /*
544 1.11 ad * Post the system table to the IOP and bring it to the OPERATIONAL
545 1.11 ad * state.
546 1.11 ad */
547 1.5 ad if (iop_systab_set(sc) != 0) {
548 1.82 chs aprint_error_dev(sc->sc_dev, "unable to set system table\n");
549 1.65 ad mutex_exit(&sc->sc_conflock);
550 1.5 ad return;
551 1.5 ad }
552 1.42 ad if (iop_sys_enable(sc) != 0) {
553 1.82 chs aprint_error_dev(sc->sc_dev, "unable to enable system\n");
554 1.65 ad mutex_exit(&sc->sc_conflock);
555 1.5 ad return;
556 1.5 ad }
557 1.5 ad
558 1.5 ad /*
559 1.5 ad * Set up an event handler for this IOP.
560 1.5 ad */
561 1.5 ad sc->sc_eventii.ii_dv = self;
562 1.5 ad sc->sc_eventii.ii_intr = iop_intr_event;
563 1.15 ad sc->sc_eventii.ii_flags = II_NOTCTX | II_UTILITY;
564 1.5 ad sc->sc_eventii.ii_tid = I2O_TID_IOP;
565 1.11 ad iop_initiator_register(sc, &sc->sc_eventii);
566 1.11 ad
567 1.11 ad rv = iop_util_eventreg(sc, &sc->sc_eventii,
568 1.11 ad I2O_EVENT_EXEC_RESOURCE_LIMITS |
569 1.11 ad I2O_EVENT_EXEC_CONNECTION_FAIL |
570 1.11 ad I2O_EVENT_EXEC_ADAPTER_FAULT |
571 1.11 ad I2O_EVENT_EXEC_POWER_FAIL |
572 1.11 ad I2O_EVENT_EXEC_RESET_PENDING |
573 1.11 ad I2O_EVENT_EXEC_RESET_IMMINENT |
574 1.11 ad I2O_EVENT_EXEC_HARDWARE_FAIL |
575 1.11 ad I2O_EVENT_EXEC_XCT_CHANGE |
576 1.11 ad I2O_EVENT_EXEC_DDM_AVAILIBILITY |
577 1.11 ad I2O_EVENT_GEN_DEVICE_RESET |
578 1.11 ad I2O_EVENT_GEN_STATE_CHANGE |
579 1.11 ad I2O_EVENT_GEN_GENERAL_WARNING);
580 1.11 ad if (rv != 0) {
581 1.82 chs aprint_error_dev(sc->sc_dev, "unable to register for events");
582 1.65 ad mutex_exit(&sc->sc_conflock);
583 1.5 ad return;
584 1.5 ad }
585 1.5 ad
586 1.18 ad /*
587 1.18 ad * Attempt to match and attach a product-specific extension.
588 1.18 ad */
589 1.1 ad ia.ia_class = I2O_CLASS_ANY;
590 1.1 ad ia.ia_tid = I2O_TID_IOP;
591 1.49 drochner locs[IOPCF_TID] = I2O_TID_IOP;
592 1.50 drochner config_found_sm_loc(self, "iop", locs, &ia, iop_print,
593 1.50 drochner config_stdsubmatch);
594 1.5 ad
595 1.18 ad /*
596 1.18 ad * Start device configuration.
597 1.18 ad */
598 1.63 ad if ((rv = iop_reconfigure(sc, 0)) == -1)
599 1.82 chs aprint_error_dev(sc->sc_dev, "configure failed (%d)\n", rv);
600 1.65 ad
601 1.9 ad
602 1.11 ad sc->sc_flags |= IOP_ONLINE;
603 1.66 ad rv = kthread_create(PRI_NONE, 0, NULL, iop_reconf_thread, sc,
604 1.82 chs &sc->sc_reconf_thread, "%s", device_xname(sc->sc_dev));
605 1.65 ad mutex_exit(&sc->sc_conflock);
606 1.11 ad if (rv != 0) {
607 1.82 chs aprint_error_dev(sc->sc_dev, "unable to create reconfiguration thread (%d)", rv);
608 1.11 ad return;
609 1.11 ad }
610 1.5 ad }
611 1.5 ad
612 1.5 ad /*
613 1.5 ad * Reconfiguration thread; listens for LCT change notification, and
614 1.14 wiz * initiates re-configuration if received.
615 1.5 ad */
616 1.5 ad static void
617 1.9 ad iop_reconf_thread(void *cookie)
618 1.5 ad {
619 1.5 ad struct iop_softc *sc;
620 1.5 ad struct i2o_lct lct;
621 1.5 ad u_int32_t chgind;
622 1.11 ad int rv;
623 1.5 ad
624 1.5 ad sc = cookie;
625 1.11 ad chgind = sc->sc_chgind + 1;
626 1.5 ad
627 1.5 ad for (;;) {
628 1.11 ad DPRINTF(("%s: async reconfig: requested 0x%08x\n",
629 1.82 chs device_xname(sc->sc_dev), chgind));
630 1.5 ad
631 1.11 ad rv = iop_lct_get0(sc, &lct, sizeof(lct), chgind);
632 1.11 ad
633 1.11 ad DPRINTF(("%s: async reconfig: notified (0x%08x, %d)\n",
634 1.82 chs device_xname(sc->sc_dev), le32toh(lct.changeindicator), rv));
635 1.11 ad
636 1.65 ad mutex_enter(&sc->sc_conflock);
637 1.63 ad if (rv == 0) {
638 1.11 ad iop_reconfigure(sc, le32toh(lct.changeindicator));
639 1.11 ad chgind = sc->sc_chgind + 1;
640 1.5 ad }
641 1.65 ad (void)cv_timedwait(&sc->sc_confcv, &sc->sc_conflock, hz * 5);
642 1.65 ad mutex_exit(&sc->sc_conflock);
643 1.5 ad }
644 1.5 ad }
645 1.5 ad
646 1.5 ad /*
647 1.5 ad * Reconfigure: find new and removed devices.
648 1.5 ad */
649 1.18 ad int
650 1.11 ad iop_reconfigure(struct iop_softc *sc, u_int chgind)
651 1.5 ad {
652 1.5 ad struct iop_msg *im;
653 1.11 ad struct i2o_hba_bus_scan mf;
654 1.5 ad struct i2o_lct_entry *le;
655 1.5 ad struct iop_initiator *ii, *nextii;
656 1.5 ad int rv, tid, i;
657 1.5 ad
658 1.65 ad KASSERT(mutex_owned(&sc->sc_conflock));
659 1.65 ad
660 1.1 ad /*
661 1.5 ad * If the reconfiguration request isn't the result of LCT change
662 1.5 ad * notification, then be more thorough: ask all bus ports to scan
663 1.5 ad * their busses. Wait up to 5 minutes for each bus port to complete
664 1.5 ad * the request.
665 1.1 ad */
666 1.5 ad if (chgind == 0) {
667 1.5 ad if ((rv = iop_lct_get(sc)) != 0) {
668 1.5 ad DPRINTF(("iop_reconfigure: unable to read LCT\n"));
669 1.11 ad return (rv);
670 1.5 ad }
671 1.5 ad
672 1.5 ad le = sc->sc_lct->entry;
673 1.5 ad for (i = 0; i < sc->sc_nlctent; i++, le++) {
674 1.5 ad if ((le16toh(le->classid) & 4095) !=
675 1.5 ad I2O_CLASS_BUS_ADAPTER_PORT)
676 1.5 ad continue;
677 1.15 ad tid = le16toh(le->localtid) & 4095;
678 1.5 ad
679 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
680 1.5 ad
681 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
682 1.11 ad mf.msgfunc = I2O_MSGFUNC(tid, I2O_HBA_BUS_SCAN);
683 1.11 ad mf.msgictx = IOP_ICTX;
684 1.11 ad mf.msgtctx = im->im_tctx;
685 1.5 ad
686 1.82 chs DPRINTF(("%s: scanning bus %d\n", device_xname(sc->sc_dev),
687 1.5 ad tid));
688 1.5 ad
689 1.11 ad rv = iop_msg_post(sc, im, &mf, 5*60*1000);
690 1.11 ad iop_msg_free(sc, im);
691 1.11 ad #ifdef I2ODEBUG
692 1.11 ad if (rv != 0)
693 1.82 chs aprint_error_dev(sc->sc_dev, "bus scan failed\n");
694 1.11 ad #endif
695 1.5 ad }
696 1.11 ad } else if (chgind <= sc->sc_chgind) {
697 1.82 chs DPRINTF(("%s: LCT unchanged (async)\n", device_xname(sc->sc_dev)));
698 1.11 ad return (0);
699 1.5 ad }
700 1.5 ad
701 1.5 ad /* Re-read the LCT and determine if it has changed. */
702 1.5 ad if ((rv = iop_lct_get(sc)) != 0) {
703 1.5 ad DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
704 1.11 ad return (rv);
705 1.5 ad }
706 1.82 chs DPRINTF(("%s: %d LCT entries\n", device_xname(sc->sc_dev), sc->sc_nlctent));
707 1.5 ad
708 1.11 ad chgind = le32toh(sc->sc_lct->changeindicator);
709 1.11 ad if (chgind == sc->sc_chgind) {
710 1.82 chs DPRINTF(("%s: LCT unchanged\n", device_xname(sc->sc_dev)));
711 1.11 ad return (0);
712 1.5 ad }
713 1.82 chs DPRINTF(("%s: LCT changed\n", device_xname(sc->sc_dev)));
714 1.11 ad sc->sc_chgind = chgind;
715 1.5 ad
716 1.5 ad if (sc->sc_tidmap != NULL)
717 1.5 ad free(sc->sc_tidmap, M_DEVBUF);
718 1.5 ad sc->sc_tidmap = malloc(sc->sc_nlctent * sizeof(struct iop_tidmap),
719 1.22 tsutsui M_DEVBUF, M_NOWAIT|M_ZERO);
720 1.5 ad
721 1.11 ad /* Allow 1 queued command per device while we're configuring. */
722 1.11 ad iop_adjqparam(sc, 1);
723 1.11 ad
724 1.11 ad /*
725 1.11 ad * Match and attach child devices. We configure high-level devices
726 1.11 ad * first so that any claims will propagate throughout the LCT,
727 1.11 ad * hopefully masking off aliased devices as a result.
728 1.11 ad *
729 1.11 ad * Re-reading the LCT at this point is a little dangerous, but we'll
730 1.11 ad * trust the IOP (and the operator) to behave itself...
731 1.11 ad */
732 1.11 ad iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
733 1.11 ad IC_CONFIGURE | IC_PRIORITY);
734 1.58 christos if ((rv = iop_lct_get(sc)) != 0) {
735 1.11 ad DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
736 1.58 christos }
737 1.11 ad iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
738 1.11 ad IC_CONFIGURE);
739 1.5 ad
740 1.5 ad for (ii = LIST_FIRST(&sc->sc_iilist); ii != NULL; ii = nextii) {
741 1.11 ad nextii = LIST_NEXT(ii, ii_list);
742 1.5 ad
743 1.5 ad /* Detach devices that were configured, but are now gone. */
744 1.5 ad for (i = 0; i < sc->sc_nlctent; i++)
745 1.5 ad if (ii->ii_tid == sc->sc_tidmap[i].it_tid)
746 1.5 ad break;
747 1.5 ad if (i == sc->sc_nlctent ||
748 1.52 bouyer (sc->sc_tidmap[i].it_flags & IT_CONFIGURED) == 0) {
749 1.5 ad config_detach(ii->ii_dv, DETACH_FORCE);
750 1.52 bouyer continue;
751 1.52 bouyer }
752 1.5 ad
753 1.5 ad /*
754 1.5 ad * Tell initiators that existed before the re-configuration
755 1.5 ad * to re-configure.
756 1.5 ad */
757 1.5 ad if (ii->ii_reconfig == NULL)
758 1.5 ad continue;
759 1.5 ad if ((rv = (*ii->ii_reconfig)(ii->ii_dv)) != 0)
760 1.82 chs aprint_error_dev(sc->sc_dev, "%s failed reconfigure (%d)\n",
761 1.69 cegger device_xname(ii->ii_dv), rv);
762 1.5 ad }
763 1.5 ad
764 1.11 ad /* Re-adjust queue parameters and return. */
765 1.11 ad if (sc->sc_nii != 0)
766 1.11 ad iop_adjqparam(sc, (sc->sc_maxib - sc->sc_nuii - IOP_MF_RESERVE)
767 1.11 ad / sc->sc_nii);
768 1.11 ad
769 1.11 ad return (0);
770 1.1 ad }
771 1.1 ad
772 1.1 ad /*
773 1.5 ad * Configure I2O devices into the system.
774 1.1 ad */
775 1.1 ad static void
776 1.11 ad iop_configure_devices(struct iop_softc *sc, int mask, int maskval)
777 1.1 ad {
778 1.1 ad struct iop_attach_args ia;
779 1.5 ad struct iop_initiator *ii;
780 1.1 ad const struct i2o_lct_entry *le;
781 1.76 cegger device_t dv;
782 1.8 ad int i, j, nent;
783 1.11 ad u_int usertid;
784 1.49 drochner int locs[IOPCF_NLOCS];
785 1.1 ad
786 1.1 ad nent = sc->sc_nlctent;
787 1.1 ad for (i = 0, le = sc->sc_lct->entry; i < nent; i++, le++) {
788 1.15 ad sc->sc_tidmap[i].it_tid = le16toh(le->localtid) & 4095;
789 1.9 ad
790 1.11 ad /* Ignore the device if it's in use. */
791 1.11 ad usertid = le32toh(le->usertid) & 4095;
792 1.11 ad if (usertid != I2O_TID_NONE && usertid != I2O_TID_HOST)
793 1.1 ad continue;
794 1.1 ad
795 1.1 ad ia.ia_class = le16toh(le->classid) & 4095;
796 1.9 ad ia.ia_tid = sc->sc_tidmap[i].it_tid;
797 1.8 ad
798 1.8 ad /* Ignore uninteresting devices. */
799 1.8 ad for (j = 0; j < sizeof(iop_class) / sizeof(iop_class[0]); j++)
800 1.8 ad if (iop_class[j].ic_class == ia.ia_class)
801 1.8 ad break;
802 1.8 ad if (j < sizeof(iop_class) / sizeof(iop_class[0]) &&
803 1.11 ad (iop_class[j].ic_flags & mask) != maskval)
804 1.8 ad continue;
805 1.1 ad
806 1.1 ad /*
807 1.5 ad * Try to configure the device only if it's not already
808 1.5 ad * configured.
809 1.1 ad */
810 1.7 ad LIST_FOREACH(ii, &sc->sc_iilist, ii_list) {
811 1.9 ad if (ia.ia_tid == ii->ii_tid) {
812 1.9 ad sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
813 1.9 ad strcpy(sc->sc_tidmap[i].it_dvname,
814 1.69 cegger device_xname(ii->ii_dv));
815 1.11 ad break;
816 1.9 ad }
817 1.7 ad }
818 1.5 ad if (ii != NULL)
819 1.5 ad continue;
820 1.5 ad
821 1.49 drochner locs[IOPCF_TID] = ia.ia_tid;
822 1.44 drochner
823 1.82 chs dv = config_found_sm_loc(sc->sc_dev, "iop", locs, &ia,
824 1.50 drochner iop_print, config_stdsubmatch);
825 1.9 ad if (dv != NULL) {
826 1.11 ad sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
827 1.69 cegger strcpy(sc->sc_tidmap[i].it_dvname, device_xname(dv));
828 1.9 ad }
829 1.1 ad }
830 1.1 ad }
831 1.1 ad
832 1.11 ad /*
833 1.11 ad * Adjust queue parameters for all child devices.
834 1.11 ad */
835 1.11 ad static void
836 1.11 ad iop_adjqparam(struct iop_softc *sc, int mpi)
837 1.11 ad {
838 1.11 ad struct iop_initiator *ii;
839 1.11 ad
840 1.11 ad LIST_FOREACH(ii, &sc->sc_iilist, ii_list)
841 1.11 ad if (ii->ii_adjqparam != NULL)
842 1.11 ad (*ii->ii_adjqparam)(ii->ii_dv, mpi);
843 1.11 ad }
844 1.11 ad
845 1.1 ad static void
846 1.43 itojun iop_devinfo(int class, char *devinfo, size_t l)
847 1.1 ad {
848 1.1 ad int i;
849 1.1 ad
850 1.1 ad for (i = 0; i < sizeof(iop_class) / sizeof(iop_class[0]); i++)
851 1.1 ad if (class == iop_class[i].ic_class)
852 1.1 ad break;
853 1.47 perry
854 1.1 ad if (i == sizeof(iop_class) / sizeof(iop_class[0]))
855 1.43 itojun snprintf(devinfo, l, "device (class 0x%x)", class);
856 1.1 ad else
857 1.43 itojun strlcpy(devinfo, iop_class[i].ic_caption, l);
858 1.1 ad }
859 1.1 ad
860 1.1 ad static int
861 1.1 ad iop_print(void *aux, const char *pnp)
862 1.1 ad {
863 1.1 ad struct iop_attach_args *ia;
864 1.1 ad char devinfo[256];
865 1.1 ad
866 1.1 ad ia = aux;
867 1.1 ad
868 1.1 ad if (pnp != NULL) {
869 1.43 itojun iop_devinfo(ia->ia_class, devinfo, sizeof(devinfo));
870 1.33 thorpej aprint_normal("%s at %s", devinfo, pnp);
871 1.1 ad }
872 1.33 thorpej aprint_normal(" tid %d", ia->ia_tid);
873 1.1 ad return (UNCONF);
874 1.1 ad }
875 1.1 ad
876 1.1 ad /*
877 1.1 ad * Shut down all configured IOPs.
878 1.47 perry */
879 1.1 ad static void
880 1.61 christos iop_shutdown(void *junk)
881 1.1 ad {
882 1.1 ad struct iop_softc *sc;
883 1.1 ad int i;
884 1.1 ad
885 1.11 ad printf("shutting down iop devices...");
886 1.1 ad
887 1.1 ad for (i = 0; i < iop_cd.cd_ndevs; i++) {
888 1.73 tsutsui if ((sc = device_lookup_private(&iop_cd, i)) == NULL)
889 1.1 ad continue;
890 1.5 ad if ((sc->sc_flags & IOP_ONLINE) == 0)
891 1.5 ad continue;
892 1.27 ad
893 1.5 ad iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_QUIESCE, IOP_ICTX,
894 1.12 ad 0, 5000);
895 1.27 ad
896 1.27 ad if (le16toh(sc->sc_status.orgid) != I2O_ORG_AMI) {
897 1.27 ad /*
898 1.27 ad * Some AMI firmware revisions will go to sleep and
899 1.27 ad * never come back after this.
900 1.27 ad */
901 1.27 ad iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_IOP_CLEAR,
902 1.27 ad IOP_ICTX, 0, 1000);
903 1.27 ad }
904 1.1 ad }
905 1.1 ad
906 1.1 ad /* Wait. Some boards could still be flushing, stupidly enough. */
907 1.1 ad delay(5000*1000);
908 1.18 ad printf(" done\n");
909 1.1 ad }
910 1.1 ad
911 1.1 ad /*
912 1.11 ad * Retrieve IOP status.
913 1.1 ad */
914 1.18 ad int
915 1.11 ad iop_status_get(struct iop_softc *sc, int nosleep)
916 1.1 ad {
917 1.11 ad struct i2o_exec_status_get mf;
918 1.15 ad struct i2o_status *st;
919 1.15 ad paddr_t pa;
920 1.11 ad int rv, i;
921 1.1 ad
922 1.75 mhitch pa = sc->sc_scr_dmamap->dm_segs[0].ds_addr;
923 1.15 ad st = (struct i2o_status *)sc->sc_scr;
924 1.15 ad
925 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_exec_status_get);
926 1.11 ad mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_STATUS_GET);
927 1.11 ad mf.reserved[0] = 0;
928 1.11 ad mf.reserved[1] = 0;
929 1.11 ad mf.reserved[2] = 0;
930 1.11 ad mf.reserved[3] = 0;
931 1.15 ad mf.addrlow = (u_int32_t)pa;
932 1.15 ad mf.addrhigh = (u_int32_t)((u_int64_t)pa >> 32);
933 1.11 ad mf.length = sizeof(sc->sc_status);
934 1.1 ad
935 1.72 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*st),
936 1.72 ad BUS_DMASYNC_PREWRITE);
937 1.15 ad memset(st, 0, sizeof(*st));
938 1.15 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*st),
939 1.78 asau BUS_DMASYNC_POSTWRITE);
940 1.1 ad
941 1.11 ad if ((rv = iop_post(sc, (u_int32_t *)&mf)) != 0)
942 1.1 ad return (rv);
943 1.1 ad
944 1.72 ad for (i = 100; i != 0; i--) {
945 1.15 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0,
946 1.15 ad sizeof(*st), BUS_DMASYNC_POSTREAD);
947 1.15 ad if (st->syncbyte == 0xff)
948 1.11 ad break;
949 1.11 ad if (nosleep)
950 1.11 ad DELAY(100*1000);
951 1.11 ad else
952 1.65 ad kpause("iopstat", false, hz / 10, NULL);
953 1.11 ad }
954 1.1 ad
955 1.21 ad if (st->syncbyte != 0xff) {
956 1.82 chs aprint_error_dev(sc->sc_dev, "STATUS_GET timed out\n");
957 1.11 ad rv = EIO;
958 1.21 ad } else {
959 1.15 ad memcpy(&sc->sc_status, st, sizeof(sc->sc_status));
960 1.11 ad rv = 0;
961 1.15 ad }
962 1.15 ad
963 1.11 ad return (rv);
964 1.1 ad }
965 1.1 ad
966 1.1 ad /*
967 1.17 wiz * Initialize and populate the IOP's outbound FIFO.
968 1.1 ad */
969 1.1 ad static int
970 1.1 ad iop_ofifo_init(struct iop_softc *sc)
971 1.1 ad {
972 1.1 ad bus_addr_t addr;
973 1.5 ad bus_dma_segment_t seg;
974 1.11 ad struct i2o_exec_outbound_init *mf;
975 1.5 ad int i, rseg, rv;
976 1.15 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)], *sw;
977 1.1 ad
978 1.15 ad sw = (u_int32_t *)sc->sc_scr;
979 1.1 ad
980 1.11 ad mf = (struct i2o_exec_outbound_init *)mb;
981 1.11 ad mf->msgflags = I2O_MSGFLAGS(i2o_exec_outbound_init);
982 1.11 ad mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_OUTBOUND_INIT);
983 1.11 ad mf->msgictx = IOP_ICTX;
984 1.15 ad mf->msgtctx = 0;
985 1.11 ad mf->pagesize = PAGE_SIZE;
986 1.19 ad mf->flags = IOP_INIT_CODE | ((sc->sc_framesize >> 2) << 16);
987 1.1 ad
988 1.5 ad /*
989 1.5 ad * The I2O spec says that there are two SGLs: one for the status
990 1.5 ad * word, and one for a list of discarded MFAs. It continues to say
991 1.5 ad * that if you don't want to get the list of MFAs, an IGNORE SGL is
992 1.11 ad * necessary; this isn't the case (and is in fact a bad thing).
993 1.5 ad */
994 1.15 ad mb[sizeof(*mf) / sizeof(u_int32_t) + 0] = sizeof(*sw) |
995 1.15 ad I2O_SGL_SIMPLE | I2O_SGL_END_BUFFER | I2O_SGL_END;
996 1.15 ad mb[sizeof(*mf) / sizeof(u_int32_t) + 1] =
997 1.75 mhitch (u_int32_t)sc->sc_scr_dmamap->dm_segs[0].ds_addr;
998 1.15 ad mb[0] += 2 << 16;
999 1.15 ad
1000 1.72 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1001 1.80 bouyer BUS_DMASYNC_POSTWRITE);
1002 1.15 ad *sw = 0;
1003 1.15 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1004 1.80 bouyer BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
1005 1.15 ad
1006 1.15 ad if ((rv = iop_post(sc, mb)) != 0)
1007 1.1 ad return (rv);
1008 1.1 ad
1009 1.15 ad POLL(5000,
1010 1.15 ad (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1011 1.80 bouyer BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD),
1012 1.15 ad *sw == htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)));
1013 1.15 ad
1014 1.15 ad if (*sw != htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)) {
1015 1.82 chs aprint_error_dev(sc->sc_dev, "outbound FIFO init failed (%d)\n",
1016 1.69 cegger le32toh(*sw));
1017 1.5 ad return (EIO);
1018 1.1 ad }
1019 1.1 ad
1020 1.11 ad /* Allocate DMA safe memory for the reply frames. */
1021 1.1 ad if (sc->sc_rep_phys == 0) {
1022 1.19 ad sc->sc_rep_size = sc->sc_maxob * sc->sc_framesize;
1023 1.5 ad
1024 1.5 ad rv = bus_dmamem_alloc(sc->sc_dmat, sc->sc_rep_size, PAGE_SIZE,
1025 1.5 ad 0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
1026 1.5 ad if (rv != 0) {
1027 1.82 chs aprint_error_dev(sc->sc_dev, "DMA alloc = %d\n",
1028 1.5 ad rv);
1029 1.5 ad return (rv);
1030 1.5 ad }
1031 1.5 ad
1032 1.5 ad rv = bus_dmamem_map(sc->sc_dmat, &seg, rseg, sc->sc_rep_size,
1033 1.5 ad &sc->sc_rep, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
1034 1.5 ad if (rv != 0) {
1035 1.82 chs aprint_error_dev(sc->sc_dev, "DMA map = %d\n", rv);
1036 1.5 ad return (rv);
1037 1.5 ad }
1038 1.5 ad
1039 1.5 ad rv = bus_dmamap_create(sc->sc_dmat, sc->sc_rep_size, 1,
1040 1.5 ad sc->sc_rep_size, 0, BUS_DMA_NOWAIT, &sc->sc_rep_dmamap);
1041 1.5 ad if (rv != 0) {
1042 1.82 chs aprint_error_dev(sc->sc_dev, "DMA create = %d\n", rv);
1043 1.5 ad return (rv);
1044 1.5 ad }
1045 1.5 ad
1046 1.15 ad rv = bus_dmamap_load(sc->sc_dmat, sc->sc_rep_dmamap,
1047 1.15 ad sc->sc_rep, sc->sc_rep_size, NULL, BUS_DMA_NOWAIT);
1048 1.5 ad if (rv != 0) {
1049 1.82 chs aprint_error_dev(sc->sc_dev, "DMA load = %d\n", rv);
1050 1.5 ad return (rv);
1051 1.5 ad }
1052 1.5 ad
1053 1.5 ad sc->sc_rep_phys = sc->sc_rep_dmamap->dm_segs[0].ds_addr;
1054 1.65 ad
1055 1.65 ad /* Now safe to sync the reply map. */
1056 1.65 ad sc->sc_curib = 0;
1057 1.1 ad }
1058 1.1 ad
1059 1.1 ad /* Populate the outbound FIFO. */
1060 1.11 ad for (i = sc->sc_maxob, addr = sc->sc_rep_phys; i != 0; i--) {
1061 1.5 ad iop_outl(sc, IOP_REG_OFIFO, (u_int32_t)addr);
1062 1.19 ad addr += sc->sc_framesize;
1063 1.1 ad }
1064 1.1 ad
1065 1.1 ad return (0);
1066 1.1 ad }
1067 1.1 ad
1068 1.1 ad /*
1069 1.1 ad * Read the specified number of bytes from the IOP's hardware resource table.
1070 1.1 ad */
1071 1.1 ad static int
1072 1.1 ad iop_hrt_get0(struct iop_softc *sc, struct i2o_hrt *hrt, int size)
1073 1.1 ad {
1074 1.1 ad struct iop_msg *im;
1075 1.1 ad int rv;
1076 1.11 ad struct i2o_exec_hrt_get *mf;
1077 1.11 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1078 1.1 ad
1079 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
1080 1.11 ad mf = (struct i2o_exec_hrt_get *)mb;
1081 1.11 ad mf->msgflags = I2O_MSGFLAGS(i2o_exec_hrt_get);
1082 1.11 ad mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_HRT_GET);
1083 1.11 ad mf->msgictx = IOP_ICTX;
1084 1.11 ad mf->msgtctx = im->im_tctx;
1085 1.1 ad
1086 1.15 ad iop_msg_map(sc, im, mb, hrt, size, 0, NULL);
1087 1.11 ad rv = iop_msg_post(sc, im, mb, 30000);
1088 1.1 ad iop_msg_unmap(sc, im);
1089 1.11 ad iop_msg_free(sc, im);
1090 1.1 ad return (rv);
1091 1.1 ad }
1092 1.1 ad
1093 1.1 ad /*
1094 1.5 ad * Read the IOP's hardware resource table.
1095 1.1 ad */
1096 1.1 ad static int
1097 1.1 ad iop_hrt_get(struct iop_softc *sc)
1098 1.1 ad {
1099 1.1 ad struct i2o_hrt hrthdr, *hrt;
1100 1.1 ad int size, rv;
1101 1.1 ad
1102 1.11 ad rv = iop_hrt_get0(sc, &hrthdr, sizeof(hrthdr));
1103 1.11 ad if (rv != 0)
1104 1.1 ad return (rv);
1105 1.1 ad
1106 1.82 chs DPRINTF(("%s: %d hrt entries\n", device_xname(sc->sc_dev),
1107 1.5 ad le16toh(hrthdr.numentries)));
1108 1.5 ad
1109 1.47 perry size = sizeof(struct i2o_hrt) +
1110 1.15 ad (le16toh(hrthdr.numentries) - 1) * sizeof(struct i2o_hrt_entry);
1111 1.1 ad hrt = (struct i2o_hrt *)malloc(size, M_DEVBUF, M_NOWAIT);
1112 1.1 ad
1113 1.1 ad if ((rv = iop_hrt_get0(sc, hrt, size)) != 0) {
1114 1.1 ad free(hrt, M_DEVBUF);
1115 1.1 ad return (rv);
1116 1.1 ad }
1117 1.1 ad
1118 1.1 ad if (sc->sc_hrt != NULL)
1119 1.1 ad free(sc->sc_hrt, M_DEVBUF);
1120 1.1 ad sc->sc_hrt = hrt;
1121 1.1 ad return (0);
1122 1.1 ad }
1123 1.1 ad
1124 1.1 ad /*
1125 1.1 ad * Request the specified number of bytes from the IOP's logical
1126 1.5 ad * configuration table. If a change indicator is specified, this
1127 1.11 ad * is a verbatim notification request, so the caller is prepared
1128 1.5 ad * to wait indefinitely.
1129 1.1 ad */
1130 1.1 ad static int
1131 1.5 ad iop_lct_get0(struct iop_softc *sc, struct i2o_lct *lct, int size,
1132 1.5 ad u_int32_t chgind)
1133 1.1 ad {
1134 1.1 ad struct iop_msg *im;
1135 1.11 ad struct i2o_exec_lct_notify *mf;
1136 1.1 ad int rv;
1137 1.11 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1138 1.1 ad
1139 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
1140 1.1 ad memset(lct, 0, size);
1141 1.1 ad
1142 1.11 ad mf = (struct i2o_exec_lct_notify *)mb;
1143 1.11 ad mf->msgflags = I2O_MSGFLAGS(i2o_exec_lct_notify);
1144 1.11 ad mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_LCT_NOTIFY);
1145 1.11 ad mf->msgictx = IOP_ICTX;
1146 1.11 ad mf->msgtctx = im->im_tctx;
1147 1.11 ad mf->classid = I2O_CLASS_ANY;
1148 1.11 ad mf->changeindicator = chgind;
1149 1.5 ad
1150 1.9 ad #ifdef I2ODEBUG
1151 1.9 ad printf("iop_lct_get0: reading LCT");
1152 1.9 ad if (chgind != 0)
1153 1.9 ad printf(" (async)");
1154 1.9 ad printf("\n");
1155 1.9 ad #endif
1156 1.1 ad
1157 1.15 ad iop_msg_map(sc, im, mb, lct, size, 0, NULL);
1158 1.11 ad rv = iop_msg_post(sc, im, mb, (chgind == 0 ? 120*1000 : 0));
1159 1.1 ad iop_msg_unmap(sc, im);
1160 1.11 ad iop_msg_free(sc, im);
1161 1.1 ad return (rv);
1162 1.1 ad }
1163 1.1 ad
1164 1.1 ad /*
1165 1.6 ad * Read the IOP's logical configuration table.
1166 1.1 ad */
1167 1.1 ad int
1168 1.1 ad iop_lct_get(struct iop_softc *sc)
1169 1.1 ad {
1170 1.5 ad int esize, size, rv;
1171 1.5 ad struct i2o_lct *lct;
1172 1.1 ad
1173 1.5 ad esize = le32toh(sc->sc_status.expectedlctsize);
1174 1.5 ad lct = (struct i2o_lct *)malloc(esize, M_DEVBUF, M_WAITOK);
1175 1.5 ad if (lct == NULL)
1176 1.1 ad return (ENOMEM);
1177 1.1 ad
1178 1.5 ad if ((rv = iop_lct_get0(sc, lct, esize, 0)) != 0) {
1179 1.1 ad free(lct, M_DEVBUF);
1180 1.1 ad return (rv);
1181 1.1 ad }
1182 1.1 ad
1183 1.5 ad size = le16toh(lct->tablesize) << 2;
1184 1.5 ad if (esize != size) {
1185 1.1 ad free(lct, M_DEVBUF);
1186 1.5 ad lct = (struct i2o_lct *)malloc(size, M_DEVBUF, M_WAITOK);
1187 1.5 ad if (lct == NULL)
1188 1.5 ad return (ENOMEM);
1189 1.5 ad
1190 1.5 ad if ((rv = iop_lct_get0(sc, lct, size, 0)) != 0) {
1191 1.5 ad free(lct, M_DEVBUF);
1192 1.5 ad return (rv);
1193 1.5 ad }
1194 1.1 ad }
1195 1.5 ad
1196 1.5 ad /* Swap in the new LCT. */
1197 1.1 ad if (sc->sc_lct != NULL)
1198 1.1 ad free(sc->sc_lct, M_DEVBUF);
1199 1.1 ad sc->sc_lct = lct;
1200 1.1 ad sc->sc_nlctent = ((le16toh(sc->sc_lct->tablesize) << 2) -
1201 1.1 ad sizeof(struct i2o_lct) + sizeof(struct i2o_lct_entry)) /
1202 1.1 ad sizeof(struct i2o_lct_entry);
1203 1.1 ad return (0);
1204 1.1 ad }
1205 1.1 ad
1206 1.1 ad /*
1207 1.42 ad * Post a SYS_ENABLE message to the adapter.
1208 1.42 ad */
1209 1.42 ad int
1210 1.42 ad iop_sys_enable(struct iop_softc *sc)
1211 1.42 ad {
1212 1.42 ad struct iop_msg *im;
1213 1.42 ad struct i2o_msg mf;
1214 1.42 ad int rv;
1215 1.42 ad
1216 1.42 ad im = iop_msg_alloc(sc, IM_WAIT | IM_NOSTATUS);
1217 1.42 ad
1218 1.42 ad mf.msgflags = I2O_MSGFLAGS(i2o_msg);
1219 1.42 ad mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_ENABLE);
1220 1.42 ad mf.msgictx = IOP_ICTX;
1221 1.42 ad mf.msgtctx = im->im_tctx;
1222 1.42 ad
1223 1.42 ad rv = iop_msg_post(sc, im, &mf, 30000);
1224 1.42 ad if (rv == 0) {
1225 1.42 ad if ((im->im_flags & IM_FAIL) != 0)
1226 1.42 ad rv = ENXIO;
1227 1.42 ad else if (im->im_reqstatus == I2O_STATUS_SUCCESS ||
1228 1.42 ad (im->im_reqstatus == I2O_STATUS_ERROR_NO_DATA_XFER &&
1229 1.42 ad im->im_detstatus == I2O_DSC_INVALID_REQUEST))
1230 1.42 ad rv = 0;
1231 1.42 ad else
1232 1.42 ad rv = EIO;
1233 1.42 ad }
1234 1.42 ad
1235 1.42 ad iop_msg_free(sc, im);
1236 1.42 ad return (rv);
1237 1.42 ad }
1238 1.42 ad
1239 1.42 ad /*
1240 1.11 ad * Request the specified parameter group from the target. If an initiator
1241 1.11 ad * is specified (a) don't wait for the operation to complete, but instead
1242 1.11 ad * let the initiator's interrupt handler deal with the reply and (b) place a
1243 1.11 ad * pointer to the parameter group op in the wrapper's `im_dvcontext' field.
1244 1.1 ad */
1245 1.1 ad int
1246 1.16 ad iop_field_get_all(struct iop_softc *sc, int tid, int group, void *buf,
1247 1.16 ad int size, struct iop_initiator *ii)
1248 1.1 ad {
1249 1.1 ad struct iop_msg *im;
1250 1.11 ad struct i2o_util_params_op *mf;
1251 1.16 ad int rv;
1252 1.11 ad struct iop_pgop *pgop;
1253 1.11 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1254 1.1 ad
1255 1.15 ad im = iop_msg_alloc(sc, (ii == NULL ? IM_WAIT : 0) | IM_NOSTATUS);
1256 1.11 ad if ((pgop = malloc(sizeof(*pgop), M_DEVBUF, M_WAITOK)) == NULL) {
1257 1.11 ad iop_msg_free(sc, im);
1258 1.11 ad return (ENOMEM);
1259 1.11 ad }
1260 1.11 ad im->im_dvcontext = pgop;
1261 1.1 ad
1262 1.11 ad mf = (struct i2o_util_params_op *)mb;
1263 1.11 ad mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
1264 1.16 ad mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_GET);
1265 1.11 ad mf->msgictx = IOP_ICTX;
1266 1.11 ad mf->msgtctx = im->im_tctx;
1267 1.11 ad mf->flags = 0;
1268 1.11 ad
1269 1.11 ad pgop->olh.count = htole16(1);
1270 1.11 ad pgop->olh.reserved = htole16(0);
1271 1.16 ad pgop->oat.operation = htole16(I2O_PARAMS_OP_FIELD_GET);
1272 1.11 ad pgop->oat.fieldcount = htole16(0xffff);
1273 1.11 ad pgop->oat.group = htole16(group);
1274 1.11 ad
1275 1.5 ad memset(buf, 0, size);
1276 1.15 ad iop_msg_map(sc, im, mb, pgop, sizeof(*pgop), 1, NULL);
1277 1.16 ad iop_msg_map(sc, im, mb, buf, size, 0, NULL);
1278 1.11 ad rv = iop_msg_post(sc, im, mb, (ii == NULL ? 30000 : 0));
1279 1.11 ad
1280 1.11 ad /* Detect errors; let partial transfers to count as success. */
1281 1.11 ad if (ii == NULL && rv == 0) {
1282 1.42 ad if (im->im_reqstatus == I2O_STATUS_ERROR_PARTIAL_XFER &&
1283 1.42 ad im->im_detstatus == I2O_DSC_UNKNOWN_ERROR)
1284 1.11 ad rv = 0;
1285 1.11 ad else
1286 1.42 ad rv = (im->im_reqstatus != 0 ? EIO : 0);
1287 1.16 ad
1288 1.16 ad if (rv != 0)
1289 1.16 ad printf("%s: FIELD_GET failed for tid %d group %d\n",
1290 1.82 chs device_xname(sc->sc_dev), tid, group);
1291 1.11 ad }
1292 1.11 ad
1293 1.11 ad if (ii == NULL || rv != 0) {
1294 1.11 ad iop_msg_unmap(sc, im);
1295 1.11 ad iop_msg_free(sc, im);
1296 1.11 ad free(pgop, M_DEVBUF);
1297 1.11 ad }
1298 1.1 ad
1299 1.1 ad return (rv);
1300 1.11 ad }
1301 1.1 ad
1302 1.1 ad /*
1303 1.16 ad * Set a single field in a scalar parameter group.
1304 1.16 ad */
1305 1.16 ad int
1306 1.16 ad iop_field_set(struct iop_softc *sc, int tid, int group, void *buf,
1307 1.16 ad int size, int field)
1308 1.16 ad {
1309 1.16 ad struct iop_msg *im;
1310 1.16 ad struct i2o_util_params_op *mf;
1311 1.16 ad struct iop_pgop *pgop;
1312 1.16 ad int rv, totsize;
1313 1.16 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1314 1.16 ad
1315 1.16 ad totsize = sizeof(*pgop) + size;
1316 1.16 ad
1317 1.16 ad im = iop_msg_alloc(sc, IM_WAIT);
1318 1.16 ad if ((pgop = malloc(totsize, M_DEVBUF, M_WAITOK)) == NULL) {
1319 1.16 ad iop_msg_free(sc, im);
1320 1.16 ad return (ENOMEM);
1321 1.16 ad }
1322 1.16 ad
1323 1.16 ad mf = (struct i2o_util_params_op *)mb;
1324 1.16 ad mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
1325 1.16 ad mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
1326 1.16 ad mf->msgictx = IOP_ICTX;
1327 1.16 ad mf->msgtctx = im->im_tctx;
1328 1.16 ad mf->flags = 0;
1329 1.16 ad
1330 1.16 ad pgop->olh.count = htole16(1);
1331 1.16 ad pgop->olh.reserved = htole16(0);
1332 1.16 ad pgop->oat.operation = htole16(I2O_PARAMS_OP_FIELD_SET);
1333 1.16 ad pgop->oat.fieldcount = htole16(1);
1334 1.16 ad pgop->oat.group = htole16(group);
1335 1.16 ad pgop->oat.fields[0] = htole16(field);
1336 1.16 ad memcpy(pgop + 1, buf, size);
1337 1.16 ad
1338 1.16 ad iop_msg_map(sc, im, mb, pgop, totsize, 1, NULL);
1339 1.16 ad rv = iop_msg_post(sc, im, mb, 30000);
1340 1.16 ad if (rv != 0)
1341 1.82 chs aprint_error_dev(sc->sc_dev, "FIELD_SET failed for tid %d group %d\n",
1342 1.69 cegger tid, group);
1343 1.16 ad
1344 1.16 ad iop_msg_unmap(sc, im);
1345 1.16 ad iop_msg_free(sc, im);
1346 1.16 ad free(pgop, M_DEVBUF);
1347 1.16 ad return (rv);
1348 1.16 ad }
1349 1.16 ad
1350 1.16 ad /*
1351 1.16 ad * Delete all rows in a tablular parameter group.
1352 1.16 ad */
1353 1.16 ad int
1354 1.16 ad iop_table_clear(struct iop_softc *sc, int tid, int group)
1355 1.16 ad {
1356 1.16 ad struct iop_msg *im;
1357 1.16 ad struct i2o_util_params_op *mf;
1358 1.16 ad struct iop_pgop pgop;
1359 1.16 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1360 1.16 ad int rv;
1361 1.16 ad
1362 1.16 ad im = iop_msg_alloc(sc, IM_WAIT);
1363 1.16 ad
1364 1.16 ad mf = (struct i2o_util_params_op *)mb;
1365 1.16 ad mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
1366 1.16 ad mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
1367 1.16 ad mf->msgictx = IOP_ICTX;
1368 1.16 ad mf->msgtctx = im->im_tctx;
1369 1.16 ad mf->flags = 0;
1370 1.16 ad
1371 1.16 ad pgop.olh.count = htole16(1);
1372 1.16 ad pgop.olh.reserved = htole16(0);
1373 1.16 ad pgop.oat.operation = htole16(I2O_PARAMS_OP_TABLE_CLEAR);
1374 1.16 ad pgop.oat.fieldcount = htole16(0);
1375 1.16 ad pgop.oat.group = htole16(group);
1376 1.16 ad pgop.oat.fields[0] = htole16(0);
1377 1.16 ad
1378 1.16 ad iop_msg_map(sc, im, mb, &pgop, sizeof(pgop), 1, NULL);
1379 1.16 ad rv = iop_msg_post(sc, im, mb, 30000);
1380 1.16 ad if (rv != 0)
1381 1.82 chs aprint_error_dev(sc->sc_dev, "TABLE_CLEAR failed for tid %d group %d\n",
1382 1.69 cegger tid, group);
1383 1.16 ad
1384 1.16 ad iop_msg_unmap(sc, im);
1385 1.16 ad iop_msg_free(sc, im);
1386 1.16 ad return (rv);
1387 1.16 ad }
1388 1.16 ad
1389 1.16 ad /*
1390 1.16 ad * Add a single row to a tabular parameter group. The row can have only one
1391 1.16 ad * field.
1392 1.16 ad */
1393 1.16 ad int
1394 1.16 ad iop_table_add_row(struct iop_softc *sc, int tid, int group, void *buf,
1395 1.16 ad int size, int row)
1396 1.16 ad {
1397 1.16 ad struct iop_msg *im;
1398 1.16 ad struct i2o_util_params_op *mf;
1399 1.16 ad struct iop_pgop *pgop;
1400 1.16 ad int rv, totsize;
1401 1.16 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1402 1.16 ad
1403 1.16 ad totsize = sizeof(*pgop) + sizeof(u_int16_t) * 2 + size;
1404 1.16 ad
1405 1.16 ad im = iop_msg_alloc(sc, IM_WAIT);
1406 1.16 ad if ((pgop = malloc(totsize, M_DEVBUF, M_WAITOK)) == NULL) {
1407 1.16 ad iop_msg_free(sc, im);
1408 1.16 ad return (ENOMEM);
1409 1.16 ad }
1410 1.16 ad
1411 1.16 ad mf = (struct i2o_util_params_op *)mb;
1412 1.16 ad mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
1413 1.16 ad mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
1414 1.16 ad mf->msgictx = IOP_ICTX;
1415 1.16 ad mf->msgtctx = im->im_tctx;
1416 1.16 ad mf->flags = 0;
1417 1.16 ad
1418 1.16 ad pgop->olh.count = htole16(1);
1419 1.16 ad pgop->olh.reserved = htole16(0);
1420 1.16 ad pgop->oat.operation = htole16(I2O_PARAMS_OP_ROW_ADD);
1421 1.16 ad pgop->oat.fieldcount = htole16(1);
1422 1.16 ad pgop->oat.group = htole16(group);
1423 1.16 ad pgop->oat.fields[0] = htole16(0); /* FieldIdx */
1424 1.16 ad pgop->oat.fields[1] = htole16(1); /* RowCount */
1425 1.16 ad pgop->oat.fields[2] = htole16(row); /* KeyValue */
1426 1.16 ad memcpy(&pgop->oat.fields[3], buf, size);
1427 1.16 ad
1428 1.16 ad iop_msg_map(sc, im, mb, pgop, totsize, 1, NULL);
1429 1.16 ad rv = iop_msg_post(sc, im, mb, 30000);
1430 1.16 ad if (rv != 0)
1431 1.82 chs aprint_error_dev(sc->sc_dev, "ADD_ROW failed for tid %d group %d row %d\n",
1432 1.69 cegger tid, group, row);
1433 1.16 ad
1434 1.16 ad iop_msg_unmap(sc, im);
1435 1.16 ad iop_msg_free(sc, im);
1436 1.16 ad free(pgop, M_DEVBUF);
1437 1.16 ad return (rv);
1438 1.16 ad }
1439 1.16 ad
1440 1.16 ad /*
1441 1.5 ad * Execute a simple command (no parameters).
1442 1.1 ad */
1443 1.1 ad int
1444 1.5 ad iop_simple_cmd(struct iop_softc *sc, int tid, int function, int ictx,
1445 1.5 ad int async, int timo)
1446 1.1 ad {
1447 1.1 ad struct iop_msg *im;
1448 1.11 ad struct i2o_msg mf;
1449 1.5 ad int rv, fl;
1450 1.1 ad
1451 1.11 ad fl = (async != 0 ? IM_WAIT : IM_POLL);
1452 1.15 ad im = iop_msg_alloc(sc, fl);
1453 1.1 ad
1454 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_msg);
1455 1.11 ad mf.msgfunc = I2O_MSGFUNC(tid, function);
1456 1.11 ad mf.msgictx = ictx;
1457 1.11 ad mf.msgtctx = im->im_tctx;
1458 1.1 ad
1459 1.11 ad rv = iop_msg_post(sc, im, &mf, timo);
1460 1.11 ad iop_msg_free(sc, im);
1461 1.1 ad return (rv);
1462 1.1 ad }
1463 1.1 ad
1464 1.1 ad /*
1465 1.5 ad * Post the system table to the IOP.
1466 1.1 ad */
1467 1.1 ad static int
1468 1.1 ad iop_systab_set(struct iop_softc *sc)
1469 1.1 ad {
1470 1.11 ad struct i2o_exec_sys_tab_set *mf;
1471 1.1 ad struct iop_msg *im;
1472 1.13 ad bus_space_handle_t bsh;
1473 1.13 ad bus_addr_t boo;
1474 1.1 ad u_int32_t mema[2], ioa[2];
1475 1.1 ad int rv;
1476 1.11 ad u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
1477 1.1 ad
1478 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
1479 1.1 ad
1480 1.11 ad mf = (struct i2o_exec_sys_tab_set *)mb;
1481 1.11 ad mf->msgflags = I2O_MSGFLAGS(i2o_exec_sys_tab_set);
1482 1.11 ad mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_TAB_SET);
1483 1.11 ad mf->msgictx = IOP_ICTX;
1484 1.11 ad mf->msgtctx = im->im_tctx;
1485 1.82 chs mf->iopid = (device_unit(sc->sc_dev) + 2) << 12;
1486 1.11 ad mf->segnumber = 0;
1487 1.5 ad
1488 1.13 ad mema[1] = sc->sc_status.desiredprivmemsize;
1489 1.13 ad ioa[1] = sc->sc_status.desiredpriviosize;
1490 1.13 ad
1491 1.13 ad if (mema[1] != 0) {
1492 1.13 ad rv = bus_space_alloc(sc->sc_bus_memt, 0, 0xffffffff,
1493 1.13 ad le32toh(mema[1]), PAGE_SIZE, 0, 0, &boo, &bsh);
1494 1.13 ad mema[0] = htole32(boo);
1495 1.13 ad if (rv != 0) {
1496 1.82 chs aprint_error_dev(sc->sc_dev, "can't alloc priv mem space, err = %d\n", rv);
1497 1.13 ad mema[0] = 0;
1498 1.13 ad mema[1] = 0;
1499 1.13 ad }
1500 1.13 ad }
1501 1.13 ad
1502 1.13 ad if (ioa[1] != 0) {
1503 1.13 ad rv = bus_space_alloc(sc->sc_bus_iot, 0, 0xffff,
1504 1.13 ad le32toh(ioa[1]), 0, 0, 0, &boo, &bsh);
1505 1.13 ad ioa[0] = htole32(boo);
1506 1.13 ad if (rv != 0) {
1507 1.82 chs aprint_error_dev(sc->sc_dev, "can't alloc priv i/o space, err = %d\n", rv);
1508 1.13 ad ioa[0] = 0;
1509 1.13 ad ioa[1] = 0;
1510 1.13 ad }
1511 1.13 ad }
1512 1.1 ad
1513 1.15 ad iop_msg_map(sc, im, mb, iop_systab, iop_systab_size, 1, NULL);
1514 1.15 ad iop_msg_map(sc, im, mb, mema, sizeof(mema), 1, NULL);
1515 1.15 ad iop_msg_map(sc, im, mb, ioa, sizeof(ioa), 1, NULL);
1516 1.11 ad rv = iop_msg_post(sc, im, mb, 5000);
1517 1.1 ad iop_msg_unmap(sc, im);
1518 1.11 ad iop_msg_free(sc, im);
1519 1.1 ad return (rv);
1520 1.1 ad }
1521 1.1 ad
1522 1.1 ad /*
1523 1.11 ad * Reset the IOP. Must be called with interrupts disabled.
1524 1.1 ad */
1525 1.1 ad static int
1526 1.1 ad iop_reset(struct iop_softc *sc)
1527 1.1 ad {
1528 1.15 ad u_int32_t mfa, *sw;
1529 1.11 ad struct i2o_exec_iop_reset mf;
1530 1.1 ad int rv;
1531 1.15 ad paddr_t pa;
1532 1.1 ad
1533 1.15 ad sw = (u_int32_t *)sc->sc_scr;
1534 1.75 mhitch pa = sc->sc_scr_dmamap->dm_segs[0].ds_addr;
1535 1.1 ad
1536 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_exec_iop_reset);
1537 1.11 ad mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_IOP_RESET);
1538 1.11 ad mf.reserved[0] = 0;
1539 1.11 ad mf.reserved[1] = 0;
1540 1.11 ad mf.reserved[2] = 0;
1541 1.11 ad mf.reserved[3] = 0;
1542 1.15 ad mf.statuslow = (u_int32_t)pa;
1543 1.15 ad mf.statushigh = (u_int32_t)((u_int64_t)pa >> 32);
1544 1.15 ad
1545 1.72 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1546 1.80 bouyer BUS_DMASYNC_POSTWRITE);
1547 1.15 ad *sw = htole32(0);
1548 1.15 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1549 1.80 bouyer BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
1550 1.1 ad
1551 1.11 ad if ((rv = iop_post(sc, (u_int32_t *)&mf)))
1552 1.1 ad return (rv);
1553 1.1 ad
1554 1.15 ad POLL(2500,
1555 1.15 ad (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
1556 1.80 bouyer BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD), *sw != 0));
1557 1.15 ad if (*sw != htole32(I2O_RESET_IN_PROGRESS)) {
1558 1.82 chs aprint_error_dev(sc->sc_dev, "reset rejected, status 0x%x\n",
1559 1.69 cegger le32toh(*sw));
1560 1.1 ad return (EIO);
1561 1.1 ad }
1562 1.1 ad
1563 1.47 perry /*
1564 1.5 ad * IOP is now in the INIT state. Wait no more than 10 seconds for
1565 1.1 ad * the inbound queue to become responsive.
1566 1.1 ad */
1567 1.5 ad POLL(10000, (mfa = iop_inl(sc, IOP_REG_IFIFO)) != IOP_MFA_EMPTY);
1568 1.1 ad if (mfa == IOP_MFA_EMPTY) {
1569 1.82 chs aprint_error_dev(sc->sc_dev, "reset failed\n");
1570 1.1 ad return (EIO);
1571 1.1 ad }
1572 1.1 ad
1573 1.1 ad iop_release_mfa(sc, mfa);
1574 1.1 ad return (0);
1575 1.1 ad }
1576 1.1 ad
1577 1.1 ad /*
1578 1.11 ad * Register a new initiator. Must be called with the configuration lock
1579 1.11 ad * held.
1580 1.1 ad */
1581 1.11 ad void
1582 1.1 ad iop_initiator_register(struct iop_softc *sc, struct iop_initiator *ii)
1583 1.1 ad {
1584 1.11 ad static int ictxgen;
1585 1.5 ad
1586 1.11 ad /* 0 is reserved (by us) for system messages. */
1587 1.11 ad ii->ii_ictx = ++ictxgen;
1588 1.1 ad
1589 1.11 ad /*
1590 1.11 ad * `Utility initiators' don't make it onto the per-IOP initiator list
1591 1.11 ad * (which is used only for configuration), but do get one slot on
1592 1.11 ad * the inbound queue.
1593 1.11 ad */
1594 1.11 ad if ((ii->ii_flags & II_UTILITY) == 0) {
1595 1.11 ad LIST_INSERT_HEAD(&sc->sc_iilist, ii, ii_list);
1596 1.11 ad sc->sc_nii++;
1597 1.11 ad } else
1598 1.11 ad sc->sc_nuii++;
1599 1.11 ad
1600 1.65 ad cv_init(&ii->ii_cv, "iopevt");
1601 1.65 ad
1602 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1603 1.5 ad LIST_INSERT_HEAD(IOP_ICTXHASH(ii->ii_ictx), ii, ii_hash);
1604 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1605 1.1 ad }
1606 1.1 ad
1607 1.1 ad /*
1608 1.11 ad * Unregister an initiator. Must be called with the configuration lock
1609 1.11 ad * held.
1610 1.1 ad */
1611 1.1 ad void
1612 1.1 ad iop_initiator_unregister(struct iop_softc *sc, struct iop_initiator *ii)
1613 1.1 ad {
1614 1.11 ad
1615 1.11 ad if ((ii->ii_flags & II_UTILITY) == 0) {
1616 1.11 ad LIST_REMOVE(ii, ii_list);
1617 1.11 ad sc->sc_nii--;
1618 1.11 ad } else
1619 1.11 ad sc->sc_nuii--;
1620 1.1 ad
1621 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1622 1.5 ad LIST_REMOVE(ii, ii_hash);
1623 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1624 1.65 ad
1625 1.65 ad cv_destroy(&ii->ii_cv);
1626 1.1 ad }
1627 1.1 ad
1628 1.1 ad /*
1629 1.11 ad * Handle a reply frame from the IOP.
1630 1.1 ad */
1631 1.1 ad static int
1632 1.5 ad iop_handle_reply(struct iop_softc *sc, u_int32_t rmfa)
1633 1.1 ad {
1634 1.1 ad struct iop_msg *im;
1635 1.1 ad struct i2o_reply *rb;
1636 1.11 ad struct i2o_fault_notify *fn;
1637 1.1 ad struct iop_initiator *ii;
1638 1.5 ad u_int off, ictx, tctx, status, size;
1639 1.1 ad
1640 1.65 ad KASSERT(mutex_owned(&sc->sc_intrlock));
1641 1.65 ad
1642 1.1 ad off = (int)(rmfa - sc->sc_rep_phys);
1643 1.64 christos rb = (struct i2o_reply *)((char *)sc->sc_rep + off);
1644 1.1 ad
1645 1.15 ad /* Perform reply queue DMA synchronisation. */
1646 1.11 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, off,
1647 1.19 ad sc->sc_framesize, BUS_DMASYNC_POSTREAD);
1648 1.1 ad
1649 1.1 ad #ifdef I2ODEBUG
1650 1.1 ad if ((le32toh(rb->msgflags) & I2O_MSGFLAGS_64BIT) != 0)
1651 1.5 ad panic("iop_handle_reply: 64-bit reply");
1652 1.1 ad #endif
1653 1.47 perry /*
1654 1.1 ad * Find the initiator.
1655 1.1 ad */
1656 1.1 ad ictx = le32toh(rb->msgictx);
1657 1.1 ad if (ictx == IOP_ICTX)
1658 1.1 ad ii = NULL;
1659 1.1 ad else {
1660 1.5 ad ii = LIST_FIRST(IOP_ICTXHASH(ictx));
1661 1.5 ad for (; ii != NULL; ii = LIST_NEXT(ii, ii_hash))
1662 1.5 ad if (ii->ii_ictx == ictx)
1663 1.5 ad break;
1664 1.5 ad if (ii == NULL) {
1665 1.1 ad #ifdef I2ODEBUG
1666 1.11 ad iop_reply_print(sc, rb);
1667 1.1 ad #endif
1668 1.82 chs aprint_error_dev(sc->sc_dev, "WARNING: bad ictx returned (%x)\n",
1669 1.69 cegger ictx);
1670 1.5 ad return (-1);
1671 1.5 ad }
1672 1.1 ad }
1673 1.1 ad
1674 1.11 ad /*
1675 1.14 wiz * If we received a transport failure notice, we've got to dig the
1676 1.11 ad * transaction context (if any) out of the original message frame,
1677 1.11 ad * and then release the original MFA back to the inbound FIFO.
1678 1.11 ad */
1679 1.11 ad if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) {
1680 1.11 ad status = I2O_STATUS_SUCCESS;
1681 1.11 ad
1682 1.11 ad fn = (struct i2o_fault_notify *)rb;
1683 1.29 msaitoh tctx = iop_inl_msg(sc, fn->lowmfa + 12);
1684 1.11 ad iop_release_mfa(sc, fn->lowmfa);
1685 1.11 ad iop_tfn_print(sc, fn);
1686 1.11 ad } else {
1687 1.11 ad status = rb->reqstatus;
1688 1.11 ad tctx = le32toh(rb->msgtctx);
1689 1.11 ad }
1690 1.1 ad
1691 1.15 ad if (ii == NULL || (ii->ii_flags & II_NOTCTX) == 0) {
1692 1.1 ad /*
1693 1.1 ad * This initiator tracks state using message wrappers.
1694 1.1 ad *
1695 1.1 ad * Find the originating message wrapper, and if requested
1696 1.1 ad * notify the initiator.
1697 1.1 ad */
1698 1.11 ad im = sc->sc_ims + (tctx & IOP_TCTX_MASK);
1699 1.11 ad if ((tctx & IOP_TCTX_MASK) > sc->sc_maxib ||
1700 1.11 ad (im->im_flags & IM_ALLOCED) == 0 ||
1701 1.11 ad tctx != im->im_tctx) {
1702 1.82 chs aprint_error_dev(sc->sc_dev, "WARNING: bad tctx returned (0x%08x, %p)\n", tctx, im);
1703 1.11 ad if (im != NULL)
1704 1.82 chs aprint_error_dev(sc->sc_dev, "flags=0x%08x tctx=0x%08x\n",
1705 1.69 cegger im->im_flags, im->im_tctx);
1706 1.5 ad #ifdef I2ODEBUG
1707 1.11 ad if ((rb->msgflags & I2O_MSGFLAGS_FAIL) == 0)
1708 1.11 ad iop_reply_print(sc, rb);
1709 1.5 ad #endif
1710 1.5 ad return (-1);
1711 1.5 ad }
1712 1.11 ad
1713 1.11 ad if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
1714 1.11 ad im->im_flags |= IM_FAIL;
1715 1.11 ad
1716 1.1 ad #ifdef I2ODEBUG
1717 1.1 ad if ((im->im_flags & IM_REPLIED) != 0)
1718 1.82 chs panic("%s: dup reply", device_xname(sc->sc_dev));
1719 1.1 ad #endif
1720 1.11 ad im->im_flags |= IM_REPLIED;
1721 1.1 ad
1722 1.11 ad #ifdef I2ODEBUG
1723 1.11 ad if (status != I2O_STATUS_SUCCESS)
1724 1.11 ad iop_reply_print(sc, rb);
1725 1.11 ad #endif
1726 1.11 ad im->im_reqstatus = status;
1727 1.42 ad im->im_detstatus = le16toh(rb->detail);
1728 1.1 ad
1729 1.11 ad /* Copy the reply frame, if requested. */
1730 1.11 ad if (im->im_rb != NULL) {
1731 1.11 ad size = (le32toh(rb->msgflags) >> 14) & ~3;
1732 1.1 ad #ifdef I2ODEBUG
1733 1.19 ad if (size > sc->sc_framesize)
1734 1.11 ad panic("iop_handle_reply: reply too large");
1735 1.1 ad #endif
1736 1.11 ad memcpy(im->im_rb, rb, size);
1737 1.11 ad }
1738 1.11 ad
1739 1.1 ad /* Notify the initiator. */
1740 1.11 ad if ((im->im_flags & IM_WAIT) != 0)
1741 1.65 ad cv_broadcast(&im->im_cv);
1742 1.55 christos else if ((im->im_flags & (IM_POLL | IM_POLL_INTR)) != IM_POLL) {
1743 1.65 ad if (ii != NULL) {
1744 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1745 1.55 christos (*ii->ii_intr)(ii->ii_dv, im, rb);
1746 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1747 1.65 ad }
1748 1.55 christos }
1749 1.1 ad } else {
1750 1.1 ad /*
1751 1.1 ad * This initiator discards message wrappers.
1752 1.1 ad *
1753 1.1 ad * Simply pass the reply frame to the initiator.
1754 1.1 ad */
1755 1.65 ad if (ii != NULL) {
1756 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1757 1.55 christos (*ii->ii_intr)(ii->ii_dv, NULL, rb);
1758 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1759 1.65 ad }
1760 1.1 ad }
1761 1.1 ad
1762 1.1 ad return (status);
1763 1.1 ad }
1764 1.1 ad
1765 1.1 ad /*
1766 1.11 ad * Handle an interrupt from the IOP.
1767 1.1 ad */
1768 1.1 ad int
1769 1.1 ad iop_intr(void *arg)
1770 1.1 ad {
1771 1.1 ad struct iop_softc *sc;
1772 1.5 ad u_int32_t rmfa;
1773 1.1 ad
1774 1.1 ad sc = arg;
1775 1.1 ad
1776 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1777 1.65 ad
1778 1.65 ad if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) == 0) {
1779 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1780 1.5 ad return (0);
1781 1.65 ad }
1782 1.5 ad
1783 1.5 ad for (;;) {
1784 1.5 ad /* Double read to account for IOP bug. */
1785 1.11 ad if ((rmfa = iop_inl(sc, IOP_REG_OFIFO)) == IOP_MFA_EMPTY) {
1786 1.11 ad rmfa = iop_inl(sc, IOP_REG_OFIFO);
1787 1.11 ad if (rmfa == IOP_MFA_EMPTY)
1788 1.11 ad break;
1789 1.11 ad }
1790 1.5 ad iop_handle_reply(sc, rmfa);
1791 1.11 ad iop_outl(sc, IOP_REG_OFIFO, rmfa);
1792 1.1 ad }
1793 1.1 ad
1794 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1795 1.5 ad return (1);
1796 1.5 ad }
1797 1.5 ad
1798 1.5 ad /*
1799 1.5 ad * Handle an event signalled by the executive.
1800 1.5 ad */
1801 1.5 ad static void
1802 1.76 cegger iop_intr_event(device_t dv, struct iop_msg *im, void *reply)
1803 1.5 ad {
1804 1.5 ad struct i2o_util_event_register_reply *rb;
1805 1.5 ad u_int event;
1806 1.5 ad
1807 1.5 ad rb = reply;
1808 1.5 ad
1809 1.11 ad if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
1810 1.5 ad return;
1811 1.5 ad
1812 1.11 ad event = le32toh(rb->event);
1813 1.69 cegger printf("%s: event 0x%08x received\n", device_xname(dv), event);
1814 1.1 ad }
1815 1.1 ad
1816 1.47 perry /*
1817 1.1 ad * Allocate a message wrapper.
1818 1.1 ad */
1819 1.11 ad struct iop_msg *
1820 1.15 ad iop_msg_alloc(struct iop_softc *sc, int flags)
1821 1.1 ad {
1822 1.1 ad struct iop_msg *im;
1823 1.11 ad static u_int tctxgen;
1824 1.65 ad int i;
1825 1.1 ad
1826 1.1 ad #ifdef I2ODEBUG
1827 1.1 ad if ((flags & IM_SYSMASK) != 0)
1828 1.1 ad panic("iop_msg_alloc: system flags specified");
1829 1.1 ad #endif
1830 1.1 ad
1831 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1832 1.11 ad im = SLIST_FIRST(&sc->sc_im_freelist);
1833 1.11 ad #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
1834 1.11 ad if (im == NULL)
1835 1.11 ad panic("iop_msg_alloc: no free wrappers");
1836 1.11 ad #endif
1837 1.11 ad SLIST_REMOVE_HEAD(&sc->sc_im_freelist, im_chain);
1838 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1839 1.1 ad
1840 1.11 ad im->im_tctx = (im->im_tctx & IOP_TCTX_MASK) | tctxgen;
1841 1.11 ad tctxgen += (1 << IOP_TCTX_SHIFT);
1842 1.1 ad im->im_flags = flags | IM_ALLOCED;
1843 1.11 ad im->im_rb = NULL;
1844 1.11 ad i = 0;
1845 1.11 ad do {
1846 1.11 ad im->im_xfer[i++].ix_size = 0;
1847 1.11 ad } while (i < IOP_MAX_MSG_XFERS);
1848 1.1 ad
1849 1.11 ad return (im);
1850 1.1 ad }
1851 1.1 ad
1852 1.47 perry /*
1853 1.1 ad * Free a message wrapper.
1854 1.1 ad */
1855 1.1 ad void
1856 1.11 ad iop_msg_free(struct iop_softc *sc, struct iop_msg *im)
1857 1.1 ad {
1858 1.1 ad
1859 1.1 ad #ifdef I2ODEBUG
1860 1.1 ad if ((im->im_flags & IM_ALLOCED) == 0)
1861 1.1 ad panic("iop_msg_free: wrapper not allocated");
1862 1.1 ad #endif
1863 1.1 ad
1864 1.1 ad im->im_flags = 0;
1865 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
1866 1.11 ad SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
1867 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
1868 1.1 ad }
1869 1.1 ad
1870 1.1 ad /*
1871 1.47 perry * Map a data transfer. Write a scatter-gather list into the message frame.
1872 1.1 ad */
1873 1.1 ad int
1874 1.11 ad iop_msg_map(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
1875 1.15 ad void *xferaddr, int xfersize, int out, struct proc *up)
1876 1.1 ad {
1877 1.11 ad bus_dmamap_t dm;
1878 1.11 ad bus_dma_segment_t *ds;
1879 1.1 ad struct iop_xfer *ix;
1880 1.11 ad u_int rv, i, nsegs, flg, off, xn;
1881 1.11 ad u_int32_t *p;
1882 1.5 ad
1883 1.11 ad for (xn = 0, ix = im->im_xfer; xn < IOP_MAX_MSG_XFERS; xn++, ix++)
1884 1.1 ad if (ix->ix_size == 0)
1885 1.1 ad break;
1886 1.11 ad
1887 1.1 ad #ifdef I2ODEBUG
1888 1.11 ad if (xfersize == 0)
1889 1.11 ad panic("iop_msg_map: null transfer");
1890 1.11 ad if (xfersize > IOP_MAX_XFER)
1891 1.11 ad panic("iop_msg_map: transfer too large");
1892 1.11 ad if (xn == IOP_MAX_MSG_XFERS)
1893 1.1 ad panic("iop_msg_map: too many xfers");
1894 1.1 ad #endif
1895 1.1 ad
1896 1.11 ad /*
1897 1.11 ad * Only the first DMA map is static.
1898 1.11 ad */
1899 1.11 ad if (xn != 0) {
1900 1.1 ad rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
1901 1.11 ad IOP_MAX_SEGS, IOP_MAX_XFER, 0,
1902 1.1 ad BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ix->ix_map);
1903 1.1 ad if (rv != 0)
1904 1.1 ad return (rv);
1905 1.1 ad }
1906 1.1 ad
1907 1.11 ad dm = ix->ix_map;
1908 1.15 ad rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, up,
1909 1.15 ad (up == NULL ? BUS_DMA_NOWAIT : 0));
1910 1.11 ad if (rv != 0)
1911 1.11 ad goto bad;
1912 1.11 ad
1913 1.11 ad /*
1914 1.11 ad * How many SIMPLE SG elements can we fit in this message?
1915 1.11 ad */
1916 1.11 ad off = mb[0] >> 16;
1917 1.11 ad p = mb + off;
1918 1.19 ad nsegs = ((sc->sc_framesize >> 2) - off) >> 1;
1919 1.11 ad
1920 1.11 ad if (dm->dm_nsegs > nsegs) {
1921 1.11 ad bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
1922 1.11 ad rv = EFBIG;
1923 1.11 ad DPRINTF(("iop_msg_map: too many segs\n"));
1924 1.11 ad goto bad;
1925 1.11 ad }
1926 1.1 ad
1927 1.11 ad nsegs = dm->dm_nsegs;
1928 1.11 ad xfersize = 0;
1929 1.1 ad
1930 1.11 ad /*
1931 1.11 ad * Write out the SG list.
1932 1.11 ad */
1933 1.1 ad if (out)
1934 1.11 ad flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
1935 1.1 ad else
1936 1.11 ad flg = I2O_SGL_SIMPLE;
1937 1.1 ad
1938 1.11 ad for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
1939 1.11 ad p[0] = (u_int32_t)ds->ds_len | flg;
1940 1.11 ad p[1] = (u_int32_t)ds->ds_addr;
1941 1.11 ad xfersize += ds->ds_len;
1942 1.1 ad }
1943 1.1 ad
1944 1.11 ad p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER;
1945 1.11 ad p[1] = (u_int32_t)ds->ds_addr;
1946 1.11 ad xfersize += ds->ds_len;
1947 1.11 ad
1948 1.11 ad /* Fix up the transfer record, and sync the map. */
1949 1.11 ad ix->ix_flags = (out ? IX_OUT : IX_IN);
1950 1.11 ad ix->ix_size = xfersize;
1951 1.11 ad bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
1952 1.72 ad out ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
1953 1.11 ad
1954 1.1 ad /*
1955 1.1 ad * If this is the first xfer we've mapped for this message, adjust
1956 1.1 ad * the SGL offset field in the message header.
1957 1.1 ad */
1958 1.2 ad if ((im->im_flags & IM_SGLOFFADJ) == 0) {
1959 1.11 ad mb[0] += (mb[0] >> 12) & 0xf0;
1960 1.2 ad im->im_flags |= IM_SGLOFFADJ;
1961 1.2 ad }
1962 1.11 ad mb[0] += (nsegs << 17);
1963 1.11 ad return (0);
1964 1.11 ad
1965 1.11 ad bad:
1966 1.11 ad if (xn != 0)
1967 1.11 ad bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
1968 1.11 ad return (rv);
1969 1.11 ad }
1970 1.11 ad
1971 1.11 ad /*
1972 1.11 ad * Map a block I/O data transfer (different in that there's only one per
1973 1.11 ad * message maximum, and PAGE addressing may be used). Write a scatter
1974 1.11 ad * gather list into the message frame.
1975 1.11 ad */
1976 1.11 ad int
1977 1.11 ad iop_msg_map_bio(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
1978 1.11 ad void *xferaddr, int xfersize, int out)
1979 1.11 ad {
1980 1.11 ad bus_dma_segment_t *ds;
1981 1.11 ad bus_dmamap_t dm;
1982 1.11 ad struct iop_xfer *ix;
1983 1.11 ad u_int rv, i, nsegs, off, slen, tlen, flg;
1984 1.11 ad paddr_t saddr, eaddr;
1985 1.11 ad u_int32_t *p;
1986 1.11 ad
1987 1.11 ad #ifdef I2ODEBUG
1988 1.11 ad if (xfersize == 0)
1989 1.11 ad panic("iop_msg_map_bio: null transfer");
1990 1.11 ad if (xfersize > IOP_MAX_XFER)
1991 1.11 ad panic("iop_msg_map_bio: transfer too large");
1992 1.11 ad if ((im->im_flags & IM_SGLOFFADJ) != 0)
1993 1.11 ad panic("iop_msg_map_bio: SGLOFFADJ");
1994 1.11 ad #endif
1995 1.11 ad
1996 1.11 ad ix = im->im_xfer;
1997 1.11 ad dm = ix->ix_map;
1998 1.15 ad rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, NULL,
1999 1.15 ad BUS_DMA_NOWAIT | BUS_DMA_STREAMING);
2000 1.11 ad if (rv != 0)
2001 1.11 ad return (rv);
2002 1.11 ad
2003 1.11 ad off = mb[0] >> 16;
2004 1.19 ad nsegs = ((sc->sc_framesize >> 2) - off) >> 1;
2005 1.11 ad
2006 1.11 ad /*
2007 1.11 ad * If the transfer is highly fragmented and won't fit using SIMPLE
2008 1.11 ad * elements, use PAGE_LIST elements instead. SIMPLE elements are
2009 1.11 ad * potentially more efficient, both for us and the IOP.
2010 1.11 ad */
2011 1.11 ad if (dm->dm_nsegs > nsegs) {
2012 1.11 ad nsegs = 1;
2013 1.11 ad p = mb + off + 1;
2014 1.11 ad
2015 1.11 ad /* XXX This should be done with a bus_space flag. */
2016 1.11 ad for (i = dm->dm_nsegs, ds = dm->dm_segs; i > 0; i--, ds++) {
2017 1.11 ad slen = ds->ds_len;
2018 1.11 ad saddr = ds->ds_addr;
2019 1.11 ad
2020 1.11 ad while (slen > 0) {
2021 1.11 ad eaddr = (saddr + PAGE_SIZE) & ~(PAGE_SIZE - 1);
2022 1.11 ad tlen = min(eaddr - saddr, slen);
2023 1.11 ad slen -= tlen;
2024 1.11 ad *p++ = le32toh(saddr);
2025 1.11 ad saddr = eaddr;
2026 1.11 ad nsegs++;
2027 1.11 ad }
2028 1.11 ad }
2029 1.11 ad
2030 1.11 ad mb[off] = xfersize | I2O_SGL_PAGE_LIST | I2O_SGL_END_BUFFER |
2031 1.11 ad I2O_SGL_END;
2032 1.11 ad if (out)
2033 1.11 ad mb[off] |= I2O_SGL_DATA_OUT;
2034 1.11 ad } else {
2035 1.11 ad p = mb + off;
2036 1.13 ad nsegs = dm->dm_nsegs;
2037 1.11 ad
2038 1.11 ad if (out)
2039 1.11 ad flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
2040 1.11 ad else
2041 1.11 ad flg = I2O_SGL_SIMPLE;
2042 1.11 ad
2043 1.11 ad for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
2044 1.11 ad p[0] = (u_int32_t)ds->ds_len | flg;
2045 1.11 ad p[1] = (u_int32_t)ds->ds_addr;
2046 1.11 ad }
2047 1.11 ad
2048 1.11 ad p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER |
2049 1.11 ad I2O_SGL_END;
2050 1.11 ad p[1] = (u_int32_t)ds->ds_addr;
2051 1.11 ad nsegs <<= 1;
2052 1.11 ad }
2053 1.11 ad
2054 1.11 ad /* Fix up the transfer record, and sync the map. */
2055 1.11 ad ix->ix_flags = (out ? IX_OUT : IX_IN);
2056 1.11 ad ix->ix_size = xfersize;
2057 1.11 ad bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
2058 1.72 ad out ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
2059 1.11 ad
2060 1.11 ad /*
2061 1.11 ad * Adjust the SGL offset and total message size fields. We don't
2062 1.11 ad * set IM_SGLOFFADJ, since it's used only for SIMPLE elements.
2063 1.11 ad */
2064 1.11 ad mb[0] += ((off << 4) + (nsegs << 16));
2065 1.1 ad return (0);
2066 1.1 ad }
2067 1.1 ad
2068 1.1 ad /*
2069 1.1 ad * Unmap all data transfers associated with a message wrapper.
2070 1.1 ad */
2071 1.1 ad void
2072 1.1 ad iop_msg_unmap(struct iop_softc *sc, struct iop_msg *im)
2073 1.1 ad {
2074 1.1 ad struct iop_xfer *ix;
2075 1.1 ad int i;
2076 1.11 ad
2077 1.47 perry #ifdef I2ODEBUG
2078 1.11 ad if (im->im_xfer[0].ix_size == 0)
2079 1.11 ad panic("iop_msg_unmap: no transfers mapped");
2080 1.11 ad #endif
2081 1.11 ad
2082 1.11 ad for (ix = im->im_xfer, i = 0;;) {
2083 1.1 ad bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, ix->ix_size,
2084 1.1 ad ix->ix_flags & IX_OUT ? BUS_DMASYNC_POSTWRITE :
2085 1.1 ad BUS_DMASYNC_POSTREAD);
2086 1.1 ad bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
2087 1.1 ad
2088 1.1 ad /* Only the first DMA map is static. */
2089 1.1 ad if (i != 0)
2090 1.1 ad bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
2091 1.47 perry if ((++ix)->ix_size == 0)
2092 1.11 ad break;
2093 1.11 ad if (++i >= IOP_MAX_MSG_XFERS)
2094 1.11 ad break;
2095 1.1 ad }
2096 1.1 ad }
2097 1.1 ad
2098 1.11 ad /*
2099 1.11 ad * Post a message frame to the IOP's inbound queue.
2100 1.1 ad */
2101 1.1 ad int
2102 1.11 ad iop_post(struct iop_softc *sc, u_int32_t *mb)
2103 1.1 ad {
2104 1.11 ad u_int32_t mfa;
2105 1.11 ad
2106 1.15 ad #ifdef I2ODEBUG
2107 1.19 ad if ((mb[0] >> 16) > (sc->sc_framesize >> 2))
2108 1.13 ad panic("iop_post: frame too large");
2109 1.15 ad #endif
2110 1.13 ad
2111 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
2112 1.11 ad
2113 1.11 ad /* Allocate a slot with the IOP. */
2114 1.11 ad if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY)
2115 1.11 ad if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY) {
2116 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2117 1.82 chs aprint_error_dev(sc->sc_dev, "mfa not forthcoming\n");
2118 1.11 ad return (EAGAIN);
2119 1.11 ad }
2120 1.11 ad
2121 1.15 ad /* Perform reply buffer DMA synchronisation. */
2122 1.72 ad if (sc->sc_rep_size != 0) {
2123 1.11 ad bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
2124 1.11 ad sc->sc_rep_size, BUS_DMASYNC_PREREAD);
2125 1.72 ad }
2126 1.1 ad
2127 1.11 ad /* Copy out the message frame. */
2128 1.30 ad bus_space_write_region_4(sc->sc_msg_iot, sc->sc_msg_ioh, mfa, mb,
2129 1.29 msaitoh mb[0] >> 16);
2130 1.30 ad bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, mfa,
2131 1.29 msaitoh (mb[0] >> 14) & ~3, BUS_SPACE_BARRIER_WRITE);
2132 1.11 ad
2133 1.11 ad /* Post the MFA back to the IOP. */
2134 1.11 ad iop_outl(sc, IOP_REG_IFIFO, mfa);
2135 1.1 ad
2136 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2137 1.11 ad return (0);
2138 1.11 ad }
2139 1.1 ad
2140 1.11 ad /*
2141 1.11 ad * Post a message to the IOP and deal with completion.
2142 1.11 ad */
2143 1.11 ad int
2144 1.11 ad iop_msg_post(struct iop_softc *sc, struct iop_msg *im, void *xmb, int timo)
2145 1.11 ad {
2146 1.11 ad u_int32_t *mb;
2147 1.65 ad int rv;
2148 1.1 ad
2149 1.11 ad mb = xmb;
2150 1.1 ad
2151 1.11 ad /* Terminate the scatter/gather list chain. */
2152 1.1 ad if ((im->im_flags & IM_SGLOFFADJ) != 0)
2153 1.11 ad mb[(mb[0] >> 16) - 2] |= I2O_SGL_END;
2154 1.1 ad
2155 1.11 ad if ((rv = iop_post(sc, mb)) != 0)
2156 1.11 ad return (rv);
2157 1.1 ad
2158 1.15 ad if ((im->im_flags & (IM_POLL | IM_WAIT)) != 0) {
2159 1.11 ad if ((im->im_flags & IM_POLL) != 0)
2160 1.11 ad iop_msg_poll(sc, im, timo);
2161 1.11 ad else
2162 1.11 ad iop_msg_wait(sc, im, timo);
2163 1.1 ad
2164 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
2165 1.11 ad if ((im->im_flags & IM_REPLIED) != 0) {
2166 1.11 ad if ((im->im_flags & IM_NOSTATUS) != 0)
2167 1.11 ad rv = 0;
2168 1.11 ad else if ((im->im_flags & IM_FAIL) != 0)
2169 1.11 ad rv = ENXIO;
2170 1.11 ad else if (im->im_reqstatus != I2O_STATUS_SUCCESS)
2171 1.11 ad rv = EIO;
2172 1.11 ad else
2173 1.11 ad rv = 0;
2174 1.11 ad } else
2175 1.11 ad rv = EBUSY;
2176 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2177 1.11 ad } else
2178 1.11 ad rv = 0;
2179 1.11 ad
2180 1.11 ad return (rv);
2181 1.11 ad }
2182 1.11 ad
2183 1.47 perry /*
2184 1.11 ad * Spin until the specified message is replied to.
2185 1.11 ad */
2186 1.11 ad static void
2187 1.11 ad iop_msg_poll(struct iop_softc *sc, struct iop_msg *im, int timo)
2188 1.11 ad {
2189 1.11 ad u_int32_t rmfa;
2190 1.11 ad
2191 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
2192 1.1 ad
2193 1.1 ad for (timo *= 10; timo != 0; timo--) {
2194 1.5 ad if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) != 0) {
2195 1.5 ad /* Double read to account for IOP bug. */
2196 1.5 ad rmfa = iop_inl(sc, IOP_REG_OFIFO);
2197 1.5 ad if (rmfa == IOP_MFA_EMPTY)
2198 1.5 ad rmfa = iop_inl(sc, IOP_REG_OFIFO);
2199 1.11 ad if (rmfa != IOP_MFA_EMPTY) {
2200 1.35 simonb iop_handle_reply(sc, rmfa);
2201 1.11 ad
2202 1.11 ad /*
2203 1.11 ad * Return the reply frame to the IOP's
2204 1.11 ad * outbound FIFO.
2205 1.11 ad */
2206 1.11 ad iop_outl(sc, IOP_REG_OFIFO, rmfa);
2207 1.11 ad }
2208 1.5 ad }
2209 1.1 ad if ((im->im_flags & IM_REPLIED) != 0)
2210 1.1 ad break;
2211 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2212 1.1 ad DELAY(100);
2213 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
2214 1.1 ad }
2215 1.1 ad
2216 1.1 ad if (timo == 0) {
2217 1.5 ad #ifdef I2ODEBUG
2218 1.82 chs printf("%s: poll - no reply\n", device_xname(sc->sc_dev));
2219 1.11 ad if (iop_status_get(sc, 1) != 0)
2220 1.11 ad printf("iop_msg_poll: unable to retrieve status\n");
2221 1.5 ad else
2222 1.11 ad printf("iop_msg_poll: IOP state = %d\n",
2223 1.47 perry (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
2224 1.5 ad #endif
2225 1.1 ad }
2226 1.1 ad
2227 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2228 1.1 ad }
2229 1.1 ad
2230 1.1 ad /*
2231 1.11 ad * Sleep until the specified message is replied to.
2232 1.1 ad */
2233 1.11 ad static void
2234 1.61 christos iop_msg_wait(struct iop_softc *sc, struct iop_msg *im, int timo)
2235 1.1 ad {
2236 1.65 ad int rv;
2237 1.1 ad
2238 1.65 ad mutex_spin_enter(&sc->sc_intrlock);
2239 1.5 ad if ((im->im_flags & IM_REPLIED) != 0) {
2240 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2241 1.11 ad return;
2242 1.5 ad }
2243 1.65 ad rv = cv_timedwait(&im->im_cv, &sc->sc_intrlock, mstohz(timo));
2244 1.65 ad mutex_spin_exit(&sc->sc_intrlock);
2245 1.11 ad
2246 1.5 ad #ifdef I2ODEBUG
2247 1.5 ad if (rv != 0) {
2248 1.5 ad printf("iop_msg_wait: tsleep() == %d\n", rv);
2249 1.11 ad if (iop_status_get(sc, 0) != 0)
2250 1.84 christos printf("%s: unable to retrieve status\n", __func__);
2251 1.5 ad else
2252 1.84 christos printf("%s: IOP state = %d\n", __func__,
2253 1.47 perry (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
2254 1.5 ad }
2255 1.84 christos #else
2256 1.84 christos __USE(rv);
2257 1.5 ad #endif
2258 1.1 ad }
2259 1.1 ad
2260 1.1 ad /*
2261 1.1 ad * Release an unused message frame back to the IOP's inbound fifo.
2262 1.1 ad */
2263 1.1 ad static void
2264 1.1 ad iop_release_mfa(struct iop_softc *sc, u_int32_t mfa)
2265 1.1 ad {
2266 1.1 ad
2267 1.1 ad /* Use the frame to issue a no-op. */
2268 1.30 ad iop_outl_msg(sc, mfa, I2O_VERSION_11 | (4 << 16));
2269 1.30 ad iop_outl_msg(sc, mfa + 4, I2O_MSGFUNC(I2O_TID_IOP, I2O_UTIL_NOP));
2270 1.30 ad iop_outl_msg(sc, mfa + 8, 0);
2271 1.30 ad iop_outl_msg(sc, mfa + 12, 0);
2272 1.1 ad
2273 1.5 ad iop_outl(sc, IOP_REG_IFIFO, mfa);
2274 1.1 ad }
2275 1.1 ad
2276 1.1 ad #ifdef I2ODEBUG
2277 1.1 ad /*
2278 1.11 ad * Dump a reply frame header.
2279 1.1 ad */
2280 1.1 ad static void
2281 1.11 ad iop_reply_print(struct iop_softc *sc, struct i2o_reply *rb)
2282 1.1 ad {
2283 1.5 ad u_int function, detail;
2284 1.1 ad const char *statusstr;
2285 1.1 ad
2286 1.5 ad function = (le32toh(rb->msgfunc) >> 24) & 0xff;
2287 1.1 ad detail = le16toh(rb->detail);
2288 1.1 ad
2289 1.82 chs printf("%s: reply:\n", device_xname(sc->sc_dev));
2290 1.5 ad
2291 1.1 ad if (rb->reqstatus < sizeof(iop_status) / sizeof(iop_status[0]))
2292 1.1 ad statusstr = iop_status[rb->reqstatus];
2293 1.1 ad else
2294 1.1 ad statusstr = "undefined error code";
2295 1.1 ad
2296 1.47 perry printf("%s: function=0x%02x status=0x%02x (%s)\n",
2297 1.82 chs device_xname(sc->sc_dev), function, rb->reqstatus, statusstr);
2298 1.5 ad printf("%s: detail=0x%04x ictx=0x%08x tctx=0x%08x\n",
2299 1.82 chs device_xname(sc->sc_dev), detail, le32toh(rb->msgictx),
2300 1.5 ad le32toh(rb->msgtctx));
2301 1.82 chs printf("%s: tidi=%d tidt=%d flags=0x%02x\n", device_xname(sc->sc_dev),
2302 1.5 ad (le32toh(rb->msgfunc) >> 12) & 4095, le32toh(rb->msgfunc) & 4095,
2303 1.5 ad (le32toh(rb->msgflags) >> 8) & 0xff);
2304 1.1 ad }
2305 1.1 ad #endif
2306 1.1 ad
2307 1.1 ad /*
2308 1.11 ad * Dump a transport failure reply.
2309 1.11 ad */
2310 1.11 ad static void
2311 1.11 ad iop_tfn_print(struct iop_softc *sc, struct i2o_fault_notify *fn)
2312 1.11 ad {
2313 1.11 ad
2314 1.82 chs printf("%s: WARNING: transport failure:\n", device_xname(sc->sc_dev));
2315 1.11 ad
2316 1.82 chs printf("%s: ictx=0x%08x tctx=0x%08x\n", device_xname(sc->sc_dev),
2317 1.11 ad le32toh(fn->msgictx), le32toh(fn->msgtctx));
2318 1.11 ad printf("%s: failurecode=0x%02x severity=0x%02x\n",
2319 1.82 chs device_xname(sc->sc_dev), fn->failurecode, fn->severity);
2320 1.11 ad printf("%s: highestver=0x%02x lowestver=0x%02x\n",
2321 1.82 chs device_xname(sc->sc_dev), fn->highestver, fn->lowestver);
2322 1.11 ad }
2323 1.11 ad
2324 1.11 ad /*
2325 1.5 ad * Translate an I2O ASCII field into a C string.
2326 1.1 ad */
2327 1.1 ad void
2328 1.5 ad iop_strvis(struct iop_softc *sc, const char *src, int slen, char *dst, int dlen)
2329 1.1 ad {
2330 1.5 ad int hc, lc, i, nit;
2331 1.1 ad
2332 1.1 ad dlen--;
2333 1.1 ad lc = 0;
2334 1.1 ad hc = 0;
2335 1.1 ad i = 0;
2336 1.5 ad
2337 1.5 ad /*
2338 1.5 ad * DPT use NUL as a space, whereas AMI use it as a terminator. The
2339 1.5 ad * spec has nothing to say about it. Since AMI fields are usually
2340 1.5 ad * filled with junk after the terminator, ...
2341 1.5 ad */
2342 1.5 ad nit = (le16toh(sc->sc_status.orgid) != I2O_ORG_DPT);
2343 1.5 ad
2344 1.5 ad while (slen-- != 0 && dlen-- != 0) {
2345 1.5 ad if (nit && *src == '\0')
2346 1.5 ad break;
2347 1.5 ad else if (*src <= 0x20 || *src >= 0x7f) {
2348 1.1 ad if (hc)
2349 1.1 ad dst[i++] = ' ';
2350 1.1 ad } else {
2351 1.1 ad hc = 1;
2352 1.1 ad dst[i++] = *src;
2353 1.1 ad lc = i;
2354 1.1 ad }
2355 1.1 ad src++;
2356 1.1 ad }
2357 1.47 perry
2358 1.1 ad dst[lc] = '\0';
2359 1.1 ad }
2360 1.1 ad
2361 1.1 ad /*
2362 1.11 ad * Retrieve the DEVICE_IDENTITY parameter group from the target and dump it.
2363 1.11 ad */
2364 1.11 ad int
2365 1.11 ad iop_print_ident(struct iop_softc *sc, int tid)
2366 1.11 ad {
2367 1.11 ad struct {
2368 1.11 ad struct i2o_param_op_results pr;
2369 1.11 ad struct i2o_param_read_results prr;
2370 1.11 ad struct i2o_param_device_identity di;
2371 1.74 gmcgarry } __packed p;
2372 1.11 ad char buf[32];
2373 1.11 ad int rv;
2374 1.11 ad
2375 1.16 ad rv = iop_field_get_all(sc, tid, I2O_PARAM_DEVICE_IDENTITY, &p,
2376 1.16 ad sizeof(p), NULL);
2377 1.11 ad if (rv != 0)
2378 1.11 ad return (rv);
2379 1.11 ad
2380 1.11 ad iop_strvis(sc, p.di.vendorinfo, sizeof(p.di.vendorinfo), buf,
2381 1.11 ad sizeof(buf));
2382 1.11 ad printf(" <%s, ", buf);
2383 1.11 ad iop_strvis(sc, p.di.productinfo, sizeof(p.di.productinfo), buf,
2384 1.11 ad sizeof(buf));
2385 1.11 ad printf("%s, ", buf);
2386 1.11 ad iop_strvis(sc, p.di.revlevel, sizeof(p.di.revlevel), buf, sizeof(buf));
2387 1.11 ad printf("%s>", buf);
2388 1.11 ad
2389 1.11 ad return (0);
2390 1.11 ad }
2391 1.11 ad
2392 1.11 ad /*
2393 1.5 ad * Claim or unclaim the specified TID.
2394 1.1 ad */
2395 1.1 ad int
2396 1.5 ad iop_util_claim(struct iop_softc *sc, struct iop_initiator *ii, int release,
2397 1.15 ad int flags)
2398 1.1 ad {
2399 1.5 ad struct iop_msg *im;
2400 1.11 ad struct i2o_util_claim mf;
2401 1.5 ad int rv, func;
2402 1.5 ad
2403 1.5 ad func = release ? I2O_UTIL_CLAIM_RELEASE : I2O_UTIL_CLAIM;
2404 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
2405 1.5 ad
2406 1.11 ad /* We can use the same structure, as they're identical. */
2407 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_util_claim);
2408 1.11 ad mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, func);
2409 1.11 ad mf.msgictx = ii->ii_ictx;
2410 1.11 ad mf.msgtctx = im->im_tctx;
2411 1.11 ad mf.flags = flags;
2412 1.5 ad
2413 1.11 ad rv = iop_msg_post(sc, im, &mf, 5000);
2414 1.11 ad iop_msg_free(sc, im);
2415 1.5 ad return (rv);
2416 1.47 perry }
2417 1.5 ad
2418 1.5 ad /*
2419 1.5 ad * Perform an abort.
2420 1.5 ad */
2421 1.5 ad int iop_util_abort(struct iop_softc *sc, struct iop_initiator *ii, int func,
2422 1.15 ad int tctxabort, int flags)
2423 1.5 ad {
2424 1.5 ad struct iop_msg *im;
2425 1.11 ad struct i2o_util_abort mf;
2426 1.5 ad int rv;
2427 1.5 ad
2428 1.15 ad im = iop_msg_alloc(sc, IM_WAIT);
2429 1.1 ad
2430 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_util_abort);
2431 1.11 ad mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_ABORT);
2432 1.11 ad mf.msgictx = ii->ii_ictx;
2433 1.11 ad mf.msgtctx = im->im_tctx;
2434 1.11 ad mf.flags = (func << 24) | flags;
2435 1.11 ad mf.tctxabort = tctxabort;
2436 1.1 ad
2437 1.11 ad rv = iop_msg_post(sc, im, &mf, 5000);
2438 1.11 ad iop_msg_free(sc, im);
2439 1.5 ad return (rv);
2440 1.1 ad }
2441 1.1 ad
2442 1.1 ad /*
2443 1.11 ad * Enable or disable reception of events for the specified device.
2444 1.1 ad */
2445 1.5 ad int iop_util_eventreg(struct iop_softc *sc, struct iop_initiator *ii, int mask)
2446 1.5 ad {
2447 1.11 ad struct i2o_util_event_register mf;
2448 1.5 ad
2449 1.11 ad mf.msgflags = I2O_MSGFLAGS(i2o_util_event_register);
2450 1.11 ad mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_EVENT_REGISTER);
2451 1.11 ad mf.msgictx = ii->ii_ictx;
2452 1.15 ad mf.msgtctx = 0;
2453 1.11 ad mf.eventmask = mask;
2454 1.5 ad
2455 1.11 ad /* This message is replied to only when events are signalled. */
2456 1.15 ad return (iop_post(sc, (u_int32_t *)&mf));
2457 1.5 ad }
2458 1.5 ad
2459 1.1 ad int
2460 1.61 christos iopopen(dev_t dev, int flag, int mode, struct lwp *l)
2461 1.1 ad {
2462 1.5 ad struct iop_softc *sc;
2463 1.5 ad
2464 1.73 tsutsui if ((sc = device_lookup_private(&iop_cd, minor(dev))) == NULL)
2465 1.11 ad return (ENXIO);
2466 1.11 ad if ((sc->sc_flags & IOP_ONLINE) == 0)
2467 1.1 ad return (ENXIO);
2468 1.5 ad if ((sc->sc_flags & IOP_OPEN) != 0)
2469 1.5 ad return (EBUSY);
2470 1.5 ad sc->sc_flags |= IOP_OPEN;
2471 1.5 ad
2472 1.5 ad return (0);
2473 1.1 ad }
2474 1.1 ad
2475 1.5 ad int
2476 1.61 christos iopclose(dev_t dev, int flag, int mode,
2477 1.61 christos struct lwp *l)
2478 1.1 ad {
2479 1.5 ad struct iop_softc *sc;
2480 1.1 ad
2481 1.73 tsutsui sc = device_lookup_private(&iop_cd, minor(dev));
2482 1.11 ad sc->sc_flags &= ~IOP_OPEN;
2483 1.15 ad
2484 1.5 ad return (0);
2485 1.1 ad }
2486 1.1 ad
2487 1.1 ad int
2488 1.64 christos iopioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
2489 1.1 ad {
2490 1.5 ad struct iop_softc *sc;
2491 1.5 ad struct iovec *iov;
2492 1.5 ad int rv, i;
2493 1.5 ad
2494 1.73 tsutsui sc = device_lookup_private(&iop_cd, minor(dev));
2495 1.63 ad rv = 0;
2496 1.5 ad
2497 1.5 ad switch (cmd) {
2498 1.5 ad case IOPIOCPT:
2499 1.62 elad rv = kauth_authorize_device_passthru(l->l_cred, dev,
2500 1.62 elad KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data);
2501 1.60 elad if (rv)
2502 1.60 elad return (rv);
2503 1.56 christos
2504 1.51 christos return (iop_passthrough(sc, (struct ioppt *)data, l->l_proc));
2505 1.5 ad
2506 1.11 ad case IOPIOCGSTATUS:
2507 1.11 ad iov = (struct iovec *)data;
2508 1.11 ad i = sizeof(struct i2o_status);
2509 1.11 ad if (i > iov->iov_len)
2510 1.11 ad i = iov->iov_len;
2511 1.11 ad else
2512 1.11 ad iov->iov_len = i;
2513 1.11 ad if ((rv = iop_status_get(sc, 0)) == 0)
2514 1.11 ad rv = copyout(&sc->sc_status, iov->iov_base, i);
2515 1.11 ad return (rv);
2516 1.5 ad
2517 1.11 ad case IOPIOCGLCT:
2518 1.11 ad case IOPIOCGTIDMAP:
2519 1.11 ad case IOPIOCRECONFIG:
2520 1.11 ad break;
2521 1.5 ad
2522 1.11 ad default:
2523 1.11 ad #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
2524 1.82 chs printf("%s: unknown ioctl %lx\n", device_xname(sc->sc_dev), cmd);
2525 1.11 ad #endif
2526 1.11 ad return (ENOTTY);
2527 1.11 ad }
2528 1.5 ad
2529 1.63 ad mutex_enter(&sc->sc_conflock);
2530 1.1 ad
2531 1.11 ad switch (cmd) {
2532 1.5 ad case IOPIOCGLCT:
2533 1.5 ad iov = (struct iovec *)data;
2534 1.11 ad i = le16toh(sc->sc_lct->tablesize) << 2;
2535 1.5 ad if (i > iov->iov_len)
2536 1.5 ad i = iov->iov_len;
2537 1.5 ad else
2538 1.5 ad iov->iov_len = i;
2539 1.11 ad rv = copyout(sc->sc_lct, iov->iov_base, i);
2540 1.5 ad break;
2541 1.5 ad
2542 1.5 ad case IOPIOCRECONFIG:
2543 1.63 ad rv = iop_reconfigure(sc, 0);
2544 1.9 ad break;
2545 1.9 ad
2546 1.9 ad case IOPIOCGTIDMAP:
2547 1.9 ad iov = (struct iovec *)data;
2548 1.11 ad i = sizeof(struct iop_tidmap) * sc->sc_nlctent;
2549 1.11 ad if (i > iov->iov_len)
2550 1.11 ad i = iov->iov_len;
2551 1.11 ad else
2552 1.11 ad iov->iov_len = i;
2553 1.11 ad rv = copyout(sc->sc_tidmap, iov->iov_base, i);
2554 1.11 ad break;
2555 1.11 ad }
2556 1.11 ad
2557 1.63 ad mutex_exit(&sc->sc_conflock);
2558 1.11 ad return (rv);
2559 1.11 ad }
2560 1.11 ad
2561 1.11 ad static int
2562 1.15 ad iop_passthrough(struct iop_softc *sc, struct ioppt *pt, struct proc *p)
2563 1.11 ad {
2564 1.11 ad struct iop_msg *im;
2565 1.11 ad struct i2o_msg *mf;
2566 1.11 ad struct ioppt_buf *ptb;
2567 1.11 ad int rv, i, mapped;
2568 1.11 ad
2569 1.11 ad mf = NULL;
2570 1.11 ad im = NULL;
2571 1.11 ad mapped = 1;
2572 1.11 ad
2573 1.19 ad if (pt->pt_msglen > sc->sc_framesize ||
2574 1.11 ad pt->pt_msglen < sizeof(struct i2o_msg) ||
2575 1.11 ad pt->pt_nbufs > IOP_MAX_MSG_XFERS ||
2576 1.57 christos pt->pt_nbufs < 0 ||
2577 1.57 christos #if 0
2578 1.57 christos pt->pt_replylen < 0 ||
2579 1.57 christos #endif
2580 1.11 ad pt->pt_timo < 1000 || pt->pt_timo > 5*60*1000)
2581 1.11 ad return (EINVAL);
2582 1.11 ad
2583 1.11 ad for (i = 0; i < pt->pt_nbufs; i++)
2584 1.11 ad if (pt->pt_bufs[i].ptb_datalen > IOP_MAX_XFER) {
2585 1.11 ad rv = ENOMEM;
2586 1.11 ad goto bad;
2587 1.11 ad }
2588 1.11 ad
2589 1.19 ad mf = malloc(sc->sc_framesize, M_DEVBUF, M_WAITOK);
2590 1.11 ad if (mf == NULL)
2591 1.11 ad return (ENOMEM);
2592 1.11 ad
2593 1.11 ad if ((rv = copyin(pt->pt_msg, mf, pt->pt_msglen)) != 0)
2594 1.11 ad goto bad;
2595 1.11 ad
2596 1.15 ad im = iop_msg_alloc(sc, IM_WAIT | IM_NOSTATUS);
2597 1.11 ad im->im_rb = (struct i2o_reply *)mf;
2598 1.11 ad mf->msgictx = IOP_ICTX;
2599 1.11 ad mf->msgtctx = im->im_tctx;
2600 1.11 ad
2601 1.11 ad for (i = 0; i < pt->pt_nbufs; i++) {
2602 1.11 ad ptb = &pt->pt_bufs[i];
2603 1.15 ad rv = iop_msg_map(sc, im, (u_int32_t *)mf, ptb->ptb_data,
2604 1.15 ad ptb->ptb_datalen, ptb->ptb_out != 0, p);
2605 1.11 ad if (rv != 0)
2606 1.11 ad goto bad;
2607 1.11 ad mapped = 1;
2608 1.11 ad }
2609 1.11 ad
2610 1.11 ad if ((rv = iop_msg_post(sc, im, mf, pt->pt_timo)) != 0)
2611 1.11 ad goto bad;
2612 1.11 ad
2613 1.11 ad i = (le32toh(im->im_rb->msgflags) >> 14) & ~3;
2614 1.19 ad if (i > sc->sc_framesize)
2615 1.19 ad i = sc->sc_framesize;
2616 1.11 ad if (i > pt->pt_replylen)
2617 1.11 ad i = pt->pt_replylen;
2618 1.15 ad rv = copyout(im->im_rb, pt->pt_reply, i);
2619 1.9 ad
2620 1.11 ad bad:
2621 1.11 ad if (mapped != 0)
2622 1.11 ad iop_msg_unmap(sc, im);
2623 1.11 ad if (im != NULL)
2624 1.11 ad iop_msg_free(sc, im);
2625 1.11 ad if (mf != NULL)
2626 1.11 ad free(mf, M_DEVBUF);
2627 1.1 ad return (rv);
2628 1.5 ad }
2629