![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ubavar.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba|
Return to ubavar.h CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba |
1.1 root 1: /* ubavar.h 6.1 83/08/13 */
2:
3: /*
4: * This file contains definitions related to the kernel structures
5: * for dealing with the unibus adapters.
6: *
7: * Each uba has a uba_hd structure.
8: * Each unibus controller which is not a device has a uba_ctlr structure.
9: * Each unibus device has a uba_device structure.
10: */
11:
12: #ifndef LOCORE
13: /*
14: * Per-uba structure.
15: *
16: * This structure holds the interrupt vector for the uba,
17: * and its address in physical and virtual space. At boot time
18: * we determine the devices attached to the uba's and their
19: * interrupt vectors, filling in uh_vec. We free the map
20: * register and bdp resources of the uba into the structures
21: * defined here.
22: *
23: * During normal operation, resources are allocated and returned
24: * to the structures here. We watch the number of passive releases
25: * on each uba, and if the number is excessive may reset the uba.
26: *
27: * When uba resources are needed and not available, or if a device
28: * which can tolerate no other uba activity (rk07) gets on the bus,
29: * then device drivers may have to wait to get to the bus and are
30: * queued here. It is also possible for processes to block in
31: * the unibus driver in resource wait (mrwant, bdpwant); these
32: * wait states are also recorded here.
33: */
34: struct uba_hd {
35: struct uba_regs *uh_uba; /* virt addr of uba */
36: struct uba_regs *uh_physuba; /* phys addr of uba */
37: int (**uh_vec)(); /* interrupt vector */
38: struct uba_device *uh_actf; /* head of queue to transfer */
39: struct uba_device *uh_actl; /* tail of queue to transfer */
40: short uh_mrwant; /* someone is waiting for map reg */
41: short uh_bdpwant; /* someone awaits bdp's */
42: int uh_bdpfree; /* free bdp's */
43: int uh_hangcnt; /* number of ticks hung */
44: int uh_zvcnt; /* number of 0 vectors */
45: int uh_errcnt; /* number of errors */
46: int uh_lastiv; /* last free interrupt vector */
47: short uh_users; /* transient bdp use count */
48: short uh_xclu; /* an rk07 is using this uba! */
49: #define UAMSIZ 25
50: struct map *uh_map; /* buffered data path regs free */
51: };
52:
53: #ifndef LOCORE
54: /*
55: * Per-controller structure.
56: * (E.g. one for each disk and tape controller, and other things
57: * which use and release buffered data paths.)
58: *
59: * If a controller has devices attached, then there are
60: * cross-referenced uba_drive structures.
61: * This structure is the one which is queued in unibus resource wait,
62: * and saves the information about unibus resources which are used.
63: * The queue of devices waiting to transfer is also attached here.
64: */
65: struct uba_ctlr {
66: struct uba_driver *um_driver;
67: short um_ctlr; /* controller index in driver */
68: short um_ubanum; /* the uba it is on */
69: short um_alive; /* controller exists */
70: int (**um_intr)(); /* interrupt handler(s) */
71: caddr_t um_addr; /* address of device in i/o space */
72: struct uba_hd *um_hd;
73: /* the driver saves the prototype command here for use in its go routine */
74: int um_cmd; /* communication to dgo() */
75: int um_ubinfo; /* save unibus registers, etc */
76: struct buf um_tab; /* queue of devices for this controller */
77: };
78:
79: /*
80: * Per ``device'' structure.
81: * (A controller has devices or uses and releases buffered data paths).
82: * (Everything else is a ``device''.)
83: *
84: * If a controller has many drives attached, then there will
85: * be several uba_device structures associated with a single uba_ctlr
86: * structure.
87: *
88: * This structure contains all the information necessary to run
89: * a unibus device such as a dz or a dh. It also contains information
90: * for slaves of unibus controllers as to which device on the slave
91: * this is. A flags field here can also be given in the system specification
92: * and is used to tell which dz lines are hard wired or other device
93: * specific parameters.
94: */
95: struct uba_device {
96: struct uba_driver *ui_driver;
97: short ui_unit; /* unit number on the system */
98: short ui_ctlr; /* mass ctlr number; -1 if none */
99: short ui_ubanum; /* the uba it is on */
100: short ui_slave; /* slave on controller */
101: int (**ui_intr)(); /* interrupt handler(s) */
102: caddr_t ui_addr; /* address of device in i/o space */
103: short ui_dk; /* if init 1 set to number for iostat */
104: int ui_flags; /* parameter from system specification */
105: short ui_alive; /* device exists */
106: short ui_type; /* driver specific type information */
107: caddr_t ui_physaddr; /* phys addr, for standalone (dump) code */
108: /* this is the forward link in a list of devices on a controller */
109: struct uba_device *ui_forw;
110: /* if the device is connected to a controller, this is the controller */
111: struct uba_ctlr *ui_mi;
112: struct uba_hd *ui_hd;
113: };
114: #endif
115:
116: /*
117: * Per-driver structure.
118: *
119: * Each unibus driver defines entries for a set of routines
120: * as well as an array of types which are acceptable to it.
121: * These are used at boot time by the configuration program.
122: */
123: struct uba_driver {
124: int (*ud_probe)(); /* see if a driver is really there */
125: int (*ud_slave)(); /* see if a slave is there */
126: int (*ud_attach)(); /* setup driver for a slave */
127: int (*ud_dgo)(); /* fill csr/ba to start transfer */
128: u_short *ud_addr; /* device csr addresses */
129: char *ud_dname; /* name of a device */
130: struct uba_device **ud_dinfo; /* backpointers to ubdinit structs */
131: char *ud_mname; /* name of a controller */
132: struct uba_ctlr **ud_minfo; /* backpointers to ubminit structs */
133: short ud_xclu; /* want exclusive use of bdp's */
134: };
135: #endif
136:
137: /*
138: * Flags to UBA map/bdp allocation routines
139: */
140: #define UBA_NEEDBDP 0x01 /* transfer needs a bdp */
141: #define UBA_CANTWAIT 0x02 /* don't block me */
142: #define UBA_NEED16 0x04 /* need 16 bit addresses only */
143: #define UBA_HAVEBDP 0x08 /* use bdp specified in high bits */
144:
145: /*
146: * Macros to bust return word from map allocation routines.
147: */
148: #define UBAI_BDP(i) ((int)(((unsigned)(i))>>28))
149: #define UBAI_NMR(i) ((int)((i)>>18)&0x3ff)
150: #define UBAI_MR(i) ((int)((i)>>9)&0x1ff)
151: #define UBAI_BOFF(i) ((int)((i)&0x1ff))
152:
153: #ifndef LOCORE
154: #ifdef KERNEL
155: /*
156: * UBA related kernel variables
157: */
158: int numuba; /* number of uba's */
159: struct uba_hd uba_hd[];
160:
161: /*
162: * Ubminit and ubdinit initialize the mass storage controller and
163: * device tables specifying possible devices.
164: */
165: extern struct uba_ctlr ubminit[];
166: extern struct uba_device ubdinit[];
167:
168: /*
169: * UNIbus device address space is mapped by UMEMmap
170: * into virtual address umem[][].
171: */
172: extern struct pte UMEMmap[][512]; /* uba device addr pte's */
173: extern char umem[][512*NBPG]; /* uba device addr space */
174:
175: /*
176: * Since some VAXen vector their unibus interrupts
177: * just adjacent to the system control block, we must
178: * allocate space there when running on ``any'' cpu. This space is
179: * used for the vectors for uba0 and uba1 on all cpu's.
180: */
181: extern int (*UNIvec[])(); /* unibus vec for uba0 */
182: #if NUBA > 1
183: extern int (*UNI1vec[])(); /* unibus vec for uba1 */
184: #endif
185:
186: #if VAX780
187: /*
188: * On 780's, we must set the scb vectors for the nexus of the
189: * UNIbus adaptors to vector to locore unibus adaptor interrupt dispatchers
190: * which make 780's look like the other VAXen.
191: */
192: extern Xua0int(), Xua1int(), Xua2int(), Xua3int();
193: #endif VAX780
194: #endif KERNEL
195: #endif !LOCORE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.