From fb71935198a214aa67159382d529122234368160 Mon Sep 17 00:00:00 2001 From: Luca Valente Date: Wed, 25 Nov 2020 14:24:44 +0100 Subject: [PATCH] branch first commit --- .../plp_flash_stimuli.cpython-34.pyc | Bin 0 -> 13250 bytes bin/plp_flash_stimuli.py | 469 ++++++++++++++++++ bin/plp_mkflash | 89 ++++ bin/slm_hyper.py | 30 ++ rules/pulpos/default_rules.mk | 6 +- 5 files changed, 592 insertions(+), 2 deletions(-) create mode 100644 bin/__pycache__/plp_flash_stimuli.cpython-34.pyc create mode 100755 bin/plp_flash_stimuli.py create mode 100755 bin/plp_mkflash create mode 100755 bin/slm_hyper.py diff --git a/bin/__pycache__/plp_flash_stimuli.cpython-34.pyc b/bin/__pycache__/plp_flash_stimuli.cpython-34.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac47a73d5426b77286ef609d11029ef8fd0d5f82 GIT binary patch literal 13250 zcmc&*OKe=%c|P~vd2@zu4oN+%v1L8Rkt|tGB3ZU&N|t3imT5UuLUkH-I-I#AM;gv> z&b^d|Q>soQrCqc@fuau}i+0gPkVPM8gQAO~ExHKW6zHZvQQU1eWfxtvi$2i8{l5R) zJ1;U#0xvSuoH_5ufByeF-}&#=zh-lpZ@>QM<-fb8)IX_#PY&@Ve7*ldP{ThXpf)f`oesb^>tS2g@gNIaoxNmWZp9FerDWh9sj0oC$<(MmNcol>=F$(@dJbI6@hwOPrXjdI7i2=i|P zJHl|7#%2F%EBl}psS}s~a@}1kaZq*xZ)nN`k{EgxJHoo3b z1ba$75JBx(YR^{dw#q-XL?|mod$~Kdbn4=jdxcXMFWt+azxZQa_uZls#MaSk5UbQ` zI*322GDRa13v2b}h3&?6dA(8bHp?FJb{h4Uw|9eFZD(uy#;)()ZLKu6<~eg4fwFWO;b&jk z=eaaZ$rK$;;pjMn1OqO~1S!OVaZY7rv!#8R%Ms*7bIBn7+2?ZQN1uy`WwoViGL_>4 zQyKd#Q^`g<{>m4B%(>idH8*4~g@L(b2j@cJQjVg1Uq+W%gU!y596!@-vD_0A%2fhmGLC9D(?n`RF9=_3x%C(ii?vA0`W+e4~E-4vO&h$vN-I3rF}0kV^tFlXii%@n$~mNA0e@`BiQ#or8K4_ftR5NlSp+#tE(`d+;Y zvt~#m_uR&MkgU};>*_oP9~DQcT&_3ke!2V-3PWiuSZS-9<04*;N~_!me)!9sk<|d0 zIoaMcEu#xe+iIRL#0*>cMjv7dS-otm(`3hovZWF+eWe&*?k4VF;#UjZ>@9*yfpCRX zVg>8FS_l+G5jVRoYn#P<0>|@pkQNZSj_P^=nSh5y{ERL>MqRjo0*}V8teiDv&Ev0| zmc_Glxfl;1Bg(g24l?EPR;#wtU_4tcw|6QHQ=$pQy1<~1I1;0|=xGF0B9EfW+S$0| z9IkA~Q04zowv}Qm$la(nD|&au-Pi&?4`~{8R`%u;B2+MF4kD3``H0w*H}j#qp+?1m z*jmMd;?QgY2dHnv<`}WDFMXOpe{r%duKEhTq2i>eIQgN;^)zU?7}L+Qix(K2WFRu@ z_t+QLizxjfz5>lzTQfZ*EC(4&tZ)LsL1DorpMff1eLPKLLBdRFxk~Bq6UUdpCX)IV zA{(N`l$6-`Lr3Y~R6fLnq@`e@zq+NKK#?Qy5#i81@XH9Y^ChMqKzS7q@D23@#w%=O z5fJ#$R{BG+5*S8Y`3WhDqisw*NU{kAptZC=RQR{Lif#G$UK6In?MW;Lwq7eG-7@xC z@0JqVWq)_uEhX>VE#Lm=`pr^uySz=qD5ipxXH){{(Avf(a=k&^w9Db(*X3S?L}eQ_ zY9d?N+hSZcJ8*y*a*ATe#=6jiWZ3Gk?SBhHc#{Z}mA13?w3W4U_KY=YbtjC}dm8X# zC;)ARP#Gxz(^Y(XAD)m)_zCG=o&3fOi@Pd!7Pw7ruI+`ku1AqB&YUJ4H1aL z7=#dnAifDR&~+Y1bp;KqWB$jA6G3LJ)$)z*1&*#f4w4}k4N_H{X}9a154hV|Uk}FQ zl=x_U-E;jQz1C<|AM#`gQtUyfaq^L?*IGcvctuw?>p{|OR`u?-A0#TS_kp{MeAj#b zQFz|m#e@QkRrx*u&O4$oF1Aplo7m z^p{oHUOdX{&h+=WXL3Ej<0d=!%0~073{Prco3bcdC^uzmFYA|4TC_DyPQPm6a&|I* zWRAh40g)R$fx{FdLft(&Frm?ULuVE?&`gXR7?XJ*w1-$L>KB5e%n$6x(L5UTc?LXJ zk-_;1&Ea8uD9xEL6X3DlY61^8(ZUdayL;roJbTruq&xg@iaq(^O4_GAoG-`@Y+=Df zkDAjJnX^wYf3Xqpy#*W}CIMM@&XD}TW_TFeI5F}OXU2&D2nvsbWl&=7inFZ8F{Y?J zD33#$%VSr+h9HO=E_|68lnQW`0x4yhZpSyujWYu3jJumAQjhFnX}Vn2t(_+BAmw( zh~q0p_X#3c8TRvGO6m8g=P@WcmX5{ZB6Xj1gNQ10V?ZNp^+1jYAqbyStIbzc=iEr; zqkZ*37olER7F4c%Ppx9ul}L}M&>{yM_o70>f(ho!{WX=#q1oc<9x9c7H)?;VwBjPI zUDWZYu*%Acpyus7u2|j4e%C-Kh^tBo@iQc;Rb-G{8A-hsNebeDa`Yr5QWGJHAtC9g z<`Fg=t!TJfB!R$sU(?Nm1yLP>1g;A^Rh$UhmFhzgNwm}ii&IVavFyH4o?(nGjYT4Q zzv(|k_0VLp_EBpZYwqTUR&1n+sy~@^f4ooS4cD!|gt-2I0o7n|&H6TT#a2d^I}t6H zo&v1nS5R?u$%AM*QvD~h>>GlepJmy&>GciaHx60z{2|*+e^(C^DaRfX`~nhCV;E;= zo92G={-&5Okk3)qnf(PHQPd{T~5#K}^1;2xO9`EVOO5kA002d~4aY!I` z#O_WH2olZ=HmK4J`61<}0t=ds1IKvWLQ%ghm>`tF9KiG_Q3l8Y+XS3K)}WM@@}t8Q z3=^mBWgO4Ai{SIs=bh!7ZaKxY$S`=!EIbb^exvxa`EuIB~uJG`t0u{-bId8af6j=r_itXC_( z8)UTW?`T<2kbb9Ab+`R`s~JoV9a1<*%uyzgb%raR8?7J^UK}$_F+uY0YQed{VRLfw zU<|Rlt?)MBRJUrH9?rnp4jf9&L5mTsE{*q)L3;ds)c2l4K)Rl{!4d2;)*Oz&3EqvZ zdF0GN?YoNuYChaUH6on+zou!-i{83-?C36~Na5lml5_cgzzH+7Wt*t9kU-epRi)l3~Uh z;#~m;U@{pc(HQ@5mo>fHyqk9ZYH;N5%E%Z2r~ng(^8PIw0A_)=Xl(G7vxu_}Lk#^e zh6|p>iH#I25Ru}rYuJ8*W*%3amy|CTXJi15gz^E4&{0}|CA{(InCyB zahBdh2-0Eu_r!&6@CwhYE+a<4;!zf#2#KIOzaA|zi4lKMoLabYODB|bRy^}^mB|{4 z4%q;GfPshrngJMz}xYHU~pzW`9uEh{5!YFsIhzBYQ;*ZvUFK$}RwR0O)a< zY(H)M!Tq#&i^T>^{oG)ExZsA`8uUGSfu368(TMsw zyx(($=9;Jq%Pj956_j2?qHgNb1q!VDXTAVi*vZNL@@D9FNzVHMgVbz%L~luTYTq zy~JNU*<>nKtFNz{n~Gd^gyu*v0lV=c@{0sS>w(m*bV;d@Yk8Kx+jLf zpTIdheh)x7#U6krogRQ*8~{*SoN-G-F(Yl42f)A#AS%p@pa{>|ggCDUYR%5m_)toO zMV*)sBE+cUfHGjGzyRnAViQZOjFN=Xf2=yEB`yQrygw)O)d4`kONwr6fNA@;a8or? zh^Y{C!s-AWpfO+rY2e-HXyO-e#5IT!5dqVZ2;omE19Z$>pn^9niU8dRoP&?CS74Co z8)13~bO7c+UwG%+-vbv$%M=zmsbq1|C)|#HPEH93#_%*DX7CULf}i3}9c9u#h3Q}j zfvAHO!csVH542?woVWw|9lzh(&HL*rB(NA8d=xBmpeh@id@#;K^RW$w=EEa9kl)@n zxI0ClW~b9?fr}D^To|m$!kMsuRN747;3%`KgX4x3aHd(7)%oJ!vd%`!LPabKesS!S zSzo^qp!F|pIS?>0bOgSP5Ob45j7;|jBW`!RP*`3o(DprnHBu-8nVXD_BlxUHNuR8_ z9TSUmg~2j{{VZb~W`7Am{XcPWD&_|el+1JhM#VQJT?m#6PJ-bn4X$B8wv<};LOL2> z!*$Zrbj#^;46ZV`&p?1p*!32Zrx6rW=8ndqQU;f(vH@IyN)5Bbqlis|ccj9)#fBui zqx|+TfV^ZwsNQYVCO~GaB2$S}4q-Vf+M?f$>F6?*CdLC|(1;FQm{2jAT13u@h ze0;__ZT~P>ywrn5ZfWnC#XTgb9`fXZcdU0M3B$H{NA}J~N%MH(sw6?IK%U!oB>~on zMAHx&z=L6-a-)hZ2dPK(M=h^ay%Z$ZcN$xD9P`|3IM3)B7l(duV(7Fw2N%WVxmfr41Lw_XtDb1-qM#PPjj#77=*x&! z9}iC)Cd2oOphPAGC?>N6Zivs}GGd)ep=58~KNEU3AXb*34ldyYX8{=;7C409oLCYt zMk$fKbFbI@Lurl?cphcc5|0COvxo5iOlF0objL8!d;N*ilMIGQb0zo$gJ1zdV2LG6 zq-8#c$hI@L)9#H96qd(TJb0wDek;>$KRvptsKlH{p!9%hI32`+AOnL?hW!42)oSOx z-k5L7;RtQSfH<|`P{6b2lj8irEYTe(@&r|u_#95kvdBa~zSnL`WTiN^+&w)&N%;)d zE1WeJUl=5ZMWLvA8~ZKTxbGm=y$C8PPYVjTi<{>qg|mFL0!a1F71sGGhQTF6F^k>! zj=z5XiY~IB3WELrA^1%WfS;h0Jh%}UbdETS))Y$StnRS`_B7CO6&=fmrc}UJOzA%$R%+Ye{XO&vb<}Qw z%nS<1P&`zuDw;wqT5YBj4$_}$TIwFIu%-;?M!h&5@;hia`4pO^BONmu5n3tugYiK9 zyL0$xazp$9qoFZ06{Ef6gtQB~Y&?+4_RZ-m!@`=EX#Ho&pkT3JTCnH^x!TS|rUacf zH?TJK{_ky5b*P)9dP~~;b<{>Q9lgyGFBV}F*UVC(|B{<#Zbn_3AI=_QcJ@Gaj@jb} zvH=o{AjzYhOfq}wK=w4V6QkLS^I(?7ZHKwRRN=a{+OJ>_|3!=*f}0W7?YD*nHw~X| zTwH`#Y_6dvB zn13o0Kypqd`iIWY*5p(^oaltpc|F=^xGD$L0F}(9_a17(pMh5s!hQcY42os_W7vA6 zsW`iTUO*6x)67=%nw!l%qDcLyh>IOu=V&o@uU|~T47Wyq{bC$3Qr!NWv)a6>I+qWb zpy(y64#pZyq1SpOY8zVmo3upXCUTe`BPg+3A`gh=QPV*6JZ(9gYpkpZz| z|11K-TzT)`Utp5geqopb)|vpO`BYN-2#T{K5AXUuIsJK7nn4hxwki)@yb$OKq-w&G zL0BTc)(pgrDlaW8F)4U`i!p&?@&iqZVcuqtJAN9;2$y4smohja{IcP!ldQ|djgZSA zwPCy_?lYpXA(R>1u^p>`Z`_`x8`VQI+&h92Betd|DjXo9EKf{W`y5+EvV@ssc=ilFCl^q6; z7_2kcVDL)}`X`gbQq1F?FXJmOdSvZ0a}!QBmQ7|86Pf8W{xaE#g$3kX$-bV=Wv@#8 zTly8WxLX}V$Pa}~wc&nxUxz%Q5j-StfZ%@oRH-Lp;WMSZF@iZ=l;%wEu8Ctn_zz(n z9D0wC5SD&bd;>T=(#!_{KLK+=2!;~%pns0Gjbt9VH0@(#CO7ZTswcRnqB_ojah1P} zmhEo{2V>vp?=R%yj-CWP@W5m}hCU`#6K}=iI5P!+fL_5~M(KZ6dvc?`%!)Wx;g5)0 z%mO#U)ifm(Fe-#Mc0mfqz${Ju-qV;bNCAe1PckZuDeuej&Z_YWLWt;@Lc~aTVS`Rx zNr!^kwS06Z9!EU%Y42L?J=R3&N^xSjI{~#bY^hM^>sQ^JS9#>t$`!rg;faaiUdOOw z-TA`#^Fpi6(|vf}JZO3Il-JFmfV_tBm-%x2)nS`qj zCs%k}_czHUw<^ur)$R+?BPY<(LTH)&HX^BF0(TA)LA;AnX?O;M1iupAuIIa3`fDgI zPL`5hV`~Nf)1Z{X!sP!P$i*y(Q)u3g@YYo+)8CU)T3Yc1u~JgEws=p{Fa@R881!wI zW*g)%^*$B+E-{Qa&W9uL8v>IS;0;XRu@7!xcpD&VE!wymD|i&uJb$gMnnH~X>dskn zj{aq|1!d+cEdY-b{>Ag-`DA`7|Eb#eKMRWg0{{R3 literal 0 HcmV?d00001 diff --git a/bin/plp_flash_stimuli.py b/bin/plp_flash_stimuli.py new file mode 100755 index 0000000..1bb7a79 --- /dev/null +++ b/bin/plp_flash_stimuli.py @@ -0,0 +1,469 @@ +#!/usr/bin/env python3 + +# +# Copyright (C) 2015 ETH Zurich and University of Bologna +# All rights reserved. +# +# This software may be modified and distributed under the terms +# of the BSD license. See the LICENSE file for details. +# +# Authors: Germain Haugou (germain.haugou@gmail.com) +# + +#file extracted from pulp sdk : https://github.com/pulp-platform/pulp-sdk.git +#to be used in marsellus project + +import os +import struct +from elftools.elf.elffile import ELFFile +import subprocess + + + +def dumpByteToSlm(file, addr, value): + file.write("@%08X %02X\n" % (addr, value)) + +def dumpShortToSlm(file, addr, value): + file.write("@%08X %04X\n" % (addr, value)) + +def dumpWordToSlm(file, addr, value): + file.write("@%08X %08X\n" % (addr, value)) + +def dumpLongToSlm(file, addr, value): + file.write("@%08X %016X\n" % (addr, value)) + +def dump_word( filetoprint, addr, data_s): + for i in xrange(0,4,1): + filetoprint.write("@%08X %s\n" % ( addr+i, data_s[i*2:(i+1)*2] )) + return 4 + +class Comp(object): + + def __init__(self, dirpath, name): + self.path = os.path.join(dirpath, name) + self.name = name + self.size = os.path.getsize(self.path) + + def dump(self): + print (self.name) + print ('Path: ' + self.path) + print ('Flash addr: ' + str(self.flashAddr)) + print ('Size: ' + str(self.size)) + print ('') + +class BinarySegment(object): + + def __init__(self, base, data): + self.base = base + self.data = data + self.size = len(data) + +class Binary(object): + + def __init__(self, elf=None): + self.segments = [] + + if elf != None: + + with open(elf, 'rb') as file: + elffile = ELFFile(file) + + self.entry = elffile['e_entry'] + + for segment in elffile.iter_segments(): + if segment['p_type'] == 'PT_LOAD': + self.segments.append(BinarySegment(segment['p_paddr'], segment.data())) + + +class FlashImage(object): + + def __init__(self, raw=None, stimuli=None, verbose=True, archi=None, encrypt=False, aesKey=None, aesIv=None, flashType='spi', qpi=True): + + self.bootBinary = None + self.raw = raw + self.stimuli = stimuli + self.compList = [] + self.buff = [] + self.flashOffset = 0 + if flashType == 'hyper': self.blockSize = 1024 + else: self.blockSize = 4096 + self.bootaddr = 0x1c000000 + self.verbose = verbose + self.archi = archi + self.encrypt = encrypt + self.aesKey = aesKey + self.aesIv = aesIv + self.flashType = flashType + self.qpi = qpi + + + + def appendBootBinary(self, elf=None): + self.bootBinary = Binary(elf=elf) + + def appendComponent(self, dirname, name): + + self.compList.append(Comp(dirname, name)) + + def __roundToNextBlock(self): + nextOffset = (int)((self.flashOffset + self.blockSize - 1) / self.blockSize) * self.blockSize + padding = nextOffset - self.flashOffset + self.flashOffset = nextOffset + for i in range(0, padding): + self.buff.append(0) + + def __padBlock(self, size): + padsize = (int)((size + self.blockSize - 1) / self.blockSize) * self.blockSize - size + self.flashOffset += padsize + for i in range(0, padsize): + self.buff.append(0) + + def __pad(self, padsize, buff=None): + if buff is None: + self.flashOffset += padsize + for i in range(0, padsize): + self.buff.append(0) + else: + for i in range(0, padsize): + buff = self.__appendByte(0, buff=buff) + return buff + + def __appendInt(self, value, newBlock=False, buff=None): + if buff is None: + #if newBlock: self.__roundToNextBlock() + self.buff += struct.pack("I", value) + self.flashOffset += 4 + else: + buff += struct.pack("I", value) + return buff + + def __appendLongInt(self, value, newBlock=False, buff=None): + if buff is None: + #if newBlock: self.__roundToNextBlock() + self.buff += struct.pack("Q", value) + self.flashOffset += 8 + else: + buff += struct.pack("Q", value) + return buff + + def __appendByte(self, value, newBlock=False, buff=None): + if buff is None: + #if newBlock: self.__roundToNextBlock() + self.buff += struct.pack("B", value) + self.flashOffset += 1 + else: + buff += struct.pack("B", value) + return buff + + + def get_crc(self, buff): + crc = 0xffffffff + for data in buff: + crc = crc ^ data + for i in range(7, -1, -1): + if crc & 1 == 1: + mask = 0xffffffff + else: + mask = 0 + crc2 = crc >> 1 + crc = (crc >> 1) ^ (0xEDB88320 & mask) + + return (crc ^ 0xffffffff) + + + def __appendBuffer(self, buffer, newBlock=False, pad=False, encrypt=False, padToOffset=None): + #if newBlock: self.__roundToNextBlock() + if self.encrypt: + cmd = 'aes_encode %s %s' % (self.aesKey, self.aesIv) + + crc = self.get_crc(buffer) + buffer += struct.pack("I", crc) + + p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE) + out, err = p.communicate(buffer) + if p.returncode != 0: + raise Exception('Error when executing aes_encore to encrypt binary, probably this tool is not available') + buffer = out + + if padToOffset != None: + self.__pad(padToOffset - self.flashOffset) + + self.buff += buffer + self.flashOffset += len(buffer) + if pad: + self.__padBlock(len(buffer)) + + + + def __dumpToBuff(self): + self.__dumpBootBinaryToBuff() + self.__dumpCompsToBuff() + + def __dumpFlashHeader_v1(self): + + if self.verbose: + print ("Generating boot binary") + + index = 0 + print ("Merging following segments:") + for segment in self.bootBinary.segments: + if self.verbose: print (" Area %d: base: 0x%x, size: 0x%x" % (index, segment.base, segment.size)) + index = index + 1 + + l1Area = BinarySegment(0x10000000, []) + l2Area = BinarySegment(0x1c000000, []) + + self.bootBinary.mergedSegments = [l2Area, l1Area] + + for segment in self.bootBinary.segments: + if segment.base < 0x1c000000: area = l1Area + else: area = l2Area + if segment.base > area.base + area.size: + diff = segment.base - (area.base + area.size) + area.size += diff + for i in range(0, diff): + area.data.append(0) + + area.data += segment.data + area.size += segment.size + + # First compute areas flash information + flashOffset = 0 + flashOffset += 4*4*2 + + print ("Merged into:") + index = 0 + for segment in self.bootBinary.mergedSegments: + segment.nbBlocks = int((segment.size + self.blockSize - 1) / self.blockSize) + segment.offset = flashOffset + flashOffset += segment.nbBlocks * self.blockSize + if self.verbose: print (" Area %d: offset: 0x%x, base: 0x%x, size: 0x%x, nbBlocks: %d" % (index, segment.offset, segment.base, segment.size, segment.nbBlocks)) + index += 1 + + # Then write the header containing memory areas declaration + self.__appendInt(l2Area.offset) + self.__appendInt(l2Area.base) + self.__appendInt(l2Area.size) + self.__appendInt(l2Area.nbBlocks) + + self.__appendInt(l1Area.offset) + self.__appendInt(l1Area.base) + self.__appendInt(l1Area.size) + self.__appendInt(l1Area.nbBlocks) + + # Finally write the data + for area in self.bootBinary.mergedSegments: + self.__appendBuffer(area.data, pad=True, encrypt=self.encrypt) + + def __dumpFlashHeader_v2(self): + + if self.verbose: + print ("Generating boot binary") + print (" Nb areas: %d" % len(self.bootBinary.segments)) + + # First compute areas flash information + flashOffset = 0 + flashOffset += 4 + 4 + 4 + 4 + 16 * 4 * len(self.bootBinary.segments) + + crc_offset = flashOffset + flashOffset += 4 + + flashOffset = (flashOffset + self.blockSize - 1) & ~(self.blockSize - 1) + + if self.encrypt: + for segment in self.bootBinary.segments: + segment.size += 4 + + index = 0 + for segment in self.bootBinary.segments: + segment.nbBlocks = int((segment.size + self.blockSize - 1) / self.blockSize) + segment.offset = flashOffset + flashOffset += segment.nbBlocks * self.blockSize + if self.verbose: print (" Area %d: offset: 0x%x, base: 0x%x, size: 0x%x, nbBlocks: %d" % (index, segment.offset, segment.base, segment.size, segment.nbBlocks)) + index += 1 + + + + # Then write the header containing memory areas declaration + flashOffset = (flashOffset + 7) & ~7 + self.fsOffset = flashOffset + + header_buff = bytes([]) + header_buff = self.__appendInt(flashOffset, buff=header_buff) + header_buff = self.__appendInt(len(self.bootBinary.segments), buff=header_buff) + #self.__appendInt(self.bootBinary.entry) + header_buff = self.__appendInt(self.bootBinary.entry, buff=header_buff) + header_buff = self.__appendInt(self.bootaddr, buff=header_buff) + + for area in self.bootBinary.segments: + header_buff = self.__appendInt(area.offset, buff=header_buff) + header_buff = self.__appendInt(area.base, buff=header_buff) + header_buff = self.__appendInt(area.size, buff=header_buff) + header_buff = self.__appendInt(area.nbBlocks, buff=header_buff) + + header_buff = self.__pad(crc_offset - self.flashOffset - len(header_buff), buff=header_buff) + crc = self.get_crc(header_buff) + header_buff = self.__appendInt(crc, buff=header_buff) + self.__appendBuffer(header_buff, encrypt=self.encrypt) + + + + # Finally write the data + for area in self.bootBinary.segments: + self.__appendBuffer(area.data, padToOffset=area.offset, encrypt=self.encrypt) + + self.__pad(self.fsOffset - self.flashOffset) + + def __dumpBootBinaryToBuff(self): + if self.bootBinary != None: + + if self.archi == 'vivosoc2' or self.archi == 'fulmine': + self.__dumpFlashHeader_v1() + else: + self.__dumpFlashHeader_v2() + + else: + # In case no boot binary is there, we must have at least the first word telling where starts the next descriptor + self.__appendLongInt(8) + + + def __dumpCompsToBuff(self): + + # + # Flash address computation + # + + if self.verbose: print ('Generating files (header offset: 0x%x)' % self.flashOffset) + + flashAddr = self.flashOffset + headerSize = 0 + + # Compute the header size + headerSize += 12 # Header size and number of components + + for comp in self.compList: + headerSize += 12 # Flash address, size and path length + headerSize += len(comp.name)+1 # Path + + flashAddr += headerSize + + # Now set the flash address for each component + for comp in self.compList: + comp.flashAddr = (flashAddr + 3) & ~3 + if self. verbose: + print (' Adding component (name: %s, flashOffset: 0x%x)' % (comp.name, comp.flashAddr)) + flashAddr = comp.flashAddr + comp.size + + + # Now create the raw image as a byte array + + # First header size + self.__appendLongInt(headerSize) + + # Number of components + self.__appendInt(len(self.compList)) + + # Then for each component + for comp in self.compList: + # The flash address + self.__appendInt(comp.flashAddr) + + # Binary size + self.__appendInt(comp.size) + + # The path length + self.__appendInt(len(comp.name)+1) + + # And the path + self.__appendBuffer(comp.name.encode('utf-8')) + self.__appendByte(0) + + # Then dump all components + for comp in self.compList: + with open(comp.path, 'rb') as file: + self.__appendBuffer(file.read(), padToOffset=comp.flashAddr) + + + + def generate(self): + + self.__dumpToBuff() + + if self.raw != None: + try: + os.makedirs(os.path.dirname(self.raw)) + except: + pass + + with open(self.raw, 'wb') as file: + file.write(bytes(self.buff)) + + if self.stimuli != None: + + try: + os.makedirs(os.path.dirname(self.stimuli)) + except: + pass + + with open(self.stimuli, 'w') as file: + if self.flashType == 'mram': + last_bytes = len(self.buff) & 0x7 + for i in range(0, 8 - last_bytes): + self.__appendByte(0) + for i in range(0, len(self.buff)>>3): + value = (self.buff[i*8+7] << 56) + (self.buff[i*8+6] << 48) + (self.buff[i*8+5] << 40) + (self.buff[i*8+4] << 32) + (self.buff[i*8+3] << 24) + (self.buff[i*8+2] << 16) + (self.buff[i*8+1] << 8) + self.buff[i*8] + dumpLongToSlm(file, i, value) + elif self.flashType == 'hyper': + if len(self.buff) & 1 != 0: + self.__appendByte(0) + for i in range(0, len(self.buff)>>1): + value = (self.buff[i*2+1] << 8) + self.buff[i*2] + dumpShortToSlm(file, i, value) + elif self.archi == 'vivosoc2' or self.archi == 'fulmine': + if len(self.buff) % 4 != 0: + for i in range(0, 4 - (len(self.buff)%4)): + self.buff.append(0) + for i in range(0, len(self.buff), 4): + dumpByteToSlm(file, i, self.buff[i+3]) + dumpByteToSlm(file, i+1, self.buff[i+2]) + dumpByteToSlm(file, i+2, self.buff[i+1]) + dumpByteToSlm(file, i+3, self.buff[i+0]) + else: + for i in range(0, len(self.buff)): + dumpByteToSlm(file, i, self.buff[i]) + + +def genFlashImage(slmStim=None, raw_stim=None, bootBinary=None, comps=[], verbose=False, archi=None, encrypt=False, aesKey=None, aesIv=None, flashType='spi', qpi=True): + print('gen flash image') + saved_args = locals() + print("saved_args is", saved_args) + if bootBinary != None or len(comps) != 0: + if slmStim != None or raw_stim is not None: + compsList = '' + romBoot = '' + + if bootBinary != None: + romBoot = ' --flash-boot-binary=%s' % bootBinary + + for comp in comps: + compsList += ' --comp=%s' % comp + + if slmStim is not None: + cmd = "plp_mkflash %s %s --stimuli=%s --flash-type=%s" % (romBoot, compsList, slmStim, flashType) + else: + cmd = "plp_mkflash %s %s --raw=%s --flash-type=%s" % (romBoot, compsList, raw_stim, flashType) + + if qpi: cmd+= ' --qpi' + + if encrypt: cmd += ' --encrypt --aes-key=%s --aes-iv=%s' % (aesKey, aesIv) + + if verbose: cmd += ' --verbose' + if archi != None: cmd += ' --archi=%s' % archi + if not verbose: + print ('Building flash stimuli with command:') + print (cmd) + if os.system(cmd) != 0: + raise Exception('Error while generating flash image') + + + return 0 diff --git a/bin/plp_mkflash b/bin/plp_mkflash new file mode 100755 index 0000000..ef62723 --- /dev/null +++ b/bin/plp_mkflash @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 + +#file extracted from pulp sdk : https://github.com/pulp-platform/pulp-sdk.git +#to be used in marsellus project +import argparse +import os +from os import listdir +from os.path import isfile, join, isdir +import struct +import plp_flash_stimuli as plp_flash_stimuli + +class bcolors: + HEADER = '\033[95m' + OKBLUE = '\033[94m' + OKGREEN = '\033[92m' + WARNING = '\033[93m' + FAIL = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + +parser = argparse.ArgumentParser(description='Build flash image for Pulp') + +parser.add_argument("--flash-boot-binary", dest="flashBootBinary", default=None, help="Boot from flash") +parser.add_argument("--elf-loader", dest="elfLoader", default=None, help="Boot using the specified ELF loader") +parser.add_argument("--binary", dest="binary", default=None, help="Resident binary") +parser.add_argument("--flash-type", dest="flashType", default='spi', help="Flash type") +parser.add_argument("--comp-dir", dest="compDir", default=[], action="append", help="Component directory") +parser.add_argument("--comp-dir-rec", dest="compDirRec", default=[], action="append", help="Recursive component directory") +parser.add_argument("--comp", dest="comp", default=[], action="append", help="Component") +parser.add_argument("--stimuli", dest="stimuli", default=None, help="Generate stimuli") +parser.add_argument("--raw", dest="raw", default=None, help="Generate raw image") +parser.add_argument("--archi", dest="archi", default=None, help="Architecture") +parser.add_argument("--verbose", dest="verbose", action="store_true", help="Verbose mode") +parser.add_argument("--encrypt", dest="encrypt", action="store_true", help="Encrypt binary") +parser.add_argument("--qpi", dest="qpi", action="store_true", help="Use QPI") +parser.add_argument("--aes-key", dest="aesKey", default=None, help="AES key for encryption") +parser.add_argument("--aes-iv", dest="aesIv", default=None, help="AES init vector for encryption") + +args = parser.parse_args() + + + +def getFilesFromDir(path, rec=False, incDirInName=True): + files = [] + for file in listdir(path): + fullPath = os.path.join(path, file) + if isfile(fullPath): files.append(Comp(path, file)) + elif rec and isdir(fullPath): files += getFilesFromDir(fullPath, True) + return files + + +flashImage = plp_flash_stimuli.FlashImage(raw=args.raw, stimuli=args.stimuli, verbose=args.verbose, archi=args.archi, encrypt=args.encrypt, aesKey=args.aesKey, aesIv=args.aesIv, flashType=args.flashType, qpi=args.qpi) + + +# +# Boot binary +# + +# In case the chip is booting from ROM, the flash contains first the binary to be loaded into the chip by the ROM + +bootBinary = args.flashBootBinary +if bootBinary != None: + + flashImage.appendBootBinary(elf=bootBinary) + + +# +# Collect files from options +# + +for comp in args.comp: + flashImage.appendComponent(os.path.dirname(comp), os.path.basename(comp)) + +for compDir in args.compDir: + for dirname, name in getFilesFromDir(compDir, incDirInName=False): + flashImage.appendComponent(dirname, name) + +for compDir in args.compDirRec: + for dirname, name in getFilesFromDir(compDir, True, incDirInName=False): + flashImage.appendComponent(dirname, name) + + + +# +# Finally generate the image +# + +flashImage.generate() diff --git a/bin/slm_hyper.py b/bin/slm_hyper.py new file mode 100755 index 0000000..5732f63 --- /dev/null +++ b/bin/slm_hyper.py @@ -0,0 +1,30 @@ +#!/usr/bin/python3 + +#Written by ABA to update the format of the slm file to be compliant with hyperflash model used in testbench +import numpy as np +import os +import os.path +import argparse +import sys + +parser = argparse.ArgumentParser(description='Generate hyper memory image file from slm') + +parser.add_argument("--input", dest="input_file", default=None, help="Specify input file (ex. ./build/pulpissimo/slm_files/flash_stim.slm)") +parser.add_argument("--output", dest="output_file", default=None, help="Specify output file (ex. ./build/pulpissimo/slm_files/hyper_flash_stim.slm)") + +args = parser.parse_args() + +if args.input_file is None: + raise Exception('Specify the input file with --input= (ex. --input=./build/pulpissimo/slm_files/flash_stim.slm)') + +if args.output_file is None: + raise Exception('Specify the output file with --output= (ex. --output=./build/pulpissimo/slm_files/hyper_flash_stim.slm') + +delimiter=" " +with open(args.input_file, "rU") as fi: + data = list(map(lambda x:x.split(delimiter), fi.read().strip().split("\n"))) +fo=open(args.output_file, "w") +A=np.array(data) +fo.write('@000000\n') +for i in range(0, A.shape[0],2): + fo.write('%s%s\n' %(A[i+1][1],A[i][1])) \ No newline at end of file diff --git a/rules/pulpos/default_rules.mk b/rules/pulpos/default_rules.mk index 654fa33..1e70c83 100644 --- a/rules/pulpos/default_rules.mk +++ b/rules/pulpos/default_rules.mk @@ -224,11 +224,13 @@ $(TARGET_BUILD_DIR)/waves: run: $(TARGET_BUILD_DIR)/modelsim.ini $(TARGET_BUILD_DIR)/boot $(TARGET_BUILD_DIR)/tcl_files $(TARGET_BUILD_DIR)/waves $(PULPRT_HOME)/bin/stim_utils.py --binary=$(TARGETS) --vectors=$(TARGET_BUILD_DIR)/vectors/stim.txt + $(PULPRT_HOME)/bin/plp_mkflash --flash-boot-binary=$(TARGETS) --stimuli=$(TARGET_BUILD_DIR)/vectors/qspi_stim.slm --flash-type=spi --qpi + $(PULPRT_HOME)/bin/slm_hyper.py --input=$(TARGET_BUILD_DIR)/vectors/qspi_stim.slm --output=$(TARGET_BUILD_DIR)/vectors/hyper_stim.slm ifdef gui - cd $(TARGET_BUILD_DIR) && export VSIM_RUNNER_FLAGS="+ENTRY_POINT=0x1c008080 -gLOAD_L2=JTAG -dpicpppath /usr/bin/g++ -permit_unmatched_virtual_intf -gBAUDRATE=115200" && export VOPT_ACC_ENA="YES" && vsim -64 -do 'source $(VSIM_PATH)/tcl_files/config/run_and_exit.tcl' -do 'source $(VSIM_PATH)/tcl_files/run.tcl; ' + cd $(TARGET_BUILD_DIR) && export VSIM_RUNNER_FLAGS="+ENTRY_POINT=0x1c008080 -dpicpppath /usr/bin/g++ -permit_unmatched_virtual_intf -gBAUDRATE=115200" && export VOPT_ACC_ENA="YES" && vsim -64 -do 'source $(VSIM_PATH)/tcl_files/config/run_and_exit.tcl' -do 'source $(VSIM_PATH)/tcl_files/run.tcl; ' else - cd $(TARGET_BUILD_DIR) && export VSIM_RUNNER_FLAGS="+ENTRY_POINT=0x1c008080 -gLOAD_L2=JTAG -dpicpppath /usr/bin/g++ -permit_unmatched_virtual_intf -gBAUDRATE=115200" && vsim -64 -c -do 'source $(VSIM_PATH)/tcl_files/config/run_and_exit.tcl' -do 'source $(VSIM_PATH)/tcl_files/run.tcl; run_and_exit;' + cd $(TARGET_BUILD_DIR) && export VSIM_RUNNER_FLAGS="+ENTRY_POINT=0x1c008080 -dpicpppath /usr/bin/g++ -permit_unmatched_virtual_intf -gBAUDRATE=115200" && vsim -64 -c -do 'source $(VSIM_PATH)/tcl_files/config/run_and_exit.tcl' -do 'source $(VSIM_PATH)/tcl_files/run.tcl; run_and_exit;' endif endif