Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | # ========== Copyright Header Begin ========================================== |
2 | # | |
3 | # OpenSPARC T2 Processor File: SS_State.py | |
4 | # Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved. | |
5 | # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES. | |
6 | # | |
7 | # The above named program is free software; you can redistribute it and/or | |
8 | # modify it under the terms of the GNU General Public | |
9 | # License version 2 as published by the Free Software Foundation. | |
10 | # | |
11 | # The above named program is distributed in the hope that it will be | |
12 | # useful, but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | # General Public License for more details. | |
15 | # | |
16 | # You should have received a copy of the GNU General Public | |
17 | # License along with this work; if not, write to the Free Software | |
18 | # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. | |
19 | # | |
20 | # ========== Copyright Header End ============================================ | |
21 | ||
22 | from SS_Access import * | |
23 | ||
24 | X = '0' | |
25 | ||
26 | RW = 'RW' | |
27 | RO = 'RO' | |
28 | R1C = 'R1C' | |
29 | RW1C = 'RW1C' | |
30 | ||
31 | class SS_Field: | |
32 | def old__init__(self,name,start,end,access,init): | |
33 | self.name = name | |
34 | self.start = start | |
35 | self.end = end | |
36 | self.access = access | |
37 | self.init = init | |
38 | self.width = end - start + 1 | |
39 | ||
40 | def __init__(self,nseai): | |
41 | self.name = nseai[0] | |
42 | self.start = nseai[1] | |
43 | self.end = nseai[2] | |
44 | self.access = nseai[3] | |
45 | self.init = nseai[4] | |
46 | self.width = self.end - self.start + 1 | |
47 | if self.end < self.start: | |
48 | raise RuntimeError, "end < start in field "+self.name | |
49 | ||
50 | def set_reg(self,reg): | |
51 | self.reg = reg | |
52 | if self.width == self.reg.size: | |
53 | self.mask = '~('+self.reg.type+')0' | |
54 | else: | |
55 | self.mask = '(('+self.reg.type+'(1) << '+str(self.width)+') - 1)' | |
56 | ||
57 | def cpp(self,file): | |
58 | if len(self.name): | |
59 | ofs = str(self.start) | |
60 | msk = '('+self.mask+' << '+ofs+')' | |
61 | set = '{ '+self.reg.type+' m = '+msk+'; _data = (_data &~ m) | ((v << '+ofs+') & m); return *this; }' | |
62 | get = '{ return (_data >> '+ofs+') & '+self.mask+'; }' | |
63 | for l in [ | |
64 | ' '+self.reg.type+'\t'+self.name+'()\t\t\t'+get, | |
65 | ' '+self.reg.class_name+'&\t'+self.name+'( '+self.reg.type+' v )\t'+set, | |
66 | ' const static uint64_t\t\tOFFSET_'+self.name.upper()+' = '+ofs+';', | |
67 | ' const static uint64_t\t\tWIDTH_'+self.name.upper()+' = '+str(self.width)+';', | |
68 | '']: | |
69 | file.write(l+'\n') | |
70 | ||
71 | def ro_mask(self): | |
72 | if self.access == RO: | |
73 | return '('+self.mask+' << '+str(self.start)+')' | |
74 | else: | |
75 | return '0' | |
76 | ||
77 | def rw_mask(self): | |
78 | if self.access == RW: | |
79 | return '('+self.mask+' << '+str(self.start)+')' | |
80 | else: | |
81 | return '0' | |
82 | ||
83 | def r1c_mask(self): | |
84 | if self.access == R1C: | |
85 | return '('+self.mask+' << '+str(self.start)+')' | |
86 | else: | |
87 | return '0' | |
88 | ||
89 | def w1c_mask(self): | |
90 | if self.access == RW1C: | |
91 | return '('+self.mask+' << '+str(self.start)+')' | |
92 | else: | |
93 | return '0' | |
94 | ||
95 | def init_val(self): | |
96 | return '(('+self.reg.type+')('+str(self.init)+') << '+str(self.start)+')' | |
97 | ||
98 | ||
99 | # Coding conventions have it that members and variables are all lower | |
100 | # case with underscore(underbar) as spacer and types are capitalized | |
101 | # with no underscores. capitalize_variable() converts member name to that | |
102 | ||
103 | def capitalize_variable(name): | |
104 | name = name.capitalize() | |
105 | us = name.find('_') | |
106 | if us >= 0: | |
107 | name = name[:us] + capitalize_variable(name[us+1:]) | |
108 | return name | |
109 | ||
110 | class SS_CtrReg: | |
111 | def __init__(self,class_prefix,name,table,index,access,size,fields): | |
112 | self.class_prefix = class_prefix | |
113 | self.name = name | |
114 | self.table = table | |
115 | self.index = index | |
116 | self.access = access | |
117 | self.size = size | |
118 | self.fields = map(SS_Field,fields) | |
119 | self.class_name = self.class_prefix+'_'+capitalize_variable(self.name) | |
120 | self.type = 'uint' + str(self.size) + '_t' | |
121 | for f in self.fields: | |
122 | f.set_reg(self) | |
123 | ||
124 | ||
125 | def cpp(self,file): | |
126 | if self.size == 0: | |
127 | return | |
128 | rw_mask='0' | |
129 | w1c_mask='0' | |
130 | for i,field in enumerate(self.fields): | |
131 | if i == 0: | |
132 | rw_mask=rw_mask+' | '+field.rw_mask() | |
133 | w1c_mask=w1c_mask+' | '+field.w1c_mask() | |
134 | else: | |
135 | rw_mask=rw_mask+'\n | '+field.rw_mask() | |
136 | w1c_mask=w1c_mask+'\n | '+field.w1c_mask() | |
137 | ||
138 | file.write('class %s /*{{{*/\n' % self.class_name) | |
139 | file.write('{\n') | |
140 | file.write(' public:\n') | |
141 | file.write(' %s()\n' % self.class_name) | |
142 | file.write(' :_data(0)\n') | |
143 | if self.fields != []: | |
144 | file.write(' ,_mask(%s)\n' % rw_mask) | |
145 | file.write(' {}\n') | |
146 | if self.fields != []: | |
147 | file.write(' %s( %s d, %s m, %s i )\n' % (self.class_name,self.type,self.type,self.type)) | |
148 | else: | |
149 | file.write(' %s( %s d )\n' % (self.class_name,self.type)) | |
150 | file.write(' :_data(d)\n') | |
151 | if self.fields != []: | |
152 | file.write(' ,_mask(m)\n') | |
153 | file.write(' {}\n') | |
154 | file.write('\n') | |
155 | if self.fields != []: | |
156 | file.write(' void reset() \t\t{ _data = 0; }\n') | |
157 | else: | |
158 | file.write(' void reset() \t\t{}\n') | |
159 | file.write('\n') | |
160 | file.write(' void snapshot( SS_SnapShot& ss )\t{ ss.val(&_data); }\n') | |
161 | file.write('\n') | |
162 | file.write(' const char* name() \t\t{ return "%s"; }\n' % self.name) | |
163 | file.write('\n') | |
164 | file.write(' %s operator()() \t\t{ return _data; }\n' % self.type) | |
165 | file.write('\n') | |
166 | file.write(' %s& operator=( %s v )\t{ _data = v; return *this; }\n' % (self.class_name,self.type)) | |
167 | file.write('\n') | |
168 | if self.fields == []: | |
169 | file.write(' void set( %s v )\t{ _data = v; }\n' % (self.type)) | |
170 | else: | |
171 | file.write(' void set( %s v )\t{ _data = (_data &~ _mask) | (v & _mask); }\n' % (self.type)) | |
172 | file.write('\n') | |
173 | for field in self.fields: | |
174 | field.cpp(file) | |
175 | file.write(' protected:\n') | |
176 | file.write(' %s _data;\n' % self.type) | |
177 | if self.fields != []: | |
178 | file.write(' %s _mask;\n' % self.type) | |
179 | file.write('};\n') | |
180 | file.write('/*}}}*/\n') | |
181 | ||
182 | def run_exe_rd(self): | |
183 | pass | |
184 | ||
185 | def run_exe_wr(self): | |
186 | pass | |
187 | ||
188 | ||
189 | class SS_CtrTable: | |
190 | def __init__(self,regs): | |
191 | self.table = {} | |
192 | for r in regs: | |
193 | self.table[r.index] = r | |
194 | ||
195 | def reg_at(self,index): | |
196 | if self.table.has_key(index): | |
197 | return self.table[index] | |
198 | else: | |
199 | return None | |
200 | ||
201 | #============================================================================ | |
202 | # SS_AsiCtrReg(prefix,name,fields) | |
203 | #============================================================================ | |
204 | ||
205 | SHARED ='SS_SharedAsiCtrReg' | |
206 | PRIVATE='SS_AsiCtrReg' | |
207 | ||
208 | class SS_AsiCtrReg: | |
209 | def __init__(self,prefix,name,inheritance,fields,code=[],constructor_code=[]): | |
210 | self.class_prefix = prefix | |
211 | self.name = name | |
212 | self.inheritance = inheritance | |
213 | self.fields = map(SS_Field,fields) | |
214 | self.size = 64 | |
215 | self.type = 'uint64_t' | |
216 | self.class_name = self.class_prefix+'_'+capitalize_variable(self.name) | |
217 | for f in self.fields: | |
218 | f.set_reg(self) | |
219 | self.code = code | |
220 | self.constructor_code = constructor_code | |
221 | ||
222 | ||
223 | def cpp(self,file): | |
224 | ro_mask ='\n , uint64_t(0)' | |
225 | rw_mask ='\n , uint64_t(0)' | |
226 | r1c_mask='\n , uint64_t(0)' | |
227 | w1c_mask='\n , uint64_t(0)' | |
228 | init ='\n , uint64_t(0)' | |
229 | for i,field in enumerate(self.fields): | |
230 | ro_mask=ro_mask+ '\n | '+field.ro_mask() | |
231 | rw_mask=rw_mask+ '\n | '+field.rw_mask() | |
232 | r1c_mask=r1c_mask+'\n | '+field.r1c_mask() | |
233 | w1c_mask=w1c_mask+'\n | '+field.w1c_mask() | |
234 | init=init+ '\n | '+field.init_val() | |
235 | ||
236 | for l in [ | |
237 | 'class '+self.class_name+' : public '+self.inheritance+' /*{{{*/', | |
238 | '{\n', | |
239 | ' public:\n', | |
240 | ' '+self.class_name+'()\n', | |
241 | ' :\n', | |
242 | ' '+self.inheritance+'("'+self.name+'"'+ro_mask+r1c_mask+rw_mask+w1c_mask+init+')\n', | |
243 | ' {']: | |
244 | file.write(l) | |
245 | if self.constructor_code != []: | |
246 | file.write('\n') | |
247 | for line in self.constructor_code: | |
248 | file.write(' %s\n' % line) | |
249 | for l in [ | |
250 | ' }', | |
251 | '', | |
252 | ' uint64_t operator()()\t\t{ return get(); }', | |
253 | '', | |
254 | ' '+self.class_name+'& operator=( uint64_t v )\t{ set(v); return *this; }', | |
255 | '']: | |
256 | file.write(l+'\n') | |
257 | ||
258 | for field in self.fields: | |
259 | field.cpp(file) | |
260 | ||
261 | if self.code != []: | |
262 | file.write('\n') | |
263 | for line in self.code: | |
264 | file.write(' %s\n' % line) | |
265 | ||
266 | for l in [ | |
267 | '};', | |
268 | '/*}}}*/']: | |
269 | file.write(l+'\n') | |
270 | ||
271 | def run_exe_rd(self): | |
272 | pass | |
273 | ||
274 | def run_exe_wr(self): | |
275 | pass | |
276 | ||
277 | class SS_RasCtrReg: | |
278 | def __init__(self,class_prefix,name,table,index,access,size,fields,code=[]): | |
279 | self.class_prefix = class_prefix | |
280 | self.name = name | |
281 | self.table = table | |
282 | self.index = index | |
283 | self.access = access | |
284 | self.size = size | |
285 | self.fields = map(SS_Field,fields) | |
286 | self.class_name = self.class_prefix+'_'+capitalize_variable(self.name) | |
287 | self.type = 'uint' + str(self.size) + '_t' | |
288 | for f in self.fields: | |
289 | f.set_reg(self) | |
290 | ||
291 | self.code = code | |
292 | ||
293 | def cpp(self,file): | |
294 | if self.size == 0: | |
295 | return | |
296 | mask='0' | |
297 | for i,field in enumerate(self.fields): | |
298 | if i == 0: | |
299 | mask=mask+' | '+field.rw_mask() | |
300 | else: | |
301 | mask=mask+'\n | '+field.rw_mask() | |
302 | ||
303 | file.write('class %s /*{{{*/\n' % self.class_name) | |
304 | file.write('{\n') | |
305 | file.write(' public:\n') | |
306 | file.write(' %s()\n' % self.class_name) | |
307 | file.write(' :_data(0)\n') | |
308 | if self.fields != []: | |
309 | file.write(' ,_mask(%s)\n' % mask) | |
310 | file.write(' {}\n') | |
311 | if self.fields != []: | |
312 | file.write(' %s( %s d, %s m, %s i )\n' % (self.class_name,self.type,self.type,self.type)) | |
313 | else: | |
314 | file.write(' %s( %s d )\n' % (self.class_name,self.type)) | |
315 | file.write(' :_data(d)\n') | |
316 | if self.fields != []: | |
317 | file.write(' ,_mask(m)\n') | |
318 | file.write(' {}\n') | |
319 | file.write('\n') | |
320 | if self.fields != []: | |
321 | file.write(' void reset() \t\t{ _data = 0; }\n') | |
322 | else: | |
323 | file.write(' void reset() \t\t{}\n') | |
324 | file.write('\n') | |
325 | file.write(' void snapshot( SS_SnapShot& ss )\t{ ss.val(&_data); }\n') | |
326 | file.write('\n') | |
327 | file.write(' const char* name() \t\t{ return "%s"; }\n' % self.name) | |
328 | file.write('\n') | |
329 | file.write(' %s operator()() \t\t{ return _data; }\n' % self.type) | |
330 | file.write('\n') | |
331 | file.write(' %s& operator=( %s v )\t{ _data = v; return *this; }\n' % (self.class_name,self.type)) | |
332 | file.write('\n') | |
333 | if self.fields == []: | |
334 | file.write(' void set( %s v )\t{ _data = v; }\n' % (self.type)) | |
335 | else: | |
336 | file.write(' void set( %s v )\t{ _data = (_data &~ _mask) | (v & _mask); }\n' % (self.type)) | |
337 | file.write('\n') | |
338 | for field in self.fields: | |
339 | field.cpp(file) | |
340 | file.write(' const static uint8_t bit_size_%s = %s;\n' % (field.name,field.width)) | |
341 | ||
342 | if self.code != []: | |
343 | file.write('\n') | |
344 | for line in self.code: | |
345 | file.write(' %s;\n' % line) | |
346 | ||
347 | file.write(' protected:\n') | |
348 | file.write(' %s _data;\n' % self.type) | |
349 | if self.fields != []: | |
350 | file.write(' %s _mask;\n' % self.type) | |
351 | file.write('};\n') | |
352 | file.write('/*}}}*/\n') | |
353 | ||
354 | def run_exe_rd(self): | |
355 | pass | |
356 | ||
357 | def run_exe_wr(self): | |
358 | pass | |
359 | ||
360 | ||
361 | ||
362 | ||
363 | ||
364 |