image.c 85 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215
  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. bootstage_error(BOOTSTAGE_ID_RD_MAGIC);
  330. return NULL;
  331. }
  332. if (!image_check_hcrc(rd_hdr)) {
  333. puts("Bad Header Checksum\n");
  334. bootstage_error(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
  335. return NULL;
  336. }
  337. bootstage_mark(BOOTSTAGE_ID_RD_MAGIC);
  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. bootstage_error(BOOTSTAGE_ID_RD_CHECKSUM);
  344. return NULL;
  345. }
  346. puts("OK\n");
  347. }
  348. bootstage_mark(BOOTSTAGE_ID_RD_HDR_CHECKSUM);
  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. bootstage_error(BOOTSTAGE_ID_RAMDISK);
  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. #ifdef CONFIG_SUPPORT_RAW_INITRD
  707. char *end;
  708. #endif
  709. #if defined(CONFIG_FIT)
  710. void *fit_hdr;
  711. const char *fit_uname_config = NULL;
  712. const char *fit_uname_ramdisk = NULL;
  713. ulong default_addr;
  714. int rd_noffset;
  715. int cfg_noffset;
  716. const void *data;
  717. size_t size;
  718. #endif
  719. *rd_start = 0;
  720. *rd_end = 0;
  721. /*
  722. * Look for a '-' which indicates to ignore the
  723. * ramdisk argument
  724. */
  725. if ((argc >= 3) && (strcmp(argv[2], "-") == 0)) {
  726. debug("## Skipping init Ramdisk\n");
  727. rd_len = rd_data = 0;
  728. } else if (argc >= 3 || genimg_has_config(images)) {
  729. #if defined(CONFIG_FIT)
  730. if (argc >= 3) {
  731. /*
  732. * If the init ramdisk comes from the FIT image and
  733. * the FIT image address is omitted in the command
  734. * line argument, try to use os FIT image address or
  735. * default load address.
  736. */
  737. if (images->fit_uname_os)
  738. default_addr = (ulong)images->fit_hdr_os;
  739. else
  740. default_addr = load_addr;
  741. if (fit_parse_conf(argv[2], default_addr,
  742. &rd_addr, &fit_uname_config)) {
  743. debug("* ramdisk: config '%s' from image at "
  744. "0x%08lx\n",
  745. fit_uname_config, rd_addr);
  746. } else if (fit_parse_subimage(argv[2], default_addr,
  747. &rd_addr, &fit_uname_ramdisk)) {
  748. debug("* ramdisk: subimage '%s' from image at "
  749. "0x%08lx\n",
  750. fit_uname_ramdisk, rd_addr);
  751. } else
  752. #endif
  753. {
  754. rd_addr = simple_strtoul(argv[2], NULL, 16);
  755. debug("* ramdisk: cmdline image address = "
  756. "0x%08lx\n",
  757. rd_addr);
  758. }
  759. #if defined(CONFIG_FIT)
  760. } else {
  761. /* use FIT configuration provided in first bootm
  762. * command argument
  763. */
  764. rd_addr = (ulong)images->fit_hdr_os;
  765. fit_uname_config = images->fit_uname_cfg;
  766. debug("* ramdisk: using config '%s' from image "
  767. "at 0x%08lx\n",
  768. fit_uname_config, rd_addr);
  769. /*
  770. * Check whether configuration has ramdisk defined,
  771. * if not, don't try to use it, quit silently.
  772. */
  773. fit_hdr = (void *)rd_addr;
  774. cfg_noffset = fit_conf_get_node(fit_hdr,
  775. fit_uname_config);
  776. if (cfg_noffset < 0) {
  777. debug("* ramdisk: no such config\n");
  778. return 1;
  779. }
  780. rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
  781. cfg_noffset);
  782. if (rd_noffset < 0) {
  783. debug("* ramdisk: no ramdisk in config\n");
  784. return 0;
  785. }
  786. }
  787. #endif
  788. /* copy from dataflash if needed */
  789. rd_addr = genimg_get_image(rd_addr);
  790. /*
  791. * Check if there is an initrd image at the
  792. * address provided in the second bootm argument
  793. * check image type, for FIT images get FIT node.
  794. */
  795. switch (genimg_get_format((void *)rd_addr)) {
  796. case IMAGE_FORMAT_LEGACY:
  797. printf("## Loading init Ramdisk from Legacy "
  798. "Image at %08lx ...\n", rd_addr);
  799. bootstage_mark(BOOTSTAGE_ID_CHECK_RAMDISK);
  800. rd_hdr = image_get_ramdisk(rd_addr, arch,
  801. images->verify);
  802. if (rd_hdr == NULL)
  803. return 1;
  804. rd_data = image_get_data(rd_hdr);
  805. rd_len = image_get_data_size(rd_hdr);
  806. rd_load = image_get_load(rd_hdr);
  807. break;
  808. #if defined(CONFIG_FIT)
  809. case IMAGE_FORMAT_FIT:
  810. fit_hdr = (void *)rd_addr;
  811. printf("## Loading init Ramdisk from FIT "
  812. "Image at %08lx ...\n", rd_addr);
  813. bootstage_mark(BOOTSTAGE_ID_FIT_RD_FORMAT);
  814. if (!fit_check_format(fit_hdr)) {
  815. puts("Bad FIT ramdisk image format!\n");
  816. bootstage_error(
  817. BOOTSTAGE_ID_FIT_RD_FORMAT);
  818. return 1;
  819. }
  820. bootstage_mark(BOOTSTAGE_ID_FIT_RD_FORMAT_OK);
  821. if (!fit_uname_ramdisk) {
  822. /*
  823. * no ramdisk image node unit name, try to get config
  824. * node first. If config unit node name is NULL
  825. * fit_conf_get_node() will try to find default config node
  826. */
  827. bootstage_mark(
  828. BOOTSTAGE_ID_FIT_RD_NO_UNIT_NAME);
  829. cfg_noffset = fit_conf_get_node(fit_hdr,
  830. fit_uname_config);
  831. if (cfg_noffset < 0) {
  832. puts("Could not find configuration "
  833. "node\n");
  834. bootstage_error(
  835. BOOTSTAGE_ID_FIT_RD_NO_UNIT_NAME);
  836. return 1;
  837. }
  838. fit_uname_config = fdt_get_name(fit_hdr,
  839. cfg_noffset, NULL);
  840. printf(" Using '%s' configuration\n",
  841. fit_uname_config);
  842. rd_noffset = fit_conf_get_ramdisk_node(fit_hdr,
  843. cfg_noffset);
  844. fit_uname_ramdisk = fit_get_name(fit_hdr,
  845. rd_noffset, NULL);
  846. } else {
  847. /* get ramdisk component image node offset */
  848. bootstage_mark(
  849. BOOTSTAGE_ID_FIT_RD_UNIT_NAME);
  850. rd_noffset = fit_image_get_node(fit_hdr,
  851. fit_uname_ramdisk);
  852. }
  853. if (rd_noffset < 0) {
  854. puts("Could not find subimage node\n");
  855. bootstage_error(BOOTSTAGE_ID_FIT_RD_SUBNODE);
  856. return 1;
  857. }
  858. printf(" Trying '%s' ramdisk subimage\n",
  859. fit_uname_ramdisk);
  860. bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK);
  861. if (!fit_check_ramdisk(fit_hdr, rd_noffset, arch,
  862. images->verify))
  863. return 1;
  864. /* get ramdisk image data address and length */
  865. if (fit_image_get_data(fit_hdr, rd_noffset, &data,
  866. &size)) {
  867. puts("Could not find ramdisk subimage data!\n");
  868. bootstage_error(BOOTSTAGE_ID_FIT_RD_GET_DATA);
  869. return 1;
  870. }
  871. bootstage_mark(BOOTSTAGE_ID_FIT_RD_GET_DATA_OK);
  872. rd_data = (ulong)data;
  873. rd_len = size;
  874. if (fit_image_get_load(fit_hdr, rd_noffset, &rd_load)) {
  875. puts("Can't get ramdisk subimage load "
  876. "address!\n");
  877. bootstage_error(BOOTSTAGE_ID_FIT_RD_LOAD);
  878. return 1;
  879. }
  880. bootstage_mark(BOOTSTAGE_ID_FIT_RD_LOAD);
  881. images->fit_hdr_rd = fit_hdr;
  882. images->fit_uname_rd = fit_uname_ramdisk;
  883. images->fit_noffset_rd = rd_noffset;
  884. break;
  885. #endif
  886. default:
  887. #ifdef CONFIG_SUPPORT_RAW_INITRD
  888. if (argc >= 3 && (end = strchr(argv[2], ':'))) {
  889. rd_len = simple_strtoul(++end, NULL, 16);
  890. rd_data = rd_addr;
  891. } else
  892. #endif
  893. {
  894. puts("Wrong Ramdisk Image Format\n");
  895. rd_data = rd_len = rd_load = 0;
  896. return 1;
  897. }
  898. }
  899. } else if (images->legacy_hdr_valid &&
  900. image_check_type(&images->legacy_hdr_os_copy,
  901. IH_TYPE_MULTI)) {
  902. /*
  903. * Now check if we have a legacy mult-component image,
  904. * get second entry data start address and len.
  905. */
  906. bootstage_mark(BOOTSTAGE_ID_RAMDISK);
  907. printf("## Loading init Ramdisk from multi component "
  908. "Legacy Image at %08lx ...\n",
  909. (ulong)images->legacy_hdr_os);
  910. image_multi_getimg(images->legacy_hdr_os, 1, &rd_data, &rd_len);
  911. } else {
  912. /*
  913. * no initrd image
  914. */
  915. bootstage_mark(BOOTSTAGE_ID_NO_RAMDISK);
  916. rd_len = rd_data = 0;
  917. }
  918. if (!rd_data) {
  919. debug("## No init Ramdisk\n");
  920. } else {
  921. *rd_start = rd_data;
  922. *rd_end = rd_data + rd_len;
  923. }
  924. debug(" ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
  925. *rd_start, *rd_end);
  926. return 0;
  927. }
  928. #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
  929. /**
  930. * boot_ramdisk_high - relocate init ramdisk
  931. * @lmb: pointer to lmb handle, will be used for memory mgmt
  932. * @rd_data: ramdisk data start address
  933. * @rd_len: ramdisk data length
  934. * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
  935. * start address (after possible relocation)
  936. * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
  937. * end address (after possible relocation)
  938. *
  939. * boot_ramdisk_high() takes a relocation hint from "initrd_high" environement
  940. * variable and if requested ramdisk data is moved to a specified location.
  941. *
  942. * Initrd_start and initrd_end are set to final (after relocation) ramdisk
  943. * start/end addresses if ramdisk image start and len were provided,
  944. * otherwise set initrd_start and initrd_end set to zeros.
  945. *
  946. * returns:
  947. * 0 - success
  948. * -1 - failure
  949. */
  950. int boot_ramdisk_high(struct lmb *lmb, ulong rd_data, ulong rd_len,
  951. ulong *initrd_start, ulong *initrd_end)
  952. {
  953. char *s;
  954. ulong initrd_high;
  955. int initrd_copy_to_ram = 1;
  956. if ((s = getenv("initrd_high")) != NULL) {
  957. /* a value of "no" or a similar string will act like 0,
  958. * turning the "load high" feature off. This is intentional.
  959. */
  960. initrd_high = simple_strtoul(s, NULL, 16);
  961. if (initrd_high == ~0)
  962. initrd_copy_to_ram = 0;
  963. } else {
  964. /* not set, no restrictions to load high */
  965. initrd_high = ~0;
  966. }
  967. #ifdef CONFIG_LOGBUFFER
  968. /* Prevent initrd from overwriting logbuffer */
  969. lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE);
  970. #endif
  971. debug("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
  972. initrd_high, initrd_copy_to_ram);
  973. if (rd_data) {
  974. if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */
  975. debug(" in-place initrd\n");
  976. *initrd_start = rd_data;
  977. *initrd_end = rd_data + rd_len;
  978. lmb_reserve(lmb, rd_data, rd_len);
  979. } else {
  980. if (initrd_high)
  981. *initrd_start = (ulong)lmb_alloc_base(lmb,
  982. rd_len, 0x1000, initrd_high);
  983. else
  984. *initrd_start = (ulong)lmb_alloc(lmb, rd_len,
  985. 0x1000);
  986. if (*initrd_start == 0) {
  987. puts("ramdisk - allocation error\n");
  988. goto error;
  989. }
  990. bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);
  991. *initrd_end = *initrd_start + rd_len;
  992. printf(" Loading Ramdisk to %08lx, end %08lx ... ",
  993. *initrd_start, *initrd_end);
  994. memmove_wd((void *)*initrd_start,
  995. (void *)rd_data, rd_len, CHUNKSZ);
  996. #ifdef CONFIG_MP
  997. /*
  998. * Ensure the image is flushed to memory to handle
  999. * AMP boot scenarios in which we might not be
  1000. * HW cache coherent
  1001. */
  1002. flush_cache((unsigned long)*initrd_start, rd_len);
  1003. #endif
  1004. puts("OK\n");
  1005. }
  1006. } else {
  1007. *initrd_start = 0;
  1008. *initrd_end = 0;
  1009. }
  1010. debug(" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
  1011. *initrd_start, *initrd_end);
  1012. return 0;
  1013. error:
  1014. return -1;
  1015. }
  1016. #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */
  1017. #ifdef CONFIG_OF_LIBFDT
  1018. static void fdt_error(const char *msg)
  1019. {
  1020. puts("ERROR: ");
  1021. puts(msg);
  1022. puts(" - must RESET the board to recover.\n");
  1023. }
  1024. static const image_header_t *image_get_fdt(ulong fdt_addr)
  1025. {
  1026. const image_header_t *fdt_hdr = (const image_header_t *)fdt_addr;
  1027. image_print_contents(fdt_hdr);
  1028. puts(" Verifying Checksum ... ");
  1029. if (!image_check_hcrc(fdt_hdr)) {
  1030. fdt_error("fdt header checksum invalid");
  1031. return NULL;
  1032. }
  1033. if (!image_check_dcrc(fdt_hdr)) {
  1034. fdt_error("fdt checksum invalid");
  1035. return NULL;
  1036. }
  1037. puts("OK\n");
  1038. if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
  1039. fdt_error("uImage is not a fdt");
  1040. return NULL;
  1041. }
  1042. if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
  1043. fdt_error("uImage is compressed");
  1044. return NULL;
  1045. }
  1046. if (fdt_check_header((char *)image_get_data(fdt_hdr)) != 0) {
  1047. fdt_error("uImage data is not a fdt");
  1048. return NULL;
  1049. }
  1050. return fdt_hdr;
  1051. }
  1052. /**
  1053. * fit_check_fdt - verify FIT format FDT subimage
  1054. * @fit_hdr: pointer to the FIT header
  1055. * fdt_noffset: FDT subimage node offset within FIT image
  1056. * @verify: data CRC verification flag
  1057. *
  1058. * fit_check_fdt() verifies integrity of the FDT subimage and from
  1059. * specified FIT image.
  1060. *
  1061. * returns:
  1062. * 1, on success
  1063. * 0, on failure
  1064. */
  1065. #if defined(CONFIG_FIT)
  1066. static int fit_check_fdt(const void *fit, int fdt_noffset, int verify)
  1067. {
  1068. fit_image_print(fit, fdt_noffset, " ");
  1069. if (verify) {
  1070. puts(" Verifying Hash Integrity ... ");
  1071. if (!fit_image_check_hashes(fit, fdt_noffset)) {
  1072. fdt_error("Bad Data Hash");
  1073. return 0;
  1074. }
  1075. puts("OK\n");
  1076. }
  1077. if (!fit_image_check_type(fit, fdt_noffset, IH_TYPE_FLATDT)) {
  1078. fdt_error("Not a FDT image");
  1079. return 0;
  1080. }
  1081. if (!fit_image_check_comp(fit, fdt_noffset, IH_COMP_NONE)) {
  1082. fdt_error("FDT image is compressed");
  1083. return 0;
  1084. }
  1085. return 1;
  1086. }
  1087. #endif /* CONFIG_FIT */
  1088. #ifndef CONFIG_SYS_FDT_PAD
  1089. #define CONFIG_SYS_FDT_PAD 0x3000
  1090. #endif
  1091. #if defined(CONFIG_OF_LIBFDT)
  1092. /**
  1093. * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable
  1094. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1095. * @fdt_blob: pointer to fdt blob base address
  1096. *
  1097. * Adds the memreserve regions in the dtb to the lmb block. Adding the
  1098. * memreserve regions prevents u-boot from using them to store the initrd
  1099. * or the fdt blob.
  1100. */
  1101. void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
  1102. {
  1103. uint64_t addr, size;
  1104. int i, total;
  1105. if (fdt_check_header(fdt_blob) != 0)
  1106. return;
  1107. total = fdt_num_mem_rsv(fdt_blob);
  1108. for (i = 0; i < total; i++) {
  1109. if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
  1110. continue;
  1111. printf(" reserving fdt memory region: addr=%llx size=%llx\n",
  1112. (unsigned long long)addr, (unsigned long long)size);
  1113. lmb_reserve(lmb, addr, size);
  1114. }
  1115. }
  1116. /**
  1117. * boot_relocate_fdt - relocate flat device tree
  1118. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1119. * @of_flat_tree: pointer to a char* variable, will hold fdt start address
  1120. * @of_size: pointer to a ulong variable, will hold fdt length
  1121. *
  1122. * boot_relocate_fdt() allocates a region of memory within the bootmap and
  1123. * relocates the of_flat_tree into that region, even if the fdt is already in
  1124. * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
  1125. * bytes.
  1126. *
  1127. * of_flat_tree and of_size are set to final (after relocation) values
  1128. *
  1129. * returns:
  1130. * 0 - success
  1131. * 1 - failure
  1132. */
  1133. int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
  1134. {
  1135. void *fdt_blob = *of_flat_tree;
  1136. void *of_start = 0;
  1137. char *fdt_high;
  1138. ulong of_len = 0;
  1139. int err;
  1140. int disable_relocation = 0;
  1141. /* nothing to do */
  1142. if (*of_size == 0)
  1143. return 0;
  1144. if (fdt_check_header(fdt_blob) != 0) {
  1145. fdt_error("image is not a fdt");
  1146. goto error;
  1147. }
  1148. /* position on a 4K boundary before the alloc_current */
  1149. /* Pad the FDT by a specified amount */
  1150. of_len = *of_size + CONFIG_SYS_FDT_PAD;
  1151. /* If fdt_high is set use it to select the relocation address */
  1152. fdt_high = getenv("fdt_high");
  1153. if (fdt_high) {
  1154. void *desired_addr = (void *)simple_strtoul(fdt_high, NULL, 16);
  1155. if (((ulong) desired_addr) == ~0UL) {
  1156. /* All ones means use fdt in place */
  1157. of_start = fdt_blob;
  1158. lmb_reserve(lmb, (ulong)of_start, of_len);
  1159. disable_relocation = 1;
  1160. } else if (desired_addr) {
  1161. of_start =
  1162. (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  1163. (ulong)desired_addr);
  1164. if (of_start == 0) {
  1165. puts("Failed using fdt_high value for Device Tree");
  1166. goto error;
  1167. }
  1168. } else {
  1169. of_start =
  1170. (void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
  1171. }
  1172. } else {
  1173. of_start =
  1174. (void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
  1175. getenv_bootm_mapsize()
  1176. + getenv_bootm_low());
  1177. }
  1178. if (of_start == 0) {
  1179. puts("device tree - allocation error\n");
  1180. goto error;
  1181. }
  1182. if (disable_relocation) {
  1183. /* We assume there is space after the existing fdt to use for padding */
  1184. fdt_set_totalsize(of_start, of_len);
  1185. printf(" Using Device Tree in place at %p, end %p\n",
  1186. of_start, of_start + of_len - 1);
  1187. } else {
  1188. debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
  1189. fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
  1190. printf(" Loading Device Tree to %p, end %p ... ",
  1191. of_start, of_start + of_len - 1);
  1192. err = fdt_open_into(fdt_blob, of_start, of_len);
  1193. if (err != 0) {
  1194. fdt_error("fdt move failed");
  1195. goto error;
  1196. }
  1197. puts("OK\n");
  1198. }
  1199. *of_flat_tree = of_start;
  1200. *of_size = of_len;
  1201. set_working_fdt_addr(*of_flat_tree);
  1202. return 0;
  1203. error:
  1204. return 1;
  1205. }
  1206. #endif /* CONFIG_OF_LIBFDT */
  1207. /**
  1208. * boot_get_fdt - main fdt handling routine
  1209. * @argc: command argument count
  1210. * @argv: command argument list
  1211. * @images: pointer to the bootm images structure
  1212. * @of_flat_tree: pointer to a char* variable, will hold fdt start address
  1213. * @of_size: pointer to a ulong variable, will hold fdt length
  1214. *
  1215. * boot_get_fdt() is responsible for finding a valid flat device tree image.
  1216. * Curently supported are the following ramdisk sources:
  1217. * - multicomponent kernel/ramdisk image,
  1218. * - commandline provided address of decicated ramdisk image.
  1219. *
  1220. * returns:
  1221. * 0, if fdt image was found and valid, or skipped
  1222. * of_flat_tree and of_size are set to fdt start address and length if
  1223. * fdt image is found and valid
  1224. *
  1225. * 1, if fdt image is found but corrupted
  1226. * of_flat_tree and of_size are set to 0 if no fdt exists
  1227. */
  1228. int boot_get_fdt(int flag, int argc, char * const argv[],
  1229. bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
  1230. {
  1231. const image_header_t *fdt_hdr;
  1232. ulong fdt_addr;
  1233. char *fdt_blob = NULL;
  1234. ulong image_start, image_data, image_end;
  1235. ulong load_start, load_end;
  1236. #if defined(CONFIG_FIT)
  1237. void *fit_hdr;
  1238. const char *fit_uname_config = NULL;
  1239. const char *fit_uname_fdt = NULL;
  1240. ulong default_addr;
  1241. int cfg_noffset;
  1242. int fdt_noffset;
  1243. const void *data;
  1244. size_t size;
  1245. #endif
  1246. *of_flat_tree = NULL;
  1247. *of_size = 0;
  1248. if (argc > 3 || genimg_has_config(images)) {
  1249. #if defined(CONFIG_FIT)
  1250. if (argc > 3) {
  1251. /*
  1252. * If the FDT blob comes from the FIT image and the
  1253. * FIT image address is omitted in the command line
  1254. * argument, try to use ramdisk or os FIT image
  1255. * address or default load address.
  1256. */
  1257. if (images->fit_uname_rd)
  1258. default_addr = (ulong)images->fit_hdr_rd;
  1259. else if (images->fit_uname_os)
  1260. default_addr = (ulong)images->fit_hdr_os;
  1261. else
  1262. default_addr = load_addr;
  1263. if (fit_parse_conf(argv[3], default_addr,
  1264. &fdt_addr, &fit_uname_config)) {
  1265. debug("* fdt: config '%s' from image at "
  1266. "0x%08lx\n",
  1267. fit_uname_config, fdt_addr);
  1268. } else if (fit_parse_subimage(argv[3], default_addr,
  1269. &fdt_addr, &fit_uname_fdt)) {
  1270. debug("* fdt: subimage '%s' from image at "
  1271. "0x%08lx\n",
  1272. fit_uname_fdt, fdt_addr);
  1273. } else
  1274. #endif
  1275. {
  1276. fdt_addr = simple_strtoul(argv[3], NULL, 16);
  1277. debug("* fdt: cmdline image address = "
  1278. "0x%08lx\n",
  1279. fdt_addr);
  1280. }
  1281. #if defined(CONFIG_FIT)
  1282. } else {
  1283. /* use FIT configuration provided in first bootm
  1284. * command argument
  1285. */
  1286. fdt_addr = (ulong)images->fit_hdr_os;
  1287. fit_uname_config = images->fit_uname_cfg;
  1288. debug("* fdt: using config '%s' from image "
  1289. "at 0x%08lx\n",
  1290. fit_uname_config, fdt_addr);
  1291. /*
  1292. * Check whether configuration has FDT blob defined,
  1293. * if not quit silently.
  1294. */
  1295. fit_hdr = (void *)fdt_addr;
  1296. cfg_noffset = fit_conf_get_node(fit_hdr,
  1297. fit_uname_config);
  1298. if (cfg_noffset < 0) {
  1299. debug("* fdt: no such config\n");
  1300. return 0;
  1301. }
  1302. fdt_noffset = fit_conf_get_fdt_node(fit_hdr,
  1303. cfg_noffset);
  1304. if (fdt_noffset < 0) {
  1305. debug("* fdt: no fdt in config\n");
  1306. return 0;
  1307. }
  1308. }
  1309. #endif
  1310. debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
  1311. fdt_addr);
  1312. /* copy from dataflash if needed */
  1313. fdt_addr = genimg_get_image(fdt_addr);
  1314. /*
  1315. * Check if there is an FDT image at the
  1316. * address provided in the second bootm argument
  1317. * check image type, for FIT images get a FIT node.
  1318. */
  1319. switch (genimg_get_format((void *)fdt_addr)) {
  1320. case IMAGE_FORMAT_LEGACY:
  1321. /* verify fdt_addr points to a valid image header */
  1322. printf("## Flattened Device Tree from Legacy Image "
  1323. "at %08lx\n",
  1324. fdt_addr);
  1325. fdt_hdr = image_get_fdt(fdt_addr);
  1326. if (!fdt_hdr)
  1327. goto error;
  1328. /*
  1329. * move image data to the load address,
  1330. * make sure we don't overwrite initial image
  1331. */
  1332. image_start = (ulong)fdt_hdr;
  1333. image_data = (ulong)image_get_data(fdt_hdr);
  1334. image_end = image_get_image_end(fdt_hdr);
  1335. load_start = image_get_load(fdt_hdr);
  1336. load_end = load_start + image_get_data_size(fdt_hdr);
  1337. if (load_start == image_start ||
  1338. load_start == image_data) {
  1339. fdt_blob = (char *)image_data;
  1340. break;
  1341. }
  1342. if ((load_start < image_end) && (load_end > image_start)) {
  1343. fdt_error("fdt overwritten");
  1344. goto error;
  1345. }
  1346. debug(" Loading FDT from 0x%08lx to 0x%08lx\n",
  1347. image_data, load_start);
  1348. memmove((void *)load_start,
  1349. (void *)image_data,
  1350. image_get_data_size(fdt_hdr));
  1351. fdt_blob = (char *)load_start;
  1352. break;
  1353. case IMAGE_FORMAT_FIT:
  1354. /*
  1355. * This case will catch both: new uImage format
  1356. * (libfdt based) and raw FDT blob (also libfdt
  1357. * based).
  1358. */
  1359. #if defined(CONFIG_FIT)
  1360. /* check FDT blob vs FIT blob */
  1361. if (fit_check_format((const void *)fdt_addr)) {
  1362. /*
  1363. * FIT image
  1364. */
  1365. fit_hdr = (void *)fdt_addr;
  1366. printf("## Flattened Device Tree from FIT "
  1367. "Image at %08lx\n",
  1368. fdt_addr);
  1369. if (!fit_uname_fdt) {
  1370. /*
  1371. * no FDT blob image node unit name,
  1372. * try to get config node first. If
  1373. * config unit node name is NULL
  1374. * fit_conf_get_node() will try to
  1375. * find default config node
  1376. */
  1377. cfg_noffset = fit_conf_get_node(fit_hdr,
  1378. fit_uname_config);
  1379. if (cfg_noffset < 0) {
  1380. fdt_error("Could not find "
  1381. "configuration "
  1382. "node\n");
  1383. goto error;
  1384. }
  1385. fit_uname_config = fdt_get_name(fit_hdr,
  1386. cfg_noffset, NULL);
  1387. printf(" Using '%s' configuration\n",
  1388. fit_uname_config);
  1389. fdt_noffset = fit_conf_get_fdt_node(
  1390. fit_hdr,
  1391. cfg_noffset);
  1392. fit_uname_fdt = fit_get_name(fit_hdr,
  1393. fdt_noffset, NULL);
  1394. } else {
  1395. /* get FDT component image node offset */
  1396. fdt_noffset = fit_image_get_node(
  1397. fit_hdr,
  1398. fit_uname_fdt);
  1399. }
  1400. if (fdt_noffset < 0) {
  1401. fdt_error("Could not find subimage "
  1402. "node\n");
  1403. goto error;
  1404. }
  1405. printf(" Trying '%s' FDT blob subimage\n",
  1406. fit_uname_fdt);
  1407. if (!fit_check_fdt(fit_hdr, fdt_noffset,
  1408. images->verify))
  1409. goto error;
  1410. /* get ramdisk image data address and length */
  1411. if (fit_image_get_data(fit_hdr, fdt_noffset,
  1412. &data, &size)) {
  1413. fdt_error("Could not find FDT "
  1414. "subimage data");
  1415. goto error;
  1416. }
  1417. /* verift that image data is a proper FDT blob */
  1418. if (fdt_check_header((char *)data) != 0) {
  1419. fdt_error("Subimage data is not a FTD");
  1420. goto error;
  1421. }
  1422. /*
  1423. * move image data to the load address,
  1424. * make sure we don't overwrite initial image
  1425. */
  1426. image_start = (ulong)fit_hdr;
  1427. image_end = fit_get_end(fit_hdr);
  1428. if (fit_image_get_load(fit_hdr, fdt_noffset,
  1429. &load_start) == 0) {
  1430. load_end = load_start + size;
  1431. if ((load_start < image_end) &&
  1432. (load_end > image_start)) {
  1433. fdt_error("FDT overwritten");
  1434. goto error;
  1435. }
  1436. printf(" Loading FDT from 0x%08lx "
  1437. "to 0x%08lx\n",
  1438. (ulong)data,
  1439. load_start);
  1440. memmove((void *)load_start,
  1441. (void *)data, size);
  1442. fdt_blob = (char *)load_start;
  1443. } else {
  1444. fdt_blob = (char *)data;
  1445. }
  1446. images->fit_hdr_fdt = fit_hdr;
  1447. images->fit_uname_fdt = fit_uname_fdt;
  1448. images->fit_noffset_fdt = fdt_noffset;
  1449. break;
  1450. } else
  1451. #endif
  1452. {
  1453. /*
  1454. * FDT blob
  1455. */
  1456. fdt_blob = (char *)fdt_addr;
  1457. debug("* fdt: raw FDT blob\n");
  1458. printf("## Flattened Device Tree blob at "
  1459. "%08lx\n", (long)fdt_blob);
  1460. }
  1461. break;
  1462. default:
  1463. puts("ERROR: Did not find a cmdline Flattened Device "
  1464. "Tree\n");
  1465. goto error;
  1466. }
  1467. printf(" Booting using the fdt blob at 0x%p\n", fdt_blob);
  1468. } else if (images->legacy_hdr_valid &&
  1469. image_check_type(&images->legacy_hdr_os_copy,
  1470. IH_TYPE_MULTI)) {
  1471. ulong fdt_data, fdt_len;
  1472. /*
  1473. * Now check if we have a legacy multi-component image,
  1474. * get second entry data start address and len.
  1475. */
  1476. printf("## Flattened Device Tree from multi "
  1477. "component Image at %08lX\n",
  1478. (ulong)images->legacy_hdr_os);
  1479. image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
  1480. &fdt_len);
  1481. if (fdt_len) {
  1482. fdt_blob = (char *)fdt_data;
  1483. printf(" Booting using the fdt at 0x%p\n", fdt_blob);
  1484. if (fdt_check_header(fdt_blob) != 0) {
  1485. fdt_error("image is not a fdt");
  1486. goto error;
  1487. }
  1488. if (fdt_totalsize(fdt_blob) != fdt_len) {
  1489. fdt_error("fdt size != image size");
  1490. goto error;
  1491. }
  1492. } else {
  1493. debug("## No Flattened Device Tree\n");
  1494. return 0;
  1495. }
  1496. } else {
  1497. debug("## No Flattened Device Tree\n");
  1498. return 0;
  1499. }
  1500. *of_flat_tree = fdt_blob;
  1501. *of_size = fdt_totalsize(fdt_blob);
  1502. debug(" of_flat_tree at 0x%08lx size 0x%08lx\n",
  1503. (ulong)*of_flat_tree, *of_size);
  1504. return 0;
  1505. error:
  1506. *of_flat_tree = 0;
  1507. *of_size = 0;
  1508. return 1;
  1509. }
  1510. #endif /* CONFIG_OF_LIBFDT */
  1511. #ifdef CONFIG_SYS_BOOT_GET_CMDLINE
  1512. /**
  1513. * boot_get_cmdline - allocate and initialize kernel cmdline
  1514. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1515. * @cmd_start: pointer to a ulong variable, will hold cmdline start
  1516. * @cmd_end: pointer to a ulong variable, will hold cmdline end
  1517. *
  1518. * boot_get_cmdline() allocates space for kernel command line below
  1519. * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt
  1520. * variable is present its contents is copied to allocated kernel
  1521. * command line.
  1522. *
  1523. * returns:
  1524. * 0 - success
  1525. * -1 - failure
  1526. */
  1527. int boot_get_cmdline(struct lmb *lmb, ulong *cmd_start, ulong *cmd_end)
  1528. {
  1529. char *cmdline;
  1530. char *s;
  1531. cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
  1532. getenv_bootm_mapsize() + getenv_bootm_low());
  1533. if (cmdline == NULL)
  1534. return -1;
  1535. if ((s = getenv("bootargs")) == NULL)
  1536. s = "";
  1537. strcpy(cmdline, s);
  1538. *cmd_start = (ulong) & cmdline[0];
  1539. *cmd_end = *cmd_start + strlen(cmdline);
  1540. debug("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
  1541. return 0;
  1542. }
  1543. #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */
  1544. #ifdef CONFIG_SYS_BOOT_GET_KBD
  1545. /**
  1546. * boot_get_kbd - allocate and initialize kernel copy of board info
  1547. * @lmb: pointer to lmb handle, will be used for memory mgmt
  1548. * @kbd: double pointer to board info data
  1549. *
  1550. * boot_get_kbd() allocates space for kernel copy of board info data below
  1551. * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized
  1552. * with the current u-boot board info data.
  1553. *
  1554. * returns:
  1555. * 0 - success
  1556. * -1 - failure
  1557. */
  1558. int boot_get_kbd(struct lmb *lmb, bd_t **kbd)
  1559. {
  1560. *kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
  1561. getenv_bootm_mapsize() + getenv_bootm_low());
  1562. if (*kbd == NULL)
  1563. return -1;
  1564. **kbd = *(gd->bd);
  1565. debug("## kernel board info at 0x%08lx\n", (ulong)*kbd);
  1566. #if defined(DEBUG) && defined(CONFIG_CMD_BDI)
  1567. do_bdinfo(NULL, 0, 0, NULL);
  1568. #endif
  1569. return 0;
  1570. }
  1571. #endif /* CONFIG_SYS_BOOT_GET_KBD */
  1572. #endif /* !USE_HOSTCC */
  1573. #if defined(CONFIG_FIT)
  1574. /*****************************************************************************/
  1575. /* New uImage format routines */
  1576. /*****************************************************************************/
  1577. #ifndef USE_HOSTCC
  1578. static int fit_parse_spec(const char *spec, char sepc, ulong addr_curr,
  1579. ulong *addr, const char **name)
  1580. {
  1581. const char *sep;
  1582. *addr = addr_curr;
  1583. *name = NULL;
  1584. sep = strchr(spec, sepc);
  1585. if (sep) {
  1586. if (sep - spec > 0)
  1587. *addr = simple_strtoul(spec, NULL, 16);
  1588. *name = sep + 1;
  1589. return 1;
  1590. }
  1591. return 0;
  1592. }
  1593. /**
  1594. * fit_parse_conf - parse FIT configuration spec
  1595. * @spec: input string, containing configuration spec
  1596. * @add_curr: current image address (to be used as a possible default)
  1597. * @addr: pointer to a ulong variable, will hold FIT image address of a given
  1598. * configuration
  1599. * @conf_name double pointer to a char, will hold pointer to a configuration
  1600. * unit name
  1601. *
  1602. * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>,
  1603. * where <addr> is a FIT image address that contains configuration
  1604. * with a <conf> unit name.
  1605. *
  1606. * Address part is optional, and if omitted default add_curr will
  1607. * be used instead.
  1608. *
  1609. * returns:
  1610. * 1 if spec is a valid configuration string,
  1611. * addr and conf_name are set accordingly
  1612. * 0 otherwise
  1613. */
  1614. int fit_parse_conf(const char *spec, ulong addr_curr,
  1615. ulong *addr, const char **conf_name)
  1616. {
  1617. return fit_parse_spec(spec, '#', addr_curr, addr, conf_name);
  1618. }
  1619. /**
  1620. * fit_parse_subimage - parse FIT subimage spec
  1621. * @spec: input string, containing subimage spec
  1622. * @add_curr: current image address (to be used as a possible default)
  1623. * @addr: pointer to a ulong variable, will hold FIT image address of a given
  1624. * subimage
  1625. * @image_name: double pointer to a char, will hold pointer to a subimage name
  1626. *
  1627. * fit_parse_subimage() expects subimage spec in the for of
  1628. * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
  1629. * subimage with a <subimg> unit name.
  1630. *
  1631. * Address part is optional, and if omitted default add_curr will
  1632. * be used instead.
  1633. *
  1634. * returns:
  1635. * 1 if spec is a valid subimage string,
  1636. * addr and image_name are set accordingly
  1637. * 0 otherwise
  1638. */
  1639. int fit_parse_subimage(const char *spec, ulong addr_curr,
  1640. ulong *addr, const char **image_name)
  1641. {
  1642. return fit_parse_spec(spec, ':', addr_curr, addr, image_name);
  1643. }
  1644. #endif /* !USE_HOSTCC */
  1645. static void fit_get_debug(const void *fit, int noffset,
  1646. char *prop_name, int err)
  1647. {
  1648. debug("Can't get '%s' property from FIT 0x%08lx, "
  1649. "node: offset %d, name %s (%s)\n",
  1650. prop_name, (ulong)fit, noffset,
  1651. fit_get_name(fit, noffset, NULL),
  1652. fdt_strerror(err));
  1653. }
  1654. /**
  1655. * fit_print_contents - prints out the contents of the FIT format image
  1656. * @fit: pointer to the FIT format image header
  1657. * @p: pointer to prefix string
  1658. *
  1659. * fit_print_contents() formats a multi line FIT image contents description.
  1660. * The routine prints out FIT image properties (root node level) follwed by
  1661. * the details of each component image.
  1662. *
  1663. * returns:
  1664. * no returned results
  1665. */
  1666. void fit_print_contents(const void *fit)
  1667. {
  1668. char *desc;
  1669. char *uname;
  1670. int images_noffset;
  1671. int confs_noffset;
  1672. int noffset;
  1673. int ndepth;
  1674. int count = 0;
  1675. int ret;
  1676. const char *p;
  1677. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  1678. time_t timestamp;
  1679. #endif
  1680. #ifdef USE_HOSTCC
  1681. p = "";
  1682. #else
  1683. p = " ";
  1684. #endif
  1685. /* Root node properties */
  1686. ret = fit_get_desc(fit, 0, &desc);
  1687. printf("%sFIT description: ", p);
  1688. if (ret)
  1689. printf("unavailable\n");
  1690. else
  1691. printf("%s\n", desc);
  1692. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  1693. ret = fit_get_timestamp(fit, 0, &timestamp);
  1694. printf("%sCreated: ", p);
  1695. if (ret)
  1696. printf("unavailable\n");
  1697. else
  1698. genimg_print_time(timestamp);
  1699. #endif
  1700. /* Find images parent node offset */
  1701. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  1702. if (images_noffset < 0) {
  1703. printf("Can't find images parent node '%s' (%s)\n",
  1704. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  1705. return;
  1706. }
  1707. /* Process its subnodes, print out component images details */
  1708. for (ndepth = 0, count = 0,
  1709. noffset = fdt_next_node(fit, images_noffset, &ndepth);
  1710. (noffset >= 0) && (ndepth > 0);
  1711. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1712. if (ndepth == 1) {
  1713. /*
  1714. * Direct child node of the images parent node,
  1715. * i.e. component image node.
  1716. */
  1717. printf("%s Image %u (%s)\n", p, count++,
  1718. fit_get_name(fit, noffset, NULL));
  1719. fit_image_print(fit, noffset, p);
  1720. }
  1721. }
  1722. /* Find configurations parent node offset */
  1723. confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
  1724. if (confs_noffset < 0) {
  1725. debug("Can't get configurations parent node '%s' (%s)\n",
  1726. FIT_CONFS_PATH, fdt_strerror(confs_noffset));
  1727. return;
  1728. }
  1729. /* get default configuration unit name from default property */
  1730. uname = (char *)fdt_getprop(fit, noffset, FIT_DEFAULT_PROP, NULL);
  1731. if (uname)
  1732. printf("%s Default Configuration: '%s'\n", p, uname);
  1733. /* Process its subnodes, print out configurations details */
  1734. for (ndepth = 0, count = 0,
  1735. noffset = fdt_next_node(fit, confs_noffset, &ndepth);
  1736. (noffset >= 0) && (ndepth > 0);
  1737. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1738. if (ndepth == 1) {
  1739. /*
  1740. * Direct child node of the configurations parent node,
  1741. * i.e. configuration node.
  1742. */
  1743. printf("%s Configuration %u (%s)\n", p, count++,
  1744. fit_get_name(fit, noffset, NULL));
  1745. fit_conf_print(fit, noffset, p);
  1746. }
  1747. }
  1748. }
  1749. /**
  1750. * fit_image_print - prints out the FIT component image details
  1751. * @fit: pointer to the FIT format image header
  1752. * @image_noffset: offset of the component image node
  1753. * @p: pointer to prefix string
  1754. *
  1755. * fit_image_print() lists all mandatory properies for the processed component
  1756. * image. If present, hash nodes are printed out as well. Load
  1757. * address for images of type firmware is also printed out. Since the load
  1758. * address is not mandatory for firmware images, it will be output as
  1759. * "unavailable" when not present.
  1760. *
  1761. * returns:
  1762. * no returned results
  1763. */
  1764. void fit_image_print(const void *fit, int image_noffset, const char *p)
  1765. {
  1766. char *desc;
  1767. uint8_t type, arch, os, comp;
  1768. size_t size;
  1769. ulong load, entry;
  1770. const void *data;
  1771. int noffset;
  1772. int ndepth;
  1773. int ret;
  1774. /* Mandatory properties */
  1775. ret = fit_get_desc(fit, image_noffset, &desc);
  1776. printf("%s Description: ", p);
  1777. if (ret)
  1778. printf("unavailable\n");
  1779. else
  1780. printf("%s\n", desc);
  1781. fit_image_get_type(fit, image_noffset, &type);
  1782. printf("%s Type: %s\n", p, genimg_get_type_name(type));
  1783. fit_image_get_comp(fit, image_noffset, &comp);
  1784. printf("%s Compression: %s\n", p, genimg_get_comp_name(comp));
  1785. ret = fit_image_get_data(fit, image_noffset, &data, &size);
  1786. #ifndef USE_HOSTCC
  1787. printf("%s Data Start: ", p);
  1788. if (ret)
  1789. printf("unavailable\n");
  1790. else
  1791. printf("0x%08lx\n", (ulong)data);
  1792. #endif
  1793. printf("%s Data Size: ", p);
  1794. if (ret)
  1795. printf("unavailable\n");
  1796. else
  1797. genimg_print_size(size);
  1798. /* Remaining, type dependent properties */
  1799. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
  1800. (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) ||
  1801. (type == IH_TYPE_FLATDT)) {
  1802. fit_image_get_arch(fit, image_noffset, &arch);
  1803. printf("%s Architecture: %s\n", p, genimg_get_arch_name(arch));
  1804. }
  1805. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_RAMDISK)) {
  1806. fit_image_get_os(fit, image_noffset, &os);
  1807. printf("%s OS: %s\n", p, genimg_get_os_name(os));
  1808. }
  1809. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
  1810. (type == IH_TYPE_FIRMWARE) || (type == IH_TYPE_RAMDISK)) {
  1811. ret = fit_image_get_load(fit, image_noffset, &load);
  1812. printf("%s Load Address: ", p);
  1813. if (ret)
  1814. printf("unavailable\n");
  1815. else
  1816. printf("0x%08lx\n", load);
  1817. }
  1818. if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
  1819. (type == IH_TYPE_RAMDISK)) {
  1820. fit_image_get_entry(fit, image_noffset, &entry);
  1821. printf("%s Entry Point: ", p);
  1822. if (ret)
  1823. printf("unavailable\n");
  1824. else
  1825. printf("0x%08lx\n", entry);
  1826. }
  1827. /* Process all hash subnodes of the component image node */
  1828. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  1829. (noffset >= 0) && (ndepth > 0);
  1830. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  1831. if (ndepth == 1) {
  1832. /* Direct child node of the component image node */
  1833. fit_image_print_hash(fit, noffset, p);
  1834. }
  1835. }
  1836. }
  1837. /**
  1838. * fit_image_print_hash - prints out the hash node details
  1839. * @fit: pointer to the FIT format image header
  1840. * @noffset: offset of the hash node
  1841. * @p: pointer to prefix string
  1842. *
  1843. * fit_image_print_hash() lists properies for the processed hash node
  1844. *
  1845. * returns:
  1846. * no returned results
  1847. */
  1848. void fit_image_print_hash(const void *fit, int noffset, const char *p)
  1849. {
  1850. char *algo;
  1851. uint8_t *value;
  1852. int value_len;
  1853. int i, ret;
  1854. /*
  1855. * Check subnode name, must be equal to "hash".
  1856. * Multiple hash nodes require unique unit node
  1857. * names, e.g. hash@1, hash@2, etc.
  1858. */
  1859. if (strncmp(fit_get_name(fit, noffset, NULL),
  1860. FIT_HASH_NODENAME,
  1861. strlen(FIT_HASH_NODENAME)) != 0)
  1862. return;
  1863. debug("%s Hash node: '%s'\n", p,
  1864. fit_get_name(fit, noffset, NULL));
  1865. printf("%s Hash algo: ", p);
  1866. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  1867. printf("invalid/unsupported\n");
  1868. return;
  1869. }
  1870. printf("%s\n", algo);
  1871. ret = fit_image_hash_get_value(fit, noffset, &value,
  1872. &value_len);
  1873. printf("%s Hash value: ", p);
  1874. if (ret) {
  1875. printf("unavailable\n");
  1876. } else {
  1877. for (i = 0; i < value_len; i++)
  1878. printf("%02x", value[i]);
  1879. printf("\n");
  1880. }
  1881. debug("%s Hash len: %d\n", p, value_len);
  1882. }
  1883. /**
  1884. * fit_get_desc - get node description property
  1885. * @fit: pointer to the FIT format image header
  1886. * @noffset: node offset
  1887. * @desc: double pointer to the char, will hold pointer to the descrption
  1888. *
  1889. * fit_get_desc() reads description property from a given node, if
  1890. * description is found pointer to it is returened in third call argument.
  1891. *
  1892. * returns:
  1893. * 0, on success
  1894. * -1, on failure
  1895. */
  1896. int fit_get_desc(const void *fit, int noffset, char **desc)
  1897. {
  1898. int len;
  1899. *desc = (char *)fdt_getprop(fit, noffset, FIT_DESC_PROP, &len);
  1900. if (*desc == NULL) {
  1901. fit_get_debug(fit, noffset, FIT_DESC_PROP, len);
  1902. return -1;
  1903. }
  1904. return 0;
  1905. }
  1906. /**
  1907. * fit_get_timestamp - get node timestamp property
  1908. * @fit: pointer to the FIT format image header
  1909. * @noffset: node offset
  1910. * @timestamp: pointer to the time_t, will hold read timestamp
  1911. *
  1912. * fit_get_timestamp() reads timestamp poperty from given node, if timestamp
  1913. * is found and has a correct size its value is retured in third call
  1914. * argument.
  1915. *
  1916. * returns:
  1917. * 0, on success
  1918. * -1, on property read failure
  1919. * -2, on wrong timestamp size
  1920. */
  1921. int fit_get_timestamp(const void *fit, int noffset, time_t *timestamp)
  1922. {
  1923. int len;
  1924. const void *data;
  1925. data = fdt_getprop(fit, noffset, FIT_TIMESTAMP_PROP, &len);
  1926. if (data == NULL) {
  1927. fit_get_debug(fit, noffset, FIT_TIMESTAMP_PROP, len);
  1928. return -1;
  1929. }
  1930. if (len != sizeof(uint32_t)) {
  1931. debug("FIT timestamp with incorrect size of (%u)\n", len);
  1932. return -2;
  1933. }
  1934. *timestamp = uimage_to_cpu(*((uint32_t *)data));
  1935. return 0;
  1936. }
  1937. /**
  1938. * fit_image_get_node - get node offset for component image of a given unit name
  1939. * @fit: pointer to the FIT format image header
  1940. * @image_uname: component image node unit name
  1941. *
  1942. * fit_image_get_node() finds a component image (withing the '/images'
  1943. * node) of a provided unit name. If image is found its node offset is
  1944. * returned to the caller.
  1945. *
  1946. * returns:
  1947. * image node offset when found (>=0)
  1948. * negative number on failure (FDT_ERR_* code)
  1949. */
  1950. int fit_image_get_node(const void *fit, const char *image_uname)
  1951. {
  1952. int noffset, images_noffset;
  1953. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  1954. if (images_noffset < 0) {
  1955. debug("Can't find images parent node '%s' (%s)\n",
  1956. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  1957. return images_noffset;
  1958. }
  1959. noffset = fdt_subnode_offset(fit, images_noffset, image_uname);
  1960. if (noffset < 0) {
  1961. debug("Can't get node offset for image unit name: '%s' (%s)\n",
  1962. image_uname, fdt_strerror(noffset));
  1963. }
  1964. return noffset;
  1965. }
  1966. /**
  1967. * fit_image_get_os - get os id for a given component image node
  1968. * @fit: pointer to the FIT format image header
  1969. * @noffset: component image node offset
  1970. * @os: pointer to the uint8_t, will hold os numeric id
  1971. *
  1972. * fit_image_get_os() finds os property in a given component image node.
  1973. * If the property is found, its (string) value is translated to the numeric
  1974. * id which is returned to the caller.
  1975. *
  1976. * returns:
  1977. * 0, on success
  1978. * -1, on failure
  1979. */
  1980. int fit_image_get_os(const void *fit, int noffset, uint8_t *os)
  1981. {
  1982. int len;
  1983. const void *data;
  1984. /* Get OS name from property data */
  1985. data = fdt_getprop(fit, noffset, FIT_OS_PROP, &len);
  1986. if (data == NULL) {
  1987. fit_get_debug(fit, noffset, FIT_OS_PROP, len);
  1988. *os = -1;
  1989. return -1;
  1990. }
  1991. /* Translate OS name to id */
  1992. *os = genimg_get_os_id(data);
  1993. return 0;
  1994. }
  1995. /**
  1996. * fit_image_get_arch - get arch id for a given component image node
  1997. * @fit: pointer to the FIT format image header
  1998. * @noffset: component image node offset
  1999. * @arch: pointer to the uint8_t, will hold arch numeric id
  2000. *
  2001. * fit_image_get_arch() finds arch property in a given component image node.
  2002. * If the property is found, its (string) value is translated to the numeric
  2003. * id which is returned to the caller.
  2004. *
  2005. * returns:
  2006. * 0, on success
  2007. * -1, on failure
  2008. */
  2009. int fit_image_get_arch(const void *fit, int noffset, uint8_t *arch)
  2010. {
  2011. int len;
  2012. const void *data;
  2013. /* Get architecture name from property data */
  2014. data = fdt_getprop(fit, noffset, FIT_ARCH_PROP, &len);
  2015. if (data == NULL) {
  2016. fit_get_debug(fit, noffset, FIT_ARCH_PROP, len);
  2017. *arch = -1;
  2018. return -1;
  2019. }
  2020. /* Translate architecture name to id */
  2021. *arch = genimg_get_arch_id(data);
  2022. return 0;
  2023. }
  2024. /**
  2025. * fit_image_get_type - get type id for a given component image node
  2026. * @fit: pointer to the FIT format image header
  2027. * @noffset: component image node offset
  2028. * @type: pointer to the uint8_t, will hold type numeric id
  2029. *
  2030. * fit_image_get_type() finds type property in a given component image node.
  2031. * If the property is found, its (string) value is translated to the numeric
  2032. * id which is returned to the caller.
  2033. *
  2034. * returns:
  2035. * 0, on success
  2036. * -1, on failure
  2037. */
  2038. int fit_image_get_type(const void *fit, int noffset, uint8_t *type)
  2039. {
  2040. int len;
  2041. const void *data;
  2042. /* Get image type name from property data */
  2043. data = fdt_getprop(fit, noffset, FIT_TYPE_PROP, &len);
  2044. if (data == NULL) {
  2045. fit_get_debug(fit, noffset, FIT_TYPE_PROP, len);
  2046. *type = -1;
  2047. return -1;
  2048. }
  2049. /* Translate image type name to id */
  2050. *type = genimg_get_type_id(data);
  2051. return 0;
  2052. }
  2053. /**
  2054. * fit_image_get_comp - get comp id for a given component image node
  2055. * @fit: pointer to the FIT format image header
  2056. * @noffset: component image node offset
  2057. * @comp: pointer to the uint8_t, will hold comp numeric id
  2058. *
  2059. * fit_image_get_comp() finds comp property in a given component image node.
  2060. * If the property is found, its (string) value is translated to the numeric
  2061. * id which is returned to the caller.
  2062. *
  2063. * returns:
  2064. * 0, on success
  2065. * -1, on failure
  2066. */
  2067. int fit_image_get_comp(const void *fit, int noffset, uint8_t *comp)
  2068. {
  2069. int len;
  2070. const void *data;
  2071. /* Get compression name from property data */
  2072. data = fdt_getprop(fit, noffset, FIT_COMP_PROP, &len);
  2073. if (data == NULL) {
  2074. fit_get_debug(fit, noffset, FIT_COMP_PROP, len);
  2075. *comp = -1;
  2076. return -1;
  2077. }
  2078. /* Translate compression name to id */
  2079. *comp = genimg_get_comp_id(data);
  2080. return 0;
  2081. }
  2082. /**
  2083. * fit_image_get_load - get load address property for a given component image node
  2084. * @fit: pointer to the FIT format image header
  2085. * @noffset: component image node offset
  2086. * @load: pointer to the uint32_t, will hold load address
  2087. *
  2088. * fit_image_get_load() finds load address property in a given component image node.
  2089. * If the property is found, its value is returned to the caller.
  2090. *
  2091. * returns:
  2092. * 0, on success
  2093. * -1, on failure
  2094. */
  2095. int fit_image_get_load(const void *fit, int noffset, ulong *load)
  2096. {
  2097. int len;
  2098. const uint32_t *data;
  2099. data = fdt_getprop(fit, noffset, FIT_LOAD_PROP, &len);
  2100. if (data == NULL) {
  2101. fit_get_debug(fit, noffset, FIT_LOAD_PROP, len);
  2102. return -1;
  2103. }
  2104. *load = uimage_to_cpu(*data);
  2105. return 0;
  2106. }
  2107. /**
  2108. * fit_image_get_entry - get entry point address property for a given component image node
  2109. * @fit: pointer to the FIT format image header
  2110. * @noffset: component image node offset
  2111. * @entry: pointer to the uint32_t, will hold entry point address
  2112. *
  2113. * fit_image_get_entry() finds entry point address property in a given component image node.
  2114. * If the property is found, its value is returned to the caller.
  2115. *
  2116. * returns:
  2117. * 0, on success
  2118. * -1, on failure
  2119. */
  2120. int fit_image_get_entry(const void *fit, int noffset, ulong *entry)
  2121. {
  2122. int len;
  2123. const uint32_t *data;
  2124. data = fdt_getprop(fit, noffset, FIT_ENTRY_PROP, &len);
  2125. if (data == NULL) {
  2126. fit_get_debug(fit, noffset, FIT_ENTRY_PROP, len);
  2127. return -1;
  2128. }
  2129. *entry = uimage_to_cpu(*data);
  2130. return 0;
  2131. }
  2132. /**
  2133. * fit_image_get_data - get data property and its size for a given component image node
  2134. * @fit: pointer to the FIT format image header
  2135. * @noffset: component image node offset
  2136. * @data: double pointer to void, will hold data property's data address
  2137. * @size: pointer to size_t, will hold data property's data size
  2138. *
  2139. * fit_image_get_data() finds data property in a given component image node.
  2140. * If the property is found its data start address and size are returned to
  2141. * the caller.
  2142. *
  2143. * returns:
  2144. * 0, on success
  2145. * -1, on failure
  2146. */
  2147. int fit_image_get_data(const void *fit, int noffset,
  2148. const void **data, size_t *size)
  2149. {
  2150. int len;
  2151. *data = fdt_getprop(fit, noffset, FIT_DATA_PROP, &len);
  2152. if (*data == NULL) {
  2153. fit_get_debug(fit, noffset, FIT_DATA_PROP, len);
  2154. *size = 0;
  2155. return -1;
  2156. }
  2157. *size = len;
  2158. return 0;
  2159. }
  2160. /**
  2161. * fit_image_hash_get_algo - get hash algorithm name
  2162. * @fit: pointer to the FIT format image header
  2163. * @noffset: hash node offset
  2164. * @algo: double pointer to char, will hold pointer to the algorithm name
  2165. *
  2166. * fit_image_hash_get_algo() finds hash algorithm property in a given hash node.
  2167. * If the property is found its data start address is returned to the caller.
  2168. *
  2169. * returns:
  2170. * 0, on success
  2171. * -1, on failure
  2172. */
  2173. int fit_image_hash_get_algo(const void *fit, int noffset, char **algo)
  2174. {
  2175. int len;
  2176. *algo = (char *)fdt_getprop(fit, noffset, FIT_ALGO_PROP, &len);
  2177. if (*algo == NULL) {
  2178. fit_get_debug(fit, noffset, FIT_ALGO_PROP, len);
  2179. return -1;
  2180. }
  2181. return 0;
  2182. }
  2183. /**
  2184. * fit_image_hash_get_value - get hash value and length
  2185. * @fit: pointer to the FIT format image header
  2186. * @noffset: hash node offset
  2187. * @value: double pointer to uint8_t, will hold address of a hash value data
  2188. * @value_len: pointer to an int, will hold hash data length
  2189. *
  2190. * fit_image_hash_get_value() finds hash value property in a given hash node.
  2191. * If the property is found its data start address and size are returned to
  2192. * the caller.
  2193. *
  2194. * returns:
  2195. * 0, on success
  2196. * -1, on failure
  2197. */
  2198. int fit_image_hash_get_value(const void *fit, int noffset, uint8_t **value,
  2199. int *value_len)
  2200. {
  2201. int len;
  2202. *value = (uint8_t *)fdt_getprop(fit, noffset, FIT_VALUE_PROP, &len);
  2203. if (*value == NULL) {
  2204. fit_get_debug(fit, noffset, FIT_VALUE_PROP, len);
  2205. *value_len = 0;
  2206. return -1;
  2207. }
  2208. *value_len = len;
  2209. return 0;
  2210. }
  2211. /**
  2212. * fit_set_timestamp - set node timestamp property
  2213. * @fit: pointer to the FIT format image header
  2214. * @noffset: node offset
  2215. * @timestamp: timestamp value to be set
  2216. *
  2217. * fit_set_timestamp() attempts to set timestamp property in the requested
  2218. * node and returns operation status to the caller.
  2219. *
  2220. * returns:
  2221. * 0, on success
  2222. * -1, on property read failure
  2223. */
  2224. int fit_set_timestamp(void *fit, int noffset, time_t timestamp)
  2225. {
  2226. uint32_t t;
  2227. int ret;
  2228. t = cpu_to_uimage(timestamp);
  2229. ret = fdt_setprop(fit, noffset, FIT_TIMESTAMP_PROP, &t,
  2230. sizeof(uint32_t));
  2231. if (ret) {
  2232. printf("Can't set '%s' property for '%s' node (%s)\n",
  2233. FIT_TIMESTAMP_PROP, fit_get_name(fit, noffset, NULL),
  2234. fdt_strerror(ret));
  2235. return -1;
  2236. }
  2237. return 0;
  2238. }
  2239. /**
  2240. * calculate_hash - calculate and return hash for provided input data
  2241. * @data: pointer to the input data
  2242. * @data_len: data length
  2243. * @algo: requested hash algorithm
  2244. * @value: pointer to the char, will hold hash value data (caller must
  2245. * allocate enough free space)
  2246. * value_len: length of the calculated hash
  2247. *
  2248. * calculate_hash() computes input data hash according to the requested algorithm.
  2249. * Resulting hash value is placed in caller provided 'value' buffer, length
  2250. * of the calculated hash is returned via value_len pointer argument.
  2251. *
  2252. * returns:
  2253. * 0, on success
  2254. * -1, when algo is unsupported
  2255. */
  2256. static int calculate_hash(const void *data, int data_len, const char *algo,
  2257. uint8_t *value, int *value_len)
  2258. {
  2259. if (strcmp(algo, "crc32") == 0) {
  2260. *((uint32_t *)value) = crc32_wd(0, data, data_len,
  2261. CHUNKSZ_CRC32);
  2262. *((uint32_t *)value) = cpu_to_uimage(*((uint32_t *)value));
  2263. *value_len = 4;
  2264. } else if (strcmp(algo, "sha1") == 0) {
  2265. sha1_csum_wd((unsigned char *) data, data_len,
  2266. (unsigned char *) value, CHUNKSZ_SHA1);
  2267. *value_len = 20;
  2268. } else if (strcmp(algo, "md5") == 0) {
  2269. md5_wd((unsigned char *)data, data_len, value, CHUNKSZ_MD5);
  2270. *value_len = 16;
  2271. } else {
  2272. debug("Unsupported hash alogrithm\n");
  2273. return -1;
  2274. }
  2275. return 0;
  2276. }
  2277. #ifdef USE_HOSTCC
  2278. /**
  2279. * fit_set_hashes - process FIT component image nodes and calculate hashes
  2280. * @fit: pointer to the FIT format image header
  2281. *
  2282. * fit_set_hashes() adds hash values for all component images in the FIT blob.
  2283. * Hashes are calculated for all component images which have hash subnodes
  2284. * with algorithm property set to one of the supported hash algorithms.
  2285. *
  2286. * returns
  2287. * 0, on success
  2288. * libfdt error code, on failure
  2289. */
  2290. int fit_set_hashes(void *fit)
  2291. {
  2292. int images_noffset;
  2293. int noffset;
  2294. int ndepth;
  2295. int ret;
  2296. /* Find images parent node offset */
  2297. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  2298. if (images_noffset < 0) {
  2299. printf("Can't find images parent node '%s' (%s)\n",
  2300. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  2301. return images_noffset;
  2302. }
  2303. /* Process its subnodes, print out component images details */
  2304. for (ndepth = 0, noffset = fdt_next_node(fit, images_noffset, &ndepth);
  2305. (noffset >= 0) && (ndepth > 0);
  2306. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2307. if (ndepth == 1) {
  2308. /*
  2309. * Direct child node of the images parent node,
  2310. * i.e. component image node.
  2311. */
  2312. ret = fit_image_set_hashes(fit, noffset);
  2313. if (ret)
  2314. return ret;
  2315. }
  2316. }
  2317. return 0;
  2318. }
  2319. /**
  2320. * fit_image_set_hashes - calculate/set hashes for given component image node
  2321. * @fit: pointer to the FIT format image header
  2322. * @image_noffset: requested component image node
  2323. *
  2324. * fit_image_set_hashes() adds hash values for an component image node. All
  2325. * existing hash subnodes are checked, if algorithm property is set to one of
  2326. * the supported hash algorithms, hash value is computed and corresponding
  2327. * hash node property is set, for example:
  2328. *
  2329. * Input component image node structure:
  2330. *
  2331. * o image@1 (at image_noffset)
  2332. * | - data = [binary data]
  2333. * o hash@1
  2334. * |- algo = "sha1"
  2335. *
  2336. * Output component image node structure:
  2337. *
  2338. * o image@1 (at image_noffset)
  2339. * | - data = [binary data]
  2340. * o hash@1
  2341. * |- algo = "sha1"
  2342. * |- value = sha1(data)
  2343. *
  2344. * returns:
  2345. * 0 on sucess
  2346. * <0 on failure
  2347. */
  2348. int fit_image_set_hashes(void *fit, int image_noffset)
  2349. {
  2350. const void *data;
  2351. size_t size;
  2352. char *algo;
  2353. uint8_t value[FIT_MAX_HASH_LEN];
  2354. int value_len;
  2355. int noffset;
  2356. int ndepth;
  2357. /* Get image data and data length */
  2358. if (fit_image_get_data(fit, image_noffset, &data, &size)) {
  2359. printf("Can't get image data/size\n");
  2360. return -1;
  2361. }
  2362. /* Process all hash subnodes of the component image node */
  2363. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  2364. (noffset >= 0) && (ndepth > 0);
  2365. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2366. if (ndepth == 1) {
  2367. /* Direct child node of the component image node */
  2368. /*
  2369. * Check subnode name, must be equal to "hash".
  2370. * Multiple hash nodes require unique unit node
  2371. * names, e.g. hash@1, hash@2, etc.
  2372. */
  2373. if (strncmp(fit_get_name(fit, noffset, NULL),
  2374. FIT_HASH_NODENAME,
  2375. strlen(FIT_HASH_NODENAME)) != 0) {
  2376. /* Not a hash subnode, skip it */
  2377. continue;
  2378. }
  2379. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  2380. printf("Can't get hash algo property for "
  2381. "'%s' hash node in '%s' image node\n",
  2382. fit_get_name(fit, noffset, NULL),
  2383. fit_get_name(fit, image_noffset, NULL));
  2384. return -1;
  2385. }
  2386. if (calculate_hash(data, size, algo, value,
  2387. &value_len)) {
  2388. printf("Unsupported hash algorithm (%s) for "
  2389. "'%s' hash node in '%s' image node\n",
  2390. algo, fit_get_name(fit, noffset, NULL),
  2391. fit_get_name(fit, image_noffset,
  2392. NULL));
  2393. return -1;
  2394. }
  2395. if (fit_image_hash_set_value(fit, noffset, value,
  2396. value_len)) {
  2397. printf("Can't set hash value for "
  2398. "'%s' hash node in '%s' image node\n",
  2399. fit_get_name(fit, noffset, NULL),
  2400. fit_get_name(fit, image_noffset, NULL));
  2401. return -1;
  2402. }
  2403. }
  2404. }
  2405. return 0;
  2406. }
  2407. /**
  2408. * fit_image_hash_set_value - set hash value in requested has node
  2409. * @fit: pointer to the FIT format image header
  2410. * @noffset: hash node offset
  2411. * @value: hash value to be set
  2412. * @value_len: hash value length
  2413. *
  2414. * fit_image_hash_set_value() attempts to set hash value in a node at offset
  2415. * given and returns operation status to the caller.
  2416. *
  2417. * returns
  2418. * 0, on success
  2419. * -1, on failure
  2420. */
  2421. int fit_image_hash_set_value(void *fit, int noffset, uint8_t *value,
  2422. int value_len)
  2423. {
  2424. int ret;
  2425. ret = fdt_setprop(fit, noffset, FIT_VALUE_PROP, value, value_len);
  2426. if (ret) {
  2427. printf("Can't set hash '%s' property for '%s' node(%s)\n",
  2428. FIT_VALUE_PROP, fit_get_name(fit, noffset, NULL),
  2429. fdt_strerror(ret));
  2430. return -1;
  2431. }
  2432. return 0;
  2433. }
  2434. #endif /* USE_HOSTCC */
  2435. /**
  2436. * fit_image_check_hashes - verify data intergity
  2437. * @fit: pointer to the FIT format image header
  2438. * @image_noffset: component image node offset
  2439. *
  2440. * fit_image_check_hashes() goes over component image hash nodes,
  2441. * re-calculates each data hash and compares with the value stored in hash
  2442. * node.
  2443. *
  2444. * returns:
  2445. * 1, if all hashes are valid
  2446. * 0, otherwise (or on error)
  2447. */
  2448. int fit_image_check_hashes(const void *fit, int image_noffset)
  2449. {
  2450. const void *data;
  2451. size_t size;
  2452. char *algo;
  2453. uint8_t *fit_value;
  2454. int fit_value_len;
  2455. uint8_t value[FIT_MAX_HASH_LEN];
  2456. int value_len;
  2457. int noffset;
  2458. int ndepth;
  2459. char *err_msg = "";
  2460. /* Get image data and data length */
  2461. if (fit_image_get_data(fit, image_noffset, &data, &size)) {
  2462. printf("Can't get image data/size\n");
  2463. return 0;
  2464. }
  2465. /* Process all hash subnodes of the component image node */
  2466. for (ndepth = 0, noffset = fdt_next_node(fit, image_noffset, &ndepth);
  2467. (noffset >= 0) && (ndepth > 0);
  2468. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2469. if (ndepth == 1) {
  2470. /* Direct child node of the component image node */
  2471. /*
  2472. * Check subnode name, must be equal to "hash".
  2473. * Multiple hash nodes require unique unit node
  2474. * names, e.g. hash@1, hash@2, etc.
  2475. */
  2476. if (strncmp(fit_get_name(fit, noffset, NULL),
  2477. FIT_HASH_NODENAME,
  2478. strlen(FIT_HASH_NODENAME)) != 0)
  2479. continue;
  2480. if (fit_image_hash_get_algo(fit, noffset, &algo)) {
  2481. err_msg = " error!\nCan't get hash algo "
  2482. "property";
  2483. goto error;
  2484. }
  2485. printf("%s", algo);
  2486. if (fit_image_hash_get_value(fit, noffset, &fit_value,
  2487. &fit_value_len)) {
  2488. err_msg = " error!\nCan't get hash value "
  2489. "property";
  2490. goto error;
  2491. }
  2492. if (calculate_hash(data, size, algo, value,
  2493. &value_len)) {
  2494. err_msg = " error!\n"
  2495. "Unsupported hash algorithm";
  2496. goto error;
  2497. }
  2498. if (value_len != fit_value_len) {
  2499. err_msg = " error !\nBad hash value len";
  2500. goto error;
  2501. } else if (memcmp(value, fit_value, value_len) != 0) {
  2502. err_msg = " error!\nBad hash value";
  2503. goto error;
  2504. }
  2505. printf("+ ");
  2506. }
  2507. }
  2508. return 1;
  2509. error:
  2510. printf("%s for '%s' hash node in '%s' image node\n",
  2511. err_msg, fit_get_name(fit, noffset, NULL),
  2512. fit_get_name(fit, image_noffset, NULL));
  2513. return 0;
  2514. }
  2515. /**
  2516. * fit_all_image_check_hashes - verify data intergity for all images
  2517. * @fit: pointer to the FIT format image header
  2518. *
  2519. * fit_all_image_check_hashes() goes over all images in the FIT and
  2520. * for every images checks if all it's hashes are valid.
  2521. *
  2522. * returns:
  2523. * 1, if all hashes of all images are valid
  2524. * 0, otherwise (or on error)
  2525. */
  2526. int fit_all_image_check_hashes(const void *fit)
  2527. {
  2528. int images_noffset;
  2529. int noffset;
  2530. int ndepth;
  2531. int count;
  2532. /* Find images parent node offset */
  2533. images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
  2534. if (images_noffset < 0) {
  2535. printf("Can't find images parent node '%s' (%s)\n",
  2536. FIT_IMAGES_PATH, fdt_strerror(images_noffset));
  2537. return 0;
  2538. }
  2539. /* Process all image subnodes, check hashes for each */
  2540. printf("## Checking hash(es) for FIT Image at %08lx ...\n",
  2541. (ulong)fit);
  2542. for (ndepth = 0, count = 0,
  2543. noffset = fdt_next_node(fit, images_noffset, &ndepth);
  2544. (noffset >= 0) && (ndepth > 0);
  2545. noffset = fdt_next_node(fit, noffset, &ndepth)) {
  2546. if (ndepth == 1) {
  2547. /*
  2548. * Direct child node of the images parent node,
  2549. * i.e. component image node.
  2550. */
  2551. printf(" Hash(es) for Image %u (%s): ", count++,
  2552. fit_get_name(fit, noffset, NULL));
  2553. if (!fit_image_check_hashes(fit, noffset))
  2554. return 0;
  2555. printf("\n");
  2556. }
  2557. }
  2558. return 1;
  2559. }
  2560. /**
  2561. * fit_image_check_os - check whether image node is of a given os type
  2562. * @fit: pointer to the FIT format image header
  2563. * @noffset: component image node offset
  2564. * @os: requested image os
  2565. *
  2566. * fit_image_check_os() reads image os property and compares its numeric
  2567. * id with the requested os. Comparison result is returned to the caller.
  2568. *
  2569. * returns:
  2570. * 1 if image is of given os type
  2571. * 0 otherwise (or on error)
  2572. */
  2573. int fit_image_check_os(const void *fit, int noffset, uint8_t os)
  2574. {
  2575. uint8_t image_os;
  2576. if (fit_image_get_os(fit, noffset, &image_os))
  2577. return 0;
  2578. return (os == image_os);
  2579. }
  2580. /**
  2581. * fit_image_check_arch - check whether image node is of a given arch
  2582. * @fit: pointer to the FIT format image header
  2583. * @noffset: component image node offset
  2584. * @arch: requested imagearch
  2585. *
  2586. * fit_image_check_arch() reads image arch property and compares its numeric
  2587. * id with the requested arch. Comparison result is returned to the caller.
  2588. *
  2589. * returns:
  2590. * 1 if image is of given arch
  2591. * 0 otherwise (or on error)
  2592. */
  2593. int fit_image_check_arch(const void *fit, int noffset, uint8_t arch)
  2594. {
  2595. uint8_t image_arch;
  2596. if (fit_image_get_arch(fit, noffset, &image_arch))
  2597. return 0;
  2598. return (arch == image_arch);
  2599. }
  2600. /**
  2601. * fit_image_check_type - check whether image node is of a given type
  2602. * @fit: pointer to the FIT format image header
  2603. * @noffset: component image node offset
  2604. * @type: requested image type
  2605. *
  2606. * fit_image_check_type() reads image type property and compares its numeric
  2607. * id with the requested type. Comparison result is returned to the caller.
  2608. *
  2609. * returns:
  2610. * 1 if image is of given type
  2611. * 0 otherwise (or on error)
  2612. */
  2613. int fit_image_check_type(const void *fit, int noffset, uint8_t type)
  2614. {
  2615. uint8_t image_type;
  2616. if (fit_image_get_type(fit, noffset, &image_type))
  2617. return 0;
  2618. return (type == image_type);
  2619. }
  2620. /**
  2621. * fit_image_check_comp - check whether image node uses given compression
  2622. * @fit: pointer to the FIT format image header
  2623. * @noffset: component image node offset
  2624. * @comp: requested image compression type
  2625. *
  2626. * fit_image_check_comp() reads image compression property and compares its
  2627. * numeric id with the requested compression type. Comparison result is
  2628. * returned to the caller.
  2629. *
  2630. * returns:
  2631. * 1 if image uses requested compression
  2632. * 0 otherwise (or on error)
  2633. */
  2634. int fit_image_check_comp(const void *fit, int noffset, uint8_t comp)
  2635. {
  2636. uint8_t image_comp;
  2637. if (fit_image_get_comp(fit, noffset, &image_comp))
  2638. return 0;
  2639. return (comp == image_comp);
  2640. }
  2641. /**
  2642. * fit_check_format - sanity check FIT image format
  2643. * @fit: pointer to the FIT format image header
  2644. *
  2645. * fit_check_format() runs a basic sanity FIT image verification.
  2646. * Routine checks for mandatory properties, nodes, etc.
  2647. *
  2648. * returns:
  2649. * 1, on success
  2650. * 0, on failure
  2651. */
  2652. int fit_check_format(const void *fit)
  2653. {
  2654. /* mandatory / node 'description' property */
  2655. if (fdt_getprop(fit, 0, FIT_DESC_PROP, NULL) == NULL) {
  2656. debug("Wrong FIT format: no description\n");
  2657. return 0;
  2658. }
  2659. #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
  2660. /* mandatory / node 'timestamp' property */
  2661. if (fdt_getprop(fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
  2662. debug("Wrong FIT format: no timestamp\n");
  2663. return 0;
  2664. }
  2665. #endif
  2666. /* mandatory subimages parent '/images' node */
  2667. if (fdt_path_offset(fit, FIT_IMAGES_PATH) < 0) {
  2668. debug("Wrong FIT format: no images parent node\n");
  2669. return 0;
  2670. }
  2671. return 1;
  2672. }
  2673. /**
  2674. * fit_conf_get_node - get node offset for configuration of a given unit name
  2675. * @fit: pointer to the FIT format image header
  2676. * @conf_uname: configuration node unit name
  2677. *
  2678. * fit_conf_get_node() finds a configuration (withing the '/configurations'
  2679. * parant node) of a provided unit name. If configuration is found its node offset
  2680. * is returned to the caller.
  2681. *
  2682. * When NULL is provided in second argument fit_conf_get_node() will search
  2683. * for a default configuration node instead. Default configuration node unit name
  2684. * is retrived from FIT_DEFAULT_PROP property of the '/configurations' node.
  2685. *
  2686. * returns:
  2687. * configuration node offset when found (>=0)
  2688. * negative number on failure (FDT_ERR_* code)
  2689. */
  2690. int fit_conf_get_node(const void *fit, const char *conf_uname)
  2691. {
  2692. int noffset, confs_noffset;
  2693. int len;
  2694. confs_noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
  2695. if (confs_noffset < 0) {
  2696. debug("Can't find configurations parent node '%s' (%s)\n",
  2697. FIT_CONFS_PATH, fdt_strerror(confs_noffset));
  2698. return confs_noffset;
  2699. }
  2700. if (conf_uname == NULL) {
  2701. /* get configuration unit name from the default property */
  2702. debug("No configuration specified, trying default...\n");
  2703. conf_uname = (char *)fdt_getprop(fit, confs_noffset,
  2704. FIT_DEFAULT_PROP, &len);
  2705. if (conf_uname == NULL) {
  2706. fit_get_debug(fit, confs_noffset, FIT_DEFAULT_PROP,
  2707. len);
  2708. return len;
  2709. }
  2710. debug("Found default configuration: '%s'\n", conf_uname);
  2711. }
  2712. noffset = fdt_subnode_offset(fit, confs_noffset, conf_uname);
  2713. if (noffset < 0) {
  2714. debug("Can't get node offset for configuration unit name: "
  2715. "'%s' (%s)\n",
  2716. conf_uname, fdt_strerror(noffset));
  2717. }
  2718. return noffset;
  2719. }
  2720. static int __fit_conf_get_prop_node(const void *fit, int noffset,
  2721. const char *prop_name)
  2722. {
  2723. char *uname;
  2724. int len;
  2725. /* get kernel image unit name from configuration kernel property */
  2726. uname = (char *)fdt_getprop(fit, noffset, prop_name, &len);
  2727. if (uname == NULL)
  2728. return len;
  2729. return fit_image_get_node(fit, uname);
  2730. }
  2731. /**
  2732. * fit_conf_get_kernel_node - get kernel image node offset that corresponds to
  2733. * a given configuration
  2734. * @fit: pointer to the FIT format image header
  2735. * @noffset: configuration node offset
  2736. *
  2737. * fit_conf_get_kernel_node() retrives kernel image node unit name from
  2738. * configuration FIT_KERNEL_PROP property and translates it to the node
  2739. * offset.
  2740. *
  2741. * returns:
  2742. * image node offset when found (>=0)
  2743. * negative number on failure (FDT_ERR_* code)
  2744. */
  2745. int fit_conf_get_kernel_node(const void *fit, int noffset)
  2746. {
  2747. return __fit_conf_get_prop_node(fit, noffset, FIT_KERNEL_PROP);
  2748. }
  2749. /**
  2750. * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to
  2751. * a given configuration
  2752. * @fit: pointer to the FIT format image header
  2753. * @noffset: configuration node offset
  2754. *
  2755. * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from
  2756. * configuration FIT_KERNEL_PROP property and translates it to the node
  2757. * offset.
  2758. *
  2759. * returns:
  2760. * image node offset when found (>=0)
  2761. * negative number on failure (FDT_ERR_* code)
  2762. */
  2763. int fit_conf_get_ramdisk_node(const void *fit, int noffset)
  2764. {
  2765. return __fit_conf_get_prop_node(fit, noffset, FIT_RAMDISK_PROP);
  2766. }
  2767. /**
  2768. * fit_conf_get_fdt_node - get fdt image node offset that corresponds to
  2769. * a given configuration
  2770. * @fit: pointer to the FIT format image header
  2771. * @noffset: configuration node offset
  2772. *
  2773. * fit_conf_get_fdt_node() retrives fdt image node unit name from
  2774. * configuration FIT_KERNEL_PROP property and translates it to the node
  2775. * offset.
  2776. *
  2777. * returns:
  2778. * image node offset when found (>=0)
  2779. * negative number on failure (FDT_ERR_* code)
  2780. */
  2781. int fit_conf_get_fdt_node(const void *fit, int noffset)
  2782. {
  2783. return __fit_conf_get_prop_node(fit, noffset, FIT_FDT_PROP);
  2784. }
  2785. /**
  2786. * fit_conf_print - prints out the FIT configuration details
  2787. * @fit: pointer to the FIT format image header
  2788. * @noffset: offset of the configuration node
  2789. * @p: pointer to prefix string
  2790. *
  2791. * fit_conf_print() lists all mandatory properies for the processed
  2792. * configuration node.
  2793. *
  2794. * returns:
  2795. * no returned results
  2796. */
  2797. void fit_conf_print(const void *fit, int noffset, const char *p)
  2798. {
  2799. char *desc;
  2800. char *uname;
  2801. int ret;
  2802. /* Mandatory properties */
  2803. ret = fit_get_desc(fit, noffset, &desc);
  2804. printf("%s Description: ", p);
  2805. if (ret)
  2806. printf("unavailable\n");
  2807. else
  2808. printf("%s\n", desc);
  2809. uname = (char *)fdt_getprop(fit, noffset, FIT_KERNEL_PROP, NULL);
  2810. printf("%s Kernel: ", p);
  2811. if (uname == NULL)
  2812. printf("unavailable\n");
  2813. else
  2814. printf("%s\n", uname);
  2815. /* Optional properties */
  2816. uname = (char *)fdt_getprop(fit, noffset, FIT_RAMDISK_PROP, NULL);
  2817. if (uname)
  2818. printf("%s Init Ramdisk: %s\n", p, uname);
  2819. uname = (char *)fdt_getprop(fit, noffset, FIT_FDT_PROP, NULL);
  2820. if (uname)
  2821. printf("%s FDT: %s\n", p, uname);
  2822. }
  2823. /**
  2824. * fit_check_ramdisk - verify FIT format ramdisk subimage
  2825. * @fit_hdr: pointer to the FIT ramdisk header
  2826. * @rd_noffset: ramdisk subimage node offset within FIT image
  2827. * @arch: requested ramdisk image architecture type
  2828. * @verify: data CRC verification flag
  2829. *
  2830. * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from
  2831. * specified FIT image.
  2832. *
  2833. * returns:
  2834. * 1, on success
  2835. * 0, on failure
  2836. */
  2837. #ifndef USE_HOSTCC
  2838. static int fit_check_ramdisk(const void *fit, int rd_noffset, uint8_t arch,
  2839. int verify)
  2840. {
  2841. fit_image_print(fit, rd_noffset, " ");
  2842. if (verify) {
  2843. puts(" Verifying Hash Integrity ... ");
  2844. if (!fit_image_check_hashes(fit, rd_noffset)) {
  2845. puts("Bad Data Hash\n");
  2846. bootstage_error(BOOTSTAGE_ID_FIT_RD_HASH);
  2847. return 0;
  2848. }
  2849. puts("OK\n");
  2850. }
  2851. bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
  2852. if (!fit_image_check_os(fit, rd_noffset, IH_OS_LINUX) ||
  2853. !fit_image_check_arch(fit, rd_noffset, arch) ||
  2854. !fit_image_check_type(fit, rd_noffset, IH_TYPE_RAMDISK)) {
  2855. printf("No Linux %s Ramdisk Image\n",
  2856. genimg_get_arch_name(arch));
  2857. bootstage_error(BOOTSTAGE_ID_FIT_RD_CHECK_ALL);
  2858. return 0;
  2859. }
  2860. bootstage_mark(BOOTSTAGE_ID_FIT_RD_CHECK_ALL_OK);
  2861. return 1;
  2862. }
  2863. #endif /* USE_HOSTCC */
  2864. #endif /* CONFIG_FIT */