![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asypatch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / tools|
Return to asypatch.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / tools |
1.1 root 1: /*
2: * File: asypatch.c
3: *
4: * Purpose: read a spec from stdin and patch the asy driver
5: *
6: * $Log: asypatch.c,v $
7: * Revision 1.3 93/05/18 07:32:22 bin
8: * *** empty log message ***
9: *
10: */
11:
12: /*
13: * ----------------------------------------------------------------------
14: * Includes.
15: */
16: #include <stdio.h>
17: #include <termio.h>
18: #include <sys/ktty.h>
19: #include <sys/asy.h>
20: #ifdef _I386
21: #include <coff.h>
22: #endif
23:
24: /*
25: * ----------------------------------------------------------------------
26: * Definitions.
27: * Constants.
28: * Macros with argument lists.
29: * Typedefs.
30: * Enums.
31: */
32: #define BSZ 256
33: #ifdef _I386
34: #define MAKEPATCH(a1,a2,a3,a4,a5) coffp0(a1,a2,a3,a4,a5)
35: #else
36: #define MAKEPATCH(a1,a2,a3,a4,a5) loutpatch(a1,a2,a3,a4,a5)
37: #endif
38:
39: /*
40: * ----------------------------------------------------------------------
41: * Functions.
42: * Import Functions.
43: * Export Functions.
44: * Local Functions.
45: */
46: void p_rec();
47: void g_rec();
48: void m_rec();
49: void fatal();
50: void asydump();
51: int asy_ver();
52: int get_speed();
53: void usage();
54:
55: /*
56: * ----------------------------------------------------------------------
57: * Global Data.
58: * Import Variables.
59: * Export Variables.
60: * Local Variables.
61: */
62: int line; /* line number in input file */
63: int num_chan; /* highest channel number used */
64: int group; /* next port group to be assigned */
65: unsigned int x1,x2,x3,x4,x5,x6,x7;
66: asy0_t asy0[MAX_ASY];
67: asy_gp_t asy_gp[MAX_ASY];
68: char chan_found[MAX_ASY]; /* true if record seen for the channel */
69: char buf[BSZ]; /* input line buffer */
70: char msg[BSZ]; /* error message line buffer */
71: char expect_chan; /* number of "M" records expected */
72: char outs, irq, nms;
73: char vflag; /* verbose mode */
74: char xflag; /* debug mode */
75: char *cmd; /* command name */
76:
77: /*
78: * ----------------------------------------------------------------------
79: * Code.
80: */
81:
82: /*
83: * main()
84: *
85: * while able to read a line from input
86: * call routine to process the record type
87: */
88: main(argc, argv)
89: int argc;
90: char **argv;
91: {
92: int fd, len, ch, hi_chan, p_ver;
93: char *pfile = 0, *cp;
94:
95: cmd = argv[0];
96:
97: /*
98: * Scan command arguments.
99: */
100: while (cp = *++argv) {
101: if (*cp == '-') {
102: while(*++cp) {
103: switch (*cp) {
104: case 'v':
105: vflag = 1;
106: break;
107: case 'x':
108: xflag = 1;
109: break;
110: default:
111: usage();
112: }
113: }
114: } else {
115: if (pfile)
116: usage();
117: pfile = cp;
118: }
119: }
120:
121: if (!pfile)
122: usage();
123:
124: if (vflag)
125: printf("%s Version %d\n", cmd, ASY_VERSION);
126:
127: while (fgets(buf, BSZ, stdin)) {
128: line++;
129: switch (buf[0]) {
130: case 'P': p_rec(); break;
131: case 'G': g_rec(); break;
132: case 'M': m_rec(); break;
133: }
134: }
135:
136: if (expect_chan) {
137: sprintf(msg, "expecting %d \"M\" entries", expect_chan);
138: fatal(msg);
139: }
140:
141: /*
142: * Find highest channel number in use.
143: */
144: for (hi_chan = -1, ch = 0; ch < MAX_ASY; ch++)
145: if (chan_found[ch])
146: hi_chan = ch;
147:
148: num_chan = hi_chan + 1;
149:
150: if (num_chan == 0)
151: fatal("No channels specified");
152:
153: /*
154: * Make sure the file to be patched is accessible.
155: */
156: if ((fd = open(pfile, 2)) == -1) {
157: sprintf(msg, "can't open file %s\n", pfile);
158: fatal(msg);
159: }
160: close(fd);
161:
162: /*
163: * Version numbers in patch program and driver must match.
164: */
165: p_ver = asy_ver(pfile);
166: if (p_ver != ASY_VERSION) {
167: sprintf(msg, "Wrong versions: asypatch=%d %s=%d\n",
168: ASY_VERSION, pfile, p_ver);
169: fatal(msg);
170: }
171:
172: if (vflag)
173: asydump();
174:
175: /*
176: * Make three or four patches.
177: */
178: if (MAKEPATCH(pfile, "ASY_NUM", &num_chan, sizeof(int), 0) == 0)
179: fatal("can't patch ASY_NUM");
180:
181: if (MAKEPATCH(pfile, "ASYGP_NUM", &group, sizeof(int), 0) == 0)
182: fatal("can't patch ASYGP_NUM");
183:
184: len = num_chan * sizeof(asy0[0]);
185: if (MAKEPATCH(pfile, "asy0", asy0, len, 0) == 0)
186: fatal("can't patch asy0");
187:
188: if (group) {
189: len = group * sizeof(asy_gp[0]);
190: if (MAKEPATCH(pfile, "asy_gp", asy_gp, len, 0) == 0)
191: fatal("can't patch asy_gp");
192: }
193:
194: exit(0);
195: }
196:
197: void
198: p_rec()
199: {
200: asy0_t *a0;
201: int speed;
202:
203: if (expect_chan) {
204: sprintf(msg, "expecting %d \"M\" entries", expect_chan);
205: fatal(msg);
206: }
207:
208: /*
209: * Load a struct from input.
210: *
211: * "P" record is:
212: * P port irq outs excl speed channel nms
213: * port and outs are in hex, others in decimal
214: */
215: if (sscanf(buf+1, "%x%d%x%d%d%d%d",&x1,&x2,&x3,&x4,&x5,&x6,&x7) != 7)
216: fatal("need 7 parameters");
217:
218: if (x6 >= MAX_ASY) {
219: sprintf(msg, "invalid channel #%d\n", x6);
220: fatal(msg);
221: }
222:
223: if (chan_found[x6]) {
224: sprintf(msg, "duplicate channel #%d\n", x6);
225: fatal(msg);
226: }
227:
228: a0 = asy0 + x6;
229: #ifdef _I386
230: if (x1 >= 0x10000)
231: fatal("address must be ffff or less");
232: #endif
233: a0->a_port = x1;
234: if (x2 >= 16)
235: fatal("irq must be 15 or less");
236: a0->a_irqno = x2;
237: #ifdef _I386
238: if (x3 & 0xfffffff3)
239: #else
240: if (x3 & 0xfff3)
241: #endif
242: fatal("only bits 2 & 3 of outs may be nonzero");
243: a0->a_outs = x3;
244: if (x4 > 1)
245: fatal("excl must be 0 or 1");
246: a0->a_ixc = x4;
247: speed = get_speed(x5);
248: if (speed < 0)
249: fatal("invalid speed");
250: else
251: a0->a_speed = speed;
252: a0->a_asy_gp = NO_ASYGP;
253: chan_found[x6] = 1;
254: if (x7 > 1)
255: fatal("nms must be 0 or 1");
256: a0->a_nms = x7;
257: }
258:
259: void
260: g_rec()
261: {
262: int slot;
263: asy_gp_t *gp = asy_gp + group;
264:
265: if (expect_chan) {
266: fprintf(stderr, "expecting %d \"M\" entries", expect_chan);
267: fatal("record out of order");
268: }
269:
270: if (group >= MAX_ASYGP) {
271: fprintf(stderr, "Just found group #%d\n", group);
272: fatal("too many groups");
273: }
274:
275: /*
276: * Load a struct from input.
277: *
278: * "G" record is:
279: * G port irq outs type number-of-channels nms
280: * port and outs are in hex, others in decimal
281: * see asy.h for valid types
282: */
283: if (sscanf(buf+1, "%x%d%x%d%d%d",&x1,&x2,&x3,&x4,&x5,&x6) != 6)
284: fatal("need 6 parameters");
285: #ifdef _I386
286: if (x1 >= 0x10000)
287: fatal("address must be ffff or less");
288: #endif
289: gp->stat_port = x1;
290: if (x2 >= 16)
291: fatal("irq must be 15 or less");
292: irq = gp->irq = x2;
293: #ifdef _I386
294: if (x3 & 0xfffffff3)
295: #else
296: if (x3 & 0xfff3)
297: #endif
298: fatal("only bits 2 & 3 of outs may be nonzero");
299: outs = x3;
300: if (x4 >= PT_MAX)
301: fatal("invalid type");
302: gp->gp_type = x4;
303: if (x5 > MAX_SLOTS || x5 == 0)
304: fatal("number of channels must be in range 1..16");
305: expect_chan = x5;
306: if (x6 > 1)
307: fatal("nms must be 0 or 1");
308: nms = x6;
309: for (slot = 0; slot < MAX_SLOTS; slot++)
310: gp->chan_list[slot] = NO_CHANNEL;
311: group++;
312: }
313:
314: void
315: usage()
316: {
317: fprintf(stderr, "%s Version %d\n", cmd, ASY_VERSION);
318: fprintf(stderr, "Usage: %s [-vx] patchfile < specfile\n", cmd);
319: exit(1);
320: }
321:
322: void
323: fatal(s)
324: char *s;
325: {
326: fprintf(stderr, "%s: line %d %s\n", cmd, line, s);
327: exit(1);
328: }
329:
330: void
331: m_rec()
332: {
333: asy0_t *a0;
334: int speed;
335:
336: if (expect_chan == 0) {
337: fatal("unexpected \"M\" record");
338: }
339:
340: /*
341: * Load a struct from input.
342: *
343: * "M" record is:
344: * M port speed slot channel
345: * port is in hex, speed in decimal
346: */
347: if (sscanf(buf+1, "%x%d%d%d",&x1,&x2,&x3,&x4) != 4)
348: fatal("need 4 parameters");
349:
350: if (x4 >= MAX_ASY) {
351: sprintf(msg, "invalid channel #%d\n", x4);
352: fatal(msg);
353: }
354:
355: if (chan_found[x4]) {
356: sprintf(msg, "duplicate channel #%d\n", x4);
357: fatal(msg);
358: }
359:
360: if (x3 >= MAX_SLOTS) {
361: sprintf(msg, "slot number %d must be less than 16\n", x3);
362: fatal(msg);
363: }
364: a0 = asy0 + x4;
365:
366: #ifdef _I386
367: if (x1 >= 0x10000)
368: fatal("address must be ffff or less");
369: #endif
370: a0->a_port = x1;
371: speed = get_speed(x2);
372: if (speed < 0)
373: fatal("invalid speed");
374: else
375: a0->a_speed = speed;
376:
377: a0->a_outs = outs;
378: a0->a_nms = nms;
379: a0->a_ixc = 0;
380: a0->a_irqno = irq;
381: a0->a_asy_gp = group - 1;
382: asy_gp[group - 1].chan_list[x3] = x4;
383: chan_found[x4] = 1;
384: expect_chan--;
385: }
386:
387: int
388: get_speed(rate)
389: int rate;
390: {
391: int ret;
392:
393: switch (rate) {
394: case 0: ret = B0; break;
395: case 50: ret = B50; break;
396: case 75: ret = B75; break;
397: case 110: ret = B110; break;
398: case 134: ret = B134; break;
399: case 150: ret = B150; break;
400: case 200: ret = B200; break;
401: case 300: ret = B300; break;
402: case 600: ret = B600; break;
403: case 1200: ret = B1200; break;
404: case 1800: ret = B1800; break;
405: case 2400: ret = B2400; break;
406: case 4800: ret = B4800; break;
407: case 9600: ret = B9600; break;
408: case 19200: ret = B19200; break;
409: #ifdef _I386
410: case 38400: ret = B38400; break;
411: #endif
412: default: ret = -1;
413: }
414: return ret;
415: }
416:
417: #ifdef _I386
418: /*
419: * coffp0()
420: *
421: * Given a file name, a symbol name, a buffer, and number of bytes in
422: * the buffer, read or write the buffer into the COFF file at the
423: * symbol specified.
424: *
425: * Read the given file if argument "do_read" is 1, else write to the file.
426: * Return nonzero if success; zero if failure.
427: */
428: int
429: coffp0(fname, sym, data, len, do_read)
430: char *fname, *sym, *data;
431: int len, do_read;
432: {
433: int ret;
434: SYMENT se;
435:
436: /*
437: * put together SYMENT stuff for coffnlist
438: */
439: se._n._n_n._n_zeroes = 0;
440: se._n._n_n._n_offset = sizeof(long);
441: se.n_type = -1;
442: ret = coffnlist(fname, &se, sym, 1);
443:
444: if (ret)
445: ret = coffpatch(fname, &se, sym, data, len, do_read);
446:
447: return ret;
448: }
449: #endif
450:
451: void
452: asydump()
453: {
454: char chan, g;
455: asy0_t *a0;
456: asy_gp_t *gp;
457:
458: /*
459: * Display totals.
460: */
461: printf("Channels = %2d Groups = %d\n", num_chan, group);
462:
463: /*
464: * Display channel table asy0.
465: */
466: printf("Ch port Ir S O Gp X N\n");
467: for (chan = 0; chan < num_chan; chan++) {
468: a0 = asy0 + chan;
469: printf("%2d %4x %2d %1x %1x %2d %1d %1d\n",
470: chan, a0->a_port, a0->a_irqno, a0->a_speed, a0->a_outs,
471: a0->a_asy_gp, a0->a_ixc, a0->a_nms);
472: }
473:
474: /*
475: * Display group table asy_gp.
476: */
477: if (group) {
478: printf("Gp Port T Irq Channels...............\n");
479: for (g = 0; g < group; g++) {
480: int s;
481:
482: gp = asy_gp + g;
483: printf("%2d %4x %1d %2d ",
484: g,gp->stat_port,gp->gp_type,gp->irq);
485: for (s = 0; s < MAX_SLOTS; s++)
486: if (gp->chan_list[s] == NO_CHANNEL)
487: printf(" ", gp->chan_list[s]);
488: else
489: printf(" %2d", gp->chan_list[s]);
490: putchar('\n');
491: }
492: }
493: }
494:
495: /*
496: * asy_ver()
497: *
498: * Fetch the initial value at symbol ASY_VER (ASY_VER_ for 286)
499: * in file "fname".
500: *
501: * Return -1 on failure; otherwise return the value at the symbol.
502: */
503: int
504: asy_ver(fname)
505: char * fname;
506: {
507: int ret = -1;
508: int version;
509:
510: if (MAKEPATCH(fname, "ASY_VER", &version, sizeof(int), 1))
511: ret = version;
512: return ret;
513: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.