![[BACK]](/icons/back.gif){kind=icon}
Return to mscp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / mscp|
Return to mscp.c CVS log | Up to [local] / sys / arch / vax / mscp |
1.1 nbrk 1: /* $OpenBSD: mscp.c,v 1.9 2005/11/24 04:53:56 brad Exp $ */
2: /* $NetBSD: mscp.c,v 1.16 2001/11/13 07:38:28 lukem Exp $ */
3:
4: /*
5: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
6: * Copyright (c) 1988 Regents of the University of California.
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to Berkeley by
10: * Chris Torek.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)mscp.c 7.5 (Berkeley) 12/16/90
37: */
38:
39: /*
40: * MSCP generic driver routines
41: */
42:
43: #include <sys/cdefs.h>
44:
45: #include <sys/param.h>
46: #include <sys/buf.h>
47: #include <sys/malloc.h>
48: #include <sys/device.h>
49: #include <sys/proc.h>
50: #include <sys/systm.h>
51:
52: #include <machine/bus.h>
53:
54: #include <arch/vax/mscp/mscp.h>
55: #include <arch/vax/mscp/mscpreg.h>
56: #include <arch/vax/mscp/mscpvar.h>
57:
58: #define PCMD PSWP /* priority for command packet waits */
59:
60: /*
61: * Get a command packet. Second argument is true iff we are
62: * to wait if necessary. Return NULL if none are available and
63: * we cannot wait.
64: */
65: struct mscp *
66: mscp_getcp(mi, canwait)
67: struct mscp_softc *mi;
68: int canwait;
69: {
70: #define mri (&mi->mi_cmd)
71: struct mscp *mp;
72: int i;
73: int s = splbio();
74:
75: again:
76: /*
77: * Ensure that we have some command credits, and
78: * that the next command packet is free.
79: */
80: if (mi->mi_credits <= MSCP_MINCREDITS) {
81: if (!canwait) {
82: splx(s);
83: return (NULL);
84: }
85: mi->mi_wantcredits = 1;
86: (void) tsleep(&mi->mi_wantcredits, PCMD, "mscpwcrd", 0);
87: goto again;
88: }
89: i = mri->mri_next;
90: if (mri->mri_desc[i] & MSCP_OWN) {
91: if (!canwait) {
92: splx(s);
93: return (NULL);
94: }
95: mi->mi_wantcmd = 1;
96: (void) tsleep(&mi->mi_wantcmd, PCMD, "mscpwcmd", 0);
97: goto again;
98: }
99: mi->mi_credits--;
100: mri->mri_desc[i] &= ~MSCP_INT;
101: mri->mri_next = (mri->mri_next + 1) % mri->mri_size;
102: splx(s);
103: mp = &mri->mri_ring[i];
104:
105: /*
106: * Initialise some often-zero fields.
107: * ARE THE LAST TWO NECESSARY IN GENERAL? IT SURE WOULD BE
108: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
109: */
110: mp->mscp_msglen = MSCP_MSGLEN;
111: mp->mscp_flags = 0;
112: mp->mscp_modifier = 0;
113: mp->mscp_seq.seq_bytecount = 0;
114: mp->mscp_seq.seq_buffer = 0;
115: mp->mscp_seq.seq_mapbase = 0;
116: /*???*/ mp->mscp_sccc.sccc_errlgfl = 0;
117: /*???*/ mp->mscp_sccc.sccc_copyspd = 0;
118: return (mp);
119: #undef mri
120: }
121:
122: #ifdef AVOID_EMULEX_BUG
123: int mscp_aeb_xor = 0x8000bb80;
124: #endif
125:
126: /*
127: * Handle a response ring transition.
128: */
129: void
130: mscp_dorsp(mi)
131: struct mscp_softc *mi;
132: {
133: struct device *drive;
134: struct mscp_device *me = mi->mi_me;
135: struct mscp_ctlr *mc = mi->mi_mc;
136: struct buf *bp;
137: struct mscp *mp;
138: struct mscp_xi *mxi;
139: int nextrsp;
140: int st, error;
141: extern int cold;
142: extern struct mscp slavereply;
143:
144: nextrsp = mi->mi_rsp.mri_next;
145: loop:
146: if (mi->mi_rsp.mri_desc[nextrsp] & MSCP_OWN) {
147: /*
148: * No more responses. Remember the next expected
149: * response index. Check to see if we have some
150: * credits back, and wake up sleepers if so.
151: */
152: mi->mi_rsp.mri_next = nextrsp;
153: if (mi->mi_wantcredits && mi->mi_credits > MSCP_MINCREDITS) {
154: mi->mi_wantcredits = 0;
155: wakeup((caddr_t) &mi->mi_wantcredits);
156: }
157: return;
158: }
159:
160: mp = &mi->mi_rsp.mri_ring[nextrsp];
161: mi->mi_credits += MSCP_CREDITS(mp->mscp_msgtc);
162: /*
163: * Controllers are allowed to interrupt as any drive, so we
164: * must check the command before checking for a drive.
165: */
166: if (mp->mscp_opcode == (M_OP_SETCTLRC | M_OP_END)) {
167: if ((mp->mscp_status & M_ST_MASK) == M_ST_SUCCESS) {
168: mi->mi_flags |= MSC_READY;
169: } else {
170: printf("%s: SETCTLRC failed: %d ",
171: mi->mi_dev.dv_xname, mp->mscp_status);
172: mscp_printevent(mp);
173: }
174: goto done;
175: }
176:
177: /*
178: * Found a response. Update credit information. If there is
179: * nothing else to do, jump to `done' to get the next response.
180: */
181: if (mp->mscp_unit >= mi->mi_driveno) { /* Must expand drive table */
182: int tmpno = ((mp->mscp_unit + 32) & 0xffe0) * sizeof(void *);
183: struct device **tmp = (struct device **)
184: malloc(tmpno, M_DEVBUF, M_NOWAIT);
185: if (tmp == NULL)
186: panic("mscp_dorsp");
187: bzero(tmp, tmpno);
188: if (mi->mi_driveno) {
189: bcopy(mi->mi_dp, tmp, mi->mi_driveno);
190: free(mi->mi_dp, mi->mi_driveno);
191: }
192: mi->mi_driveno = tmpno;
193: mi->mi_dp = tmp;
194: }
195:
196: drive = mi->mi_dp[mp->mscp_unit];
197:
198: switch (MSCP_MSGTYPE(mp->mscp_msgtc)) {
199:
200: case MSCPT_SEQ:
201: break;
202:
203: case MSCPT_DATAGRAM:
204: (*me->me_dgram)(drive, mp, mi);
205: goto done;
206:
207: case MSCPT_CREDITS:
208: goto done;
209:
210: case MSCPT_MAINTENANCE:
211: default:
212: printf("%s: unit %d: unknown message type 0x%x ignored\n",
213: mi->mi_dev.dv_xname, mp->mscp_unit,
214: MSCP_MSGTYPE(mp->mscp_msgtc));
215: goto done;
216: }
217:
218: /*
219: * Handle individual responses.
220: */
221: st = mp->mscp_status & M_ST_MASK;
222: error = 0;
223: switch (mp->mscp_opcode) {
224:
225: case M_OP_END:
226: /*
227: * The controller presents a bogus END packet when
228: * a read/write command is given with an illegal
229: * block number. This is contrary to the MSCP
230: * specification (ENDs are to be given only for
231: * invalid commands), but that is the way of it.
232: */
233: if (st == M_ST_INVALCMD && mp->mscp_cmdref != 0) {
234: printf("%s: bad lbn (%d)?\n", drive->dv_xname,
235: (int)mp->mscp_seq.seq_lbn);
236: error = EIO;
237: goto rwend;
238: }
239: goto unknown;
240:
241: case M_OP_ONLINE | M_OP_END:
242: /*
243: * Finished an ON LINE request. Call the driver to
244: * find out whether it succeeded. If so, mark it on
245: * line.
246: */
247: (*me->me_online)(drive, mp);
248: break;
249:
250: case M_OP_GETUNITST | M_OP_END:
251: /*
252: * Got unit status. If we are autoconfiguring, save
253: * the mscp struct so that mscp_attach know what to do.
254: * If the drive isn't configured, call config_found()
255: * to set it up, otherwise it's just a "normal" unit
256: * status.
257: */
258: if (cold)
259: bcopy(mp, &slavereply, sizeof(struct mscp));
260:
261: if (mp->mscp_status == (M_ST_OFFLINE|M_OFFLINE_UNKNOWN))
262: break;
263:
264: if (drive == 0) {
265: struct drive_attach_args da;
266:
267: da.da_mp = (struct mscp *)mp;
268: da.da_typ = mi->mi_type;
269: config_found(&mi->mi_dev, (void *)&da, mscp_print);
270: } else
271: /* Hack to avoid complaints */
272: if (!(((mp->mscp_event & M_ST_MASK) == M_ST_AVAILABLE)
273: && cold))
274: (*me->me_gotstatus)(drive, mp);
275: break;
276:
277: case M_OP_AVAILATTN:
278: /*
279: * The drive went offline and we did not notice.
280: * Mark it off line now, to force an on line request
281: * next, so we can make sure it is still the same
282: * drive.
283: *
284: * IF THE UDA DRIVER HAS A COMMAND AWAITING UNIBUS
285: * RESOURCES, THAT COMMAND MAY GO OUT BEFORE THE ON
286: * LINE. IS IT WORTH FIXING??
287: */
288: #ifdef notyet
289: (*md->md_offline)(ui, mp);
290: #endif
291: break;
292:
293: case M_OP_POS | M_OP_END:
294: case M_OP_WRITM | M_OP_END:
295: case M_OP_AVAILABLE | M_OP_END:
296: /*
297: * A non-data transfer operation completed.
298: */
299: (*me->me_cmddone)(drive, mp);
300: break;
301:
302: case M_OP_READ | M_OP_END:
303: case M_OP_WRITE | M_OP_END:
304: /*
305: * A transfer finished. Get the buffer, and release its
306: * map registers via ubadone(). If the command finished
307: * with an off line or available status, the drive went
308: * off line (the idiot controller does not tell us until
309: * it comes back *on* line, or until we try to use it).
310: */
311: rwend:
312: #ifdef DIAGNOSTIC
313: if (mp->mscp_cmdref >= NCMD) {
314: /*
315: * No buffer means there is a bug somewhere!
316: */
317: printf("%s: io done, but bad xfer number?\n",
318: drive->dv_xname);
319: mscp_hexdump(mp);
320: break;
321: }
322: #endif
323:
324: if (mp->mscp_cmdref == -1) {
325: (*me->me_cmddone)(drive, mp);
326: break;
327: }
328: mxi = &mi->mi_xi[mp->mscp_cmdref];
329: if (mxi->mxi_inuse == 0)
330: panic("mxi not inuse");
331: bp = mxi->mxi_bp;
332: /*
333: * Mark any error-due-to-bad-LBN (via `goto rwend').
334: * WHAT STATUS WILL THESE HAVE? IT SURE WOULD BE NICE
335: * IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
336: */
337: if (error) {
338: bp->b_flags |= B_ERROR;
339: bp->b_error = error;
340: }
341: if (st == M_ST_OFFLINE || st == M_ST_AVAILABLE) {
342: #ifdef notyet
343: (*md->md_offline)(ui, mp);
344: #endif
345: }
346:
347: /*
348: * If the transfer has something to do with bad
349: * block forwarding, let the driver handle the
350: * rest.
351: */
352: if ((bp->b_flags & B_BAD) != 0 && me->me_bb != NULL) {
353: (*me->me_bb)(drive, mp, bp);
354: goto out;
355: }
356:
357: /*
358: * If the transfer failed, give the driver a crack
359: * at fixing things up.
360: */
361: if (st != M_ST_SUCCESS) {
362: switch ((*me->me_ioerr)(drive, mp, bp)) {
363:
364: case MSCP_DONE: /* fixed */
365: break;
366:
367: case MSCP_RESTARTED: /* still working on it */
368: goto out;
369:
370: case MSCP_FAILED: /* no luck */
371: /* XXX must move to ra.c */
372: mscp_printevent(mp);
373: break;
374: }
375: }
376:
377: /*
378: * Set the residual count and mark the transfer as
379: * done. If the I/O wait queue is now empty, release
380: * the shared BDP, if any.
381: */
382: bp->b_resid = bp->b_bcount - mp->mscp_seq.seq_bytecount;
383: bus_dmamap_unload(mi->mi_dmat, mxi->mxi_dmam);
384:
385: (*mc->mc_ctlrdone)(mi->mi_dev.dv_parent);
386: (*me->me_iodone)(drive, bp);
387: out:
388: mxi->mxi_inuse = 0;
389: mi->mi_mxiuse |= (1 << mp->mscp_cmdref);
390: break;
391:
392: case M_OP_REPLACE | M_OP_END:
393: /*
394: * A replace operation finished. Just let the driver
395: * handle it (if it does replaces).
396: */
397: if (me->me_replace == NULL)
398: printf("%s: bogus REPLACE end\n", drive->dv_xname);
399: else
400: (*me->me_replace)(drive, mp);
401: break;
402:
403: default:
404: /*
405: * If it is not one of the above, we cannot handle it.
406: * (And we should not have received it, for that matter.)
407: */
408: unknown:
409: printf("%s: unknown opcode 0x%x status 0x%x ignored\n",
410: drive->dv_xname, mp->mscp_opcode, mp->mscp_status);
411: #ifdef DIAGNOSTIC
412: mscp_hexdump(mp);
413: #endif
414: break;
415: }
416:
417: /*
418: * If the drive needs to be put back in the controller queue,
419: * do that now. (`bp' below ought to be `dp', but they are all
420: * struct buf *.) Note that b_active was cleared in the driver;
421: * we presume that there is something to be done, hence reassert it.
422: */
423: #ifdef notyet /* XXX */
424: if (ui->ui_flags & UNIT_REQUEUE) {
425: ...
426: }
427: #endif
428: done:
429: /*
430: * Give back the response packet, and take a look at the next.
431: */
432: mp->mscp_msglen = MSCP_MSGLEN;
433: mi->mi_rsp.mri_desc[nextrsp] |= MSCP_OWN;
434: nextrsp = (nextrsp + 1) % mi->mi_rsp.mri_size;
435: goto loop;
436: }
437:
438: /*
439: * Requeue outstanding transfers, e.g., after bus reset.
440: * Also requeue any drives that have on line or unit status
441: * info pending.
442: */
443: void
444: mscp_requeue(mi)
445: struct mscp_softc *mi;
446: {
447: panic("mscp_requeue");
448: }
449: