![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mscpvar.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax|
Return to mscpvar.h CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Chris Torek.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that the above copyright notice and this paragraph are
10: * duplicated in all such forms and that any documentation,
11: * advertising materials, and other materials related to such
12: * distribution and use acknowledge that the software was developed
13: * by the University of California, Berkeley. The name of the
14: * University may not be used to endorse or promote products derived
15: * from this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)mscpvar.h 7.2 (Berkeley) 7/9/88
21: */
22:
23: /*
24: * MSCP generic driver configuration
25: */
26:
27: /*
28: * Enabling MSCP_PARANOIA makes the response code perform various checks
29: * on the hardware. (Right now it verifies only the buffer pointer in
30: * mscp_cmdref.)
31: *
32: * Enabling AVOID_EMULEX_BUG selects an alternative method of identifying
33: * transfers in progress, which gets around a rather peculiar bug in the
34: * SC41/MS. Enabling MSCP_PARANOIA instead should work, but will cause
35: * `extra' Unibus resets.
36: *
37: * Either of these flags can simply be included as an `options' line in
38: * your configuration file.
39: */
40:
41: /* #define MSCP_PARANOIA */
42: /* #define AVOID_EMULEX_BUG */
43:
44: /*
45: * Per driver information.
46: *
47: * md_ndpc sets the maximum unit number allowed in response packets.
48: * md_nunits is the number of drives attached to all controllers.
49: * md_unitshift is the divisor for converting a minor device number
50: * to a unit index for the device queues in md_utab.
51: *
52: * The routines are called from the generic response dispatcher.
53: * THE FOLLOWING IS OUT OF DATE
54: * The first three (dgram, ctlrdone, and unconf) get passed a pointer
55: * to the uba_ctlr and to the packet; the rest get a pointer to the
56: * uba_device and to the packet (`um, mp' and `ui, mp' respectively).
57: * The routines unconf, online, gotstatus, and ioerr are functions
58: * and should return one of the values given below. In addition,
59: * the ioerr and bb routines get a third argument, `bp': a pointer
60: * to the buffer describing the transfer in error.
61: * END OUT OF DATE
62: */
63: struct mscp_driver {
64: int md_ndpc; /* number of drives per ctlr */
65: int md_nunits; /* total number drives (all ctlrs) */
66: int md_unitshift; /* device number to unit: >> count */
67: struct buf *md_utab; /* pointer to device queues */
68: struct disklabel *md_lab; /* pointer to devicee disklabels */
69: struct uba_device **md_dinfo; /* pointer to device info */
70: int (*md_dgram)(); /* error datagram */
71: int (*md_ctlrdone)(); /* controller operation complete */
72: int (*md_unconf)(); /* response from unconfigured drive */
73: int (*md_iodone)(); /* normal I/O is done */
74: int (*md_online)(); /* drive on line */
75: int (*md_gotstatus)(); /* got unit status */
76: int (*md_replace)(); /* replace done */
77: int (*md_ioerr)(); /* read or write failed */
78: int (*md_bb)(); /* B_BAD io done */
79: char *md_mname; /* name of controllers */
80: char *md_dname; /* name of drives */
81: };
82:
83: /*
84: * Return values from functions.
85: * MSCP_RESTARTED is peculiar to I/O errors.
86: */
87: #define MSCP_DONE 0 /* all ok */
88: #define MSCP_FAILED 1 /* no go */
89: #define MSCP_RESTARTED 2 /* transfer restarted */
90:
91: /*
92: * Ring information, per ring (one each for commands and responses).
93: */
94: struct mscp_ri {
95: int mri_size; /* ring size */
96: int mri_next; /* next (expected|free) */
97: long *mri_desc; /* base address of descriptors */
98: struct mscp *mri_ring; /* base address of packets */
99: };
100:
101: /*
102: * Per device information.
103: *
104: * mi_ip is a pointer to the inverting pointers (things that get `ui's
105: * given unit numbers) FOR THIS CONTROLLER (NOT the whole set!).
106: *
107: * mi_wtab holds a queue of those transfers that were started but have
108: * not yet finished. Other Unibus drivers do not need this as they hand
109: * out requests one at a time. MSCP devices, however, take a slew of
110: * requests and pick their own order to execute them. This means that
111: * we have to have a place to move transfers that were given to the
112: * controller, so we can tell those apart from those that have not yet
113: * been handed out; mi_wtab is that place.
114: */
115: struct mscp_info {
116: struct mscp_driver *mi_md; /* pointer to driver info */
117: int mi_ctlr; /* controller index */
118: struct buf *mi_tab; /* pointer to ctlr's drive queue */
119: struct uba_device **mi_ip; /* pointer to inverting pointers */
120: struct mscp_ri mi_cmd; /* MSCP command ring info */
121: struct mscp_ri mi_rsp; /* MSCP response ring info */
122: short mi_credits; /* transfer credits */
123: char mi_wantcmd; /* waiting for command packet */
124: char mi_wantcredits; /* waiting for transfer credits */
125: struct buf mi_wtab; /* transfer wait queue */
126: #ifdef AVOID_EMULEX_BUG
127: #define AEB_MAX_BP 32 /* max pend xfers (power of 2) XXX */
128: struct buf *mi_bp[AEB_MAX_BP]; /* xfer no. to buffer */
129: u_int mi_nextbp; /* generates unique xfer no's */
130: int mi_ok; /* for error rate statistics */
131: #endif AVOID_EMULEX_BUG
132: };
133:
134: /*
135: * We have run out of credits when mi_credits is <= MSCP_MINCREDITS.
136: * It is still possible to issue one command in this case, but it must
137: * not be a data transfer. E.g., `get command status' or `abort command'
138: * is legal, while `read' is not.
139: */
140: #define MSCP_MINCREDITS 1
141:
142: /*
143: * Flags for mscp_getcp().
144: */
145: #define MSCP_WAIT 1
146: #define MSCP_DONTWAIT 0
147:
148: struct mscp *mscp_getcp(); /* get a command packet */
149:
150: /*
151: * Unit flags
152: */
153: #define UNIT_ONLINE 0x01 /* drive is on line */
154: #define UNIT_HAVESTATUS 0x02 /* got unit status */
155: #define UNIT_REQUEUE 0x04 /* requeue after response */
156:
157: /*
158: * Handle a command ring transition: wake up sleepers for command packets.
159: * This is too simple to bother with a function call.
160: */
161: #define MSCP_DOCMD(mi) { \
162: if ((mi)->mi_wantcmd) { \
163: (mi)->mi_wantcmd = 0; \
164: wakeup((caddr_t) &(mi)->mi_wantcmd); \
165: } \
166: }
167:
168: /*
169: * The following macro appends a buffer to a drive queue or a drive to
170: * a controller queue, given the name of the forward link. Use as
171: * `APPEND(dp, &um->um_tab, b_forw)' or `APPEND(bp, dp, av_forw)',
172: * where `bp' is a transfer request, `dp' is a drive queue, and `um_tab'
173: * is a controller queue. (That is, the forward link for controller
174: * queues is `b_forw'; for drive queues, it is `av_forw'.)
175: */
176: #define APPEND(bp, queue, link) { \
177: (bp)->link = NULL; \
178: if ((queue)->b_actf == NULL) \
179: (queue)->b_actf = (bp); \
180: else \
181: (queue)->b_actl->link = (bp); \
182: (queue)->b_actl = (bp); \
183: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.