Context Navigation

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

Last change on this file since 359 was 356, checked in by alain, 10 years ago
Bloup...
Property svn:executable set to ``*
File size: 103.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: