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