![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hpib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to hpib.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 root 1: /*
2: * Copyright (c) 1982, 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)hpib.c 7.1 (Berkeley) 5/8/90
21: */
22:
23: /*
24: * HPIB driver
25: */
26: #include "hpib.h"
27: #if NHPIB > 0
28:
29: #include "param.h"
30: #include "systm.h"
31: #include "buf.h"
32: #include "device.h"
33: #include "hpibvar.h"
34: #include "dmavar.h"
35:
36: #include "machine/cpu.h"
37: #include "machine/isr.h"
38:
39: int internalhpib = IOV(0x478000);
40:
41: int hpibinit(), hpibstart(), hpibgo(), hpibintr(), hpibdone();
42: struct driver hpibdriver = {
43: hpibinit, "hpib", hpibstart, hpibgo, hpibintr, hpibdone,
44: };
45:
46: struct hpib_softc hpib_softc[NHPIB];
47: struct isr hpib_isr[NHPIB];
48: int nhpibppoll(), fhpibppoll();
49:
50: int hpibtimeout = 100000; /* # of status tests before we give up */
51: int hpibidtimeout = 20000; /* # of status tests for hpibid() calls */
52:
53: hpibinit(hc)
54: register struct hp_ctlr *hc;
55: {
56: register struct hpib_softc *hs = &hpib_softc[hc->hp_unit];
57:
58: if (!nhpibtype(hc) && !fhpibtype(hc))
59: return(0);
60: hs->sc_hc = hc;
61: hs->sc_dq.dq_unit = hc->hp_unit;
62: hs->sc_dq.dq_driver = &hpibdriver;
63: hs->sc_sq.dq_forw = hs->sc_sq.dq_back = &hs->sc_sq;
64: hpib_isr[hc->hp_unit].isr_intr = hpibintr;
65: hpib_isr[hc->hp_unit].isr_ipl = hc->hp_ipl;
66: hpib_isr[hc->hp_unit].isr_arg = hc->hp_unit;
67: isrlink(&hpib_isr[hc->hp_unit]);
68: hpibreset(hc->hp_unit);
69: return(1);
70: }
71:
72: hpibreset(unit)
73: register int unit;
74: {
75: if (hpib_softc[unit].sc_type == HPIBC)
76: fhpibreset(unit);
77: else
78: nhpibreset(unit);
79: }
80:
81: hpibreq(dq)
82: register struct devqueue *dq;
83: {
84: register struct devqueue *hq;
85:
86: hq = &hpib_softc[dq->dq_ctlr].sc_sq;
87: insque(dq, hq->dq_back);
88: if (dq->dq_back == hq)
89: return(1);
90: return(0);
91: }
92:
93: hpibfree(dq)
94: register struct devqueue *dq;
95: {
96: register struct devqueue *hq;
97:
98: hq = &hpib_softc[dq->dq_ctlr].sc_sq;
99: remque(dq);
100: if ((dq = hq->dq_forw) != hq)
101: (dq->dq_driver->d_start)(dq->dq_unit);
102: }
103:
104: hpibid(unit, slave)
105: {
106: short id;
107: int ohpibtimeout;
108:
109: /*
110: * XXX: shorten timeout value (so autoconfig doesn't take forever)
111: */
112: ohpibtimeout = hpibtimeout;
113: hpibtimeout = hpibidtimeout;
114: if (hpibrecv(unit, 31, slave, &id, 2) != 2)
115: id = 0;
116: hpibtimeout = ohpibtimeout;
117: return(id);
118: }
119:
120: hpibsend(unit, slave, sec, addr, cnt)
121: register int unit;
122: {
123: if (hpib_softc[unit].sc_type == HPIBC)
124: return(fhpibsend(unit, slave, sec, addr, cnt));
125: else
126: return(nhpibsend(unit, slave, sec, addr, cnt));
127: }
128:
129: hpibrecv(unit, slave, sec, addr, cnt)
130: register int unit;
131: {
132: if (hpib_softc[unit].sc_type == HPIBC)
133: return(fhpibrecv(unit, slave, sec, addr, cnt));
134: else
135: return(nhpibrecv(unit, slave, sec, addr, cnt));
136: }
137:
138: hpibpptest(unit, slave)
139: register int unit;
140: {
141: int (*ppoll)();
142:
143: ppoll = (hpib_softc[unit].sc_type == HPIBC) ? fhpibppoll : nhpibppoll;
144: return((*ppoll)(unit) & (0x80 >> slave));
145: }
146:
147: hpibawait(unit)
148: {
149: register struct hpib_softc *hs = &hpib_softc[unit];
150:
151: hs->sc_flags |= HPIBF_PPOLL;
152: if (hs->sc_type == HPIBC)
153: fhpibppwatch(unit);
154: else
155: nhpibppwatch(unit);
156: }
157:
158: hpibswait(unit, slave)
159: register int unit;
160: {
161: register int timo = hpibtimeout;
162: register int mask, (*ppoll)();
163:
164: ppoll = (hpib_softc[unit].sc_type == HPIBC) ? fhpibppoll : nhpibppoll;
165: mask = 0x80 >> slave;
166: while (((ppoll)(unit) & mask) == 0)
167: if (--timo == 0) {
168: printf("hpib%d: swait timeout\n", unit);
169: return(-1);
170: }
171: return(0);
172: }
173:
174: hpibustart(unit)
175: {
176: register struct hpib_softc *hs = &hpib_softc[unit];
177:
178: if (hs->sc_type == HPIBA)
179: hs->sc_dq.dq_ctlr = DMA0;
180: else
181: hs->sc_dq.dq_ctlr = DMA0 | DMA1;
182: if (dmareq(&hs->sc_dq))
183: return(1);
184: return(0);
185: }
186:
187: hpibstart(unit)
188: {
189: register struct devqueue *dq;
190:
191: dq = hpib_softc[unit].sc_sq.dq_forw;
192: (dq->dq_driver->d_go)(dq->dq_unit);
193: }
194:
195: hpibgo(unit, slave, sec, addr, count, rw)
196: register int unit;
197: {
198: if (hpib_softc[unit].sc_type == HPIBC)
199: fhpibgo(unit, slave, sec, addr, count, rw);
200: else
201: nhpibgo(unit, slave, sec, addr, count, rw);
202: }
203:
204: hpibdone(unit)
205: register int unit;
206: {
207: if (hpib_softc[unit].sc_type == HPIBC)
208: fhpibdone(unit);
209: else
210: nhpibdone(unit);
211: }
212:
213: hpibintr(unit)
214: register int unit;
215: {
216: int found;
217:
218: if (hpib_softc[unit].sc_type == HPIBC)
219: found = fhpibintr(unit);
220: else
221: found = nhpibintr(unit);
222: return(found);
223: }
224: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.