config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / scsi / script_asm.pl
1 #!/usr/bin/perl -s
2
3 # NCR 53c810 script assembler
4 # Sponsored by 
5 #       iX Multiuser Multitasking Magazine
6 #
7 # Copyright 1993, Drew Eckhardt
8 #      Visionary Computing 
9 #      (Unix and Linux consulting and custom programming)
10 #      drew@Colorado.EDU
11 #      +1 (303) 786-7975 
12 #
13 #   Support for 53c710 (via -ncr7x0_family switch) added by Richard
14 #   Hirst <richard@sleepie.demon.co.uk> - 15th March 1997
15 #
16 #   This program is free software; you can redistribute it and/or modify
17 #   it under the terms of the GNU General Public License as published by
18 #   the Free Software Foundation; either version 2 of the License, or
19 #   (at your option) any later version.
20 #
21 #   This program is distributed in the hope that it will be useful,
22 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
23 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24 #   GNU General Public License for more details.
25 #
26 #   You should have received a copy of the GNU General Public License
27 #   along with this program; if not, write to the Free Software
28 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #
30 # TolerANT and SCSI SCRIPTS are registered trademarks of NCR Corporation.
31 #
32
33
34 # Basically, I follow the NCR syntax documented in the NCR53c710 
35 # Programmer's guide, with the new instructions, registers, etc.
36 # from the NCR53c810.
37 #
38 # Differences between this assembler and NCR's are that 
39 # 1.  PASS, REL (data, JUMPs work fine), and the option to start a new 
40 #       script,  are unimplemented, since I didn't use them in my scripts.
41
42 # 2.  I also emit a script_u.h file, which will undefine all of 
43 #       the A_*, E_*, etc. symbols defined in the script.  This 
44 #       makes including multiple scripts in one program easier
45 #       
46 # 3.  This is a single pass assembler, which only emits 
47 #       .h files.
48 #
49
50
51 # XXX - set these with command line options
52 $debug = 0;             # Print general debugging messages
53 $debug_external = 0;    # Print external/forward reference messages
54 $list_in_array = 1;     # Emit original SCRIPTS assembler in comments in
55                         # script.h
56 #$prefix;               # (set by perl -s)
57                         # define all arrays having this prefix so we 
58                         # don't have name space collisions after 
59                         # assembling this file in different ways for
60                         # different host adapters
61
62 # Constants
63
64
65 # Table of the SCSI phase encodings
66 %scsi_phases = (                        
67     'DATA_OUT', 0x00_00_00_00, 'DATA_IN', 0x01_00_00_00, 'CMD', 0x02_00_00_00,
68     'STATUS', 0x03_00_00_00, 'MSG_OUT', 0x06_00_00_00, 'MSG_IN', 0x07_00_00_00
69 );
70
71 # XXX - replace references to the *_810 constants with general constants
72 # assigned at compile time based on chip type.
73
74 # Table of operator encodings
75 # XXX - NCR53c710 only implements 
76 #       move (nop) = 0x00_00_00_00
77 #       or = 0x02_00_00_00
78 #       and = 0x04_00_00_00
79 #       add = 0x06_00_00_00
80
81 if ($ncr7x0_family) {
82   %operators = (
83     '|', 0x02_00_00_00, 'OR', 0x02_00_00_00,
84     '&', 0x04_00_00_00, 'AND', 0x04_00_00_00,
85     '+', 0x06_00_00_00
86   );
87 }
88 else {
89   %operators = (
90     'SHL',  0x01_00_00_00, 
91     '|', 0x02_00_00_00, 'OR', 0x02_00_00_00, 
92     'XOR', 0x03_00_00_00, 
93     '&', 0x04_00_00_00, 'AND', 0x04_00_00_00, 
94     'SHR', 0x05_00_00_00, 
95     # Note : low bit of the operator bit should be set for add with 
96     # carry.
97     '+', 0x06_00_00_00 
98   );
99 }
100
101 # Table of register addresses
102
103 if ($ncr7x0_family) {
104   %registers = (
105     'SCNTL0', 0, 'SCNTL1', 1, 'SDID', 2, 'SIEN', 3,
106     'SCID', 4, 'SXFER', 5, 'SODL', 6, 'SOCL', 7,
107     'SFBR', 8, 'SIDL', 9, 'SBDL', 10, 'SBCL', 11,
108     'DSTAT', 12, 'SSTAT0', 13, 'SSTAT1', 14, 'SSTAT2', 15,
109     'DSA0', 16, 'DSA1', 17, 'DSA2', 18, 'DSA3', 19,
110     'CTEST0', 20, 'CTEST1', 21, 'CTEST2', 22, 'CTEST3', 23,
111     'CTEST4', 24, 'CTEST5', 25, 'CTEST6', 26, 'CTEST7', 27,
112     'TEMP0', 28, 'TEMP1', 29, 'TEMP2', 30, 'TEMP3', 31,
113     'DFIFO', 32, 'ISTAT', 33, 'CTEST8', 34, 'LCRC', 35,
114     'DBC0', 36, 'DBC1', 37, 'DBC2', 38, 'DCMD', 39,
115     'DNAD0', 40, 'DNAD1', 41, 'DNAD2', 42, 'DNAD3', 43,
116     'DSP0', 44, 'DSP1', 45, 'DSP2', 46, 'DSP3', 47,
117     'DSPS0', 48, 'DSPS1', 49, 'DSPS2', 50, 'DSPS3', 51,
118     'SCRATCH0', 52, 'SCRATCH1', 53, 'SCRATCH2', 54, 'SCRATCH3', 55,
119     'DMODE', 56, 'DIEN', 57, 'DWT', 58, 'DCNTL', 59,
120     'ADDER0', 60, 'ADDER1', 61, 'ADDER2', 62, 'ADDER3', 63,
121   );
122 }
123 else {
124   %registers = (
125     'SCNTL0', 0, 'SCNTL1', 1, 'SCNTL2', 2, 'SCNTL3', 3,
126     'SCID', 4, 'SXFER', 5, 'SDID', 6, 'GPREG', 7,
127     'SFBR', 8, 'SOCL', 9, 'SSID', 10, 'SBCL', 11,
128     'DSTAT', 12, 'SSTAT0', 13, 'SSTAT1', 14, 'SSTAT2', 15,
129     'DSA0', 16, 'DSA1', 17, 'DSA2', 18, 'DSA3', 19,
130     'ISTAT', 20,
131     'CTEST0', 24, 'CTEST1', 25, 'CTEST2', 26, 'CTEST3', 27,
132     'TEMP0', 28, 'TEMP1', 29, 'TEMP2', 30, 'TEMP3', 31,
133     'DFIFO', 32, 'CTEST4', 33, 'CTEST5', 34, 'CTEST6', 35,
134     'DBC0', 36, 'DBC1', 37, 'DBC2', 38, 'DCMD', 39,
135     'DNAD0', 40, 'DNAD1', 41, 'DNAD2', 42, 'DNAD3', 43,
136     'DSP0', 44, 'DSP1', 45, 'DSP2', 46, 'DSP3', 47,
137     'DSPS0', 48, 'DSPS1', 49, 'DSPS2', 50, 'DSPS3', 51,
138     'SCRATCH0', 52, 'SCRATCH1', 53, 'SCRATCH2', 54, 'SCRATCH3', 55,
139     'SCRATCHA0', 52, 'SCRATCHA1', 53, 'SCRATCHA2', 54, 'SCRATCHA3', 55,
140     'DMODE', 56, 'DIEN', 57, 'DWT', 58, 'DCNTL', 59,
141     'ADDER0', 60, 'ADDER1', 61, 'ADDER2', 62, 'ADDER3', 63,
142     'SIEN0', 64, 'SIEN1', 65, 'SIST0', 66, 'SIST1', 67,
143     'SLPAR', 68,              'MACNTL', 70, 'GPCNTL', 71,
144     'STIME0', 72, 'STIME1', 73, 'RESPID', 74, 
145     'STEST0', 76, 'STEST1', 77, 'STEST2', 78, 'STEST3', 79,
146     'SIDL', 80,
147     'SODL', 84,
148     'SBDL', 88,
149     'SCRATCHB0', 92, 'SCRATCHB1', 93, 'SCRATCHB2', 94, 'SCRATCHB3', 95
150   );
151 }
152
153 # Parsing regular expressions
154 $identifier = '[A-Za-z_][A-Za-z_0-9]*';         
155 $decnum = '-?\\d+';
156 $hexnum = '0[xX][0-9A-Fa-f]+';          
157 $constant = "$hexnum|$decnum";
158
159 # yucky - since we can't control grouping of # $constant, we need to 
160 # expand out each alternative for $value.
161
162 $value = "$identifier|$identifier\\s*[+\-]\\s*$decnum|".
163     "$identifier\\s*[+-]\s*$hexnum|$constant";
164
165 print STDERR "value regex = $value\n" if ($debug);
166
167 $phase = join ('|', keys %scsi_phases);
168 print STDERR "phase regex = $phase\n" if ($debug);
169 $register = join ('|', keys %registers);
170
171 # yucky - since %operators includes meta-characters which must
172 # be escaped, I can't use the join() trick I used for the register
173 # regex
174
175 if ($ncr7x0_family) {
176   $operator = '\||OR|AND|\&|\+';
177 }
178 else {
179   $operator = '\||OR|AND|XOR|\&|\+';
180 }
181
182 # Global variables
183
184 %symbol_values = (%registers) ;         # Traditional symbol table
185
186 %symbol_references = () ;               # Table of symbol references, where
187                                         # the index is the symbol name, 
188                                         # and the contents a white space 
189                                         # delimited list of address,size
190                                         # tuples where size is in bytes.
191
192 @code = ();                             # Array of 32 bit words for SIOP 
193
194 @entry = ();                            # Array of entry point names
195
196 @label = ();                            # Array of label names
197
198 @absolute = ();                         # Array of absolute names
199
200 @relative = ();                         # Array of relative names
201
202 @external = ();                         # Array of external names
203
204 $address = 0;                           # Address of current instruction
205
206 $lineno = 0;                            # Line number we are parsing
207
208 $output = 'script.h';                   # Output file
209 $outputu = 'scriptu.h';
210
211 # &patch ($address, $offset, $length, $value) patches $code[$address]
212 #       so that the $length bytes at $offset have $value added to
213 #       them.  
214
215 @inverted_masks = (0x00_00_00_00, 0x00_00_00_ff, 0x00_00_ff_ff, 0x00_ff_ff_ff, 
216     0xff_ff_ff_ff);
217
218 sub patch {
219     local ($address, $offset, $length, $value) = @_;
220     if ($debug) {
221         print STDERR "Patching $address at offset $offset, length $length to $value\n";
222         printf STDERR "Old code : %08x\n", $code[$address];
223      }
224
225     $mask = ($inverted_masks[$length] << ($offset * 8));
226    
227     $code[$address] = ($code[$address] & ~$mask) | 
228         (($code[$address] & $mask) + ($value << ($offset * 8)) & 
229         $mask);
230     
231     printf STDERR "New code : %08x\n", $code[$address] if ($debug);
232 }
233
234 # &parse_value($value, $word, $offset, $length) where $value is 
235 #       an identifier or constant, $word is the word offset relative to 
236 #       $address, $offset is the starting byte within that word, and 
237 #       $length is the length of the field in bytes.
238 #
239 # Side effects are that the bytes are combined into the @code array
240 #       relative to $address, and that the %symbol_references table is 
241 #       updated as appropriate.
242
243 sub parse_value {
244     local ($value, $word, $offset, $length) = @_;
245     local ($tmp);
246
247     $symbol = '';
248
249     if ($value =~ /^REL\s*\(\s*($identifier)\s*\)\s*(.*)/i) {
250         $relative = 'REL';
251         $symbol = $1;
252         $value = $2;
253 print STDERR "Relative reference $symbol\n" if ($debug);
254     } elsif ($value =~ /^($identifier)\s*(.*)/) {
255         $relative = 'ABS';
256         $symbol = $1;
257         $value = $2;
258 print STDERR "Absolute reference $symbol\n" if ($debug);
259     } 
260
261     if ($symbol ne '') {
262 print STDERR "Referencing symbol $1, length = $length in $_\n" if ($debug);
263         $tmp = ($address + $word) * 4 + $offset;
264         if ($symbol_references{$symbol} ne undef) {
265             $symbol_references{$symbol} = 
266                 "$symbol_references{$symbol} $relative,$tmp,$length";
267         } else {
268             if (!defined($symbol_values{$symbol})) {
269 print STDERR "forward $1\n" if ($debug_external);
270                 $forward{$symbol} = "line $lineno : $_";
271             } 
272             $symbol_references{$symbol} = "$relative,$tmp,$length";
273         }
274     } 
275
276     $value = eval $value;
277     &patch ($address + $word, $offset, $length, $value);
278 }
279
280 # &parse_conditional ($conditional) where $conditional is the conditional
281 # clause from a transfer control instruction (RETURN, CALL, JUMP, INT).
282
283 sub parse_conditional {
284     local ($conditional) = @_;
285     if ($conditional =~ /^\s*(IF|WHEN)\s*(.*)/i) {
286         $if = $1;
287         $conditional = $2;
288         if ($if =~ /WHEN/i) {
289             $allow_atn = 0;
290             $code[$address] |= 0x00_01_00_00;
291             $allow_atn = 0;
292             print STDERR "$0 : parsed WHEN\n" if ($debug);
293         } else {
294             $allow_atn = 1;
295             print STDERR "$0 : parsed IF\n" if ($debug);
296         }
297     } else {
298             die "$0 : syntax error in line $lineno : $_
299         expected IF or WHEN
300 ";
301     }
302
303     if ($conditional =~ /^NOT\s+(.*)$/i) {
304         $not = 'NOT ';
305         $other = 'OR';
306         $conditional = $1;
307         print STDERR "$0 : parsed NOT\n" if ($debug);
308     } else {
309         $code[$address] |= 0x00_08_00_00;
310         $not = '';
311         $other = 'AND'
312     }
313
314     $need_data = 0;
315     if ($conditional =~ /^ATN\s*(.*)/i) {#
316         die "$0 : syntax error in line $lineno : $_
317         WHEN conditional is incompatible with ATN 
318 " if (!$allow_atn);
319         $code[$address] |= 0x00_02_00_00;
320         $conditional = $1;
321         print STDERR "$0 : parsed ATN\n" if ($debug);
322     } elsif ($conditional =~ /^($phase)\s*(.*)/i) {
323         $phase_index = "\U$1\E";
324         $p = $scsi_phases{$phase_index};
325         $code[$address] |= $p | 0x00_02_00_00;
326         $conditional = $2;
327         print STDERR "$0 : parsed phase $phase_index\n" if ($debug);
328     } else {
329         $other = '';
330         $need_data = 1;
331     }
332
333 print STDERR "Parsing conjunction, expecting $other\n" if ($debug);
334     if ($conditional =~ /^(AND|OR)\s*(.*)/i) {
335         $conjunction = $1;
336         $conditional = $2;
337         $need_data = 1;
338         die "$0 : syntax error in line $lineno : $_
339             Illegal use of $1.  Valid uses are 
340             ".$not."<phase> $1 data
341             ".$not."ATN $1 data
342 " if ($other eq '');
343         die "$0 : syntax error in line $lineno : $_
344         Illegal use of $conjunction.  Valid syntaxes are 
345                 NOT <phase>|ATN OR data
346                 <phase>|ATN AND data
347 " if ($conjunction !~ /\s*$other\s*/i);
348         print STDERR "$0 : parsed $1\n" if ($debug);
349     }
350
351     if ($need_data) {
352 print STDERR "looking for data in $conditional\n" if ($debug);
353         if ($conditional=~ /^($value)\s*(.*)/i) {
354             $code[$address] |= 0x00_04_00_00;
355             $conditional = $2;
356             &parse_value($1, 0, 0, 1);
357             print STDERR "$0 : parsed data\n" if ($debug);
358         } else {
359         die "$0 : syntax error in line $lineno : $_
360         expected <data>.
361 ";
362         }
363     }
364
365     if ($conditional =~ /^\s*,\s*(.*)/) {
366         $conditional = $1;
367         if ($conditional =~ /^AND\s\s*MASK\s\s*($value)\s*(.*)/i) {
368             &parse_value ($1, 0, 1, 1);
369             print STDERR "$0 parsed AND MASK $1\n" if ($debug);
370             die "$0 : syntax error in line $lineno : $_
371         expected end of line, not \"$2\"
372 " if ($2 ne '');
373         } else {
374             die "$0 : syntax error in line $lineno : $_
375         expected \",AND MASK <data>\", not \"$2\"
376 ";
377         }
378     } elsif ($conditional !~ /^\s*$/) { 
379         die "$0 : syntax error in line $lineno : $_
380         expected end of line" . (($need_data) ? " or \"AND MASK <data>\"" : "") . "
381         not \"$conditional\"
382 ";
383     }
384 }
385
386 # Parse command line
387 $output = shift;
388 $outputu = shift;
389
390     
391 # Main loop
392 while (<STDIN>) {
393     $lineno = $lineno + 1;
394     $list[$address] = $list[$address].$_;
395     s/;.*$//;                           # Strip comments
396
397
398     chop;                               # Leave new line out of error messages
399
400 # Handle symbol definitions of the form label:
401     if (/^\s*($identifier)\s*:(.*)/) {
402         if (!defined($symbol_values{$1})) {
403             $symbol_values{$1} = $address * 4;  # Address is an index into
404             delete $forward{$1};                # an array of longs
405             push (@label, $1);
406             $_ = $2;
407         } else {
408             die "$0 : redefinition of symbol $1 in line $lineno : $_\n";
409         }
410     }
411
412 # Handle symbol definitions of the form ABSOLUTE or RELATIVE identifier = 
413 # value
414     if (/^\s*(ABSOLUTE|RELATIVE)\s+(.*)/i) {
415         $is_absolute = $1;
416         $rest = $2;
417         foreach $rest (split (/\s*,\s*/, $rest)) {
418             if ($rest =~ /^($identifier)\s*=\s*($constant)\s*$/) {
419                 local ($id, $cnst) = ($1, $2);
420                 if ($symbol_values{$id} eq undef) {
421                     $symbol_values{$id} = eval $cnst;
422                     delete $forward{$id};
423                     if ($is_absolute =~ /ABSOLUTE/i) {
424                         push (@absolute , $id);
425                     } else {
426                         push (@relative, $id);
427                     }
428                 } else {
429                     die "$0 : redefinition of symbol $id in line $lineno : $_\n";
430                 }
431             } else {
432                 die 
433 "$0 : syntax error in line $lineno : $_
434             expected <identifier> = <value>
435 ";
436             }
437         }
438     } elsif (/^\s*EXTERNAL\s+(.*)/i) {
439         $externals = $1;
440         foreach $external (split (/,/,$externals)) {
441             if ($external =~ /\s*($identifier)\s*$/) {
442                 $external = $1;
443                 push (@external, $external);
444                 delete $forward{$external};
445                 if (defined($symbol_values{$external})) {
446                         die "$0 : redefinition of symbol $1 in line $lineno : $_\n";
447                 }
448                 $symbol_values{$external} = $external;
449 print STDERR "defined external $1 to $external\n" if ($debug_external);
450             } else {
451                 die 
452 "$0 : syntax error in line $lineno : $_
453         expected <identifier>, got $external
454 ";
455             }
456         }
457 # Process ENTRY identifier declarations
458     } elsif (/^\s*ENTRY\s+(.*)/i) {
459         if ($1 =~ /^($identifier)\s*$/) {
460             push (@entry, $1);
461         } else {
462             die
463 "$0 : syntax error in line $lineno : $_
464         expected ENTRY <identifier>
465 ";
466         }
467 # Process MOVE length, address, WITH|WHEN phase instruction
468     } elsif (/^\s*MOVE\s+(.*)/i) {
469         $rest = $1;
470         if ($rest =~ /^FROM\s+($value)\s*,\s*(WITH|WHEN)\s+($phase)\s*$/i) {
471             $transfer_addr = $1;
472             $with_when = $2;
473             $scsi_phase = $3;
474 print STDERR "Parsing MOVE FROM $transfer_addr, $with_when $3\n" if ($debug);
475             $code[$address] = 0x18_00_00_00 | (($with_when =~ /WITH/i) ? 
476                 0x00_00_00_00 : 0x08_00_00_00) | $scsi_phases{$scsi_phase};
477             &parse_value ($transfer_addr, 1, 0, 4);
478             $address += 2;
479         } elsif ($rest =~ /^($value)\s*,\s*(PTR\s+|)($value)\s*,\s*(WITH|WHEN)\s+($phase)\s*$/i) {
480             $transfer_len = $1;
481             $ptr = $2;
482             $transfer_addr = $3;
483             $with_when = $4;
484             $scsi_phase = $5;
485             $code[$address] = (($with_when =~ /WITH/i) ? 0x00_00_00_00 : 
486                 0x08_00_00_00)  | (($ptr =~ /PTR/i) ? (1 << 29) : 0) | 
487                 $scsi_phases{$scsi_phase};
488             &parse_value ($transfer_len, 0, 0, 3);
489             &parse_value ($transfer_addr, 1, 0, 4);
490             $address += 2;
491         } elsif ($rest =~ /^MEMORY\s+(.*)/i) {
492             $rest = $1;
493             $code[$address] = 0xc0_00_00_00; 
494             if ($rest =~ /^($value)\s*,\s*($value)\s*,\s*($value)\s*$/) {
495                 $count = $1;
496                 $source = $2;
497                 $dest =  $3;
498 print STDERR "Parsing MOVE MEMORY $count, $source, $dest\n" if ($debug);
499                 &parse_value ($count, 0, 0, 3);
500                 &parse_value ($source, 1, 0, 4);
501                 &parse_value ($dest, 2, 0, 4);
502 printf STDERR "Move memory instruction = %08x,%08x,%08x\n", 
503                 $code[$address], $code[$address+1], $code[$address +2] if
504                 ($debug);
505                 $address += 3;
506         
507             } else {
508                 die 
509 "$0 : syntax error in line $lineno : $_
510         expected <count>, <source>, <destination>
511 "
512             }
513         } elsif ($1 =~ /^(.*)\s+(TO|SHL|SHR)\s+(.*)/i) {
514 print STDERR "Parsing register to register move\n" if ($debug);
515             $src = $1;
516             $op = "\U$2\E";
517             $rest = $3;
518
519             $code[$address] = 0x40_00_00_00;
520         
521             $force = ($op !~ /TO/i); 
522
523
524 print STDERR "Forcing register source \n" if ($force && $debug);
525
526             if (!$force && $src =~ 
527                 /^($register)\s+(-|$operator)\s+($value)\s*$/i) {
528 print STDERR "register operand  data8 source\n" if ($debug);
529                 $src_reg = "\U$1\E";
530                 $op = "\U$2\E";
531                 if ($op ne '-') {
532                     $data8 = $3;
533                 } else {
534                     die "- is not implemented yet.\n"
535                 }
536             } elsif ($src =~ /^($register)\s*$/i) {
537 print STDERR "register source\n" if ($debug);
538                 $src_reg = "\U$1\E";
539                 # Encode register to register move as a register | 0 
540                 # move to register.
541                 if (!$force) {
542                     $op = '|';
543                 }
544                 $data8 = 0;
545             } elsif (!$force && $src =~ /^($value)\s*$/i) {
546 print STDERR "data8 source\n" if ($debug);
547                 $src_reg = undef;
548                 $op = 'NONE';
549                 $data8 = $1;
550             } else {
551                 if (!$force) {
552                     die 
553 "$0 : syntax error in line $lineno : $_
554         expected <register>
555                 <data8>
556                 <register> <operand> <data8>
557 ";
558                 } else {
559                     die
560 "$0 : syntax error in line $lineno : $_
561         expected <register>
562 ";
563                 }
564             }
565             if ($rest =~ /^($register)\s*(.*)$/i) {
566                 $dst_reg = "\U$1\E";
567                 $rest = $2;
568             } else {
569             die 
570 "$0 : syntax error in $lineno : $_
571         expected <register>, got $rest
572 ";
573             }
574
575             if ($rest =~ /^WITH\s+CARRY\s*(.*)/i) {
576                 $rest = $1;
577                 if ($op eq '+') {
578                     $code[$address] |= 0x01_00_00_00;
579                 } else {
580                     die
581 "$0 : syntax error in $lineno : $_
582         WITH CARRY option is incompatible with the $op operator.
583 ";
584                 }
585             }
586
587             if ($rest !~ /^\s*$/) {
588                 die
589 "$0 : syntax error in $lineno : $_
590         Expected end of line, got $rest
591 ";
592             }
593
594             print STDERR "source = $src_reg, data = $data8 , destination = $dst_reg\n"
595                 if ($debug);
596             # Note that Move data8 to reg is encoded as a read-modify-write
597             # instruction.
598             if (($src_reg eq undef) || ($src_reg eq $dst_reg)) {
599                 $code[$address] |= 0x38_00_00_00 | 
600                     ($registers{$dst_reg} << 16);
601             } elsif ($dst_reg =~ /SFBR/i) {
602                 $code[$address] |= 0x30_00_00_00 |
603                     ($registers{$src_reg} << 16);
604             } elsif ($src_reg =~ /SFBR/i) {
605                 $code[$address] |= 0x28_00_00_00 |
606                     ($registers{$dst_reg} << 16);
607             } else {
608                 die
609 "$0 : Illegal combination of registers in line $lineno : $_
610         Either source and destination registers must be the same,
611         or either source or destination register must be SFBR.
612 ";
613             }
614
615             $code[$address] |= $operators{$op};
616             
617             &parse_value ($data8, 0, 1, 1);
618             $code[$address] |= $operators{$op};
619             $code[$address + 1] = 0x00_00_00_00;# Reserved
620             $address += 2;
621         } else {
622             die 
623 "$0 : syntax error in line $lineno : $_
624         expected (initiator) <length>, <address>, WHEN <phase>
625                  (target) <length>, <address>, WITH <phase>
626                  MEMORY <length>, <source>, <destination>
627                  <expression> TO <register>
628 ";
629         }
630 # Process SELECT {ATN|} id, fail_address
631     } elsif (/^\s*(SELECT|RESELECT)\s+(.*)/i) {
632         $rest = $2;
633         if ($rest =~ /^(ATN|)\s*($value)\s*,\s*($identifier)\s*$/i) {
634             $atn = $1;
635             $id = $2;
636             $alt_addr = $3;
637             $code[$address] = 0x40_00_00_00 | 
638                 (($atn =~ /ATN/i) ? 0x01_00_00_00 : 0);
639             $code[$address + 1] = 0x00_00_00_00;
640             &parse_value($id, 0, 2, 1);
641             &parse_value($alt_addr, 1, 0, 4);
642             $address += 2;
643         } elsif ($rest =~ /^(ATN|)\s*FROM\s+($value)\s*,\s*($identifier)\s*$/i) {
644             $atn = $1;
645             $addr = $2;
646             $alt_addr = $3;
647             $code[$address] = 0x42_00_00_00 | 
648                 (($atn =~ /ATN/i) ? 0x01_00_00_00 : 0);
649             $code[$address + 1] = 0x00_00_00_00;
650             &parse_value($addr, 0, 0, 3);
651             &parse_value($alt_addr, 1, 0, 4);
652             $address += 2;
653         } else {
654             die 
655 "$0 : syntax error in line $lineno : $_
656         expected SELECT id, alternate_address or 
657                 SELECT FROM address, alternate_address or 
658                 RESELECT id, alternate_address or
659                 RESELECT FROM address, alternate_address
660 ";
661         }
662     } elsif (/^\s*WAIT\s+(.*)/i) {
663             $rest = $1;
664 print STDERR "Parsing WAIT $rest\n" if ($debug);
665         if ($rest =~ /^DISCONNECT\s*$/i) {
666             $code[$address] = 0x48_00_00_00;
667             $code[$address + 1] = 0x00_00_00_00;
668             $address += 2;
669         } elsif ($rest =~ /^(RESELECT|SELECT)\s+($identifier)\s*$/i) {
670             $alt_addr = $2;
671             $code[$address] = 0x50_00_00_00;
672             &parse_value ($alt_addr, 1, 0, 4);
673             $address += 2;
674         } else {
675             die
676 "$0 : syntax error in line $lineno : $_
677         expected (initiator) WAIT DISCONNECT or 
678                  (initiator) WAIT RESELECT alternate_address or
679                  (target) WAIT SELECT alternate_address
680 ";
681         }
682 # Handle SET and CLEAR instructions.  Note that we should also do something
683 # with this syntax to set target mode.
684     } elsif (/^\s*(SET|CLEAR)\s+(.*)/i) {
685         $set = $1;
686         $list = $2;
687         $code[$address] = ($set =~ /SET/i) ?  0x58_00_00_00 : 
688             0x60_00_00_00;
689         foreach $arg (split (/\s+AND\s+/i,$list)) {
690             if ($arg =~ /ATN/i) {
691                 $code[$address] |= 0x00_00_00_08;
692             } elsif ($arg =~ /ACK/i) {
693                 $code[$address] |= 0x00_00_00_40;
694             } elsif ($arg =~ /TARGET/i) {
695                 $code[$address] |= 0x00_00_02_00;
696             } elsif ($arg =~ /CARRY/i) {
697                 $code[$address] |= 0x00_00_04_00;
698             } else {
699                 die 
700 "$0 : syntax error in line $lineno : $_
701         expected $set followed by a AND delimited list of one or 
702         more strings from the list ACK, ATN, CARRY, TARGET.
703 ";
704             }
705         }
706         $code[$address + 1] = 0x00_00_00_00;
707         $address += 2;
708     } elsif (/^\s*(JUMP|CALL|INT)\s+(.*)/i) {
709         $instruction = $1;
710         $rest = $2;
711         if ($instruction =~ /JUMP/i) {
712             $code[$address] = 0x80_00_00_00;
713         } elsif ($instruction =~ /CALL/i) {
714             $code[$address] = 0x88_00_00_00;
715         } else {
716             $code[$address] = 0x98_00_00_00;
717         }
718 print STDERR "parsing JUMP, rest = $rest\n" if ($debug);
719
720 # Relative jump. 
721         if ($rest =~ /^(REL\s*\(\s*$identifier\s*\))\s*(.*)/i) { 
722             $addr = $1;
723             $rest = $2;
724 print STDERR "parsing JUMP REL, addr = $addr, rest = $rest\n" if ($debug);
725             $code[$address]  |= 0x00_80_00_00;
726             &parse_value($addr, 1, 0, 4);
727 # Absolute jump, requires no more gunk
728         } elsif ($rest =~ /^($value)\s*(.*)/) {
729             $addr = $1;
730             $rest = $2;
731             &parse_value($addr, 1, 0, 4);
732         } else {
733             die
734 "$0 : syntax error in line $lineno : $_
735         expected <address> or REL (address)
736 ";
737         }
738
739         if ($rest =~ /^,\s*(.*)/) {
740             &parse_conditional($1);
741         } elsif ($rest =~ /^\s*$/) {
742             $code[$address] |= (1 << 19);
743         } else {
744             die
745 "$0 : syntax error in line $lineno : $_
746         expected , <conditional> or end of line, got $1
747 ";
748         }
749         
750         $address += 2;
751     } elsif (/^\s*(RETURN|INTFLY)\s*(.*)/i) {
752         $instruction = $1;
753         $conditional = $2; 
754 print STDERR "Parsing $instruction\n" if ($debug);
755         $code[$address] = ($instruction =~ /RETURN/i) ? 0x90_00_00_00 :
756             0x98_10_00_00;
757         if ($conditional =~ /^,\s*(.*)/) {
758             $conditional = $1;
759             &parse_conditional ($conditional);
760         } elsif ($conditional !~ /^\s*$/) {
761             die
762 "$0 : syntax error in line $lineno : $_
763         expected , <conditional> 
764 ";
765         } else {
766             $code[$address] |= 0x00_08_00_00;
767         }
768            
769         $code[$address + 1] = 0x00_00_00_00;
770         $address += 2;
771     } elsif (/^\s*DISCONNECT\s*$/) {
772         $code[$address] = 0x48_00_00_00;
773         $code[$address + 1] = 0x00_00_00_00;
774         $address += 2;
775 # I'm not sure that I should be including this extension, but 
776 # what the hell?
777     } elsif (/^\s*NOP\s*$/i) {
778         $code[$address] = 0x80_88_00_00;
779         $code[$address + 1] = 0x00_00_00_00;
780         $address += 2;
781 # Ignore lines consisting entirely of white space
782     } elsif (/^\s*$/) {
783     } else {
784         die 
785 "$0 : syntax error in line $lineno: $_
786         expected label:, ABSOLUTE, CLEAR, DISCONNECT, EXTERNAL, MOVE, RESELECT,
787             SELECT SET, or WAIT
788 ";
789     }
790 }
791
792 # Fill in label references
793
794 @undefined = keys %forward;
795 if ($#undefined >= 0) {
796     print STDERR "Undefined symbols : \n";
797     foreach $undef (@undefined) {
798         print STDERR "$undef in $forward{$undef}\n";
799     }
800     exit 1;
801 }
802
803 @label_patches = ();
804
805 @external_patches = ();
806
807 @absolute = sort @absolute;
808
809 foreach $i (@absolute) {
810     foreach $j (split (/\s+/,$symbol_references{$i})) {
811         $j =~ /(REL|ABS),(.*),(.*)/;
812         $type = $1;
813         $address = $2;
814         $length = $3;
815         die 
816 "$0 : $symbol $i has invalid relative reference at address $address,
817     size $length\n"
818         if ($type eq 'REL');
819             
820         &patch ($address / 4, $address % 4, $length, $symbol_values{$i});
821     }
822 }
823
824 foreach $external (@external) {
825 print STDERR "checking external $external \n" if ($debug_external);
826     if ($symbol_references{$external} ne undef) {
827         for $reference (split(/\s+/,$symbol_references{$external})) {
828             $reference =~ /(REL|ABS),(.*),(.*)/;
829             $type = $1;
830             $address = $2;
831             $length = $3;
832             
833             die 
834 "$0 : symbol $label is external, has invalid relative reference at $address,
835     size $length\n"
836                 if ($type eq 'REL');
837
838             die 
839 "$0 : symbol $label has invalid reference at $address, size $length\n"
840                 if ((($address % 4) !=0) || ($length != 4));
841
842             $symbol = $symbol_values{$external};
843             $add = $code[$address / 4];
844             if ($add eq 0) {
845                 $code[$address / 4] = $symbol;
846             } else {
847                 $add = sprintf ("0x%08x", $add);
848                 $code[$address / 4] = "$symbol + $add";
849             }
850                 
851 print STDERR "referenced external $external at $1\n" if ($debug_external);
852         }
853     }
854 }
855
856 foreach $label (@label) {
857     if ($symbol_references{$label} ne undef) {
858         for $reference (split(/\s+/,$symbol_references{$label})) {
859             $reference =~ /(REL|ABS),(.*),(.*)/;
860             $type = $1;
861             $address = $2;
862             $length = $3;
863
864             if ((($address % 4) !=0) || ($length != 4)) {
865                 die "$0 : symbol $label has invalid reference at $1, size $2\n";
866             }
867
868             if ($type eq 'ABS') {
869                 $code[$address / 4] += $symbol_values{$label};
870                 push (@label_patches, $address / 4);
871             } else {
872
873 # - The address of the reference should be in the second and last word
874 #       of an instruction
875 # - Relative jumps, etc. are relative to the DSP of the _next_ instruction
876 #
877 # So, we need to add four to the address of the reference, to get 
878 # the address of the next instruction, when computing the reference.
879   
880                 $tmp = $symbol_values{$label} - 
881                     ($address + 4);
882                 die 
883 # Relative addressing is limited to 24 bits.
884 "$0 : symbol $label is too far ($tmp) from $address to reference as 
885     relative/\n" if (($tmp >= 0x80_00_00) || ($tmp < -0x80_00_00));
886                 $code[$address / 4] = $tmp & 0x00_ff_ff_ff;
887             }
888         }
889     }
890 }
891
892 # Output SCRIPT[] array, one instruction per line.  Optionally 
893 # print the original code too.
894
895 open (OUTPUT, ">$output") || die "$0 : can't open $output for writing\n";
896 open (OUTPUTU, ">$outputu") || die "$0 : can't open $outputu for writing\n";
897
898 ($_ = $0) =~ s:.*/::;
899 print OUTPUT "/* DO NOT EDIT - Generated automatically by ".$_." */\n";
900 print OUTPUT "static u32 ".$prefix."SCRIPT[] = {\n";
901 $instructions = 0;
902 for ($i = 0; $i < $#code; ) {
903     if ($list_in_array) {
904         printf OUTPUT "/*\n$list[$i]\nat 0x%08x : */", $i;
905     }
906     printf OUTPUT "\t0x%08x,", $code[$i];
907     printf STDERR "Address $i = %x\n", $code[$i] if ($debug);
908     if ($code[$i + 1] =~ /\s*($identifier)(.*)$/) {
909         push (@external_patches, $i+1, $1);
910         printf OUTPUT "0%s,", $2
911     } else {
912         printf OUTPUT "0x%08x,",$code[$i+1];
913     }
914
915     if (($code[$i] & 0xff_00_00_00) == 0xc0_00_00_00) {
916         if ($code[$i + 2] =~ /$identifier/) {
917             push (@external_patches, $i+2, $code[$i+2]);
918             printf OUTPUT "0,\n";
919         } else {
920             printf OUTPUT "0x%08x,\n",$code[$i+2];
921         }
922         $i += 3;
923     } else {
924         printf OUTPUT "\n";
925         $i += 2;
926     }
927     $instructions += 1;
928 }
929 print OUTPUT "};\n\n";
930
931 foreach $i (@absolute) {
932     printf OUTPUT "#define A_$i\t0x%08x\n", $symbol_values{$i};
933     if (defined($prefix) && $prefix ne '') {
934         printf OUTPUT "#define A_".$i."_used ".$prefix."A_".$i."_used\n";
935         printf OUTPUTU "#undef A_".$i."_used\n";
936     }
937     printf OUTPUTU "#undef A_$i\n";
938
939     printf OUTPUT "static u32 A_".$i."_used\[\] __attribute((unused)) = {\n";
940 printf STDERR "$i is used $symbol_references{$i}\n" if ($debug);
941     foreach $j (split (/\s+/,$symbol_references{$i})) {
942         $j =~ /(ABS|REL),(.*),(.*)/;
943         if ($1 eq 'ABS') {
944             $address = $2;
945             $length = $3;
946             printf OUTPUT "\t0x%08x,\n", $address / 4;
947         }
948     }
949     printf OUTPUT "};\n\n";
950 }
951
952 foreach $i (sort @entry) {
953     printf OUTPUT "#define Ent_$i\t0x%08x\n", $symbol_values{$i};
954     printf OUTPUTU "#undef Ent_$i\n", $symbol_values{$i};
955 }
956
957 #
958 # NCR assembler outputs label patches in the form of indices into 
959 # the code.
960 #
961 printf OUTPUT "static u32 ".$prefix."LABELPATCHES[] __attribute((unused)) = {\n";
962 for $patch (sort {$a <=> $b} @label_patches) {
963     printf OUTPUT "\t0x%08x,\n", $patch;
964 }
965 printf OUTPUT "};\n\n";
966
967 $num_external_patches = 0;
968 printf OUTPUT "static struct {\n\tu32\toffset;\n\tvoid\t\t*address;\n".
969     "} ".$prefix."EXTERNAL_PATCHES[] __attribute((unused)) = {\n";
970 while ($ident = pop(@external_patches)) {
971     $off = pop(@external_patches);
972     printf OUTPUT "\t{0x%08x, &%s},\n", $off, $ident;
973     ++$num_external_patches;
974 }
975 printf OUTPUT "};\n\n";
976
977 printf OUTPUT "static u32 ".$prefix."INSTRUCTIONS __attribute((unused))\t= %d;\n", 
978     $instructions;
979 printf OUTPUT "static u32 ".$prefix."PATCHES __attribute((unused))\t= %d;\n", 
980     $#label_patches+1;
981 printf OUTPUT "static u32 ".$prefix."EXTERNAL_PATCHES_LEN __attribute((unused))\t= %d;\n",
982     $num_external_patches;
983 close OUTPUT;
984 close OUTPUTU;