Annotation of sys/dev/i2o/ioprbs.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ioprbs.c,v 1.11 2006/11/28 23:59:45 dlg Exp $ */
2:
3: /*
4: * Copyright (c) 2001 Niklas Hallqvist
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26: * SUCH DAMAGE.
27: */
28:
29: /*-
30: * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
31: * All rights reserved.
32: *
33: * This code is derived from software contributed to The NetBSD Foundation
34: * by Andrew Doran.
35: *
36: * Redistribution and use in source and binary forms, with or without
37: * modification, are permitted provided that the following conditions
38: * are met:
39: * 1. Redistributions of source code must retain the above copyright
40: * notice, this list of conditions and the following disclaimer.
41: * 2. Redistributions in binary form must reproduce the above copyright
42: * notice, this list of conditions and the following disclaimer in the
43: * documentation and/or other materials provided with the distribution.
44: * 3. All advertising materials mentioning features or use of this software
45: * must display the following acknowledgement:
46: * This product includes software developed by the NetBSD
47: * Foundation, Inc. and its contributors.
48: * 4. Neither the name of The NetBSD Foundation nor the names of its
49: * contributors may be used to endorse or promote products derived
50: * from this software without specific prior written permission.
51: *
52: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
53: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
54: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
55: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
56: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
57: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
58: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
59: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
60: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
61: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
62: * POSSIBILITY OF SUCH DAMAGE.
63: */
64:
65: /*
66: * A driver for I2O "Random block storage" devices, like RAID.
67: */
68:
69: /*
70: * This driver would not have been written if it was not for the hardware
71: * donation from pi.se. I want to thank them for their support. It also
72: * had been much harder without Andrew Doran's work in NetBSD's ld_iop.c
73: * driver, from which I have both gotten inspiration and actual code.
74: * - Niklas Hallqvist
75: */
76:
77: #include <sys/param.h>
78: #include <sys/buf.h>
79: #include <sys/device.h>
80: #include <sys/kernel.h>
81: #include <sys/proc.h>
82: #include <sys/systm.h>
83:
84: #include <machine/bus.h>
85:
86: #include <scsi/scsi_all.h>
87: #include <scsi/scsi_disk.h>
88: #include <scsi/scsiconf.h>
89:
90: #include <dev/i2o/i2o.h>
91: #include <dev/i2o/iopio.h>
92: #include <dev/i2o/iopvar.h>
93: #include <dev/i2o/ioprbsvar.h>
94:
95: #ifdef I2ODEBUG
96: #define DPRINTF(x) printf x
97: #else
98: #define DPRINTF(x)
99: #endif
100:
101: void ioprbsminphys(struct buf *);
102: void ioprbs_adjqparam(struct device *, int);
103: void ioprbs_attach(struct device *, struct device *, void *);
104: void ioprbs_copy_internal_data(struct scsi_xfer *, u_int8_t *,
105: size_t);
106: struct scsi_xfer *ioprbs_dequeue(struct ioprbs_softc *);
107: void ioprbs_enqueue(struct ioprbs_softc *, struct scsi_xfer *, int);
108: void ioprbs_enqueue_ccb(struct ioprbs_softc *, struct ioprbs_ccb *);
109: int ioprbs_exec_ccb(struct ioprbs_ccb *);
110: void ioprbs_free_ccb(struct ioprbs_softc *, struct ioprbs_ccb *);
111: struct ioprbs_ccb *ioprbs_get_ccb(struct ioprbs_softc *, int);
112: void ioprbs_internal_cache_cmd(struct scsi_xfer *);
113: void ioprbs_intr(struct device *, struct iop_msg *, void *);
114: void ioprbs_intr_event(struct device *, struct iop_msg *, void *);
115: int ioprbs_match(struct device *, void *, void *);
116: int ioprbs_scsi_cmd(struct scsi_xfer *);
117: int ioprbs_start(struct ioprbs_ccb *);
118: void ioprbs_start_ccbs(struct ioprbs_softc *);
119: void ioprbs_timeout(void *);
120: void ioprbs_unconfig(struct ioprbs_softc *, int);
121: void ioprbs_watchdog(void *);
122:
123: struct cfdriver ioprbs_cd = {
124: NULL, "ioprbs", DV_DULL
125: };
126:
127: struct cfattach ioprbs_ca = {
128: sizeof(struct ioprbs_softc), ioprbs_match, ioprbs_attach
129: };
130:
131: struct scsi_adapter ioprbs_switch = {
132: ioprbs_scsi_cmd, ioprbsminphys, 0, 0,
133: };
134:
135: struct scsi_device ioprbs_dev = {
136: NULL, NULL, NULL, NULL
137: };
138:
139: #ifdef I2OVERBOSE
140: static const char *const ioprbs_errors[] = {
141: "success",
142: "media error",
143: "access error",
144: "device failure",
145: "device not ready",
146: "media not present",
147: "media locked",
148: "media failure",
149: "protocol failure",
150: "bus failure",
151: "access violation",
152: "media write protected",
153: "device reset",
154: "volume changed, waiting for acknowledgement",
155: "timeout",
156: };
157: #endif
158:
159: /*
160: * Match a supported device.
161: */
162: int
163: ioprbs_match(parent, match, aux)
164: struct device *parent;
165: void *match;
166: void *aux;
167: {
168: struct iop_attach_args *ia = aux;
169:
170: return (ia->ia_class == I2O_CLASS_RANDOM_BLOCK_STORAGE);
171: }
172:
173: /*
174: * Attach a supported device.
175: */
176: void
177: ioprbs_attach(struct device *parent, struct device *self, void *aux)
178: {
179: struct iop_attach_args *ia = aux;
180: struct ioprbs_softc *sc = (struct ioprbs_softc *)self;
181: struct iop_softc *iop = (struct iop_softc *)parent;
182: struct scsibus_attach_args saa;
183: int rv, state = 0;
184: int enable;
185: u_int32_t cachesz;
186: char *typestr, *fixedstr;
187: struct {
188: struct i2o_param_op_results pr;
189: struct i2o_param_read_results prr;
190: union {
191: struct i2o_param_rbs_cache_control cc;
192: struct i2o_param_rbs_device_info bdi;
193: struct i2o_param_rbs_operation op;
194: } p;
195: } param /* XXX gcc __attribute__ ((__packed__)) */;
196: int i;
197:
198: TAILQ_INIT(&sc->sc_free_ccb);
199: TAILQ_INIT(&sc->sc_ccbq);
200: LIST_INIT(&sc->sc_queue);
201:
202: /* Initialize the ccbs */
203: for (i = 0; i < IOPRBS_MAX_CCBS; i++)
204: TAILQ_INSERT_TAIL(&sc->sc_free_ccb, &sc->sc_ccbs[i],
205: ic_chain);
206:
207: /* Register us as an initiator. */
208: sc->sc_ii.ii_dv = self;
209: sc->sc_ii.ii_intr = ioprbs_intr;
210: sc->sc_ii.ii_adjqparam = ioprbs_adjqparam;
211: sc->sc_ii.ii_flags = 0;
212: sc->sc_ii.ii_tid = ia->ia_tid;
213: iop_initiator_register(iop, &sc->sc_ii);
214:
215: /* Register another initiator to handle events from the device. */
216: sc->sc_eventii.ii_dv = self;
217: sc->sc_eventii.ii_intr = ioprbs_intr_event;
218: sc->sc_eventii.ii_flags = II_DISCARD | II_UTILITY;
219: sc->sc_eventii.ii_tid = ia->ia_tid;
220: iop_initiator_register(iop, &sc->sc_eventii);
221:
222: rv = iop_util_eventreg(iop, &sc->sc_eventii,
223: I2O_EVENT_GEN_EVENT_MASK_MODIFIED | I2O_EVENT_GEN_DEVICE_RESET |
224: I2O_EVENT_GEN_STATE_CHANGE | I2O_EVENT_GEN_GENERAL_WARNING);
225: if (rv != 0) {
226: printf("%s: unable to register for events", self->dv_xname);
227: goto bad;
228: }
229: state++;
230:
231: /*
232: * Start out with one queued command. The `iop' driver will adjust
233: * the queue parameters once we're up and running.
234: */
235: sc->sc_maxqueuecnt = 1;
236:
237: sc->sc_maxxfer = IOP_MAX_XFER;
238:
239: /* Say what the device is. */
240: printf(":");
241: iop_print_ident(iop, ia->ia_tid);
242:
243: /*
244: * Claim the device so that we don't get any nasty surprises. Allow
245: * failure.
246: */
247: rv = iop_util_claim(iop, &sc->sc_ii, 0,
248: I2O_UTIL_CLAIM_CAPACITY_SENSITIVE |
249: I2O_UTIL_CLAIM_NO_PEER_SERVICE |
250: I2O_UTIL_CLAIM_NO_MANAGEMENT_SERVICE |
251: I2O_UTIL_CLAIM_PRIMARY_USER);
252: sc->sc_flags = rv ? 0 : IOPRBS_CLAIMED;
253:
254: rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_RBS_DEVICE_INFO,
255: ¶m, sizeof param);
256: if (rv != 0) {
257: printf("%s: unable to get parameters (0x%04x; %d)\n",
258: sc->sc_dv.dv_xname, I2O_PARAM_RBS_DEVICE_INFO, rv);
259: goto bad;
260: }
261:
262: sc->sc_secsize = letoh32(param.p.bdi.blocksize);
263: sc->sc_secperunit = (int)
264: (letoh64(param.p.bdi.capacity) / sc->sc_secsize);
265:
266: switch (param.p.bdi.type) {
267: case I2O_RBS_TYPE_DIRECT:
268: typestr = "direct access";
269: enable = 1;
270: break;
271: case I2O_RBS_TYPE_WORM:
272: typestr = "WORM";
273: enable = 0;
274: break;
275: case I2O_RBS_TYPE_CDROM:
276: typestr = "CD-ROM";
277: enable = 0;
278: break;
279: case I2O_RBS_TYPE_OPTICAL:
280: typestr = "optical";
281: enable = 0;
282: break;
283: default:
284: typestr = "unknown";
285: enable = 0;
286: break;
287: }
288:
289: if ((letoh32(param.p.bdi.capabilities) & I2O_RBS_CAP_REMOVABLE_MEDIA)
290: != 0) {
291: /* sc->sc_flags = IOPRBS_REMOVABLE; */
292: fixedstr = "removable";
293: enable = 0;
294: } else
295: fixedstr = "fixed";
296:
297: printf(" %s, %s", typestr, fixedstr);
298:
299: /*
300: * Determine if the device has an private cache. If so, print the
301: * cache size. Even if the device doesn't appear to have a cache,
302: * we perform a flush at shutdown.
303: */
304: rv = iop_param_op(iop, ia->ia_tid, NULL, 0,
305: I2O_PARAM_RBS_CACHE_CONTROL, ¶m, sizeof(param));
306: if (rv != 0) {
307: printf("%s: unable to get parameters (0x%04x; %d)\n",
308: sc->sc_dv.dv_xname, I2O_PARAM_RBS_CACHE_CONTROL, rv);
309: goto bad;
310: }
311:
312: if ((cachesz = letoh32(param.p.cc.totalcachesize)) != 0)
313: printf(", %dkB cache", cachesz >> 10);
314:
315: printf("\n");
316:
317: /*
318: * Configure the DDM's timeout functions to time out all commands
319: * after 30 seconds.
320: */
321: rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_RBS_OPERATION,
322: ¶m, sizeof(param));
323: if (rv != 0) {
324: printf("%s: unable to get parameters (0x%04x; %d)\n",
325: sc->sc_dv.dv_xname, I2O_PARAM_RBS_OPERATION, rv);
326: goto bad;
327: }
328:
329: param.p.op.timeoutbase = htole32(IOPRBS_TIMEOUT * 1000);
330: param.p.op.rwvtimeoutbase = htole32(IOPRBS_TIMEOUT * 1000);
331: param.p.op.rwvtimeout = 0;
332:
333: rv = iop_param_op(iop, ia->ia_tid, NULL, 1, I2O_PARAM_RBS_OPERATION,
334: ¶m, sizeof(param));
335: #ifdef notdef
336: /*
337: * Intel RAID adapters don't like the above, but do post a
338: * `parameter changed' event. Perhaps we're doing something
339: * wrong...
340: */
341: if (rv != 0) {
342: printf("%s: unable to set parameters (0x%04x; %d)\n",
343: sc->sc_dv.dv_xname, I2O_PARAM_RBS_OPERATION, rv);
344: goto bad;
345: }
346: #endif
347:
348: if (enable)
349: sc->sc_flags |= IOPRBS_ENABLED;
350: else
351: printf("%s: device not yet supported\n", self->dv_xname);
352:
353: /* Fill in the prototype scsi_link. */
354: sc->sc_link.adapter_softc = sc;
355: sc->sc_link.adapter = &ioprbs_switch;
356: sc->sc_link.device = &ioprbs_dev;
357: sc->sc_link.openings = 1;
358: sc->sc_link.adapter_buswidth = 1;
359: sc->sc_link.adapter_target = 1;
360:
361: bzero(&saa, sizeof(saa));
362: saa.saa_sc_link = &sc->sc_link;
363:
364: config_found(&sc->sc_dv, &saa, scsiprint);
365:
366: return;
367:
368: bad:
369: ioprbs_unconfig(sc, state > 0);
370: }
371:
372: void
373: ioprbs_unconfig(struct ioprbs_softc *sc, int evreg)
374: {
375: struct iop_softc *iop;
376: int s;
377:
378: iop = (struct iop_softc *)sc->sc_dv.dv_parent;
379:
380: if ((sc->sc_flags & IOPRBS_CLAIMED) != 0)
381: iop_util_claim(iop, &sc->sc_ii, 1,
382: I2O_UTIL_CLAIM_PRIMARY_USER);
383:
384: if (evreg) {
385: /*
386: * Mask off events, and wait up to 5 seconds for a reply.
387: * Note that some adapters won't reply to this (XXX We
388: * should check the event capabilities).
389: */
390: sc->sc_flags &= ~IOPRBS_NEW_EVTMASK;
391: iop_util_eventreg(iop, &sc->sc_eventii,
392: I2O_EVENT_GEN_EVENT_MASK_MODIFIED);
393: s = splbio();
394: if ((sc->sc_flags & IOPRBS_NEW_EVTMASK) == 0)
395: tsleep(&sc->sc_eventii, PRIBIO, "ioprbsevt", hz * 5);
396: splx(s);
397: #ifdef I2ODEBUG
398: if ((sc->sc_flags & IOPRBS_NEW_EVTMASK) == 0)
399: printf("%s: didn't reply to event unregister",
400: sc->sc_dv.dv_xname);
401: #endif
402: }
403:
404: iop_initiator_unregister(iop, &sc->sc_eventii);
405: iop_initiator_unregister(iop, &sc->sc_ii);
406: }
407:
408: int
409: ioprbs_scsi_cmd(xs)
410: struct scsi_xfer *xs;
411: {
412: struct scsi_link *link = xs->sc_link;
413: struct ioprbs_softc *sc = link->adapter_softc;
414: struct ioprbs_ccb *ccb;
415: u_int32_t blockno, blockcnt;
416: struct scsi_rw *rw;
417: struct scsi_rw_big *rwb;
418: ioprbs_lock_t lock;
419: int retval = SUCCESSFULLY_QUEUED;
420:
421: lock = IOPRBS_LOCK(sc);
422:
423: /* Don't double enqueue if we came from ioprbs_chain. */
424: if (xs != LIST_FIRST(&sc->sc_queue))
425: ioprbs_enqueue(sc, xs, 0);
426:
427: while ((xs = ioprbs_dequeue(sc))) {
428: xs->error = XS_NOERROR;
429:
430: ccb = NULL;
431:
432: switch (xs->cmd->opcode) {
433: case TEST_UNIT_READY:
434: case REQUEST_SENSE:
435: case INQUIRY:
436: case MODE_SENSE:
437: case START_STOP:
438: case READ_CAPACITY:
439: #if 0
440: case VERIFY:
441: #endif
442: ioprbs_internal_cache_cmd(xs);
443: xs->flags |= ITSDONE;
444: scsi_done(xs);
445: goto ready;
446:
447: case PREVENT_ALLOW:
448: DPRINTF(("PREVENT/ALLOW "));
449: /* XXX Not yet implemented */
450: xs->error = XS_NOERROR;
451: xs->flags |= ITSDONE;
452: scsi_done(xs);
453: goto ready;
454:
455: case SYNCHRONIZE_CACHE:
456: DPRINTF(("SYNCHRONIZE_CACHE "));
457: /* XXX Not yet implemented */
458: xs->error = XS_NOERROR;
459: xs->flags |= ITSDONE;
460: scsi_done(xs);
461: goto ready;
462:
463: default:
464: DPRINTF(("unknown opc %d ", xs->cmd->opcode));
465: /* XXX Not yet implemented */
466: xs->error = XS_DRIVER_STUFFUP;
467: xs->flags |= ITSDONE;
468: scsi_done(xs);
469: goto ready;
470:
471: case READ_COMMAND:
472: case READ_BIG:
473: case WRITE_COMMAND:
474: case WRITE_BIG:
475: DPRINTF(("rw opc %d ", xs->cmd->opcode));
476:
477: if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
478: /* A read or write operation. */
479: if (xs->cmdlen == 6) {
480: rw = (struct scsi_rw *)xs->cmd;
481: blockno = _3btol(rw->addr) &
482: (SRW_TOPADDR << 16 | 0xffff);
483: blockcnt =
484: rw->length ? rw->length : 0x100;
485: } else {
486: rwb = (struct scsi_rw_big *)xs->cmd;
487: blockno = _4btol(rwb->addr);
488: blockcnt = _2btol(rwb->length);
489: }
490: if (blockno >= sc->sc_secperunit ||
491: blockno + blockcnt > sc->sc_secperunit) {
492: printf(
493: "%s: out of bounds %u-%u >= %u\n",
494: sc->sc_dv.dv_xname, blockno,
495: blockcnt, sc->sc_secperunit);
496: /*
497: * XXX Should be XS_SENSE but that
498: * would require setting up a faked
499: * sense too.
500: */
501: xs->error = XS_DRIVER_STUFFUP;
502: xs->flags |= ITSDONE;
503: scsi_done(xs);
504: goto ready;
505: }
506: }
507:
508: ccb = ioprbs_get_ccb(sc, xs->flags);
509:
510: /*
511: * We are out of commands, try again in a little while.
512: */
513: if (ccb == NULL) {
514: IOPRBS_UNLOCK(sc, lock);
515: return (TRY_AGAIN_LATER);
516: }
517:
518: ccb->ic_blockno = blockno;
519: ccb->ic_blockcnt = blockcnt;
520: ccb->ic_xs = xs;
521: ccb->ic_timeout = xs->timeout;
522:
523: ioprbs_enqueue_ccb(sc, ccb);
524:
525: /* XXX what if enqueue did not start a transfer? */
526: if (xs->flags & SCSI_POLL) {
527: #if 0
528: if (!ioprbs_wait(sc, ccb, ccb->ic_timeout)) {
529: IOPRBS_UNLOCK(sc, lock);
530: printf("%s: command timed out\n",
531: sc->sc_dv.dv_xname);
532: return (TRY_AGAIN_LATER);
533: }
534: xs->flags |= ITSDONE;
535: scsi_done(xs);
536: #endif
537: }
538: }
539:
540: ready:
541: /*
542: * Don't process the queue if we are polling.
543: */
544: if (xs->flags & SCSI_POLL) {
545: retval = COMPLETE;
546: break;
547: }
548: }
549:
550: IOPRBS_UNLOCK(sc, lock);
551: return (retval);
552: }
553:
554: void
555: ioprbsminphys(bp)
556: struct buf *bp;
557: {
558: minphys(bp);
559: }
560:
561: void
562: ioprbs_intr(struct device *dv, struct iop_msg *im, void *reply)
563: {
564: struct i2o_rbs_reply *rb = reply;
565: struct ioprbs_ccb *ccb = im->im_dvcontext;
566: struct buf *bp = ccb->ic_xs->bp;
567: struct ioprbs_softc *sc = (struct ioprbs_softc *)dv;
568: struct iop_softc *iop = (struct iop_softc *)dv->dv_parent;
569: int err, detail;
570: #ifdef I2OVERBOSE
571: const char *errstr;
572: #endif
573:
574: DPRINTF(("ioprbs_intr(%p, %p, %p) ", dv, im, reply));
575:
576: timeout_del(&ccb->ic_xs->stimeout);
577:
578: err = ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0);
579:
580: if (!err && rb->reqstatus != I2O_STATUS_SUCCESS) {
581: detail = letoh16(rb->detail);
582: #ifdef I2OVERBOSE
583: if (detail > sizeof(ioprbs_errors) / sizeof(ioprbs_errors[0]))
584: errstr = "<unknown>";
585: else
586: errstr = ioprbs_errors[detail];
587: printf("%s: error 0x%04x: %s\n", dv->dv_xname, detail, errstr);
588: #else
589: printf("%s: error 0x%04x\n", dv->dv_xname, detail);
590: #endif
591: err = 1;
592: }
593:
594: if (bp) {
595: if (err) {
596: bp->b_flags |= B_ERROR;
597: bp->b_error = EIO;
598: bp->b_resid = bp->b_bcount;
599: } else
600: bp->b_resid = bp->b_bcount - letoh32(rb->transfercount);
601: }
602:
603: iop_msg_unmap(iop, im);
604: iop_msg_free(iop, im);
605: scsi_done(ccb->ic_xs);
606: ioprbs_free_ccb(sc, ccb);
607: }
608:
609: void
610: ioprbs_intr_event(struct device *dv, struct iop_msg *im, void *reply)
611: {
612: struct i2o_util_event_register_reply *rb;
613: struct ioprbs_softc *sc;
614: u_int event;
615:
616: rb = reply;
617:
618: if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
619: return;
620:
621: event = letoh32(rb->event);
622: sc = (struct ioprbs_softc *)dv;
623:
624: if (event == I2O_EVENT_GEN_EVENT_MASK_MODIFIED) {
625: sc->sc_flags |= IOPRBS_NEW_EVTMASK;
626: wakeup(&sc->sc_eventii);
627: #ifndef I2ODEBUG
628: return;
629: #endif
630: }
631:
632: printf("%s: event 0x%08x received\n", dv->dv_xname, event);
633: }
634:
635: void
636: ioprbs_adjqparam(struct device *dv, int mpi)
637: {
638: #if 0
639: struct iop_softc *iop;
640:
641: /*
642: * AMI controllers seem to lose the plot if you hand off lots of
643: * queued commands.
644: */
645: iop = (struct iop_softc *)dv->dv_parent;
646: if (letoh16(I2O_ORG_AMI) == iop->sc_status.orgid && mpi > 64)
647: mpi = 64;
648:
649: ldadjqparam((struct ld_softc *)dv, mpi);
650: #endif
651: }
652:
653: /*
654: * Insert a command into the driver queue, either at the front or at the tail.
655: * It's ok to overload the freelist link as these structures are never on
656: * the freelist at this time.
657: */
658: void
659: ioprbs_enqueue(sc, xs, infront)
660: struct ioprbs_softc *sc;
661: struct scsi_xfer *xs;
662: int infront;
663: {
664: if (infront || LIST_FIRST(&sc->sc_queue) == NULL) {
665: if (LIST_FIRST(&sc->sc_queue) == NULL)
666: sc->sc_queuelast = xs;
667: LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
668: return;
669: }
670: LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
671: sc->sc_queuelast = xs;
672: }
673:
674: /*
675: * Pull a command off the front of the driver queue.
676: */
677: struct scsi_xfer *
678: ioprbs_dequeue(sc)
679: struct ioprbs_softc *sc;
680: {
681: struct scsi_xfer *xs;
682:
683: xs = LIST_FIRST(&sc->sc_queue);
684: if (xs == NULL)
685: return (NULL);
686: LIST_REMOVE(xs, free_list);
687:
688: if (LIST_FIRST(&sc->sc_queue) == NULL)
689: sc->sc_queuelast = NULL;
690:
691: return (xs);
692: }
693:
694: void
695: ioprbs_copy_internal_data(xs, data, size)
696: struct scsi_xfer *xs;
697: u_int8_t *data;
698: size_t size;
699: {
700: size_t copy_cnt;
701:
702: DPRINTF(("ioprbs_copy_internal_data "));
703:
704: if (!xs->datalen)
705: printf("uio move not yet supported\n");
706: else {
707: copy_cnt = MIN(size, xs->datalen);
708: bcopy(data, xs->data, copy_cnt);
709: }
710: }
711:
712: /* Emulated SCSI operation on cache device */
713: void
714: ioprbs_internal_cache_cmd(xs)
715: struct scsi_xfer *xs;
716: {
717: struct scsi_link *link = xs->sc_link;
718: struct ioprbs_softc *sc = link->adapter_softc;
719: u_int8_t target = link->target;
720: struct scsi_inquiry_data inq;
721: struct scsi_sense_data sd;
722: struct scsi_read_cap_data rcd;
723:
724: DPRINTF(("ioprbs_internal_cache_cmd "));
725:
726: xs->error = XS_NOERROR;
727:
728: if (target > 0 || link->lun != 0) {
729: xs->error = XS_DRIVER_STUFFUP;
730: return;
731: }
732:
733: switch (xs->cmd->opcode) {
734: case TEST_UNIT_READY:
735: case START_STOP:
736: #if 0
737: case VERIFY:
738: #endif
739: DPRINTF(("opc %d tgt %d ", xs->cmd->opcode, target));
740: break;
741:
742: case REQUEST_SENSE:
743: DPRINTF(("REQUEST SENSE tgt %d ", target));
744: bzero(&sd, sizeof sd);
745: sd.error_code = 0x70;
746: sd.segment = 0;
747: sd.flags = SKEY_NO_SENSE;
748: bzero(sd.info, sizeof sd.info);
749: sd.extra_len = 0;
750: ioprbs_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
751: break;
752:
753: case INQUIRY:
754: DPRINTF(("INQUIRY tgt %d", target));
755: bzero(&inq, sizeof inq);
756: /* XXX How do we detect removable/CD-ROM devices? */
757: inq.device = T_DIRECT;
758: inq.dev_qual2 = 0;
759: inq.version = 2;
760: inq.response_format = 2;
761: inq.additional_length = 32;
762: strlcpy(inq.vendor, "I2O", sizeof inq.vendor);
763: snprintf(inq.product, sizeof inq.product, "Container #%02d",
764: target);
765: strlcpy(inq.revision, " ", sizeof inq.revision);
766: ioprbs_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
767: break;
768:
769: case READ_CAPACITY:
770: DPRINTF(("READ CAPACITY tgt %d ", target));
771: bzero(&rcd, sizeof rcd);
772: _lto4b(sc->sc_secperunit - 1, rcd.addr);
773: _lto4b(IOPRBS_BLOCK_SIZE, rcd.length);
774: ioprbs_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
775: break;
776:
777: default:
778: DPRINTF(("unsupported scsi command %#x tgt %d ",
779: xs->cmd->opcode, target));
780: xs->error = XS_DRIVER_STUFFUP;
781: return;
782: }
783:
784: xs->error = XS_NOERROR;
785: }
786:
787: struct ioprbs_ccb *
788: ioprbs_get_ccb(sc, flags)
789: struct ioprbs_softc *sc;
790: int flags;
791: {
792: struct ioprbs_ccb *ccb;
793: ioprbs_lock_t lock;
794:
795: DPRINTF(("ioprbs_get_ccb(%p, 0x%x) ", sc, flags));
796:
797: lock = IOPRBS_LOCK(sc);
798:
799: for (;;) {
800: ccb = TAILQ_FIRST(&sc->sc_free_ccb);
801: if (ccb != NULL)
802: break;
803: if (flags & SCSI_NOSLEEP)
804: goto bail_out;
805: tsleep(&sc->sc_free_ccb, PRIBIO, "ioprbs_ccb", 0);
806: }
807:
808: TAILQ_REMOVE(&sc->sc_free_ccb, ccb, ic_chain);
809:
810: /* initialise the command */
811: ccb->ic_flags = 0;
812:
813: bail_out:
814: IOPRBS_UNLOCK(sc, lock);
815: return (ccb);
816: }
817:
818: void
819: ioprbs_free_ccb(sc, ccb)
820: struct ioprbs_softc *sc;
821: struct ioprbs_ccb *ccb;
822: {
823: ioprbs_lock_t lock;
824:
825: DPRINTF(("ioprbs_free_ccb(%p, %p) ", sc, ccb));
826:
827: lock = IOPRBS_LOCK(sc);
828:
829: TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, ic_chain);
830:
831: /* If the free list was empty, wake up potential waiters. */
832: if (TAILQ_NEXT(ccb, ic_chain) == NULL)
833: wakeup(&sc->sc_free_ccb);
834:
835: IOPRBS_UNLOCK(sc, lock);
836: }
837:
838: void
839: ioprbs_enqueue_ccb(sc, ccb)
840: struct ioprbs_softc *sc;
841: struct ioprbs_ccb *ccb;
842: {
843: DPRINTF(("ioprbs_enqueue_ccb(%p, %p) ", sc, ccb));
844:
845: timeout_set(&ccb->ic_xs->stimeout, ioprbs_timeout, ccb);
846: TAILQ_INSERT_TAIL(&sc->sc_ccbq, ccb, ic_chain);
847: ioprbs_start_ccbs(sc);
848: }
849:
850: void
851: ioprbs_start_ccbs(sc)
852: struct ioprbs_softc *sc;
853: {
854: struct ioprbs_ccb *ccb;
855: struct scsi_xfer *xs;
856:
857: DPRINTF(("ioprbs_start_ccbs(%p) ", sc));
858:
859: while ((ccb = TAILQ_FIRST(&sc->sc_ccbq)) != NULL) {
860:
861: xs = ccb->ic_xs;
862: if (ccb->ic_flags & IOPRBS_ICF_WATCHDOG)
863: timeout_del(&xs->stimeout);
864:
865: if (ioprbs_exec_ccb(ccb) == 0) {
866: ccb->ic_flags |= IOPRBS_ICF_WATCHDOG;
867: timeout_set(&ccb->ic_xs->stimeout, ioprbs_watchdog,
868: ccb);
869: timeout_add(&xs->stimeout,
870: (IOPRBS_WATCH_TIMEOUT * hz) / 1000);
871: break;
872: }
873: TAILQ_REMOVE(&sc->sc_ccbq, ccb, ic_chain);
874:
875: if ((xs->flags & SCSI_POLL) == 0) {
876: timeout_set(&ccb->ic_xs->stimeout, ioprbs_timeout,
877: ccb);
878: timeout_add(&xs->stimeout,
879: (ccb->ic_timeout * hz) / 1000);
880: }
881: }
882: }
883:
884: int
885: ioprbs_exec_ccb(ccb)
886: struct ioprbs_ccb *ccb;
887: {
888: struct scsi_xfer *xs = ccb->ic_xs;
889:
890: DPRINTF(("ioprbs_exec_ccb(%p, %p) ", xs, ccb));
891:
892: ioprbs_start(ccb);
893:
894: xs->error = XS_NOERROR;
895: xs->resid = 0;
896: return (1);
897: }
898:
899: /*
900: * Deliver a command to the controller; allocate controller resources at the
901: * last moment when possible.
902: */
903: int
904: ioprbs_start(struct ioprbs_ccb *ccb)
905: {
906: struct scsi_xfer *xs = ccb->ic_xs;
907: struct scsi_link *link = xs->sc_link;
908: struct ioprbs_softc *sc = link->adapter_softc;
909: #ifdef I2ODEBUG
910: u_int8_t target = link->target;
911: #endif
912: struct iop_msg *im;
913: struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
914: struct i2o_rbs_block_read *mf;
915: u_int rv, flags = 0, mode = I2O_RBS_BLOCK_READ;
916: u_int64_t ba;
917: u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
918:
919: im = iop_msg_alloc(iop, &sc->sc_ii, 0);
920: im->im_dvcontext = ccb;
921:
922: switch (xs->cmd->opcode) {
923: case PREVENT_ALLOW:
924: case SYNCHRONIZE_CACHE:
925: if (xs->cmd->opcode == PREVENT_ALLOW) {
926: /* XXX PREVENT_ALLOW support goes here */
927: } else {
928: DPRINTF(("SYNCHRONIZE CACHE tgt %d ", target));
929: }
930: break;
931:
932: case WRITE_COMMAND:
933: case WRITE_BIG:
934: flags = I2O_RBS_BLOCK_WRITE_CACHE_WB;
935: mode = I2O_RBS_BLOCK_WRITE;
936: /* FALLTHROUGH */
937:
938: case READ_COMMAND:
939: case READ_BIG:
940: ba = (u_int64_t)ccb->ic_blockno * DEV_BSIZE;
941:
942: /*
943: * Fill the message frame. We can use the block_read
944: * structure for both reads and writes, as it's almost
945: * identical to the * block_write structure.
946: */
947: mf = (struct i2o_rbs_block_read *)mb;
948: mf->msgflags = I2O_MSGFLAGS(i2o_rbs_block_read);
949: mf->msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, mode);
950: mf->msgictx = sc->sc_ii.ii_ictx;
951: mf->msgtctx = im->im_tctx;
952: mf->flags = flags | (1 << 16); /* flags & time multiplier */
953: mf->datasize = ccb->ic_blockcnt * DEV_BSIZE;
954: mf->lowoffset = (u_int32_t)ba;
955: mf->highoffset = (u_int32_t)(ba >> 32);
956:
957: /* Map the data transfer and enqueue the command. */
958: rv = iop_msg_map_bio(iop, im, mb, xs->data,
959: ccb->ic_blockcnt * DEV_BSIZE, mode == I2O_RBS_BLOCK_WRITE);
960: if (rv == 0) {
961: if ((rv = iop_msg_post(iop, im, mb, 0)) != 0) {
962: iop_msg_unmap(iop, im);
963: iop_msg_free(iop, im);
964: }
965: }
966: break;
967: }
968: return (0);
969: }
970:
971: void
972: ioprbs_timeout(arg)
973: void *arg;
974: {
975: struct ioprbs_ccb *ccb = arg;
976: struct scsi_link *link = ccb->ic_xs->sc_link;
977: struct ioprbs_softc *sc = link->adapter_softc;
978: ioprbs_lock_t lock;
979:
980: sc_print_addr(link);
981: printf("timed out\n");
982:
983: /* XXX Test for multiple timeouts */
984:
985: ccb->ic_xs->error = XS_TIMEOUT;
986: lock = IOPRBS_LOCK(sc);
987: ioprbs_enqueue_ccb(sc, ccb);
988: IOPRBS_UNLOCK(sc, lock);
989: }
990:
991: void
992: ioprbs_watchdog(arg)
993: void *arg;
994: {
995: struct ioprbs_ccb *ccb = arg;
996: struct scsi_link *link = ccb->ic_xs->sc_link;
997: struct ioprbs_softc *sc = link->adapter_softc;
998: ioprbs_lock_t lock;
999:
1000: lock = IOPRBS_LOCK(sc);
1001: ccb->ic_flags &= ~IOPRBS_ICF_WATCHDOG;
1002: ioprbs_start_ccbs(sc);
1003: IOPRBS_UNLOCK(sc, lock);
1004: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ioprbs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / i2o