Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

arch_classes.py

Last change on this file was 687, checked in by alain, 4 years ago
cosmetic
File size: 38.8 KB

Line
1	#!/usr/bin/env python
2
3	import 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
38	ARCHINFO_SIGNATURE = 0xBABE2016 # magic number indicating a valid C BLOB
39	PAGE_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
46	DEVICE_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
68	DEVICE_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	#########################################################################################
91	class 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	###################################################################################
733	class 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	##################################################################################
800	class 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	##################################################################################
843	class 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	##################################################################################
938	class 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.

Context Navigation

source: trunk/tools/arch_info/arch_classes.py

Download in other formats: