![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enpload.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / cci|
Return to enpload.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / cci |
1.1 root 1: #include <a.out.h>
2: #include <fcntl.h>
3: #include <stdio.h>
4:
5: #define mkioctl(type,value) (0x20000000|('type'<<8)|value)
6:
7: #define ENPIOGO mkioctl( S,1 ) /* start the enp */
8: #define ENPIORESET mkioctl( S,2 ) /* reset the enp */
9:
10: #define ENP0 0x0 /* Enp's 0 Memory */
11: #define ENP1 0x0 /* Enp's 1 Memory */
12: #define ENP2 0x0 /* Enp's 2 Memory */
13: #define ENP3 0x0 /* Enp's 3 Memory */
14:
15: #define RELO 0x03FFFF /* ENP->Kernel Mask */
16:
17: #define BUTTON 0x1000 /* Addr to "push" for startup */
18: #define JADDR 0x1004 /* Start vector goes here */
19: #define JUMP 0x8080 /* "jump" command */
20:
21: /*
22: * ENP "device" table (so we can load multiple ENPs)
23: * See ENP/30 User Guide
24: */
25:
26: typedef struct enp
27: {
28: char name[8]; /* Device's "name" */
29: long mstart; /* Host's idea of enp mem org */
30: long button; /* Addr of "go" button */
31: long jaddr; /* Addr of "jump" command */
32: } ENP;
33:
34: ENP enp_tab[] =
35: {
36: { "enp0", ENP0, ENP0 + BUTTON, ENP0 + JADDR, },
37: { "enp1", ENP1, ENP1 + BUTTON, ENP1 + JADDR, },
38: { "enp2", ENP2, ENP2 + BUTTON, ENP2 + JADDR, },
39: { "enp3", ENP3, ENP3 + BUTTON, ENP3 + JADDR, },
40: };
41: short num_enp = sizeof(enp_tab) / sizeof(enp_tab[0]);
42:
43: ENP *getenp();
44: short enpfid = -1; /* dev "enpram" fid */
45:
46:
47: /*
48: * For loading from a.out files ...
49: */
50:
51: #define BSIZE 512 /* Size buffer we use */
52: #define MAXFILE 4 /* Max of 4 a.outs */
53: #define MAXBIN 4 /* bin files on command line */
54:
55: typedef struct bins
56: {
57: short b_fid;
58: char *b_name;
59: } BINS;
60:
61: BINS file_tab[ MAXFILE ]; /* fid/name of a.outs */
62:
63: char enpdev[] = "/dev/enpXram";
64: char buff[ BSIZE ]; /* I/O Buffer */
65: char zbuf[ BSIZE ]; /* For quick clearing */
66:
67: int nostart;
68: int noload;
69:
70: main( argc,argv )
71: int argc;
72: char **argv;
73: {
74: register BINS *fp; /* File params */
75: register short fcnt,i; /* Files to load */
76: struct exec hdr; /* a.out header */
77: int cnt; /* I/O count */
78: long f_size,bss_size; /* text + data & bss */
79:
80: register ENP *ep; /* enp_tab pointer */
81: unsigned long enp_go; /* Start up vector */
82: short enp_jump = JUMP; /* "jump" command */
83: long lstart; /* Start loading at */
84: long cstart; /* Clear from */
85:
86:
87: if( (argc < 3) || (argc > 3 + MAXBIN) )
88: {
89: printf( "usage: enpload dev file_1 [ file_2 ... file_4 ]\n" );
90: exit( 1 );
91: }
92: argv++;
93: if( (ep = getenp( *argv++ )) == 0 )
94: {
95: printf( "Bad ENP device name!\n" );
96: exit( 1 );
97: }
98:
99: enpdev[8] = ep->name[3];
100: dup2(1,2); /* redirect sdterr to stdout */
101: if( (enpfid = open(enpdev,O_RDWR)) == -1 )
102: {
103: sprintf(zbuf, "enpload: Can't open %s ram", ep->name);
104: perror( zbuf );
105: exit( 1 );
106: }
107:
108: /* Collect file names and compute number of them */
109:
110: fp = file_tab; fcnt = 0;
111: while( *argv )
112: {
113: if( argv[0][0] == '-' )
114: {
115: if( argv[0][1] == 'L' )
116: noload = 1;
117: else
118: if( argv[0][1] == 'S' )
119: nostart = 1;
120: argv++;
121: }
122: else
123: {
124: fp->b_name = *argv++;
125: fp++; fcnt++;
126: }
127: }
128:
129: /* Zero buffer used to clear bss storage in ENP */
130:
131: for( i = 0; i < BSIZE; i++ )
132: {
133: zbuf[i] = 0;
134: }
135:
136: if( noload )
137: {
138: printf("Restart %s at 0xf02000\n", ep->name);
139: ioctl( enpfid,ENPIOGO,0xf02000 );
140: exit( 0 );
141: }
142: ioctl( enpfid,ENPIORESET,0 );
143:
144: /* Open, validate, and load each file_tab[] file */
145:
146: for( i = 0; i < fcnt; i++ )
147: {
148: fp = &file_tab[i];
149: if( (fp->b_fid = open( fp->b_name,O_RDONLY )) == -1 )
150: {
151: printf( "enpload: Can't open %s!\n",fp->b_name );
152: closem( i-1 );
153: exit( 1 );
154: }
155:
156: if( read( fp->b_fid,&hdr,sizeof( hdr ) ) != sizeof( hdr) )
157: {
158: printf( "enpload: %s Bad header!\n",fp->b_name );
159: closem( i );
160: exit( 1 );
161: }
162:
163: if( N_BADMAG( hdr ) )
164: {
165: printf( "enpload: %s Bad magic!\n",fp->b_name );
166: closem( i );
167: exit( 1 );
168: }
169:
170: f_size = hdr.a_text + hdr.a_data;
171: bss_size = hdr.a_bss;
172: lstart = (ep->mstart + (hdr.a_entry & RELO)) - 0x1000;
173: cstart = lstart + f_size;
174:
175: printf("Loading %s --- ", enpdev);
176: printf( "with file: %s --- ",fp->b_name );
177: /*
178: printf( "text + data: %d bss: %d\n",f_size,bss_size );
179: printf( "ENP's a_entry addr: %06X\n",hdr.a_entry );
180: printf( "load start:%06X bss start:%06X\n",lstart,cstart );
181:
182: printf( "Clearing bss ... " );
183: */
184: lseek( enpfid,cstart,0 );
185: while( bss_size >= BSIZE )
186: {
187: if( write( enpfid,zbuf,BSIZE ) != BSIZE )
188: printf("enpload: bss write error\n");
189: bss_size -= BSIZE;
190: }
191: if( bss_size > 0 )
192: {
193: write( enpfid,zbuf,bss_size );
194: }
195: /*
196: printf( "DONE!\n" );
197: */
198:
199: /*
200: printf( "Loading ... " );
201: */
202: lseek( enpfid,lstart,0 );
203: while( f_size > BSIZE )
204: {
205: cnt = read( fp->b_fid,buff,BSIZE );
206: f_size -= cnt;
207: if( write( enpfid,buff,cnt ) != cnt )
208: perror("enpload: write");
209: }
210: if( f_size > 0 )
211: {
212: cnt = read( fp->b_fid,buff,f_size );
213: write( enpfid,buff,cnt );
214: }
215: printf( "DONE!\n" );
216: }
217:
218: /* Last file, we exec this one */
219:
220: if( nostart == 0 )
221: {
222: enp_go = hdr.a_entry;
223: /*
224: printf( "Starting ENP execution at %X ... ",enp_go );
225: */
226: ioctl( enpfid,ENPIOGO, enp_go );
227: /*
228: printf( "DONE!\n" );
229: */
230: }
231: }
232:
233:
234: ENP *
235: getenp( np )
236: register char *np;
237: {
238: register ENP *ep;
239:
240: for( ep = enp_tab; ep < &enp_tab[num_enp]; ep++ )
241: if( strcmp( np,ep->name ) == 0 )
242: {
243: return( ep );
244: }
245: return( 0 );
246: }
247:
248:
249: closem( cnt )
250: register short cnt;
251: {
252: register BINS *fp;
253:
254: for( fp = file_tab; fp < &file_tab[cnt]; fp++ )
255: {
256: close( fp->b_fid );
257: }
258: if( enpfid != -1 )
259: {
260: close( enpfid );
261: }
262: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.