OpenCores
URL https://opencores.org/ocsvn/socgen/socgen/trunk

Subversion Repositories socgen

[/] [socgen/] [trunk/] [tools/] [padring/] [create_padring] - Blame information for rev 135

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 135 jt_eaton 
eval 'exec `which perl` -S $0 ${1+"$@"}'
2 
   if 0;
3 
 
4 
#/****************************************************************************/
5 
#/*                                                                          */
6 
#/*   SOCGEN Design for Reuse toolset                                        */
7 
#/*                                                                          */
8 
#/*   Version 1.0.0                                                          */
9 
#/*                                                                          */
10 
#/*   Author(s):                                                             */
11 
#/*      - John Eaton, z3qmtr45@gmail.com                                    */
12 
#/*                                                                          */
13 
#/****************************************************************************/
14 
#/*                                                                          */
15 
#/*                                                                          */
16 
#/*             Copyright 2016 John T Eaton                                  */
17 
#/*                                                                          */
18 
#/* Licensed under the Apache License, Version 2.0 (the "License");          */
19 
#/* you may not use this file except in compliance with the License.         */
20 
#/* You may obtain a copy of the License at                                  */
21 
#/*                                                                          */
22 
#/*    http://www.apache.org/licenses/LICENSE-2.0                            */
23 
#/*                                                                          */
24 
#/* Unless required by applicable law or agreed to in writing, software      */
25 
#/* distributed under the License is distributed on an "AS IS" BASIS,        */
26 
#/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
27 
#/* See the License for the specific language governing permissions and      */
28 
#/* limitations under the License.                                           */
29 
#/*                                                                          */
30 
#/*                                                                          */
31 
#/****************************************************************************/
32 
 
33 
 
34 
 
35 
############################################################################
36 
# General PERL config
37 
############################################################################
38 
use Getopt::Long;
39 
use English;
40 
use File::Basename;
41 
use Cwd;
42 
use XML::LibXML;
43 
use lib './tools';
44 
use sys::lib;
45 
use yp::lib;
46 
 
47 
$OUTPUT_AUTOFLUSH = 1; # set autoflush of stdout to TRUE.
48 
 
49 
############################################################################
50 
### Process the options
51 
############################################################################
52 
Getopt::Long::config("require_order", "prefix=-");
53 
GetOptions("h","help",
54 
           "vendor=s" => \$vendor,
55 
           "library=s" => \$library,
56 
           "component=s" => \$component,
57 
           "version=s" => \$version,
58 
           "core=s" => \$core,
59 
           "rtl=s" => \$rtl,
60 
           "xml=s" => \$xml
61 
) || die "(use '$program_name -h' for help)";
62 
 
63 
 
64 
 
65 
##############################################################################
66 
## Help option
67 
##############################################################################
68 
if ( $opt_h  or $opt_help)
69 
  { print "\n create_padring -vendor vendor_name  -library library_name  -component component_name path_to_pads_csv_from_cfgfile  pads_csv_file  ";
70 
    print "\nEX: create_padring -vendor foo  -library bar  -component chip  ./pads/padring.csv   ";
71 
    exit 1;
72 
  }
73 
 
74 
 
75 
##############################################################################
76 
##
77 
##############################################################################
78 
 
79 
$home = cwd();
80 
 
81 
 
82 
my    $pads_csv_path     = $ARGV[0];
83 
my    $pads_csv          = $ARGV[1];
84 
 
85 
 
86 
chomp($pads_csv_path);
87 
chomp($pads_csv);
88 
 
89 
 
90 
 
91 
 
92 
unless(defined $rtl)       {$rtl = "rtl";}
93 
unless(defined $xml)       {$xml = "xml";}
94 
 
95 
unless(defined $pads_csv)  {print "pads_csv file missing \n";exit}
96 
unless(defined $vendor)    { print "vendor missing \n";exit}
97 
unless(defined $library)   { print "library missing \n";exit}
98 
unless(defined $component) { print "component missing \n";exit}
99 
unless(defined $version)   { $version = "padring";}
100 
unless(defined $core)      { $core    = "core";}
101 
 
102 
my $parser = XML::LibXML->new();
103 
 
104 
 
105 
my $component_repo           = yp::lib::find_component_repo($vendor,$library,$component);
106 
my $lib_comp_sep             = yp::lib::find_lib_comp_sep($vendor,$library,$component);
107 
 
108 
 
109 
 
110 
 
111 
$pads_csv ="${home}${component_repo}/${vendor}/${library}${lib_comp_sep}${component}/${pads_csv_path}${pads_csv}";
112 
 
113 
unless(-e $pads_csv)
114 
{
115 
print "file not exist:  $pads_csv  \n";
116 
exit;
117 
}
118 
 
119 
 
120 
 
121 
 
122 
my @pad_list;
123 
my %Pin_type;
124 
my %Pad_name;
125 
my %Pin_dir;
126 
my %Pin_port;
127 
my %Pin_portDir;
128 
my %Pad_type;
129 
my %Pin_min;
130 
my %Pin_max;
131 
my %Has_in;
132 
my %Has_out;
133 
my %Has_oe;
134 
 
135 
 
136 
 
137 
$SRCFILE ="$pads_csv";
138 
open(SRCFILE) or die("Could not open src file.  $SRCFILE ");
139 
foreach $line ()
140 
    {
141 
    chomp($line);
142 
    $_ = $line;
143 
 
144 
if(/(\s+)/) {print " Syntax error: White space => $line \n" ;}
145 
 
146 
 
147 
 
148 
 
149 
if(/(\S+),(\S+)/)
150 
      {
151 
      $remainder      =$1;
152 
      $pin_ucf      =$2;
153 
 
154 
      }
155 
 
156 
    $_ = $remainder;
157 
if(/(\S+),(\S+)/)
158 
      {
159 
      $remainder      =$1;
160 
      $pin_reset      =$2;
161 
      }
162 
 
163 
    $_ = $remainder;
164 
if(/(\S+),(\S+)/)
165 
      {
166 
      $remainder      =$1;
167 
      $pin_dir      =$2;
168 
      }
169 
 
170 
      $_ = $remainder;
171 
 
172 
 
173 
if(/(\S+),(\S+)/)
174 
      {
175 
      $remainder      =$1;
176 
      $pin_name       =lc  $2;
177 
      }
178 
 
179 
      $_ = $remainder;
180 
 
181 
 
182 
 
183 
 
184 
   if(/(\w+)[\[](\d+)[\]]/)
185 
        {
186 
        $pad_name    = uc $1;
187 
        $pin_bit     = $2;
188 
        $pin_type    = "vector";
189 
 
190 
 
191 
        $Pad_name{$pin_name} = $pad_name;
192 
 
193 
 
194 
        if(defined $Pin_min{$pin_name})
195 
         {  if($Pin_min{$pin_name} >= $pin_bit) { $Pin_min{$pin_name} = $pin_bit;}      }
196 
         else
197 
         { $Pin_min{$pin_name} = $pin_bit ; }
198 
 
199 
 
200 
        if(defined $Pin_max{$pin_name})
201 
         {  if($Pin_max{$pin_name} <= $pin_bit) { $Pin_max{$pin_name} = $pin_bit;}      }
202 
         else
203 
         { $Pin_max{$pin_name} = $pin_bit ; }
204 
 
205 
         }
206 
       else
207 
        {
208 
        $Pad_name{$pin_name} = uc $_ ;
209 
        $pin_bit     = "xx";
210 
        $pin_type    = "scaler";
211 
        }
212 
 
213 
      #print "${pin_name}::${pin_type}::${pin_bit}::${pin_dir}::${pin_reset}::${pin_ucf}  \n";
214 
 
215 
      push (@pad_list,  "${pin_name}::${pin_type}::${pin_bit}::${pin_dir}::${pin_reset}::${pin_ucf}");
216 
 
217 
 
218 
      if(defined $Pin_type{$pin_name})
219 
      {  if($Pin_type{$pin_name} ne $pin_type) {print "Syntax Error: Pin type mismatch $line  \n";}      }
220 
      else
221 
      {$Pin_type{$pin_name} = $pin_type ; }
222 
 
223 
 
224 
      if(defined $Pin_dir{$pin_name})
225 
      {  if($Pin_dir{$pin_name} ne $pin_dir) {print "Syntax Error: Pin dir mismatch $line  \n";}      }
226 
      else
227 
      {$Pin_dir{$pin_name} = $pin_dir ; }
228 
 
229 
       if   ($pin_dir eq "in")
230 
           {
231 
           $Pin_port{$pin_name} ="in" ;
232 
           $Pin_portDir{$pin_name} ="in" ;
233 
           $Pad_type{$pin_name} ="in" ;
234 
           $Has_in{$pin_name}   = 1;
235 
           $Has_out{$pin_name}  = 0;
236 
           $Has_oe{$pin_name}   = 0;
237 
            }
238 
       elsif($pin_dir eq "out")
239 
           {
240 
           $Pin_port{$pin_name} ="out";
241 
           $Pin_portDir{$pin_name} ="out" ;
242 
           $Pad_type{$pin_name} ="out" ;
243 
           $Has_in{$pin_name}   = 0;
244 
           $Has_out{$pin_name}  = 1;
245 
           $Has_oe{$pin_name}   = 0;
246 
           }
247 
       elsif($pin_dir eq "inout")
248 
           {
249 
           $Pin_port{$pin_name} ="io";
250 
           $Pin_portDir{$pin_name} ="inout" ;
251 
           $Pad_type{$pin_name} ="se" ;
252 
           $Has_in{$pin_name}   = 1;
253 
           $Has_out{$pin_name}  = 1;
254 
           $Has_oe{$pin_name}   = 1;
255 
           }
256 
       elsif($pin_dir eq "inouts")
257 
           {
258 
           $Pin_port{$pin_name} ="io";
259 
           $Pin_portDir{$pin_name} ="inout" ;
260 
           $Pad_type{$pin_name} ="se" ;
261 
           $Has_in{$pin_name}   = 1;
262 
           $Has_out{$pin_name}  = 1;
263 
           $Has_oe{$pin_name}   = 2;
264 
           }
265 
       elsif($pin_dir eq "tsout")
266 
           {
267 
           $Pin_port{$pin_name} ="out";
268 
           $Pin_portDir{$pin_name} ="out" ;
269 
           $Pad_type{$pin_name} ="ts" ;
270 
           $Has_in{$pin_name}   = 0;
271 
           $Has_out{$pin_name}  = 1;
272 
           $Has_oe{$pin_name}   = 1;
273 
           }
274 
       elsif($pin_dir eq "odout")
275 
           {
276 
           $Pin_port{$pin_name} ="out";
277 
           $Pin_portDir{$pin_name} ="out" ;
278 
           $Pad_type{$pin_name} ="od" ;
279 
           $Has_in{$pin_name}   = 0;
280 
           $Has_out{$pin_name}  = 0;
281 
           $Has_oe{$pin_name}   = 1;
282 
           }
283 
       elsif($pin_dir eq "odinout")
284 
           {
285 
           $Pin_port{$pin_name} ="io";
286 
           $Pin_portDir{$pin_name} ="inout" ;
287 
           $Pad_type{$pin_name} ="se" ;
288 
           $Has_in{$pin_name}   = 1;
289 
           $Has_out{$pin_name}  = 0;
290 
           $Has_oe{$pin_name}   = 1;
291 
           }
292 
       else
293 
           {
294 
           $Pin_port{$pin_name} ="XX";
295 
           $Pin_portDir{$pin_name} ="XX" ;
296 
           $Pad_type{$pin_name} ="XX" ;
297 
           $Has_in{$pin_name}   = 0;
298 
           $Has_out{$pin_name}   = 0;
299 
           $Has_oe{$pin_name}   = 0;
300 
           }
301 
 
302 
 
303 
 
304 
 
305 
 
306 
 
307 
}
308 
 
309 
 
310 
 
311 
my @names = keys %Pin_type;
312 
@names      = sys::lib::trim_sort(@names);
313 
 
314 
for my $name (@names){print "$name   [ $Pin_max{$name}  $Pin_min{$name}]     $Pin_type{$name}   $Pin_dir{$name}     \n"}
315 
 
316 
 
317 
 
318 
 
319 
 
320 
 
321 
 
322 
 
323 
 
324 
print " Processing  $vendor $library $component  $rtl  $xml \n ---->>  ${pads_csv} \n";
325 
 
326 
my $xml_file = "${home}${component_repo}/${vendor}/${library}${lib_comp_sep}${component}/${rtl}";
327 
mkdir $xml_file,0755   unless( -e $xml_file );
328 
 
329 
my $xml_file = "${xml_file}/${xml}";
330 
mkdir $xml_file,0755   unless( -e $xml_file );
331 
 
332 
 
333 
#
334 
# Create Padring component file
335 
#
336 
 
337 
 
338 
my $outfile = "${xml_file}/${component}_${version}.xml";
339 
 
340 
my $cmd = "cp ${home}/tools/padring/component_boilerplate ${outfile}\n";
341 
 
342 
if(system($cmd)){}
343 
 
344 
open COMP_FILE,">>$outfile" or die "unable to open $outfile";
345 
 
346 
 
347 
 
348 
print COMP_FILE  "${vendor} \n";
349 
print COMP_FILE  "${library} \n";
350 
print COMP_FILE  "${component} \n";
351 
print COMP_FILE  "${version} \n";
352 
 
353 
 
354 
 
355 
 
356 
 
357 
 
358 
print COMP_FILE  "\n  \n";
359 
 
360 
foreach $pin_name (@names)
361 
  {
362 
  $PIN_name   =  $Pad_name{$pin_name};
363 
 
364 
  print COMP_FILE  "                                                                                   \n";
365 
  print COMP_FILE  " ${PIN_name}                                                                \n";
366 
  print COMP_FILE  "            \n";
367 
  print COMP_FILE  "                                                      \n";
368 
  print COMP_FILE  "    \n";
369 
  print COMP_FILE  "                                                                                      \n";
370 
  print COMP_FILE  "                                                                                       \n";
371 
  print COMP_FILE  "      PAD_${Pin_port{$pin_name}}   \n";
372 
  print COMP_FILE  "          ${PIN_name}         \n";
373 
 
374 
if($Pin_type{$pin_name} eq "vector")
375 
  {
376 
  print COMP_FILE  "            \n";
377 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
378 
  print COMP_FILE  "            \n";
379 
  }
380 
 
381 
  print COMP_FILE  "                      \n";
382 
  print COMP_FILE  "                                                                                      \n";
383 
  print COMP_FILE  "                                                                                     \n";
384 
  print COMP_FILE  "                                                    \n";
385 
  print COMP_FILE  "                                                                                       \n";
386 
  print COMP_FILE  "                                                                                 \n\n";
387 
  }
388 
 
389 
 
390 
print COMP_FILE  "\n  \n ";
391 
print COMP_FILE  "\n  \n";
392 
print COMP_FILE  "   \n";
393 
print COMP_FILE  "    \n";
394 
print COMP_FILE  "     Padring \n";
395 
print COMP_FILE  "     \n";
396 
print COMP_FILE  "    \n";
397 
print COMP_FILE  "   \n";
398 
print COMP_FILE  " \n";
399 
print COMP_FILE  "   \n";
400 
print COMP_FILE  "     \n";
401 
print COMP_FILE  "      Padring \n";
402 
print COMP_FILE  "      Padring \n";
403 
print COMP_FILE  "       \n";
404 
print COMP_FILE  "   \n";
405 
print COMP_FILE  "\n  \n";
406 
 
407 
foreach $pin_name (@names)
408 
  {
409 
  $PIN_name   =  $Pad_name{$pin_name};
410 
 
411 
  print COMP_FILE  "   ${PIN_name}                                                 \n";
412 
  print COMP_FILE  " wire         \n";
413 
  print COMP_FILE  "  ${Pin_portDir{$pin_name}}      \n";
414 
  if($Pin_type{$pin_name} eq "vector")
415 
   {
416 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
417 
   }
418 
  print COMP_FILE  "            \n";
419 
  print COMP_FILE  "                                                                                  \n\n";
420 
 
421 
  }
422 
 
423 
 
424 
 
425 
 
426 
 
427 
 
428 
print COMP_FILE  "\n  \n ";
429 
print COMP_FILE  "\n  \n ";
430 
print COMP_FILE  "\n  \n ";
431 
close COMP_FILE;
432 
 
433 
 
434 
 
435 
 
436 
 
437 
 
438 
#
439 
# Create Padring design file
440 
#
441 
 
442 
 
443 
$outfile = "${xml_file}/${component}_${version}.design.xml";
444 
 
445 
my $cmd = "cp ${home}/tools/padring/design_boilerplate ${outfile}\n";
446 
 
447 
if(system($cmd)){}
448 
 
449 
open DESIGN_FILE,">>$outfile" or die "unable to open $outfile";
450 
 
451 
print DESIGN_FILE  "${vendor} \n";
452 
print DESIGN_FILE  "${library} \n";
453 
print DESIGN_FILE  "${component} \n";
454 
print DESIGN_FILE  "${version}.design \n";
455 
 
456 
 
457 
 
458 
print DESIGN_FILE  "\n  \n";
459 
foreach $pin_name (@names)
460 
  {
461 
  $PIN_name   =  $Pad_name{$pin_name};
462 
 
463 
  print DESIGN_FILE  "                                                               \n";
464 
  print DESIGN_FILE  " ${PIN_name}                                                \n";
465 
  print DESIGN_FILE  "         \n";
466 
  print DESIGN_FILE  "                                                                      \n";
467 
  print DESIGN_FILE  "                                                                       \n";
468 
  print DESIGN_FILE  "    PAD_${Pin_port{$pin_name}} \n";
469 
  print DESIGN_FILE  "          ${PIN_name}                  \n";
470 
 
471 
 
472 
if($Pin_type{$pin_name} eq "vector")
473 
  {
474 
  print DESIGN_FILE  "            \n";
475 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}\n";
476 
  print DESIGN_FILE  "            \n";
477 
  }
478 
 
479 
  print DESIGN_FILE  "                               \n";
480 
  print DESIGN_FILE  "                                                    \n";
481 
  print DESIGN_FILE  "                                             \n";
482 
  print DESIGN_FILE  "                        \n";
483 
  print DESIGN_FILE  "                                             \n\n";
484 
 
485 
 
486 
print DESIGN_FILE  "                                              \n";
487 
  print DESIGN_FILE  " ${pin_name}                                               \n";
488 
  print DESIGN_FILE  "             \n";
489 
  print DESIGN_FILE  "                                                                     \n";
490 
  if ($Has_in{$pin_name} == 1)
491 
  {
492 
  print DESIGN_FILE  "                                                                       \n";
493 
  print DESIGN_FILE  "    pad_in         \n";
494 
  print DESIGN_FILE  "          ${pin_name}_pad_in                  \n";
495 
if($Pin_type{$pin_name} eq "vector")
496 
  {
497 
  print DESIGN_FILE  "            \n";
498 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name} \n";
499 
  print DESIGN_FILE  "            \n";
500 
  }
501 
 
502 
  print DESIGN_FILE  "                                \n";
503 
  }
504 
  if ($Has_out{$pin_name} == 1)
505 
  {
506 
  print DESIGN_FILE  "                                                                   \n";
507 
  print DESIGN_FILE  "    pad_out    \n";
508 
  print DESIGN_FILE  "          ${pin_name}_pad_out                  \n";
509 
  if($Pin_type{$pin_name} eq "vector")
510 
  {
511 
  print DESIGN_FILE  "            \n";
512 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}\n";
513 
  print DESIGN_FILE  "            \n";
514 
  }
515 
 
516 
  print DESIGN_FILE  "                                                    \n";
517 
  }
518 
 
519 
 
520 
 
521 
if ($Has_oe{$pin_name} == 1)
522 
  {
523 
  print DESIGN_FILE  "                                                                         \n";
524 
  print DESIGN_FILE  "    pad_oe           \n";
525 
  print DESIGN_FILE  "          ${pin_name}_pad_oe  \n";
526 
  print DESIGN_FILE  "                                                                        \n";
527 
  }
528 
 
529 
 
530 
if ($Has_oe{$pin_name} == 2)
531 
  {
532 
  print DESIGN_FILE  "                                                                         \n";
533 
  print DESIGN_FILE  "    pad_oe           \n";
534 
  print DESIGN_FILE  "          ${pin_name}_pad_oe  \n";
535 
  print DESIGN_FILE  "            \n";
536 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}\n";
537 
  print DESIGN_FILE  "            \n";
538 
  print DESIGN_FILE  "                                                                        \n";
539 
  }
540 
 
541 
 
542 
 
543 
 
544 
 
545 
 
546 
 
547 
  print DESIGN_FILE  "                                                                       \n";
548 
  print DESIGN_FILE  "                                                   \n";
549 
 
550 
 
551 
 
552 
print DESIGN_FILE  "            \n";
553 
  print DESIGN_FILE  "                                                                        \n";
554 
  if ($Has_in{$pin_name} == 1)
555 
  {
556 
  print DESIGN_FILE  "                                                                         \n";
557 
  print DESIGN_FILE  "    ${pin_name}_pad_in           \n";
558 
  print DESIGN_FILE  "          ${pin_name}_pad_in             \n";
559 
if($Pin_type{$pin_name} eq "vector")
560 
  {
561 
  print DESIGN_FILE  "            \n";
562 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name} \n";
563 
  print DESIGN_FILE  "            \n";
564 
  }
565 
 
566 
  print DESIGN_FILE  "                                                   \n";
567 
  }
568 
  if ($Has_out{$pin_name} == 1)
569 
  {
570 
  print DESIGN_FILE  "                                                                           \n";
571 
  print DESIGN_FILE  "    ${pin_name}_pad_out            \n";
572 
  print DESIGN_FILE  "          ${pin_name}_pad_out              \n";
573 
if($Pin_type{$pin_name} eq "vector")
574 
  {
575 
  print DESIGN_FILE  "            \n";
576 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}\n";
577 
  print DESIGN_FILE  "            \n";
578 
  }
579 
 
580 
  print DESIGN_FILE  "                                                     \n";
581 
  }
582 
  if ($Has_oe{$pin_name} == 1)
583 
  {
584 
  print DESIGN_FILE  "                                                                               \n";
585 
  print DESIGN_FILE  "    ${pin_name}_pad_oe                  \n";
586 
  print DESIGN_FILE  "          ${pin_name}_pad_oe  \n";
587 
  print DESIGN_FILE  "                                                                                    \n";
588 
  }
589 
 
590 
 
591 
 
592 
  if ($Has_oe{$pin_name} == 2)
593 
  {
594 
  print DESIGN_FILE  "                                                                               \n";
595 
  print DESIGN_FILE  "    ${pin_name}_pad_oe                  \n";
596 
  print DESIGN_FILE  "          ${pin_name}_pad_oe  \n";
597 
  print DESIGN_FILE  "            \n";
598 
  print DESIGN_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}\n";
599 
  print DESIGN_FILE  "            \n";
600 
print DESIGN_FILE  "                                                                                    \n";
601 
}
602 
 
603 
 
604 
 
605 
 
606 
 
607 
  print DESIGN_FILE  "                                                                                   \n";
608 
  print DESIGN_FILE  "                                                   \n";
609 
  print DESIGN_FILE  "                                                                           \n\n";
610 
  }
611 
 
612 
 
613 
print DESIGN_FILE  "\n  \n ";
614 
 
615 
  print DESIGN_FILE  "\n  \n\n";
616 
 
617 
  print DESIGN_FILE  "   ${core}      \n";
618 
  print DESIGN_FILE  "          \n";
619 
  print DESIGN_FILE  "                                                                                  \n\n";
620 
 
621 
foreach $pin_name (@names)
622 
  {
623 
 
624 
 
625 
  print DESIGN_FILE  "   ${pin_name}_pad      \n";
626 
  print DESIGN_FILE  "          \n";
627 
if($Pin_type{$pin_name} eq "vector")
628 
  {
629 
  my $width = $Pin_max{$pin_name} - $Pin_min{$pin_name} + 1  ;
630 
  print DESIGN_FILE  "       \n";
631 
  print DESIGN_FILE  " ${width}      \n";
632 
 
633 
  if($Has_oe{$pin_name} == 2)
634 
    {
635 
  print DESIGN_FILE  " ${width}      \n";
636 
    }
637 
 
638 
 
639 
 
640 
  print DESIGN_FILE  "       \n";
641 
  }
642 
 
643 
 
644 
  print DESIGN_FILE  "                                                                                  \n\n";
645 
 
646 
  }
647 
 
648 
 
649 
 
650 
print DESIGN_FILE  "\n  \n ";
651 
print DESIGN_FILE  "\n  \n ";
652 
 
653 
close DESIGN_FILE;
654 
 
655 
 
656 
 
657 
#
658 
# Create core component file
659 
#
660 
 
661 
 
662 
 
663 
 
664 
my $outfile = "${xml_file}/${component}_${core}.xml";
665 
 
666 
my $cmd = "cp ${home}/tools/padring/component_boilerplate ${outfile}\n";
667 
 
668 
if(system($cmd)){}
669 
 
670 
open COMP_FILE,">>$outfile" or die "unable to open $outfile";
671 
 
672 
print COMP_FILE  "${vendor} \n";
673 
print COMP_FILE  "${library} \n";
674 
print COMP_FILE  "${component} \n";
675 
print COMP_FILE  "${core} \n";
676 
 
677 
 
678 
print COMP_FILE  "\n  \n";
679 
 
680 
foreach $pin_name (@names)
681 
  {
682 
 
683 
  print COMP_FILE  "                                                                                   \n";
684 
  print COMP_FILE  " ${pin_name}_pad                                                             \n";
685 
  print COMP_FILE  "             \n";
686 
  print COMP_FILE  "                                                       \n";
687 
  print COMP_FILE  "    \n";
688 
  print COMP_FILE  "                                                                                       \n";
689 
 if($Has_in{$pin_name})
690 
  {
691 
 print COMP_FILE  "                                                                                        \n";
692 
  print COMP_FILE  "      pad_in                       \n";
693 
  print COMP_FILE  "          ${pin_name}_pad_in      \n";
694 
if($Pin_type{$pin_name} eq "vector")
695 
  {
696 
  print COMP_FILE  "            \n";
697 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
698 
  print COMP_FILE  "            \n";
699 
  }
700 
  print COMP_FILE  "                                                                                       \n";
701 
  }
702 
 if($Has_out{$pin_name})
703 
  {
704 
  print COMP_FILE  "                                                                                        \n";
705 
  print COMP_FILE  "      pad_out                       \n";
706 
  print COMP_FILE  "          ${pin_name}_pad_out   \n";
707 
if($Pin_type{$pin_name} eq "vector")
708 
  {
709 
  print COMP_FILE  "            \n";
710 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
711 
  print COMP_FILE  "            \n";
712 
  }
713 
  print COMP_FILE  "                                                                                       \n";
714 
  }
715 
 if($Has_oe{$pin_name} == 1)
716 
  {
717 
  print COMP_FILE  "                                                                                        \n";
718 
  print COMP_FILE  "      pad_oe                       \n";
719 
  print COMP_FILE  "          ${pin_name}_pad_oe     \n";
720 
  print COMP_FILE  "                                                                                       \n";
721 
  }
722 
 
723 
 
724 
 if($Has_oe{$pin_name} == 2)
725 
  {
726 
  print COMP_FILE  "                                                                                        \n";
727 
  print COMP_FILE  "      pad_oe                       \n";
728 
  print COMP_FILE  "          ${pin_name}_pad_oe     \n";
729 
  print COMP_FILE  "            \n";
730 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
731 
  print COMP_FILE  "            \n";
732 
 
733 
  print COMP_FILE  "                                                                                       \n";
734 
  }
735 
 
736 
 
737 
 
738 
 
739 
 
740 
  print COMP_FILE  "                                                                                      \n";
741 
  print COMP_FILE  "                                                     \n";
742 
  print COMP_FILE  "                                                                                        \n";
743 
  print COMP_FILE  "                                                                                  \n\n";
744 
 
745 
  }
746 
 
747 
 
748 
print COMP_FILE  "\n  \n ";
749 
print COMP_FILE  "\n  \n";
750 
print COMP_FILE  "   \n";
751 
print COMP_FILE  "    \n";
752 
print COMP_FILE  "     Core \n";
753 
print COMP_FILE  "     \n";
754 
print COMP_FILE  "    \n";
755 
print COMP_FILE  "   \n";
756 
print COMP_FILE  " \n";
757 
print COMP_FILE  "   \n";
758 
print COMP_FILE  "     \n";
759 
print COMP_FILE  "      Core \n";
760 
print COMP_FILE  "      Core \n";
761 
print COMP_FILE  "       \n";
762 
print COMP_FILE  "   \n";
763 
print COMP_FILE  "\n  \n";
764 
 
765 
foreach $pin_name (@names)
766 
  {
767 
 
768 
 
769 
if($Has_in{$pin_name})
770 
  {
771 
  print COMP_FILE  "   ${pin_name}_pad_in                             \n";
772 
  print COMP_FILE  " wire  \n";
773 
  print COMP_FILE  "  in                                                    \n";
774 
  if($Pin_type{$pin_name} eq "vector")
775 
   {
776 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
777 
   }
778 
 
779 
  print COMP_FILE  "                                                                                  \n\n";
780 
  }
781 
 
782 
 
783 
if($Has_out{$pin_name})
784 
  {
785 
  print COMP_FILE  "   ${pin_name}_pad_out                             \n";
786 
  print COMP_FILE  " wire  \n";
787 
  print COMP_FILE  "  out                                                     \n";
788 
  if($Pin_type{$pin_name} eq "vector")
789 
   {
790 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
791 
   }
792 
  print COMP_FILE  "                                                                                  \n\n";
793 
  }
794 
 
795 
 
796 
if($Has_oe{$pin_name} == 1)
797 
  {
798 
  print COMP_FILE  "   ${pin_name}_pad_oe                             \n";
799 
  print COMP_FILE  " wire  \n";
800 
  print COMP_FILE  "  out                                                    \n";
801 
  print COMP_FILE  "                                                                                   \n\n";
802 
  }
803 
 
804 
 
805 
if($Has_oe{$pin_name} == 2)
806 
  {
807 
  print COMP_FILE  "   ${pin_name}_pad_oe                             \n";
808 
  print COMP_FILE  " wire  \n";
809 
  print COMP_FILE  "  out                                                     \n";
810 
  print COMP_FILE  "   $Pin_max{$pin_name}$Pin_min{$pin_name}         \n";
811 
 
812 
print COMP_FILE  "                                                                                   \n\n";
813 
  }
814 
 
815 
 
816 
 
817 
 
818 
}
819 
 
820 
 
821 
print COMP_FILE  "\n  \n ";
822 
print COMP_FILE  "\n  \n ";
823 
print COMP_FILE  "\n  \n ";
824 
 
825 
close COMP_FILE;
826 
 
827 
 
828 
#
829 
# Create Core design file
830 
#
831 
 
832 
$outfile = "${xml_file}/${component}_padring_dut.design.xml";
833 
 
834 
my $cmd = "cp ${home}/tools/padring/design_boilerplate ${outfile}\n";
835 
 
836 
if(system($cmd)){}
837 
 
838 
open DESIGN_FILE,">>$outfile" or die "unable to open $outfile";
839 
 
840 
print DESIGN_FILE  "${vendor} \n";
841 
print DESIGN_FILE  "${library} \n";
842 
print DESIGN_FILE  "${component} \n";
843 
print DESIGN_FILE  "padring_dut.design \n";
844 
 
845 
print DESIGN_FILE  " \n";
846 
print DESIGN_FILE  " \n";
847 
print DESIGN_FILE  "dut<\/ipxact:instanceName> \n";
848 
print DESIGN_FILE  " \n";
849 
print DESIGN_FILE  " \n";
850 
print DESIGN_FILE  "<\/ipxact:configurableElementValues> \n";
851 
print DESIGN_FILE  "<\/ipxact:componentInstance> \n";
852 
print DESIGN_FILE  "<\/ipxact:componentInstances> \n";
853 
 
854 
 
855 
 
856 
 
857 
print DESIGN_FILE  "\n  \n";
858 
foreach $pin_name (@names)
859 
  {
860 
  $PIN_name   =  $Pad_name{$pin_name};
861 
  $pin_min    =  $Pin_min{$pin_name};
862 
  $pin_max    =  $Pin_max{$pin_name};
863 
 
864 
  print DESIGN_FILE  "                                                               \n";
865 
  print DESIGN_FILE  " ${PIN_name}                                                \n";
866 
if($Pin_type{$pin_name} eq "vector")
867 
  {
868 
  print DESIGN_FILE  "  \n";
869 
  }
870 
else
871 
  {
872 
  print DESIGN_FILE  "         \n";
873 
  }
874 
 
875 
 
876 
 
877 
print DESIGN_FILE  "         \n";
878 
  print DESIGN_FILE  "                                                              \n";
879 
 
880 
  }
881 
 
882 
 
883 
print DESIGN_FILE  "\n  \n";
884 
 
885 
 
886 
print DESIGN_FILE  "\n  \n ";
887 
 
888 
close DESIGN_FILE;
889 
 
890 
 
891 
 
892 
$outfile ="${home}${component_repo}/${vendor}/${library}${lib_comp_sep}${component}/${pads_csv_path}padring.pcf";
893 
 
894 
print "creating  $outfile  \n";
895 
 
896 
open ARA_FILE,">$outfile" or die "unable to open $outfile";
897 
 
898 
foreach $pad (@pad_list)
899 
 {
900 
 ( ${pin_name},${pin_type},${pin_bit},${pin_dir},${pin_reset},${pin_ucf}) = split( /::/ , $pad);
901 
 
902 
  $PIN_name = $Pad_name{$pin_name};
903 
if (${pin_type} eq "vector")
904 
   {
905 
   print ARA_FILE  "set_io ${PIN_name}[${pin_bit}]  ${pin_ucf}    \n";
906 
   }
907 
 else
908 
   {
909 
   print ARA_FILE  "set_io ${PIN_name} ${pin_ucf}    \n";
910 
   }
911 
}
912 
 
913 
close ARA_FILE;
914 
 
915 
 
916 
 
917 
$outfile ="${home}${component_repo}/${vendor}/${library}${lib_comp_sep}${component}/${pads_csv_path}padring.ucf";
918 
 
919 
print "creating  $outfile  \n";
920 
 
921 
open ISE_FILE,">$outfile" or die "unable to open $outfile";
922 
 
923 
foreach $pad (@pad_list) {
924 
 
925 
 
926 
 ( ${pin_name},${pin_type},${pin_bit},${pin_dir},${pin_reset},${pin_ucf}) = split( /::/ , $pad);
927 
 $PIN_name = $Pad_name{$pin_name};
928 
if (${pin_type} eq "vector")
929 
   {
930 
   print ISE_FILE  "NET  \"${PIN_name}<${pin_bit}>\"  lOC=\"${pin_ucf}\"; \n";
931 
   }
932 
 else
933 
   {
934 
   print ISE_FILE  "NET  \"${PIN_name}\"  LOC=\"${pin_ucf}\";\n";
935 
   }
936 
 
937 
 
938 
 
939 
 
940 
}
941 
 
942 
close ISE_FILE;
943 
 
944 
 
945 
 
946 
1
947 
 
948 
 
949 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.