OpenCores
URL https://opencores.org/ocsvn/socgen/socgen/trunk

Subversion Repositories socgen

[/] [socgen/] [trunk/] [tools/] [ip-xact/] [1685-2014/] [memoryMap.xsd] - Blame information for rev 135

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 135 jt_eaton
2
3
50
51
        
52
        
53
        
54
                
55
                        The read/write accessability of an addess block.
56
                
57
                
58
                        
59
                        
60
                        
61
                        
62
                        
63
                
64
        
65
        
66
                
67
                        The sharedness of the memoryMap content.
68
                
69
                
70
                        
71
                        
72
                        
73
                
74
        
75
        
76
                
77
                        'serial' or 'parallel' bank alignment.
78
                
79
                
80
                        
81
                        
82
                
83
        
84
        
85
                
86
                        Describes the usage of an address block.
87
                
88
                
89
                        
90
                                
91
                                        Denotes an address range that can be used for read-write or read-only data storage.
92
                                
93
                        
94
                        
95
                                
96
                                        Denotes an address block that is used to communicate with hardware.
97
                                
98
                        
99
                        
100
                                
101
                                        Denotes an address range that must remain unoccupied.
102
                                
103
                        
104
                
105
        
106
        
107
                
108
                        Top level bank the specify an address
109
                
110
                
111
                        
112
                        
113
                                
114
                                        
115
                                                
116
                                        
117
                                
118
                        
119
                        
120
                        
121
                
122
                
123
                        
124
                                Describes whether this bank's blocks are aligned in 'parallel' or 'serial'.
125
                        
126
                
127
                
128
        
129
        
130
                
131
                        Top level bank the specify an address
132
                
133
                
134
                        
135
                        
136
                                
137
                                        
138
                                                
139
                                        
140
                                
141
                        
142
                        
143
                        
144
                
145
                
146
                        
147
                                Describes whether this bank's blocks are aligned in 'parallel' or 'serial'.
148
                        
149
                
150
                
151
        
152
        
153
                
154
                        Top level address block that specify an address
155
                
156
                
157
                        
158
                        
159
                                
160
                                        
161
                                                
162
                                        
163
                                
164
                        
165
                        
166
                        
167
                        
168
                        
169
                
170
                
171
        
172
        
173
                
174
                        Base type for an element which references an address space.  Reference is kept in an attribute rather than the text value, so that the type may be extended with child elements if necessary.
175
                
176
                
177
                        
178
                
179
                
180
                        
181
                                A reference to a unique address space.
182
                        
183
                
184
                
185
        
186
        
187
                
188
                        Base type for an element which references an memory map.  Reference is kept in an attribute rather than the text value, so that the type may be extended with child elements if necessary.
189
                
190
                
191
                        
192
                                A reference to a unique memory map.
193
                        
194
                
195
        
196
        
197
                
198
                        Banks nested inside a bank do not specify address.
199
                
200
                
201
                        
202
                        
203
                                
204
                                        
205
                                                
206
                                        
207
                                
208
                        
209
                        
210
                
211
                
212
                
213
        
214
        
215
                
216
                        Banks nested inside a bank do not specify address.
217
                
218
                
219
                        
220
                        
221
                                
222
                                        
223
                                                
224
                                        
225
                                
226
                        
227
                        
228
                
229
                
230
                
231
        
232
        
233
                
234
                        Address blocks inside a bank do not specify address.
235
                
236
                
237
                        
238
                        
239
                                
240
                                        
241
                                                
242
                                        
243
                                
244
                        
245
                        
246
                        
247
                        
248
                        
249
                
250
                
251
        
252
        
253
                
254
                        Subspace references inside banks do not specify an address.
255
                
256
                
257
                        
258
                        
259
                        
260
                                
261
                                        Any parameters that may apply to the subspace reference.
262
                                
263
                        
264
                        
265
                
266
                
267
                        
268
                                For subspaceMap elements, this attribute identifies the master that contains the address space to be mapped.
269
                        
270
                
271
                
272
        
273
        
274
                
275
                        A field within a register
276
                
277
                
278
                        
279
                        
280
                                
281
                                        
282
                                                
283
                                        
284
                                
285
                        
286
                        
287
                        
288
                                
289
                                        Offset of this field's bit 0 from bit 0 of the register.
290
                                
291
                        
292
                        
293
                                
294
                                        
295
                                                
296
                                                        
297
                                                                BitField reset value
298
                                                        
299
                                                
300
                                        
301
                                
302
                        
303
                        
304
                        
305
                        
306
                
307
                
308
                
309
                        
310
                                A unique identifier within a component for a field.
311
                
312
                
313
        
314
        
315
                
316
                        A group elements for a memoryMap
317
                
318
                
319
                        
320
                        
321
                        
322
                                
323
                                        Maps in an address subspace from across a bus bridge.  Its masterRef attribute refers by name to the master bus interface on the other side of the bridge.  It must match the masterRef attribute of a bridge element on the slave interface, and that bridge element must be designated as opaque.
324
                                
325
                        
326
                
327
        
328
        
329
                
330
                        Map of address space blocks on slave slave bus interface.
331
                
332
                
333
                        
334
                        
335
                        
336
                        
337
                                
338
                                        Additional memory map elements that are dependent on the component state.
339
                                
340
                                
341
                                        
342
                                        
343
                                
344
                        
345
                        
346
                        
347
                                
348
                        When the value is 'yes', the contents of the memoryMap are shared by all the references to this memoryMap, when the value is 'no' the contents of the memoryMap is not shared and when the value is 'undefined' (default) the sharing of the memoryMap is undefined.
349
                
350
        
351
                        
352
                
353
                
354
        
355
        
356
                
357
                        Map of address space blocks on a slave bus interface in a specific remap state.
358
                
359
                
360
                        
361
                        
362
                        
363
                
364
                
365
                        
366
                                State of the component in which the memory map is active.
367
                        
368
                
369
                
370
        
371
        
372
                
373
                        Map of address space blocks on the local memory map of a master bus interface.
374
                
375
                
376
                        
377
                        
378
                        
379
                                
380
        
381
                
382
                        Represents a bank of memory made up of address blocks or other banks.  It has a bankAlignment attribute indicating whether its blocks are aligned in 'parallel' (occupying adjacent bit fields) or 'serial' (occupying contiguous addresses). Its child blocks do not contain addresses or bit offsets.
383
                
384
                
385
                        
386
                        
387
                
388
        
389
                        
390
                
391
                
392
        
393
        
394
                
395
                        Address subspace type.  Its subspaceReference attribute references the subspace from which the dimensions are taken.
396
                
397
                
398
                        
399
                                Any parameters that may apply to the subspace reference.
400
                        
401
                        
402
                        
403
                        
404
                        
405
                                
406
                                        Any parameters that may apply to the subspace reference.
407
                                
408
                        
409
                        
410
                
411
                
412
                        
413
                                For subspaceMap elements, this attribute identifies the master that contains the address space to be mapped.
414
                        
415
                
416
                
417
                        
418
                                Refernce to a segment of the addressSpace of the masterRef attribute.
419
                        
420
                
421
        
422
        
423
                
424
                        Indicates whether the data is volatile.
425
                
426
        
427
        
428
                
429
                        Indicates the accessibility of the data in the address bank, address block, register or field.  Possible values are 'read-write', 'read-only',  'write-only', 'writeOnce' and 'read-writeOnce'. If not specified the value is inherited from the containing object.
430
                
431
        
432
        
433
                
434
                        This is a single contiguous block of memory inside a memory map.
435
                
436
                
437
                        
438
                        
439
                
440
        
441
        
442
                
443
                        References the address space.  The name of the address space is kept in its addressSpaceRef attribute.
444
                
445
        
446
        
447
                
448
                        If this component is a bus master, this lists all the address spaces
449
defined by the component.
450
                
451
                
452
                        
453
                                
454
                                        
455
                                                This defines a logical space, referenced by a bus master.
456
                                        
457
                                        
458
                                                
459
                                                        
460
                                                        
461
                                                        
462
                                                        
463
                                                                
464
                                                                        Address segments withing an addressSpace 
465
                                                                
466
                                                                
467
                                                                        
468
                                                                                
469
                                                                                        
470
                                                                                                Address segment withing an addressSpace 
471
                                                                                        
472
                                                                                        
473
                                                                                                
474
                                                                                                        
475
                                                                                                        
476
                                                                                                        
477
                                                                                                                
478
                                                                                                                        Address offset of the segment within the containing address space.
479
                                                                                                                
480
                                                                                                        
481
                                                                                                        
482
                                                                                                                
483
                                                                                                                        The address range of asegment.  Expressed as the number of addressable units accessible to the segment.                                 
484
                                                                                                                
485
                                                                                                        
486
                                                                                                        
487
                                                                                                
488
                                                                                                
489
                                                                                        
490
                                                                                
491
                                                                        
492
                                                                
493
                                                        
494
                                                        
495
                                                        
496
                                                        
497
                                                                
498
                                                                        Provides the local memory map of an address space.  Blocks in this memory map are accessable to master interfaces on this component that reference this address space.   They are not accessable to any external master interface.
499
                                                                
500
                                                                
501
                                                                        
502
                                                                        
503
                                                                
504
                                                        
505
                                                        
506
                                                                
507
                                                                        Data specific to this address space.
508
                                                                
509
                                                        
510
                                                        
511
                                                
512
                                                
513
                                        
514
                                        
515
                                                
516
                                                
517
                                        
518
                                
519
                        
520
                
521
        
522
        
523
                
524
                        References the memory map. The name of the memory map is kept in its memoryMapRef attribute.
525
                
526
        
527
        
528
                
529
                        Lists all the slave memory maps defined by the component.
530
                
531
                
532
                        
533
                                
534
                                        
535
                                                The set of address blocks a bus slave contributes to the bus' address space.
536
                                        
537
                                        
538
                                                
539
                                                
540
                                        
541
                                        
542
                                                
543
                                                
544
                                        
545
                                
546
                        
547
                
548
        
549
        
550
                
551
                        Represents a bank of memory made up of address blocks or other banks.  It has a bankAlignment attribute indicating whether its blocks are aligned in 'parallel' (occupying adjacent bit fields) or 'serial' (occupying contiguous addresses). Its child blocks do not contain addresses or bit offsets.
552
                
553
                
554
                        
555
                        
556
                
557
        
558
        
559
                
560
                        Base of an address block, bank, subspace map or address space. Expressed as the number of addressable units from the containing memoryMap or localMemoryMap.
561
                
562
        
563
        
564
                
565
                        The number of data bits in an addressable unit. The default is byte addressable (8 bits).
566
                
567
        
568
        
569
                
570
                        This is a group of optional elements commonly added to various types of address blocks in a memory map.
571
                
572
                
573
                        
574
                        
575
                
576
        
577
        
578
                
579
                        This group of elements describes an absolute or relative address of an address block in a memory map.
580
 
581
Note that this is a group, not an element.  It does not appear in the XML, but its contents may.
582
                
583
                
584
                        
585
                
586
        
587
        
588
                
589
                        This group of elements is common to top level banks and banked banks.
590
                
591
                
592
                        
593
                        
594
                                
595
                                        
596
                                                An address block within the bank.  No address information is supplied.
597
                                        
598
                                        
599
                                                
600
                                                
601
                                        
602
                                
603
                                
604
                                        
605
                                                A nested bank of blocks within a bank.  No address information is supplied.
606
                                        
607
                                        
608
                                                
609
                                                
610
                                        
611
                                
612
                                
613
                                        
614
                                                A subspace map within the bank.  No address information is supplied.
615
                                        
616
                                
617
                        
618
                        
619
                        
620
                
621
        
622
        
623
                
624
                        This group of elements is common to top level banks and banked banks.
625
                
626
                
627
                        
628
                        
629
                                
630
                                        
631
                                                An address block within the bank.  No address information is supplied.
632
                                        
633
                                        
634
                                                
635
                                                
636
                                        
637
                                
638
                                
639
                                        
640
                                                A nested bank of blocks within a bank.  No address information is supplied.
641
                                        
642
                                        
643
                                                
644
                                                
645
                                        
646
                                
647
                        
648
                        
649
                        
650
                
651
        
652
        
653
                
654
                        This group of elements describes the number of addressable units and the width of a row of an address block in a memory map.
655
 
656
Note that this is a group, not an element.  It does not appear in the XML, but its contents may.
657
                
658
                
659
                        
660
                                
661
                                        The address range of an address block.  Expressed as the number of addressable units accessible to the block. The range and the width are related by the following formulas:
662
                                        number_of_bits_in_block = ipxact:addressUnitBits * ipxact:range
663
                                        number_of_rows_in_block = number_of_bits_in_block / ipxact:width
664
                                        
665
                                
666
                        
667
                        
668
                                
669
                                        The bit width of a row in the address block. The range and the width are related by the following formulas:
670
                                        number_of_bits_in_block = ipxact:addressUnitBits * ipxact:range
671
                                        number_of_rows_in_block = number_of_bits_in_block / ipxact:width
672
                                        
673
                                
674
                        
675
                
676
        
677
        
678
                
679
                        This group of optional elements can be used to provide additional descriptions to an address block or bank.
680
 
681
Note that this is a group, not an element.  It does not appear in the XML, but its contents may.
682
                
683
                
684
                        
685
                                
686
                                        Indicates the usage of this block.  Possible values are 'memory', 'register' and 'reserved'.
687
                                
688
                        
689
                        
690
                        
691
                        
692
                                
693
                                        Any additional parameters needed to describe this address block to the generators.
694
                                
695
                        
696
                
697
        
698
        
699
                
700
                        This group of optional elements describes the memory mapped registers of an address block
701
                
702
                
703
                        
704
                                
705
                                        A single register
706
                                
707
                                
708
                                        
709
                                                
710
                                                
711
                                                        
712
                                                                
713
                                                                        
714
                                                                
715
                                                        
716
                                                
717
                                                
718
                                                
719
                                                        
720
                                                                Dimensions a register array, the semantics for dim elements are the same as the C language standard for the  layout of memory in multidimensional arrays.
721
                                                        
722
                                                        
723
                                                                
724
                                                                        
725
                                                                                
726
                                                                        
727
                                                                
728
                                                        
729
                                                
730
                                                
731
                                                        
732
                                                                Offset from the address block's baseAddress or the containing register file's addressOffset, expressed as the number of addressUnitBits from the containing memoryMap or localMemoryMap.
733
                                                        
734
                                                
735
                                                
736
                                                
737
                                                
738
                                                
739
                                        
740
                                        
741
                                
742
                                
743
                                        
744
                                        
745
                                
746
                        
747
                        
748
                                
749
                                        A structure of registers and register files
750
                                
751
                        
752
                
753
        
754
        
755
                
756
                        Alternate definitions for the current register
757
                
758
                
759
                        
760
                                
761
                                        
762
                                                Alternate definition for the current register
763
                                        
764
                                        
765
                                                
766
                                                        
767
                                                        
768
                                                                
769
                                                                        
770
                                                                                
771
                                                                        
772
                                                                
773
                                                        
774
                                                        
775
                                                        
776
                                                                
777
                                                                        Defines a list of grouping names that this register description belongs.
778
                                                                
779
                                                                
780
                                                                        
781
                                                                                
782
                                                                                        
783
                                                                                                Defines a grouping name that this register description belongs.
784
                                                                                        
785
                                                                                        
786
                                                                                                
787
                                                                                                        
788
                                                                                                                
789
                                                                                                        
790
                                                                                                
791
                                                                                        
792
                                                                                
793
                                                                        
794
                                                                        
795
                                                                
796
                                                        
797
                                                        
798
                                                        
799
                                                        
800
                                                
801
                                                
802
                                        
803
                                        
804
                                                
805
                                                
806
                                        
807
                                
808
                        
809
                
810
                
811
                        
812
                        
813
                
814
        
815
        
816
                
817
                        Enumerates specific values that can be assigned to the bit field.
818
                
819
                
820
                        
821
                                
822
                                        
823
                                                Enumerates specific values that can be assigned to the bit field. The name of this enumerated value. This may be used as a token in generating code.
824
                                        
825
                                        
826
                                                
827
                                                        
828
                                                        
829
                                                                
830
                                                                        Enumerated bit field value.
831
                                                                
832
                                                        
833
                                                        
834
                                                
835
                                                
836
                                                        
837
                                                                Usage for the enumeration. 'read' for a software read access. 'write' for a software write access. 'read-write' for a software read or write access.
838
                                                        
839
                                                        
840
                                                                
841
                                                                        
842
                                                                        
843
                                                                        
844
                                                                
845
                                                        
846
                                                
847
                                                
848
                                        
849
                                
850
                        
851
                
852
                
853
                        
854
                        
855
                
856
        
857
        
858
                
859
                        This type is used to specify a value and optional mask that are configurable
860
                
861
                
862
        
863
        
864
                
865
                        
866
                        
867
                        
868
                        
869
                        
870
                        
871
                        
872
                        
873
                        
874
                
875
        
876
        
877
                
878
                        
879
                        
880
                        
881
                
882
        
883
        
884
                
885
                        Additional field data
886
                
887
                
888
                        
889
                                
890
                                        Indicates whether the data is volatile. The presumed value is 'false' if not present.
891
                                
892
                        
893
                        
894
                        
895
                        
896
                                
897
                                        If present this element describes the modification of field data caused by a write operation. 'oneToClear' means that in a bitwise fashion each write data bit of a one will clear the corresponding bit in the field. 'oneToSet' means that in a bitwise fashion each write data bit of a one will set the corresponding bit in the field.  'oneToToggle' means that in a bitwise fashion each write data bit of a one will toggle the corresponding bit in the field. 'zeroToClear' means that in a bitwise fashion each write data bit of a zero will clear the corresponding bit in the field. 'zeroToSet' means that in a bitwise fashion each write data bit of a zero will set the corresponding bit in the field. 'zeroToToggle' means that in a bitwise fashion each write data bit of a zero will toggle the corresponding bit in the field. 'clear' means any write to this field clears the field. 'set' means any write to the field sets the field. 'modify' means any write to this field may modify that data. If this element is not present the write operation data is written.
898
                                
899
                                
900
                                        
901
                                                
902
                                                        
903
                                                
904
                                        
905
                                
906
                        
907
                        
908
                                
909
                                        The legal values that may be written to a field. If not specified the legal values are not specified.
910
                                
911
                        
912
                        
913
                                
914
                                        A list of possible actions for a read to set the field after the read. 'clear' means that after a read the field is cleared. 'set' means that after a read the field is set. 'modify' means after a read the field is modified. If not present the field value is not modified after a read.
915
                                
916
                                
917
                                        
918
                                                
919
                                                        
920
                                                
921
                                        
922
                                
923
                        
924
                        
925
                                
926
                                        Can the field be tested with an automated register test routine. The presumed value is true if not specified.
927
                                
928
                                
929
                                        
930
                                                
931
                                                        
932
                                                                
933
                                                                        Constraint for an automated register test routine. 'unconstrained' (default) means may read and write all legal values. 'restore' means may read and write legal values but the value must be restored to the initially read value before accessing another register. 'writeAsRead' has limitations on testability where only the value read before a write may be written to the field. 'readOnly' has limitations on testability where values may only be read from the field.
934
                                                                
935
                                                                
936
                                                                        
937
                                                                                
938
                                                                                
939
                                                                                
940
                                                                                
941
                                                                        
942
                                                                
943
                                                        
944
                                                
945
                                        
946
                                
947
                        
948
                        
949
                                
950
                                        Indicates that the field should be documented as reserved. The presumed value is 'false' if not present.
951
                                
952
                        
953
                
954
        
955
        
956
                
957
                        A constraint on the values that can be written to this field. Absence of this element implies that any value that fits can be written to it.
958
                
959
                
960
                        
961
                                
962
                                        writeAsRead indicates that only a value immediately read before a write is a legal value to be written.
963
                                
964
                        
965
                        
966
                                
967
                                        useEnumeratedValues indicates that only write enumeration value shall be legal values to be written.
968
                                
969
                        
970
                        
971
                                
972
                                        
973
                                                The minimum legal value that may be written to a field
974
                                        
975
                                
976
                                
977
                                        
978
                                                The maximum legal value that may be written to a field
979
                                        
980
                                
981
                        
982
                
983
        
984
        
985
                
986
                        A structure of registers and register files
987
                
988
                
989
                        
990
                                
991
                                
992
                                        
993
                                                
994
                                                        
995
                                                
996
                                        
997
                                
998
                                
999
                                
1000
                                        
1001
                                                Dimensions a register array, the semantics for dim elements are the same as the C language standard for the  layout of memory in multidimensional arrays.
1002
                                        
1003
                                        
1004
                                                
1005
                                                        
1006
                                                                
1007
                                                        
1008
                                                
1009
                                        
1010
                                
1011
                                
1012
                                        
1013
                                                Offset from the address block's baseAddress or the containing register file's addressOffset, expressed as the number of addressUnitBits from the containing memoryMap or localMemoryMap.
1014
                                        
1015
                                
1016
                                
1017
                                
1018
                                
1019
                        
1020
                        
1021
                
1022
                
1023
                        
1024
                        
1025
                
1026
        
1027
        
1028
                
1029
                        Field definition specific information
1030
                
1031
                
1032
                        
1033
                                
1034
                                        Identifier name used to indicate that multiple field elements contain the exact same information for the elements in the fieldDefinitionGroup.
1035
                                
1036
                        
1037
                        
1038
                                
1039
                                        Width of the field in bits.
1040
                                
1041
                        
1042
                        
1043
                
1044
        
1045
        
1046
                
1047
                        Register file defnition specific information
1048
                
1049
                
1050
                        
1051
                                
1052
                                        Identifier name used to indicate that multiple registerFile elements contain the exact same information except for the elements in the registerFileInstanceGroup.
1053
                                
1054
                        
1055
                        
1056
                                
1057
                                        The range of a register file.  Expressed as the number of addressable units accessible to the block. Specified in units of addressUnitBits.
1058
                                
1059
                        
1060
                        
1061
                
1062
        
1063
        
1064
                
1065
                        Address block definition specific information
1066
                
1067
                
1068
                        
1069
                                
1070
                                        Identifier name used to indicate that multiple addressBlock elements contain the exact same information except for the elements in the addressBlockInstanceGroup.
1071
                                
1072
                        
1073
                        
1074
                        
1075
                        
1076
                
1077
        
1078
        
1079
                
1080
                        Register definition specific information
1081
                
1082
                
1083
                        
1084
                                
1085
                                        Identifier name used to indicate that multiple register elements contain the exact same information for the elements in the registerDefinitionGroup.
1086
                                
1087
                        
1088
                        
1089
                                
1090
                                        Width of the register in bits.
1091
                                
1092
                        
1093
                        
1094
                        
1095
                        
1096
                                
1097
                                        
1098
                                                Describes individual bit fields within the register.
1099
                                        
1100
                                        
1101
                                                
1102
                                                
1103
                                        
1104
                                
1105
                        
1106
                
1107
        
1108
        
1109
                
1110
                        Alternate register definition specific information
1111
                
1112
                
1113
                        
1114
                                
1115
                                        Identifier name used to indicate that multiple register elements contain the exact same information for the elements in the alternateRegisterDefinitionGroup.
1116
                                
1117
                        
1118
                        
1119
                        
1120
                        
1121
                                
1122
                                        
1123
                                                Describes individual bit fields within the register.
1124
                                        
1125
                                        
1126
                                                
1127
                                                
1128
                                        
1129
                                
1130
                        
1131
                
1132
        
1133
        
1134
                
1135
                        Register value at reset.
1136
                
1137
                
1138
                        
1139
                                
1140
                                        
1141
                                                The value itself.
1142
                                        
1143
                                
1144
                                
1145
                                        
1146
                                                Mask to be anded with the value before comparing to the reset value.
1147
                                        
1148
                                
1149
                        
1150
                        
1151
                                
1152
                                        Reference to a user defined resetType. Assumed to be HARD if not present.
1153
                                
1154
                        
1155
                        
1156
                
1157
        
1158

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.