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

Last change on this file since 621 was 565, checked in by alain, 10 years ago

Introduce support for a new driver sdc_driver.
There is now 5 IOC drivers: BDV / HBA / RDK / SDC / SPI.

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