![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tape.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / pits|
Return to tape.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / pits |
1.1 root 1:
2: /*
3: *********************
4: *
5: * Cypher tape driver
6: *
7: *********************/
8:
9: #include "pte.h"
10: #include "cy.h"
11: #include "cyconf.h"
12:
13: struct scp *SCP; /* Pointer System configuration block */
14: struct scb scblk; /* System conf. block */
15: struct ccb ccblk; /* Channel control block */
16: struct tpb tpb; /* Tape parameter block */
17: struct tpb tpb1; /* Tape parameter block (spare) */
18: long cmd_done; /* 1 : cmd completed without error */
19: /* 2 : cmd error */
20: long CYattn; /* Virtual address of Cypher I/O attention address */
21: long ntape;
22: extern long unused, Multi, Berr;
23: extern short erase, unit;
24:
25: chk_tape()
26: { register long r12;
27: long oldvec;
28:
29: m_cy(); /* Map Tape master space */
30:
31: /* Set handler for tape master interrupt */
32: asm("movab cyhdlr,r12");
33: set_handler(CYVEC,&oldvec,r12);
34:
35: cy_reset(); /* Reset Tape master */
36: return(ntape);
37: }
38: tape()
39: {
40: if (ntape == 0) {
41: writes("\n\nNo Tape controller installed\n");
42: return(0); }
43: return(cy_setup()); /* Set up structures and initialize Tape master */
44: }
45: long tm_cnt;
46: /*
47: Routine to sent a command to Tape master
48: return -1 if error
49: return return count of TPB if sucessful
50: */
51: sent_tm()
52: { register long cntr, rtn_cnt;
53:
54: tm_cnt = 0;
55: ccblk.gate = (char)GATE_CLOSED; /* Close gate */
56: cy_attn(); /* Execute command */
57: cntr = RETRY;
58: cmd_done = 0;
59: if (Multi) return;
60: while (!cmd_done) { /* Wait for completion interrupt */
61: DELAY(0x100000);
62: if (--cntr == 0) {
63: writes("\n...sent_tm no interrupt respond");
64: return(-1); /* Time out */
65: }
66: }
67: if (cmd_done == 2) return(-1); /* Command has error */
68: return(tm_cnt);
69: }
70:
71: /* Tape master completion interrupt handler
72: */
73: tm_hdlr()
74: {
75: if (chk_cstat())
76: cmd_done = 2; /* completion error */
77: else cmd_done = 1; /* completion without error */
78: tm_cnt = gt_bcnt(); /* Get return count from TPB */
79: clr_tint(); /* Clear tape master interrupt */
80: }
81: /*
82: Routine to ACK on tape master completion interrupt
83: Sent out a NOOP command without interrupt on completion
84: */
85: clr_tint()
86: {
87: while (g_open()==0) /* Gate close */
88: { tm_init();
89: error("\n...Received interrupt but gate closed.");
90: }
91: ccblk.gate = GATE_CLOSED;
92: ccblk.ccw = 0x9; /* Clear tape master interrupt */
93: set_g3(&tpb,NOOP,0,0,0); /* No Interrupt on completion please */
94: cy_attn();
95: DELAY(0x1500); /* wait for completion */
96: while (g_open()==0) /* Gate close */
97: { tm_init();
98: error("\n...Cannot clear interrupt");
99: return(0);
100: }
101: ccblk.ccw = 0x11;
102: return(1);
103: }
104: /*
105: Check status of command previously issued
106: If all are OK return 0
107: else return Status byte.
108: */
109: chk_cstat()
110: {
111: register long *r12, cstat;
112: r12 = (long *)&tpb.status[1];
113: uncache(r12);
114: /* Cmd status without retry bit */
115: cstat = (long)tpb.status[1];
116: if (((cstat & 0x87) == 0x87) && (erase))
117: { writes("\nCy hard error 87 expected, tape is blank\n");
118: return(cstat); }
119: if ((cstat & 0xc0) != 0xc0)
120: { writes("\n...Cy hard error ");
121: writeh(cstat & 0xff); writec('\n');
122: return(cstat); }
123: return(0);
124: }
125: /*
126: Check status of drive after received command
127: completion interrupt. If all are OK return 0
128: else return Status byte.
129: */
130: chk_dstat()
131: { register long *r12, tstat;
132:
133: r12 = (long *)&tpb.status[0];
134: uncache(r12);
135: tstat = tpb.status[0];
136: if ( (tstat & 0x48) != 0x48)
137: { writes("\n...drive error ");
138: writeh(tstat & 0xff);
139: return(tstat); }
140: return(0);
141: }
142: /*
143: Routine to get return_count field of TPB after
144: receive command completion interrupt
145: */
146: gt_bcnt()
147: { register long *r12, tmp1, tmp2;
148:
149: r12 = (long *)&tpb.count;
150: uncache(r12);
151: tmp1 = (long)((tpb.count & (short)0xff)<<8);
152: tmp2 = (long)((tpb.count & (short)0xff00)>>8);
153: return(tmp1|tmp2);
154: }
155: /*
156: Routine to issue a GO command to tape master
157: also known as Channel attention interrupt
158: */
159: cy_attn()
160: { register long r12;
161:
162: r12 = CYattn; /* R12 = Cypher attention address */
163: asm("movob $0xff,(r12)");
164: }
165: /*
166: Routine to reset Tape master controller
167: */
168: cy_reset()
169: { register long r12;
170:
171: r12 = CYattn + 1; /* R12 = Cypher attention address */
172: asm("movob $0xff,(r12)");
173: DELAY(100);
174: ntape = 0;
175: writes("\n\nProbing for Tape Master controller...");
176: if(!Berr) {
177: writes("\nTape Master controller at address ");
178: writeh(TBASE);
179: ntape++; }
180: writes("\n"); writed(ntape); writes(" Tape controller(s) found");
181: }
182: /*
183: Map channel attention address of Tape master
184: */
185: m_cy()
186: { register long r12;
187: long phys_pg, pte, old_pte, which1;
188:
189: /* physical page of Tape master in IO space */
190: phys_pg = ((TBASE+IOBASE) >> PGSHIFT) & 0x3fffff;
191: pte = phys_pg | PG_KW | PG_V | PG_NC;
192: fix_pte(SBR,unused,&old_pte,pte);
193: CYattn = (unused << PGSHIFT); /* Virtual address of CY attn address */
194: asm("mfpr $SLR,r12");
195: r12++;
196: asm("mtpr r12,$SLR");
197: unused++; /* Next unused PTE in system map */
198: }
199: /*
200: Set up all structures for Tape master
201: and initialize Tape master
202: */
203: cy_setup()
204: {
205: register long cntr;
206:
207: SCP = (struct scp *)SCP_ADR; /* absolute - for setup */
208:
209: /* Initialize the system configuration pointer */
210: SCP->sysbus = 1; /* system width = 16 bits. */
211: set_pointer(&scblk.sysblk,(char *)SCP->pt_scb);
212:
213: /* Initialize the system configuration block. */
214: scblk.sysblk = 0x3; /* fixed value */
215: scblk.nu2 = 0; /* not used */
216: set_pointer(&ccblk.ccw,(char *)scblk.pt_ccb);
217:
218: /* Initialize the channel control block. */
219: ccblk.ccw = 0x11; /* normal interrupts */
220: set_pointer(&tpb,(char *)ccblk.pt_tpb);
221:
222: ccblk.gate = GATE_CLOSED;
223: cy_attn(); /* 1st attention : initialization Cypher */
224: cntr = RETRY;
225: while (ccblk.gate == GATE_CLOSED) {
226: DELAY(0x400); /* wait for completion */
227: if (--cntr == 0) {
228: writes("\n...Init : Cypher time out");
229: return(0); } /* Time out */
230: }
231: return(1);
232: }
233: /*
234: Set a TAPEMASTER 20_bit pointer (first parameter), into
235: the 4 bytes array pointed by the second parameter.
236: */
237: set_pointer(pointer,dest)
238: long pointer;
239: char *dest;
240: {
241: *dest++ = pointer & 0xff; /* low byte - offset */
242: *dest++ = (pointer >> 8) & 0xff; /* high byte - offset */
243: *dest++ = 0;
244: *dest = (pointer & 0xf0000) >> 12; /* base */
245: }
246: g_open()
247: { register long *r12, cntr;
248:
249: r12 = (long *)&ccblk.gate;
250: cntr = RETRY;
251: while (ccblk.gate!=0) {
252: uncache(r12);
253: DELAY(0x500); /* wait for completion */
254: if (--cntr == 0) {
255: writes("\n...g_open time out");
256: return(0);
257: }
258: }
259: return(1);
260: }
261: error(msg)
262: char *msg;
263: {
264: writes(msg);
265: }
266: /*
267: Set Tape Parameter Block
268: Input :
269: cmd = Opcode
270: bufsiz = Block size
271: bufadr = System buffer address
272: int = interrupt on completion or not
273: */
274: set_g3(tpblk,cmd,bufsiz,bufadr,intr)
275: struct tpb *tpblk;
276: long cmd, bufsiz, intr;
277: char *bufadr;
278: { char *cptr;
279:
280: tpblk->cmd = cmd; /* Command */
281: tpblk->control[1] = 0x80 | CW_100ips; /* 16_bit system bus */
282: tpblk->control[0] = ((unit << 2)|(intr << 5)); /* Drive,interrupt */
283: tpblk->count = 0; /* Return count = 0 */
284: cptr = (char *)&tpblk->size; /* Set buffer size */
285: *cptr++ = (char)(bufsiz & 0xff);
286: *cptr = (char)((bufsiz & 0xff00)>>8);
287: if(cmd == ERASE_F)
288: tpblk->rec_over = 0x0004; /* Set record count, erase */
289: else
290: tpblk->rec_over = 0; /* Set record count */
291: /* Set system buffer address */
292: set_pointer((long)(bufadr),(char *)tpblk->pt_data);
293: tpblk->status[0] = tpblk->status[1] = 0;/* Clear ctlr & drive status */
294: }
295: /*
296: *************************************
297: Routine to Read/Write Cypher tape
298: return 0 if cannot complete operation
299: *************************************
300: */
301: long tape_op(cmd,buf_adr,buf_siz)
302: long cmd, buf_siz;
303: char *buf_adr;
304: { char *cptr;
305: register long cnt, stat, tmp1, tmp2;
306:
307: set_g3(&tpb,cmd,buf_siz,buf_adr,1); /* Set up command block */
308: while (g_open()==0) { /* Gate closed !! */
309: tm_init(); /* Init controller */
310: writes("\n...tape_op : Can not open gate !!");
311: return(0);
312: }
313: return(sent_tm());
314: }
315:
316: /*
317: Rewind tapemaster
318: */
319: tm_rew()
320: { char tstat;
321: writes("\nTape rewinding");
322: if (tape_op(REWD_TA,0,0) == -1) return(0);
323: tstat = tpb.status[0];
324: if ( (tstat & 0x20) != 0x20) return(0);
325: return(1);
326: }
327: /*
328: Erase 1024 records
329: */
330: tm_erase()
331: {
332: writes("\nErasing 1024 records");
333: if (tape_op(ERASE_F,0,0) == -1) return(0);
334: return(1);
335: }
336: /*
337: Routine to initialize tape master
338: */
339: tm_init()
340: { register long cntr;
341:
342: cy_reset();
343: if (!g_open()) return(0);
344: ccblk.gate = GATE_CLOSED;
345: cy_attn(); /* 1st attention : initialization Cypher */
346: cntr = RETRY;
347: while (ccblk.gate == GATE_CLOSED) {
348: DELAY(2000); /* wait for completion */
349: if (--cntr == 0) {
350: writes("\n...Init : Cypher time out");
351: return(0); } /* Time out */
352: }
353: return(1);
354: }
355: cyhandler()
356: { long dummy;
357:
358: asm(".align 2");
359: asm("cyhdlr:");
360: asm("svpctx");
361: tm_hdlr();
362: asm("ldpctx");
363: asm("rei");
364: dummy = 0;
365: }
366:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.