image.c 84 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194
  1. /*
  2. * (C) Copyright 2008 Semihalf
  3. *
  4. * (C) Copyright 2000-2006
  5. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  6. *
  7. * See file CREDITS for list of people who contributed to this
  8. * project.
  9. *
  10. * This program is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU General Public License as
  12. * published by the Free Software Foundation; either version 2 of
  13. * the License, or (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23. * MA 02111-1307 USA
  24. */
  25. #ifndef USE_HOSTCC
  26. #include <common.h>
  27. #include <watchdog.h>
  28. #ifdef CONFIG_SHOW_BOOT_PROGRESS
  29. #include <status_led.h>
  30. #endif
  31. #ifdef CONFIG_HAS_DATAFLASH
  32. #include <dataflash.h>
  33. #endif
  34. #ifdef CONFIG_LOGBUFFER
  35. #include <logbuff.h>
  36. #endif
  37. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
  38. #include <rtc.h>
  39. #endif
  40. #include <image.h>
  41. #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
  42. #include <fdt.h>
  43. #include <libfdt.h>
  44. #include <fdt_support.h>
  45. #endif
  46. #if defined(CONFIG_FIT)
  47. #include <u-boot/md5.h>
  48. #include <sha1.h>
  49. static int fit_check_ramdisk(const void *fit, int os_noffset,
  50. uint8_t arch, int verify);
  51. #endif
  52. #ifdef CONFIG_CMD_BDI
  53. extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
  54. #endif
  55. DECLARE_GLOBAL_DATA_PTR;
  56. static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
  57. int verify);
  58. #else
  59. #include "mkimage.h"
  60. #include <u-boot/md5.h>
  61. #include <time.h>
  62. #include <image.h>
  63. #endif /* !USE_HOSTCC*/
  64. static const table_entry_t uimage_arch[] = {
  65. { IH_ARCH_INVALID, NULL, "Invalid ARCH", },
  66. { IH_ARCH_ALPHA, "alpha", "Alpha", },
  67. { IH_ARCH_ARM, "arm", "ARM", },
  68. { IH_ARCH_I386, "x86", "Intel x86", },
  69. { IH_ARCH_IA64, "ia64", "IA64", },
  70. { IH_ARCH_M68K, "m68k", "M68K", },
  71. { IH_ARCH_MICROBLAZE, "microblaze", "MicroBlaze", },
  72. { IH_ARCH_MIPS, "mips", "MIPS", },
  73. { IH_ARCH_MIPS64, "mips64", "MIPS 64 Bit", },
  74. { IH_ARCH_NIOS2, "nios2", "NIOS II", },
  75. { IH_ARCH_PPC, "powerpc", "PowerPC", },
  76. { IH_ARCH_PPC, "ppc", "PowerPC", },
  77. { IH_ARCH_S390, "s390", "IBM S390", },
  78. { IH_ARCH_SH, "sh", "SuperH", },
  79. { IH_ARCH_SPARC, "sparc", "SPARC", },
  80. { IH_ARCH_SPARC64, "sparc64", "SPARC 64 Bit", },
  81. { IH_ARCH_BLACKFIN, "blackfin", "Blackfin", },
  82. { IH_ARCH_AVR32, "avr32", "AVR32", },
  83. { IH_ARCH_NDS32, "nds32", "NDS32", },
  84. { IH_ARCH_OPENRISC, "or1k", "OpenRISC 1000",},
  85. { -1, "", "", },
  86. };
  87. static const table_entry_t uimage_os[] = {
  88. { IH_OS_INVALID, NULL, "Invalid OS", },
  89. { IH_OS_LINUX, "linux", "Linux", },
  90. #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC)
  91. { IH_OS_LYNXOS, "lynxos", "LynxOS", },
  92. #endif
  93. { IH_OS_NETBSD, "netbsd", "NetBSD", },
  94. { IH_OS_OSE, "ose", "Enea OSE", },
  95. { IH_OS_RTEMS, "rtems", "RTEMS", },
  96. { IH_OS_U_BOOT, "u-boot", "U-Boot", },
  97. #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
  98. { IH_OS_QNX, "qnx", "QNX", },
  99. { IH_OS_VXWORKS, "vxworks", "VxWorks", },
  100. #endif
  101. #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC)
  102. { IH_OS_INTEGRITY,"integrity", "INTEGRITY", },
  103. #endif
  104. #ifdef USE_HOSTCC
  105. { IH_OS_4_4BSD, "4_4bsd", "4_4BSD", },
  106. { IH_OS_DELL, "dell", "Dell", },
  107. { IH_OS_ESIX, "esix", "Esix", },
  108. { IH_OS_FREEBSD, "freebsd", "FreeBSD", },
  109. { IH_OS_IRIX, "irix", "Irix", },
  110. { IH_OS_NCR, "ncr", "NCR", },
  111. { IH_OS_OPENBSD, "openbsd", "OpenBSD", },
  112. { IH_OS_PSOS, "psos", "pSOS", },
  113. { IH_OS_SCO, "sco", "SCO", },
  114. { IH_OS_SOLARIS, "solaris", "Solaris", },
  115. { IH_OS_SVR4, "svr4", "SVR4", },
  116. #endif
  117. { -1, "", "", },
  118. };
  119. static const table_entry_t uimage_type[] = {
  120. { IH_TYPE_AISIMAGE, "aisimage", "Davinci AIS image",},
  121. { IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image", },
  122. { IH_TYPE_FIRMWARE, "firmware", "Firmware", },
  123. { IH_TYPE_FLATDT, "flat_dt", "Flat Device Tree", },
  124. { IH_TYPE_KERNEL, "kernel", "Kernel Image", },
  125. { IH_TYPE_KERNEL_NOLOAD, "kernel_noload", "Kernel Image (no loading done)", },
  126. { IH_TYPE_KWBIMAGE, "kwbimage", "Kirkwood Boot Image",},
  127. { IH_TYPE_IMXIMAGE, "imximage", "Freescale i.MX Boot Image",},
  128. { IH_TYPE_INVALID, NULL, "Invalid Image", },
  129. { IH_TYPE_MULTI, "multi", "Multi-File Image", },
  130. { IH_TYPE_OMAPIMAGE, "omapimage", "TI OMAP SPL With GP CH",},
  131. { IH_TYPE_RAMDISK, "ramdisk", "RAMDisk Image", },
  132. { IH_TYPE_SCRIPT, "script", "Script", },
  133. { IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
  134. { IH_TYPE_UBLIMAGE, "ublimage", "Davinci UBL image",},
  135. { -1, "", "", },
  136. };
  137. static const table_entry_t uimage_comp[] = {
  138. { IH_COMP_NONE, "none", "uncompressed", },
  139. { IH_COMP_BZIP2, "bzip2", "bzip2 compressed", },
  140. { IH_COMP_GZIP, "gzip", "gzip compressed", },
  141. { IH_COMP_LZMA, "lzma", "lzma compressed", },
  142. { IH_COMP_LZO, "lzo", "lzo compressed", },
  143. { -1, "", "", },
  144. };
  145. uint32_t crc32(uint32_t, const unsigned char *, uint);
  146. uint32_t crc32_wd(uint32_t, const unsigned char *, uint, uint);
  147. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  148. static void genimg_print_time(time_t timestamp);
  149. #endif
  150. /*****************************************************************************/
  151. /* Legacy format routines */
  152. /*****************************************************************************/
  153. int image_check_hcrc(const image_header_t *hdr)
  154. {
  155. ulong hcrc;
  156. ulong len = image_get_header_size();
  157. image_header_t header;
  158. /* Copy header so we can blank CRC field for re-calculation */
  159. memmove(&header, (char *)hdr, image_get_header_size());
  160. image_set_hcrc(&header, 0);
  161. hcrc = crc32(0, (unsigned char *)&header, len);
  162. return (hcrc == image_get_hcrc(hdr));
  163. }
  164. int image_check_dcrc(const image_header_t *hdr)
  165. {
  166. ulong data = image_get_data(hdr);
  167. ulong len = image_get_data_size(hdr);
  168. ulong dcrc = crc32_wd(0, (unsigned char *)data, len, CHUNKSZ_CRC32);
  169. return (dcrc == image_get_dcrc(hdr));
  170. }
  171. /**
  172. * image_multi_count - get component (sub-image) count
  173. * @hdr: pointer to the header of the multi component image
  174. *
  175. * image_multi_count() returns number of components in a multi
  176. * component image.
  177. *
  178. * Note: no checking of the image type is done, caller must pass
  179. * a valid multi component image.
  180. *
  181. * returns:
  182. * number of components
  183. */
  184. ulong image_multi_count(const image_header_t *hdr)
  185. {
  186. ulong i, count = 0;
  187. uint32_t *size;
  188. /* get start of the image payload, which in case of multi
  189. * component images that points to a table of component sizes */
  190. size = (uint32_t *)image_get_data(hdr);
  191. /* count non empty slots */
  192. for (i = 0; size[i]; ++i)
  193. count++;
  194. return count;
  195. }
  196. /**
  197. * image_multi_getimg - get component data address and size
  198. * @hdr: pointer to the header of the multi component image
  199. * @idx: index of the requested component
  200. * @data: pointer to a ulong variable, will hold component data address
  201. * @len: pointer to a ulong variable, will hold component size
  202. *
  203. * image_multi_getimg() returns size and data address for the requested
  204. * component in a multi component image.
  205. *
  206. * Note: no checking of the image type is done, caller must pass
  207. * a valid multi component image.
  208. *
  209. * returns:
  210. * data address and size of the component, if idx is valid
  211. * 0 in data and len, if idx is out of range
  212. */
  213. void image_multi_getimg(const image_header_t *hdr, ulong idx,
  214. ulong *data, ulong *len)
  215. {
  216. int i;
  217. uint32_t *size;
  218. ulong offset, count, img_data;
  219. /* get number of component */
  220. count = image_multi_count(hdr);
  221. /* get start of the image payload, which in case of multi
  222. * component images that points to a table of component sizes */
  223. size = (uint32_t *)image_get_data(hdr);
  224. /* get address of the proper component data start, which means
  225. * skipping sizes table (add 1 for last, null entry) */
  226. img_data = image_get_data(hdr) + (count + 1) * sizeof(uint32_t);
  227. if (idx < count) {
  228. *len = uimage_to_cpu(size[idx]);
  229. offset = 0;
  230. /* go over all indices preceding requested component idx */
  231. for (i = 0; i < idx; i++) {
  232. /* add up i-th component size, rounding up to 4 bytes */
  233. offset += (uimage_to_cpu(size[i]) + 3) & ~3 ;
  234. }
  235. /* calculate idx-th component data address */
  236. *data = img_data + offset;
  237. } else {
  238. *len = 0;
  239. *data = 0;
  240. }
  241. }
  242. static void image_print_type(const image_header_t *hdr)
  243. {
  244. const char *os, *arch, *type, *comp;
  245. os = genimg_get_os_name(image_get_os(hdr));
  246. arch = genimg_get_arch_name(image_get_arch(hdr));
  247. type = genimg_get_type_name(image_get_type(hdr));
  248. comp = genimg_get_comp_name(image_get_comp(hdr));
  249. printf("%s %s %s (%s)\n", arch, os, type, comp);
  250. }
  251. /**
  252. * image_print_contents - prints out the contents of the legacy format image
  253. * @ptr: pointer to the legacy format image header
  254. * @p: pointer to prefix string
  255. *
  256. * image_print_contents() formats a multi line legacy image contents description.
  257. * The routine prints out all header fields followed by the size/offset data
  258. * for MULTI/SCRIPT images.
  259. *
  260. * returns:
  261. * no returned results
  262. */
  263. void image_print_contents(const void *ptr)
  264. {
  265. const image_header_t *hdr = (const image_header_t *)ptr;
  266. const char *p;
  267. #ifdef USE_HOSTCC
  268. p = "";
  269. #else
  270. p = " ";
  271. #endif
  272. printf("%sImage Name: %.*s\n", p, IH_NMLEN, image_get_name(hdr));
  273. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  274. printf("%sCreated: ", p);
  275. genimg_print_time((time_t)image_get_time(hdr));
  276. #endif
  277. printf("%sImage Type: ", p);
  278. image_print_type(hdr);
  279. printf("%sData Size: ", p);
  280. genimg_print_size(image_get_data_size(hdr));
  281. printf("%sLoad Address: %08x\n", p, image_get_load(hdr));
  282. printf("%sEntry Point: %08x\n", p, image_get_ep(hdr));
  283. if (image_check_type(hdr, IH_TYPE_MULTI) ||
  284. image_check_type(hdr, IH_TYPE_SCRIPT)) {
  285. int i;
  286. ulong data, len;
  287. ulong count = image_multi_count(hdr);
  288. printf("%sContents:\n", p);
  289. for (i = 0; i < count; i++) {
  290. image_multi_getimg(hdr, i, &data, &len);
  291. printf("%s Image %d: ", p, i);
  292. genimg_print_size(len);
  293. if (image_check_type(hdr, IH_TYPE_SCRIPT) && i > 0) {
  294. /*
  295. * the user may need to know offsets
  296. * if planning to do something with
  297. * multiple files
  298. */
  299. printf("%s Offset = 0x%08lx\n", p, data);
  300. }
  301. }
  302. }
  303. }
  304. #ifndef USE_HOSTCC
  305. /**
  306. * image_get_ramdisk - get and verify ramdisk image
  307. * @rd_addr: ramdisk image start address
  308. * @arch: expected ramdisk architecture
  309. * @verify: checksum verification flag
  310. *
  311. * image_get_ramdisk() returns a pointer to the verified ramdisk image
  312. * header. Routine receives image start address and expected architecture
  313. * flag. Verification done covers data and header integrity and os/type/arch
  314. * fields checking.
  315. *
  316. * If dataflash support is enabled routine checks for dataflash addresses
  317. * and handles required dataflash reads.
  318. *
  319. * returns:
  320. * pointer to a ramdisk image header, if image was found and valid
  321. * otherwise, return NULL
  322. */
  323. static const image_header_t *image_get_ramdisk(ulong rd_addr, uint8_t arch,
  324. int verify)
  325. {
  326. const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
  327. if (!image_check_magic(rd_hdr)) {
  328. puts("Bad Magic Number\n");
  329. show_boot_progress(-10);
  330. return NULL;
  331. }
  332. if (!image_check_hcrc(rd_hdr)) {
  333. puts("Bad Header Checksum\n");
  334. show_boot_progress(-11);
  335. return NULL;
  336. }
  337. show_boot_progress(10);
  338. image_print_contents(rd_hdr);
  339. if (verify) {
  340. puts(" Verifying Checksum ... ");
  341. if (!image_check_dcrc(rd_hdr)) {
  342. puts("Bad Data CRC\n");
  343. show_boot_progress(-12);
  344. return NULL;
  345. }
  346. puts("OK\n");
  347. }
  348. show_boot_progress(11);
  349. if (!image_check_os(rd_hdr, IH_OS_LINUX) ||
  350. !image_check_arch(rd_hdr, arch) ||
  351. !image_check_type(rd_hdr, IH_TYPE_RAMDISK)) {
  352. printf("No Linux %s Ramdisk Image\n",
  353. genimg_get_arch_name(arch));
  354. show_boot_progress(-13);
  355. return NULL;
  356. }
  357. return rd_hdr;
  358. }
  359. #endif /* !USE_HOSTCC */
  360. /*****************************************************************************/
  361. /* Shared dual-format routines */
  362. /*****************************************************************************/
  363. #ifndef USE_HOSTCC
  364. int getenv_yesno(char *var)
  365. {
  366. char *s = getenv(var);
  367. return (s && (*s == 'n')) ? 0 : 1;
  368. }
  369. ulong getenv_bootm_low(void)
  370. {
  371. char *s = getenv("bootm_low");
  372. if (s) {
  373. ulong tmp = simple_strtoul(s, NULL, 16);
  374. return tmp;
  375. }
  376. #if defined(CONFIG_SYS_SDRAM_BASE)
  377. return CONFIG_SYS_SDRAM_BASE;
  378. #elif defined(CONFIG_ARM)
  379. return gd->bd->bi_dram[0].start;
  380. #else
  381. return 0;
  382. #endif
  383. }
  384. phys_size_t getenv_bootm_size(void)
  385. {
  386. phys_size_t tmp;
  387. char *s = getenv("bootm_size");
  388. if (s) {
  389. tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
  390. return tmp;
  391. }
  392. s = getenv("bootm_low");
  393. if (s)
  394. tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
  395. else
  396. tmp = 0;
  397. #if defined(CONFIG_ARM)
  398. return gd->bd->bi_dram[0].size - tmp;
  399. #else
  400. return gd->bd->bi_memsize - tmp;
  401. #endif
  402. }
  403. phys_size_t getenv_bootm_mapsize(void)
  404. {
  405. phys_size_t tmp;
  406. char *s = getenv("bootm_mapsize");
  407. if (s) {
  408. tmp = (phys_size_t)simple_strtoull(s, NULL, 16);
  409. return tmp;
  410. }
  411. #if defined(CONFIG_SYS_BOOTMAPSZ)
  412. return CONFIG_SYS_BOOTMAPSZ;
  413. #else
  414. return getenv_bootm_size();
  415. #endif
  416. }
  417. void memmove_wd(void *to, void *from, size_t len, ulong chunksz)
  418. {
  419. if (to == from)
  420. return;
  421. #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
  422. while (len > 0) {
  423. size_t tail = (len > chunksz) ? chunksz : len;
  424. WATCHDOG_RESET();
  425. memmove(to, from, tail);
  426. to += tail;
  427. from += tail;
  428. len -= tail;
  429. }
  430. #else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
  431. memmove(to, from, len);
  432. #endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
  433. }
  434. #endif /* !USE_HOSTCC */
  435. void genimg_print_size(uint32_t size)
  436. {
  437. #ifndef USE_HOSTCC
  438. printf("%d Bytes = ", size);
  439. print_size(size, "\n");
  440. #else
  441. printf("%d Bytes = %.2f kB = %.2f MB\n",
  442. size, (double)size / 1.024e3,
  443. (double)size / 1.048576e6);
  444. #endif
  445. }
  446. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  447. static void genimg_print_time(time_t timestamp)
  448. {
  449. #ifndef USE_HOSTCC
  450. struct rtc_time tm;
  451. to_tm(timestamp, &tm);
  452. printf("%4d-%02d-%02d %2d:%02d:%02d UTC\n",
  453. tm.tm_year, tm.tm_mon, tm.tm_mday,
  454. tm.tm_hour, tm.tm_min, tm.tm_sec);
  455. #else
  456. printf("%s", ctime(&timestamp));
  457. #endif
  458. }
  459. #endif /* CONFIG_TIMESTAMP || CONFIG_CMD_DATE || USE_HOSTCC */
  460. /**
  461. * get_table_entry_name - translate entry id to long name
  462. * @table: pointer to a translation table for entries of a specific type
  463. * @msg: message to be returned when translation fails
  464. * @id: entry id to be translated
  465. *
  466. * get_table_entry_name() will go over translation table trying to find
  467. * entry that matches given id. If matching entry is found, its long
  468. * name is returned to the caller.
  469. *
  470. * returns:
  471. * long entry name if translation succeeds
  472. * msg otherwise
  473. */
  474. char *get_table_entry_name(const table_entry_t *table, char *msg, int id)
  475. {
  476. for (; table->id >= 0; ++table) {
  477. if (table->id == id)
  478. #if defined(USE_HOSTCC) || !defined(CONFIG_NEEDS_MANUAL_RELOC)
  479. return table->lname;
  480. #else
  481. return table->lname + gd->reloc_off;
  482. #endif
  483. }
  484. return (msg);
  485. }
  486. const char *genimg_get_os_name(uint8_t os)
  487. {
  488. return (get_table_entry_name(uimage_os, "Unknown OS", os));
  489. }
  490. const char *genimg_get_arch_name(uint8_t arch)
  491. {
  492. return (get_table_entry_name(uimage_arch, "Unknown Architecture",
  493. arch));
  494. }
  495. const char *genimg_get_type_name(uint8_t type)
  496. {
  497. return (get_table_entry_name(uimage_type, "Unknown Image", type));
  498. }
  499. const char *genimg_get_comp_name(uint8_t comp)
  500. {
  501. return (get_table_entry_name(uimage_comp, "Unknown Compression",
  502. comp));
  503. }
  504. /**
  505. * get_table_entry_id - translate short entry name to id
  506. * @table: pointer to a translation table for entries of a specific type
  507. * @table_name: to be used in case of error
  508. * @name: entry short name to be translated
  509. *
  510. * get_table_entry_id() will go over translation table trying to find
  511. * entry that matches given short name. If matching entry is found,
  512. * its id returned to the caller.
  513. *
  514. * returns:
  515. * entry id if translation succeeds
  516. * -1 otherwise
  517. */
  518. int get_table_entry_id(const table_entry_t *table,
  519. const char *table_name, const char *name)
  520. {
  521. const table_entry_t *t;
  522. #ifdef USE_HOSTCC
  523. int first = 1;
  524. for (t = table; t->id >= 0; ++t) {
  525. if (t->sname && strcasecmp(t->sname, name) == 0)
  526. return(t->id);
  527. }
  528. fprintf(stderr, "\nInvalid %s Type - valid names are", table_name);
  529. for (t = table; t->id >= 0; ++t) {
  530. if (t->sname == NULL)
  531. continue;
  532. fprintf(stderr, "%c %s", (first) ? ':' : ',', t->sname);
  533. first = 0;
  534. }
  535. fprintf(stderr, "\n");
  536. #else
  537. for (t = table; t->id >= 0; ++t) {
  538. #ifdef CONFIG_NEEDS_MANUAL_RELOC
  539. if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
  540. #else
  541. if (t->sname && strcmp(t->sname, name) == 0)
  542. #endif
  543. return (t->id);
  544. }
  545. debug("Invalid %s Type: %s\n", table_name, name);
  546. #endif /* USE_HOSTCC */
  547. return (-1);
  548. }
  549. int genimg_get_os_id(const char *name)
  550. {
  551. return (get_table_entry_id(uimage_os, "OS", name));
  552. }
  553. int genimg_get_arch_id(const char *name)
  554. {
  555. return (get_table_entry_id(uimage_arch, "CPU", name));
  556. }
  557. int genimg_get_type_id(const char *name)
  558. {
  559. return (get_table_entry_id(uimage_type, "Image", name));
  560. }
  561. int genimg_get_comp_id(const char *name)
  562. {
  563. return (get_table_entry_id(uimage_comp, "Compression", name));
  564. }
  565. #ifndef USE_HOSTCC
  566. /**
  567. * genimg_get_format - get image format type
  568. * @img_addr: image start address
  569. *
  570. * genimg_get_format() checks whether provided address points to a valid
  571. * legacy or FIT image.
  572. *
  573. * New uImage format and FDT blob are based on a libfdt. FDT blob
  574. * may be passed directly or embedded in a FIT image. In both situations
  575. * genimg_get_format() must be able to dectect libfdt header.
  576. *
  577. * returns:
  578. * image format type or IMAGE_FORMAT_INVALID if no image is present
  579. */
  580. int genimg_get_format(void *img_addr)
  581. {
  582. ulong format = IMAGE_FORMAT_INVALID;
  583. const image_header_t *hdr;
  584. #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
  585. char *fit_hdr;
  586. #endif
  587. hdr = (const image_header_t *)img_addr;
  588. if (image_check_magic(hdr))
  589. format = IMAGE_FORMAT_LEGACY;
  590. #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
  591. else {
  592. fit_hdr = (char *)img_addr;
  593. if (fdt_check_header(fit_hdr) == 0)
  594. format = IMAGE_FORMAT_FIT;
  595. }
  596. #endif
  597. return format;
  598. }
  599. /**
  600. * genimg_get_image - get image from special storage (if necessary)
  601. * @img_addr: image start address
  602. *
  603. * genimg_get_image() checks if provided image start adddress is located
  604. * in a dataflash storage. If so, image is moved to a system RAM memory.
  605. *
  606. * returns:
  607. * image start address after possible relocation from special storage
  608. */
  609. ulong genimg_get_image(ulong img_addr)
  610. {
  611. ulong ram_addr = img_addr;
  612. #ifdef CONFIG_HAS_DATAFLASH
  613. ulong h_size, d_size;
  614. if (addr_dataflash(img_addr)) {
  615. /* ger RAM address */
  616. ram_addr = CONFIG_SYS_LOAD_ADDR;
  617. /* get header size */
  618. h_size = image_get_header_size();
  619. #if defined(CONFIG_FIT)
  620. if (sizeof(struct fdt_header) > h_size)
  621. h_size = sizeof(struct fdt_header);
  622. #endif
  623. /* read in header */
  624. debug(" Reading image header from dataflash address "
  625. "%08lx to RAM address %08lx\n", img_addr, ram_addr);
  626. read_dataflash(img_addr, h_size, (char *)ram_addr);
  627. /* get data size */
  628. switch (genimg_get_format((void *)ram_addr)) {
  629. case IMAGE_FORMAT_LEGACY:
  630. d_size = image_get_data_size(
  631. (const image_header_t *)ram_addr);
  632. debug(" Legacy format image found at 0x%08lx, "
  633. "size 0x%08lx\n",
  634. ram_addr, d_size);
  635. break;
  636. #if defined(CONFIG_FIT)
  637. case IMAGE_FORMAT_FIT:
  638. d_size = fit_get_size((const void *)ram_addr) - h_size;
  639. debug(" FIT/FDT format image found at 0x%08lx, "
  640. "size 0x%08lx\n",
  641. ram_addr, d_size);
  642. break;
  643. #endif
  644. default:
  645. printf(" No valid image found at 0x%08lx\n",
  646. img_addr);
  647. return ram_addr;
  648. }
  649. /* read in image data */
  650. debug(" Reading image remaining data from dataflash address "
  651. "%08lx to RAM address %08lx\n", img_addr + h_size,
  652. ram_addr + h_size);
  653. read_dataflash(img_addr + h_size, d_size,
  654. (char *)(ram_addr + h_size));
  655. }
  656. #endif /* CONFIG_HAS_DATAFLASH */
  657. return ram_addr;
  658. }
  659. /**
  660. * fit_has_config - check if there is a valid FIT configuration
  661. * @images: pointer to the bootm command headers structure
  662. *
  663. * fit_has_config() checks if there is a FIT configuration in use
  664. * (if FTI support is present).
  665. *
  666. * returns:
  667. * 0, no FIT support or no configuration found
  668. * 1, configuration found
  669. */
  670. int genimg_has_config(bootm_headers_t *images)
  671. {
  672. #if defined(CONFIG_FIT)
  673. if (images->fit_uname_cfg)
  674. return 1;
  675. #endif
  676. return 0;
  677. }
  678. /**
  679. * boot_get_ramdisk - main ramdisk handling routine
  680. * @argc: command argument count
  681. * @argv: command argument list
  682. * @images: pointer to the bootm images structure
  683. * @arch: expected ramdisk architecture
  684. * @rd_start: pointer to a ulong variable, will hold ramdisk start address
  685. * @rd_end: pointer to a ulong variable, will hold ramdisk end
  686. *
  687. * boot_get_ramdisk() is responsible for finding a valid ramdisk image.
  688. * Curently supported are the following ramdisk sources:
  689. * - multicomponent kernel/ramdisk image,
  690. * - commandline provided address of decicated ramdisk image.
  691. *
  692. * returns:
  693. * 0, if ramdisk image was found and valid, or skiped
  694. * rd_start and rd_end are set to ramdisk start/end addresses if
  695. * ramdisk image is found and valid
  696. *
  697. * 1, if ramdisk image is found but corrupted, or invalid
  698. * rd_start and rd_end are set to 0 if no ramdisk exists
  699. */
  700. int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
  701. uint8_t arch, ulong *rd_start, ulong *rd_end)
  702. {
  703. ulong rd_addr, rd_load;
  704. ulong rd_data, rd_len;
  705. const image_header_t *rd_hdr;
  706. #if defined(CONFIG_FIT)
  707. void *fit_hdr;
  708. const char *fit_uname_config = NULL;
  709. const char *fit_uname_ramdisk = NULL;
  710. ulong default_addr;
  711. int rd_noffset;
  712. int cfg_noffset;
  713. const void *data;
  714. size_t size;
  715. #endif
  716. *rd_start = 0;
  717. *rd_end = 0;
  718. /*
  719. * Look for a '-' which indicates to ignore the
  720. * ramdisk argument
  721. */
  722. if ((argc >= 3) && (strcmp(argv[2], "-") == 0)) {
  723. debug("## Skipping init Ramdisk\n");
  724. rd_len = rd_data = 0;
  725. } else if (argc >= 3 || genimg_has_config(images)) {
  726. #if defined(CONFIG_FIT)
  727. if (argc >= 3) {
  728. /*
  729. * If the init ramdisk comes from the FIT image and
  730. * the FIT image address is omitted in the command
  731. * line argument, try to use os FIT image address or
  732. * default load address.
  733. */
  734. if (images->fit_uname_os)
  735. default_addr = (ulong)images->fit_hdr_os;
  736. else
  737. default_addr = load_addr;
  738. if (fit_parse_conf(argv[2], default_addr,
  739. &rd_addr, &fit_uname_config)) {
  740. debug("* ramdisk: config '%s' from image at "
  741. "0x%08lx\n",
  742. fit_uname_config, rd_addr);
  743. } else if (fit_parse_subimage(argv[2], default_addr,
  744. &rd_addr, &fit_uname_ramdisk)) {
  745. debug("* ramdisk: subimage '%s' from image at "
  746. "0x%08lx\n",
  747. fit_uname_ramdisk, rd_addr);
  748. } else
  749. #endif
  750. {
  751. rd_addr = simple_strtoul(argv[2], NULL, 16);
  752. debug("* ramdisk: cmdline image address = "
  753. "0x%08lx\n",
  754. rd_addr);
  755. }
  756. #if defined(CONFIG_FIT)
  757. } else {
  758. /* use FIT configuration provided in first bootm
  759. * command argument
  760. */
  761. rd_addr = (ulong)images->fit_hdr_os;
  762. fit_uname_config = images->fit_uname_cfg;
  763. debug("* ramdisk: using config '%s' from image "
  764. "at 0x%08lx\n",
  765. fit_uname_config, rd_addr);
  766. /*
  767. * Check whether configuration has ramdisk defined,
  768. * if not, don't try to use it, quit silently.
  769. */
  770. fit_hdr = (void *)rd_addr;
  771. cfg_noffset = fit_conf_get_node(fit_hdr,
  772. fit_uname_config);
  773. if (cfg_noffset < 0) {
  774. debug("* ramdisk: no such config\n");
  775. return 1;
  776. }
  777. rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
  778. cfg_noffset);
  779. if (rd_noffset < 0) {
  780. debug("* ramdisk: no ramdisk in config\n");
  781. return 0;
  782. }
  783. }
  784. #endif
  785. /* copy from dataflash if needed */
  786. rd_addr = genimg_get_image(rd_addr);
  787. /*
  788. * Check if there is an initrd image at the
  789. * address provided in the second bootm argument
  790. * check image type, for FIT images get FIT node.
  791. */
  792. switch (genimg_get_format((void *)rd_addr)) {
  793. case IMAGE_FORMAT_LEGACY:
  794. printf("## Loading init Ramdisk from Legacy "
  795. "Image at %08lx ...\n", rd_addr);
  796. show_boot_progress(9);
  797. rd_hdr = image_get_ramdisk(rd_addr, arch,
  798. images->verify);
  799. if (rd_hdr == NULL)
  800. return 1;
  801. rd_data = image_get_data(rd_hdr);
  802. rd_len = image_get_data_size(rd_hdr);
  803. rd_load = image_get_load(rd_hdr);
  804. break;
  805. #if defined(CONFIG_FIT)
  806. case IMAGE_FORMAT_FIT:
  807. fit_hdr = (void *)rd_addr;
  808. printf("## Loading init Ramdisk from FIT "
  809. "Image at %08lx ...\n", rd_addr);
  810. show_boot_progress(120);
  811. if (!fit_check_format(fit_hdr)) {
  812. puts("Bad FIT ramdisk image format!\n");
  813. show_boot_progress(-120);
  814. return 1;
  815. }
  816. show_boot_progress(121);
  817. if (!fit_uname_ramdisk) {
  818. /*
  819. * no ramdisk image node unit name, try to get config
  820. * node first. If config unit node name is NULL
  821. * fit_conf_get_node() will try to find default config node
  822. */
  823. show_boot_progress(122);
  824. cfg_noffset = fit_conf_get_node(fit_hdr,
  825. fit_uname_config);
  826. if (cfg_noffset < 0) {
  827. puts("Could not find configuration "
  828. "node\n");
  829. show_boot_progress(-122);
  830. return 1;
  831. }
  832. fit_uname_config = fdt_get_name(fit_hdr,
  833. cfg_noffset, NULL);
  834. printf(" Using '%s' configuration\n",
  835. fit_uname_config);
  836. rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
  837. cfg_noffset);
  838. fit_uname_ramdisk = fit_get_name(fit_hdr,
  839. rd_noffset, NULL);
  840. } else {
  841. /* get ramdisk component image node offset */
  842. show_boot_progress(123);
  843. rd_noffset = fit_image_get_node(fit_hdr,
  844. fit_uname_ramdisk);
  845. }
  846. if (rd_noffset < 0) {
  847. puts("Could not find subimage node\n");
  848. show_boot_progress(-124);
  849. return 1;
  850. }
  851. printf(" Trying '%s' ramdisk subimage\n",
  852. fit_uname_ramdisk);
  853. show_boot_progress(125);
  854. if (!fit_check_ramdisk(fit_hdr, rd_noffset, arch,
  855. images->verify))
  856. return 1;
  857. /* get ramdisk image data address and length */
  858. if (fit_image_get_data(fit_hdr, rd_noffset, &data,
  859. &size)) {
  860. puts("Could not find ramdisk subimage data!\n");
  861. show_boot_progress(-127);
  862. return 1;
  863. }
  864. show_boot_progress(128);
  865. rd_data = (ulong)data;
  866. rd_len = size;
  867. if (fit_image_get_load(fit_hdr, rd_noffset, &rd_load)) {
  868. puts("Can't get ramdisk subimage load "
  869. "address!\n");
  870. show_boot_progress(-129);
  871. return 1;
  872. }
  873. show_boot_progress(129);
  874. images->fit_hdr_rd = fit_hdr;
  875. images->fit_uname_rd = fit_uname_ramdisk;
  876. images->fit_noffset_rd = rd_noffset;
  877. break;
  878. #endif
  879. default:
  880. puts("Wrong Ramdisk Image Format\n");
  881. rd_data = rd_len = rd_load = 0;
  882. return 1;
  883. }
  884. } else if (images->legacy_hdr_valid &&
  885. image_check_type(&images->legacy_hdr_os_copy,
  886. IH_TYPE_MULTI)) {
  887. /*
  888. * Now check if we have a legacy mult-component image,
  889. * get second entry data start address and len.
  890. */
  891. show_boot_progress(13);
  892. printf("## Loading init Ramdisk from multi component "
  893. "Legacy Image at %08lx ...\n",
  894. (ulong)images->legacy_hdr_os);
  895. image_multi_getimg(images->legacy_hdr_os, 1, &rd_data, &rd_len);
  896. } else {
  897. /*
  898. * no initrd image
  899. */
  900. show_boot_progress(14);
  901. rd_len = rd_data = 0;
  902. }
  903. if (!rd_data) {
  904. debug("## No init Ramdisk\n");
  905. } else {
  906. *rd_start = rd_data;
  907. *rd_end = rd_data + rd_len;
  908. }
  909. debug(" ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
  910. *rd_start, *rd_end);
  911. return 0;
  912. }
  913. #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
  914. /**
  915. * boot_ramdisk_high - relocate init ramdisk
  916. * @lmb: pointer to lmb handle, will be used for memory mgmt
  917. * @rd_data: ramdisk data start address
  918. * @rd_len: ramdisk data length
  919. * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
  920. * start address (after possible relocation)
  921. * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
  922. * end address (after possible relocation)
  923. *
  924. * boot_ramdisk_high() takes a relocation hint from "initrd_high" environement
  925. * variable and if requested ramdisk data is moved to a specified location.
  926. *
  927. * Initrd_start and initrd_end are set to final (after relocation) ramdisk
  928. * start/end addresses if ramdisk image start and len were provided,
  929. * otherwise set initrd_start and initrd_end set to zeros.
  930. *
  931. * returns:
  932. * 0 - success
  933. * -1 - failure
  934. */
  935. int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
  936. ulong *initrd_start, ulong *initrd_end)
  937. {
  938. char *s;
  939. ulong initrd_high;
  940. int initrd_copy_to_ram = 1;
  941. if ((s = getenv("initrd_high")) != NULL) {
  942. /* a value of "no" or a similar string will act like 0,
  943. * turning the "load high" feature off. This is intentional.
  944. */
  945. initrd_high = simple_strtoul(s, NULL, 16);
  946. if (initrd_high == ~0)
  947. initrd_copy_to_ram = 0;
  948. } else {
  949. /* not set, no restrictions to load high */
  950. initrd_high = ~0;
  951. }
  952. #ifdef CONFIG_LOGBUFFER
  953. /* Prevent initrd from overwriting logbuffer */
  954. lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
  955. #endif
  956. debug("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
  957. initrd_high, initrd_copy_to_ram);
  958. if (rd_data) {
  959. if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */
  960. debug(" in-place initrd\n");
  961. *initrd_start = rd_data;
  962. *initrd_end = rd_data + rd_len;
  963. lmb_reserve(lmb, rd_data, rd_len);
  964. } else {
  965. if (initrd_high)
  966. *initrd_start = (ulong)lmb_alloc_base(lmb,
  967. rd_len, 0x1000, initrd_high);
  968. else
  969. *initrd_start = (ulong)lmb_alloc(lmb, rd_len,
  970. 0x1000);
  971. if (*initrd_start == 0) {
  972. puts("ramdisk - allocation error\n");
  973. goto error;
  974. }
  975. show_boot_progress(12);
  976. *initrd_end = *initrd_start + rd_len;
  977. printf(" Loading Ramdisk to %08lx, end %08lx ... ",
  978. *initrd_start, *initrd_end);
  979. memmove_wd((void *)*initrd_start,
  980. (void *)rd_data, rd_len, CHUNKSZ);
  981. #ifdef CONFIG_MP
  982. /*
  983. * Ensure the image is flushed to memory to handle
  984. * AMP boot scenarios in which we might not be
  985. * HW cache coherent
  986. */
  987. flush_cache((unsigned long)*initrd_start, rd_len);
  988. #endif
  989. puts("OK\n");
  990. }
  991. } else {
  992. *initrd_start = 0;
  993. *initrd_end = 0;
  994. }
  995. debug(" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
  996. *initrd_start, *initrd_end);
  997. return 0;
  998. error:
  999. return -1;
  1000. }
  1001. #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
  1002. #ifdef CONFIG_OF_LIBFDT
  1003. static void fdt_error(const char *msg)
  1004. {
  1005. puts("ERROR: ");
  1006. puts(msg);
  1007. puts(" - must RESET the board to recover.\n");
  1008. }
  1009. static const image_header_t *image_get_fdt(ulong fdt_addr)
  1010. {
  1011. const image_header_t *fdt_hdr = (const image_header_t *)fdt_addr;
  1012. image_print_contents(fdt_hdr);
  1013. puts(" Verifying Checksum ... ");
  1014. if (!image_check_hcrc(fdt_hdr)) {
  1015. fdt_error("fdt header checksum invalid");
  1016. return NULL;
  1017. }
  1018. if (!image_check_dcrc(fdt_hdr)) {
  1019. fdt_error("fdt checksum invalid");
  1020. return NULL;
  1021. }
  1022. puts("OK\n");
  1023. if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
  1024. fdt_error("uImage is not a fdt");
  1025. return NULL;
  1026. }
  1027. if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
  1028. fdt_error("uImage is compressed");
  1029. return NULL;
  1030. }
  1031. if (fdt_check_header((char *)image_get_data(fdt_hdr)) != 0) {
  1032. fdt_error("uImage data is not a fdt");
  1033. return NULL;
  1034. }
  1035. return fdt_hdr;
  1036. }
  1037. /**
  1038. * fit_check_fdt - verify FIT format FDT subimage
  1039. * @fit_hdr: pointer to the FIT header
  1040. * fdt_noffset: FDT subimage node offset within FIT image
  1041. * @verify: data CRC verification flag
  1042. *
  1043. * fit_check_fdt() verifies integrity of the FDT subimage and from
  1044. * specified FIT image.
  1045. *
  1046. * returns:
  1047. * 1, on success
  1048. * 0, on failure
  1049. */
  1050. #if defined(CONFIG_FIT)
  1051. static int fit_check_fdt(const void *fit, int fdt_noffset, int verify)
  1052. {
  1053. fit_image_print(fit, fdt_noffset, " ");
  1054. if (verify) {
  1055. puts(" Verifying Hash Integrity ... ");
  1056. if (!fit_image_check_hashes(fit, fdt_noffset)) {
  1057. fdt_error("Bad Data Hash");
  1058. return 0;
  1059. }
  1060. puts("OK\n");
  1061. }
  1062. if (!fit_image_check_type(fit, fdt_noffset, IH_TYPE_FLATDT)) {
  1063. fdt_error("Not a FDT image");
  1064. return 0;
  1065. }
  1066. if (!fit_image_check_comp(fit, fdt_noffset, IH_COMP_NONE)) {
  1067. fdt_error("FDT image is compressed");
  1068. return 0;
  1069. }
  1070. return 1;
  1071. }
  1072. #endif /* CONFIG_FIT */
  1073. #ifndef CONFIG_SYS_FDT_PAD
  1074. #define CONFIG_SYS_FDT_PAD 0x3000
  1075. #endif
  1076. #if defined(CONFIG_OF_LIBFDT)
  1077. /**
  1078. * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
  1079. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1080. * @fdt_blob: pointer to fdt blob base address
  1081. *
  1082. * Adds the memreserve regions in the dtb to the lmb block. Adding the
  1083. * memreserve regions prevents u-boot from using them to store the initrd
  1084. * or the fdt blob.
  1085. */
  1086. void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
  1087. {
  1088. uint64_t addr, size;
  1089. int i, total;
  1090. if (fdt_check_header(fdt_blob) != 0)
  1091. return;
  1092. total = fdt_num_mem_rsv(fdt_blob);
  1093. for (i = 0; i < total; i++) {
  1094. if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
  1095. continue;
  1096. printf(" reserving fdt memory region: addr=%llx size=%llx\n",
  1097. (unsigned long long)addr, (unsigned long long)size);
  1098. lmb_reserve(lmb, addr, size);
  1099. }
  1100. }
  1101. /**
  1102. * boot_relocate_fdt - relocate flat device tree
  1103. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1104. * @of_flat_tree: pointer to a char* variable, will hold fdt start address
  1105. * @of_size: pointer to a ulong variable, will hold fdt length
  1106. *
  1107. * boot_relocate_fdt() allocates a region of memory within the bootmap and
  1108. * relocates the of_flat_tree into that region, even if the fdt is already in
  1109. * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
  1110. * bytes.
  1111. *
  1112. * of_flat_tree and of_size are set to final (after relocation) values
  1113. *
  1114. * returns:
  1115. * 0 - success
  1116. * 1 - failure
  1117. */
  1118. int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
  1119. {
  1120. void *fdt_blob = *of_flat_tree;
  1121. void *of_start = 0;
  1122. char *fdt_high;
  1123. ulong of_len = 0;
  1124. int err;
  1125. int disable_relocation = 0;
  1126. /* nothing to do */
  1127. if (*of_size == 0)
  1128. return 0;
  1129. if (fdt_check_header(fdt_blob) != 0) {
  1130. fdt_error("image is not a fdt");
  1131. goto error;
  1132. }
  1133. /* position on a 4K boundary before the alloc_current */
  1134. /* Pad the FDT by a specified amount */
  1135. of_len = *of_size + CONFIG_SYS_FDT_PAD;
  1136. /* If fdt_high is set use it to select the relocation address */
  1137. fdt_high = getenv("fdt_high");
  1138. if (fdt_high) {
  1139. void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
  1140. if (((ulong) desired_addr) == ~0UL) {
  1141. /* All ones means use fdt in place */
  1142. desired_addr = fdt_blob;
  1143. disable_relocation = 1;
  1144. }
  1145. if (desired_addr) {
  1146. of_start =
  1147. (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  1148. ((ulong)
  1149. desired_addr)
  1150. + of_len);
  1151. if (desired_addr && of_start != desired_addr) {
  1152. puts("Failed using fdt_high value for Device Tree");
  1153. goto error;
  1154. }
  1155. } else {
  1156. of_start =
  1157. (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
  1158. }
  1159. } else {
  1160. of_start =
  1161. (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  1162. getenv_bootm_mapsize()
  1163. + getenv_bootm_low());
  1164. }
  1165. if (of_start == 0) {
  1166. puts("device tree - allocation error\n");
  1167. goto error;
  1168. }
  1169. if (disable_relocation) {
  1170. /* We assume there is space after the existing fdt to use for padding */
  1171. fdt_set_totalsize(of_start, of_len);
  1172. printf(" Using Device Tree in place at %p, end %p\n",
  1173. of_start, of_start + of_len - 1);
  1174. } else {
  1175. debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
  1176. fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
  1177. printf(" Loading Device Tree to %p, end %p ... ",
  1178. of_start, of_start + of_len - 1);
  1179. err = fdt_open_into(fdt_blob, of_start, of_len);
  1180. if (err != 0) {
  1181. fdt_error("fdt move failed");
  1182. goto error;
  1183. }
  1184. puts("OK\n");
  1185. }
  1186. *of_flat_tree = of_start;
  1187. *of_size = of_len;
  1188. set_working_fdt_addr(*of_flat_tree);
  1189. return 0;
  1190. error:
  1191. return 1;
  1192. }
  1193. #endif /* CONFIG_OF_LIBFDT */
  1194. /**
  1195. * boot_get_fdt - main fdt handling routine
  1196. * @argc: command argument count
  1197. * @argv: command argument list
  1198. * @images: pointer to the bootm images structure
  1199. * @of_flat_tree: pointer to a char* variable, will hold fdt start address
  1200. * @of_size: pointer to a ulong variable, will hold fdt length
  1201. *
  1202. * boot_get_fdt() is responsible for finding a valid flat device tree image.
  1203. * Curently supported are the following ramdisk sources:
  1204. * - multicomponent kernel/ramdisk image,
  1205. * - commandline provided address of decicated ramdisk image.
  1206. *
  1207. * returns:
  1208. * 0, if fdt image was found and valid, or skipped
  1209. * of_flat_tree and of_size are set to fdt start address and length if
  1210. * fdt image is found and valid
  1211. *
  1212. * 1, if fdt image is found but corrupted
  1213. * of_flat_tree and of_size are set to 0 if no fdt exists
  1214. */
  1215. int boot_get_fdt(int flag, int argc, char * const argv[],
  1216. bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
  1217. {
  1218. const image_header_t *fdt_hdr;
  1219. ulong fdt_addr;
  1220. char *fdt_blob = NULL;
  1221. ulong image_start, image_end;
  1222. ulong load_start, load_end;
  1223. #if defined(CONFIG_FIT)
  1224. void *fit_hdr;
  1225. const char *fit_uname_config = NULL;
  1226. const char *fit_uname_fdt = NULL;
  1227. ulong default_addr;
  1228. int cfg_noffset;
  1229. int fdt_noffset;
  1230. const void *data;
  1231. size_t size;
  1232. #endif
  1233. *of_flat_tree = NULL;
  1234. *of_size = 0;
  1235. if (argc > 3 || genimg_has_config(images)) {
  1236. #if defined(CONFIG_FIT)
  1237. if (argc > 3) {
  1238. /*
  1239. * If the FDT blob comes from the FIT image and the
  1240. * FIT image address is omitted in the command line
  1241. * argument, try to use ramdisk or os FIT image
  1242. * address or default load address.
  1243. */
  1244. if (images->fit_uname_rd)
  1245. default_addr = (ulong)images->fit_hdr_rd;
  1246. else if (images->fit_uname_os)
  1247. default_addr = (ulong)images->fit_hdr_os;
  1248. else
  1249. default_addr = load_addr;
  1250. if (fit_parse_conf(argv[3], default_addr,
  1251. &fdt_addr, &fit_uname_config)) {
  1252. debug("* fdt: config '%s' from image at "
  1253. "0x%08lx\n",
  1254. fit_uname_config, fdt_addr);
  1255. } else if (fit_parse_subimage(argv[3], default_addr,
  1256. &fdt_addr, &fit_uname_fdt)) {
  1257. debug("* fdt: subimage '%s' from image at "
  1258. "0x%08lx\n",
  1259. fit_uname_fdt, fdt_addr);
  1260. } else
  1261. #endif
  1262. {
  1263. fdt_addr = simple_strtoul(argv[3], NULL, 16);
  1264. debug("* fdt: cmdline image address = "
  1265. "0x%08lx\n",
  1266. fdt_addr);
  1267. }
  1268. #if defined(CONFIG_FIT)
  1269. } else {
  1270. /* use FIT configuration provided in first bootm
  1271. * command argument
  1272. */
  1273. fdt_addr = (ulong)images->fit_hdr_os;
  1274. fit_uname_config = images->fit_uname_cfg;
  1275. debug("* fdt: using config '%s' from image "
  1276. "at 0x%08lx\n",
  1277. fit_uname_config, fdt_addr);
  1278. /*
  1279. * Check whether configuration has FDT blob defined,
  1280. * if not quit silently.
  1281. */
  1282. fit_hdr = (void *)fdt_addr;
  1283. cfg_noffset = fit_conf_get_node(fit_hdr,
  1284. fit_uname_config);
  1285. if (cfg_noffset < 0) {
  1286. debug("* fdt: no such config\n");
  1287. return 0;
  1288. }
  1289. fdt_noffset = fit_conf_get_fdt_node(fit_hdr,
  1290. cfg_noffset);
  1291. if (fdt_noffset < 0) {
  1292. debug("* fdt: no fdt in config\n");
  1293. return 0;
  1294. }
  1295. }
  1296. #endif
  1297. debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
  1298. fdt_addr);
  1299. /* copy from dataflash if needed */
  1300. fdt_addr = genimg_get_image(fdt_addr);
  1301. /*
  1302. * Check if there is an FDT image at the
  1303. * address provided in the second bootm argument
  1304. * check image type, for FIT images get a FIT node.
  1305. */
  1306. switch (genimg_get_format((void *)fdt_addr)) {
  1307. case IMAGE_FORMAT_LEGACY:
  1308. /* verify fdt_addr points to a valid image header */
  1309. printf("## Flattened Device Tree from Legacy Image "
  1310. "at %08lx\n",
  1311. fdt_addr);
  1312. fdt_hdr = image_get_fdt(fdt_addr);
  1313. if (!fdt_hdr)
  1314. goto error;
  1315. /*
  1316. * move image data to the load address,
  1317. * make sure we don't overwrite initial image
  1318. */
  1319. image_start = (ulong)fdt_hdr;
  1320. image_end = image_get_image_end(fdt_hdr);
  1321. load_start = image_get_load(fdt_hdr);
  1322. load_end = load_start + image_get_data_size(fdt_hdr);
  1323. if ((load_start < image_end) && (load_end > image_start)) {
  1324. fdt_error("fdt overwritten");
  1325. goto error;
  1326. }
  1327. debug(" Loading FDT from 0x%08lx to 0x%08lx\n",
  1328. image_get_data(fdt_hdr), load_start);
  1329. memmove((void *)load_start,
  1330. (void *)image_get_data(fdt_hdr),
  1331. image_get_data_size(fdt_hdr));
  1332. fdt_blob = (char *)load_start;
  1333. break;
  1334. case IMAGE_FORMAT_FIT:
  1335. /*
  1336. * This case will catch both: new uImage format
  1337. * (libfdt based) and raw FDT blob (also libfdt
  1338. * based).
  1339. */
  1340. #if defined(CONFIG_FIT)
  1341. /* check FDT blob vs FIT blob */
  1342. if (fit_check_format((const void *)fdt_addr)) {
  1343. /*
  1344. * FIT image
  1345. */
  1346. fit_hdr = (void *)fdt_addr;
  1347. printf("## Flattened Device Tree from FIT "
  1348. "Image at %08lx\n",
  1349. fdt_addr);
  1350. if (!fit_uname_fdt) {
  1351. /*
  1352. * no FDT blob image node unit name,
  1353. * try to get config node first. If
  1354. * config unit node name is NULL
  1355. * fit_conf_get_node() will try to
  1356. * find default config node
  1357. */
  1358. cfg_noffset = fit_conf_get_node(fit_hdr,
  1359. fit_uname_config);
  1360. if (cfg_noffset < 0) {
  1361. fdt_error("Could not find "
  1362. "configuration "
  1363. "node\n");
  1364. goto error;
  1365. }
  1366. fit_uname_config = fdt_get_name(fit_hdr,
  1367. cfg_noffset, NULL);
  1368. printf(" Using '%s' configuration\n",
  1369. fit_uname_config);
  1370. fdt_noffset = fit_conf_get_fdt_node(
  1371. fit_hdr,
  1372. cfg_noffset);
  1373. fit_uname_fdt = fit_get_name(fit_hdr,
  1374. fdt_noffset, NULL);
  1375. } else {
  1376. /* get FDT component image node offset */
  1377. fdt_noffset = fit_image_get_node(
  1378. fit_hdr,
  1379. fit_uname_fdt);
  1380. }
  1381. if (fdt_noffset < 0) {
  1382. fdt_error("Could not find subimage "
  1383. "node\n");
  1384. goto error;
  1385. }
  1386. printf(" Trying '%s' FDT blob subimage\n",
  1387. fit_uname_fdt);
  1388. if (!fit_check_fdt(fit_hdr, fdt_noffset,
  1389. images->verify))
  1390. goto error;
  1391. /* get ramdisk image data address and length */
  1392. if (fit_image_get_data(fit_hdr, fdt_noffset,
  1393. &data, &size)) {
  1394. fdt_error("Could not find FDT "
  1395. "subimage data");
  1396. goto error;
  1397. }
  1398. /* verift that image data is a proper FDT blob */
  1399. if (fdt_check_header((char *)data) != 0) {
  1400. fdt_error("Subimage data is not a FTD");
  1401. goto error;
  1402. }
  1403. /*
  1404. * move image data to the load address,
  1405. * make sure we don't overwrite initial image
  1406. */
  1407. image_start = (ulong)fit_hdr;
  1408. image_end = fit_get_end(fit_hdr);
  1409. if (fit_image_get_load(fit_hdr, fdt_noffset,
  1410. &load_start) == 0) {
  1411. load_end = load_start + size;
  1412. if ((load_start < image_end) &&
  1413. (load_end > image_start)) {
  1414. fdt_error("FDT overwritten");
  1415. goto error;
  1416. }
  1417. printf(" Loading FDT from 0x%08lx "
  1418. "to 0x%08lx\n",
  1419. (ulong)data,
  1420. load_start);
  1421. memmove((void *)load_start,
  1422. (void *)data, size);
  1423. fdt_blob = (char *)load_start;
  1424. } else {
  1425. fdt_blob = (char *)data;
  1426. }
  1427. images->fit_hdr_fdt = fit_hdr;
  1428. images->fit_uname_fdt = fit_uname_fdt;
  1429. images->fit_noffset_fdt = fdt_noffset;
  1430. break;
  1431. } else
  1432. #endif
  1433. {
  1434. /*
  1435. * FDT blob
  1436. */
  1437. fdt_blob = (char *)fdt_addr;
  1438. debug("* fdt: raw FDT blob\n");
  1439. printf("## Flattened Device Tree blob at "
  1440. "%08lx\n", (long)fdt_blob);
  1441. }
  1442. break;
  1443. default:
  1444. puts("ERROR: Did not find a cmdline Flattened Device "
  1445. "Tree\n");
  1446. goto error;
  1447. }
  1448. printf(" Booting using the fdt blob at 0x%p\n", fdt_blob);
  1449. } else if (images->legacy_hdr_valid &&
  1450. image_check_type(&images->legacy_hdr_os_copy,
  1451. IH_TYPE_MULTI)) {
  1452. ulong fdt_data, fdt_len;
  1453. /*
  1454. * Now check if we have a legacy multi-component image,
  1455. * get second entry data start address and len.
  1456. */
  1457. printf("## Flattened Device Tree from multi "
  1458. "component Image at %08lX\n",
  1459. (ulong)images->legacy_hdr_os);
  1460. image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
  1461. &fdt_len);
  1462. if (fdt_len) {
  1463. fdt_blob = (char *)fdt_data;
  1464. printf(" Booting using the fdt at 0x%p\n", fdt_blob);
  1465. if (fdt_check_header(fdt_blob) != 0) {
  1466. fdt_error("image is not a fdt");
  1467. goto error;
  1468. }
  1469. if (fdt_totalsize(fdt_blob) != fdt_len) {
  1470. fdt_error("fdt size != image size");
  1471. goto error;
  1472. }
  1473. } else {
  1474. debug("## No Flattened Device Tree\n");
  1475. return 0;
  1476. }
  1477. } else {
  1478. debug("## No Flattened Device Tree\n");
  1479. return 0;
  1480. }
  1481. *of_flat_tree = fdt_blob;
  1482. *of_size = fdt_totalsize(fdt_blob);
  1483. debug(" of_flat_tree at 0x%08lx size 0x%08lx\n",
  1484. (ulong)*of_flat_tree, *of_size);
  1485. return 0;
  1486. error:
  1487. *of_flat_tree = 0;
  1488. *of_size = 0;
  1489. return 1;
  1490. }
  1491. #endif /* CONFIG_OF_LIBFDT */
  1492. #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
  1493. /**
  1494. * boot_get_cmdline - allocate and initialize kernel cmdline
  1495. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1496. * @cmd_start: pointer to a ulong variable, will hold cmdline start
  1497. * @cmd_end: pointer to a ulong variable, will hold cmdline end
  1498. *
  1499. * boot_get_cmdline() allocates space for kernel command line below
  1500. * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt
  1501. * variable is present its contents is copied to allocated kernel
  1502. * command line.
  1503. *
  1504. * returns:
  1505. * 0 - success
  1506. * -1 - failure
  1507. */
  1508. int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end)
  1509. {
  1510. char *cmdline;
  1511. char *s;
  1512. cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
  1513. getenv_bootm_mapsize() + getenv_bootm_low());
  1514. if (cmdline == NULL)
  1515. return -1;
  1516. if ((s = getenv("bootargs")) == NULL)
  1517. s = "";
  1518. strcpy(cmdline, s);
  1519. *cmd_start = (ulong) & cmdline[0];
  1520. *cmd_end = *cmd_start + strlen(cmdline);
  1521. debug("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
  1522. return 0;
  1523. }
  1524. #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
  1525. #ifdef CONFIG_SYS_BOOT_GET_KBD
  1526. /**
  1527. * boot_get_kbd - allocate and initialize kernel copy of board info
  1528. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1529. * @kbd: double pointer to board info data
  1530. *
  1531. * boot_get_kbd() allocates space for kernel copy of board info data below
  1532. * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized
  1533. * with the current u-boot board info data.
  1534. *
  1535. * returns:
  1536. * 0 - success
  1537. * -1 - failure
  1538. */
  1539. int boot_get_kbd(struct lmb *lmb, bd_t **kbd)
  1540. {
  1541. *kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
  1542. getenv_bootm_mapsize() + getenv_bootm_low());
  1543. if (*kbd == NULL)
  1544. return -1;
  1545. **kbd = *(gd->bd);
  1546. debug("## kernel board info at 0x%08lx\n", (ulong)*kbd);
  1547. #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
  1548. do_bdinfo(NULL, 0, 0, NULL);
  1549. #endif
  1550. return 0;
  1551. }
  1552. #endif /* CONFIG_SYS_BOOT_GET_KBD */
  1553. #endif /* !USE_HOSTCC */
  1554. #if defined(CONFIG_FIT)
  1555. /*****************************************************************************/
  1556. /* New uImage format routines */
  1557. /*****************************************************************************/
  1558. #ifndef USE_HOSTCC
  1559. static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
  1560. ulong *addr, const char **name)
  1561. {
  1562. const char *sep;
  1563. *addr = addr_curr;
  1564. *name = NULL;
  1565. sep = strchr(spec, sepc);
  1566. if (sep) {
  1567. if (sep - spec > 0)
  1568. *addr = simple_strtoul(spec, NULL, 16);
  1569. *name = sep + 1;
  1570. return 1;
  1571. }
  1572. return 0;
  1573. }
  1574. /**
  1575. * fit_parse_conf - parse FIT configuration spec
  1576. * @spec: input string, containing configuration spec
  1577. * @add_curr: current image address (to be used as a possible default)
  1578. * @addr: pointer to a ulong variable, will hold FIT image address of a given
  1579. * configuration
  1580. * @conf_name double pointer to a char, will hold pointer to a configuration
  1581. * unit name
  1582. *
  1583. * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>,
  1584. * where <addr> is a FIT image address that contains configuration
  1585. * with a <conf> unit name.
  1586. *
  1587. * Address part is optional, and if omitted default add_curr will
  1588. * be used instead.
  1589. *
  1590. * returns:
  1591. * 1 if spec is a valid configuration string,
  1592. * addr and conf_name are set accordingly
  1593. * 0 otherwise
  1594. */
  1595. inline int fit_parse_conf(const char *spec, ulong addr_curr,
  1596. ulong *addr, const char **conf_name)
  1597. {
  1598. return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
  1599. }
  1600. /**
  1601. * fit_parse_subimage - parse FIT subimage spec
  1602. * @spec: input string, containing subimage spec
  1603. * @add_curr: current image address (to be used as a possible default)
  1604. * @addr: pointer to a ulong variable, will hold FIT image address of a given
  1605. * subimage
  1606. * @image_name: double pointer to a char, will hold pointer to a subimage name
  1607. *
  1608. * fit_parse_subimage() expects subimage spec in the for of
  1609. * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
  1610. * subimage with a <subimg> unit name.
  1611. *
  1612. * Address part is optional, and if omitted default add_curr will
  1613. * be used instead.
  1614. *
  1615. * returns:
  1616. * 1 if spec is a valid subimage string,
  1617. * addr and image_name are set accordingly
  1618. * 0 otherwise
  1619. */
  1620. inline int fit_parse_subimage(const char *spec, ulong addr_curr,
  1621. ulong *addr, const char **image_name)
  1622. {
  1623. return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
  1624. }
  1625. #endif /* !USE_HOSTCC */
  1626. static void fit_get_debug(const void *fit, int noffset,
  1627. char *prop_name, int err)
  1628. {
  1629. debug("Can't get '%s' property from FIT 0x%08lx, "
  1630. "node: offset %d, name %s (%s)\n",
  1631. prop_name, (ulong)fit, noffset,
  1632. fit_get_name(fit, noffset, NULL),
  1633. fdt_strerror(err));
  1634. }
  1635. /**
  1636. * fit_print_contents - prints out the contents of the FIT format image
  1637. * @fit: pointer to the FIT format image header
  1638. * @p: pointer to prefix string
  1639. *
  1640. * fit_print_contents() formats a multi line FIT image contents description.
  1641. * The routine prints out FIT image properties (root node level) follwed by
  1642. * the details of each component image.
  1643. *
  1644. * returns:
  1645. * no returned results
  1646. */
  1647. void fit_print_contents(const void *fit)
  1648. {
  1649. char *desc;
  1650. char *uname;
  1651. int images_noffset;
  1652. int confs_noffset;
  1653. int noffset;
  1654. int ndepth;
  1655. int count = 0;
  1656. int ret;
  1657. const char *p;
  1658. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  1659. time_t timestamp;
  1660. #endif
  1661. #ifdef USE_HOSTCC
  1662. p = "";
  1663. #else
  1664. p = " ";
  1665. #endif
  1666. /* Root node properties */
  1667. ret = fit_get_desc(fit, 0, &desc);
  1668. printf("%sFIT description: ", p);
  1669. if (ret)
  1670. printf("unavailable\n");
  1671. else
  1672. printf("%s\n", desc);
  1673. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  1674. ret = fit_get_timestamp(fit, 0, &timestamp);
  1675. printf("%sCreated: ", p);
  1676. if (ret)
  1677. printf("unavailable\n");
  1678. else
  1679. genimg_print_time(timestamp);
  1680. #endif
  1681. /* Find images parent node offset */
  1682. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  1683. if (images_noffset < 0) {
  1684. printf("Can't find images parent node '%s' (%s)\n",
  1685. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  1686. return;
  1687. }
  1688. /* Process its subnodes, print out component images details */
  1689. for (ndepth = 0, count = 0,
  1690. noffset = fdt_next_node(fit, images_noffset, &ndepth);
  1691. (noffset >= 0) && (ndepth > 0);
  1692. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1693. if (ndepth == 1) {
  1694. /*
  1695. * Direct child node of the images parent node,
  1696. * i.e. component image node.
  1697. */
  1698. printf("%s Image %u (%s)\n", p, count++,
  1699. fit_get_name(fit, noffset, NULL));
  1700. fit_image_print(fit, noffset, p);
  1701. }
  1702. }
  1703. /* Find configurations parent node offset */
  1704. confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
  1705. if (confs_noffset < 0) {
  1706. debug("Can't get configurations parent node '%s' (%s)\n",
  1707. FIT_CONFS_PATH, fdt_strerror(confs_noffset));
  1708. return;
  1709. }
  1710. /* get default configuration unit name from default property */
  1711. uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
  1712. if (uname)
  1713. printf("%s Default Configuration: '%s'\n", p, uname);
  1714. /* Process its subnodes, print out configurations details */
  1715. for (ndepth = 0, count = 0,
  1716. noffset = fdt_next_node(fit, confs_noffset, &ndepth);
  1717. (noffset >= 0) && (ndepth > 0);
  1718. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1719. if (ndepth == 1) {
  1720. /*
  1721. * Direct child node of the configurations parent node,
  1722. * i.e. configuration node.
  1723. */
  1724. printf("%s Configuration %u (%s)\n", p, count++,
  1725. fit_get_name(fit, noffset, NULL));
  1726. fit_conf_print(fit, noffset, p);
  1727. }
  1728. }
  1729. }
  1730. /**
  1731. * fit_image_print - prints out the FIT component image details
  1732. * @fit: pointer to the FIT format image header
  1733. * @image_noffset: offset of the component image node
  1734. * @p: pointer to prefix string
  1735. *
  1736. * fit_image_print() lists all mandatory properies for the processed component
  1737. * image. If present, hash nodes are printed out as well. Load
  1738. * address for images of type firmware is also printed out. Since the load
  1739. * address is not mandatory for firmware images, it will be output as
  1740. * "unavailable" when not present.
  1741. *
  1742. * returns:
  1743. * no returned results
  1744. */
  1745. void fit_image_print(const void *fit, int image_noffset, const char *p)
  1746. {
  1747. char *desc;
  1748. uint8_t type, arch, os, comp;
  1749. size_t size;
  1750. ulong load, entry;
  1751. const void *data;
  1752. int noffset;
  1753. int ndepth;
  1754. int ret;
  1755. /* Mandatory properties */
  1756. ret = fit_get_desc(fit, image_noffset, &desc);
  1757. printf("%s Description: ", p);
  1758. if (ret)
  1759. printf("unavailable\n");
  1760. else
  1761. printf("%s\n", desc);
  1762. fit_image_get_type(fit, image_noffset, &type);
  1763. printf("%s Type: %s\n", p, genimg_get_type_name(type));
  1764. fit_image_get_comp(fit, image_noffset, &comp);
  1765. printf("%s Compression: %s\n", p, genimg_get_comp_name(comp));
  1766. ret = fit_image_get_data(fit, image_noffset, &data, &size);
  1767. #ifndef USE_HOSTCC
  1768. printf("%s Data Start: ", p);
  1769. if (ret)
  1770. printf("unavailable\n");
  1771. else
  1772. printf("0x%08lx\n", (ulong)data);
  1773. #endif
  1774. printf("%s Data Size: ", p);
  1775. if (ret)
  1776. printf("unavailable\n");
  1777. else
  1778. genimg_print_size(size);
  1779. /* Remaining, type dependent properties */
  1780. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
  1781. (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
  1782. (type == IH_TYPE_FLATDT)) {
  1783. fit_image_get_arch(fit, image_noffset, &arch);
  1784. printf("%s Architecture: %s\n", p, genimg_get_arch_name(arch));
  1785. }
  1786. if (type == IH_TYPE_KERNEL) {
  1787. fit_image_get_os(fit, image_noffset, &os);
  1788. printf("%s OS: %s\n", p, genimg_get_os_name(os));
  1789. }
  1790. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
  1791. (type == IH_TYPE_FIRMWARE)) {
  1792. ret = fit_image_get_load(fit, image_noffset, &load);
  1793. printf("%s Load Address: ", p);
  1794. if (ret)
  1795. printf("unavailable\n");
  1796. else
  1797. printf("0x%08lx\n", load);
  1798. }
  1799. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE)) {
  1800. fit_image_get_entry(fit, image_noffset, &entry);
  1801. printf("%s Entry Point: ", p);
  1802. if (ret)
  1803. printf("unavailable\n");
  1804. else
  1805. printf("0x%08lx\n", entry);
  1806. }
  1807. /* Process all hash subnodes of the component image node */
  1808. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  1809. (noffset >= 0) && (ndepth > 0);
  1810. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1811. if (ndepth == 1) {
  1812. /* Direct child node of the component image node */
  1813. fit_image_print_hash(fit, noffset, p);
  1814. }
  1815. }
  1816. }
  1817. /**
  1818. * fit_image_print_hash - prints out the hash node details
  1819. * @fit: pointer to the FIT format image header
  1820. * @noffset: offset of the hash node
  1821. * @p: pointer to prefix string
  1822. *
  1823. * fit_image_print_hash() lists properies for the processed hash node
  1824. *
  1825. * returns:
  1826. * no returned results
  1827. */
  1828. void fit_image_print_hash(const void *fit, int noffset, const char *p)
  1829. {
  1830. char *algo;
  1831. uint8_t *value;
  1832. int value_len;
  1833. int i, ret;
  1834. /*
  1835. * Check subnode name, must be equal to "hash".
  1836. * Multiple hash nodes require unique unit node
  1837. * names, e.g. hash@1, hash@2, etc.
  1838. */
  1839. if (strncmp(fit_get_name(fit, noffset, NULL),
  1840. FIT_HASH_NODENAME,
  1841. strlen(FIT_HASH_NODENAME)) != 0)
  1842. return;
  1843. debug("%s Hash node: '%s'\n", p,
  1844. fit_get_name(fit, noffset, NULL));
  1845. printf("%s Hash algo: ", p);
  1846. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  1847. printf("invalid/unsupported\n");
  1848. return;
  1849. }
  1850. printf("%s\n", algo);
  1851. ret = fit_image_hash_get_value(fit, noffset, &value,
  1852. &value_len);
  1853. printf("%s Hash value: ", p);
  1854. if (ret) {
  1855. printf("unavailable\n");
  1856. } else {
  1857. for (i = 0; i < value_len; i++)
  1858. printf("%02x", value[i]);
  1859. printf("\n");
  1860. }
  1861. debug("%s Hash len: %d\n", p, value_len);
  1862. }
  1863. /**
  1864. * fit_get_desc - get node description property
  1865. * @fit: pointer to the FIT format image header
  1866. * @noffset: node offset
  1867. * @desc: double pointer to the char, will hold pointer to the descrption
  1868. *
  1869. * fit_get_desc() reads description property from a given node, if
  1870. * description is found pointer to it is returened in third call argument.
  1871. *
  1872. * returns:
  1873. * 0, on success
  1874. * -1, on failure
  1875. */
  1876. int fit_get_desc(const void *fit, int noffset, char **desc)
  1877. {
  1878. int len;
  1879. *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
  1880. if (*desc == NULL) {
  1881. fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
  1882. return -1;
  1883. }
  1884. return 0;
  1885. }
  1886. /**
  1887. * fit_get_timestamp - get node timestamp property
  1888. * @fit: pointer to the FIT format image header
  1889. * @noffset: node offset
  1890. * @timestamp: pointer to the time_t, will hold read timestamp
  1891. *
  1892. * fit_get_timestamp() reads timestamp poperty from given node, if timestamp
  1893. * is found and has a correct size its value is retured in third call
  1894. * argument.
  1895. *
  1896. * returns:
  1897. * 0, on success
  1898. * -1, on property read failure
  1899. * -2, on wrong timestamp size
  1900. */
  1901. int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
  1902. {
  1903. int len;
  1904. const void *data;
  1905. data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
  1906. if (data == NULL) {
  1907. fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
  1908. return -1;
  1909. }
  1910. if (len != sizeof(uint32_t)) {
  1911. debug("FIT timestamp with incorrect size of (%u)\n", len);
  1912. return -2;
  1913. }
  1914. *timestamp = uimage_to_cpu(*((uint32_t *)data));
  1915. return 0;
  1916. }
  1917. /**
  1918. * fit_image_get_node - get node offset for component image of a given unit name
  1919. * @fit: pointer to the FIT format image header
  1920. * @image_uname: component image node unit name
  1921. *
  1922. * fit_image_get_node() finds a component image (withing the '/images'
  1923. * node) of a provided unit name. If image is found its node offset is
  1924. * returned to the caller.
  1925. *
  1926. * returns:
  1927. * image node offset when found (>=0)
  1928. * negative number on failure (FDT_ERR_* code)
  1929. */
  1930. int fit_image_get_node(const void *fit, const char *image_uname)
  1931. {
  1932. int noffset, images_noffset;
  1933. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  1934. if (images_noffset < 0) {
  1935. debug("Can't find images parent node '%s' (%s)\n",
  1936. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  1937. return images_noffset;
  1938. }
  1939. noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
  1940. if (noffset < 0) {
  1941. debug("Can't get node offset for image unit name: '%s' (%s)\n",
  1942. image_uname, fdt_strerror(noffset));
  1943. }
  1944. return noffset;
  1945. }
  1946. /**
  1947. * fit_image_get_os - get os id for a given component image node
  1948. * @fit: pointer to the FIT format image header
  1949. * @noffset: component image node offset
  1950. * @os: pointer to the uint8_t, will hold os numeric id
  1951. *
  1952. * fit_image_get_os() finds os property in a given component image node.
  1953. * If the property is found, its (string) value is translated to the numeric
  1954. * id which is returned to the caller.
  1955. *
  1956. * returns:
  1957. * 0, on success
  1958. * -1, on failure
  1959. */
  1960. int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
  1961. {
  1962. int len;
  1963. const void *data;
  1964. /* Get OS name from property data */
  1965. data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
  1966. if (data == NULL) {
  1967. fit_get_debug(fit, noffset, FIT_OS_PROP, len);
  1968. *os = -1;
  1969. return -1;
  1970. }
  1971. /* Translate OS name to id */
  1972. *os = genimg_get_os_id(data);
  1973. return 0;
  1974. }
  1975. /**
  1976. * fit_image_get_arch - get arch id for a given component image node
  1977. * @fit: pointer to the FIT format image header
  1978. * @noffset: component image node offset
  1979. * @arch: pointer to the uint8_t, will hold arch numeric id
  1980. *
  1981. * fit_image_get_arch() finds arch property in a given component image node.
  1982. * If the property is found, its (string) value is translated to the numeric
  1983. * id which is returned to the caller.
  1984. *
  1985. * returns:
  1986. * 0, on success
  1987. * -1, on failure
  1988. */
  1989. int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
  1990. {
  1991. int len;
  1992. const void *data;
  1993. /* Get architecture name from property data */
  1994. data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
  1995. if (data == NULL) {
  1996. fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
  1997. *arch = -1;
  1998. return -1;
  1999. }
  2000. /* Translate architecture name to id */
  2001. *arch = genimg_get_arch_id(data);
  2002. return 0;
  2003. }
  2004. /**
  2005. * fit_image_get_type - get type id for a given component image node
  2006. * @fit: pointer to the FIT format image header
  2007. * @noffset: component image node offset
  2008. * @type: pointer to the uint8_t, will hold type numeric id
  2009. *
  2010. * fit_image_get_type() finds type property in a given component image node.
  2011. * If the property is found, its (string) value is translated to the numeric
  2012. * id which is returned to the caller.
  2013. *
  2014. * returns:
  2015. * 0, on success
  2016. * -1, on failure
  2017. */
  2018. int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
  2019. {
  2020. int len;
  2021. const void *data;
  2022. /* Get image type name from property data */
  2023. data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
  2024. if (data == NULL) {
  2025. fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
  2026. *type = -1;
  2027. return -1;
  2028. }
  2029. /* Translate image type name to id */
  2030. *type = genimg_get_type_id(data);
  2031. return 0;
  2032. }
  2033. /**
  2034. * fit_image_get_comp - get comp id for a given component image node
  2035. * @fit: pointer to the FIT format image header
  2036. * @noffset: component image node offset
  2037. * @comp: pointer to the uint8_t, will hold comp numeric id
  2038. *
  2039. * fit_image_get_comp() finds comp property in a given component image node.
  2040. * If the property is found, its (string) value is translated to the numeric
  2041. * id which is returned to the caller.
  2042. *
  2043. * returns:
  2044. * 0, on success
  2045. * -1, on failure
  2046. */
  2047. int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
  2048. {
  2049. int len;
  2050. const void *data;
  2051. /* Get compression name from property data */
  2052. data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
  2053. if (data == NULL) {
  2054. fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
  2055. *comp = -1;
  2056. return -1;
  2057. }
  2058. /* Translate compression name to id */
  2059. *comp = genimg_get_comp_id(data);
  2060. return 0;
  2061. }
  2062. /**
  2063. * fit_image_get_load - get load address property for a given component image node
  2064. * @fit: pointer to the FIT format image header
  2065. * @noffset: component image node offset
  2066. * @load: pointer to the uint32_t, will hold load address
  2067. *
  2068. * fit_image_get_load() finds load address property in a given component image node.
  2069. * If the property is found, its value is returned to the caller.
  2070. *
  2071. * returns:
  2072. * 0, on success
  2073. * -1, on failure
  2074. */
  2075. int fit_image_get_load(const void *fit, int noffset, ulong *load)
  2076. {
  2077. int len;
  2078. const uint32_t *data;
  2079. data = fdt_getprop(fit, noffset, FIT_LOAD_PROP, &len);
  2080. if (data == NULL) {
  2081. fit_get_debug(fit, noffset, FIT_LOAD_PROP, len);
  2082. return -1;
  2083. }
  2084. *load = uimage_to_cpu(*data);
  2085. return 0;
  2086. }
  2087. /**
  2088. * fit_image_get_entry - get entry point address property for a given component image node
  2089. * @fit: pointer to the FIT format image header
  2090. * @noffset: component image node offset
  2091. * @entry: pointer to the uint32_t, will hold entry point address
  2092. *
  2093. * fit_image_get_entry() finds entry point address property in a given component image node.
  2094. * If the property is found, its value is returned to the caller.
  2095. *
  2096. * returns:
  2097. * 0, on success
  2098. * -1, on failure
  2099. */
  2100. int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
  2101. {
  2102. int len;
  2103. const uint32_t *data;
  2104. data = fdt_getprop(fit, noffset, FIT_ENTRY_PROP, &len);
  2105. if (data == NULL) {
  2106. fit_get_debug(fit, noffset, FIT_ENTRY_PROP, len);
  2107. return -1;
  2108. }
  2109. *entry = uimage_to_cpu(*data);
  2110. return 0;
  2111. }
  2112. /**
  2113. * fit_image_get_data - get data property and its size for a given component image node
  2114. * @fit: pointer to the FIT format image header
  2115. * @noffset: component image node offset
  2116. * @data: double pointer to void, will hold data property's data address
  2117. * @size: pointer to size_t, will hold data property's data size
  2118. *
  2119. * fit_image_get_data() finds data property in a given component image node.
  2120. * If the property is found its data start address and size are returned to
  2121. * the caller.
  2122. *
  2123. * returns:
  2124. * 0, on success
  2125. * -1, on failure
  2126. */
  2127. int fit_image_get_data(const void *fit, int noffset,
  2128. const void **data, size_t *size)
  2129. {
  2130. int len;
  2131. *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
  2132. if (*data == NULL) {
  2133. fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
  2134. *size = 0;
  2135. return -1;
  2136. }
  2137. *size = len;
  2138. return 0;
  2139. }
  2140. /**
  2141. * fit_image_hash_get_algo - get hash algorithm name
  2142. * @fit: pointer to the FIT format image header
  2143. * @noffset: hash node offset
  2144. * @algo: double pointer to char, will hold pointer to the algorithm name
  2145. *
  2146. * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
  2147. * If the property is found its data start address is returned to the caller.
  2148. *
  2149. * returns:
  2150. * 0, on success
  2151. * -1, on failure
  2152. */
  2153. int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
  2154. {
  2155. int len;
  2156. *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
  2157. if (*algo == NULL) {
  2158. fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
  2159. return -1;
  2160. }
  2161. return 0;
  2162. }
  2163. /**
  2164. * fit_image_hash_get_value - get hash value and length
  2165. * @fit: pointer to the FIT format image header
  2166. * @noffset: hash node offset
  2167. * @value: double pointer to uint8_t, will hold address of a hash value data
  2168. * @value_len: pointer to an int, will hold hash data length
  2169. *
  2170. * fit_image_hash_get_value() finds hash value property in a given hash node.
  2171. * If the property is found its data start address and size are returned to
  2172. * the caller.
  2173. *
  2174. * returns:
  2175. * 0, on success
  2176. * -1, on failure
  2177. */
  2178. int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
  2179. int *value_len)
  2180. {
  2181. int len;
  2182. *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
  2183. if (*value == NULL) {
  2184. fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
  2185. *value_len = 0;
  2186. return -1;
  2187. }
  2188. *value_len = len;
  2189. return 0;
  2190. }
  2191. /**
  2192. * fit_set_timestamp - set node timestamp property
  2193. * @fit: pointer to the FIT format image header
  2194. * @noffset: node offset
  2195. * @timestamp: timestamp value to be set
  2196. *
  2197. * fit_set_timestamp() attempts to set timestamp property in the requested
  2198. * node and returns operation status to the caller.
  2199. *
  2200. * returns:
  2201. * 0, on success
  2202. * -1, on property read failure
  2203. */
  2204. int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
  2205. {
  2206. uint32_t t;
  2207. int ret;
  2208. t = cpu_to_uimage(timestamp);
  2209. ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
  2210. sizeof(uint32_t));
  2211. if (ret) {
  2212. printf("Can't set '%s' property for '%s' node (%s)\n",
  2213. FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
  2214. fdt_strerror(ret));
  2215. return -1;
  2216. }
  2217. return 0;
  2218. }
  2219. /**
  2220. * calculate_hash - calculate and return hash for provided input data
  2221. * @data: pointer to the input data
  2222. * @data_len: data length
  2223. * @algo: requested hash algorithm
  2224. * @value: pointer to the char, will hold hash value data (caller must
  2225. * allocate enough free space)
  2226. * value_len: length of the calculated hash
  2227. *
  2228. * calculate_hash() computes input data hash according to the requested algorithm.
  2229. * Resulting hash value is placed in caller provided 'value' buffer, length
  2230. * of the calculated hash is returned via value_len pointer argument.
  2231. *
  2232. * returns:
  2233. * 0, on success
  2234. * -1, when algo is unsupported
  2235. */
  2236. static int calculate_hash(const void *data, int data_len, const char *algo,
  2237. uint8_t *value, int *value_len)
  2238. {
  2239. if (strcmp(algo, "crc32") == 0) {
  2240. *((uint32_t *)value) = crc32_wd(0, data, data_len,
  2241. CHUNKSZ_CRC32);
  2242. *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
  2243. *value_len = 4;
  2244. } else if (strcmp(algo, "sha1") == 0) {
  2245. sha1_csum_wd((unsigned char *) data, data_len,
  2246. (unsigned char *) value, CHUNKSZ_SHA1);
  2247. *value_len = 20;
  2248. } else if (strcmp(algo, "md5") == 0) {
  2249. md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
  2250. *value_len = 16;
  2251. } else {
  2252. debug("Unsupported hash alogrithm\n");
  2253. return -1;
  2254. }
  2255. return 0;
  2256. }
  2257. #ifdef USE_HOSTCC
  2258. /**
  2259. * fit_set_hashes - process FIT component image nodes and calculate hashes
  2260. * @fit: pointer to the FIT format image header
  2261. *
  2262. * fit_set_hashes() adds hash values for all component images in the FIT blob.
  2263. * Hashes are calculated for all component images which have hash subnodes
  2264. * with algorithm property set to one of the supported hash algorithms.
  2265. *
  2266. * returns
  2267. * 0, on success
  2268. * libfdt error code, on failure
  2269. */
  2270. int fit_set_hashes(void *fit)
  2271. {
  2272. int images_noffset;
  2273. int noffset;
  2274. int ndepth;
  2275. int ret;
  2276. /* Find images parent node offset */
  2277. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  2278. if (images_noffset < 0) {
  2279. printf("Can't find images parent node '%s' (%s)\n",
  2280. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  2281. return images_noffset;
  2282. }
  2283. /* Process its subnodes, print out component images details */
  2284. for (ndepth = 0, noffset = fdt_next_node(fit, images_noffset, &ndepth);
  2285. (noffset >= 0) && (ndepth > 0);
  2286. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2287. if (ndepth == 1) {
  2288. /*
  2289. * Direct child node of the images parent node,
  2290. * i.e. component image node.
  2291. */
  2292. ret = fit_image_set_hashes(fit, noffset);
  2293. if (ret)
  2294. return ret;
  2295. }
  2296. }
  2297. return 0;
  2298. }
  2299. /**
  2300. * fit_image_set_hashes - calculate/set hashes for given component image node
  2301. * @fit: pointer to the FIT format image header
  2302. * @image_noffset: requested component image node
  2303. *
  2304. * fit_image_set_hashes() adds hash values for an component image node. All
  2305. * existing hash subnodes are checked, if algorithm property is set to one of
  2306. * the supported hash algorithms, hash value is computed and corresponding
  2307. * hash node property is set, for example:
  2308. *
  2309. * Input component image node structure:
  2310. *
  2311. * o image@1 (at image_noffset)
  2312. * | - data = [binary data]
  2313. * o hash@1
  2314. * |- algo = "sha1"
  2315. *
  2316. * Output component image node structure:
  2317. *
  2318. * o image@1 (at image_noffset)
  2319. * | - data = [binary data]
  2320. * o hash@1
  2321. * |- algo = "sha1"
  2322. * |- value = sha1(data)
  2323. *
  2324. * returns:
  2325. * 0 on sucess
  2326. * <0 on failure
  2327. */
  2328. int fit_image_set_hashes(void *fit, int image_noffset)
  2329. {
  2330. const void *data;
  2331. size_t size;
  2332. char *algo;
  2333. uint8_t value[FIT_MAX_HASH_LEN];
  2334. int value_len;
  2335. int noffset;
  2336. int ndepth;
  2337. /* Get image data and data length */
  2338. if (fit_image_get_data(fit, image_noffset, &data, &size)) {
  2339. printf("Can't get image data/size\n");
  2340. return -1;
  2341. }
  2342. /* Process all hash subnodes of the component image node */
  2343. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  2344. (noffset >= 0) && (ndepth > 0);
  2345. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2346. if (ndepth == 1) {
  2347. /* Direct child node of the component image node */
  2348. /*
  2349. * Check subnode name, must be equal to "hash".
  2350. * Multiple hash nodes require unique unit node
  2351. * names, e.g. hash@1, hash@2, etc.
  2352. */
  2353. if (strncmp(fit_get_name(fit, noffset, NULL),
  2354. FIT_HASH_NODENAME,
  2355. strlen(FIT_HASH_NODENAME)) != 0) {
  2356. /* Not a hash subnode, skip it */
  2357. continue;
  2358. }
  2359. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  2360. printf("Can't get hash algo property for "
  2361. "'%s' hash node in '%s' image node\n",
  2362. fit_get_name(fit, noffset, NULL),
  2363. fit_get_name(fit, image_noffset, NULL));
  2364. return -1;
  2365. }
  2366. if (calculate_hash(data, size, algo, value,
  2367. &value_len)) {
  2368. printf("Unsupported hash algorithm (%s) for "
  2369. "'%s' hash node in '%s' image node\n",
  2370. algo, fit_get_name(fit, noffset, NULL),
  2371. fit_get_name(fit, image_noffset,
  2372. NULL));
  2373. return -1;
  2374. }
  2375. if (fit_image_hash_set_value(fit, noffset, value,
  2376. value_len)) {
  2377. printf("Can't set hash value for "
  2378. "'%s' hash node in '%s' image node\n",
  2379. fit_get_name(fit, noffset, NULL),
  2380. fit_get_name(fit, image_noffset, NULL));
  2381. return -1;
  2382. }
  2383. }
  2384. }
  2385. return 0;
  2386. }
  2387. /**
  2388. * fit_image_hash_set_value - set hash value in requested has node
  2389. * @fit: pointer to the FIT format image header
  2390. * @noffset: hash node offset
  2391. * @value: hash value to be set
  2392. * @value_len: hash value length
  2393. *
  2394. * fit_image_hash_set_value() attempts to set hash value in a node at offset
  2395. * given and returns operation status to the caller.
  2396. *
  2397. * returns
  2398. * 0, on success
  2399. * -1, on failure
  2400. */
  2401. int fit_image_hash_set_value(void *fit, int noffset, uint8_t *value,
  2402. int value_len)
  2403. {
  2404. int ret;
  2405. ret = fdt_setprop(fit, noffset, FIT_VALUE_PROP, value, value_len);
  2406. if (ret) {
  2407. printf("Can't set hash '%s' property for '%s' node(%s)\n",
  2408. FIT_VALUE_PROP, fit_get_name(fit, noffset, NULL),
  2409. fdt_strerror(ret));
  2410. return -1;
  2411. }
  2412. return 0;
  2413. }
  2414. #endif /* USE_HOSTCC */
  2415. /**
  2416. * fit_image_check_hashes - verify data intergity
  2417. * @fit: pointer to the FIT format image header
  2418. * @image_noffset: component image node offset
  2419. *
  2420. * fit_image_check_hashes() goes over component image hash nodes,
  2421. * re-calculates each data hash and compares with the value stored in hash
  2422. * node.
  2423. *
  2424. * returns:
  2425. * 1, if all hashes are valid
  2426. * 0, otherwise (or on error)
  2427. */
  2428. int fit_image_check_hashes(const void *fit, int image_noffset)
  2429. {
  2430. const void *data;
  2431. size_t size;
  2432. char *algo;
  2433. uint8_t *fit_value;
  2434. int fit_value_len;
  2435. uint8_t value[FIT_MAX_HASH_LEN];
  2436. int value_len;
  2437. int noffset;
  2438. int ndepth;
  2439. char *err_msg = "";
  2440. /* Get image data and data length */
  2441. if (fit_image_get_data(fit, image_noffset, &data, &size)) {
  2442. printf("Can't get image data/size\n");
  2443. return 0;
  2444. }
  2445. /* Process all hash subnodes of the component image node */
  2446. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  2447. (noffset >= 0) && (ndepth > 0);
  2448. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2449. if (ndepth == 1) {
  2450. /* Direct child node of the component image node */
  2451. /*
  2452. * Check subnode name, must be equal to "hash".
  2453. * Multiple hash nodes require unique unit node
  2454. * names, e.g. hash@1, hash@2, etc.
  2455. */
  2456. if (strncmp(fit_get_name(fit, noffset, NULL),
  2457. FIT_HASH_NODENAME,
  2458. strlen(FIT_HASH_NODENAME)) != 0)
  2459. continue;
  2460. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  2461. err_msg = " error!\nCan't get hash algo "
  2462. "property";
  2463. goto error;
  2464. }
  2465. printf("%s", algo);
  2466. if (fit_image_hash_get_value(fit, noffset, &fit_value,
  2467. &fit_value_len)) {
  2468. err_msg = " error!\nCan't get hash value "
  2469. "property";
  2470. goto error;
  2471. }
  2472. if (calculate_hash(data, size, algo, value,
  2473. &value_len)) {
  2474. err_msg = " error!\n"
  2475. "Unsupported hash algorithm";
  2476. goto error;
  2477. }
  2478. if (value_len != fit_value_len) {
  2479. err_msg = " error !\nBad hash value len";
  2480. goto error;
  2481. } else if (memcmp(value, fit_value, value_len) != 0) {
  2482. err_msg = " error!\nBad hash value";
  2483. goto error;
  2484. }
  2485. printf("+ ");
  2486. }
  2487. }
  2488. return 1;
  2489. error:
  2490. printf("%s for '%s' hash node in '%s' image node\n",
  2491. err_msg, fit_get_name(fit, noffset, NULL),
  2492. fit_get_name(fit, image_noffset, NULL));
  2493. return 0;
  2494. }
  2495. /**
  2496. * fit_all_image_check_hashes - verify data intergity for all images
  2497. * @fit: pointer to the FIT format image header
  2498. *
  2499. * fit_all_image_check_hashes() goes over all images in the FIT and
  2500. * for every images checks if all it's hashes are valid.
  2501. *
  2502. * returns:
  2503. * 1, if all hashes of all images are valid
  2504. * 0, otherwise (or on error)
  2505. */
  2506. int fit_all_image_check_hashes(const void *fit)
  2507. {
  2508. int images_noffset;
  2509. int noffset;
  2510. int ndepth;
  2511. int count;
  2512. /* Find images parent node offset */
  2513. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  2514. if (images_noffset < 0) {
  2515. printf("Can't find images parent node '%s' (%s)\n",
  2516. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  2517. return 0;
  2518. }
  2519. /* Process all image subnodes, check hashes for each */
  2520. printf("## Checking hash(es) for FIT Image at %08lx ...\n",
  2521. (ulong)fit);
  2522. for (ndepth = 0, count = 0,
  2523. noffset = fdt_next_node(fit, images_noffset, &ndepth);
  2524. (noffset >= 0) && (ndepth > 0);
  2525. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2526. if (ndepth == 1) {
  2527. /*
  2528. * Direct child node of the images parent node,
  2529. * i.e. component image node.
  2530. */
  2531. printf(" Hash(es) for Image %u (%s): ", count++,
  2532. fit_get_name(fit, noffset, NULL));
  2533. if (!fit_image_check_hashes(fit, noffset))
  2534. return 0;
  2535. printf("\n");
  2536. }
  2537. }
  2538. return 1;
  2539. }
  2540. /**
  2541. * fit_image_check_os - check whether image node is of a given os type
  2542. * @fit: pointer to the FIT format image header
  2543. * @noffset: component image node offset
  2544. * @os: requested image os
  2545. *
  2546. * fit_image_check_os() reads image os property and compares its numeric
  2547. * id with the requested os. Comparison result is returned to the caller.
  2548. *
  2549. * returns:
  2550. * 1 if image is of given os type
  2551. * 0 otherwise (or on error)
  2552. */
  2553. int fit_image_check_os(const void *fit, int noffset, uint8_t os)
  2554. {
  2555. uint8_t image_os;
  2556. if (fit_image_get_os(fit, noffset, &image_os))
  2557. return 0;
  2558. return (os == image_os);
  2559. }
  2560. /**
  2561. * fit_image_check_arch - check whether image node is of a given arch
  2562. * @fit: pointer to the FIT format image header
  2563. * @noffset: component image node offset
  2564. * @arch: requested imagearch
  2565. *
  2566. * fit_image_check_arch() reads image arch property and compares its numeric
  2567. * id with the requested arch. Comparison result is returned to the caller.
  2568. *
  2569. * returns:
  2570. * 1 if image is of given arch
  2571. * 0 otherwise (or on error)
  2572. */
  2573. int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
  2574. {
  2575. uint8_t image_arch;
  2576. if (fit_image_get_arch(fit, noffset, &image_arch))
  2577. return 0;
  2578. return (arch == image_arch);
  2579. }
  2580. /**
  2581. * fit_image_check_type - check whether image node is of a given type
  2582. * @fit: pointer to the FIT format image header
  2583. * @noffset: component image node offset
  2584. * @type: requested image type
  2585. *
  2586. * fit_image_check_type() reads image type property and compares its numeric
  2587. * id with the requested type. Comparison result is returned to the caller.
  2588. *
  2589. * returns:
  2590. * 1 if image is of given type
  2591. * 0 otherwise (or on error)
  2592. */
  2593. int fit_image_check_type(const void *fit, int noffset, uint8_t type)
  2594. {
  2595. uint8_t image_type;
  2596. if (fit_image_get_type(fit, noffset, &image_type))
  2597. return 0;
  2598. return (type == image_type);
  2599. }
  2600. /**
  2601. * fit_image_check_comp - check whether image node uses given compression
  2602. * @fit: pointer to the FIT format image header
  2603. * @noffset: component image node offset
  2604. * @comp: requested image compression type
  2605. *
  2606. * fit_image_check_comp() reads image compression property and compares its
  2607. * numeric id with the requested compression type. Comparison result is
  2608. * returned to the caller.
  2609. *
  2610. * returns:
  2611. * 1 if image uses requested compression
  2612. * 0 otherwise (or on error)
  2613. */
  2614. int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
  2615. {
  2616. uint8_t image_comp;
  2617. if (fit_image_get_comp(fit, noffset, &image_comp))
  2618. return 0;
  2619. return (comp == image_comp);
  2620. }
  2621. /**
  2622. * fit_check_format - sanity check FIT image format
  2623. * @fit: pointer to the FIT format image header
  2624. *
  2625. * fit_check_format() runs a basic sanity FIT image verification.
  2626. * Routine checks for mandatory properties, nodes, etc.
  2627. *
  2628. * returns:
  2629. * 1, on success
  2630. * 0, on failure
  2631. */
  2632. int fit_check_format(const void *fit)
  2633. {
  2634. /* mandatory / node 'description' property */
  2635. if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
  2636. debug("Wrong FIT format: no description\n");
  2637. return 0;
  2638. }
  2639. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  2640. /* mandatory / node 'timestamp' property */
  2641. if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
  2642. debug("Wrong FIT format: no timestamp\n");
  2643. return 0;
  2644. }
  2645. #endif
  2646. /* mandatory subimages parent '/images' node */
  2647. if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
  2648. debug("Wrong FIT format: no images parent node\n");
  2649. return 0;
  2650. }
  2651. return 1;
  2652. }
  2653. /**
  2654. * fit_conf_get_node - get node offset for configuration of a given unit name
  2655. * @fit: pointer to the FIT format image header
  2656. * @conf_uname: configuration node unit name
  2657. *
  2658. * fit_conf_get_node() finds a configuration (withing the '/configurations'
  2659. * parant node) of a provided unit name. If configuration is found its node offset
  2660. * is returned to the caller.
  2661. *
  2662. * When NULL is provided in second argument fit_conf_get_node() will search
  2663. * for a default configuration node instead. Default configuration node unit name
  2664. * is retrived from FIT_DEFAULT_PROP property of the '/configurations' node.
  2665. *
  2666. * returns:
  2667. * configuration node offset when found (>=0)
  2668. * negative number on failure (FDT_ERR_* code)
  2669. */
  2670. int fit_conf_get_node(const void *fit, const char *conf_uname)
  2671. {
  2672. int noffset, confs_noffset;
  2673. int len;
  2674. confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
  2675. if (confs_noffset < 0) {
  2676. debug("Can't find configurations parent node '%s' (%s)\n",
  2677. FIT_CONFS_PATH, fdt_strerror(confs_noffset));
  2678. return confs_noffset;
  2679. }
  2680. if (conf_uname == NULL) {
  2681. /* get configuration unit name from the default property */
  2682. debug("No configuration specified, trying default...\n");
  2683. conf_uname = (char *)fdt_getprop(fit, confs_noffset,
  2684. FIT_DEFAULT_PROP, &len);
  2685. if (conf_uname == NULL) {
  2686. fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
  2687. len);
  2688. return len;
  2689. }
  2690. debug("Found default configuration: '%s'\n", conf_uname);
  2691. }
  2692. noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
  2693. if (noffset < 0) {
  2694. debug("Can't get node offset for configuration unit name: "
  2695. "'%s' (%s)\n",
  2696. conf_uname, fdt_strerror(noffset));
  2697. }
  2698. return noffset;
  2699. }
  2700. static int __fit_conf_get_prop_node(const void *fit, int noffset,
  2701. const char *prop_name)
  2702. {
  2703. char *uname;
  2704. int len;
  2705. /* get kernel image unit name from configuration kernel property */
  2706. uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
  2707. if (uname == NULL)
  2708. return len;
  2709. return fit_image_get_node(fit, uname);
  2710. }
  2711. /**
  2712. * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
  2713. * a given configuration
  2714. * @fit: pointer to the FIT format image header
  2715. * @noffset: configuration node offset
  2716. *
  2717. * fit_conf_get_kernel_node() retrives kernel image node unit name from
  2718. * configuration FIT_KERNEL_PROP property and translates it to the node
  2719. * offset.
  2720. *
  2721. * returns:
  2722. * image node offset when found (>=0)
  2723. * negative number on failure (FDT_ERR_* code)
  2724. */
  2725. int fit_conf_get_kernel_node(const void *fit, int noffset)
  2726. {
  2727. return __fit_conf_get_prop_node(fit, noffset, FIT_KERNEL_PROP);
  2728. }
  2729. /**
  2730. * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
  2731. * a given configuration
  2732. * @fit: pointer to the FIT format image header
  2733. * @noffset: configuration node offset
  2734. *
  2735. * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
  2736. * configuration FIT_KERNEL_PROP property and translates it to the node
  2737. * offset.
  2738. *
  2739. * returns:
  2740. * image node offset when found (>=0)
  2741. * negative number on failure (FDT_ERR_* code)
  2742. */
  2743. int fit_conf_get_ramdisk_node(const void *fit, int noffset)
  2744. {
  2745. return __fit_conf_get_prop_node(fit, noffset, FIT_RAMDISK_PROP);
  2746. }
  2747. /**
  2748. * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
  2749. * a given configuration
  2750. * @fit: pointer to the FIT format image header
  2751. * @noffset: configuration node offset
  2752. *
  2753. * fit_conf_get_fdt_node() retrives fdt image node unit name from
  2754. * configuration FIT_KERNEL_PROP property and translates it to the node
  2755. * offset.
  2756. *
  2757. * returns:
  2758. * image node offset when found (>=0)
  2759. * negative number on failure (FDT_ERR_* code)
  2760. */
  2761. int fit_conf_get_fdt_node(const void *fit, int noffset)
  2762. {
  2763. return __fit_conf_get_prop_node(fit, noffset, FIT_FDT_PROP);
  2764. }
  2765. /**
  2766. * fit_conf_print - prints out the FIT configuration details
  2767. * @fit: pointer to the FIT format image header
  2768. * @noffset: offset of the configuration node
  2769. * @p: pointer to prefix string
  2770. *
  2771. * fit_conf_print() lists all mandatory properies for the processed
  2772. * configuration node.
  2773. *
  2774. * returns:
  2775. * no returned results
  2776. */
  2777. void fit_conf_print(const void *fit, int noffset, const char *p)
  2778. {
  2779. char *desc;
  2780. char *uname;
  2781. int ret;
  2782. /* Mandatory properties */
  2783. ret = fit_get_desc(fit, noffset, &desc);
  2784. printf("%s Description: ", p);
  2785. if (ret)
  2786. printf("unavailable\n");
  2787. else
  2788. printf("%s\n", desc);
  2789. uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
  2790. printf("%s Kernel: ", p);
  2791. if (uname == NULL)
  2792. printf("unavailable\n");
  2793. else
  2794. printf("%s\n", uname);
  2795. /* Optional properties */
  2796. uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
  2797. if (uname)
  2798. printf("%s Init Ramdisk: %s\n", p, uname);
  2799. uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
  2800. if (uname)
  2801. printf("%s FDT: %s\n", p, uname);
  2802. }
  2803. /**
  2804. * fit_check_ramdisk - verify FIT format ramdisk subimage
  2805. * @fit_hdr: pointer to the FIT ramdisk header
  2806. * @rd_noffset: ramdisk subimage node offset within FIT image
  2807. * @arch: requested ramdisk image architecture type
  2808. * @verify: data CRC verification flag
  2809. *
  2810. * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
  2811. * specified FIT image.
  2812. *
  2813. * returns:
  2814. * 1, on success
  2815. * 0, on failure
  2816. */
  2817. #ifndef USE_HOSTCC
  2818. static int fit_check_ramdisk(const void *fit, int rd_noffset, uint8_t arch,
  2819. int verify)
  2820. {
  2821. fit_image_print(fit, rd_noffset, " ");
  2822. if (verify) {
  2823. puts(" Verifying Hash Integrity ... ");
  2824. if (!fit_image_check_hashes(fit, rd_noffset)) {
  2825. puts("Bad Data Hash\n");
  2826. show_boot_progress(-125);
  2827. return 0;
  2828. }
  2829. puts("OK\n");
  2830. }
  2831. show_boot_progress(126);
  2832. if (!fit_image_check_os(fit, rd_noffset, IH_OS_LINUX) ||
  2833. !fit_image_check_arch(fit, rd_noffset, arch) ||
  2834. !fit_image_check_type(fit, rd_noffset, IH_TYPE_RAMDISK)) {
  2835. printf("No Linux %s Ramdisk Image\n",
  2836. genimg_get_arch_name(arch));
  2837. show_boot_progress(-126);
  2838. return 0;
  2839. }
  2840. show_boot_progress(127);
  2841. return 1;
  2842. }
  2843. #endif /* USE_HOSTCC */
  2844. #endif /* CONFIG_FIT */