![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to udcformat.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 / sys / stand|
Return to udcformat.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand |
1.1 root 1: /* format disk - cmd/smd type */
2:
3: #include "../machine/mtpr.h"
4: #include "../h/param.h"
5: #include "../h/inode.h"
6: #include "../h/fs.h"
7: #include "../vba/udc.h"
8: #include "saio.h"
9:
10: char disk[50] = "xmd(00,000)";
11:
12: main()
13: {
14: int j, c, i, n;
15: char buf[50];
16: int output;
17:
18: do {
19: printf("Device to format: ");
20: gets(disk);
21: output = open(disk, 1);
22: if (output <= 0) printf("Cannot open disk\n", disk);
23: /* dummy call just to get to the local strategy routine */
24: else {
25: printf("Type <return> to start formatting ");
26: gets(buf);
27: write(output,buf,0);
28: printf("Formatting completed. \n");
29: }
30: } while (output <= 0);
31:
32: }
33:
34: /*
35: * Universal disk controller driver for the Motorola M68000/IPC.
36: * Stand-alone version (no interrupts, etc.)
37: */
38:
39:
40: static struct UDPAC udpkt = {
41: 2, 0, 21, 0, 0, 0, 0, SECTSIZ, {0, 0}, 0, 0, 3
42: } ;
43:
44: long udstd[] = { /* May be used some day to boot from any of
45: * several UDC controllers */
46: 0xf0000
47: };
48:
49: /*****************************************************
50: /*
51: /*The next layout of major/minor number assignments are for the UDC
52: /*devices.
53: /*
54: /* 1
55: /* 5 8 7 4 3 2 0
56: /* +----------------+-----+-+-+-----+
57: /* | Major device # | |D|R| FLS |
58: /* +----------------+-----+-+-+-----+
59: /* | | |_____ File system # ( 0-7 )
60: /* | |_________ Fixed (0) or removable(1) media
61: /* |___________ Drive # (0-1)
62: /*
63: /* For the floppy drives, the major / minor assignment will be
64: /* 1
65: /* 5 8 7 4 3 2 0
66: /* +----------------+-----+---+-----+
67: /* | 4 | | D | FLS |
68: /* +----------------+-----+---+-----+
69: /* | |_____ File system # ( 0-7 )
70: /* |____________ Drive # (0-3)
71: /*
72: /****************************************************/
73:
74: #define UDCUNIT(x) ((minor(x) & 0x18) >> 3)
75:
76: udstrategy(io, func)
77: register struct iob *io;
78: long func; /* Known to be 'read' */
79: {
80:
81: register unit = io->i_unit;
82: register bn = io->i_bn;
83: register char *cntaddr ;
84: register char *addr ;
85: register timeout , retries , i;
86:
87: cntaddr = (char *)(udstd[0] + IOBASE); /* Booting from cntrlr 0 */
88: /*
89: * prepare a command packet for the controller.
90: */
91: retries = 3;
92: loop:
93: if (cntaddr[OB1]) {
94: printf("UDC controller not ready, %x=%x\n",OB1+cntaddr,
95: cntaddr[OB1] & 0xff);
96: return(0);
97: }
98: udpkt._pksiz = 7 ;
99: udpkt._pkid = 0xAA ;
100: udpkt._pkdev = UDCUNIT(unit);
101: udpkt._pkcmd = 0x40; /* control command */
102: if (io->i_ino.i_dev == 1) {
103: udpkt._pkdev += 4; /* Floppy */
104: udpkt._pkfnc = 2; /* format floppy */
105: }
106: else udpkt._pkfnc = 2; /* format disk */
107: udpkt._pkcnt = 3 << 8; /* EOT (sort of) */
108: if (movep21(&udpkt,cntaddr+0x105,7)) {
109: cntaddr[OB1] = (char)0x80 ; /* signal packet transmitted */
110: cntaddr[IB2] = (char)0 ; /* clear ACK/NAK field */
111: cntaddr[INT] = (char)0x0 ; /* interrupt the controller */
112: }
113: else {
114: printf ("Wrong command packet arrived at UDC\n");
115: printf ("Original UDC\n");
116: for (i = 0; i < sizeof(udpkt); i++ )
117: printf(" %0x\t%0x\n", ((char *)&udpkt)[i*2] & 0xff,
118: cntaddr[0x105+i*2] & 0xff);
119: }
120: /*
121: *
122: * Wait until done (no interrupts now).
123: *
124: */
125: wait:
126: timeout = 10000;
127: while (cntaddr[IB2] != (char)0x06 && cntaddr[IB2] != (char)0x15) {
128: /**************
129: DELAY(10000);
130: timeout--;
131: if (timeout <= 0) {
132: printf("UDC controller timeout\n");
133: return(0);
134: }
135: *****************/
136: }
137: udpkt._pksiz = 21;
138: if (cntaddr[IB2] == (char)0x15) {
139: if (retries-- < 0) {
140: printf("Too many NAK from UDC - give up\n");
141: return(0);
142: } else goto loop;
143: }
144:
145: while (cntaddr[IB1] != (char)DEVRDY)
146: /* DELAY (10000); /* Wait for his response */;
147:
148:
149: /* Ignore unsolicited status messages */
150: if (cntaddr[PKID] != (char)udpkt._pkid && cntaddr[PKSTT] == (char)0x80)
151: {
152: cntaddr[IB1] = (char)0;
153: cntaddr[OB2] = (char)6;
154: cntaddr[INT] = (char)0x80;
155: goto loop;
156: }
157: if (cntaddr[PKID] != (char)udpkt._pkid ||
158: cntaddr[PKDEV] != (char)udpkt._pkdev ||
159: cntaddr[PKLEN] != (char)19 ||
160: cntaddr[PKCMD] != (char)udpkt._pkcmd ||
161: cntaddr[PKSTT] != (char)0x70 || /* Command completion */
162: cntaddr[STAT1] != (char)0 ||
163: cntaddr[STAT2] != (char)0 ) {
164: printf ("Strange status from UDC:\n");
165: printf("Packet id=%x,unit=%x,original command=%x,status type=%x,status=%x\n",
166: cntaddr[PKID] & 0xff,
167: cntaddr[PKDEV] & 0xff,
168: cntaddr[PKCMD] & 0xff,
169: cntaddr[PKSTT] & 0xff,
170: (cntaddr[STAT1]*256+cntaddr[STAT2]) & 0xffff);
171: if (cntaddr[PKLEN] > 9) {
172: printf("More response info : ");
173: for (i=1; i<=cntaddr[PKLEN]-9; i++)
174: printf("%x ", cntaddr[STAT2+2*i] & 0xff);
175: printf("\n");
176: }
177: cntaddr[IB1] = (char)0;
178: cntaddr[OB2] = (char)6;
179: cntaddr[INT] = (char)0x80;
180: return(0);
181: } else {
182: cntaddr[IB1] = (char)0;
183: cntaddr[OB2] = (char)6;
184: cntaddr[INT] = (char)0x80;
185: mtpr (0, PADC); /* So data will come in right */
186: return(io->i_cc);
187: }
188: }
189:
190: /*
191: * Transfer a 21 bytes packet to the controller.
192: * the message is written to odd addresses, starting from
193: * the given address.
194: * For reliability, read it back and see if it's the same. If not,
195: * return an error code.
196: */
197: movep21(src, dest,cnt)
198:
199: char *src, *dest;
200: int cnt;
201: {
202: register char *running_src, *running_dest;
203: register long running_cnt;
204:
205: running_src = src;
206: running_dest = dest;
207: running_cnt = cnt;
208:
209: for (; running_cnt>0; running_cnt--) {
210: *running_dest++ = *running_src++;
211: running_dest++;
212: }
213: running_src = src;
214: running_dest = dest;
215: running_cnt = cnt;
216: for (; running_cnt>0; running_cnt--) {
217: if (*running_dest++ != *running_src++) return(0);
218: running_dest++;
219: }
220: return(1);
221: }
222:
223: udopen(io)
224: struct iob *io;
225: {
226: register char *cntaddr;
227: /*
228: * Just clean up any junk in the controller's response buffers.
229: */
230: cntaddr = (char *)(udstd[0] + IOBASE); /* Booting from cntrlr 0 */
231: while (cntaddr[IB1] == (char)DEVRDY) {
232: cntaddr[IB1] = (char)0;
233: cntaddr[OB2] = (char)0x06; /* ACK */
234: cntaddr[INT] = (char)0; /* Force him to listen and respond */
235: DELAY(50000);
236: }
237: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.