Changeset 406


Ignore:
Timestamp:
Sep 12, 2014, 3:01:34 PM (10 years ago)
Author:
cfuguet
Message:

Introducing P_WIDTH field in hard_config.h file

  • This constant represents the number of bits used in the EBASE[9:0] MIPS CP0 register to encode the local processor id. This way, the EBASE[9:0] uses a complete fixed format:

X_WIDTH | Y_WIDTH | P_WIDTH

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_python/mapping.py

    r404 r406  
    2727# or the tasks set is split in several subsets (one subset per vspace), etc...
    2828# In the C binary data structure used by the giet_vm, all objects of same type
    29 # are stored in a linear array (one single array for all psegs for example). 
    30 # For all objects, we compute and store in the  PYTHON object itsel a "global index" 
    31 # corresponding to the index in this global array, and this index can be used as 
     29# are stored in a linear array (one single array for all psegs for example).
     30# For all objects, we compute and store in the  PYTHON object itsel a "global index"
     31# corresponding to the index in this global array, and this index can be used as
    3232# a pseudo-pointer to identify a specific object of a given type.
    3333##########################################################################################
    … …  
    131131##########################################################################################
    132132    def __init__( self,
    133                   name,                          # mapping name 
     133                  name,                          # mapping name
    134134                  x_size,                        # number of clusters in a row
    135135                  y_size,                        # number of clusters in a column
    136                   procs_max,                     # max number of processors per cluster
     136                  procs_max = 2,                 # max number of processors per cluster
    137137                  x_width = 4,                   # number of bits encoding x coordinate
    138138                  y_width = 4,                   # number of bits encoding y coordinate
     139                  p_width = 2,                   # number of bits encoding local proc id
    139140                  paddr_width = 40,              # number of bits for physical address
    140141                  coherence = 1,                 # hardware cache coherence when non-zero
    141                   irq_per_proc = 1,              # number or IRQs from XCU to processor 
     142                  irq_per_proc = 1,              # number or IRQs from XCU to processor
    142143                  use_ramdisk = False,           # use ramdisk when true
    143144                  x_io = 0,                      # cluster_io x coordinate
    … …  
    148149                  ram_size       = 0 ):          # RAM size in each cluster (bytes)
    149150
     151        assert (procs_max <= (1 << p_width))
     152
    150153        self.signature      = 0xDACE2014
    151154        self.name           = name
    152         self.paddr_width    = paddr_width           
     155        self.paddr_width    = paddr_width
    153156        self.coherence      = coherence
    154157        self.x_size         = x_size
    155158        self.y_size         = y_size
     159        self.procs_max      = procs_max
    156160        self.x_width        = x_width
    157161        self.y_width        = y_width
     162        self.p_width        = p_width
    158163        self.irq_per_proc   = irq_per_proc
    159         self.procs_max      = procs_max     
    160164        self.use_ramdisk    = use_ramdisk
    161165        self.x_io           = x_io
    … …  
    186190            for y in xrange( self.y_size ):
    187191                cluster = Cluster( x , y )
    188                 cluster.index = (x * self.y_size) + y 
     192                cluster.index = (x * self.y_size) + y
    189193                self.clusters.append( cluster )
    190194
    … …  
    192196
    193197    ##########################    add a ram pseg in a cluster
    194     def addRam( self, 
     198    def addRam( self,
    195199                name,                  # pseg name
    196200                base,                  # pseg base address
    197201                size ):                # pseg length (bytes)
    198        
     202
    199203        # check coordinates (obtained from the base address)
    200204        paddr_lsb_width = self.paddr_width - self.x_width - self.y_width
    201205        cluster_xy = base >> paddr_lsb_width
    202206        x = cluster_xy >> (self.y_width);
    203         y = cluster_xy & ((1 << self.y_width) - 1) 
     207        y = cluster_xy & ((1 << self.y_width) - 1)
    204208
    205209        assert (base & 0xFFF) == 0
    206210
    207211        assert (x < self.x_size) and (y < self.y_size)
    208        
     212
    209213        assert ( (base & ((1<<paddr_lsb_width)-1)) == self.ram_base )
    210214
    … …  
    222226
    223227    ##############################   add a peripheral and the associated pseg in a cluster
    224     def addPeriph( self, 
     228    def addPeriph( self,
    225229                   name,               # associated pseg name
    226230                   base,               # associated pseg base address
    227231                   size,               # associated pseg length (bytes)
    228                    ptype,              # peripheral type 
     232                   ptype,              # peripheral type
    229233                   subtype  = 'NONE',  # peripheral subtype
    230234                   channels = 1,       # number of channels
    … …  
    234238        cluster_xy = base >> (self.paddr_width - self.x_width - self.y_width)
    235239        x = cluster_xy >> (self.y_width);
    236         y = cluster_xy & ((1 << self.y_width) - 1) 
     240        y = cluster_xy & ((1 << self.y_width) - 1)
    237241
    238242        assert (x < self.x_size) and (y < self.y_size)
    … …  
    253257
    254258        # add one periph into mapping
    255         periph = Periph( pseg, ptype, subtype, channels, arg ) 
     259        periph = Periph( pseg, ptype, subtype, channels, arg )
    256260        self.clusters[cluster_id].periphs.append( periph )
    257261        periph.index = self.total_periphs
    … …  
    271275        assert index < 32
    272276
    273         # add one irq into mapping 
     277        # add one irq into mapping
    274278        irq = Irq( 'HWI', index , isrtype, channel )
    275279        periph.irqs.append( irq )
    … …  
    280284
    281285    ##########################    add a processor in a cluster
    282     def addProc( self, 
     286    def addProc( self,
    283287                 x,                    # cluster x coordinate
    284288                 y,                    # cluster y coordinate
    … …  
    289293        cluster_id = (x * self.y_size) + y
    290294
    291         # add one proc into mapping 
     295        # add one proc into mapping
    292296        proc = Processor( x, y, p )
    293297        self.clusters[cluster_id].procs.append( proc )
    … …  
    298302
    299303    ##############################    add a coprocessor in a cluster
    300     def addCoproc( self, 
     304    def addCoproc( self,
    301305                   name,               # associated pseg name
    302306                   base,               # associated pseg base address
    303307                   size ):             # associated pseg length
    304        
     308
    305309        # check cluster coordinates (obtained from the base address)
    306310        cluster_xy = base >> (self.paddr_width - self.x_width - self.y_width)
    307311        x = cluster_xy >> (self.y_width);
    308         y = cluster_xy & ((1 << self.y_width) - 1) 
     312        y = cluster_xy & ((1 << self.y_width) - 1)
    309313
    310314        assert (x < self.x_size) and (y < self.y_size)
    … …  
    319323
    320324        # add one coproc into mapping
    321         periph = Coproc( pseg ) 
     325        periph = Coproc( pseg )
    322326        self.clusters[cluster_id].coprocs.append( coproc )
    323327        periph.index = self.total_coprocs
    … …  
    326330        return coproc
    327331
    328     ##################################    add a port in a coprocessor 
    329     def addPort( self, 
     332    ##################################    add a port in a coprocessor
     333    def addPort( self,
    330334                 coproc,               # coprocessor containing the port
    331335                 direction,            # direction (TO_COPROC / FROM_COPROC)
    … …  
    343347        return port
    344348
    345     ############################    add one (or several) global vseg into mapping 
    346     def addGlobal( self, 
     349    ############################    add one (or several) global vseg into mapping
     350    def addGlobal( self,
    347351                   name,                  # vseg name
    348352                   vbase,                 # virtual base address
    … …  
    355359                   identity = False,      # identity mapping required if true
    356360                   binpath  = '',         # pathname for binary code
    357                    local    = False ):    # non shared vseg when true 
     361                   local    = False ):    # non shared vseg when true
    358362
    359363        assert mode in VSEGMODES
    … …  
    366370
    367371        # add one vseg into mapping
    368         vseg = Vseg( name, vbase, mode, x, y, pseg, 
     372        vseg = Vseg( name, vbase, mode, x, y, pseg,
    369373                     identity = identity, local = local )
    370374
    371375        self.globs.append( vseg )
    372376        self.total_globals += 1
    373         vseg.index = self.total_vsegs 
     377        vseg.index = self.total_vsegs
    374378        self.total_vsegs += 1
    375            
     379
    376380        # add one vobj into mapping
    377381        vobj = Vobj( name, size, vtype, binpath, 0, 0 )
    … …  
    383387
    384388    ################################    add a vspace into mapping
    385     def addVspace( self, 
     389    def addVspace( self,
    386390                   name,                # vspace name
    387391                   startname ):         # name of vobj containing start_vector
    … …  
    394398
    395399        return vspace
    396    
     400
    397401    #################################   add a private vseg and a vobj in a vspace
    398402    def addVseg( self,
    399                  vspace,                # vspace containing the vseg 
     403                 vspace,                # vspace containing the vseg
    400404                 name,                  # vseg name
    401405                 vbase,                 # virtual base address
    … …  
    432436
    433437    ################################    add a vobj in a private vseg
    434     def addVobj( self, 
     438    def addVobj( self,
    435439                 vseg,                  # vseg containing vobj
    436440                 name,                  # vobj name
    … …  
    451455        return vobj
    452456
    453     ################################    add a task in a vspace 
    454     def addTask( self, 
     457    ################################    add a task in a vspace
     458    def addTask( self,
    455459                 vspace,                # vspace containing task
    456460                 name,                  # task name
    … …  
    467471                 usehba = False,        # request a private HBA channel
    468472                 usetim = False ):      # request a private TIM channel
    469                  
     473
    470474        assert (x < self.x_size) and (y < self.y_size)
    471 
    472475        assert lpid < self.procs_max
    473476
    474         # add one task into mapping 
     477        # add one task into mapping
    475478        task = Task( name, trdid, x, y, lpid, stackname, heapname, startid,
    476479                     usetty, usenic, usecma, usehba, usetim )
    … …  
    498501
    499502    ###################################
    500     def int2bytes( self, nbytes, val ):    # integer => nbytes litle endian byte array 
     503    def int2bytes( self, nbytes, val ):    # integer => nbytes litle endian byte array
    501504
    502505        byte_stream = bytearray()
    … …  
    525528        for x in xrange ( self.x_size ):
    526529            for y in xrange ( self.y_size ):
    527                 cluster_id = (x * self.y_size) + y 
     530                cluster_id = (x * self.y_size) + y
    528531                s += self.clusters[cluster_id].xml()
    529532        s += '    </clusterset>\n'
    … …  
    549552        # header
    550553        byte_stream += self.int2bytes(4,  self.signature)
    551         byte_stream += self.int2bytes(4,  self.x_size)         
    552         byte_stream += self.int2bytes(4,  self.y_size)       
    553         byte_stream += self.int2bytes(4,  self.x_width)     
    554         byte_stream += self.int2bytes(4,  self.y_width)   
    555         byte_stream += self.int2bytes(4,  self.x_io)     
    556         byte_stream += self.int2bytes(4,  self.y_io)   
    557         byte_stream += self.int2bytes(4,  self.irq_per_proc)   
    558         byte_stream += self.int2bytes(4,  self.use_ramdisk)   
    559         byte_stream += self.int2bytes(4,  self.total_globals)   
    560         byte_stream += self.int2bytes(4,  self.total_vspaces)   
    561         byte_stream += self.int2bytes(4,  self.total_psegs)   
    562         byte_stream += self.int2bytes(4,  self.total_vsegs)   
    563         byte_stream += self.int2bytes(4,  self.total_vobjs)   
    564         byte_stream += self.int2bytes(4,  self.total_tasks)   
    565         byte_stream += self.int2bytes(4,  self.total_procs)   
    566         byte_stream += self.int2bytes(4,  self.total_irqs)   
    567         byte_stream += self.int2bytes(4,  self.total_coprocs)   
    568         byte_stream += self.int2bytes(4,  self.total_cpports)   
    569         byte_stream += self.int2bytes(4,  self.total_periphs)     
     554        byte_stream += self.int2bytes(4,  self.x_size)
     555        byte_stream += self.int2bytes(4,  self.y_size)
     556        byte_stream += self.int2bytes(4,  self.x_width)
     557        byte_stream += self.int2bytes(4,  self.y_width)
     558        byte_stream += self.int2bytes(4,  self.x_io)
     559        byte_stream += self.int2bytes(4,  self.y_io)
     560        byte_stream += self.int2bytes(4,  self.irq_per_proc)
     561        byte_stream += self.int2bytes(4,  self.use_ramdisk)
     562        byte_stream += self.int2bytes(4,  self.total_globals)
     563        byte_stream += self.int2bytes(4,  self.total_vspaces)
     564        byte_stream += self.int2bytes(4,  self.total_psegs)
     565        byte_stream += self.int2bytes(4,  self.total_vsegs)
     566        byte_stream += self.int2bytes(4,  self.total_vobjs)
     567        byte_stream += self.int2bytes(4,  self.total_tasks)
     568        byte_stream += self.int2bytes(4,  self.total_procs)
     569        byte_stream += self.int2bytes(4,  self.total_irqs)
     570        byte_stream += self.int2bytes(4,  self.total_coprocs)
     571        byte_stream += self.int2bytes(4,  self.total_cpports)
     572        byte_stream += self.int2bytes(4,  self.total_periphs)
    570573        byte_stream += self.str2bytes(32, self.name)
    571574
    572575        if ( verbose ):
    573             print '\n' 
     576            print '\n'
    574577            print 'name          = %s' % self.name
    575578            print 'signature     = %x' % self.signature
    … …  
    578581            print 'x_width       = %d' % self.x_width
    579582            print 'y_width       = %d' % self.y_width
    580             print 'x_io          = %d' % self.x_io 
    581             print 'y_io          = %d' % self.y_io 
     583            print 'x_io          = %d' % self.x_io
     584            print 'y_io          = %d' % self.y_io
    582585            print 'irq_per_proc  = %d' % self.irq_per_proc
    583586            print 'use_ramdisk   = %d' % self.use_ramdisk
    584587            print 'total_globals = %d' % self.total_globals
    585             print 'total_psegs   = %d' % self.total_psegs 
    586             print 'total_vsegs   = %d' % self.total_vsegs 
    587             print 'total_vobjs   = %d' % self.total_vobjs 
    588             print 'total_tasks   = %d' % self.total_tasks 
    589             print 'total_procs   = %d' % self.total_procs 
    590             print 'total_irqs    = %d' % self.total_irqs   
     588            print 'total_psegs   = %d' % self.total_psegs
     589            print 'total_vsegs   = %d' % self.total_vsegs
     590            print 'total_vobjs   = %d' % self.total_vobjs
     591            print 'total_tasks   = %d' % self.total_tasks
     592            print 'total_procs   = %d' % self.total_procs
     593            print 'total_irqs    = %d' % self.total_irqs
    591594            print 'total_coprocs = %d' % self.total_coprocs
    592595            print 'total_cpports = %d' % self.total_cpports
    593596            print 'total_periphs = %d' % self.total_periphs
    594             print '\n' 
     597            print '\n'
    595598
    596599        # clusters array
    … …  
    605608        index = 0
    606609        for cluster in self.clusters:
    607             for pseg in cluster.psegs: 
     610            for pseg in cluster.psegs:
    608611                byte_stream += pseg.cbin( self, verbose, index, cluster )
    609612                index += 1
    … …  
    613616        # vspaces array
    614617        index = 0
    615         for vspace in self.vspaces:   
    616             byte_stream += vspace.cbin( self, verbose, index ) 
     618        for vspace in self.vspaces:
     619            byte_stream += vspace.cbin( self, verbose, index )
    617620            index += 1
    618621
    … …  
    625628            index += 1
    626629        for vspace in self.vspaces:
    627             for vseg in vspace.vsegs: 
     630            for vseg in vspace.vsegs:
    628631                byte_stream += vseg.cbin( self, verbose, index )
    629632                index += 1
    … …  
    638641                index += 1
    639642        for vspace in self.vspaces:
    640             for vseg in vspace.vsegs: 
     643            for vseg in vspace.vsegs:
    641644                for vobj in vseg.vobjs:
    642                     byte_stream += vobj.cbin( self, verbose, index ) 
     645                    byte_stream += vobj.cbin( self, verbose, index )
    643646                    index += 1
    644647
    … …  
    648651        index = 0
    649652        for vspace in self.vspaces:
    650             for task in vspace.tasks: 
     653            for task in vspace.tasks:
    651654                byte_stream += task.cbin( self, verbose, index, vspace )
    652655                index += 1
    … …  
    657660        index = 0
    658661        for cluster in self.clusters:
    659             for proc in cluster.procs: 
     662            for proc in cluster.procs:
    660663                byte_stream += proc.cbin( self, verbose, index )
    661664                index += 1
    662                
     665
    663666        if ( verbose ): print '\n'
    664667
    665668        # irqs array
    666         index = 0 
     669        index = 0
    667670        for cluster in self.clusters:
    668671            for periph in cluster.periphs:
    … …  
    676679        index = 0
    677680        for cluster in self.clusters:
    678             for coproc in cluster.coprocs: 
    679                 byte_stream += coproc.cbin( self, verbose, index ) 
     681            for coproc in cluster.coprocs:
     682                byte_stream += coproc.cbin( self, verbose, index )
    680683                index += 1
    681684
    … …  
    685688        index = 0
    686689        for cluster in self.clusters:
    687             for coproc in cluster.coprocs: 
     690            for coproc in cluster.coprocs:
    688691                for port in coproc.ports:
    689692                    byte_stream += port.cbin( self, verbose, index )
    … …  
    695698        index = 0
    696699        for cluster in self.clusters:
    697             for periph in cluster.periphs: 
     700            for periph in cluster.periphs:
    698701                byte_stream += periph.cbin( self, verbose, index )
    699702                index += 1
    … …  
    701704        return byte_stream
    702705    # end of cbin()
    703  
     706
    704707    #######################
    705     def giet_vsegs( self ):      # compute string for giet_vsegs.ld file 
     708    def giet_vsegs( self ):      # compute string for giet_vsegs.ld file
    706709                                 # required by giet_vm compilation
    707710
    708         # search the vsegs required for the giet_vsegs.ld 
     711        # search the vsegs required for the giet_vsegs.ld
    709712        boot_code_found      = False
    710713        boot_data_found      = False
    … …  
    716719
    717720            if ( vseg.name == 'seg_boot_code' ):
    718                 boot_code_vbase      = vseg.vbase 
     721                boot_code_vbase      = vseg.vbase
    719722                boot_code_size       = vseg.vobjs[0].length
    720723                boot_code_found      = True
    721724
    722             if ( vseg.name == 'seg_boot_data' ): 
    723                 boot_data_vbase      = vseg.vbase 
     725            if ( vseg.name == 'seg_boot_data' ):
     726                boot_data_vbase      = vseg.vbase
    724727                boot_data_size       = vseg.vobjs[0].length
    725728                boot_data_found      = True
    726729
    727730            if ( vseg.name == 'seg_kernel_uncdata' ):
    728                 kernel_uncdata_vbase = vseg.vbase 
     731                kernel_uncdata_vbase = vseg.vbase
    729732                kernel_uncdata_size  = vseg.vobjs[0].length
    730733                kernel_uncdata_found = True
    731734
    732735            if ( vseg.name == 'seg_kernel_data' ):
    733                 kernel_data_vbase    = vseg.vbase 
     736                kernel_data_vbase    = vseg.vbase
    734737                kernel_data_size     = vseg.vobjs[0].length
    735738                kernel_data_found    = True
    736739
    737740            if ( vseg.name == 'seg_kernel_code' ):
    738                 kernel_code_vbase    = vseg.vbase 
     741                kernel_code_vbase    = vseg.vbase
    739742                kernel_code_size     = vseg.vobjs[0].length
    740743                kernel_code_found    = True
    741744
    742745            if ( vseg.name == 'seg_kernel_init' ):
    743                 kernel_init_vbase    = vseg.vbase 
     746                kernel_init_vbase    = vseg.vbase
    744747                kernel_init_size     = vseg.vobjs[0].length
    745748                kernel_init_found    = True
    746749
    747750        # check if all required vsegs have been found
    748         if ( boot_code_found      == False ): 
     751        if ( boot_code_found      == False ):
    749752             print '[genmap error] in giet_vsegs() : seg_boot_code vseg missing'
    750753             sys.exit()
    751754
    752         if ( boot_data_found      == False ): 
     755        if ( boot_data_found      == False ):
    753756             print '[genmap error] in giet_vsegs() : seg_boot_data vseg missing'
    754757             sys.exit()
    755758
    756         if ( kernel_data_found    == False ): 
     759        if ( kernel_data_found    == False ):
    757760             print '[genmap error] in giet_vsegs() : seg_kernel_data vseg missing'
    758761             sys.exit()
    … …  
    771774
    772775        # build string
    773         s =  '/* Generated by genmap for %s */\n'  % self.name 
    774         s += '\n'
    775 
    776         s += 'boot_code_vbase      = 0x%x;\n'   % boot_code_vbase 
    777         s += 'boot_code_size       = 0x%x;\n'   % boot_code_size 
    778         s += '\n'
    779         s += 'boot_data_vbase      = 0x%x;\n'   % boot_data_vbase 
    780         s += 'boot_data_size       = 0x%x;\n'   % boot_data_size 
    781         s += '\n'
    782         s += 'kernel_code_vbase    = 0x%x;\n'   % kernel_code_vbase 
    783         s += 'kernel_code_size     = 0x%x;\n'   % kernel_code_size 
    784         s += '\n'
    785         s += 'kernel_data_vbase    = 0x%x;\n'   % kernel_data_vbase 
    786         s += 'kernel_data_size     = 0x%x;\n'   % kernel_data_size 
    787         s += '\n'
    788         s += 'kernel_uncdata_vbase = 0x%x;\n'   % kernel_uncdata_vbase 
    789         s += 'kernel_uncdata_size  = 0x%x;\n'   % kernel_uncdata_size 
    790         s += '\n'
    791         s += 'kernel_init_vbase    = 0x%x;\n'   % kernel_init_vbase 
    792         s += 'kernel_init_size     = 0x%x;\n'   % kernel_init_size 
     776        s =  '/* Generated by genmap for %s */\n'  % self.name
     777        s += '\n'
     778
     779        s += 'boot_code_vbase      = 0x%x;\n'   % boot_code_vbase
     780        s += 'boot_code_size       = 0x%x;\n'   % boot_code_size
     781        s += '\n'
     782        s += 'boot_data_vbase      = 0x%x;\n'   % boot_data_vbase
     783        s += 'boot_data_size       = 0x%x;\n'   % boot_data_size
     784        s += '\n'
     785        s += 'kernel_code_vbase    = 0x%x;\n'   % kernel_code_vbase
     786        s += 'kernel_code_size     = 0x%x;\n'   % kernel_code_size
     787        s += '\n'
     788        s += 'kernel_data_vbase    = 0x%x;\n'   % kernel_data_vbase
     789        s += 'kernel_data_size     = 0x%x;\n'   % kernel_data_size
     790        s += '\n'
     791        s += 'kernel_uncdata_vbase = 0x%x;\n'   % kernel_uncdata_vbase
     792        s += 'kernel_uncdata_size  = 0x%x;\n'   % kernel_uncdata_size
     793        s += '\n'
     794        s += 'kernel_init_vbase    = 0x%x;\n'   % kernel_init_vbase
     795        s += 'kernel_init_size     = 0x%x;\n'   % kernel_init_size
    793796        s += '\n'
    794797
    795798        return s
    796        
     799
    797800    ########################
    798801    def hard_config( self ):     # compute string for hard_config.h file required by
    … …  
    804807
    805808        # for each peripheral type, define default values
    806         # for pbase address, size, number of components, and channels 
     809        # for pbase address, size, number of components, and channels
    807810        nb_cma       = 0
    808811        cma_channels = 0
    … …  
    889892        for cluster in self.clusters:
    890893            for periph in cluster.periphs:
    891                 if   ( periph.ptype == 'CMA' ): 
     894                if   ( periph.ptype == 'CMA' ):
    892895                    seg_cma_base = periph.pseg.base & 0xFFFFFFFF
    893896                    seg_cma_size = periph.pseg.size
    … …  
    895898                    nb_cma +=1
    896899
    897                 elif ( periph.ptype == 'DMA' ): 
    898                     seg_dma_base = periph.pseg.base & 0xFFFFFFFF 
     900                elif ( periph.ptype == 'DMA' ):
     901                    seg_dma_base = periph.pseg.base & 0xFFFFFFFF
    899902                    seg_dma_size = periph.pseg.size
    900903                    dma_channels = periph.channels
    901904                    nb_dma +=1
    902905
    903                 elif ( periph.ptype == 'FBF' ): 
     906                elif ( periph.ptype == 'FBF' ):
    904907                    seg_fbf_base = periph.pseg.base & 0xFFFFFFFF
    905908                    seg_fbf_size = periph.pseg.size
    … …  
    908911                    nb_fbf +=1
    909912
    910                 elif ( periph.ptype == 'ICU' ): 
     913                elif ( periph.ptype == 'ICU' ):
    911914                    seg_icu_base = periph.pseg.base & 0xFFFFFFFF
    912915                    seg_icu_size = periph.pseg.size
    … …  
    920923                    nb_iob +=1
    921924
    922                 elif ( periph.ptype == 'IOC' ): 
     925                elif ( periph.ptype == 'IOC' ):
    923926                    seg_ioc_base = periph.pseg.base & 0xFFFFFFFF
    924927                    seg_ioc_size = periph.pseg.size
    … …  
    956959                    nb_sim +=1
    957960
    958                 elif ( periph.ptype == 'NIC' ): 
     961                elif ( periph.ptype == 'NIC' ):
    959962                    seg_nic_base = periph.pseg.base & 0xFFFFFFFF
    960963                    seg_nic_size = periph.pseg.size
    … …  
    962965                    nb_nic +=1
    963966
    964                 elif ( periph.ptype == 'PIC' ): 
     967                elif ( periph.ptype == 'PIC' ):
    965968                    seg_pic_base = periph.pseg.base & 0xFFFFFFFF
    966969                    seg_pic_size = periph.pseg.size
    967970                    pic_channels = periph.channels
    968971                    nb_pic +=1
    969    
    970                 elif ( periph.ptype == 'TIM' ): 
     972
     973                elif ( periph.ptype == 'TIM' ):
    971974                    seg_tim_base = periph.pseg.base & 0xFFFFFFFF
    972975                    seg_tim_size = periph.pseg.size
    973976                    tim_channels = periph.channels
    974977                    nb_tim +=1
    975    
     978
    976979                elif ( periph.ptype == 'TTY' ):
    977980                    seg_tty_base = periph.pseg.base & 0xFFFFFFFF
    … …  
    979982                    tty_channels = periph.channels
    980983                    nb_tty +=1
    981    
    982                 elif ( periph.ptype == 'XCU' ): 
     984
     985                elif ( periph.ptype == 'XCU' ):
    983986                    seg_xcu_base = periph.pseg.base & 0xFFFFFFFF
    984987                    seg_xcu_size = periph.pseg.size
    … …  
    986989                    xcu_arg      = periph.arg
    987990                    nb_xcu +=1
    988    
     991
    989992        # don't mix ICU and XCU
    990         assert ( nb_icu*nb_xcu == 0 )   
     993        assert ( nb_icu*nb_xcu == 0 )
    991994
    992995        # no more than two access to external peripherals
    993         assert ( nb_fbf <= 2 ) 
    994         assert ( nb_cma <= 2 ) 
    995         assert ( nb_ioc <= 2 ) 
    996         assert ( nb_nic <= 2 ) 
    997         assert ( nb_tim <= 2 ) 
    998         assert ( nb_tty <= 2 ) 
     996        assert ( nb_fbf <= 2 )
     997        assert ( nb_cma <= 2 )
     998        assert ( nb_ioc <= 2 )
     999        assert ( nb_nic <= 2 )
     1000        assert ( nb_tim <= 2 )
     1001        assert ( nb_tty <= 2 )
    9991002        assert ( nb_pic <= 2 )
    10001003
    … …  
    10191022        for vseg in self.globs:
    10201023            if ( vseg.name == 'seg_boot_mapping' ):
    1021                 boot_mapping_base       = vseg.vbase 
     1024                boot_mapping_base       = vseg.vbase
    10221025                boot_mapping_size       = vseg.vobjs[0].length
    10231026                boot_mapping_identity   = vseg.identity
    … …  
    10251028
    10261029            if ( vseg.name == 'seg_boot_code' ):
    1027                 boot_code_base          = vseg.vbase 
     1030                boot_code_base          = vseg.vbase
    10281031                boot_code_size          = vseg.vobjs[0].length
    10291032                boot_code_identity      = vseg.identity
    10301033                boot_code_found         = True
    10311034
    1032             if ( vseg.name == 'seg_boot_data' ): 
    1033                 boot_data_base          = vseg.vbase 
     1035            if ( vseg.name == 'seg_boot_data' ):
     1036                boot_data_base          = vseg.vbase
    10341037                boot_data_size          = vseg.vobjs[0].length
    10351038                boot_data_identity      = vseg.identity
    … …  
    10371040
    10381041            if ( vseg.name == 'seg_boot_stack' ):
    1039                 boot_stack_base         = vseg.vbase 
     1042                boot_stack_base         = vseg.vbase
    10401043                boot_stack_size         = vseg.vobjs[0].length
    10411044                boot_stack_identity     = vseg.identity
    … …  
    10471050             sys.exit()
    10481051
    1049         if ( (boot_code_found == False) or (boot_code_identity == False) ): 
     1052        if ( (boot_code_found == False) or (boot_code_identity == False) ):
    10501053             print '[genmap error] in hard_config() : seg_boot_code missing or not ident'
    10511054             sys.exit()
    10521055
    1053         if ( (boot_data_found == False) or (boot_data_identity == False) ): 
     1056        if ( (boot_data_found == False) or (boot_data_identity == False) ):
    10541057             print '[genmap error] in hard_config() : seg_boot_data missing or not ident'
    10551058             sys.exit()
    … …  
    10761079
    10771080        # build string
    1078         s =  '/* Generated by genmap for %s */\n'  % self.name   
     1081        s =  '/* Generated by genmap for %s */\n'  % self.name
    10791082        s += '\n'
    10801083        s += '#ifndef HARD_CONFIG_H\n'
    … …  
    10821085        s += '\n'
    10831086
    1084         s += '/* General platform parameters */\n' 
     1087        s += '/* General platform parameters */\n'
    10851088        s += '\n'
    10861089        s += '#define X_SIZE                 %d\n'    % self.x_size
    … …  
    10881091        s += '#define X_WIDTH                %d\n'    % self.x_width
    10891092        s += '#define Y_WIDTH                %d\n'    % self.y_width
     1093        s += '#define P_WIDTH                %d\n'    % self.p_width
    10901094        s += '#define X_IO                   %d\n'    % self.x_io
    1091         s += '#define Y_IO                   %d\n'    % self.y_io 
     1095        s += '#define Y_IO                   %d\n'    % self.y_io
    10921096        s += '#define NB_PROCS_MAX           %d\n'    % self.procs_max
    10931097        s += '#define IRQ_PER_PROCESSOR      %d\n'    % self.irq_per_proc
    … …  
    10961100        s += '\n'
    10971101
    1098         s += '/* Peripherals */\n' 
     1102        s += '/* Peripherals */\n'
    10991103        s += '\n'
    11001104        s += '#define NB_TTY_CHANNELS        %d\n'    % tty_channels
    … …  
    11231127        s += '/* base addresses and sizes for physical segments */\n'
    11241128        s += '\n'
    1125         s += '#define SEG_RAM_BASE           0x%x\n'  % self.ram_base           
    1126         s += '#define SEG_RAM_SIZE           0x%x\n'  % self.ram_size           
    1127         s += '\n'
    1128         s += '#define SEG_CMA_BASE           0x%x\n'  % seg_cma_base           
    1129         s += '#define SEG_CMA_SIZE           0x%x\n'  % seg_cma_size           
    1130         s += '\n'
    1131         s += '#define SEG_DMA_BASE           0x%x\n'  % seg_dma_base           
    1132         s += '#define SEG_DMA_SIZE           0x%x\n'  % seg_dma_size           
    1133         s += '\n'
    1134         s += '#define SEG_FBF_BASE           0x%x\n'  % seg_fbf_base           
    1135         s += '#define SEG_FBF_SIZE           0x%x\n'  % seg_fbf_size           
    1136         s += '\n'
    1137         s += '#define SEG_ICU_BASE           0x%x\n'  % seg_icu_base           
    1138         s += '#define SEG_ICU_SIZE           0x%x\n'  % seg_icu_size           
    1139         s += '\n'
    1140         s += '#define SEG_IOB_BASE           0x%x\n'  % seg_iob_base           
    1141         s += '#define SEG_IOB_SIZE           0x%x\n'  % seg_iob_size           
    1142         s += '\n'
    1143         s += '#define SEG_IOC_BASE           0x%x\n'  % seg_ioc_base           
    1144         s += '#define SEG_IOC_SIZE           0x%x\n'  % seg_ioc_size           
    1145         s += '\n'
    1146         s += '#define SEG_MMC_BASE           0x%x\n'  % seg_mmc_base           
    1147         s += '#define SEG_MMC_SIZE           0x%x\n'  % seg_mmc_size           
    1148         s += '\n'
    1149         s += '#define SEG_MWR_BASE           0x%x\n'  % seg_mwr_base           
    1150         s += '#define SEG_MWR_SIZE           0x%x\n'  % seg_mwr_size           
    1151         s += '\n'
    1152         s += '#define SEG_ROM_BASE           0x%x\n'  % seg_rom_base           
    1153         s += '#define SEG_ROM_SIZE           0x%x\n'  % seg_rom_size           
    1154         s += '\n'
    1155         s += '#define SEG_SIM_BASE           0x%x\n'  % seg_sim_base           
    1156         s += '#define SEG_SIM_SIZE           0x%x\n'  % seg_sim_size           
    1157         s += '\n'
    1158         s += '#define SEG_NIC_BASE           0x%x\n'  % seg_nic_base           
    1159         s += '#define SEG_NIC_SIZE           0x%x\n'  % seg_nic_size           
    1160         s += '\n'
    1161         s += '#define SEG_PIC_BASE           0x%x\n'  % seg_pic_base           
    1162         s += '#define SEG_PIC_SIZE           0x%x\n'  % seg_pic_size           
    1163         s += '\n'
    1164         s += '#define SEG_TIM_BASE           0x%x\n'  % seg_tim_base           
    1165         s += '#define SEG_TIM_SIZE           0x%x\n'  % seg_tim_size           
    1166         s += '\n'
    1167         s += '#define SEG_TTY_BASE           0x%x\n'  % seg_tty_base           
    1168         s += '#define SEG_TTY_SIZE           0x%x\n'  % seg_tty_size           
    1169         s += '\n'
    1170         s += '#define SEG_XCU_BASE           0x%x\n'  % seg_xcu_base           
    1171         s += '#define SEG_XCU_SIZE           0x%x\n'  % seg_xcu_size           
     1129        s += '#define SEG_RAM_BASE           0x%x\n'  % self.ram_base
     1130        s += '#define SEG_RAM_SIZE           0x%x\n'  % self.ram_size
     1131        s += '\n'
     1132        s += '#define SEG_CMA_BASE           0x%x\n'  % seg_cma_base
     1133        s += '#define SEG_CMA_SIZE           0x%x\n'  % seg_cma_size
     1134        s += '\n'
     1135        s += '#define SEG_DMA_BASE           0x%x\n'  % seg_dma_base
     1136        s += '#define SEG_DMA_SIZE           0x%x\n'  % seg_dma_size
     1137        s += '\n'
     1138        s += '#define SEG_FBF_BASE           0x%x\n'  % seg_fbf_base
     1139        s += '#define SEG_FBF_SIZE           0x%x\n'  % seg_fbf_size
     1140        s += '\n'
     1141        s += '#define SEG_ICU_BASE           0x%x\n'  % seg_icu_base
     1142        s += '#define SEG_ICU_SIZE           0x%x\n'  % seg_icu_size
     1143        s += '\n'
     1144        s += '#define SEG_IOB_BASE           0x%x\n'  % seg_iob_base
     1145        s += '#define SEG_IOB_SIZE           0x%x\n'  % seg_iob_size
     1146        s += '\n'
     1147        s += '#define SEG_IOC_BASE           0x%x\n'  % seg_ioc_base
     1148        s += '#define SEG_IOC_SIZE           0x%x\n'  % seg_ioc_size
     1149        s += '\n'
     1150        s += '#define SEG_MMC_BASE           0x%x\n'  % seg_mmc_base
     1151        s += '#define SEG_MMC_SIZE           0x%x\n'  % seg_mmc_size
     1152        s += '\n'
     1153        s += '#define SEG_MWR_BASE           0x%x\n'  % seg_mwr_base
     1154        s += '#define SEG_MWR_SIZE           0x%x\n'  % seg_mwr_size
     1155        s += '\n'
     1156        s += '#define SEG_ROM_BASE           0x%x\n'  % seg_rom_base
     1157        s += '#define SEG_ROM_SIZE           0x%x\n'  % seg_rom_size
     1158        s += '\n'
     1159        s += '#define SEG_SIM_BASE           0x%x\n'  % seg_sim_base
     1160        s += '#define SEG_SIM_SIZE           0x%x\n'  % seg_sim_size
     1161        s += '\n'
     1162        s += '#define SEG_NIC_BASE           0x%x\n'  % seg_nic_base
     1163        s += '#define SEG_NIC_SIZE           0x%x\n'  % seg_nic_size
     1164        s += '\n'
     1165        s += '#define SEG_PIC_BASE           0x%x\n'  % seg_pic_base
     1166        s += '#define SEG_PIC_SIZE           0x%x\n'  % seg_pic_size
     1167        s += '\n'
     1168        s += '#define SEG_TIM_BASE           0x%x\n'  % seg_tim_base
     1169        s += '#define SEG_TIM_SIZE           0x%x\n'  % seg_tim_size
     1170        s += '\n'
     1171        s += '#define SEG_TTY_BASE           0x%x\n'  % seg_tty_base
     1172        s += '#define SEG_TTY_SIZE           0x%x\n'  % seg_tty_size
     1173        s += '\n'
     1174        s += '#define SEG_XCU_BASE           0x%x\n'  % seg_xcu_base
     1175        s += '#define SEG_XCU_SIZE           0x%x\n'  % seg_xcu_size
    11721176        s += '\n'
    11731177        s += '#define SEG_RDK_BASE           0x%x\n'  % seg_rdk_base
    … …  
    11921196        s += '#define SEG_BOOT_STACK_SIZE    0x%x\n'  % boot_stack_size
    11931197        s += '#endif\n'
    1194        
     1198
    11951199        return s
    11961200
    … …  
    11991203    #######################
    12001204    def netbsd_dts( self ):    # compute string for netbsd.dts file generation,
    1201                                # used for netbsd configuration 
     1205                               # used for netbsd configuration
    12021206        # header
    12031207        s =  '/dts-v1/;\n'
    12041208        s += '\n'
    12051209        s += '/{\n'
    1206         s += '  #address-cells = <2>;\n' 
    1207         s += '  #size-cells    = <1>;\n' 
     1210        s += '  #address-cells = <2>;\n'
     1211        s += '  #size-cells    = <1>;\n'
    12081212
    12091213        # cpus (for each cluster)
    … …  
    12141218        for cluster in self.clusters:
    12151219            for proc in cluster.procs:
    1216                 proc_id = (((cluster.x << self.y_width) + cluster.y) * self.procs_max) + proc.lpid
     1220                proc_id = (((cluster.x << self.y_width) + cluster.y) << self.p_width) + proc.lpid
    12171221
    12181222                s += '    Mips,32@0x%x {\n'                % proc_id
    … …  
    12441248        for cluster in self.clusters:
    12451249
    1246             # research XCU component 
     1250            # research XCU component
    12471251            found_xcu = False
    12481252            for periph in cluster.periphs:
    1249                 if ( (periph.ptype == 'XCU') ): 
     1253                if ( (periph.ptype == 'XCU') ):
    12501254                    found_xcu = True
    12511255                    xcu = periph
    … …  
    12641268                    for lpid in xrange ( len(cluster.procs) ):        # destination processor index
    12651269                        for itid in xrange ( self.irq_per_proc ):     # input irq index on processor
    1266                             proc_id = (((cluster.x << self.y_width) + cluster.y) * self.procs_max) + lpid
     1270                            cluster_xy = (cluster.x << self.y_width) + cluster.y
     1271                            proc_id    = (cluster_xy << self.p_width) + lpid
    12671272                            s += '    out@%d {\n' % output_id
    12681273                            s += '      device_type = "soclib:xicu:filter";\n'
    12691274                            s += '      irq         = <&{/cpus/Mips,32@0x%x} %d>;\n' % (proc_id, itid)
    1270                             s += '      output_line = <%d>;\n' % output_id 
     1275                            s += '      output_line = <%d>;\n' % output_id
    12711276                            s += '      parent      = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
    12721277                            s += '    };\n'
    … …  
    12791284            found_pic = False
    12801285            for periph in cluster.periphs:
    1281                 if ( periph.ptype == 'PIC' ): 
     1286                if ( periph.ptype == 'PIC' ):
    12821287                    found_pic = True
    12831288                    pic  = periph
    … …  
    12891294                    s += '    device_type = "soclib:pic:root";\n'
    12901295                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
    1291                     s += '    input_lines = <%d>;\n'    % periph.channels 
     1296                    s += '    input_lines = <%d>;\n'    % periph.channels
    12921297                    s += '  };\n'
    12931298
    12941299            if ( (found_xcu == False) and (found_pic == False) and (len(cluster.periphs) > 0) ):
    12951300                print '[genmap error] in netbsd_dts() : No XCU/PIC in cluster(%d,%d)' % (cluster.x, cluster.y)
    1296                 sys.exit(1)   
    1297              
     1301                sys.exit(1)
     1302
    12981303            if ( found_pic == True ):  irq_tgt = pic
    12991304            else:                      irq_tgt = xcu
    1300            
     1305
    13011306            # get all others peripherals in cluster
    13021307            for periph in cluster.periphs:
    … …  
    13171322                        hwi_id = 0xFFFFFFFF
    13181323                        for irq in xcu.irqs:
    1319                             if ( (irq.isrtype == 'ISR_DMA') and (irq.channel == channel) ): 
     1324                            if ( (irq.isrtype == 'ISR_DMA') and (irq.channel == channel) ):
    13201325                                hwi_id = irq.srcid
    13211326                        if ( hwi_id == 0xFFFFFFFF ):
    … …  
    13311336                        s += '    };\n'
    13321337
    1333                     s += '  };\n'       
     1338                    s += '  };\n'
    13341339
    13351340                # research MMC component
    … …  
    13481353                    s += '    irq         = <&{/%s@0x%x}  %d>;\n' % (irq_tgt.pseg.name, irq_tgt.pseg.base, irq_in)
    13491354                    s += '    reg         = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
    1350                     s += '  };\n' 
     1355                    s += '  };\n'
    13511356
    13521357                # research FBF component
    1353                 elif ( periph.ptype == 'FBF' ): 
     1358                elif ( periph.ptype == 'FBF' ):
    13541359
    13551360                    s += '  %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
    … …  
    13621367
    13631368                # research IOC component
    1364                 elif ( periph.ptype == 'IOC' ): 
     1369                elif ( periph.ptype == 'IOC' ):
    13651370
    13661371                    if   ( periph.subtype == 'BDV' ):
    … …  
    14231428                    s += '    device_type   = "soclib:tty";\n'
    14241429                    s += '    reg           = <0x%x  0x%x  0x%x>;\n' % (msb, lsb, size)
    1425                     s += '    channel_count = < %d >;\n' % periph.channels 
     1430                    s += '    channel_count = < %d >;\n' % periph.channels
    14261431
    14271432                    # multi-channels : get HWI index (to XCU or PIC) for each channel
    … …  
    14291434                        hwi_id = 0xFFFFFFFF
    14301435                        for irq in irq_tgt.irqs:
    1431                             if ( (irq.isrtype == 'ISR_TTY_RX') and (irq.channel == channel) ): 
     1436                            if ( (irq.isrtype == 'ISR_TTY_RX') and (irq.channel == channel) ):
    14321437                                hwi_id = irq.srcid
    14331438                        if ( hwi_id == 0xFFFFFFFF ):
    … …  
    14441449
    14451450                    s += '  };\n'
    1446    
     1451
    14471452                # research IOB component
    14481453                elif ( periph.ptype == 'IOB' ):
    … …  
    14541459
    14551460                # research NIC component
    1456                 elif ( periph.ptype == 'NIC' ): 
     1461                elif ( periph.ptype == 'NIC' ):
    14571462
    14581463                    s += '  %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
    … …  
    14661471                        hwi_id = 0xFFFFFFFF
    14671472                        for irq in irq_tgt.irqs:
    1468                             if ( (irq.isrtype == 'ISR_NIC_RX') and (irq.channel == channel) ): 
     1473                            if ( (irq.isrtype == 'ISR_NIC_RX') and (irq.channel == channel) ):
    14691474                                hwi_id = irq.srcid
    14701475                        if ( hwi_id == 0xFFFFFFFF ):
    … …  
    14821487                        hwi_id = 0xFFFFFFFF
    14831488                        for irq in irq_tgt.irqs:
    1484                             if ( (irq.isrtype == 'ISR_NIC_TX') and (irq.channel == channel) ): 
     1489                            if ( (irq.isrtype == 'ISR_NIC_TX') and (irq.channel == channel) ):
    14851490                                hwi_id = irq.srcid
    14861491                        if ( hwi_id == 0xFFFFFFFF ):
    … …  
    14951500                        s += '      parent      = <&{/%s@0x%x}>;\n' % (periph.pseg.name, periph.pseg.base)
    14961501                        s += '    };\n'
    1497  
     1502
    14981503                    s += '  };\n'
    14991504
    15001505                # research CMA component
    1501                 elif ( periph.ptype == 'CMA' ): 
     1506                elif ( periph.ptype == 'CMA' ):
    15021507
    15031508                    s += '  %s@0x%x {\n'  % (periph.pseg.name, periph.pseg.base)
    … …  
    15101515                        hwi_id = 0xFFFFFFFF
    15111516                        for irq in irq_tgt.irqs:
    1512                             if ( (irq.isrtype == 'ISR_CMA') and (irq.channel == channel) ): 
     1517                            if ( (irq.isrtype == 'ISR_CMA') and (irq.channel == channel) ):
    15131518                                hwi_id = irq.srcid
    15141519                        if ( hwi_id == 0xFFFFFFFF ):
    … …  
    15271532
    15281533                # research TIM component
    1529                 elif ( periph.ptype == 'TIM' ): 
     1534                elif ( periph.ptype == 'TIM' ):
    15301535
    15311536                    print '[genmap error] in netbsd_dts() : TIM peripheral not supported by NetBSD'
    … …  
    15391544
    15401545                # research ICU component
    1541                 elif ( periph.ptype == 'ICU' ): 
     1546                elif ( periph.ptype == 'ICU' ):
    15421547                    print '[genmap error] in netbsd_dts() : ICU peripheral not supported by NetBSD'
    15431548                    sys.exit(1)
    … …  
    15491554        s += '    #size-cells = <0>;\n'
    15501555        for cluster in self.clusters:
    1551             s += '    cluster@%d,%d {\n' % (cluster.x, cluster.y) 
     1556            s += '    cluster@%d,%d {\n' % (cluster.x, cluster.y)
    15521557            s += '      reg     = <%d %d>;\n' % (cluster.x, cluster.y)
    15531558            s += '      devices = <\n'
    15541559
    1555             offset = ((cluster.x << self.y_width) + cluster.y) * self.procs_max
     1560            offset = ((cluster.x << self.y_width) + cluster.y) << self.p_width
    15561561            for proc in cluster.procs:
    15571562                s += '                &{/cpus/Mips,32@0x%x}\n' % (offset + proc.lpid)
    … …  
    15691574    ###########################
    15701575    def almos_archinfo( self ):    # compute string for arch.info file generation,
    1571                                    # used for almos configuration 
     1576                                   # used for almos configuration
    15721577        # header
    15731578        s =  '# arch.info file generated by genmap for %s\n' % self.name
    … …  
    15941599            # search a RAM
    15951600            for pseg in cluster.psegs:
    1596                 if ( pseg.segtype == 'RAM' ): 
     1601                if ( pseg.segtype == 'RAM' ):
    15971602                    ram     = pseg
    15981603                    nb_devs += 1
    … …  
    16051610
    16061611                for periph in cluster.periphs:
    1607                     if ( periph.ptype == 'XCU' ): 
     1612                    if ( periph.ptype == 'XCU' ):
    16081613                        # scan irqs
    16091614                        for irq in periph.irqs:
    … …  
    16141619            # Build the cluster description
    16151620            s += '[CLUSTER]\n'
    1616             s += '         CID=%d\n'        % cluster_id 
    1617             s += '         ARCH_CID=0x%x\n' % ((cluster.x << self.y_width) + cluster.y) 
     1621            s += '         CID=%d\n'        % cluster_id
     1622            s += '         ARCH_CID=0x%x\n' % ((cluster.x << self.y_width) + cluster.y)
    16181623            s += '         CPU_NR=%d\n'     % nb_cpus
    16191624            s += '         DEV_NR=%d\n'     % nb_devs
    1620            
     1625
    16211626
    16221627            # Handling RAM when cluster contain a RAM
    … …  
    16251630                size  = ram.size
    16261631                irqid = -1
    1627                 s += '         DEVID=RAM' 
     1632                s += '         DEVID=RAM'
    16281633                s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
    16291634
    … …  
    16331638                size  = periph.pseg.size
    16341639
    1635                 if   ( periph.ptype == 'XCU' ): 
    1636 
    1637                     s += '         DEVID=XICU' 
     1640                if   ( periph.ptype == 'XCU' ):
     1641
     1642                    s += '         DEVID=XICU'
    16381643                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
    16391644
    1640                 elif ( (periph.ptype == 'TTY') 
     1645                elif ( (periph.ptype == 'TTY')
    16411646                       and (tty_irq_id != None) ):
    16421647
    1643                     s += '         DEVID=TTY' 
     1648                    s += '         DEVID=TTY'
    16441649                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=%d\n' % ( base, size, tty_irq_id )
    16451650
    1646                 elif ( (periph.ptype == 'DMA') 
     1651                elif ( (periph.ptype == 'DMA')
    16471652                       and (dma_irq_id != None) ):
    16481653
    … …  
    16581663                       and (bdv_irq_id != None) ):
    16591664
    1660                     s += '         DEVID=BLKDEV' 
     1665                    s += '         DEVID=BLKDEV'
    16611666                    s += '  BASE=0x%x  SIZE=0x%x  IRQ=%d\n' % ( base, size, bdv_irq_id )
    16621667
    16631668                elif ( periph.ptype == 'PIC' ):
    16641669
    1665                         s += '         DEVID=IOPIC' 
     1670                        s += '         DEVID=IOPIC'
    16661671                        s += '  BASE=0x%x  SIZE=0x%x  IRQ=-1\n' % ( base, size )
    16671672
    … …  
    16711676                    print '# peripheral type %s/%s not supported yet\n' \
    16721677                          % ( periph.ptype, periph.subtype )
    1673                  
     1678
    16741679            cluster_id += 1
    16751680
    … …  
    16891694###########################################################################################
    16901695    def __init__( self,
    1691                   x, 
     1696                  x,
    16921697                  y ):
    1693        
     1698
    16941699        self.index       = 0             # global index (set by Mapping constructor)
    16951700        self.x           = x             # x coordinate
    … …  
    17061711
    17071712        s = '        <cluster x="%d" y="%d" >\n' % (self.x, self.y)
    1708         for pseg in self.psegs:   s += pseg.xml() 
     1713        for pseg in self.psegs:   s += pseg.xml()
    17091714        for proc in self.procs:   s += proc.xml()
    1710         for copr in self.coprocs: s += copr.xml() 
    1711         for peri in self.periphs: s += peri.xml() 
     1715        for copr in self.coprocs: s += copr.xml()
     1716        for peri in self.periphs: s += peri.xml()
    17121717        s += '        </cluster>\n'
    17131718
    … …  
    17261731            sys.exit(1)
    17271732
    1728         # compute global index for first pseg 
     1733        # compute global index for first pseg
    17291734        if ( len(self.psegs) > 0 ):
    17301735            pseg_id = self.psegs[0].index
    … …  
    17321737            pseg_id = 0
    17331738
    1734         # compute global index for first proc 
     1739        # compute global index for first proc
    17351740        if ( len(self.procs) > 0 ):
    17361741            proc_id = self.procs[0].index
    … …  
    17381743            proc_id = 0
    17391744
    1740         # compute global index for first coproc 
     1745        # compute global index for first coproc
    17411746        if ( len(self.coprocs) > 0 ):
    17421747            coproc_id = self.coprocs[0].index
    … …  
    17441749            coproc_id = 0
    17451750
    1746         # compute global index for first periph 
     1751        # compute global index for first periph
    17471752        if ( len(self.periphs) > 0 ):
    17481753            periph_id = self.periphs[0].index
    … …  
    17611766        byte_stream += mapping.int2bytes( 4 , len( self.periphs ) )    # number of periphs in cluster
    17621767        byte_stream += mapping.int2bytes( 4 , periph_id )              # first periph global index
    1763  
     1768
    17641769        if ( verbose ):
    17651770            print 'nb_psegs   = %d' %  len( self.psegs )
    … …  
    17771782class Vspace( object ):
    17781783###########################################################################################
    1779     def __init__( self, 
    1780                   name, 
     1784    def __init__( self,
     1785                  name,
    17811786                  startname ):
    17821787
    … …  
    17841789        self.name      = name           # vspace name
    17851790        self.startname = startname      # name of vobj containing the start_vector
    1786         self.vsegs     = []             
     1791        self.vsegs     = []
    17871792        self.tasks     = []
    17881793
    … …  
    17941799        s =  '        <vspace name="%s" startname="%s" >\n' % ( self.name, self.startname )
    17951800        for vseg in self.vsegs: s += vseg.xml()
    1796         for task in self.tasks: s += task.xml() 
     1801        for task in self.tasks: s += task.xml()
    17971802        s += '        </vspace>\n'
    17981803
    … …  
    18201825                  % ( self.startname, self.name )
    18211826            sys.exit(1)
    1822  
     1827
    18231828        # compute first vseg, vobj, task global index
    18241829        first_vseg_id = self.vsegs[0].index
    18251830        first_vobj_id = self.vsegs[0].vobjs[0].index
    18261831        first_task_id = self.tasks[0].index
    1827        
     1832
    18281833        # compute number of vobjs, tasks, vsegs
    18291834        nb_vsegs = len( self.vsegs )
    … …  
    18351840        byte_stream = bytearray()
    18361841        byte_stream += mapping.str2bytes( 32, self.name )         # vspace name
    1837         byte_stream += mapping.int2bytes( 4,  vobj_start_id )     # vobj start_vector 
     1842        byte_stream += mapping.int2bytes( 4,  vobj_start_id )     # vobj start_vector
    18381843        byte_stream += mapping.int2bytes( 4,  nb_vsegs )          # number of vsegs
    18391844        byte_stream += mapping.int2bytes( 4,  nb_vobjs )          # number of vobjs
    … …  
    18571862class Task( object ):
    18581863###########################################################################################
    1859     def __init__( self, 
    1860                   name, 
    1861                   trdid, 
    1862                   x, 
     1864    def __init__( self,
     1865                  name,
     1866                  trdid,
     1867                  x,
    18631868                  y,
    1864                   p, 
    1865                   stackname, 
    1866                   heapname, 
     1869                  p,
     1870                  stackname,
     1871                  heapname,
    18671872                  startid,
    1868                   usetty = False, 
    1869                   usenic = False, 
     1873                  usetty = False,
     1874                  usenic = False,
    18701875                  usecma = False,
    1871                   usehba = False, 
     1876                  usehba = False,
    18721877                  usetim = False ):
    18731878
    … …  
    18751880        self.name      = name          # tsk name
    18761881        self.trdid     = trdid         # task index (unique in vspace)
    1877         self.x         = x             # cluster x coordinate 
    1878         self.y         = y             # cluster y coordinate 
    1879         self.p         = p             # processor local index 
     1882        self.x         = x             # cluster x coordinate
     1883        self.y         = y             # cluster y coordinate
     1884        self.p         = p             # processor local index
    18801885        self.stackname = stackname     # name of vobj containing the stack
    18811886        self.heapname  = heapname      # name of vobj containing the heap
    … …  
    18991904        s += ' heapname="%s"'              % self.heapname
    19001905        s += ' startid="%d"'               % self.startid
    1901         if self.usetty != 0: s += ' usetty="1"' 
    1902         if self.usenic != 0: s += ' usenic="1"' 
    1903         if self.usecma != 0: s += ' usehba="1"' 
    1904         if self.usehba != 0: s += ' usehba="1"' 
    1905         if self.usetim != 0: s += ' usehba="1"' 
    1906         s += ' />\n'           
     1906        if self.usetty != 0: s += ' usetty="1"'
     1907        if self.usenic != 0: s += ' usenic="1"'
     1908        if self.usecma != 0: s += ' usehba="1"'
     1909        if self.usehba != 0: s += ' usehba="1"'
     1910        if self.usetim != 0: s += ' usehba="1"'
     1911        s += ' />\n'
    19071912
    19081913        return s
    19091914
    19101915    #####################################################
    1911     def cbin( self, mapping, verbose, expected, vspace ):  # C binary data structure for Task 
     1916    def cbin( self, mapping, verbose, expected, vspace ):  # C binary data structure for Task
    19121917
    19131918        if ( verbose ):
    … …  
    19271932        for vseg in vspace.vsegs:
    19281933            if ( vseg.vobjs[0].name == self.stackname ):
    1929                 vobj_stack_id = vseg.vobjs[0].index 
     1934                vobj_stack_id = vseg.vobjs[0].index
    19301935        if ( vobj_stack_id == 0xFFFFFFFF ):
    19311936            print '[genmap error] in Task.cbin() : stackname %s not found for task %s in vspace %s' \
    … …  
    19501955        byte_stream += mapping.int2bytes( 4,  vobj_stack_id )   # stack vobj local index
    19511956        byte_stream += mapping.int2bytes( 4,  vobj_heap_id )    # heap vobj local index
    1952         byte_stream += mapping.int2bytes( 4,  self.startid )    # index in start vector   
    1953         byte_stream += mapping.int2bytes( 4,  self.usetty )     # TTY channel required     
    1954         byte_stream += mapping.int2bytes( 4,  self.usenic )     # NIC channel required     
    1955         byte_stream += mapping.int2bytes( 4,  self.usecma )     # CMA channel required     
    1956         byte_stream += mapping.int2bytes( 4,  self.usehba )     # IOC channel required     
     1957        byte_stream += mapping.int2bytes( 4,  self.startid )    # index in start vector
     1958        byte_stream += mapping.int2bytes( 4,  self.usetty )     # TTY channel required
     1959        byte_stream += mapping.int2bytes( 4,  self.usenic )     # NIC channel required
     1960        byte_stream += mapping.int2bytes( 4,  self.usecma )     # CMA channel required
     1961        byte_stream += mapping.int2bytes( 4,  self.usehba )     # IOC channel required
    19571962        byte_stream += mapping.int2bytes( 4,  self.usetim )     # TIM channel required
    19581963
    … …  
    19601965            print 'clusterid  = %d' %  cluster_id
    19611966            print 'lpid       = %d' %  self.p
    1962             print 'trdid      = %d' %  self.trdid 
    1963             print 'stackid    = %d' %  vobj_stack_id 
    1964             print 'heapid     = %d' %  vobj_heap_id 
    1965             print 'startid    = %d' %  self.startid   
    1966      
     1967            print 'trdid      = %d' %  self.trdid
     1968            print 'stackid    = %d' %  vobj_stack_id
     1969            print 'heapid     = %d' %  vobj_heap_id
     1970            print 'startid    = %d' %  self.startid
     1971
    19671972        return byte_stream
    19681973
    … …  
    19701975class Vseg( object ):
    19711976###########################################################################################
    1972     def __init__( self, 
    1973                   name, 
    1974                   vbase, 
    1975                   mode, 
    1976                   x, 
    1977                   y, 
    1978                   psegname, 
     1977    def __init__( self,
     1978                  name,
     1979                  vbase,
     1980                  mode,
     1981                  x,
     1982                  y,
     1983                  psegname,
    19791984                  identity = False,
    19801985                  local    = False ):
    … …  
    19841989        self.index    = 0                   # global index ( set by addVseg() )
    19851990        self.name     = name                # vseg name
    1986         self.vbase    = vbase & 0xFFFFFFFF  # virtual base address in vspace 
     1991        self.vbase    = vbase & 0xFFFFFFFF  # virtual base address in vspace
    19871992        self.mode     = mode                # CXWU access rights
    1988         self.x        = x                   # x coordinate of destination cluster 
     1993        self.x        = x                   # x coordinate of destination cluster
    19891994        self.y        = y                   # y coordinate of destination cluster
    19901995        self.psegname = psegname            # name of pseg in destination cluster
    … …  
    19952000
    19962001    ################
    1997     def xml( self ):  # xml for one vseg 
     2002    def xml( self ):  # xml for one vseg
    19982003
    19992004        s =  '            <vseg name="%s" vbase="0x%x" mode="%s" x="%d" y="%d" psegname="%s"' \
    … …  
    20332038        # compute numerical value for mode
    20342039        mode_id = 0xFFFFFFFF
    2035         for x in xrange( len(VSEGMODES) ): 
    2036             if ( self.mode == VSEGMODES[x] ): 
     2040        for x in xrange( len(VSEGMODES) ):
     2041            if ( self.mode == VSEGMODES[x] ):
    20372042                mode_id = x
    20382043        if ( mode_id == 0xFFFFFFFF ):
    … …  
    20412046
    20422047        # compute vobj_id
    2043         vobj_id = self.vobjs[0].index 
     2048        vobj_id = self.vobjs[0].index
    20442049
    20452050        byte_stream = bytearray()
    2046         byte_stream += mapping.str2bytes( 32, self.name )       # vseg name 
     2051        byte_stream += mapping.str2bytes( 32, self.name )       # vseg name
    20472052        byte_stream += mapping.int2bytes( 4,  self.vbase )      # virtual base address
    20482053        byte_stream += mapping.int2bytes( 8,  0 )               # physical base address
    … …  
    20512056        byte_stream += mapping.int2bytes( 4,  mode_id )         # CXWU flags
    20522057        byte_stream += mapping.int2bytes( 4,  len(self.vobjs) ) # number of vobjs in vseg
    2053         byte_stream += mapping.int2bytes( 4,  vobj_id )         # first vobj global index 
     2058        byte_stream += mapping.int2bytes( 4,  vobj_id )         # first vobj global index
    20542059        byte_stream += mapping.int2bytes( 4,  0 )               # linked list of vsegs on same pseg
    20552060        byte_stream += mapping.int2bytes( 1,  0 )               # mapped when non zero
    … …  
    20632068            print 'mode       = %s' %  self.mode
    20642069            print 'nb_vobjs   = %d' %  len(self.vobjs)
    2065             print 'vobj_id    = %d' %  vobj_id 
    2066      
     2070            print 'vobj_id    = %d' %  vobj_id
     2071
    20672072        return byte_stream
    20682073
    … …  
    20712076###########################################################################################
    20722077    def __init__( self,
    2073                   name, 
    2074                   length, 
    2075                   vtype, 
    2076                   binpath = '', 
    2077                   align   = 0, 
     2078                  name,
     2079                  length,
     2080                  vtype,
     2081                  binpath = '',
     2082                  align   = 0,
    20782083                  init    = 0 ):
    20792084
    … …  
    21182123        # compute numerical value for vtype
    21192124        vtype_int = 0xFFFFFFFF
    2120         for x in xrange( len(VOBJTYPES) ): 
    2121             if ( self.vtype == VOBJTYPES[x] ): 
     2125        for x in xrange( len(VOBJTYPES) ):
     2126            if ( self.vtype == VOBJTYPES[x] ):
    21222127                vtype_int = x
    21232128        if ( vtype_int == 0xFFFFFFFF ):
    … …  
    21262131
    21272132        byte_stream = bytearray()
    2128         byte_stream += mapping.str2bytes( 32, self.name )       # vobj name 
     2133        byte_stream += mapping.str2bytes( 32, self.name )       # vobj name
    21292134        byte_stream += mapping.str2bytes( 64, self.binpath )    # pathname for .elf file
    21302135        byte_stream += mapping.int2bytes( 4 , vtype_int )       # vobj type
    … …  
    21342139        byte_stream += mapping.int2bytes( 8 , 0 )               # physical base address
    21352140        byte_stream += mapping.int2bytes( 4 , self.init )       # init value
    2136      
     2141
    21372142        if ( verbose ):
    21382143            print 'binpath    = %s' %  self.binpath
    21392144            print 'type       = %s' %  self.vtype
    21402145            print 'length     = %x' %  self.length
    2141        
     2146
    21422147        return byte_stream
    21432148
    … …  
    21462151###########################################################################################
    21472152    def __init__( self,
    2148                   x, 
    2149                   y, 
     2153                  x,
     2154                  y,
    21502155                  lpid ):
    21512156
    … …  
    21582163
    21592164    ################
    2160     def xml( self ):   # xml for a processor     
     2165    def xml( self ):   # xml for a processor
    21612166        return '            <proc index="%d" />\n' % (self.lpid)
    21622167
    … …  
    21752180        byte_stream = bytearray()
    21762181        byte_stream += mapping.int2bytes( 4 , self.lpid )       # local index
    2177      
     2182
    21782183        return byte_stream
    21792184
    … …  
    21812186class Pseg ( object ):
    21822187###########################################################################################
    2183     def __init__( self, 
    2184                   name, 
    2185                   base, 
    2186                   size, 
     2188    def __init__( self,
     2189                  name,
     2190                  base,
     2191                  size,
    21872192                  x,
    21882193                  y,
    … …  
    21952200        self.base     = base    # physical base address
    21962201        self.size     = size    # segment size (bytes)
    2197         self.x        = x       # cluster x coordinate 
    2198         self.y        = y       # cluster y coordinate 
     2202        self.x        = x       # cluster x coordinate
     2203        self.y        = y       # cluster y coordinate
    21992204        self.segtype  = segtype # RAM / PERI (defined in mapping_info.h)
    22002205
    22012206        return
    2202    
     2207
    22032208    ################
    22042209    def xml( self ):   # xml for a pseg
    … …  
    22192224                  % (self.index, expected )
    22202225            sys.exit(1)
    2221        
     2226
    22222227        # compute numerical value for segtype
    22232228        segtype_int = 0xFFFFFFFF
    2224         for x in xrange( len(PSEGTYPES) ): 
    2225             if ( self.segtype == PSEGTYPES[x] ): 
     2229        for x in xrange( len(PSEGTYPES) ):
     2230            if ( self.segtype == PSEGTYPES[x] ):
    22262231                segtype_int = x
    22272232        if ( segtype_int == 0xFFFFFFFF ):
    … …  
    22302235
    22312236        byte_stream = bytearray()
    2232         byte_stream += mapping.str2bytes( 32, self.name )      # pseg name 
     2237        byte_stream += mapping.str2bytes( 32, self.name )      # pseg name
    22332238        byte_stream += mapping.int2bytes( 8 , self.base )      # physical base address
    22342239        byte_stream += mapping.int2bytes( 8 , self.size )      # segment length
    22352240        byte_stream += mapping.int2bytes( 4 , segtype_int )    # segment type
    22362241        byte_stream += mapping.int2bytes( 4 , cluster.index )  # cluster global index
    2237         byte_stream += mapping.int2bytes( 4 , 0 )              # linked list of vsegs 
     2242        byte_stream += mapping.int2bytes( 4 , 0 )              # linked list of vsegs
    22382243
    22392244        if ( verbose ):
    … …  
    22412246            print 'size       = %x' %  self.size
    22422247            print 'type       = %s' %  self.segtype
    2243        
     2248
    22442249        return byte_stream
    22452250
    … …  
    22472252class Periph ( object ):
    22482253###########################################################################################
    2249     def __init__( self, 
     2254    def __init__( self,
    22502255                  pseg,               # associated pseg
    22512256                  ptype,              # peripheral type
    … …  
    22592264
    22602265        self.index    = 0            # global index ( set by addPeriph() )
    2261         self.channels = channels 
    2262         self.ptype    = ptype 
    2263         self.subtype  = subtype 
     2266        self.channels = channels
     2267        self.ptype    = ptype
     2268        self.subtype  = subtype
    22642269        self.arg      = arg
    22652270        self.pseg     = pseg
    … …  
    23052310        # compute numerical value for ptype
    23062311        ptype_id = 0xFFFFFFFF
    2307         for x in xrange( len(PERIPHTYPES) ): 
     2312        for x in xrange( len(PERIPHTYPES) ):
    23082313            if ( self.ptype == PERIPHTYPES[x] ):  ptype_id = x
    23092314        if ( ptype_id == 0xFFFFFFFF ):
    … …  
    23132318        # compute numerical value for subtype
    23142319        subtype_id = 0xFFFFFFFF
    2315         for x in xrange( len(PERIPHSUBTYPES) ): 
     2320        for x in xrange( len(PERIPHSUBTYPES) ):
    23162321            if ( self.subtype == PERIPHSUBTYPES[x] ):  subtype_id = x
    23172322
    23182323        # compute
    23192324        byte_stream = bytearray()
    2320         byte_stream += mapping.int2bytes( 4 , ptype_id )         # peripheral type     
     2325        byte_stream += mapping.int2bytes( 4 , ptype_id )         # peripheral type
    23212326        byte_stream += mapping.int2bytes( 4 , subtype_id )       # peripheral subtype
    2322         byte_stream += mapping.int2bytes( 4 , pseg_id )          # pseg global index 
     2327        byte_stream += mapping.int2bytes( 4 , pseg_id )          # pseg global index
    23232328        byte_stream += mapping.int2bytes( 4 , self.channels )    # number of channels
    23242329        byte_stream += mapping.int2bytes( 4 , self.arg )         # optionnal argument
    2325         byte_stream += mapping.int2bytes( 4 , len( self.irqs ) ) # number of input irqs 
    2326         byte_stream += mapping.int2bytes( 4 , irq_id )           # first irq global index 
     2330        byte_stream += mapping.int2bytes( 4 , len( self.irqs ) ) # number of input irqs
     2331        byte_stream += mapping.int2bytes( 4 , irq_id )           # first irq global index
    23272332
    23282333        if ( verbose ):
    … …  
    23302335            print 'pseg_id    = %d' %  pseg_id
    23312336            print 'nb_irqs    = %d' %  len( self.irqs )
    2332             print 'irq_id     = %d' %  irq_id       
     2337            print 'irq_id     = %d' %  irq_id
    23332338        return byte_stream
    23342339
    … …  
    23362341class Irq ( object ):
    23372342###########################################################################################
    2338     def __init__( self, 
     2343    def __init__( self,
    23392344                  irqtype,         # input IRQ type : HWI / WTI / PTI (for XCU only)
    23402345                  srcid,           # input IRQ index (for XCU or PIC)
    … …  
    23472352
    23482353        self.index   = 0        # global index ( set by addIrq() )
    2349         self.irqtype = irqtype  # IRQ type 
     2354        self.irqtype = irqtype  # IRQ type
    23502355        self.srcid   = srcid    # source IRQ index
    2351         self.isrtype = isrtype  # ISR type 
     2356        self.isrtype = isrtype  # ISR type
    23522357        self.channel = channel  # channel index (for multi-channels ISR)
    23532358        return
    … …  
    23632368
    23642369        if ( verbose ):
    2365             print '*** cbin for irq[%d]' % (self.index) 
     2370            print '*** cbin for irq[%d]' % (self.index)
    23662371
    23672372        # check index
    … …  
    23742379        irqtype_id = 0xFFFFFFFF
    23752380        for x in xrange( len(IRQTYPES) ):
    2376             if ( self.irqtype == IRQTYPES[x] ): 
     2381            if ( self.irqtype == IRQTYPES[x] ):
    23772382                irqtype_id = x
    23782383        if ( irqtype_id == 0xFFFFFFFF ):
    … …  
    23822387        # compute numerical value for isrtype
    23832388        isrtype_id = 0xFFFFFFFF
    2384         for x in xrange( len(ISRTYPES) ): 
    2385             if ( self.isrtype == ISRTYPES[x] ): 
     2389        for x in xrange( len(ISRTYPES) ):
     2390            if ( self.isrtype == ISRTYPES[x] ):
    23862391                isrtype_id = x
    23872392        if ( isrtype_id == 0xFFFFFFFF ):
    … …  
    24082413class Coproc ( object ):
    24092414###########################################################################################
    2410     def __init__( self, 
    2411                   pseg ):           # associated pseg 
     2415    def __init__( self,
     2416                  pseg ):           # associated pseg
    24122417
    24132418        self.index    = 0        # global index value set by addCoproc()
    … …  
    24182423
    24192424    ################
    2420     def xml( self ):    # xml for Coproc 
     2425    def xml( self ):    # xml for Coproc
    24212426
    24222427        print '[genmap error] in Coproc.xml() : not defined yet'
    24232428        sys.exit(1)
    24242429
    2425         return 
     2430        return
    24262431
    24272432    #############################################
    … …  
    24452450        byte_stream = bytearray()
    24462451        byte_stream += mapping.str2bytes( 32, self.pseg.name )    # probablement inutile (AG)
    2447         byte_stream += mapping.int2bytes( 4 , pseg_id )           # pseg global index 
    2448         byte_stream += mapping.int2bytes( 4 , len( self.ports ) ) # number of input irqs 
    2449         byte_stream += mapping.int2bytes( 4 , port_id )           # first port global index 
    2450        
     2452        byte_stream += mapping.int2bytes( 4 , pseg_id )           # pseg global index
     2453        byte_stream += mapping.int2bytes( 4 , len( self.ports ) ) # number of input irqs
     2454        byte_stream += mapping.int2bytes( 4 , port_id )           # first port global index
     2455
    24512456        if ( verbose ):
    24522457            print 'irqtype    = %s' %  self.irqtype
    … …  
    24542459            print 'nb_ports   = %d' %  len( self.ports )
    24552460            print 'port_id      %d' %  port_id
    2456          
     2461
    24572462        return byte_stream
    24582463
    … …  
    24602465class Cpport ( object ):
    24612466###########################################################################################
    2462     def __init__( self, 
    2463                   direction, 
    2464                   vspacename, 
     2467    def __init__( self,
     2468                  direction,
     2469                  vspacename,
    24652470                  mwmrname ):
    24662471
    … …  
    24782483        sys.exit(1)
    24792484
    2480         return 
     2485        return
    24812486
    24822487    #############################################
    … …  
    25012506        vspace_id = 0xFFFFFFFF
    25022507        for vspace in mapping.vspaces:
    2503             if ( self.vspacename == vspace.name ): 
     2508            if ( self.vspacename == vspace.name ):
    25042509                vspace_id = vspace.index
    25052510        if (vspace_id == 0xFFFFFFFF):
    … …  
    25122517        for vseg in mapping.vspace[vspace_id].vsegs:
    25132518            for vobj in vseg.vobjs:
    2514                 if (self.mwmrname == vobj.name): 
     2519                if (self.mwmrname == vobj.name):
    25152520                    mwmr_id = vobj.index
    25162521        if (mwmr_id == 0xFFFFFFFF):
    … …  
    25202525
    25212526        byte_stream = bytearray()
    2522         byte_stream += mapping.int2bytes( 4 , dir_int )         # pseg global index 
    2523         byte_stream += mapping.int2bytes( 4 , vspace_id )       # vspace global index 
    2524         byte_stream += mapping.int2bytes( 4 , mwmr_id )         # mwmr vobj global index 
    2525        
     2527        byte_stream += mapping.int2bytes( 4 , dir_int )         # pseg global index
     2528        byte_stream += mapping.int2bytes( 4 , vspace_id )       # vspace global index
     2529        byte_stream += mapping.int2bytes( 4 , mwmr_id )         # mwmr vobj global index
     2530
    25262531        if ( verbose ):
    25272532            print 'direction  = %s' %  self.direction
Note: See TracChangeset for help on using the changeset viewer.