source: trunk/tools/arch_info/arch_classes.py @ 687

Last change on this file since 687 was 687, checked in by alain, 16 months ago

cosmetic

File size: 38.8 KB
Line 
1#!/usr/bin/env python
2
3import sys
4
5##########################################################################################
6#  File   : arch_classes.py
7#  Date   : 2016
8#  Author : Alain Greiner
9#  Copyright (c)  UPMC Sorbonne Universites
10#########################################################################################
11#  This file contains the python classes required to define a generic hardware
12#  architecture for the ALMOS-MK operating system.
13#  It handle 4 types of objects: clusters, cores, devices and irqs.
14#  - The number of cluster is variable (can be one).
15#  - The cluster topology can be a 2D mesh or a simple 1D array.
16#  - The number of cores per cluster is variable (can be zero).
17#  - The number of addressable devices per cluster is variable.
18#  - The size of the physical memory bank per cluster is variable.
19#  An adressable device can be a physical memory bank or a peripheral.
20#  Each cluster cover a fixed size segment in physical address space,
21# that is defined by (PADDR_WIDTH - X_WIDTH - Y_WIDTH)
22#########################################################################################
23# Implementation Note:
24# The objects used to describe an architecture are distributed in the python structure:
25# For example the set of cores and the set of devices are split in several subsets
26# (one subset of cores and one subset of devices per cluster).
27# In the generated C binary data structure, all objects of same type
28# are stored in a linear array (one single array for all cores for example).
29# For all objects, we compute and store in the python object  a "global index"
30# corresponding to the index in this global array, and this index can be used as
31# a pseudo-pointer to identify a specific object of a given type.
32#########################################################################################
33
34#########################################################################################
35#  Define global parameters
36#########################################################################################
37
38ARCHINFO_SIGNATURE = 0xBABE2016    # magic number indicating a valid C BLOB
39PAGE_SIZE          = 0x1000        # to check peripherals alignment
40
41#########################################################################################
42# These arrays define the supported types of peripherals.
43# They must be kept consistent with values defined in file arch_info.h
44#########################################################################################
45
46DEVICE_TYPES_STR = [
47    'RAM_SCL',         # 0.0
48    'ROM_SCL',         # 1.0
49    'FBF_SCL',         # 2.0
50    'FBF_LTI',         # 2.1
51    'IOB_TSR',         # 3.0
52    'IOC_BDV',         # 4.0
53    'IOC_HBA',         # 4.1
54    'IOC_SDC',         # 4.2
55    'IOC_SPI',         # 4.3
56    'IOC_RDK',         # 4.4
57    'MMC_TSR',         # 5.0
58    'DMA_SCL',         # 6.0
59    'NIC_CBF',         # 7.0
60    'TIM_SCL',         # 8.0
61    'TXT_TTY',         # 9.0
62    'TXT_RS2',         # 9.1
63    'TXT_MTY',         # 9.2
64    'ICU_XCU',         # A.0
65    'PIC_TSR',         # B.0
66    ]
67   
68DEVICE_TYPES_INT = [
69    0x00000000,        # 0.0
70    0x00010000,        # 1.0
71    0x00020000,        # 2.0
72    0x00020001,        # 2.1
73    0x00030000,        # 3.0
74    0x00040000,        # 4.0
75    0x00040001,        # 4.1
76    0x00040002,        # 4.2
77    0x00040003,        # 4.3
78    0x00040004,        # 4.4
79    0x00050000,        # 5.0
80    0x00060000,        # 6.0
81    0x00070000,        # 7.0
82    0x00080000,        # 8.0
83    0x00090000,        # 9.0
84    0x00090001,        # 9.1
85    0x00090002,        # 9.2
86    0x000A0000,        # A.0
87    0x000B0000,        # B.0
88    ]
89
90#########################################################################################
91class Archinfo( object ):         
92#########################################################################################
93    def __init__( self,
94                  name,              # architecture instance name
95                  x_size,            # number of clusters in a row
96                  y_size,            # number of clusters in a column
97                  cores_max,         # max number of cores per cluster
98                  devices_max,       # max number of devices per cluster
99                  paddr_width,       # number of bits in physical address
100                  x_width,           # number of bits for x coordinate
101                  y_width,           # number of bits for y coordinate
102                  irqs_per_core,     # number or IRQs from ICU to one core
103                  io_cxy,            # IO cluster identifier
104                  boot_cxy,          # boot cluster identifier
105                  cache_line,        # number of bytes in cache line
106                  reset_address,     # Preloader physical base address
107                  p_width,           # TSAR specific : number of bits to code core lid
108                  sys_clk ):         # system clock frequency (in Hertz)
109
110        assert ( x_size <= (1<<x_width) )
111        assert ( y_size <= (1<<y_width) )
112
113        self.signature      = ARCHINFO_SIGNATURE
114        self.name           = name
115        self.x_size         = x_size
116        self.y_size         = y_size
117        self.cores_max      = cores_max
118        self.devices_max    = devices_max
119        self.paddr_width    = paddr_width
120        self.x_width        = x_width
121        self.y_width        = y_width
122        self.irqs_per_core  = irqs_per_core
123        self.io_cxy         = io_cxy
124        self.boot_cxy       = boot_cxy
125        self.cache_line     = cache_line
126        self.reset_address  = reset_address
127        self.p_width        = p_width
128        self.sys_clk        = sys_clk
129
130        self.total_cores    = 0
131        self.total_devices  = 0
132        self.total_irqs     = 0
133
134        self.clusters       = []
135
136        for x in xrange( self.x_size ):
137            for y in xrange( self.y_size ):
138
139                # call cluster constructor
140                cxy = (x<<y_width) + y
141                cluster = Cluster( cxy )
142
143                # update cluster global index
144                cluster.index = (x * self.y_size) + y
145
146                # register cluster in Archinfo
147                self.clusters.append( cluster )
148
149        return
150
151    ##########################   add a device in a cluster
152    def addDevice( self,
153                   ptype,              # device type
154                   base,               # associated pseg base address
155                   size,               # associated pseg length (bytes)
156                   channels = 1,       # number of channels
157                   arg0     = 0,       # optional argument (semantic depends on ptype)
158                   arg1     = 0,       # optional argument (semantic depends on ptype)
159                   arg2     = 0,       # optional argument (semantic depends on ptype)
160                   arg3     = 0 ):     # optional argument (semantic depends on ptype)
161
162        # computes cluster identifier and global index from the base address
163        cxy = base >> (self.paddr_width - self.x_width - self.y_width)
164        x          = cxy >> (self.y_width);
165        y          = cxy & ((1 << self.y_width) - 1)
166        cluster_id = (x * self.y_size) + y
167
168        assert (x < self.x_size) and (y < self.y_size)
169        assert (base & (PAGE_SIZE-1) == 0)
170        assert (ptype in DEVICE_TYPES_STR)
171
172        # call device constructor
173        device = Device( base, size, ptype, channels, arg0, arg1, arg2, arg3 )
174
175        # register device in cluster
176        self.clusters[cluster_id].devices.append( device )
177
178        # update device global index
179        device.index = self.total_devices
180        self.total_devices += 1
181
182        return device
183
184    ################################   add an input IRQ in a device
185    def addIrq( self,
186                dstdev,                # destination device (PIC or ICU)
187                port,                  # input IRQ port index
188                srcdev,                # source device
189                channel = 0,           # source device channel
190                is_rx = False ):       # I/O operation direction
191
192        assert (dstdev.ptype == 'ICU_XCU') or (dstdev.ptype == 'PIC_TSR')
193        assert (port < dstdev.arg0)
194
195        # call Irq constructor
196        irq = Irq( port , srcdev, channel , is_rx )
197
198        # register IRQ in destination device
199        dstdev.irqs.append( irq )
200
201        # update IRQ global index
202        irq.index = self.total_irqs
203        self.total_irqs += 1
204
205        # pointer from the source to the interrupt controller device
206        if (srcdev.irq_ctrl == None): srcdev.irq_ctrl = dstdev
207
208        if (srcdev.irq_ctrl != dstdev):
209            print '[genarch error] in addIrq():'
210            print '    two different interrupt controller for the same device'
211            sys.exit(1)
212
213        return irq
214
215    ##########################    add a core in a cluster
216    def addCore( self,
217                 gid,                  # global hardware identifier
218                 cxy,                  # cluster identifier
219                 lid ):                # local index in cluster
220
221        assert ((cxy >> self.y_width) < self.x_size)
222        assert ((cxy & ((1<<self.y_width)-1)) < self.y_size)
223        assert (lid < self.cores_max)
224 
225        # call Core contructor
226        core = Core( gid, cxy, lid )
227
228        # compute cluster global index from cluster identifier
229        x          = cxy>>self.y_width
230        y          = cxy & ((1<<self.y_width)-1)
231        cluster_id = (x * self.y_size) + y
232
233        # register core in cluster
234        self.clusters[cluster_id].cores.append( core )
235
236        # update core global index
237        core.index = self.total_cores
238        self.total_cores += 1
239
240        return core
241
242    #################################
243    def str2bytes( self, nbytes, s ):    # string => nbytes_packed byte array
244
245        byte_stream = bytearray()
246        length = len( s )
247        if length < (nbytes - 1):
248            for b in s:
249                byte_stream.append( b )
250            for x in xrange(nbytes-length):
251                byte_stream.append( '\0' )
252        else:
253            print '[genarch error] in str2bytes()'
254            print '    string %s too long' % s
255            sys.exit(1)
256
257        return byte_stream
258
259    ###################################
260    def int2bytes( self, nbytes, val ):    # integer => nbytes litle endian byte array
261
262        byte_stream = bytearray()
263        for n in xrange( nbytes ):
264            byte_stream.append( (val >> (n<<3)) & 0xFF )
265
266        return byte_stream
267
268    ################
269    def xml( self ):    # compute string for xml file generation
270
271        s = '<?xml version="1.0"?>\n\n'
272        s += '<arch_info signature    = "0x%x"\n' % (self.signature)
273        s += '           name         = "%s"\n'   % (self.name)
274        s += '           x_size       = "%d"\n'   % (self.x_size)
275        s += '           y_size       = "%d"\n'   % (self.y_size)
276        s += '           cores        = "%d"\n'   % (self.cores_max)
277        s += '           io_cxy       = "%d"\n'   % (self.io_cxy)
278        s += '           sys_clk      = "%d" >\n' % (self.sys_clk)
279        s += '\n'
280
281        s += '    <clusterset>\n'
282        for x in xrange ( self.x_size ):
283            for y in xrange ( self.y_size ):
284                cluster_id = (x * self.y_size) + y
285                s += self.clusters[cluster_id].xml()
286        s += '    </clusterset>\n'
287        s += '\n'
288
289        s += '</arch_info>\n'
290        return s
291
292    ##########################
293    def cbin( self, verbose ):     # C binary structure for "archinfo.bin" file generation
294
295        byte_stream = bytearray()
296
297        # header
298        byte_stream += self.int2bytes(4,  self.signature)
299        byte_stream += self.int2bytes(4,  self.x_size)
300        byte_stream += self.int2bytes(4,  self.y_size)
301        byte_stream += self.int2bytes(4,  self.paddr_width)
302        byte_stream += self.int2bytes(4,  self.x_width)
303        byte_stream += self.int2bytes(4,  self.y_width)
304        byte_stream += self.int2bytes(4,  self.cores_max)
305        byte_stream += self.int2bytes(4,  self.devices_max)
306
307        byte_stream += self.int2bytes(4,  self.total_cores)
308        byte_stream += self.int2bytes(4,  self.total_devices)
309        byte_stream += self.int2bytes(4,  self.total_irqs)
310        byte_stream += self.int2bytes(4,  self.io_cxy)
311        byte_stream += self.int2bytes(4,  self.boot_cxy)
312        byte_stream += self.int2bytes(4,  self.irqs_per_core)
313        byte_stream += self.int2bytes(4,  self.cache_line)
314        byte_stream += self.int2bytes(4,  self.sys_clk)
315
316        byte_stream += self.str2bytes(64, self.name)
317
318        if ( verbose ):
319            print '\n'
320            print 'name          = %s' % self.name
321            print 'signature     = %x' % self.signature
322            print 'x_size        = %d' % self.x_size
323            print 'y_size        = %d' % self.y_size
324            print 'total_cores   = %d' % self.total_cores
325            print 'total_devices = %d' % self.total_devices
326            print 'total_irqs    = %d' % self.total_irqs
327            print '\n'
328
329        # cores array
330        index = 0
331        for cluster in self.clusters:
332            for core in cluster.cores:
333                byte_stream += core.cbin( self, verbose, index )
334                index += 1
335
336        if ( verbose ): print '\n'
337
338        # clusters array
339        index = 0
340        for cluster in self.clusters:
341            byte_stream += cluster.cbin( self, verbose, index )
342            index += 1
343
344        if ( verbose ): print '\n'
345
346        # devices array
347        index = 0
348        for cluster in self.clusters:
349            for device in cluster.devices:
350                byte_stream += device.cbin( self, verbose, index )
351                index += 1
352
353        if ( verbose ): print '\n'
354
355        # irqs array
356        index = 0
357        for cluster in self.clusters:
358            for device in cluster.devices:
359                for irq in device.irqs:
360                    byte_stream += irq.cbin( self, verbose, index )
361                    index += 1
362
363        if ( verbose ): print '\n'
364
365        return byte_stream
366    # end of cbin()
367
368
369    ######################################################################
370    def hard_config( self ):     # compute string for hard_config.h file
371                                 # required by
372                                 # - top.cpp compilation
373                                 # - almos-mkh bootloader compilation
374                                 # - tsar_preloader compilation
375
376        # for each device type, define default values
377        # for pbase address, size, number of components, and channels
378        nb_ram       = 0
379        ram_channels = 0
380        ram_base     = 0xFFFFFFFFFFFFFFFF
381        ram_size     = 0
382
383        nb_rom       = 0
384        rom_channels = 0
385        rom_base     = 0xFFFFFFFFFFFFFFFF
386        rom_size     = 0
387
388        nb_fbf       = 0
389        fbf_channels = 0
390        fbf_base     = 0xFFFFFFFFFFFFFFFF
391        fbf_size     = 0
392        fbf_arg0     = 0
393        fbf_arg1     = 0
394        use_fbf_scl  = False
395        use_fbf_lti  = False
396
397        nb_iob       = 0
398        iob_channels = 0
399        iob_base     = 0xFFFFFFFFFFFFFFFF
400        iob_size     = 0
401
402        nb_ioc       = 0
403        ioc_channels = 0
404        ioc_base     = 0xFFFFFFFFFFFFFFFF
405        ioc_size     = 0
406        use_ioc_bdv  = False
407        use_ioc_sdc  = False
408        use_ioc_hba  = False
409        use_ioc_spi  = False
410        use_ioc_rdk  = False
411
412        nb_mmc       = 0
413        mmc_channels = 0
414        mmc_base     = 0xFFFFFFFFFFFFFFFF
415        mmc_size     = 0
416
417        nb_dma       = 0
418        dma_channels = 0
419        dma_base     = 0xFFFFFFFFFFFFFFFF
420        dma_size     = 0
421
422        nb_nic       = 0
423        nic_channels = 0
424        nic_base     = 0xFFFFFFFFFFFFFFFF
425        nic_size     = 0
426
427        nb_sim       = 0
428        sim_channels = 0
429        sim_base     = 0xFFFFFFFFFFFFFFFF
430        sim_size     = 0
431
432        nb_tim       = 0
433        tim_channels = 0
434        tim_base     = 0xFFFFFFFFFFFFFFFF
435        tim_size     = 0
436
437        nb_txt       = 0
438        txt_channels = 0
439        txt_base     = 0xFFFFFFFFFFFFFFFF
440        txt_size     = 0
441        use_txt_tty  = False
442        use_txt_rs2  = False
443        use_txt_mty  = False
444
445        nb_icu       = 0
446        icu_channels = 0
447        icu_base     = 0xFFFFFFFFFFFFFFFF
448        icu_size     = 0
449        icu_arg0     = 0
450
451        nb_pic       = 0
452        pic_channels = 0
453        pic_base     = 0xFFFFFFFFFFFFFFFF
454        pic_size     = 0
455
456        nb_rom        = 0
457        rom_channels  = 0
458        rom_base      = 0xFFFFFFFFFFFFFFFF
459        rom_size      = 0
460
461        # get devices attributes
462        for cluster in self.clusters:
463            for device in cluster.devices:
464
465                if ( device.ptype == 'RAM_SCL' ):
466                    ram_base     = device.base
467                    ram_size     = device.size
468                    ram_channels = device.channels
469                    nb_ram +=1
470               
471                elif ( device.ptype == 'ROM_SCL' ):
472                    rom_base     = device.base
473                    rom_size     = device.size
474                    rom_channels = device.channels
475                    nb_rom +=1
476
477                elif ( device.ptype == 'FBF_SCL' ):
478                    fbf_base     = device.base
479                    fbf_size     = device.size
480                    fbf_channels = device.channels
481                    use_fbf_scl  = True
482                    fbf_arg0     = device.arg0
483                    fbf_arg1     = device.arg1
484                    nb_fbf +=1
485                elif ( device.ptype == 'FBF_LTI' ):
486                    fbf_base     = device.base
487                    fbf_size     = device.size
488                    fbf_channels = device.channels
489                    use_fbf_lti  = True
490                    fbf_arg0     = device.arg0
491                    fbf_arg1     = device.arg1
492                    nb_fbf +=1
493
494                elif ( device.ptype == 'IOB_TSR' ):
495                    iob_base     = device.base
496                    iob_size     = device.size
497                    iob_channels = device.channels
498                    nb_iob +=1
499
500                elif ( device.ptype == 'IOC_BDV' ):
501                    ioc_base     = device.base
502                    ioc_size     = device.size
503                    ioc_channels = device.channels
504                    use_ioc_bdv  = True
505                    nb_ioc += 1
506                elif ( device.ptype == 'IOC_HBA' ):
507                    ioc_base     = device.base
508                    ioc_size     = device.size
509                    ioc_channels = device.channels
510                    use_ioc_hba  = True
511                    nb_ioc += 1
512                elif ( device.ptype == 'IOC_SDC' ):
513                    ioc_base     = device.base
514                    ioc_size     = device.size
515                    ioc_channels = device.channels
516                    use_ioc_sdc  = True
517                    nb_ioc += 1
518                elif ( device.ptype == 'IOC_SPI' ):
519                    ioc_base     = device.base
520                    ioc_size     = device.size
521                    ioc_channels = device.channels
522                    use_ioc_spi  = True
523                    nb_ioc += 1
524                elif ( device.ptype == 'IOC_RDK' ):
525                    ioc_base     = device.base
526                    ioc_size     = device.size
527                    ioc_channels = device.channels
528                    use_ioc_rdk  = True
529                    nb_ioc += 1
530
531                elif ( device.ptype == 'MMC_TSR' ):
532                    mmc_base     = device.base
533                    mmc_size     = device.size
534                    mmc_channels = device.channels
535                    nb_mmc +=1
536
537                elif ( device.ptype == 'DMA_SCL' ):
538                    dma_base     = device.base
539                    dma_size     = device.size
540                    dma_channels = device.channels
541                    nb_dma +=1
542
543                elif ( device.ptype == 'NIC_CBF' ):
544                    nic_base     = device.base
545                    nic_size     = device.size
546                    nic_channels = device.channels
547                    nb_nic +=1
548
549                elif ( device.ptype == 'TIM_SCL' ):
550                    tim_base     = device.pseg.base
551                    tim_size     = device.pseg.size
552                    tim_channels = device.channels
553                    nb_tim +=1
554
555                elif ( device.ptype == 'TXT_TTY' ):
556                    txt_base     = device.base
557                    txt_size     = device.size
558                    txt_channels = device.channels
559                    use_txt_tty  = True
560                    nb_txt +=1
561                elif ( device.ptype == 'TXT_RS2' ):
562                    txt_base     = device.base
563                    txt_size     = device.size
564                    txt_channels = device.channels
565                    use_txt_rs2  = True
566                    nb_txt +=1
567                elif ( device.ptype == 'TXT_MTY' ):
568                    txt_base     = device.base
569                    txt_size     = device.size
570                    txt_channels = device.channels
571                    use_txt_mty  = True
572                    nb_txt +=1
573
574                elif ( device.ptype == 'ICU_XCU' ):
575                    icu_base     = device.base
576                    icu_size     = device.size
577                    icu_channels = device.channels
578                    icu_arg0     = device.arg0
579                    icu_arg1     = device.arg1
580                    icu_arg2     = device.arg2
581                    icu_arg3     = device.arg3
582                    nb_icu +=1
583
584                elif ( device.ptype == 'PIC_TSR' ):
585                    pic_base     = device.base
586                    pic_size     = device.size
587                    pic_channels = device.channels
588                    nb_pic +=1
589
590        # one and only one IOC controller
591        assert ( nb_ioc == 1 )
592
593        # compute rdk_base and rdk_size
594        if( use_ioc_rdk ):
595            rdk_base = ioc_base
596            rdk_size = ioc_size
597        else:
598            rdk_base = 0
599            rdk_size = 0
600
601        # Compute total number of cores, devices and irqs
602        nb_total_cores   = self.total_cores
603        nb_total_devices = self.total_devices
604        nb_total_irqs    = self.total_irqs
605
606        # boot core has (cxy == boot_cxy) and (lid == 0)
607        for cluster in self.clusters:
608            if( cluster.cxy == self.boot_cxy ): boot_core_gid = cluster.cores[0].gid
609
610        # compute mask to get local physical address (cluster independant)
611        local_paddr_width   = self.paddr_width - self.x_width - self.y_width
612        local_physical_mask = (1<<local_paddr_width)-1
613
614        # build string
615        s =  '/* Generated by genarch for %s */\n'  % self.name
616        s += '\n'
617        s += '#ifndef HARD_CONFIG_H\n'
618        s += '#define HARD_CONFIG_H\n'
619        s += '\n'
620
621        s += '/* General platform parameters */\n'
622        s += '\n'
623        s += '#define X_SIZE                 %d\n'    % self.x_size
624        s += '#define Y_SIZE                 %d\n'    % self.y_size
625        s += '#define PADDR_WIDTH            %d\n'    % self.paddr_width
626        s += '#define X_WIDTH                %d\n'    % self.x_width
627        s += '#define Y_WIDTH                %d\n'    % self.y_width
628        s += '#define P_WIDTH                %d\n'    % self.p_width 
629        s += '#define X_IO                   %d\n'    % (self.io_cxy >> self.y_width)
630        s += '#define Y_IO                   %d\n'    % (self.io_cxy & ((1<<self.y_width)-1))
631        s += '#define NB_PROCS_MAX           %d\n'    % self.cores_max
632        s += '#define NB_DEVICES_MAX         %d\n'    % self.devices_max
633        s += '#define IRQ_PER_PROCESSOR      %d\n'    % self.irqs_per_core
634        s += '#define RESET_ADDRESS          0x%x\n'  % self.reset_address
635        s += '#define NB_TOTAL_PROCS         %d\n'    % nb_total_cores
636        s += '#define BOOT_CORE_GID          %d\n'    % boot_core_gid
637        s += '#define BOOT_CORE_CXY          %d\n'    % self.boot_cxy
638        s += '#define CACHE_LINE_SIZE        %d\n'    % self.cache_line
639        s += '#define SYS_CLK                %d\n'    % self.sys_clk
640        s += '\n'
641
642        s += '/* Peripherals */\n'
643        s += '\n'
644        s += '#define NB_TXT_CHANNELS        %d\n'    % txt_channels
645        s += '#define NB_IOC_CHANNELS        %d\n'    % ioc_channels
646        s += '#define NB_NIC_CHANNELS        %d\n'    % nic_channels
647        s += '#define NB_TIM_CHANNELS        %d\n'    % tim_channels
648        s += '\n'
649        s += '#define USE_ICU                %d\n'    % ( nb_icu != 0 )
650        s += '#define USE_IOB                %d\n'    % ( nb_iob != 0 )
651        s += '#define USE_PIC                %d\n'    % ( nb_pic != 0 )
652        s += '#define USE_FBF                %d\n'    % ( nb_fbf != 0 )
653        s += '#define USE_NIC                %d\n'    % ( nb_nic != 0 )
654        s += '#define USE_DMA                %d\n'    % ( nb_dma != 0 )
655        s += '\n'
656        s += '#define USE_IOC_BDV            %d\n'    % use_ioc_bdv
657        s += '#define USE_IOC_SDC            %d\n'    % use_ioc_sdc
658        s += '#define USE_IOC_HBA            %d\n'    % use_ioc_hba
659        s += '#define USE_IOC_SPI            %d\n'    % use_ioc_spi
660        s += '#define USE_IOC_RDK            %d\n'    % use_ioc_rdk
661        s += '\n'
662        s += '#define USE_TXT_TTY            %d\n'    % use_txt_tty
663        s += '#define USE_TXT_RS2            %d\n'    % use_txt_rs2
664        s += '#define USE_TXT_MTY            %d\n'    % use_txt_mty
665        s += '\n'
666        s += '#define USE_FBF_SCL            %d\n'    % use_fbf_scl
667        s += '#define USE_FBF_LTI            %d\n'    % use_fbf_lti
668        s += '\n'
669        s += '#define FBUF_X_SIZE            %d\n'    % fbf_arg0
670        s += '#define FBUF_Y_SIZE            %d\n'    % fbf_arg1
671        s += '\n'
672        s += '#define ICU_NB_HWI             %d\n'    % icu_arg0
673        s += '#define ICU_NB_PTI             %d\n'    % icu_arg1
674        s += '#define ICU_NB_WTI             %d\n'    % icu_arg2
675        s += '#define ICU_NB_OUT             %d\n'    % icu_arg3
676        s += '\n'
677
678        s += '/* local physical base address and size for devices */\n'
679        s += '\n'
680        s += '#define SEG_RAM_BASE           0x%x\n'  % (ram_base & local_physical_mask)
681        s += '#define SEG_RAM_SIZE           0x%x\n'  % ram_size
682        s += '\n'
683        s += '#define SEG_FBF_BASE           0x%x\n'  % (fbf_base & local_physical_mask)
684        s += '#define SEG_FBF_SIZE           0x%x\n'  % fbf_size
685        s += '\n'
686        s += '#define SEG_IOB_BASE           0x%x\n'  % (iob_base & local_physical_mask)
687        s += '#define SEG_IOB_SIZE           0x%x\n'  % iob_size
688        s += '\n'
689        s += '#define SEG_IOC_BASE           0x%x\n'  % (ioc_base & local_physical_mask)
690        s += '#define SEG_IOC_SIZE           0x%x\n'  % ioc_size
691        s += '\n'
692        s += '#define SEG_MMC_BASE           0x%x\n'  % (mmc_base & local_physical_mask)
693        s += '#define SEG_MMC_SIZE           0x%x\n'  % mmc_size
694        s += '\n'
695        s += '#define SEG_DMA_BASE           0x%x\n'  % (dma_base & local_physical_mask)
696        s += '#define SEG_DMA_SIZE           0x%x\n'  % dma_size
697        s += '\n'
698        s += '#define SEG_ROM_BASE           0x%x\n'  % (rom_base & local_physical_mask)
699        s += '#define SEG_ROM_SIZE           0x%x\n'  % rom_size
700        s += '\n'
701        s += '#define SEG_SIM_BASE           0x%x\n'  % (sim_base & local_physical_mask)
702        s += '#define SEG_SIM_SIZE           0x%x\n'  % sim_size
703        s += '\n'
704        s += '#define SEG_NIC_BASE           0x%x\n'  % (nic_base & local_physical_mask)
705        s += '#define SEG_NIC_SIZE           0x%x\n'  % nic_size
706        s += '\n'
707        s += '#define SEG_PIC_BASE           0x%x\n'  % (pic_base & local_physical_mask)
708        s += '#define SEG_PIC_SIZE           0x%x\n'  % pic_size
709        s += '\n'
710        s += '#define SEG_TIM_BASE           0x%x\n'  % (tim_base & local_physical_mask)
711        s += '#define SEG_TIM_SIZE           0x%x\n'  % tim_size
712        s += '\n'
713        s += '#define SEG_TXT_BASE           0x%x\n'  % (txt_base & local_physical_mask)
714        s += '#define SEG_TXT_SIZE           0x%x\n'  % txt_size
715        s += '\n'
716        s += '#define SEG_ICU_BASE           0x%x\n'  % (icu_base & local_physical_mask)
717        s += '#define SEG_ICU_SIZE           0x%x\n'  % icu_size
718        s += '\n'
719        s += '#define SEG_RDK_BASE           0x%x\n'  % (rdk_base & local_physical_mask)
720        s += '#define SEG_RDK_SIZE           0x%x\n'  % rdk_size
721        s += '\n'
722        s += '#endif\n'
723
724        return s
725
726    # end of hard_config()
727
728
729
730
731
732###################################################################################
733class Cluster ( object ):
734###################################################################################
735    def __init__( self,
736                  cxy ):
737
738        self.index       = 0           # global index (set by Archinfo constructor)
739        self.cxy         = cxy         # cluster identifier
740        self.cores       = []          # local cores (filled by addCore)
741        self.devices     = []          # local devices(filled by addDevice)
742
743        return
744
745    ################
746    def xml( self ):  # xml for a cluster
747
748        s = '        <cluster cxy = "%x" >\n' % (self.cxy)
749        for core   in self.cores:   s += core.xml()
750        for device in self.devices: s += device.xml()
751        s += '        </cluster>\n'
752
753        return s
754
755    #############################################
756    def cbin( self, mapping, verbose, expected ):  # C binary structure for Cluster
757
758        if ( verbose ):
759            print '*** cbin for cluster[%d] / identifier = %x' \
760                   % (self.index , self.cxy)
761
762        # check index
763        if (self.index != expected):
764            print '[genarch error] in Cluster.cbin()'
765            print '    cluster global index = %d / expected = %d' \
766                       % (self.index,expected)
767            sys.exit(1)
768
769        # compute global index for first core in cluster
770        if ( len(self.cores) > 0 ):
771            core_id = self.cores[0].index
772        else:
773            core_id = 0
774
775        # compute global index for first device in cluster
776        if ( len(self.devices) > 0 ):
777            device_id = self.devices[0].index
778        else:
779            device_id = 0
780
781        byte_stream = bytearray()
782        byte_stream += mapping.int2bytes(4,self.cxy)          # cxy
783        byte_stream += mapping.int2bytes(4,len(self.cores))   # cores in cluster
784        byte_stream += mapping.int2bytes(4,core_id )          # first core global index
785        byte_stream += mapping.int2bytes(4,len(self.devices)) # devices in cluster
786        byte_stream += mapping.int2bytes(4, device_id )       # first device global index
787
788        if ( verbose ):
789            print 'nb_cores   = %d' %  len( self.cores )
790            print 'core_id    = %d' %  core_id
791            print 'nb_devices = %d' %  len( self.devices )
792            print 'device_id  = %d' %  device_id
793
794        return byte_stream
795
796
797
798
799##################################################################################
800class Core ( object ):         
801##################################################################################
802    def __init__( self,
803                  gid,
804                  cxy,
805                  lid ):
806
807        self.index    = 0          # global index / set by addProc()
808        self.gid      = gid        # hardware identifier
809        self.cxy      = cxy        # cluster identifier
810        self.lid      = lid        # local index in cluster
811
812        return
813
814    ###################################
815    def xml( self ):   # xml for a core
816        return '            <core gid="%x" lid="%d" />\n' % (self.gid, self.lid)
817
818    ####################################################################
819    def cbin( self, mapping, verbose, expected ):    # C binary for Proc
820
821        if ( verbose ):
822            print '*** cbin for core [%d] in cluster %x' \
823                  % (self.lid, self.cxy)
824
825        # check index
826        if (self.index != expected):
827            print '[genarch error] in Core.cbin()'
828            print '    core global index = %d / expected = %d' \
829                       % (self.index,expected)
830            sys.exit(1)
831
832        byte_stream = bytearray()
833        byte_stream += mapping.int2bytes( 4 , self.gid )      # hardware identifier
834        byte_stream += mapping.int2bytes( 2 , self.cxy )      # cluster identifier
835        byte_stream += mapping.int2bytes( 2 , self.lid )      # local index
836
837        return byte_stream
838
839
840
841
842##################################################################################
843class Device ( object ):
844##################################################################################
845    def __init__( self,
846                  base,
847                  size,
848                  ptype,
849                  channels = 1,
850                  arg0     = 0,
851                  arg1     = 0,
852                  arg2     = 0,
853                  arg3     = 0 ):
854
855        self.index    = 0             # global device index ( set by addDevice() )
856        self.base     = base          # associated segment base
857        self.size     = size          # associated segment size (bytes)
858        self.ptype    = ptype         # device type
859        self.channels = channels      # number of channels
860        self.arg0     = arg0          # optional (semantic depends on ptype)
861        self.arg1     = arg1          # optional (semantic depends on ptype)
862        self.arg2     = arg2          # optional (semantic depends on ptype)
863        self.arg3     = arg3          # optional (semantic depends on ptype)
864        self.irqs     = []            # set of input IRQs (for PIC and ICU only)
865        self.irq_ctrl = None          # interrupt controller for this device
866        return
867
868    ######################################
869    def xml( self ):    # xml for a device
870
871        s =  '            <device type="%s"' % self.ptype
872        s += ' base="%x"'                    % self.base
873        s += ' size="%x"'                    % self.size
874        s += ' channels="%d"'                % self.channels
875        s += ' arg0="%d"'                    % self.arg0
876        s += ' arg1="%d"'                    % self.arg1
877        s += ' arg2="%d"'                    % self.arg2
878        s += ' arg3="%d"'                    % self.arg3
879        if ( (self.ptype == 'PIC_TSR') or (self.ptype == 'ICU_XCU') ):
880            s += ' >\n'
881            for irq in self.irqs: s += irq.xml()
882            s += '            </device>\n'
883        else:
884            s += ' />\n'
885        return s
886
887    ######################################################################
888    def cbin( self, mapping, verbose, expected ):    # C binary for Periph
889
890        if ( verbose ):
891            print '*** cbin for device[%d] / type = %s / base = %x' \
892                  % (self.index , self.ptype , self.base)
893
894        # check index
895        if (self.index != expected):
896            print '[genarch error] in Periph.cbin()'
897            print '    device global index = %d / expected = %d' \
898                       % (self.index,expected)
899            sys.exit(1)
900
901        # compute first irq global index
902        if ( len(self.irqs) > 0 ):
903            irq_id = self.irqs[0].index
904        else:
905            irq_id = 0
906
907        # compute device type numerical value
908        ptype_id = 0xFFFFFFFF
909        for x in xrange( len(DEVICE_TYPES_STR) ):
910            if ( self.ptype == DEVICE_TYPES_STR[x] ):  ptype_id = DEVICE_TYPES_INT[x]
911
912        if ( ptype_id == 0xFFFFFFFF ):
913            print '[genarch error] in Device.cbin()'
914            print '    undefined device type %s' % self.ptype
915            sys.exit(1)
916
917        byte_stream = bytearray()
918        byte_stream += mapping.int2bytes(8,self.base)      # segment base address
919        byte_stream += mapping.int2bytes(8,self.size)      # segment size
920        byte_stream += mapping.int2bytes(4,ptype_id)       # device type
921        byte_stream += mapping.int2bytes(4,self.channels)  # number of channels
922        byte_stream += mapping.int2bytes(4,self.arg0)      # optionnal arg0
923        byte_stream += mapping.int2bytes(4,self.arg1)      # optionnal arg1
924        byte_stream += mapping.int2bytes(4,self.arg2)      # optionnal arg2
925        byte_stream += mapping.int2bytes(4,self.arg3)      # optionnal arg3
926        byte_stream += mapping.int2bytes(4,len(self.irqs)) # number of input irqs
927        byte_stream += mapping.int2bytes(4 ,irq_id)        # first irq global index
928
929        if ( verbose ):
930            print 'base       = %x' %  self.base
931            print 'size       = %x' %  self.size
932            print 'nb_irqs    = %d' %  len( self.irqs )
933            print 'irq_id     = %d' %  irq_id
934
935        return byte_stream
936
937##################################################################################
938class Irq ( object ): 
939##################################################################################
940    def __init__( self,
941                  port,
942                  dev,
943                  channel,
944                  is_rx ): 
945
946        assert port < 32
947
948        self.index   = 0              # global index ( set by addIrq() )
949        self.port    = port           # input IRQ port index
950        self.dev     = dev            # source device
951        self.channel = channel        # source device channel
952        self.is_rx   = is_rx          # source device direction
953
954        return
955
956    ################################
957    def xml( self ):   # xml for Irq
958        s = '                <irq port="%d" devtype="%s" channel="%d" is_rx="%d" />\n' \
959                             % ( self.port, self.dev.ptype, self.channel, self.is_rx )
960        return s
961
962    ####################################################################
963    def cbin( self, mapping, verbose, expected ):     # C binary for Irq
964
965        if ( verbose ):
966            print '*** cbin for irq[%d] / src_dev = %s' \
967                   % (self.port , self.dev.ptype)
968
969        # check index
970        if (self.index != expected):
971            print '[genarch error] in Irq.cbin()'
972            print '    irq global index = %d / expected = %d' \
973                       % (self.index , expected)
974        # compute source device type numerical value
975        dev_id = 0xFFFFFFFF
976        for x in xrange( len(DEVICE_TYPES_STR) ):
977            if ( self.dev.ptype == DEVICE_TYPES_STR[x] ): dev_id = DEVICE_TYPES_INT[x]
978
979        if ( dev_id == 0xFFFFFFFF ):
980            print '[genarch error] in Irq.cbin()'
981            print '    undefined device type %s' % self.dev.ptype
982            sys.exit(1)
983
984        byte_stream = bytearray()
985        byte_stream += mapping.int2bytes( 4,  dev_id )
986        byte_stream += mapping.int2bytes( 1,  self.channel )
987        byte_stream += mapping.int2bytes( 1,  self.is_rx )
988        byte_stream += mapping.int2bytes( 1,  self.port )
989        byte_stream += mapping.int2bytes( 1,  0 )
990
991        if ( verbose ):
992            print 'dev_id     = %d' %  dev_id
993            print 'channel    = %d' %  self.channel
994            print 'is_rx      = %d' %  self.is_rx   
995            print 'port       = %s' %  self.port
996
997        return byte_stream
998
999# Local Variables:
1000# tab-width: 4;
1001# c-basic-offset: 4;
1002# c-file-offsets:((innamespace . 0)(inline-open . 0));
1003# indent-tabs-mode: nil;
1004# End:
1005#
1006# vim: filetype=python:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
1007
Note: See TracBrowser for help on using the repository browser.