![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)io.c 1.7 (Berkeley/CCI) 6/7/88";
3: #endif
4:
5: #include "vdfmt.h"
6: #include "cmd.h"
7:
8:
9: /*
10: **
11: */
12:
13: static cmd_text_element nul_table[] = {
14: { 0, "", "" }
15: };
16:
17: int wait_for_char;
18: int vdtimeout;
19: char *clean_up = "Cleaning up... Please wait.\n";
20:
21:
22: /*
23: **
24: */
25:
26: poll(wait)
27: int wait;
28: {
29: register struct vddevice *addr = C_INFO->addr;
30: int tokens[10];
31:
32: if (kill_processes == false)
33: wait_for_char = 0;
34: vdtimeout = wait*1000;
35: for (;;) {
36: uncache(&(dcb.operrsta));
37: if (dcb.operrsta & (DCBS_DONE | DCBS_ABORT))
38: break;
39: if (kill_processes == false && input()) {
40: get_text_cmd(nul_table, tokens);
41: if (kill_processes == true) {
42: indent();
43: print(clean_up);
44: exdent(1);
45: }
46: }
47: if (vdtimeout-- <= 0) {
48: if(C_INFO->type == VDTYPE_VDDC)
49: printf("\nVDDC");
50: else
51: printf("\nSMD-E");
52: printf(": Controller timeout");
53: abort:
54: VDABORT(addr, C_INFO->type);
55: DELAY(30000);
56: break;
57: }
58: DELAY(1000);
59: }
60: if ((vdtimeout > 0)) {
61: if (C_INFO->type == VDTYPE_SMDE) {
62: for (;;) {
63: uncache(&(addr->vdcsr));
64: if ((addr->vdcsr & CS_GO) == 0)
65: break;
66: DELAY(1000);
67: if (vdtimeout-- <= 0) {
68: printf("\nSMD-E timed out clearing GO");
69: goto abort;
70: }
71: }
72: DELAY(300);
73: }
74: DELAY(500);
75: }
76: DELAY(200);
77: if((dcb.opcode == VDOP_RD) || (dcb.opcode == VDOP_RDRAW))
78: mtpr(PADC, 0);
79: uncache(&(dcb.operrsta));
80: uncache(&(dcb.err_code));
81: wait_for_char = 1;
82: }
83:
84:
85: /*
86: ** Access_with_no_trailer is used to perform controller functions which
87: ** require no data movement.
88: */
89:
90: access_with_no_trailer(function, wait_time)
91: int function, wait_time;
92: {
93: dcb.opcode = function; /* command */
94: dcb.intflg = DCBINT_NONE;
95: dcb.nxtdcb = (struct dcb *)0; /* end of chain */
96: dcb.operrsta = 0;
97: dcb.devselect = (function == VDOP_START) ? 0 :
98: ((char)cur.drive | lab->d_devflags);
99: dcb.trailcnt = (char)0;
100: mdcb.mdcb_head = &dcb;
101: mdcb.mdcb_status = 0;
102: VDGO(C_INFO->addr, (u_long)&mdcb, C_INFO->type);
103: poll(wait_time);
104: if(vdtimeout <= 0) {
105: printf(" during startup operation.\n");
106: _longjmp(abort_environ, 1);
107: }
108: return dcb.operrsta;
109: }
110:
111: vread(sn, buf, seccnt)
112: int sn, seccnt;
113: char *buf;
114: {
115: int ret;
116:
117: ret = vrdwr(sn, buf, seccnt, VDOP_RD);
118: if (ret == 0)
119: vd_error("read");
120: return (ret);
121: }
122:
123: vwrite(sn, buf, seccnt)
124: int sn, seccnt;
125: char *buf;
126: {
127: int ret;
128:
129: ret = vrdwr(sn, buf, seccnt, VDOP_WD);
130: if (ret == 0)
131: vd_error("write");
132: return (ret);
133: };
134:
135: vrdwr(sn, buf, seccnt, op)
136: int sn, seccnt, op;
137: char *buf;
138: {
139: dskadr dskaddr;
140:
141: dskaddr.cylinder = sn / lab->d_secpercyl;
142: sn %= lab->d_secpercyl;
143: dskaddr.track = sn / lab->d_nsectors;
144: dskaddr.sector = sn % lab->d_nsectors;
145: if (access_dsk(buf, &dskaddr, op, seccnt, 1) & DCBS_HARD)
146: return (0);
147: return (seccnt);
148: }
149:
150: /*
151: ** access_dsk is used by other routines to do reads and writes to the disk.
152: ** The status of the read / write is returned to the caller for processing.
153: */
154:
155: access_dsk(buf, dskaddr, func, count, wait)
156: char *buf;
157: dskadr *dskaddr;
158: int func, count, wait;
159: {
160: cur.daddr.cylinder = dskaddr->cylinder;
161: cur.daddr.track = dskaddr->track;
162: wait_for_char = 0;
163: dcb.opcode = func; /* format sector command */
164: dcb.intflg = DCBINT_NONE;
165: dcb.nxtdcb = (struct dcb *)0; /* end of chain */
166: dcb.operrsta = 0;
167: dcb.devselect = (char)cur.drive | lab->d_devflags;
168: if(func == VDOP_SEEK) {
169: dcb.trailcnt = (char)(sizeof(struct trseek) / sizeof(long));
170: dcb.trail.sktrail.skaddr.cylinder = dskaddr->cylinder;
171: dcb.trail.sktrail.skaddr.track = dskaddr->track;
172: dcb.trail.sktrail.skaddr.sector = dskaddr->sector;
173: } else {
174: dcb.trailcnt = (char)(sizeof(struct trrw) / sizeof(long));
175: dcb.trail.rwtrail.memadr = (u_long)buf;
176: dcb.trail.rwtrail.wcount=count*(lab->d_secsize/sizeof(short));
177: dcb.trail.rwtrail.disk.cylinder = dskaddr->cylinder;
178: dcb.trail.rwtrail.disk.track = dskaddr->track;
179: dcb.trail.rwtrail.disk.sector = dskaddr->sector;
180: }
181: mdcb.mdcb_head = &dcb;
182: mdcb.mdcb_status = 0;
183: VDGO(C_INFO->addr, (u_long)&mdcb, C_INFO->type);
184: if(wait) {
185: poll(10);
186: if(vdtimeout <= 0) {
187: printf(" in access_dsk.\n");
188: _longjmp(abort_environ, 1);
189: }
190: }
191: wait_for_char = 1;
192: return dcb.operrsta;
193: }
194:
195:
196: /*
197: ** Spin_up_drive starts the drives on a controller and waits around for
198: ** the drive to spin up if it is not already spinning.
199: */
200:
201: spin_up_drive()
202: {
203: register struct vddevice *addr = C_INFO->addr;
204:
205: VDRESET(addr, C_INFO->type);
206: if(C_INFO->type == VDTYPE_SMDE) {
207: addr->vdcsr = 0;
208: addr->vdtcf_mdcb = AM_ENPDA;
209: addr->vdtcf_dcb = AM_ENPDA;
210: addr->vdtcf_trail = AM_ENPDA;
211: addr->vdtcf_data = AM_ENPDA;
212: addr->vdccf = CCF_SEN | 0x8 | CCF_STS |
213: XMD_32BIT | BSZ_16WRD | CCF_ERR |
214: CCF_ENP | CCF_EPE | CCF_EDE | CCF_ECE;
215: }
216: access_with_no_trailer(VDOP_INIT, 10);
217: access_with_no_trailer(VDOP_DIAG, 20);
218: configure_drive(0);
219: }
220:
221: /*
222: ** Configure_drive tells the controller what kind of drive is attached
223: ** on a particular line.
224: */
225:
226: configure_drive(pass)
227: int pass;
228: {
229: register struct vddevice *addr = C_INFO->addr;
230: register i;
231:
232: top:
233: dcb.opcode = VDOP_CONFIG; /* command */
234: dcb.intflg = DCBINT_NONE;
235: dcb.nxtdcb = (struct dcb *)0; /* end of chain */
236: dcb.operrsta = 0;
237: dcb.devselect = cur.drive | lab->d_devflags;
238: dcb.trail.rstrail.ncyl = lab->d_ncylinders;
239: dcb.trail.rstrail.nsurfaces = lab->d_ntracks;
240: if(C_INFO->type == VDTYPE_VDDC)
241: dcb.trailcnt = (char)2;
242: else {
243: dcb.trailcnt = sizeof (struct treset)/sizeof (long);
244: dcb.trail.rstrail.nsectors = lab->d_nsectors;
245: dcb.trail.rstrail.slip_sec = lab->d_sparespertrack;
246: dcb.trail.rstrail.recovery = VDRF_NONE;
247: addr->vdcylskew = lab->d_cylskew;
248: addr->vdtrackskew = lab->d_trackskew;
249: addr->vdsecsize = lab->d_secsize/sizeof(short);
250: }
251: mdcb.mdcb_head = &dcb;
252: mdcb.mdcb_status = 0;
253: VDGO(addr, (u_long)&mdcb, C_INFO->type);
254: poll(5);
255: if(vdtimeout <= 0) {
256: printf(" during drive configuration.\n");
257: goto bad;
258: }
259: if(dcb.operrsta & VDERR_HARD) {
260: if (C_INFO->type == VDTYPE_SMDE) {
261: if (lab->d_devflags == 0) {
262: lab->d_devflags = VD_ESDI;
263: goto top;
264: }
265: #ifdef notdef
266: printf("vdstatus %x\n", addr->vdstatus[cur.drive]);
267: if ((addr->vdstatus[cur.drive] & STA_US) == 0) {
268: printf("Drive not present\n\n");
269: goto bad;
270: }
271: #endif
272: }
273: if ((dcb.operrsta & (DCBS_OCYL|DCBS_NRDY)) == 0) {
274: printf("drive config error\n");
275: goto bad;
276: }
277: if(pass) {
278: printf("\nDrive failed to start!\n\n");
279: goto bad;
280: }
281: printf("\ndrive not ready, attempting to spin up...");
282: access_with_no_trailer(VDOP_START, 62);
283: for (i = 0; i < 620; i++) {
284: if (C_INFO->type == VDTYPE_SMDE &&
285: addr->vdstatus[cur.drive] & STA_UR)
286: break;
287: DELAY(100000);
288: }
289: printf(" retrying drive configuration\n");
290: pass++;
291: lab->d_devflags = 0;
292: goto top;
293: }
294: D_INFO->alive = u_true;
295: return;
296: bad:
297: D_INFO->alive = u_false;
298: _longjmp(abort_environ, -1);
299: }
300:
301:
302: /*
303: ** data_ok checks an error status word for bit patterns
304: ** associated with error conditions from the VDDC controller. If a hardware
305: ** error is present then the problem is reported on the console.
306: ** If a data error is present the a zero is returned.
307: ** If everything is OK then a 1 is returned.
308: */
309:
310: data_ok()
311: {
312: register int status = dcb.operrsta;
313:
314: if(status & HARD_ERROR){
315: vd_error("data transfer");
316: printf(" op = 0x%x\n", dcb.opcode);
317: reset_controller();
318: dcb.operrsta &= HEADER_ERROR;
319: }
320: return (int)(!(status & (DATA_ERROR | HEADER_ERROR)));
321: }
322:
323: vd_error(s)
324: char *s;
325: {
326: register int status = dcb.operrsta;
327:
328: print("%s error at sector %d (cyl %d trk %d sect %d),\n",
329: s, to_sector(cur.daddr), dcb.err_cyl & 0xfff, dcb.err_trk,
330: dcb.err_sec);
331: print(" status=%b", dcb.operrsta, VDERRBITS);
332: if (C_INFO->type == VDTYPE_SMDE)
333: printf(", ecode=0x%x", dcb.err_code);
334: printf(".\n");
335: }
336:
337:
338: /*
339: **
340: */
341:
342: reset_controller()
343: {
344: printf("Resetting controller. Please wait...\n");
345: spin_up_drive();
346: printf("Controller was reset successfully.\n");
347: }
348:
349: /*
350: **
351: */
352:
353: static int indent_count;
354:
355:
356: /*
357: **
358: */
359:
360: indent()
361: {
362: indent_count += 2;
363: }
364:
365:
366: /*
367: **
368: */
369:
370: exdent(count)
371: int count;
372: {
373: if(count == -1)
374: indent_count = 0;
375: else
376: indent_count -= count * 2;
377: if(indent_count < 0)
378: indent_count = 0;
379: }
380:
381:
382: /*
383: **
384: */
385: /*VARARGS1*/
386: print(par0, par1, par2, par3, par4, par5, par6)
387: char *par0, *par1, *par2, *par3, *par4, *par5, *par6;
388: {
389: register int count = indent_count;
390:
391: while(count--)
392: printf(" ");
393: printf(par0, par1, par2, par3, par4, par5, par6);
394: DELAY((strlen(par0) + 20) * 9000);
395: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.