source: soft/giet_vm/giet_python/mapping.py @ 439

Last change on this file since 439 was 425, checked in by porquet, 10 years ago

genmap: fix python version

  • Property svn:executable set to *
File size: 111.5 KB
Line 
1#!/usr/bin/env python
2
3import sys
4
5##########################################################################################
6#   file   : giet_mapping.py
7#   date   : april 2014
8#   author : Alain Greiner
9##########################################################################################
10#  This file contains the classes required to define a mapping for the GIET_VM.
11# - A 'Mapping' contains a set of 'Cluster'   (hardware architecture)
12#                        a set of 'Vseg'      (kernel virtual segments mapping)
13#                        a set of 'Vspace'    (several user applications).
14# - A 'Cluster' contains a set of 'Pseg'      (all physical segments in cluster)
15#                        a set of 'Proc'      (processors in cluster)
16#                        a set of 'Periph'    (peripherals in cluster)
17#                        a set of 'Coproc'    (coprocessors in cluster)
18# - A 'Vspace' contains  a set of 'Vseg'      (user virtual segments mapping)
19#                        a set of 'Task'      (user tasks mapping)
20# - A 'Vseg'   contains  a set of 'Vobj'
21# - A 'Periph' contains  a set of 'Irq'       (only for XCU, ICU and PIC types )
22# - A 'Coproc' contains  a set of 'Cpports'   (one port per MWMR channel)
23##########################################################################################
24# Implementation Note
25# The various objects used to describe a mapping are distributed in the PYTHON structure:
26# For example the psegs set is split in several subsets (one subset per cluster),
27# or the tasks set is split in several subsets (one subset per vspace), etc...
28# In the C binary data structure used by the giet_vm, all objects of same type
29# are stored in a linear array (one single array for all psegs for example).
30# For all objects, we compute and store in the  PYTHON object itsel a "global index"
31# corresponding to the index in this global array, and this index can be used as
32# a pseudo-pointer to identify a specific object of a given type.
33##########################################################################################
34
35##########################################################################################
36# Various constants
37##########################################################################################
38
39PADDR_WIDTH       = 40            # number of bits for physical address
40X_WIDTH           = 4             # number of bits encoding x coordinate
41Y_WIDTH           = 4             # number of bits encoding y coordinate
42P_WIDTH           = 4             # number of bits encoding local proc_id
43VPN_ANTI_MASK     = 0x00000FFF    # mask virtual address to get offset in a small page
44BPN_MASK          = 0xFFE00000    # mask virtual address to get the BPN (big page)
45PERI_INCREMENT    = 0x10000       # virtual address increment for replicated global vsegs
46RESET_ADDRESS     = 0xBFC00000    # Processor wired boot_address
47MAPPING_SIGNATURE = 0xDACE2014    # Magic number indicating a valid C binary struture
48
49##########################################################################################
50# These global lists must be consistent with enums in mapping_info.h or irq_handler.
51##########################################################################################
52PERIPHTYPES =    [
53                  'CMA',
54                  'DMA',
55                  'FBF',
56                  'ICU',
57                  'IOB',
58                  'IOC',
59                  'MMC',
60                  'MWR',
61                  'NIC',
62                  'ROM',
63                  'SIM',
64                  'TIM',
65                  'TTY',
66                  'XCU',
67                  'PIC',
68                 ]
69
70PERIPHSUBTYPES = [
71                  'BDV',
72                  'HBA',
73                  'SPI',
74                  'NONE',
75                 ]
76
77IRQTYPES =       [
78                  'HWI',
79                  'WTI',
80                  'PTI',
81                 ]
82
83ISRTYPES =       [
84                  'ISR_DEFAULT',
85                  'ISR_TICK',
86                  'ISR_TTY_RX',
87                  'ISR_TTY_TX',
88                  'ISR_BDV',
89                  'ISR_TIMER',
90                  'ISR_WAKUP',
91                  'ISR_NIC_RX',
92                  'ISR_NIC_TX',
93                  'ISR_CMA',
94                  'ISR_MMC',
95                  'ISR_DMA',
96                  'ISR_SPI',
97                 ]
98
99VOBJTYPES =      [
100                  'ELF',
101                  'BLOB',
102                  'PTAB',
103                  'PERI',
104                  'MWMR',
105                  'LOCK',
106                  'BUFFER',
107                  'BARRIER',
108                  'CONST',
109                  'MEMSPACE',
110                  'SCHED',
111                 ]
112
113VSEGMODES =      [
114                  '____',
115                  '___U',
116                  '__W_',
117                  '__WU',
118                  '_X__',
119                  '_X_U',
120                  '_XW_',
121                  '_XWU',
122                  'C___',
123                  'C__U',
124                  'C_W_',
125                  'C_WU',
126                  'CX__',
127                  'CX_U',
128                  'CXW_',
129                  'CXWU',
130                 ]
131
132PSEGTYPES =      [
133                  'RAM',
134                  'ROM',        # deprecated => use PERI
135                  'PERI',
136                 ]
137
138CP_PORT_DIRS =   [
139                  'TO_COPROC',
140                  'FROM_COPROC',
141                 ]
142
143##########################################################################################
144class Mapping( object ):
145##########################################################################################
146    def __init__( self,
147                  name,                            # mapping name
148                  x_size,                          # number of clusters in a row
149                  y_size,                          # number of clusters in a column
150                  nprocs,                          # max number of processors per cluster
151                  x_width        = X_WIDTH,        # number of bits encoding x coordinate
152                  y_width        = Y_WIDTH,        # number of bits encoding y coordinate
153                  p_width        = P_WIDTH,        # number of bits encoding local proc_id
154                  paddr_width    = PADDR_WIDTH,    # number of bits for physical address
155                  coherence      = 1,              # hardware cache coherence when non-zero
156                  irq_per_proc   = 1,              # number or IRQs from XCU to processor
157                  use_ramdisk    = False,          # use ramdisk when true
158                  x_io           = 0,              # cluster_io x coordinate
159                  y_io           = 0,              # cluster_io y coordinate
160                  peri_increment = PERI_INCREMENT, # address increment for globals
161                  reset_address  = RESET_ADDRESS,  # Processor wired boot_address
162                  ram_base       = 0,              # RAM physical base in cluster[0,0]
163                  ram_size       = 0 ):            # RAM size in each cluster (bytes)
164
165        assert ( x_size <= (1<<X_WIDTH) )
166        assert ( y_size <= (1<<Y_WIDTH) )
167        assert ( nprocs <= (1<<P_WIDTH) )
168
169        self.signature      = MAPPING_SIGNATURE
170        self.name           = name
171        self.paddr_width    = paddr_width
172        self.coherence      = coherence
173        self.x_size         = x_size
174        self.y_size         = y_size
175        self.nprocs      = nprocs
176        self.x_width        = x_width
177        self.y_width        = y_width
178        self.p_width        = p_width
179        self.irq_per_proc   = irq_per_proc
180        self.use_ramdisk    = use_ramdisk
181        self.x_io           = x_io
182        self.y_io           = y_io
183        self.peri_increment = peri_increment
184        self.reset_address  = reset_address
185        self.ram_base       = ram_base
186        self.ram_size       = ram_size
187
188        self.total_vspaces  = 0
189        self.total_globals  = 0
190        self.total_psegs    = 0
191        self.total_vsegs    = 0
192        self.total_vobjs    = 0
193        self.total_tasks    = 0
194        self.total_procs    = 0
195        self.total_irqs     = 0
196        self.total_coprocs  = 0
197        self.total_cpports  = 0
198        self.total_periphs  = 0
199
200        self.clusters       = []
201        self.globs          = []
202        self.vspaces        = []
203
204        for x in xrange( self.x_size ):
205            for y in xrange( self.y_size ):
206                cluster = Cluster( x , y )
207                cluster.index = (x * self.y_size) + y
208                self.clusters.append( cluster )
209
210        return
211
212    ##########################    add a ram pseg in a cluster
213    def addRam( self,
214                name,                  # pseg name
215                base,                  # pseg base address
216                size ):                # pseg length (bytes)
217
218        # computes coordinates from the base address extension
219        paddr_lsb_width = self.paddr_width - self.x_width - self.y_width
220        cluster_xy = base >> paddr_lsb_width
221        x = cluster_xy >> (self.y_width);
222        y = cluster_xy & ((1 << self.y_width) - 1)
223
224        assert (base & VPN_ANTI_MASK) == 0
225
226        assert (x < self.x_size) and (y < self.y_size)
227
228        assert ( (base & ((1<<paddr_lsb_width)-1)) == self.ram_base )
229
230        assert ( size == self.ram_size )
231
232        cluster_id = (x * self.y_size) + y
233
234        # add one pseg in the mapping
235        pseg = Pseg( name, base, size, x, y, 'RAM' )
236        self.clusters[cluster_id].psegs.append( pseg )
237        pseg.index = self.total_psegs
238        self.total_psegs += 1
239
240        return pseg
241
242    ##############################   add a peripheral and the associated pseg in a cluster
243    def addPeriph( self,
244                   name,               # associated pseg name
245                   base,               # associated pseg base address
246                   size,               # associated pseg length (bytes)
247                   ptype,              # peripheral type
248                   subtype  = 'NONE',  # peripheral subtype
249                   channels = 1,       # number of channels
250                   arg      = 0 ):     # optional argument (semantic depends on ptype)
251
252        # check cluster coordinates (obtained from the base address)
253        cluster_xy = base >> (self.paddr_width - self.x_width - self.y_width)
254        x = cluster_xy >> (self.y_width);
255        y = cluster_xy & ((1 << self.y_width) - 1)
256
257        assert (x < self.x_size) and (y < self.y_size)
258
259        assert (base & VPN_ANTI_MASK) == 0
260
261        assert ptype in PERIPHTYPES
262
263        assert subtype in PERIPHSUBTYPES
264
265        cluster_id = (x * self.y_size) + y
266
267        # add one pseg into mapping
268        pseg = Pseg( name, base, size, x, y, 'PERI' )
269        self.clusters[cluster_id].psegs.append( pseg )
270        pseg.index = self.total_psegs
271        self.total_psegs += 1
272
273        # add one periph into mapping
274        periph = Periph( pseg, ptype, subtype, channels, arg )
275        self.clusters[cluster_id].periphs.append( periph )
276        periph.index = self.total_periphs
277        self.total_periphs += 1
278
279        return periph
280
281    ################################   add an IRQ in a peripheral
282    def addIrq( self,
283                periph,                # peripheral containing IRQ (PIC or XCU)
284                index,                 # peripheral input port index
285                isrtype,               # ISR type
286                channel = 0 ):         # channel for multi-channels ISR
287
288        assert isrtype in ISRTYPES
289
290        assert index < 32
291
292        # add one irq into mapping
293        irq = Irq( 'HWI', index , isrtype, channel )
294        periph.irqs.append( irq )
295        irq.index = self.total_irqs
296        self.total_irqs += 1
297
298        return irq
299
300    ##########################    add a processor in a cluster
301    def addProc( self,
302                 x,                    # cluster x coordinate
303                 y,                    # cluster y coordinate
304                 p ):                  # processor local index
305
306        assert (x < self.x_size) and (y < self.y_size)
307
308        cluster_id = (x * self.y_size) + y
309
310        # add one proc into mapping
311        proc = Processor( x, y, p )
312        self.clusters[cluster_id].procs.append( proc )
313        proc.index = self.total_procs
314        self.total_procs += 1
315
316        return proc
317
318    ##############################    add a coprocessor in a cluster
319    def addCoproc( self,
320                   name,               # associated pseg name
321                   base,               # associated pseg base address
322                   size ):             # associated pseg length
323
324        # check cluster coordinates (obtained from the base address)
325        cluster_xy = base >> (self.paddr_width - self.x_width - self.y_width)
326        x = cluster_xy >> (self.y_width);
327        y = cluster_xy & ((1 << self.y_width) - 1)
328
329        assert (x < self.x_size) and (y < self.y_size)
330
331        cluster_id = (x * self.y_size) + y
332
333        # add one pseg into mapping
334        pseg = Pseg( name, base, size, x, y, 'PERI' )
335        self.clusters[cluster_id].psegs.append( pseg )
336        pseg.index = self.total_psegs
337        self.total_psegs += 1
338
339        # add one coproc into mapping
340        periph = Coproc( pseg )
341        self.clusters[cluster_id].coprocs.append( coproc )
342        periph.index = self.total_coprocs
343        self.total_coprocs += 1
344
345        return coproc
346
347    ##################################    add a port in a coprocessor
348    def addPort( self,
349                 coproc,               # coprocessor containing the port
350                 direction,            # direction (TO_COPROC / FROM_COPROC)
351                 vspacename,           # name of vspace using the coproc
352                 mwmrname ):           # name of the vobj defining the MWMR channel
353
354        assert direction in CP_PORT_DIRS
355
356        # add one cpport into mapping
357        port = Cpport( direction, vspacename, mwmrname )
358        coproc.ports.append( port )
359        port.index = self.total_cpports
360        self.total_cpports += 1
361
362        return port
363
364    ############################    add one global vseg into mapping
365    def addGlobal( self, 
366                   name,               # vseg name
367                   vbase,              # virtual base address
368                   size,               # vobj length (bytes)
369                   mode,               # CXWU flags
370                   vtype,              # vobj type
371                   x,                  # destination x coordinate
372                   y,                  # destination y coordinate
373                   pseg,               # destination pseg name
374                   identity = False,   # identity mapping required if true
375                   binpath  = '',      # pathname for binary code if required
376                   align    = 0,       # alignment required
377                   local    = False,   # only mapped in local PTAB if true
378                   big      = False ): # to be mapped in a big physical page
379
380        assert mode in VSEGMODES
381
382        assert vtype in VOBJTYPES
383
384        assert (x < self.x_size) and (y < self.y_size)
385
386        # two global vsegs must not overlap if they have different names
387        for prev in self.globs:
388            prev_vbase = prev.vbase
389            prev_size = prev.vobjs[0].length
390
391            if ( ((prev_vbase + prev_size) > vbase ) and 
392                 ((vbase + size) > prev_vbase) and
393                 (prev.name != name) ):
394                print '[genmap error] in addGlobal() : %s overlap %s' % (name, prev.name)
395                print ' %s : base = %x / size = %x' %( name, vbase, size )
396                print ' %s : base = %x / size = %x' %( prev.name, prev_vbase, prev_size )
397                sys.exit(1)
398
399        # add one vseg into mapping
400        vseg = Vseg( name, vbase, mode, x, y, pseg,
401                     identity = identity, local = local, big = big )
402
403        self.globs.append( vseg )
404        self.total_globals += 1
405        vseg.index = self.total_vsegs
406        self.total_vsegs += 1
407
408        # add one vobj into mapping
409        vobj = Vobj( name, size, vtype, binpath, 0, 0 )
410        vseg.vobjs.append( vobj )
411        vobj.index = self.total_vobjs
412        self.total_vobjs += 1
413
414        return
415
416    ################################    add a vspace into mapping
417    def addVspace( self,
418                   name,                # vspace name
419                   startname ):         # name of vobj containing start_vector
420
421        # add one vspace into mapping
422        vspace = Vspace( name, startname )
423        self.vspaces.append( vspace )
424        vspace.index = self.total_vspaces
425        self.total_vspaces += 1
426
427        return vspace
428
429    #################################   add a private vseg and a vobj in a vspace
430    def addVseg( self,
431                 vspace,                # vspace containing the vseg
432                 name,                  # vseg name
433                 vbase,                 # virtual base address
434                 size,                  # vobj length (bytes)
435                 mode,                  # CXWU flags
436                 vtype,                 # vobj type
437                 x,                     # destination x coordinate
438                 y,                     # destination y coordinate
439                 pseg,                  # destination pseg name
440                 binpath    = '',       # pathname for binary code
441                 align      = 0,        # alignment required
442                 init       = 0,        # initial value
443                 local    = False,      # only mapped in local PTAB if true
444                 big      = False ):    # to be mapped in a big physical page
445
446        assert mode in VSEGMODES
447
448        assert vtype in VOBJTYPES
449
450        assert (x < self.x_size) and (y < self.y_size)
451
452        # add one vseg into mapping
453        vseg = Vseg( name, vbase, mode, x, y, pseg, local = local, big = big )
454        vspace.vsegs.append( vseg )
455        vseg.index = self.total_vsegs
456        self.total_vsegs += 1
457
458        # add one vobj into mapping
459        vobj = Vobj( name, size, vtype, binpath, align, init )
460        vseg.vobjs.append( vobj )
461        vobj.index = self.total_vobjs
462        self.total_vobjs += 1
463
464        return vseg
465
466    ################################    add a vobj in a private vseg
467    def addVobj( self,
468                 vseg,                  # vseg containing vobj
469                 name,                  # vobj name
470                 size,                  # vobj length (bytes)
471                 vtype,                 # vobj type
472                 binpath = '',          # pathname to binary
473                 align   = 0,           # alignment constraint
474                 init    = 0 ):         # initial value
475
476        assert vtype in VOBJTYPES
477
478        # add one vobj into mapping
479        vobj = Vobj( name, size, vtype, binpath, align, init )
480        vseg.vobjs.append( vobj )
481        vobj.index = self.total_vobjs
482        self.total_vobjs += 1
483
484        return vobj
485
486    ################################    add a task in a vspace
487    def addTask( self,
488                 vspace,                # vspace containing task
489                 name,                  # task name
490                 trdid,                 # task index in vspace
491                 x,                     # destination x coordinate
492                 y,                     # destination y coordinate
493                 lpid,                  # destination processor local index
494                 stackname,             # name of vobj containing stack
495                 heapname,              # name of vobj containing heap
496                 startid,               # index in start_vector
497                 usetty = False,        # request a private TTY channel
498                 usenic = False,        # request a private NIC channel
499                 usecma = False,        # request a private CMA channel
500                 usehba = False,        # request a private HBA channel
501                 usetim = False ):      # request a private TIM channel
502
503        assert (x < self.x_size) and (y < self.y_size)
504        assert lpid < self.nprocs
505
506        # add one task into mapping
507        task = Task( name, trdid, x, y, lpid, stackname, heapname, startid,
508                     usetty, usenic, usecma, usehba, usetim )
509        vspace.tasks.append( task )
510        task.index = self.total_tasks
511        self.total_tasks += 1
512
513        return task
514
515    #################################
516    def str2bytes( self, nbytes, s ):    # string => nbytes_packed byte array
517
518        byte_stream = bytearray()
519        length = len( s )
520        if length < (nbytes - 1):
521            for b in s:
522                byte_stream.append( b )
523            for x in xrange(nbytes-length):
524                byte_stream.append( '\0' )
525        else:
526            print '[genmap error] in str2bytes() : string %s too long' % s
527            sys.exit(1)
528
529        return byte_stream
530
531    ###################################
532    def int2bytes( self, nbytes, val ):    # integer => nbytes litle endian byte array
533
534        byte_stream = bytearray()
535        for n in xrange( nbytes ):
536            byte_stream.append( (val >> (n<<3)) & 0xFF )
537
538        return byte_stream
539
540    ####################################################################################
541    def xml( self ):    # compute string for map.xml file generation
542
543        s = '<?xml version="1.0"?>\n\n'
544        s += '<mapping_info signature    = "0x%x"\n' % (self.signature)
545        s += '              name         = "%s"\n'   % (self.name)
546        s += '              x_size       = "%d"\n'   % (self.x_size)
547        s += '              y_size       = "%d"\n'   % (self.y_size)
548        s += '              x_width      = "%d"\n'   % (self.x_width)
549        s += '              y_width      = "%d"\n'   % (self.y_width)
550        s += '              irq_per_proc = "%d"\n'   % (self.irq_per_proc)
551        s += '              use_ramdisk  = "%d"\n'   % (self.use_ramdisk)
552        s += '              x_io         = "%d"\n'   % (self.x_io)
553        s += '              y_io         = "%d" >\n' % (self.y_io)
554        s += '\n'
555
556        s += '    <clusterset>\n'
557        for x in xrange ( self.x_size ):
558            for y in xrange ( self.y_size ):
559                cluster_id = (x * self.y_size) + y
560                s += self.clusters[cluster_id].xml()
561        s += '    </clusterset>\n'
562        s += '\n'
563
564        s += '    <globalset>\n'
565        for vseg in self.globs: s += vseg.xml()
566        s += '    </globalset>\n'
567        s += '\n'
568
569        s += '    <vspaceset>\n'
570        for vspace in self.vspaces: s += vspace.xml()
571        s += '    </vspaceset>\n'
572
573        s += '</mapping_info>\n'
574        return s
575
576    #####################################################################################
577    def cbin( self, verbose ):     # C binary structure for map.bin file generation
578
579        byte_stream = bytearray()
580
581        # header
582        byte_stream += self.int2bytes(4,  self.signature)
583        byte_stream += self.int2bytes(4,  self.x_size)
584        byte_stream += self.int2bytes(4,  self.y_size)
585        byte_stream += self.int2bytes(4,  self.x_width)
586        byte_stream += self.int2bytes(4,  self.y_width)
587        byte_stream += self.int2bytes(4,  self.x_io)
588        byte_stream += self.int2bytes(4,  self.y_io)
589        byte_stream += self.int2bytes(4,  self.irq_per_proc)
590        byte_stream += self.int2bytes(4,  self.use_ramdisk)
591        byte_stream += self.int2bytes(4,  self.total_globals)
592        byte_stream += self.int2bytes(4,  self.total_vspaces)
593        byte_stream += self.int2bytes(4,  self.total_psegs)
594        byte_stream += self.int2bytes(4,  self.total_vsegs)
595        byte_stream += self.int2bytes(4,  self.total_vobjs)
596        byte_stream += self.int2bytes(4,  self.total_tasks)
597        byte_stream += self.int2bytes(4,  self.total_procs)
598        byte_stream += self.int2bytes(4,  self.total_irqs)
599        byte_stream += self.int2bytes(4,  self.total_coprocs)
600        byte_stream += self.int2bytes(4,  self.total_cpports)
601        byte_stream += self.int2bytes(4,  self.total_periphs)
602        byte_stream += self.str2bytes(32, self.name)
603
604        if ( verbose ):
605            print '\n'
606            print 'name          = %s' % self.name
607            print 'signature     = %x' % self.signature
608            print 'x_size        = %d' % self.x_size
609            print 'y_size        = %d' % self.y_size
610            print 'x_width       = %d' % self.x_width
611            print 'y_width       = %d' % self.y_width
612            print 'x_io          = %d' % self.x_io
613            print 'y_io          = %d' % self.y_io
614            print 'irq_per_proc  = %d' % self.irq_per_proc
615            print 'use_ramdisk   = %d' % self.use_ramdisk
616            print 'total_globals = %d' % self.total_globals
617            print 'total_psegs   = %d' % self.total_psegs
618            print 'total_vsegs   = %d' % self.total_vsegs
619            print 'total_vobjs   = %d' % self.total_vobjs
620            print 'total_tasks   = %d' % self.total_tasks
621            print 'total_procs   = %d' % self.total_procs
622            print 'total_irqs    = %d' % self.total_irqs
623            print 'total_coprocs = %d' % self.total_coprocs
624            print 'total_cpports = %d' % self.total_cpports
625            print 'total_periphs = %d' % self.total_periphs
626            print '\n'
627
628        # clusters array
629        index = 0
630        for cluster in self.clusters:
631            byte_stream += cluster.cbin( self, verbose, index )
632            index += 1
633
634        if ( verbose ): print '\n'
635
636        # psegs array
637        index = 0
638        for cluster in self.clusters:
639            for pseg in cluster.psegs:
640                byte_stream += pseg.cbin( self, verbose, index, cluster )
641                index += 1
642
643        if ( verbose ): print '\n'
644
645        # vspaces array
646        index = 0
647        for vspace in self.vspaces:
648            byte_stream += vspace.cbin( self, verbose, index )
649            index += 1
650
651        if ( verbose ): print '\n'
652
653        # vsegs array
654        index = 0
655        for vseg in self.globs:
656            byte_stream += vseg.cbin( self, verbose, index )
657            index += 1
658        for vspace in self.vspaces:
659            for vseg in vspace.vsegs:
660                byte_stream += vseg.cbin( self, verbose, index )
661                index += 1
662
663        if ( verbose ): print '\n'
664
665        # vobjs array
666        index = 0
667        for vseg in self.globs:
668            for vobj in vseg.vobjs:
669                byte_stream += vobj.cbin( self, verbose, index )
670                index += 1
671        for vspace in self.vspaces:
672            for vseg in vspace.vsegs:
673                for vobj in vseg.vobjs:
674                    byte_stream += vobj.cbin( self, verbose, index )
675                    index += 1
676
677        if ( verbose ): print '\n'
678
679        # tasks array
680        index = 0
681        for vspace in self.vspaces:
682            for task in vspace.tasks:
683                byte_stream += task.cbin( self, verbose, index, vspace )
684                index += 1
685
686        if ( verbose ): print '\n'
687
688        # procs array
689        index = 0
690        for cluster in self.clusters:
691            for proc in cluster.procs:
692                byte_stream += proc.cbin( self, verbose, index )
693                index += 1
694
695        if ( verbose ): print '\n'
696
697        # irqs array
698        index = 0
699        for cluster in self.clusters:
700            for periph in cluster.periphs:
701                for irq in periph.irqs:
702                    byte_stream += irq.cbin( self, verbose, index )
703                    index += 1
704
705        if ( verbose ): print '\n'
706
707        # coprocs array
708        index = 0
709        for cluster in self.clusters:
710            for coproc in cluster.coprocs:
711                byte_stream += coproc.cbin( self, verbose, index )
712                index += 1
713
714        if ( verbose ): print '\n'
715
716        # cpports array
717        index = 0
718        for cluster in self.clusters:
719            for coproc in cluster.coprocs:
720                for port in coproc.ports:
721                    byte_stream += port.cbin( self, verbose, index )
722                    index += 1
723
724        if ( verbose ): print '\n'
725
726        # periphs array
727        index = 0
728        for cluster in self.clusters:
729            for periph in cluster.periphs:
730                byte_stream += periph.cbin( self, verbose, index )
731                index += 1
732
733        return byte_stream
734    # end of cbin()
735
736    ##################################################################################
737    def giet_vsegs( self ):      # compute string for giet_vsegs.ld file generation
738                                 # required by giet_vm compilation
739
740        # search the vsegs required for the giet_vsegs.ld
741        boot_code_found      = False
742        boot_data_found      = False
743        kernel_uncdata_found = False
744        kernel_data_found    = False
745        kernel_code_found    = False
746        kernel_init_found    = False
747        for vseg in self.globs:
748
749            if ( vseg.name == 'seg_boot_code' ):
750                boot_code_vbase      = vseg.vbase
751                boot_code_size       = vseg.vobjs[0].length
752                boot_code_found      = True
753
754            if ( vseg.name == 'seg_boot_data' ):
755                boot_data_vbase      = vseg.vbase
756                boot_data_size       = vseg.vobjs[0].length
757                boot_data_found      = True
758
759            if ( vseg.name == 'seg_kernel_uncdata' ):
760                kernel_uncdata_vbase = vseg.vbase
761                kernel_uncdata_size  = vseg.vobjs[0].length
762                kernel_uncdata_found = True
763
764            if ( vseg.name == 'seg_kernel_data' ):
765                kernel_data_vbase    = vseg.vbase
766                kernel_data_size     = vseg.vobjs[0].length
767                kernel_data_found    = True
768
769            if ( vseg.name == 'seg_kernel_code' ):
770                kernel_code_vbase    = vseg.vbase
771                kernel_code_size     = vseg.vobjs[0].length
772                kernel_code_found    = True
773
774            if ( vseg.name == 'seg_kernel_init' ):
775                kernel_init_vbase    = vseg.vbase
776                kernel_init_size     = vseg.vobjs[0].length
777                kernel_init_found    = True
778
779        # check if all required vsegs have been found
780        if ( boot_code_found      == False ):
781             print '[genmap error] in giet_vsegs() : seg_boot_code vseg missing'
782             sys.exit()
783
784        if ( boot_data_found      == False ):
785             print '[genmap error] in giet_vsegs() : seg_boot_data vseg missing'
786             sys.exit()
787
788        if ( kernel_data_found    == False ):
789             print '[genmap error] in giet_vsegs() : seg_kernel_data vseg missing'
790             sys.exit()
791
792        if ( kernel_uncdata_found == False ):
793             print '[genmap error] in giet_vsegs() : seg_kernel_uncdata vseg missing'
794             sys.exit()
795
796        if ( kernel_code_found    == False ):
797             print '[genmap error] in giet_vsegs() : seg_kernel_code vseg missing'
798             sys.exit()
799
800        if ( kernel_init_found    == False ):
801             print '[genmap error] in giet_vsegs() : seg_kernel_init vseg missing'
802             sys.exit()
803
804        # build string
805        s =  '/* Generated by genmap for %s */\n'  % self.name
806        s += '\n'
807
808        s += 'boot_code_vbase      = 0x%x;\n'   % boot_code_vbase
809        s += 'boot_code_size       = 0x%x;\n'   % boot_code_size
810        s += '\n'
811        s += 'boot_data_vbase      = 0x%x;\n'   % boot_data_vbase
812        s += 'boot_data_size       = 0x%x;\n'   % boot_data_size
813        s += '\n'
814        s += 'kernel_code_vbase    = 0x%x;\n'   % kernel_code_vbase
815        s += 'kernel_code_size     = 0x%x;\n'   % kernel_code_size
816        s += '\n'
817        s += 'kernel_data_vbase    = 0x%x;\n'   % kernel_data_vbase
818        s += 'kernel_data_size     = 0x%x;\n'   % kernel_data_size
819        s += '\n'
820        s += 'kernel_uncdata_vbase = 0x%x;\n'   % kernel_uncdata_vbase
821        s += 'kernel_uncdata_size  = 0x%x;\n'   % kernel_uncdata_size
822        s += '\n'
823        s += 'kernel_init_vbase    = 0x%x;\n'   % kernel_init_vbase
824        s += 'kernel_init_size     = 0x%x;\n'   % kernel_init_size
825        s += '\n'
826
827        return s
828
829    ###################################################################################
830    def hard_config( self ):     # compute string for hard_config.h file generation,
831                                 # required by
832                                 # - top.cpp compilation
833                                 # - giet_vm compilation
834                                 # - tsar_preloader compilation
835
836        nb_total_procs = 0
837
838        # for each peripheral type, define default values
839        # for pbase address, size, number of components, and channels
840        nb_cma       = 0
841        cma_channels = 0
842        seg_cma_base = 0xFFFFFFFF
843        seg_cma_size = 0
844
845        nb_dma       = 0
846        dma_channels = 0
847        seg_dma_base = 0xFFFFFFFF
848        seg_dma_size = 0
849
850        nb_fbf       = 0
851        fbf_channels = 0
852        fbf_arg      = 0
853        seg_fbf_base = 0xFFFFFFFF
854        seg_fbf_size = 0
855
856        nb_icu       = 0
857        icu_channels = 0
858        seg_icu_base = 0xFFFFFFFF
859        seg_icu_size = 0
860
861        nb_iob       = 0
862        iob_channels = 0
863        seg_iob_base = 0xFFFFFFFF
864        seg_iob_size = 0
865
866        nb_ioc       = 0
867        ioc_channels = 0
868        seg_ioc_base = 0xFFFFFFFF
869        seg_ioc_size = 0
870
871        nb_mmc       = 0
872        mmc_channels = 0
873        seg_mmc_base = 0xFFFFFFFF
874        seg_mmc_size = 0
875
876        nb_mwr       = 0
877        mwr_channels = 0
878        seg_mwr_base = 0xFFFFFFFF
879        seg_mwr_size = 0
880
881        nb_nic       = 0
882        nic_channels = 0
883        seg_nic_base = 0xFFFFFFFF
884        seg_nic_size = 0
885
886        nb_pic       = 0
887        pic_channels = 0
888        seg_pic_base = 0xFFFFFFFF
889        seg_pic_size = 0
890
891        nb_rom       = 0
892        rom_channels = 0
893        seg_rom_base = 0xFFFFFFFF
894        seg_rom_size = 0
895
896        nb_sim       = 0
897        sim_channels = 0
898        seg_sim_base = 0xFFFFFFFF
899        seg_sim_size = 0
900
901        nb_tim       = 0
902        tim_channels = 0
903        seg_tim_base = 0xFFFFFFFF
904        seg_tim_size = 0
905
906        nb_tty       = 0
907        tty_channels = 0
908        seg_tty_base = 0xFFFFFFFF
909        seg_tty_size = 0
910
911        nb_xcu       = 0
912        xcu_channels = 0
913        xcu_arg      = 0
914        seg_xcu_base = 0xFFFFFFFF
915        seg_xcu_size = 0
916
917        use_bdv = False
918        use_spi = False
919        use_hba = False
920
921        # get peripherals attributes
922        for cluster in self.clusters:
923            for periph in cluster.periphs:
924                if   ( periph.ptype == 'CMA' ):
925                    seg_cma_base = periph.pseg.base & 0xFFFFFFFF
926                    seg_cma_size = periph.pseg.size
927                    cma_channels = periph.channels
928                    nb_cma +=1
929
930                elif ( periph.ptype == 'DMA' ):
931                    seg_dma_base = periph.pseg.base & 0xFFFFFFFF
932                    seg_dma_size = periph.pseg.size
933                    dma_channels = periph.channels
934                    nb_dma +=1
935
936                elif ( periph.ptype == 'FBF' ):
937                    seg_fbf_base = periph.pseg.base & 0xFFFFFFFF
938                    seg_fbf_size = periph.pseg.size
939                    fbf_channels = periph.channels
940                    fbf_arg      = periph.arg
941                    nb_fbf +=1
942
943                elif ( periph.ptype == 'ICU' ):
944                    seg_icu_base = periph.pseg.base & 0xFFFFFFFF
945                    seg_icu_size = periph.pseg.size
946                    icu_channels = periph.channels
947                    nb_icu +=1
948
949                elif ( periph.ptype == 'IOB' ):
950                    seg_iob_base = periph.pseg.base & 0xFFFFFFFF
951                    seg_iob_size = periph.pseg.size
952                    iob_channels = periph.channels
953                    nb_iob +=1
954
955                elif ( periph.ptype == 'IOC' ):
956                    seg_ioc_base = periph.pseg.base & 0xFFFFFFFF
957                    seg_ioc_size = periph.pseg.size
958                    ioc_channels = periph.channels
959                    nb_ioc += 1
960
961                    if self.use_ramdisk: continue
962
963                    if   ( periph.subtype == 'BDV' ): use_bdv = True
964                    elif ( periph.subtype == 'HBA' ): use_hba = True
965                    elif ( periph.subtype == 'SPI' ): use_spi = True
966
967                elif ( periph.ptype == 'MMC' ):
968                    seg_mmc_base = periph.pseg.base & 0xFFFFFFFF
969                    seg_mmc_size = periph.pseg.size
970                    mmc_channels = periph.channels
971                    nb_mmc +=1
972
973                elif ( periph.ptype == 'MWR' ):
974                    seg_mwr_base = periph.pseg.base & 0xFFFFFFFF
975                    seg_wmr_size = periph.pseg.size
976                    mwr_channels = periph.channels
977                    nb_mwr +=1
978
979                elif ( periph.ptype == 'ROM' ):
980                    seg_rom_base = periph.pseg.base & 0xFFFFFFFF
981                    seg_rom_size = periph.pseg.size
982                    rom_channels = periph.channels
983                    nb_rom +=1
984
985                elif ( periph.ptype == 'SIM' ):
986                    seg_sim_base = periph.pseg.base & 0xFFFFFFFF
987                    seg_sim_size = periph.pseg.size
988                    sim_channels = periph.channels
989                    nb_sim +=1
990
991                elif ( periph.ptype == 'NIC' ):
992                    seg_nic_base = periph.pseg.base & 0xFFFFFFFF
993                    seg_nic_size = periph.pseg.size
994                    nic_channels = periph.channels
995                    nb_nic +=1
996
997                elif ( periph.ptype == 'PIC' ):
998                    seg_pic_base = periph.pseg.base & 0xFFFFFFFF
999                    seg_pic_size = periph.pseg.size
1000                    pic_channels = periph.channels
1001                    nb_pic +=1
1002
1003                elif ( periph.ptype == 'TIM' ):
1004                    seg_tim_base = periph.pseg.base & 0xFFFFFFFF
1005                    seg_tim_size = periph.pseg.size
1006                    tim_channels = periph.channels
1007                    nb_tim +=1
1008
1009                elif ( periph.ptype == 'TTY' ):
1010                    seg_tty_base = periph.pseg.base & 0xFFFFFFFF
1011                    seg_tty_size = periph.pseg.size
1012                    tty_channels = periph.channels
1013                    nb_tty +=1
1014
1015                elif ( periph.ptype == 'XCU' ):
1016                    seg_xcu_base = periph.pseg.base & 0xFFFFFFFF
1017                    seg_xcu_size = periph.pseg.size
1018                    xcu_channels = periph.channels
1019                    xcu_arg      = periph.arg
1020                    nb_xcu +=1
1021
1022        # don't mix ICU and XCU
1023        assert ( nb_icu*nb_xcu == 0 )
1024
1025        # no more than two access to external peripherals
1026        assert ( nb_fbf <= 2 )
1027        assert ( nb_cma <= 2 )
1028        assert ( nb_ioc <= 2 )
1029        assert ( nb_nic <= 2 )
1030        assert ( nb_tim <= 2 )
1031        assert ( nb_tty <= 2 )
1032        assert ( nb_pic <= 2 )
1033
1034        # one and only one type of IOC controller
1035        nb_iocs = 0
1036        if use_hba         : nb_iocs += 1
1037        if use_bdv         : nb_iocs += 1
1038        if use_spi         : nb_iocs += 1
1039        if self.use_ramdisk: nb_iocs += 1
1040        assert ( nb_iocs == 1 )
1041
1042        # Compute total number of processors
1043        for cluster in self.clusters:
1044            nb_total_procs += len( cluster.procs )
1045
1046        # Compute physical addresses for BOOT vsegs
1047        boot_mapping_found   = False
1048        boot_code_found      = False
1049        boot_data_found      = False
1050        boot_stack_found     = False
1051
1052        for vseg in self.globs:
1053            if ( vseg.name == 'seg_boot_mapping' ):
1054                boot_mapping_base       = vseg.vbase
1055                boot_mapping_size       = vseg.vobjs[0].length
1056                boot_mapping_identity   = vseg.identity
1057                boot_mapping_found      = True
1058
1059            if ( vseg.name == 'seg_boot_code' ):
1060                boot_code_base          = vseg.vbase
1061                boot_code_size          = vseg.vobjs[0].length
1062                boot_code_identity      = vseg.identity
1063                boot_code_found         = True
1064
1065            if ( vseg.name == 'seg_boot_data' ):
1066                boot_data_base          = vseg.vbase
1067                boot_data_size          = vseg.vobjs[0].length
1068                boot_data_identity      = vseg.identity
1069                boot_data_found         = True
1070
1071            if ( vseg.name == 'seg_boot_stack' ):
1072                boot_stack_base         = vseg.vbase
1073                boot_stack_size         = vseg.vobjs[0].length
1074                boot_stack_identity     = vseg.identity
1075                boot_stack_found        = True
1076
1077        # check that BOOT vsegs are found and identity mapping
1078        if ( (boot_mapping_found == False) or (boot_mapping_identity == False) ):
1079             print '[genmap error] in hard_config() : seg_boot_mapping missing or not ident'
1080             sys.exit()
1081
1082        if ( (boot_code_found == False) or (boot_code_identity == False) ):
1083             print '[genmap error] in hard_config() : seg_boot_code missing or not ident'
1084             sys.exit()
1085
1086        if ( (boot_data_found == False) or (boot_data_identity == False) ):
1087             print '[genmap error] in hard_config() : seg_boot_data missing or not ident'
1088             sys.exit()
1089
1090        if ( (boot_stack_found == False) or (boot_stack_identity == False) ):
1091             print '[genmap error] in giet_vsegs() : seg_boot_stack missing or not ident'
1092             sys.exit()
1093
1094        # Search RAMDISK global vseg if required
1095        seg_rdk_base =  0xFFFFFFFF
1096        seg_rdk_size =  0
1097        seg_rdk_found = False
1098
1099        if self.use_ramdisk:
1100            for vseg in self.globs:
1101                if ( vseg.name == 'seg_rdk' ):
1102                    seg_rdk_base  = vseg.vbase
1103                    seg_rdk_size  = vseg.vobjs[0].length
1104                    seg_rdk_found = True
1105
1106            if ( seg_rdk_found == False ):
1107                print 'Error in hard_config() "seg_ramdisk" not found'
1108                sys.exit(1)
1109
1110        # build string
1111        s =  '/* Generated by genmap for %s */\n'  % self.name
1112        s += '\n'
1113        s += '#ifndef HARD_CONFIG_H\n'
1114        s += '#define HARD_CONFIG_H\n'
1115        s += '\n'
1116
1117        s += '/* General platform parameters */\n'
1118        s += '\n'
1119        s += '#define X_SIZE                 %d\n'    % self.x_size
1120        s += '#define Y_SIZE                 %d\n'    % self.y_size
1121        s += '#define X_WIDTH                %d\n'    % self.x_width
1122        s += '#define Y_WIDTH                %d\n'    % self.y_width
1123        s += '#define P_WIDTH                %d\n'    % self.p_width
1124        s += '#define X_IO                   %d\n'    % self.x_io
1125        s += '#define Y_IO                   %d\n'    % self.y_io
1126        s += '#define NB_PROCS_MAX           %d\n'    % self.nprocs
1127        s += '#define IRQ_PER_PROCESSOR      %d\n'    % self.irq_per_proc
1128        s += '#define RESET_ADDRESS          0x%x\n'  % self.reset_address
1129        s += '#define NB_TOTAL_PROCS         %d\n'    % nb_total_procs
1130        s += '\n'
1131
1132        s += '/* Peripherals */\n'
1133        s += '\n'
1134        s += '#define NB_TTY_CHANNELS        %d\n'    % tty_channels
1135        s += '#define NB_IOC_CHANNELS        %d\n'    % ioc_channels
1136        s += '#define NB_NIC_CHANNELS        %d\n'    % nic_channels
1137        s += '#define NB_CMA_CHANNELS        %d\n'    % cma_channels
1138        s += '#define NB_TIM_CHANNELS        %d\n'    % tim_channels
1139        s += '#define NB_DMA_CHANNELS        %d\n'    % dma_channels
1140        s += '\n'
1141        s += '#define USE_XCU                %d\n'    % ( nb_xcu != 0 )
1142        s += '#define USE_IOB                %d\n'    % ( nb_iob != 0 )
1143        s += '#define USE_PIC                %d\n'    % ( nb_pic != 0 )
1144        s += '#define USE_FBF                %d\n'    % ( nb_fbf != 0 )
1145        s += '\n'
1146        s += '#define USE_IOC_BDV            %d\n'    % use_bdv
1147        s += '#define USE_IOC_SPI            %d\n'    % use_spi
1148        s += '#define USE_IOC_HBA            %d\n'    % use_hba
1149        s += '#define USE_IOC_RDK            %d\n'    % self.use_ramdisk
1150        s += '\n'
1151        s += '#define FBUF_X_SIZE            %d\n'    % fbf_arg
1152        s += '#define FBUF_Y_SIZE            %d\n'    % fbf_arg
1153        s += '\n'
1154        s += '#define XCU_NB_INPUTS          %d\n'    % xcu_arg
1155        s += '\n'
1156
1157        s += '/* base addresses and sizes for physical segments */\n'
1158        s += '\n'
1159        s += '#define SEG_RAM_BASE           0x%x\n'  % self.ram_base
1160        s += '#define SEG_RAM_SIZE           0x%x\n'  % self.ram_size
1161        s += '\n'
1162        s += '#define SEG_CMA_BASE           0x%x\n'  % seg_cma_base
1163        s += '#define SEG_CMA_SIZE           0x%x\n'  % seg_cma_size
1164        s += '\n'
1165        s += '#define SEG_DMA_BASE           0x%x\n'  % seg_dma_base
1166        s += '#define SEG_DMA_SIZE           0x%x\n'  % seg_dma_size
1167        s += '\n'
1168        s += '#define SEG_FBF_BASE           0x%x\n'  % seg_fbf_base
1169        s += '#define SEG_FBF_SIZE           0x%x\n'  % seg_fbf_size
1170        s += '\n'
1171        s += '#define SEG_ICU_BASE           0x%x\n'  % seg_icu_base
1172        s += '#define SEG_ICU_SIZE           0x%x\n'  % seg_icu_size
1173        s += '\n'
1174        s += '#define SEG_IOB_BASE           0x%x\n'  % seg_iob_base
1175        s += '#define SEG_IOB_SIZE           0x%x\n'  % seg_iob_size
1176        s += '\n'
1177        s += '#define SEG_IOC_BASE           0x%x\n'  % seg_ioc_base
1178        s += '#define SEG_IOC_SIZE           0x%x\n'  % seg_ioc_size
1179        s += '\n'
1180        s += '#define SEG_MMC_BASE           0x%x\n'  % seg_mmc_base
1181        s += '#define SEG_MMC_SIZE           0x%x\n'  % seg_mmc_size
1182        s += '\n'
1183        s += '#define SEG_MWR_BASE           0x%x\n'  % seg_mwr_base
1184        s += '#define SEG_MWR_SIZE           0x%x\n'  % seg_mwr_size
1185        s += '\n'
1186        s += '#define SEG_ROM_BASE           0x%x\n'  % seg_rom_base
1187        s += '#define SEG_ROM_SIZE           0x%x\n'  % seg_rom_size
1188        s += '\n'
1189        s += '#define SEG_SIM_BASE           0x%x\n'  % seg_sim_base
1190        s += '#define SEG_SIM_SIZE           0x%x\n'  % seg_sim_size
1191        s += '\n'
1192        s += '#define SEG_NIC_BASE           0x%x\n'  % seg_nic_base
1193        s += '#define SEG_NIC_SIZE           0x%x\n'  % seg_nic_size
1194        s += '\n'
1195        s += '#define SEG_PIC_BASE           0x%x\n'  % seg_pic_base
1196        s += '#define SEG_PIC_SIZE           0x%x\n'  % seg_pic_size
1197        s += '\n'
1198        s += '#define SEG_TIM_BASE           0x%x\n'  % seg_tim_base
1199        s += '#define SEG_TIM_SIZE           0x%x\n'  % seg_tim_size
1200        s += '\n'
1201        s += '#define SEG_TTY_BASE           0x%x\n'  % seg_tty_base
1202        s += '#define SEG_TTY_SIZE           0x%x\n'  % seg_tty_size
1203        s += '\n'
1204        s += '#define SEG_XCU_BASE           0x%x\n'  % seg_xcu_base
1205        s += '#define SEG_XCU_SIZE           0x%x\n'  % seg_xcu_size
1206        s += '\n'
1207        s += '#define SEG_RDK_BASE           0x%x\n'  % seg_rdk_base
1208        s += '#define SEG_RDK_SIZE           0x%x\n'  % seg_rdk_size
1209        s += '\n'
1210        s += '#define PERI_CLUSTER_INCREMENT 0x%x\n'  % self.peri_increment
1211        s += '\n'
1212
1213        s += '/* physical base addresses for identity mapped vsegs */\n'
1214        s += '/* used by the GietVM OS                             */\n'
1215        s += '\n'
1216        s += '#define SEG_BOOT_MAPPING_BASE  0x%x\n'  % boot_mapping_base
1217        s += '#define SEG_BOOT_MAPPING_SIZE  0x%x\n'  % boot_mapping_size
1218        s += '\n'
1219        s += '#define SEG_BOOT_CODE_BASE     0x%x\n'  % boot_code_base
1220        s += '#define SEG_BOOT_CODE_SIZE     0x%x\n'  % boot_code_size
1221        s += '\n'
1222        s += '#define SEG_BOOT_DATA_BASE     0x%x\n'  % boot_data_base
1223        s += '#define SEG_BOOT_DATA_SIZE     0x%x\n'  % boot_data_size
1224        s += '\n'
1225        s += '#define SEG_BOOT_STACK_BASE    0x%x\n'  % boot_stack_base
1226        s += '#define SEG_BOOT_STACK_SIZE    0x%x\n'  % boot_stack_size
1227        s += '#endif\n'
1228
1229        return s
1230
1231    # end of hard_config()
1232
1233    ################################################################################
1234    def linux_dts( self ):     # compute string for linux.dts file generation
1235                               # used for linux configuration
1236        # header
1237        s =  '/dts-v1/;\n'
1238        s += '\n'
1239        s += '/{\n'
1240        s += '  compatible = "tsar,%s";\n' % self.name
1241        s += '  #address-cells = <2>;\n'               # physical address on 64 bits
1242        s += '  #size-cells    = <1>;\n'               # segment size on 32 bits
1243        s += '  model = "%s";\n' % self.name
1244        s += '\n'
1245
1246        # linux globals arguments
1247        s += '  chosen {\n'
1248        s += '    linux,stdout-path = &tty;\n'
1249        s += '    bootargs = "console=tty0 console=ttyVTTY0 earlyprintk";\n'
1250        s += '  };\n\n'
1251
1252        # cpus (for each cluster)
1253        s += '  cpus {\n'
1254        s += '    #address-cells = <1>;\n'
1255        s += '    #size-cells    = <0>;\n'
1256
1257        for cluster in self.clusters:
1258            for proc in cluster.procs:
1259                x       = cluster.x
1260                y       = cluster.y
1261                l       = proc.lpid
1262                proc_id = (((x << self.y_width) + y) << self.p_width) + l
1263                s += '    cpu@%d_%d_%d {\n' %(x,y,l)
1264                s += '      device_type = "cpu";\n'
1265                s += '      compatible = "soclib,mips32el";\n'
1266                s += '      reg = <0x%x>;\n' % proc_id
1267                s += '    };\n'
1268                s += '\n'
1269
1270        s += '  };\n\n'
1271
1272        # devices (ram or peripheral) are grouped per cluster
1273        # the "compatible" attribute links a peripheral device
1274        # to one or several drivers identified by ("major","minor")
1275
1276        for cluster in self.clusters:
1277            x               = cluster.x
1278            y               = cluster.y
1279            found_xcu       = False
1280            found_pic       = False
1281
1282            s += '  /*** cluster[%d,%d] ***/\n\n' % (x,y)
1283
1284            # scan all psegs to find RAM in current cluster
1285            for pseg in cluster.psegs:
1286                if ( pseg.segtype == 'RAM' ):
1287                    msb  = pseg.base >> 32
1288                    lsb  = pseg.base & 0xFFFFFFFF
1289                    size = pseg.size
1290
1291                    s += '  ram_%d_%d: ram@0x%x {\n' % (x, y, pseg.base)
1292                    s += '    device_type = "memory";\n'
1293                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1294                    s += '  };\n\n'
1295
1296            # scan all periphs to find XCU or PIC in current cluster
1297            for periph in cluster.periphs:
1298                msb     = periph.pseg.base >> 32
1299                lsb     = periph.pseg.base & 0xFFFFFFFF
1300                size    = periph.pseg.size
1301
1302                # search XCU (can be replicated)
1303                if ( (periph.ptype == 'XCU') ):
1304                    found_xcu     = True
1305                    xcu           = periph
1306                    irq_ctrl_name = 'xcu_%d_%d' % (x, y)
1307
1308                    s += %s: xcu@0x%x {\n'  % (irq_ctrl_name, periph.pseg.base)
1309                    s += '    compatible = "soclib,vci_xicu","soclib,vci_xicu_timer";\n'
1310                    s += '    interrupt-controller;\n'
1311                    s += '    #interrupt-cells = <1>;\n'
1312                    s += '    clocks = <&freq>;\n'         # the XCU component contains a timer
1313                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1314                    s += '  };\n\n'
1315
1316                # search PIC (non replicated)
1317                if ( periph.ptype == 'PIC' ):
1318                    found_pic     = True
1319                    pic           = periph
1320                    irq_ctrl_name = 'pic'
1321
1322                    s += %s: pic@0x%x {\n'  % (irq_ctrl_name, periph.pseg.base)
1323                    s += '    compatible = "soclib,vci_iopic";\n'
1324                    s += '    interrupt-controller;\n'
1325                    s += '    #interrupt-cells = <1>;\n'
1326                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1327                    s += '  };\n\n'
1328
1329                # search ICU (non supported by Linux)
1330                if ( periph.ptype == 'ICU' ):
1331                    print '[genmap warning] in linux_dts() : ICU peripheral not supported by LINUX'
1332
1333            # we need one interrupt controler in any cluster containing peripherals
1334            if ( (found_xcu == False) and (found_pic == False) and (len(cluster.periphs) > 0) ):
1335                print '[genmap error] in linux_dts() : No XCU/PIC in cluster(%d,%d)' % (x,y)
1336                sys.exit(1)
1337
1338            if ( found_pic == True ): irq_ctrl = pic
1339            else:                     irq_ctrl = xcu
1340
1341            # scan all periphs to find TTY and IOC in current cluster
1342            for periph in cluster.periphs:
1343                msb     = periph.pseg.base >> 32
1344                lsb     = periph.pseg.base & 0xFFFFFFFF
1345                size    = periph.pseg.size
1346
1347                # search TTY (non replicated)
1348                if ( periph.ptype == 'TTY' ):
1349
1350                    # get HWI index to XCU or PIC (only TTY channel 0 is used by Linux)
1351                    hwi_id = 0xFFFFFFFF
1352                    for irq in irq_ctrl.irqs:
1353                        if ( (irq.isrtype == 'ISR_TTY_RX') and (irq.channel == 0) ): hwi_id = irq.srcid
1354                    if ( hwi_id == 0xFFFFFFFF ):
1355                        print '[genmap error] in linux.dts() IRQ_TTY_RX not found'
1356                        sys.exit(1)
1357
1358                    s += '  tty: tty {\n'
1359                    s += '    compatible = "soclib,vci_multi_tty";\n'
1360                    s += '    interrupt-parent = <&%s>;\n' % (irq_ctrl_name)
1361                    s += '    interrupts = <%d>;\n' % hwi_id
1362                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1363                    s += '  };\n\n'
1364
1365                # search IOC (non replicated)
1366                elif ( periph.ptype == 'IOC' ):
1367
1368                    if ( periph.subtype == 'BDV' ):
1369
1370                        # get irq line index associated to bdv
1371                        hwi_id = 0xFFFFFFFF
1372                        for irq in irq_ctrl.irqs:
1373                            if ( irq.isrtype == 'ISR_BDV' ): hwi_id = irq.srcid
1374                        if ( hwi_id == 0xFFFFFFFF ):
1375                            print '[genmap error] in linux.dts() ISR_BDV not found'
1376                            sys.exit(1)
1377
1378                        s += '  bdv: bdv {\n'
1379                        s += '    compatible = "soclib,vci_blockdevice";\n'
1380                        s += '    interrupt-parent = <&%s>;\n' % (irq_ctrl_name)
1381                        s += '    interrupts = <%d>;\n' % hwi_id
1382                        s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1383                        s += '  };\n\n'
1384
1385                    elif ( periph.subtype == 'HBA' ):
1386
1387                        print '[genmap error] in linux_dts() : HBA peripheral not supported by LINUX'
1388                        sys.exit(1)
1389
1390                    elif ( periph.subtype == 'SPI' ):
1391
1392                        print '[genmap error] in linux_dts() : SPI peripheral not supported by LINUX'
1393                        sys.exit(1)
1394
1395                # other peripherals
1396                else:
1397                    type = periph.ptype
1398                    print '[genmap warning] in linux_dts() : %s peripheral not supported by LINUX' % (type)
1399
1400        # clocks
1401        s += '  /*** clocks ***/\n\n'
1402        s += '  clocks {\n'
1403        s += '    freq: freq@50MHZ {\n'
1404        s += '      #clock-cells = <0>;\n'
1405        s += '      compatible = "fixed-clock";\n'
1406        s += '      clock-frequency = <50000000>;\n'
1407        s += '    };\n'
1408        s += '  };\n\n'
1409        s += '  cpuclk {\n'
1410        s += '    compatible = "soclib,mips32_clksrc";\n'
1411        s += '    clocks = <&freq>;\n'
1412        s += '  };\n'
1413        s += '};\n'
1414
1415        return s
1416        # end linux_dts()
1417
1418
1419    #############################################################################
1420    def netbsd_dts( self ):    # compute string for netbsd.dts file generation,
1421                               # used for netbsd configuration
1422        # header
1423        s =  '/dts-v1/;\n'
1424        s += '\n'
1425        s += '/{\n'
1426        s += '  #address-cells = <2>;\n'
1427        s += '  #size-cells    = <1>;\n'
1428
1429        # cpus (for each cluster)
1430        s += '  cpus {\n'
1431        s += '    #address-cells = <1>;\n'
1432        s += '    #size-cells    = <0>;\n'
1433
1434        for cluster in self.clusters:
1435            for proc in cluster.procs:
1436                proc_id = (((cluster.x << self.y_width) + cluster.y) << self.p_width) + proc.lpid
1437
1438                s += '    Mips,32@0x%x {\n'                % proc_id
1439                s += '      device_type = "cpu";\n'
1440                s += '      icudev_type = "cpu:mips";\n'
1441                s += '      name        = "Mips,32";\n'
1442                s += '      reg         = <0x%x>;\n'     % proc_id
1443                s += '    };\n'
1444                s += '\n'
1445
1446        s += '  };\n'
1447
1448        # physical memory banks (for each cluster)
1449        for cluster in self.clusters:
1450            for pseg in cluster.psegs:
1451
1452                if ( pseg.segtype == 'RAM' ):
1453                    msb  = pseg.base >> 32
1454                    lsb  = pseg.base & 0xFFFFFFFF
1455                    size = pseg.size
1456
1457                    s += %s@0x%x {\n' % (pseg.name, pseg.base)
1458                    s += '    cached      = <1>;\n'
1459                    s += '    device_type = "memory";\n'
1460                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1461                    s += '  };\n'
1462
1463        # peripherals (for each cluster)
1464        for cluster in self.clusters:
1465            x = cluster.x
1466            y = cluster.y
1467
1468            # research XCU component
1469            found_xcu = False
1470            for periph in cluster.periphs:
1471                if ( (periph.ptype == 'XCU') ):
1472                    found_xcu = True
1473                    xcu = periph
1474                    msb  = periph.pseg.base >> 32
1475                    lsb  = periph.pseg.base & 0xFFFFFFFF
1476                    size = periph.pseg.size
1477
1478                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1479                    s += '    device_type = "soclib:xicu:root";\n'
1480                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1481                    s += '    input_lines = <%d>;\n'    % periph.arg
1482                    s += '    ipis        = <%d>;\n'    % periph.arg
1483                    s += '    timers      = <%d>;\n'    % periph.arg
1484
1485                    output_id = 0            # output index from XCU
1486                    for lpid in xrange ( len(cluster.procs) ):        # destination processor index
1487                        for itid in xrange ( self.irq_per_proc ):     # input irq index on processor
1488                            cluster_xy = (cluster.x << self.y_width) + cluster.y
1489                            proc_id    = (cluster_xy << self.p_width) + lpid
1490                            s += '    out@%d {\n' % output_id
1491                            s += '      device_type = "soclib:xicu:filter";\n'
1492                            s += '      irq = <&{/cpus/Mips,32@0x%x} %d>;\n' % (proc_id, itid)
1493                            s += '      output_line = <%d>;\n' % output_id
1494                            s += '      parent = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1495                            s += '    };\n'
1496
1497                            output_id += 1
1498
1499                    s += '  };\n'
1500
1501            # research PIC component
1502            found_pic = False
1503            for periph in cluster.periphs:
1504                if ( periph.ptype == 'PIC' ):
1505                    found_pic = True
1506                    pic  = periph
1507                    msb  = periph.pseg.base >> 32
1508                    lsb  = periph.pseg.base & 0xFFFFFFFF
1509                    size = periph.pseg.size
1510
1511                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1512                    s += '    device_type = "soclib:pic:root";\n'
1513                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1514                    s += '    input_lines = <%d>;\n'    % periph.channels
1515                    s += '  };\n'
1516
1517            # at least one interrupt controller
1518            if ( (found_xcu == False) and (found_pic == False) and (len(cluster.periphs) > 0) ):
1519                print '[genmap error] in netbsd_dts() : No XCU/PIC in cluster(%d,%d)' % (x,y)
1520                sys.exit(1)
1521
1522            if ( found_pic == True ):  irq_tgt = pic
1523            else:                      irq_tgt = xcu
1524
1525            # get all others peripherals in cluster
1526            for periph in cluster.periphs:
1527                msb  = periph.pseg.base >> 32
1528                lsb  = periph.pseg.base & 0xFFFFFFFF
1529                size = periph.pseg.size
1530
1531                # research DMA component
1532                if ( periph.ptype == 'DMA' ):
1533
1534                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1535                    s += '    device_type = "soclib:dma";\n'
1536                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1537                    s += '    channel_count = <%d>;\n' % periph.channels
1538
1539                    # multi-channels : get HWI index (to XCU) for each channel
1540                    for channel in xrange( periph.channels ):
1541                        hwi_id = 0xFFFFFFFF
1542                        for irq in xcu.irqs:
1543                            if ( (irq.isrtype == 'ISR_DMA') and (irq.channel == channel) ):
1544                                hwi_id = irq.srcid
1545                        if ( hwi_id == 0xFFFFFFFF ):
1546                            print '[genmap error] in netbsd.dts() ISR_DMA channel %d not found' % channel
1547                            sys.exit(1)
1548
1549                        name = '%s@0x%x' % (xcu.pseg.name, xcu.pseg.base)
1550                        s += '    irq@%d{\n' % channel
1551                        s += '      device_type = "soclib:periph:irq";\n'
1552                        s += '      output_line = <%d>;\n' % channel
1553                        s += '      irq = <&{/%s%d>;\n' % (name, hwi_id)
1554                        s += '      parent = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1555                        s += '    };\n'
1556
1557                    s += '  };\n'
1558
1559                # research MMC component
1560                elif ( periph.ptype == 'MMC' ):
1561
1562                    # get irq line index associated to MMC in XCU
1563                    irq_in = 0xFFFFFFFF
1564                    for irq in xcu.irqs:
1565                        if ( irq.isrtype == 'ISR_MMC' ): irq_in = irq.srcid
1566                    if ( irq_in == 0xFFFFFFFF ):
1567                        print '[genmap error] in netbsd.dts() ISR_MMC not found'
1568                        sys.exit(1)
1569
1570                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1571                    s += '    device_type = "soclib:mmc";\n'
1572                    s += '    irq = <&{/%s@0x%x%d>;\n' % (irq_tgt.pseg.name, irq_tgt.pseg.base, irq_in)
1573                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1574                    s += '  };\n'
1575
1576                # research FBF component
1577                elif ( periph.ptype == 'FBF' ):
1578
1579                    s += %s@0x%x {\n' % (periph.pseg.name, periph.pseg.base)
1580                    s += '    device_type = "soclib:framebuffer";\n'
1581                    s += '    mode        = <32>;\n'                    # bits par pixel
1582                    s += '    width       = <%d>;\n'    % periph.arg
1583                    s += '    height      = <%d>;\n'    % periph.arg
1584                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1585                    s += '  };\n'
1586
1587                # research IOC component
1588                elif ( periph.ptype == 'IOC' ):
1589
1590                    if   ( periph.subtype == 'BDV' ):
1591
1592                        # get irq line index associated to bdv
1593                        irq_in = 0xFFFFFFFF
1594                        for irq in irq_tgt.irqs:
1595                            if ( irq.isrtype == 'ISR_BDV' ): irq_in = irq.srcid
1596                        if ( irq_in == 0xFFFFFFFF ):
1597                            print '[genmap error] in netbsd.dts() ISR_BDV not found'
1598                            sys.exit(1)
1599
1600                        s += %s@0x%x {\n' % (periph.pseg.name, periph.pseg.base)
1601                        s += '    device_type = "soclib:blockdevice";\n'
1602                        s += '    irq = <&{/%s@0x%x} %d>;\n' % (irq_tgt.pseg.name,irq_tgt.pseg.base,irq_in)
1603                        s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1604                        s += '  };\n'
1605
1606                    elif ( periph.subtype == 'HBA' ):
1607                        print '[genmap error] in netbsd_dts() : HBA peripheral not supported by NetBSD'
1608                        sys.exit(1)
1609
1610                    elif ( periph.subtype == 'SPI' ):
1611
1612                        # get irq line index associated to spi
1613                        irq_in = 0xFFFFFFFF
1614                        for irq in irq_tgt.irqs:
1615                            if ( irq.isrtype == 'ISR_SPI' ): irq_in = irq.srcid
1616                        if ( irq_in == 0xFFFFFFFF ):
1617                            print '[genmap error] in netbsd.dts() ISR_SPI not found'
1618                            sys.exit(1)
1619
1620                        s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1621                        s += '    device_type = "soclib:spi";\n'
1622                        s += '    irq = <&{/%s@0x%x} %d>;\n' % (irq_tgt.pseg.name,irq_tgt.pseg.base,irq_in)
1623                        s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1624                        s += '  };\n'
1625
1626                # research ROM component
1627                elif ( periph.ptype == 'ROM' ):
1628
1629                    s += %s@0x%x {\n' % (periph.pseg.name, periph.pseg.base)
1630                    s += '    device_type = "rom";\n'
1631                    s += '    cached = <1>;\n'
1632                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1633                    s += '  };\n'
1634
1635                # research SIM component
1636                elif ( periph.ptype == 'SIM' ):
1637
1638                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1639                    s += '    device_type = "soclib:simhelper";\n'
1640                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1641                    s += '  };\n'
1642
1643                # research TTY component
1644                elif ( periph.ptype == 'TTY' ):
1645
1646                    s += %s@0x%x {\n' % (periph.pseg.name, periph.pseg.base)
1647                    s += '    device_type = "soclib:tty";\n'
1648                    s += '    channel_count = < %d >;\n' % periph.channels
1649                    s += '    reg = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1650
1651                    # multi-channels : get HWI index (to XCU or PIC) for each channel
1652                    for channel in xrange( periph.channels ):
1653                        hwi_id = 0xFFFFFFFF
1654                        for irq in irq_tgt.irqs:
1655                            if ( (irq.isrtype == 'ISR_TTY_RX') and (irq.channel == channel) ):
1656                                hwi_id = irq.srcid
1657                        if ( hwi_id == 0xFFFFFFFF ):
1658                            print '[genmap error] in netbsd.dts() ISR_TTY_RX channel %d not found' % channel
1659                            sys.exit(1)
1660
1661                        name = '%s@0x%x' % (irq_tgt.pseg.name, irq_tgt.pseg.base)
1662                        s += '    irq@%d{\n' % channel
1663                        s += '      device_type = "soclib:periph:irq";\n'
1664                        s += '      output_line = <%d>;\n' % channel
1665                        s += '      irq = <&{/%s%d>;\n' % (name, hwi_id)
1666                        s += '      parent = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1667                        s += '    };\n'
1668
1669                    s += '  };\n'
1670
1671                # research IOB component
1672                elif ( periph.ptype == 'IOB' ):
1673
1674                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1675                    s += '    device_type = "soclib:iob";\n'
1676                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1677                    s += '  };\n'
1678
1679                # research NIC component
1680                elif ( periph.ptype == 'NIC' ):
1681
1682                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1683                    s += '    device_type   = "soclib:nic";\n'
1684                    s += '    reg           = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1685                    s += '    channel_count = < %d >;\n' % periph.channels
1686
1687                    # multi-channels : get HWI index (to XCU or PIC) for RX & TX IRQs
1688                    # RX IRQ : (2*channel) / TX IRQs : (2*channel + 1)
1689                    for channel in xrange( periph.channels ):
1690                        hwi_id = 0xFFFFFFFF
1691                        for irq in irq_tgt.irqs:
1692                            if ( (irq.isrtype == 'ISR_NIC_RX') and (irq.channel == channel) ):
1693                                hwi_id = irq.srcid
1694                        if ( hwi_id == 0xFFFFFFFF ):
1695                            print '[genmap error] in netbsd.dts() ISR_NIC_RX channel %d not found' % channel
1696                            sys.exit(1)
1697
1698                        name = '%s@0x%x' % (irq_tgt.pseg.name, irq_tgt.pseg.base)
1699                        s += '    irq_rx@%d{\n' % channel
1700                        s += '      device_type = "soclib:periph:irq";\n'
1701                        s += '      output_line = <%d>;\n' % (2*channel)
1702                        s += '      irq         = <&{/%s%d>;\n' % (name, hwi_id)
1703                        s += '      parent      = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1704                        s += '    };\n'
1705
1706                        hwi_id = 0xFFFFFFFF
1707                        for irq in irq_tgt.irqs:
1708                            if ( (irq.isrtype == 'ISR_NIC_TX') and (irq.channel == channel) ):
1709                                hwi_id = irq.srcid
1710                        if ( hwi_id == 0xFFFFFFFF ):
1711                            print '[genmap error] in netbsd.dts() ISR_NIC_TX channel %d not found' % channel
1712                            sys.exit(1)
1713
1714                        name = '%s@0x%x' % (irq_tgt.pseg.name, irq_tgt.pseg.base)
1715                        s += '    irq_tx@%d{\n' % channel
1716                        s += '      device_type = "soclib:periph:irq";\n'
1717                        s += '      output_line = <%d>;\n' % (2*channel + 1)
1718                        s += '      irq         = <&{/%s%d>;\n' % (name, hwi_id)
1719                        s += '      parent      = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1720                        s += '    };\n'
1721
1722                    s += '  };\n'
1723
1724                # research CMA component
1725                elif ( periph.ptype == 'CMA' ):
1726
1727                    s += %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
1728                    s += '    device_type   = "soclib:cma";\n'
1729                    s += '    reg           = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
1730                    s += '    channel_count = < %d >;\n' % periph.channels
1731
1732                    # multi-channels : get HWI index (to XCU or PIC) for each channel
1733                    for channel in xrange( periph.channels ):
1734                        hwi_id = 0xFFFFFFFF
1735                        for irq in irq_tgt.irqs:
1736                            if ( (irq.isrtype == 'ISR_CMA') and (irq.channel == channel) ):
1737                                hwi_id = irq.srcid
1738                        if ( hwi_id == 0xFFFFFFFF ):
1739                            print '[genmap error] in netbsd.dts() ISR_CMA channel %d not found' % channel
1740                            sys.exit(1)
1741
1742                        name = '%s@0x%x' % (irq_tgt.pseg.name, irq_tgt.pseg.base)
1743                        s += '    irq@%d{\n' % channel
1744                        s += '      device_type = "soclib:periph:irq";\n'
1745                        s += '      output_line = <%d>;\n' % channel
1746                        s += '      irq = <&{/%s%d>;\n' % (name, hwi_id)
1747                        s += '      parent = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
1748                        s += '    };\n'
1749
1750                    s += '  };\n'
1751
1752                # research TIM component
1753                elif ( periph.ptype == 'TIM' ):
1754
1755                    print '[genmap error] in netbsd_dts() : TIM peripheral not supported by NetBSD'
1756                    sys.exit(1)
1757
1758                # research MWR component
1759                elif ( periph.ptype == 'MWR' ):
1760
1761                    print '[genmap error] in netbsd_dts() : MWR peripheral not supported by NetBSD'
1762                    sys.exit(1)
1763
1764                # research ICU component
1765                elif ( periph.ptype == 'ICU' ):
1766                    print '[genmap error] in netbsd_dts() : ICU peripheral not supported by NetBSD'
1767                    sys.exit(1)
1768
1769        # topology
1770        s += '\n'
1771        s += '  topology {\n'
1772        s += '    #address-cells = <2>;\n'
1773        s += '    #size-cells = <0>;\n'
1774        for cluster in self.clusters:
1775            s += '    cluster@%d,%d {\n' % (cluster.x, cluster.y)
1776            s += '      reg     = <%d %d>;\n' % (cluster.x, cluster.y)
1777            s += '      devices = <\n'
1778
1779            offset = ((cluster.x << self.y_width) + cluster.y) << self.p_width
1780            for proc in cluster.procs:
1781                s += '                &{/cpus/Mips,32@0x%x}\n' % (offset + proc.lpid)
1782            for periph in cluster.periphs:
1783                s += '                &{/%s@0x%x}\n' % (periph.pseg.name, periph.pseg.base)
1784
1785            s += '                >;\n'
1786            s += '    };\n'
1787        s += '  };\n'
1788        s += '};\n'
1789
1790        return s
1791        # end netbsd_dts()
1792
1793    ###########################
1794    def almos_archinfo( self ):    # compute string for arch.info file generation,
1795                                   # used for almos configuration
1796        # header
1797        s =  '# arch.info file generated by genmap for %s\n' % self.name
1798        s += '\n'
1799        s += '[HEADER]\n'
1800        s += '        REVISION=1\n'
1801        s += '        ARCH=%s\n'            % self.name
1802        s += '        XMAX=%d\n'            % self.x_size
1803        s += '        YMAX=%d\n'            % self.y_size
1804        s += '        CPU_NR=%d\n'          % self.nprocs
1805        s += '\n'
1806
1807        # clusters
1808        cluster_id = 0
1809        for cluster in self.clusters:
1810
1811            ram = None
1812            nb_cpus = len( cluster.procs )
1813            nb_devs = len( cluster.periphs )
1814            if ( len( cluster.coprocs ) != 0 ):
1815                print 'Error in almos_archinfo() coprocessors not supported yet'
1816                sys.exit(1)
1817
1818            # search a RAM
1819            for pseg in cluster.psegs:
1820                if ( pseg.segtype == 'RAM' ):
1821                    ram     = pseg
1822                    nb_devs += 1
1823
1824            # search XCU to get IRQs indexes if cluster contains peripherals
1825            if ( len( cluster.periphs ) != 0 ):
1826                tty_irq_id = None
1827                bdv_irq_id = None
1828                dma_irq_id = None
1829
1830                for periph in cluster.periphs:
1831                    if ( periph.ptype == 'XCU' ):
1832                        # scan irqs
1833                        for irq in periph.irqs:
1834                            if ( irq.isrtype == 'ISR_TTY_RX' ) : tty_irq_id = irq.srcid
1835                            if ( irq.isrtype == 'ISR_BDV'    ) : bdv_irq_id = irq.srcid
1836                            if ( irq.isrtype == 'ISR_DMA'    ) : dma_irq_id = irq.srcid
1837
1838            # Build the cluster description
1839            s += '[CLUSTER]\n'
1840            s += '         CID=%d\n'        % cluster_id
1841            s += '         ARCH_CID=0x%x\n' % ((cluster.x << self.y_width) + cluster.y)
1842            s += '         CPU_NR=%d\n'     % nb_cpus
1843            s += '         DEV_NR=%d\n'     % nb_devs
1844
1845
1846            # Handling RAM when cluster contain a RAM
1847            if (ram != None ):
1848                base  = ram.base
1849                size  = ram.size
1850                irqid = -1
1851                s += '         DEVID=RAM'
1852                s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
1853
1854            # Handling peripherals
1855            for periph in cluster.periphs:
1856                base  = periph.pseg.base
1857                size  = periph.pseg.size
1858
1859                if   ( periph.ptype == 'XCU' ):
1860
1861                    s += '         DEVID=XICU'
1862                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
1863
1864                elif ( (periph.ptype == 'TTY')
1865                       and (tty_irq_id != None) ):
1866
1867                    s += '         DEVID=TTY'
1868                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=%d\n' % ( base, size, tty_irq_id )
1869
1870                elif ( (periph.ptype == 'DMA')
1871                       and (dma_irq_id != None) ):
1872
1873                    s += '         DEVID=DMA'
1874                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=%d\n' % ( base, size, dma_irq_id )
1875
1876                elif ( periph.ptype == 'FBF' ):
1877
1878                    s += '         DEVID=FB'
1879                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
1880
1881                elif ( (periph.ptype == 'IOC') and (periph.subtype == 'BDV')
1882                       and (bdv_irq_id != None) ):
1883
1884                    s += '         DEVID=BLKDEV'
1885                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=%d\n' % ( base, size, bdv_irq_id )
1886
1887                elif ( periph.ptype == 'PIC' ):
1888
1889                        s += '         DEVID=IOPIC'
1890                        s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
1891
1892                else:
1893                    print '# Warning from almos_archinfo() in cluster[%d,%d]' \
1894                          % (cluster.x, cluster.y)
1895                    print '# peripheral type %s/%s not supported yet\n' \
1896                          % ( periph.ptype, periph.subtype )
1897
1898            cluster_id += 1
1899
1900        return s
1901
1902    # end of almos_archinfo()
1903
1904
1905
1906
1907
1908
1909
1910
1911###########################################################################################
1912class Cluster ( object ):
1913###########################################################################################
1914    def __init__( self,
1915                  x,
1916                  y ):
1917
1918        self.index       = 0             # global index (set by Mapping constructor)
1919        self.x           = x             # x coordinate
1920        self.y           = y             # y coordinate
1921        self.psegs       = []            # filled by addRam() or addPeriph()
1922        self.procs       = []            # filled by addProc()
1923        self.coprocs     = []            # filled by addCoproc()
1924        self.periphs     = []            # filled by addPeriph()
1925
1926        return
1927
1928    ################
1929    def xml( self ):  # xml for a cluster
1930
1931        s = '        <cluster x="%d" y="%d" >\n' % (self.x, self.y)
1932        for pseg in self.psegs:   s += pseg.xml()
1933        for proc in self.procs:   s += proc.xml()
1934        for copr in self.coprocs: s += copr.xml()
1935        for peri in self.periphs: s += peri.xml()
1936        s += '        </cluster>\n'
1937
1938        return s
1939
1940    #############################################
1941    def cbin( self, mapping, verbose, expected ):    # C binary structure for Cluster
1942
1943        if ( verbose ):
1944            print '*** cbin for cluster [%d,%d]' % (self.x, self.y)
1945
1946        # check index
1947        if (self.index != expected):
1948            print '[genmap error] in Cluster.cbin() : cluster global index = %d / expected = %d' \
1949                  % (self.index, expected )
1950            sys.exit(1)
1951
1952        # compute global index for first pseg
1953        if ( len(self.psegs) > 0 ):
1954            pseg_id = self.psegs[0].index
1955        else:
1956            pseg_id = 0
1957
1958        # compute global index for first proc
1959        if ( len(self.procs) > 0 ):
1960            proc_id = self.procs[0].index
1961        else:
1962            proc_id = 0
1963
1964        # compute global index for first coproc
1965        if ( len(self.coprocs) > 0 ):
1966            coproc_id = self.coprocs[0].index
1967        else:
1968            coproc_id = 0
1969
1970        # compute global index for first periph
1971        if ( len(self.periphs) > 0 ):
1972            periph_id = self.periphs[0].index
1973        else:
1974            periph_id = 0
1975
1976        byte_stream = bytearray()
1977        byte_stream += mapping.int2bytes( 4 , self.x )                 # x coordinate
1978        byte_stream += mapping.int2bytes( 4 , self.y )                 # x coordinate
1979        byte_stream += mapping.int2bytes( 4 , len( self.psegs ) )      # number of psegs in cluster
1980        byte_stream += mapping.int2bytes( 4 , pseg_id )                # first pseg global index
1981        byte_stream += mapping.int2bytes( 4 , len( self.procs ) )      # number of procs in cluster
1982        byte_stream += mapping.int2bytes( 4 , proc_id )                # first proc global index
1983        byte_stream += mapping.int2bytes( 4 , len( self.coprocs ) )    # number of coprocs in cluster
1984        byte_stream += mapping.int2bytes( 4 , coproc_id )              # first coproc global index
1985        byte_stream += mapping.int2bytes( 4 , len( self.periphs ) )    # number of periphs in cluster
1986        byte_stream += mapping.int2bytes( 4 , periph_id )              # first periph global index
1987
1988        if ( verbose ):
1989            print 'nb_psegs   = %d' %  len( self.psegs )
1990            print 'pseg_id    = %d' %  pseg_id
1991            print 'nb_procs   = %d' %  len( self.procs )
1992            print 'proc_id    = %d' %  proc_id
1993            print 'nb_coprocs = %d' %  len( self.coprocs )
1994            print 'coproc_id  = %d' %  coproc_id
1995            print 'nb_periphs = %d' %  len( self.periphs )
1996            print 'periph_id  = %d' %  periph_id
1997
1998        return byte_stream
1999
2000###########################################################################################
2001class Vspace( object ):
2002###########################################################################################
2003    def __init__( self,
2004                  name,
2005                  startname ):
2006
2007        self.index     = 0              # global index ( set by addVspace() )
2008        self.name      = name           # vspace name
2009        self.startname = startname      # name of vobj containing the start_vector
2010        self.vsegs     = []
2011        self.tasks     = []
2012
2013        return
2014
2015    ################
2016    def xml( self ):   # xml for one vspace
2017
2018        s =  '        <vspace name="%s" startname="%s" >\n' % ( self.name, self.startname )
2019        for vseg in self.vsegs: s += vseg.xml()
2020        for task in self.tasks: s += task.xml()
2021        s += '        </vspace>\n'
2022
2023        return s
2024
2025    #############################################
2026    def cbin( self, mapping, verbose, expected ):   # C binary structure for Vspace
2027
2028        if ( verbose ):
2029            print '*** cbin for vspace %s' % (self.name)
2030
2031        # check index
2032        if (self.index != expected):
2033            print '[genmap error] in Vspace.cbin() : vspace global index = %d / expected = %d' \
2034                  % (self.index, expected )
2035            sys.exit(1)
2036
2037        # compute global index for vobj containing start_vector
2038        vobj_start_id = 0xFFFFFFFF
2039        for vseg in self.vsegs:
2040            if ( vseg.vobjs[0].name == self.startname ):
2041                vobj_start_id = vseg.vobjs[0].index
2042        if ( vobj_start_id == 0xFFFFFFFF ):
2043            print '[genmap error] in Vspace.cbin() : startname %s not found for vspace %s' \
2044                  % ( self.startname, self.name )
2045            sys.exit(1)
2046
2047        # compute first vseg, vobj, task global index
2048        first_vseg_id = self.vsegs[0].index
2049        first_vobj_id = self.vsegs[0].vobjs[0].index
2050        first_task_id = self.tasks[0].index
2051
2052        # compute number of vobjs, tasks, vsegs
2053        nb_vsegs = len( self.vsegs )
2054        nb_tasks = len( self.tasks )
2055        nb_vobjs = 0
2056        for vseg in self.vsegs:
2057            nb_vobjs += len( vseg.vobjs )
2058
2059        byte_stream = bytearray()
2060        byte_stream += mapping.str2bytes( 32, self.name )         # vspace name
2061        byte_stream += mapping.int2bytes( 4,  vobj_start_id )     # vobj start_vector
2062        byte_stream += mapping.int2bytes( 4,  nb_vsegs )          # number of vsegs
2063        byte_stream += mapping.int2bytes( 4,  nb_vobjs )          # number of vobjs
2064        byte_stream += mapping.int2bytes( 4,  nb_tasks )          # number of tasks
2065        byte_stream += mapping.int2bytes( 4,  first_vseg_id )     # first vseg global index
2066        byte_stream += mapping.int2bytes( 4,  first_vobj_id )     # first vobj global index
2067        byte_stream += mapping.int2bytes( 4,  first_task_id )     # first task global index
2068
2069        if ( verbose ):
2070            print 'start_id   = %d' %  vobj_start_id
2071            print 'nb_vsegs   = %d' %  nb_vsegs
2072            print 'nb_vobjs   = %d' %  nb_vobjs
2073            print 'nb_tasks   = %d' %  nb_tasks
2074            print 'vseg_id    = %d' %  first_vseg_id
2075            print 'vobj_id    = %d' %  first_vobj_id
2076            print 'task_id    = %d' %  first_task_id
2077
2078        return byte_stream
2079
2080###########################################################################################
2081class Task( object ):
2082###########################################################################################
2083    def __init__( self,
2084                  name,
2085                  trdid,
2086                  x,
2087                  y,
2088                  p,
2089                  stackname,
2090                  heapname,
2091                  startid,
2092                  usetty = False,
2093                  usenic = False,
2094                  usecma = False,
2095                  usehba = False,
2096                  usetim = False ):
2097
2098        self.index     = 0             # global index value set by addTask()
2099        self.name      = name          # tsk name
2100        self.trdid     = trdid         # task index (unique in vspace)
2101        self.x         = x             # cluster x coordinate
2102        self.y         = y             # cluster y coordinate
2103        self.p         = p             # processor local index
2104        self.stackname = stackname     # name of vobj containing the stack
2105        self.heapname  = heapname      # name of vobj containing the heap
2106        self.startid   = startid       # index in start_vector
2107        self.usetty    = usetty        # request a private TTY channel
2108        self.usenic    = usenic        # request a private NIC channel
2109        self.usecma    = usecma        # request a private CMA channel
2110        self.usehba    = usehba        # request a private HBA channel
2111        self.usetim    = usetim        # request a private TIM channel
2112        return
2113
2114    ################
2115    def xml( self ):    # xml for one task
2116
2117        s =  '            <task name="%s"' % self.name
2118        s += ' trdid="%d"'                 % self.trdid
2119        s += ' x="%d"'                     % self.x
2120        s += ' y="%d"'                     % self.y
2121        s += ' p="%d"'                     % self.p
2122        s += ' stackname="%s"'             % self.stackname
2123        s += ' heapname="%s"'              % self.heapname
2124        s += ' startid="%d"'               % self.startid
2125        if self.usetty != 0: s += ' usetty="1"'
2126        if self.usenic != 0: s += ' usenic="1"'
2127        if self.usecma != 0: s += ' usehba="1"'
2128        if self.usehba != 0: s += ' usehba="1"'
2129        if self.usetim != 0: s += ' usehba="1"'
2130        s += ' />\n'
2131
2132        return s
2133
2134    #####################################################
2135    def cbin( self, mapping, verbose, expected, vspace ):  # C binary data structure for Task
2136
2137        if ( verbose ):
2138            print '*** cbin for task %s in vspace %s' % (self.name, vspace.name)
2139
2140        # check index
2141        if (self.index != expected):
2142            print '[genmap error] in Task.cbin() : task global index = %d / expected = %d' \
2143                  % (self.index, expected )
2144            sys.exit(1)
2145
2146        # compute cluster global index
2147        cluster_id = (self.x * mapping.y_size) + self.y
2148
2149        # compute vobj local index for stack
2150        vobj_stack_id = 0xFFFFFFFF
2151        for vseg in vspace.vsegs:
2152            if ( vseg.vobjs[0].name == self.stackname ):
2153                vobj_stack_id = vseg.vobjs[0].index
2154        if ( vobj_stack_id == 0xFFFFFFFF ):
2155            print '[genmap error] in Task.cbin() : stackname %s not found for task %s in vspace %s' \
2156                  % ( self.stackname, self.name, vspace.name )
2157            sys.exit(1)
2158
2159        # compute vobj local index for heap
2160        vobj_heap_id = 0xFFFFFFFF
2161        for vseg in vspace.vsegs:
2162            if ( vseg.vobjs[0].name == self.heapname ):
2163                vobj_heap_id = vseg.vobjs[0].index
2164        if ( vobj_heap_id == 0xFFFFFFFF ):
2165            print '[genmap error] in Task.cbin() : heapname %s not found for task %s in vspace %s' \
2166                  % ( self.heapname, self.name, vspace.name )
2167            sys.exit(1)
2168
2169        byte_stream = bytearray()
2170        byte_stream += mapping.str2bytes( 32, self.name )       # task name in vspace
2171        byte_stream += mapping.int2bytes( 4,  cluster_id )      # cluster global index
2172        byte_stream += mapping.int2bytes( 4,  self.p )          # processor local index in cluster
2173        byte_stream += mapping.int2bytes( 4,  self.trdid )      # thread local index in vspace
2174        byte_stream += mapping.int2bytes( 4,  vobj_stack_id )   # stack vobj local index
2175        byte_stream += mapping.int2bytes( 4,  vobj_heap_id )    # heap vobj local index
2176        byte_stream += mapping.int2bytes( 4,  self.startid )    # index in start vector
2177        byte_stream += mapping.int2bytes( 4,  self.usetty )     # TTY channel required
2178        byte_stream += mapping.int2bytes( 4,  self.usenic )     # NIC channel required
2179        byte_stream += mapping.int2bytes( 4,  self.usecma )     # CMA channel required
2180        byte_stream += mapping.int2bytes( 4,  self.usehba )     # IOC channel required
2181        byte_stream += mapping.int2bytes( 4,  self.usetim )     # TIM channel required
2182
2183        if ( verbose ):
2184            print 'clusterid  = %d' %  cluster_id
2185            print 'lpid       = %d' %  self.p
2186            print 'trdid      = %d' %  self.trdid
2187            print 'stackid    = %d' %  vobj_stack_id
2188            print 'heapid     = %d' %  vobj_heap_id
2189            print 'startid    = %d' %  self.startid
2190
2191        return byte_stream
2192
2193###########################################################################################
2194class Vseg( object ):
2195###########################################################################################
2196    def __init__( self,
2197                  name,
2198                  vbase,
2199                  mode,
2200                  x,
2201                  y,
2202                  psegname,
2203                  identity = False,
2204                  local    = False,
2205                  big      = False ):
2206
2207        assert mode in VSEGMODES
2208
2209        self.index    = 0                   # global index ( set by addVseg() )
2210        self.name     = name                # vseg name
2211        self.vbase    = vbase & 0xFFFFFFFF  # virtual base address in vspace
2212        self.mode     = mode                # CXWU access rights
2213        self.x        = x                   # x coordinate of destination cluster
2214        self.y        = y                   # y coordinate of destination cluster
2215        self.psegname = psegname            # name of pseg in destination cluster
2216        self.identity = identity            # identity mapping required
2217        self.local    = local               # only mapped in local PTAB when true
2218        self.big      = big                 # to be mapped in a big physical page
2219        self.vobjs    = []
2220        return
2221
2222    ################
2223    def xml( self ):  # xml for one vseg
2224
2225        s =  '            <vseg name="%s" vbase="0x%x" mode="%s" x="%d" y="%d" psegname="%s"' \
2226             % ( self.name, self.vbase, self.mode, self.x, self.y, self.psegname )
2227        if ( self.identity ): s += ' ident="1"'
2228        if ( self.local ):    s += ' local="1"'
2229        if ( self.big ):      s += ' big="1"'
2230        s += ' >\n'
2231        for vobj in self.vobjs:  s += vobj.xml()
2232        s += '            </vseg>\n'
2233
2234        return s
2235
2236    #############################################
2237    def cbin( self, mapping, verbose, expected ):    # C binary structure for Vseg
2238
2239        if ( verbose ):
2240            print '*** cbin for vseg[%d] %s' % (self.index, self.name)
2241
2242        # check index
2243        if (self.index != expected):
2244            print '[genmap error] in Vseg.cbin() : vseg global index = %d / expected = %d' \
2245                  % (self.index, expected )
2246            sys.exit(1)
2247
2248        # compute pseg_id
2249        pseg_id = 0xFFFFFFFF
2250        cluster_id = (self.x * mapping.y_size) + self.y
2251        cluster = mapping.clusters[cluster_id]
2252        for pseg in cluster.psegs:
2253            if (self.psegname == pseg.name):
2254                pseg_id = pseg.index
2255        if (pseg_id == 0xFFFFFFFF):
2256            print '[genmap error] in Vseg.cbin() : psegname %s not found for vseg %s in cluster %d' \
2257                  % ( self.psegname, self.name, cluster_id )
2258            sys.exit(1)
2259
2260        # compute numerical value for mode
2261        mode_id = 0xFFFFFFFF
2262        for x in xrange( len(VSEGMODES) ):
2263            if ( self.mode == VSEGMODES[x] ):
2264                mode_id = x
2265        if ( mode_id == 0xFFFFFFFF ):
2266            print '[genmap error] in Vseg.cbin() : undefined vseg mode %s' % self.mode
2267            sys.exit(1)
2268
2269        # compute vobj_id
2270        vobj_id = self.vobjs[0].index
2271
2272        byte_stream = bytearray()
2273        byte_stream += mapping.str2bytes( 32, self.name )       # vseg name
2274        byte_stream += mapping.int2bytes( 4,  self.vbase )      # virtual base address
2275        byte_stream += mapping.int2bytes( 8,  0 )               # physical base address
2276        byte_stream += mapping.int2bytes( 4,  0 )               # vseg size (bytes)
2277        byte_stream += mapping.int2bytes( 4,  pseg_id )         # physical segment global index
2278        byte_stream += mapping.int2bytes( 4,  mode_id )         # CXWU flags
2279        byte_stream += mapping.int2bytes( 4,  len(self.vobjs) ) # number of vobjs in vseg
2280        byte_stream += mapping.int2bytes( 4,  vobj_id )         # first vobj global index
2281        byte_stream += mapping.int2bytes( 4,  0 )               # linked list of vsegs on pseg
2282        byte_stream += mapping.int2bytes( 1,  0 )               # mapped when non zero
2283        byte_stream += mapping.int2bytes( 1,  self.identity )   # identity mapping if non zero
2284        byte_stream += mapping.int2bytes( 1,  self.local )      # only mapped in local PTAB
2285        byte_stream += mapping.int2bytes( 1,  self.big )        # to be mapped in big physical page
2286
2287        if ( verbose ):
2288            print 'vbase      = %x' %  self.vbase
2289            print 'pseg_id    = %d' %  pseg_id
2290            print 'mode       = %s' %  self.mode
2291            print 'nb_vobjs   = %d' %  len(self.vobjs)
2292            print 'vobj_id    = %d' %  vobj_id
2293
2294        return byte_stream
2295
2296###########################################################################################
2297class Vobj( object ):
2298###########################################################################################
2299    def __init__( self,
2300                  name,
2301                  length,
2302                  vtype,
2303                  binpath = '',
2304                  align   = 0,
2305                  init    = 0 ):
2306
2307        assert vtype in ['ELF','BLOB','PTAB','PERI','MWMR','LOCK', \
2308                         'BUFFER','BARRIER','CONST','MEMSPACE','SCHED']
2309
2310        assert (vtype != 'ELF') or (binpath != '')
2311
2312        self.index    = 0        # global index ( set by addVobj() )
2313        self.name     = name     # vobj name (unique in vspace)
2314        self.vtype    = vtype    # vobj type (defined in mapping_info.h)
2315        self.length   = length   # vobj size (bytes)
2316        self.binpath  = binpath  # pathname for (ELF type)
2317        self.align    = align    # required alignment (logarithm of 2)
2318        self.init     = init     # initialisation value (for BARRIER or MWMR types)
2319
2320        return
2321
2322    ################
2323    def xml( self ):  # xml for a vobj
2324
2325        s = '            <vobj name="%s" type="%s" length="0x%x"' \
2326                           % ( self.name, self.vtype, self.length )
2327        if (self.binpath != ''):   s += ' binpath="%s"' % (self.binpath)
2328        if (self.align   != 0 ):   s += ' align="%d"' % (self.align)
2329        if (self.init    != 0 ):   s += ' init="%d"' % (self.init)
2330        s += ' />\n'
2331
2332        return s
2333
2334    #############################################
2335    def cbin( self, mapping, verbose, expected ):    # C binary structure for Vobj
2336
2337        # check index
2338        if (self.index != expected):
2339            print '[genmap error] in Vobj.cbin() : vobj global index = %d / expected = %d' \
2340                  % (self.index, expected )
2341            sys.exit(1)
2342        elif ( verbose ):
2343            print '*** cbin for vobj[%d] %s' % (self.index, self.name)
2344
2345        # compute numerical value for vtype
2346        vtype_int = 0xFFFFFFFF
2347        for x in xrange( len(VOBJTYPES) ):
2348            if ( self.vtype == VOBJTYPES[x] ):
2349                vtype_int = x
2350        if ( vtype_int == 0xFFFFFFFF ):
2351            print '[genmap error] in Vobj.cbin() : undefined vobj type %s' % self.vtype
2352            sys.exit(1)
2353
2354        byte_stream = bytearray()
2355        byte_stream += mapping.str2bytes( 32, self.name )       # vobj name
2356        byte_stream += mapping.str2bytes( 64, self.binpath )    # pathname for .elf file
2357        byte_stream += mapping.int2bytes( 4 , vtype_int )       # vobj type
2358        byte_stream += mapping.int2bytes( 4 , self.length )     # vobj size
2359        byte_stream += mapping.int2bytes( 4 , self.align )      # required alignment
2360        byte_stream += mapping.int2bytes( 4 , 0 )               # virtual base address
2361        byte_stream += mapping.int2bytes( 4 , self.init )       # init value
2362
2363        if ( verbose ):
2364            print 'binpath    = %s' %  self.binpath
2365            print 'type       = %s' %  self.vtype
2366            print 'length     = %x' %  self.length
2367
2368        return byte_stream
2369
2370###########################################################################################
2371class Processor ( object ):
2372###########################################################################################
2373    def __init__( self,
2374                  x,
2375                  y,
2376                  lpid ):
2377
2378        self.index    = 0      # global index ( set by addProc() )
2379        self.x        = x      # x cluster coordinate
2380        self.y        = y      # y cluster coordinate
2381        self.lpid     = lpid   # processor local index
2382
2383        return
2384
2385    ################
2386    def xml( self ):   # xml for a processor
2387        return '            <proc index="%d" />\n' % (self.lpid)
2388
2389    #############################################
2390    def cbin( self, mapping, verbose, expected ):    # C binary structure for Proc
2391
2392        if ( verbose ):
2393            print '*** cbin for proc %d in cluster (%d,%d)' % (self.lpid, self.x, self.y)
2394
2395        # check index
2396        if (self.index != expected):
2397            print '[genmap error] in Proc.cbin() : proc global index = %d / expected = %d' \
2398                  % (self.index, expected )
2399            sys.exit(1)
2400
2401        byte_stream = bytearray()
2402        byte_stream += mapping.int2bytes( 4 , self.lpid )       # local index
2403
2404        return byte_stream
2405
2406###########################################################################################
2407class Pseg ( object ):
2408###########################################################################################
2409    def __init__( self,
2410                  name,
2411                  base,
2412                  size,
2413                  x,
2414                  y,
2415                  segtype ):
2416
2417        assert( segtype in PSEGTYPES )
2418
2419        self.index    = 0       # global index ( set by addPseg() )
2420        self.name     = name    # pseg name (unique in cluster)
2421        self.base     = base    # physical base address
2422        self.size     = size    # segment size (bytes)
2423        self.x        = x       # cluster x coordinate
2424        self.y        = y       # cluster y coordinate
2425        self.segtype  = segtype # RAM / PERI (defined in mapping_info.h)
2426
2427        return
2428
2429    ################
2430    def xml( self ):   # xml for a pseg
2431
2432        return '            <pseg name="%s" type="%s" base="0x%x" length="0x%x" />\n' \
2433                % (self.name, self.segtype, self.base, self.size)
2434
2435    ######################################################
2436    def cbin( self, mapping, verbose, expected, cluster ):    # C binary structure for Pseg
2437
2438        if ( verbose ):
2439            print '*** cbin for pseg[%d] %s in cluster[%d,%d]' \
2440                  % (self.index, self.name, cluster.x, cluster.y)
2441
2442        # check index
2443        if (self.index != expected):
2444            print '[genmap error] in Pseg.cbin() : pseg global index = %d / expected = %d' \
2445                  % (self.index, expected )
2446            sys.exit(1)
2447
2448        # compute numerical value for segtype
2449        segtype_int = 0xFFFFFFFF
2450        for x in xrange( len(PSEGTYPES) ):
2451            if ( self.segtype == PSEGTYPES[x] ):
2452                segtype_int = x
2453        if ( segtype_int == 0xFFFFFFFF ):
2454            print '[genmap error] in Pseg.cbin() : undefined segment type %s' % self.segtype
2455            sys.exit(1)
2456
2457        byte_stream = bytearray()
2458        byte_stream += mapping.str2bytes( 32, self.name )      # pseg name
2459        byte_stream += mapping.int2bytes( 8 , self.base )      # physical base address
2460        byte_stream += mapping.int2bytes( 8 , self.size )      # segment length
2461        byte_stream += mapping.int2bytes( 4 , segtype_int )    # segment type
2462        byte_stream += mapping.int2bytes( 4 , cluster.index )  # cluster global index
2463        byte_stream += mapping.int2bytes( 4 , 0 )              # linked list of vsegs
2464
2465        if ( verbose ):
2466            print 'pbase      = %x' %  self.base
2467            print 'size       = %x' %  self.size
2468            print 'type       = %s' %  self.segtype
2469
2470        return byte_stream
2471
2472###########################################################################################
2473class Periph ( object ):
2474###########################################################################################
2475    def __init__( self,
2476                  pseg,               # associated pseg
2477                  ptype,              # peripheral type
2478                  subtype  = 'NONE',  # peripheral subtype
2479                  channels = 1,       # for multi-channels peripherals
2480                  arg      = 0 ):     # optional argument (semantic depends on ptype)
2481
2482        assert ptype in PERIPHTYPES
2483
2484        assert subtype in PERIPHSUBTYPES
2485
2486        self.index    = 0            # global index ( set by addPeriph() )
2487        self.channels = channels
2488        self.ptype    = ptype
2489        self.subtype  = subtype
2490        self.arg      = arg
2491        self.pseg     = pseg
2492        self.irqs     = []
2493        return
2494
2495    ################
2496    def xml( self ):    # xml for a periph
2497
2498        s =  '            <periph type="%s"' % self.ptype
2499        s += ' subtype="%s"'                 % self.subtype
2500        s += ' psegname="%s"'                % self.pseg.name
2501        s += ' channels="%d"'                % self.channels
2502        s += ' arg="%d" >\n'                 % self.arg
2503        if ( (self.ptype == 'PIC') or (self.ptype == 'XCU') or (self.ptype == 'ICU') ):
2504            for irq in self.irqs: s += irq.xml()
2505        s += '            </periph>\n'
2506
2507        return s
2508
2509    #############################################
2510    def cbin( self, mapping, verbose, expected ):    # C binary structure for Periph
2511
2512        if ( verbose ):
2513            print '*** cbin for periph %s in cluster [%d,%d]' \
2514                  % (self.ptype, self.pseg.x, self.pseg.y)
2515
2516        # check index
2517        if (self.index != expected):
2518            print '[genmap error] in Periph.cbin() : periph global index = %d / expected = %d' \
2519                  % (self.index, expected )
2520            sys.exit(1)
2521
2522        # compute pseg global index
2523        pseg_id = self.pseg.index
2524
2525        # compute first irq global index
2526        if ( len(self.irqs) > 0 ):
2527            irq_id = self.irqs[0].index
2528        else:
2529            irq_id = 0
2530
2531        # compute numerical value for ptype
2532        ptype_id = 0xFFFFFFFF
2533        for x in xrange( len(PERIPHTYPES) ):
2534            if ( self.ptype == PERIPHTYPES[x] ):  ptype_id = x
2535        if ( ptype_id == 0xFFFFFFFF ):
2536            print '[genmap error] in Periph.cbin() : undefined peripheral type %s' % self.ptype
2537            sys.exit(1)
2538
2539        # compute numerical value for subtype
2540        subtype_id = 0xFFFFFFFF
2541        for x in xrange( len(PERIPHSUBTYPES) ):
2542            if ( self.subtype == PERIPHSUBTYPES[x] ):  subtype_id = x
2543
2544        # compute
2545        byte_stream = bytearray()
2546        byte_stream += mapping.int2bytes( 4 , ptype_id )         # peripheral type
2547        byte_stream += mapping.int2bytes( 4 , subtype_id )       # peripheral subtype
2548        byte_stream += mapping.int2bytes( 4 , pseg_id )          # pseg global index
2549        byte_stream += mapping.int2bytes( 4 , self.channels )    # number of channels
2550        byte_stream += mapping.int2bytes( 4 , self.arg )         # optionnal argument
2551        byte_stream += mapping.int2bytes( 4 , len( self.irqs ) ) # number of input irqs
2552        byte_stream += mapping.int2bytes( 4 , irq_id )           # first irq global index
2553
2554        if ( verbose ):
2555            print 'ptype      = %d' %  ptype_id
2556            print 'pseg_id    = %d' %  pseg_id
2557            print 'nb_irqs    = %d' %  len( self.irqs )
2558            print 'irq_id     = %d' %  irq_id
2559        return byte_stream
2560
2561###########################################################################################
2562class Irq ( object ):
2563###########################################################################################
2564    def __init__( self,
2565                  irqtype,         # input IRQ type : HWI / WTI / PTI (for XCU only)
2566                  srcid,           # input IRQ index (for XCU or PIC)
2567                  isrtype,         # Type of ISR to be executed
2568                  channel = 0 ):   # channel index for multi-channel ISR
2569
2570        assert irqtype in IRQTYPES
2571        assert isrtype in ISRTYPES
2572        assert srcid < 32
2573
2574        self.index   = 0        # global index ( set by addIrq() )
2575        self.irqtype = irqtype  # IRQ type
2576        self.srcid   = srcid    # source IRQ index
2577        self.isrtype = isrtype  # ISR type
2578        self.channel = channel  # channel index (for multi-channels ISR)
2579        return
2580
2581    ################
2582    def xml( self ):   # xml for Irq
2583
2584        return '                <irq srctype="%s" srcid="%d" isr="%s" channel="%d" />\n' \
2585                % ( self.irqtype, self.srcid, self.isrtype, self.channel )
2586
2587    #############################################
2588    def cbin( self, mapping, verbose, expected ):     # C binary structure for Irq
2589
2590        if ( verbose ):
2591            print '*** cbin for irq[%d]' % (self.index)
2592
2593        # check index
2594        if (self.index != expected):
2595            print '[genmap error] in Irq.cbin() : irq global index = %d / expected = %d' \
2596                  % (self.index, expected )
2597            sys.exit(1)
2598
2599        # compute numerical value for irqtype
2600        irqtype_id = 0xFFFFFFFF
2601        for x in xrange( len(IRQTYPES) ):
2602            if ( self.irqtype == IRQTYPES[x] ):
2603                irqtype_id = x
2604        if ( irqtype_id == 0xFFFFFFFF ):
2605            print '[genmap error] in Irq.cbin() : undefined irqtype %s' % self.irqtype
2606            sys.exit(1)
2607
2608        # compute numerical value for isrtype
2609        isrtype_id = 0xFFFFFFFF
2610        for x in xrange( len(ISRTYPES) ):
2611            if ( self.isrtype == ISRTYPES[x] ):
2612                isrtype_id = x
2613        if ( isrtype_id == 0xFFFFFFFF ):
2614            print '[genmap error] in Irq.cbin() : undefined isrtype %s' % self.isrtype
2615            sys.exit(1)
2616
2617        byte_stream = bytearray()
2618        byte_stream += mapping.int2bytes( 4,  irqtype_id )
2619        byte_stream += mapping.int2bytes( 4,  self.srcid )
2620        byte_stream += mapping.int2bytes( 4,  isrtype_id )
2621        byte_stream += mapping.int2bytes( 4,  self.channel )
2622        byte_stream += mapping.int2bytes( 4,  0 )
2623        byte_stream += mapping.int2bytes( 4,  0 )
2624
2625        if ( verbose ):
2626            print 'irqtype    = %s' %  self.irqtype
2627            print 'srcid      = %d' %  self.srcid
2628            print 'isrtype    = %s' %  self.isrtype
2629            print 'channel    = %d' %  self.channel
2630
2631        return byte_stream
2632
2633###########################################################################################
2634class Coproc ( object ):
2635###########################################################################################
2636    def __init__( self,
2637                  pseg ):           # associated pseg
2638
2639        self.index    = 0        # global index value set by addCoproc()
2640        self.pseg     = pseg
2641        self.ports    = []
2642
2643        return
2644
2645    ################
2646    def xml( self ):    # xml for Coproc
2647
2648        print '[genmap error] in Coproc.xml() : not defined yet'
2649        sys.exit(1)
2650
2651        return
2652
2653    #############################################
2654    def cbin( self, mapping, verbose, expected ):    # C binary structure for Coproc
2655
2656        if ( verbose ):
2657            print '*** cbin for coproc in cluster (%d,%d)' % (self.pseg.x, self.pseg.y)
2658
2659        # check index
2660        if (self.index != expected):
2661            print '[genmap error] in Coproc.cbin() : coproc global index = %d / expected = %d' \
2662                  % (self.index, expected )
2663            sys.exit(1)
2664
2665        # compute pseg global index
2666        pseg_id = self.pseg.index
2667
2668        # compute first port global index
2669        port_id = self.ports[0].index
2670
2671        byte_stream = bytearray()
2672        byte_stream += mapping.str2bytes( 32, self.pseg.name )    # probablement inutile (AG)
2673        byte_stream += mapping.int2bytes( 4 , pseg_id )           # pseg global index
2674        byte_stream += mapping.int2bytes( 4 , len( self.ports ) ) # number of input irqs
2675        byte_stream += mapping.int2bytes( 4 , port_id )           # first port global index
2676
2677        if ( verbose ):
2678            print 'irqtype    = %s' %  self.irqtype
2679            print 'pseg_id    = %d' %  pseg_id
2680            print 'nb_ports   = %d' %  len( self.ports )
2681            print 'port_id      %d' %  port_id
2682
2683        return byte_stream
2684
2685###########################################################################################
2686class Cpport ( object ):
2687###########################################################################################
2688    def __init__( self,
2689                  direction,
2690                  vspacename,
2691                  mwmrname ):
2692
2693        self.index      = 0           # global index ( set by addCpport() )
2694        self.direction  = direction   # TO_COPROC / FROM_COPROC
2695        self.vspacename = vspacename  # name of vspace containing mwmr channel
2696        self.mwmrname   = mwmrname    # name of vobj defining mwmr channel
2697
2698        return
2699
2700    ################
2701    def xml( self ):    # xml for Cpport
2702
2703        print '[genmap error] in Cpport.xml() : not defined yet'
2704        sys.exit(1)
2705
2706        return
2707
2708    #############################################
2709    def cbin( self, mapping, verbose, expected ):    # C binary structure for Cpport
2710
2711        if ( verbose ):
2712            print '*** cbin for cpport[%d]' % (self.index)
2713
2714        # check index
2715        if ( self.index != expected ):
2716            print '[genmap error] in Cpport.cbin() : port global index = %d / expected = %d' \
2717                  % ( self.index, expected )
2718            sys.exit(1)
2719
2720        # compute numerical value for direction
2721        if ( self.direction == 'TO_COPROC' ):
2722             dir_int = 0
2723        else:
2724             dir_int = 1
2725
2726        # compute vspace global index
2727        vspace_id = 0xFFFFFFFF
2728        for vspace in mapping.vspaces:
2729            if ( self.vspacename == vspace.name ):
2730                vspace_id = vspace.index
2731        if (vspace_id == 0xFFFFFFFF):
2732            print '[genmap error] in Cpport.cbin() : vspace name %s not found' \
2733                  % ( self.vspacename )
2734            sys.exit(1)
2735
2736        # compute mwmr global index
2737        mwmr_id = 0xFFFFFFFF
2738        for vseg in mapping.vspace[vspace_id].vsegs:
2739            for vobj in vseg.vobjs:
2740                if (self.mwmrname == vobj.name):
2741                    mwmr_id = vobj.index
2742        if (mwmr_id == 0xFFFFFFFF):
2743            print '[genmap error] in Cpport.cbin() : mwmr vobj name %s not found in vspace %s' \
2744                  % ( self.mwmrname, self.vspacename )
2745            sys.exit(1)
2746
2747        byte_stream = bytearray()
2748        byte_stream += mapping.int2bytes( 4 , dir_int )         # pseg global index
2749        byte_stream += mapping.int2bytes( 4 , vspace_id )       # vspace global index
2750        byte_stream += mapping.int2bytes( 4 , mwmr_id )         # mwmr vobj global index
2751
2752        if ( verbose ):
2753            print 'direction  = %s' %  self.direction
2754            print 'vspace_id  = %d' %  vspace_id
2755            print 'mwmr_id    = %d' %  mwmr_id
2756
2757        return byte_stream
2758
2759
2760# Local Variables:
2761# tab-width: 4;
2762# c-basic-offset: 4;
2763# c-file-offsets:((innamespace . 0)(inline-open . 0));
2764# indent-tabs-mode: nil;
2765# End:
2766#
2767# vim: filetype=python:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
2768
Note: See TracBrowser for help on using the repository browser.