prom_init.c 81 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998
  1. /*
  2. * Procedures for interfacing to Open Firmware.
  3. *
  4. * Paul Mackerras August 1996.
  5. * Copyright (C) 1996-2005 Paul Mackerras.
  6. *
  7. * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
  8. * {engebret|bergner}@us.ibm.com
  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
  12. * as published by the Free Software Foundation; either version
  13. * 2 of the License, or (at your option) any later version.
  14. */
  15. #undef DEBUG_PROM
  16. #include <stdarg.h>
  17. #include <linux/kernel.h>
  18. #include <linux/string.h>
  19. #include <linux/init.h>
  20. #include <linux/threads.h>
  21. #include <linux/spinlock.h>
  22. #include <linux/types.h>
  23. #include <linux/pci.h>
  24. #include <linux/proc_fs.h>
  25. #include <linux/stringify.h>
  26. #include <linux/delay.h>
  27. #include <linux/initrd.h>
  28. #include <linux/bitops.h>
  29. #include <asm/prom.h>
  30. #include <asm/rtas.h>
  31. #include <asm/page.h>
  32. #include <asm/processor.h>
  33. #include <asm/irq.h>
  34. #include <asm/io.h>
  35. #include <asm/smp.h>
  36. #include <asm/system.h>
  37. #include <asm/mmu.h>
  38. #include <asm/pgtable.h>
  39. #include <asm/pci.h>
  40. #include <asm/iommu.h>
  41. #include <asm/btext.h>
  42. #include <asm/sections.h>
  43. #include <asm/machdep.h>
  44. #include <asm/opal.h>
  45. #include <linux/linux_logo.h>
  46. /*
  47. * Properties whose value is longer than this get excluded from our
  48. * copy of the device tree. This value does need to be big enough to
  49. * ensure that we don't lose things like the interrupt-map property
  50. * on a PCI-PCI bridge.
  51. */
  52. #define MAX_PROPERTY_LENGTH (1UL * 1024 * 1024)
  53. /*
  54. * Eventually bump that one up
  55. */
  56. #define DEVTREE_CHUNK_SIZE 0x100000
  57. /*
  58. * This is the size of the local memory reserve map that gets copied
  59. * into the boot params passed to the kernel. That size is totally
  60. * flexible as the kernel just reads the list until it encounters an
  61. * entry with size 0, so it can be changed without breaking binary
  62. * compatibility
  63. */
  64. #define MEM_RESERVE_MAP_SIZE 8
  65. /*
  66. * prom_init() is called very early on, before the kernel text
  67. * and data have been mapped to KERNELBASE. At this point the code
  68. * is running at whatever address it has been loaded at.
  69. * On ppc32 we compile with -mrelocatable, which means that references
  70. * to extern and static variables get relocated automatically.
  71. * On ppc64 we have to relocate the references explicitly with
  72. * RELOC. (Note that strings count as static variables.)
  73. *
  74. * Because OF may have mapped I/O devices into the area starting at
  75. * KERNELBASE, particularly on CHRP machines, we can't safely call
  76. * OF once the kernel has been mapped to KERNELBASE. Therefore all
  77. * OF calls must be done within prom_init().
  78. *
  79. * ADDR is used in calls to call_prom. The 4th and following
  80. * arguments to call_prom should be 32-bit values.
  81. * On ppc64, 64 bit values are truncated to 32 bits (and
  82. * fortunately don't get interpreted as two arguments).
  83. */
  84. #ifdef CONFIG_PPC64
  85. #define RELOC(x) (*PTRRELOC(&(x)))
  86. #define ADDR(x) (u32) add_reloc_offset((unsigned long)(x))
  87. #define OF_WORKAROUNDS 0
  88. #else
  89. #define RELOC(x) (x)
  90. #define ADDR(x) (u32) (x)
  91. #define OF_WORKAROUNDS of_workarounds
  92. int of_workarounds;
  93. #endif
  94. #define OF_WA_CLAIM 1 /* do phys/virt claim separately, then map */
  95. #define OF_WA_LONGTRAIL 2 /* work around longtrail bugs */
  96. #define PROM_BUG() do { \
  97. prom_printf("kernel BUG at %s line 0x%x!\n", \
  98. RELOC(__FILE__), __LINE__); \
  99. __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \
  100. } while (0)
  101. #ifdef DEBUG_PROM
  102. #define prom_debug(x...) prom_printf(x)
  103. #else
  104. #define prom_debug(x...)
  105. #endif
  106. typedef u32 prom_arg_t;
  107. struct prom_args {
  108. u32 service;
  109. u32 nargs;
  110. u32 nret;
  111. prom_arg_t args[10];
  112. };
  113. struct prom_t {
  114. ihandle root;
  115. phandle chosen;
  116. int cpu;
  117. ihandle stdout;
  118. ihandle mmumap;
  119. ihandle memory;
  120. };
  121. struct mem_map_entry {
  122. u64 base;
  123. u64 size;
  124. };
  125. typedef u32 cell_t;
  126. extern void __start(unsigned long r3, unsigned long r4, unsigned long r5,
  127. unsigned long r6, unsigned long r7, unsigned long r8,
  128. unsigned long r9);
  129. #ifdef CONFIG_PPC64
  130. extern int enter_prom(struct prom_args *args, unsigned long entry);
  131. #else
  132. static inline int enter_prom(struct prom_args *args, unsigned long entry)
  133. {
  134. return ((int (*)(struct prom_args *))entry)(args);
  135. }
  136. #endif
  137. extern void copy_and_flush(unsigned long dest, unsigned long src,
  138. unsigned long size, unsigned long offset);
  139. /* prom structure */
  140. static struct prom_t __initdata prom;
  141. static unsigned long prom_entry __initdata;
  142. #define PROM_SCRATCH_SIZE 256
  143. static char __initdata of_stdout_device[256];
  144. static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
  145. static unsigned long __initdata dt_header_start;
  146. static unsigned long __initdata dt_struct_start, dt_struct_end;
  147. static unsigned long __initdata dt_string_start, dt_string_end;
  148. static unsigned long __initdata prom_initrd_start, prom_initrd_end;
  149. #ifdef CONFIG_PPC64
  150. static int __initdata prom_iommu_force_on;
  151. static int __initdata prom_iommu_off;
  152. static unsigned long __initdata prom_tce_alloc_start;
  153. static unsigned long __initdata prom_tce_alloc_end;
  154. #endif
  155. /* Platforms codes are now obsolete in the kernel. Now only used within this
  156. * file and ultimately gone too. Feel free to change them if you need, they
  157. * are not shared with anything outside of this file anymore
  158. */
  159. #define PLATFORM_PSERIES 0x0100
  160. #define PLATFORM_PSERIES_LPAR 0x0101
  161. #define PLATFORM_LPAR 0x0001
  162. #define PLATFORM_POWERMAC 0x0400
  163. #define PLATFORM_GENERIC 0x0500
  164. #define PLATFORM_OPAL 0x0600
  165. static int __initdata of_platform;
  166. static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
  167. static unsigned long __initdata prom_memory_limit;
  168. static unsigned long __initdata alloc_top;
  169. static unsigned long __initdata alloc_top_high;
  170. static unsigned long __initdata alloc_bottom;
  171. static unsigned long __initdata rmo_top;
  172. static unsigned long __initdata ram_top;
  173. static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
  174. static int __initdata mem_reserve_cnt;
  175. static cell_t __initdata regbuf[1024];
  176. /*
  177. * Error results ... some OF calls will return "-1" on error, some
  178. * will return 0, some will return either. To simplify, here are
  179. * macros to use with any ihandle or phandle return value to check if
  180. * it is valid
  181. */
  182. #define PROM_ERROR (-1u)
  183. #define PHANDLE_VALID(p) ((p) != 0 && (p) != PROM_ERROR)
  184. #define IHANDLE_VALID(i) ((i) != 0 && (i) != PROM_ERROR)
  185. /* This is the one and *ONLY* place where we actually call open
  186. * firmware.
  187. */
  188. static int __init call_prom(const char *service, int nargs, int nret, ...)
  189. {
  190. int i;
  191. struct prom_args args;
  192. va_list list;
  193. args.service = ADDR(service);
  194. args.nargs = nargs;
  195. args.nret = nret;
  196. va_start(list, nret);
  197. for (i = 0; i < nargs; i++)
  198. args.args[i] = va_arg(list, prom_arg_t);
  199. va_end(list);
  200. for (i = 0; i < nret; i++)
  201. args.args[nargs+i] = 0;
  202. if (enter_prom(&args, RELOC(prom_entry)) < 0)
  203. return PROM_ERROR;
  204. return (nret > 0) ? args.args[nargs] : 0;
  205. }
  206. static int __init call_prom_ret(const char *service, int nargs, int nret,
  207. prom_arg_t *rets, ...)
  208. {
  209. int i;
  210. struct prom_args args;
  211. va_list list;
  212. args.service = ADDR(service);
  213. args.nargs = nargs;
  214. args.nret = nret;
  215. va_start(list, rets);
  216. for (i = 0; i < nargs; i++)
  217. args.args[i] = va_arg(list, prom_arg_t);
  218. va_end(list);
  219. for (i = 0; i < nret; i++)
  220. args.args[nargs+i] = 0;
  221. if (enter_prom(&args, RELOC(prom_entry)) < 0)
  222. return PROM_ERROR;
  223. if (rets != NULL)
  224. for (i = 1; i < nret; ++i)
  225. rets[i-1] = args.args[nargs+i];
  226. return (nret > 0) ? args.args[nargs] : 0;
  227. }
  228. static void __init prom_print(const char *msg)
  229. {
  230. const char *p, *q;
  231. struct prom_t *_prom = &RELOC(prom);
  232. if (_prom->stdout == 0)
  233. return;
  234. for (p = msg; *p != 0; p = q) {
  235. for (q = p; *q != 0 && *q != '\n'; ++q)
  236. ;
  237. if (q > p)
  238. call_prom("write", 3, 1, _prom->stdout, p, q - p);
  239. if (*q == 0)
  240. break;
  241. ++q;
  242. call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
  243. }
  244. }
  245. static void __init prom_print_hex(unsigned long val)
  246. {
  247. int i, nibbles = sizeof(val)*2;
  248. char buf[sizeof(val)*2+1];
  249. struct prom_t *_prom = &RELOC(prom);
  250. for (i = nibbles-1; i >= 0; i--) {
  251. buf[i] = (val & 0xf) + '0';
  252. if (buf[i] > '9')
  253. buf[i] += ('a'-'0'-10);
  254. val >>= 4;
  255. }
  256. buf[nibbles] = '\0';
  257. call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
  258. }
  259. /* max number of decimal digits in an unsigned long */
  260. #define UL_DIGITS 21
  261. static void __init prom_print_dec(unsigned long val)
  262. {
  263. int i, size;
  264. char buf[UL_DIGITS+1];
  265. struct prom_t *_prom = &RELOC(prom);
  266. for (i = UL_DIGITS-1; i >= 0; i--) {
  267. buf[i] = (val % 10) + '0';
  268. val = val/10;
  269. if (val == 0)
  270. break;
  271. }
  272. /* shift stuff down */
  273. size = UL_DIGITS - i;
  274. call_prom("write", 3, 1, _prom->stdout, buf+i, size);
  275. }
  276. static void __init prom_printf(const char *format, ...)
  277. {
  278. const char *p, *q, *s;
  279. va_list args;
  280. unsigned long v;
  281. long vs;
  282. struct prom_t *_prom = &RELOC(prom);
  283. va_start(args, format);
  284. #ifdef CONFIG_PPC64
  285. format = PTRRELOC(format);
  286. #endif
  287. for (p = format; *p != 0; p = q) {
  288. for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
  289. ;
  290. if (q > p)
  291. call_prom("write", 3, 1, _prom->stdout, p, q - p);
  292. if (*q == 0)
  293. break;
  294. if (*q == '\n') {
  295. ++q;
  296. call_prom("write", 3, 1, _prom->stdout,
  297. ADDR("\r\n"), 2);
  298. continue;
  299. }
  300. ++q;
  301. if (*q == 0)
  302. break;
  303. switch (*q) {
  304. case 's':
  305. ++q;
  306. s = va_arg(args, const char *);
  307. prom_print(s);
  308. break;
  309. case 'x':
  310. ++q;
  311. v = va_arg(args, unsigned long);
  312. prom_print_hex(v);
  313. break;
  314. case 'd':
  315. ++q;
  316. vs = va_arg(args, int);
  317. if (vs < 0) {
  318. prom_print(RELOC("-"));
  319. vs = -vs;
  320. }
  321. prom_print_dec(vs);
  322. break;
  323. case 'l':
  324. ++q;
  325. if (*q == 0)
  326. break;
  327. else if (*q == 'x') {
  328. ++q;
  329. v = va_arg(args, unsigned long);
  330. prom_print_hex(v);
  331. } else if (*q == 'u') { /* '%lu' */
  332. ++q;
  333. v = va_arg(args, unsigned long);
  334. prom_print_dec(v);
  335. } else if (*q == 'd') { /* %ld */
  336. ++q;
  337. vs = va_arg(args, long);
  338. if (vs < 0) {
  339. prom_print(RELOC("-"));
  340. vs = -vs;
  341. }
  342. prom_print_dec(vs);
  343. }
  344. break;
  345. }
  346. }
  347. }
  348. static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
  349. unsigned long align)
  350. {
  351. struct prom_t *_prom = &RELOC(prom);
  352. if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
  353. /*
  354. * Old OF requires we claim physical and virtual separately
  355. * and then map explicitly (assuming virtual mode)
  356. */
  357. int ret;
  358. prom_arg_t result;
  359. ret = call_prom_ret("call-method", 5, 2, &result,
  360. ADDR("claim"), _prom->memory,
  361. align, size, virt);
  362. if (ret != 0 || result == -1)
  363. return -1;
  364. ret = call_prom_ret("call-method", 5, 2, &result,
  365. ADDR("claim"), _prom->mmumap,
  366. align, size, virt);
  367. if (ret != 0) {
  368. call_prom("call-method", 4, 1, ADDR("release"),
  369. _prom->memory, size, virt);
  370. return -1;
  371. }
  372. /* the 0x12 is M (coherence) + PP == read/write */
  373. call_prom("call-method", 6, 1,
  374. ADDR("map"), _prom->mmumap, 0x12, size, virt, virt);
  375. return virt;
  376. }
  377. return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
  378. (prom_arg_t)align);
  379. }
  380. static void __init __attribute__((noreturn)) prom_panic(const char *reason)
  381. {
  382. #ifdef CONFIG_PPC64
  383. reason = PTRRELOC(reason);
  384. #endif
  385. prom_print(reason);
  386. /* Do not call exit because it clears the screen on pmac
  387. * it also causes some sort of double-fault on early pmacs */
  388. if (RELOC(of_platform) == PLATFORM_POWERMAC)
  389. asm("trap\n");
  390. /* ToDo: should put up an SRC here on p/iSeries */
  391. call_prom("exit", 0, 0);
  392. for (;;) /* should never get here */
  393. ;
  394. }
  395. static int __init prom_next_node(phandle *nodep)
  396. {
  397. phandle node;
  398. if ((node = *nodep) != 0
  399. && (*nodep = call_prom("child", 1, 1, node)) != 0)
  400. return 1;
  401. if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
  402. return 1;
  403. for (;;) {
  404. if ((node = call_prom("parent", 1, 1, node)) == 0)
  405. return 0;
  406. if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
  407. return 1;
  408. }
  409. }
  410. static int inline prom_getprop(phandle node, const char *pname,
  411. void *value, size_t valuelen)
  412. {
  413. return call_prom("getprop", 4, 1, node, ADDR(pname),
  414. (u32)(unsigned long) value, (u32) valuelen);
  415. }
  416. static int inline prom_getproplen(phandle node, const char *pname)
  417. {
  418. return call_prom("getproplen", 2, 1, node, ADDR(pname));
  419. }
  420. static void add_string(char **str, const char *q)
  421. {
  422. char *p = *str;
  423. while (*q)
  424. *p++ = *q++;
  425. *p++ = ' ';
  426. *str = p;
  427. }
  428. static char *tohex(unsigned int x)
  429. {
  430. static char digits[] = "0123456789abcdef";
  431. static char result[9];
  432. int i;
  433. result[8] = 0;
  434. i = 8;
  435. do {
  436. --i;
  437. result[i] = digits[x & 0xf];
  438. x >>= 4;
  439. } while (x != 0 && i > 0);
  440. return &result[i];
  441. }
  442. static int __init prom_setprop(phandle node, const char *nodename,
  443. const char *pname, void *value, size_t valuelen)
  444. {
  445. char cmd[256], *p;
  446. if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
  447. return call_prom("setprop", 4, 1, node, ADDR(pname),
  448. (u32)(unsigned long) value, (u32) valuelen);
  449. /* gah... setprop doesn't work on longtrail, have to use interpret */
  450. p = cmd;
  451. add_string(&p, "dev");
  452. add_string(&p, nodename);
  453. add_string(&p, tohex((u32)(unsigned long) value));
  454. add_string(&p, tohex(valuelen));
  455. add_string(&p, tohex(ADDR(pname)));
  456. add_string(&p, tohex(strlen(RELOC(pname))));
  457. add_string(&p, "property");
  458. *p = 0;
  459. return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
  460. }
  461. /* We can't use the standard versions because of RELOC headaches. */
  462. #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
  463. || ('a' <= (c) && (c) <= 'f') \
  464. || ('A' <= (c) && (c) <= 'F'))
  465. #define isdigit(c) ('0' <= (c) && (c) <= '9')
  466. #define islower(c) ('a' <= (c) && (c) <= 'z')
  467. #define toupper(c) (islower(c) ? ((c) - 'a' + 'A') : (c))
  468. unsigned long prom_strtoul(const char *cp, const char **endp)
  469. {
  470. unsigned long result = 0, base = 10, value;
  471. if (*cp == '0') {
  472. base = 8;
  473. cp++;
  474. if (toupper(*cp) == 'X') {
  475. cp++;
  476. base = 16;
  477. }
  478. }
  479. while (isxdigit(*cp) &&
  480. (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
  481. result = result * base + value;
  482. cp++;
  483. }
  484. if (endp)
  485. *endp = cp;
  486. return result;
  487. }
  488. unsigned long prom_memparse(const char *ptr, const char **retptr)
  489. {
  490. unsigned long ret = prom_strtoul(ptr, retptr);
  491. int shift = 0;
  492. /*
  493. * We can't use a switch here because GCC *may* generate a
  494. * jump table which won't work, because we're not running at
  495. * the address we're linked at.
  496. */
  497. if ('G' == **retptr || 'g' == **retptr)
  498. shift = 30;
  499. if ('M' == **retptr || 'm' == **retptr)
  500. shift = 20;
  501. if ('K' == **retptr || 'k' == **retptr)
  502. shift = 10;
  503. if (shift) {
  504. ret <<= shift;
  505. (*retptr)++;
  506. }
  507. return ret;
  508. }
  509. /*
  510. * Early parsing of the command line passed to the kernel, used for
  511. * "mem=x" and the options that affect the iommu
  512. */
  513. static void __init early_cmdline_parse(void)
  514. {
  515. struct prom_t *_prom = &RELOC(prom);
  516. const char *opt;
  517. char *p;
  518. int l = 0;
  519. RELOC(prom_cmd_line[0]) = 0;
  520. p = RELOC(prom_cmd_line);
  521. if ((long)_prom->chosen > 0)
  522. l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
  523. #ifdef CONFIG_CMDLINE
  524. if (l <= 0 || p[0] == '\0') /* dbl check */
  525. strlcpy(RELOC(prom_cmd_line),
  526. RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
  527. #endif /* CONFIG_CMDLINE */
  528. prom_printf("command line: %s\n", RELOC(prom_cmd_line));
  529. #ifdef CONFIG_PPC64
  530. opt = strstr(RELOC(prom_cmd_line), RELOC("iommu="));
  531. if (opt) {
  532. prom_printf("iommu opt is: %s\n", opt);
  533. opt += 6;
  534. while (*opt && *opt == ' ')
  535. opt++;
  536. if (!strncmp(opt, RELOC("off"), 3))
  537. RELOC(prom_iommu_off) = 1;
  538. else if (!strncmp(opt, RELOC("force"), 5))
  539. RELOC(prom_iommu_force_on) = 1;
  540. }
  541. #endif
  542. opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
  543. if (opt) {
  544. opt += 4;
  545. RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
  546. #ifdef CONFIG_PPC64
  547. /* Align to 16 MB == size of ppc64 large page */
  548. RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
  549. #endif
  550. }
  551. }
  552. #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
  553. /*
  554. * There are two methods for telling firmware what our capabilities are.
  555. * Newer machines have an "ibm,client-architecture-support" method on the
  556. * root node. For older machines, we have to call the "process-elf-header"
  557. * method in the /packages/elf-loader node, passing it a fake 32-bit
  558. * ELF header containing a couple of PT_NOTE sections that contain
  559. * structures that contain various information.
  560. */
  561. /*
  562. * New method - extensible architecture description vector.
  563. *
  564. * Because the description vector contains a mix of byte and word
  565. * values, we declare it as an unsigned char array, and use this
  566. * macro to put word values in.
  567. */
  568. #define W(x) ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \
  569. ((x) >> 8) & 0xff, (x) & 0xff
  570. /* Option vector bits - generic bits in byte 1 */
  571. #define OV_IGNORE 0x80 /* ignore this vector */
  572. #define OV_CESSATION_POLICY 0x40 /* halt if unsupported option present*/
  573. /* Option vector 1: processor architectures supported */
  574. #define OV1_PPC_2_00 0x80 /* set if we support PowerPC 2.00 */
  575. #define OV1_PPC_2_01 0x40 /* set if we support PowerPC 2.01 */
  576. #define OV1_PPC_2_02 0x20 /* set if we support PowerPC 2.02 */
  577. #define OV1_PPC_2_03 0x10 /* set if we support PowerPC 2.03 */
  578. #define OV1_PPC_2_04 0x08 /* set if we support PowerPC 2.04 */
  579. #define OV1_PPC_2_05 0x04 /* set if we support PowerPC 2.05 */
  580. #define OV1_PPC_2_06 0x02 /* set if we support PowerPC 2.06 */
  581. /* Option vector 2: Open Firmware options supported */
  582. #define OV2_REAL_MODE 0x20 /* set if we want OF in real mode */
  583. /* Option vector 3: processor options supported */
  584. #define OV3_FP 0x80 /* floating point */
  585. #define OV3_VMX 0x40 /* VMX/Altivec */
  586. #define OV3_DFP 0x20 /* decimal FP */
  587. /* Option vector 5: PAPR/OF options supported */
  588. #define OV5_LPAR 0x80 /* logical partitioning supported */
  589. #define OV5_SPLPAR 0x40 /* shared-processor LPAR supported */
  590. /* ibm,dynamic-reconfiguration-memory property supported */
  591. #define OV5_DRCONF_MEMORY 0x20
  592. #define OV5_LARGE_PAGES 0x10 /* large pages supported */
  593. #define OV5_DONATE_DEDICATE_CPU 0x02 /* donate dedicated CPU support */
  594. /* PCIe/MSI support. Without MSI full PCIe is not supported */
  595. #ifdef CONFIG_PCI_MSI
  596. #define OV5_MSI 0x01 /* PCIe/MSI support */
  597. #else
  598. #define OV5_MSI 0x00
  599. #endif /* CONFIG_PCI_MSI */
  600. #ifdef CONFIG_PPC_SMLPAR
  601. #define OV5_CMO 0x80 /* Cooperative Memory Overcommitment */
  602. #define OV5_XCMO 0x40 /* Page Coalescing */
  603. #else
  604. #define OV5_CMO 0x00
  605. #define OV5_XCMO 0x00
  606. #endif
  607. #define OV5_TYPE1_AFFINITY 0x80 /* Type 1 NUMA affinity */
  608. /* Option Vector 6: IBM PAPR hints */
  609. #define OV6_LINUX 0x02 /* Linux is our OS */
  610. /*
  611. * The architecture vector has an array of PVR mask/value pairs,
  612. * followed by # option vectors - 1, followed by the option vectors.
  613. */
  614. static unsigned char ibm_architecture_vec[] = {
  615. W(0xfffe0000), W(0x003a0000), /* POWER5/POWER5+ */
  616. W(0xffff0000), W(0x003e0000), /* POWER6 */
  617. W(0xffff0000), W(0x003f0000), /* POWER7 */
  618. W(0xffffffff), W(0x0f000003), /* all 2.06-compliant */
  619. W(0xffffffff), W(0x0f000002), /* all 2.05-compliant */
  620. W(0xfffffffe), W(0x0f000001), /* all 2.04-compliant and earlier */
  621. 6 - 1, /* 6 option vectors */
  622. /* option vector 1: processor architectures supported */
  623. 3 - 2, /* length */
  624. 0, /* don't ignore, don't halt */
  625. OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
  626. OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06,
  627. /* option vector 2: Open Firmware options supported */
  628. 34 - 2, /* length */
  629. OV2_REAL_MODE,
  630. 0, 0,
  631. W(0xffffffff), /* real_base */
  632. W(0xffffffff), /* real_size */
  633. W(0xffffffff), /* virt_base */
  634. W(0xffffffff), /* virt_size */
  635. W(0xffffffff), /* load_base */
  636. W(64), /* 64MB min RMA */
  637. W(0xffffffff), /* full client load */
  638. 0, /* min RMA percentage of total RAM */
  639. 48, /* max log_2(hash table size) */
  640. /* option vector 3: processor options supported */
  641. 3 - 2, /* length */
  642. 0, /* don't ignore, don't halt */
  643. OV3_FP | OV3_VMX | OV3_DFP,
  644. /* option vector 4: IBM PAPR implementation */
  645. 2 - 2, /* length */
  646. 0, /* don't halt */
  647. /* option vector 5: PAPR/OF options */
  648. 13 - 2, /* length */
  649. 0, /* don't ignore, don't halt */
  650. OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES | OV5_DRCONF_MEMORY |
  651. OV5_DONATE_DEDICATE_CPU | OV5_MSI,
  652. 0,
  653. OV5_CMO | OV5_XCMO,
  654. OV5_TYPE1_AFFINITY,
  655. 0,
  656. 0,
  657. 0,
  658. /* WARNING: The offset of the "number of cores" field below
  659. * must match by the macro below. Update the definition if
  660. * the structure layout changes.
  661. */
  662. #define IBM_ARCH_VEC_NRCORES_OFFSET 100
  663. W(NR_CPUS), /* number of cores supported */
  664. /* option vector 6: IBM PAPR hints */
  665. 4 - 2, /* length */
  666. 0,
  667. 0,
  668. OV6_LINUX,
  669. };
  670. /* Old method - ELF header with PT_NOTE sections */
  671. static struct fake_elf {
  672. Elf32_Ehdr elfhdr;
  673. Elf32_Phdr phdr[2];
  674. struct chrpnote {
  675. u32 namesz;
  676. u32 descsz;
  677. u32 type;
  678. char name[8]; /* "PowerPC" */
  679. struct chrpdesc {
  680. u32 real_mode;
  681. u32 real_base;
  682. u32 real_size;
  683. u32 virt_base;
  684. u32 virt_size;
  685. u32 load_base;
  686. } chrpdesc;
  687. } chrpnote;
  688. struct rpanote {
  689. u32 namesz;
  690. u32 descsz;
  691. u32 type;
  692. char name[24]; /* "IBM,RPA-Client-Config" */
  693. struct rpadesc {
  694. u32 lpar_affinity;
  695. u32 min_rmo_size;
  696. u32 min_rmo_percent;
  697. u32 max_pft_size;
  698. u32 splpar;
  699. u32 min_load;
  700. u32 new_mem_def;
  701. u32 ignore_me;
  702. } rpadesc;
  703. } rpanote;
  704. } fake_elf = {
  705. .elfhdr = {
  706. .e_ident = { 0x7f, 'E', 'L', 'F',
  707. ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
  708. .e_type = ET_EXEC, /* yeah right */
  709. .e_machine = EM_PPC,
  710. .e_version = EV_CURRENT,
  711. .e_phoff = offsetof(struct fake_elf, phdr),
  712. .e_phentsize = sizeof(Elf32_Phdr),
  713. .e_phnum = 2
  714. },
  715. .phdr = {
  716. [0] = {
  717. .p_type = PT_NOTE,
  718. .p_offset = offsetof(struct fake_elf, chrpnote),
  719. .p_filesz = sizeof(struct chrpnote)
  720. }, [1] = {
  721. .p_type = PT_NOTE,
  722. .p_offset = offsetof(struct fake_elf, rpanote),
  723. .p_filesz = sizeof(struct rpanote)
  724. }
  725. },
  726. .chrpnote = {
  727. .namesz = sizeof("PowerPC"),
  728. .descsz = sizeof(struct chrpdesc),
  729. .type = 0x1275,
  730. .name = "PowerPC",
  731. .chrpdesc = {
  732. .real_mode = ~0U, /* ~0 means "don't care" */
  733. .real_base = ~0U,
  734. .real_size = ~0U,
  735. .virt_base = ~0U,
  736. .virt_size = ~0U,
  737. .load_base = ~0U
  738. },
  739. },
  740. .rpanote = {
  741. .namesz = sizeof("IBM,RPA-Client-Config"),
  742. .descsz = sizeof(struct rpadesc),
  743. .type = 0x12759999,
  744. .name = "IBM,RPA-Client-Config",
  745. .rpadesc = {
  746. .lpar_affinity = 0,
  747. .min_rmo_size = 64, /* in megabytes */
  748. .min_rmo_percent = 0,
  749. .max_pft_size = 48, /* 2^48 bytes max PFT size */
  750. .splpar = 1,
  751. .min_load = ~0U,
  752. .new_mem_def = 0
  753. }
  754. }
  755. };
  756. static int __init prom_count_smt_threads(void)
  757. {
  758. phandle node;
  759. char type[64];
  760. unsigned int plen;
  761. /* Pick up th first CPU node we can find */
  762. for (node = 0; prom_next_node(&node); ) {
  763. type[0] = 0;
  764. prom_getprop(node, "device_type", type, sizeof(type));
  765. if (strcmp(type, RELOC("cpu")))
  766. continue;
  767. /*
  768. * There is an entry for each smt thread, each entry being
  769. * 4 bytes long. All cpus should have the same number of
  770. * smt threads, so return after finding the first.
  771. */
  772. plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s");
  773. if (plen == PROM_ERROR)
  774. break;
  775. plen >>= 2;
  776. prom_debug("Found %lu smt threads per core\n", (unsigned long)plen);
  777. /* Sanity check */
  778. if (plen < 1 || plen > 64) {
  779. prom_printf("Threads per core %lu out of bounds, assuming 1\n",
  780. (unsigned long)plen);
  781. return 1;
  782. }
  783. return plen;
  784. }
  785. prom_debug("No threads found, assuming 1 per core\n");
  786. return 1;
  787. }
  788. static void __init prom_send_capabilities(void)
  789. {
  790. ihandle elfloader, root;
  791. prom_arg_t ret;
  792. u32 *cores;
  793. root = call_prom("open", 1, 1, ADDR("/"));
  794. if (root != 0) {
  795. /* We need to tell the FW about the number of cores we support.
  796. *
  797. * To do that, we count the number of threads on the first core
  798. * (we assume this is the same for all cores) and use it to
  799. * divide NR_CPUS.
  800. */
  801. cores = (u32 *)PTRRELOC(&ibm_architecture_vec[IBM_ARCH_VEC_NRCORES_OFFSET]);
  802. if (*cores != NR_CPUS) {
  803. prom_printf("WARNING ! "
  804. "ibm_architecture_vec structure inconsistent: %lu!\n",
  805. *cores);
  806. } else {
  807. *cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
  808. prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n",
  809. *cores, NR_CPUS);
  810. }
  811. /* try calling the ibm,client-architecture-support method */
  812. prom_printf("Calling ibm,client-architecture-support...");
  813. if (call_prom_ret("call-method", 3, 2, &ret,
  814. ADDR("ibm,client-architecture-support"),
  815. root,
  816. ADDR(ibm_architecture_vec)) == 0) {
  817. /* the call exists... */
  818. if (ret)
  819. prom_printf("\nWARNING: ibm,client-architecture"
  820. "-support call FAILED!\n");
  821. call_prom("close", 1, 0, root);
  822. prom_printf(" done\n");
  823. return;
  824. }
  825. call_prom("close", 1, 0, root);
  826. prom_printf(" not implemented\n");
  827. }
  828. /* no ibm,client-architecture-support call, try the old way */
  829. elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader"));
  830. if (elfloader == 0) {
  831. prom_printf("couldn't open /packages/elf-loader\n");
  832. return;
  833. }
  834. call_prom("call-method", 3, 1, ADDR("process-elf-header"),
  835. elfloader, ADDR(&fake_elf));
  836. call_prom("close", 1, 0, elfloader);
  837. }
  838. #endif
  839. /*
  840. * Memory allocation strategy... our layout is normally:
  841. *
  842. * at 14Mb or more we have vmlinux, then a gap and initrd. In some
  843. * rare cases, initrd might end up being before the kernel though.
  844. * We assume this won't override the final kernel at 0, we have no
  845. * provision to handle that in this version, but it should hopefully
  846. * never happen.
  847. *
  848. * alloc_top is set to the top of RMO, eventually shrink down if the
  849. * TCEs overlap
  850. *
  851. * alloc_bottom is set to the top of kernel/initrd
  852. *
  853. * from there, allocations are done this way : rtas is allocated
  854. * topmost, and the device-tree is allocated from the bottom. We try
  855. * to grow the device-tree allocation as we progress. If we can't,
  856. * then we fail, we don't currently have a facility to restart
  857. * elsewhere, but that shouldn't be necessary.
  858. *
  859. * Note that calls to reserve_mem have to be done explicitly, memory
  860. * allocated with either alloc_up or alloc_down isn't automatically
  861. * reserved.
  862. */
  863. /*
  864. * Allocates memory in the RMO upward from the kernel/initrd
  865. *
  866. * When align is 0, this is a special case, it means to allocate in place
  867. * at the current location of alloc_bottom or fail (that is basically
  868. * extending the previous allocation). Used for the device-tree flattening
  869. */
  870. static unsigned long __init alloc_up(unsigned long size, unsigned long align)
  871. {
  872. unsigned long base = RELOC(alloc_bottom);
  873. unsigned long addr = 0;
  874. if (align)
  875. base = _ALIGN_UP(base, align);
  876. prom_debug("alloc_up(%x, %x)\n", size, align);
  877. if (RELOC(ram_top) == 0)
  878. prom_panic("alloc_up() called with mem not initialized\n");
  879. if (align)
  880. base = _ALIGN_UP(RELOC(alloc_bottom), align);
  881. else
  882. base = RELOC(alloc_bottom);
  883. for(; (base + size) <= RELOC(alloc_top);
  884. base = _ALIGN_UP(base + 0x100000, align)) {
  885. prom_debug(" trying: 0x%x\n\r", base);
  886. addr = (unsigned long)prom_claim(base, size, 0);
  887. if (addr != PROM_ERROR && addr != 0)
  888. break;
  889. addr = 0;
  890. if (align == 0)
  891. break;
  892. }
  893. if (addr == 0)
  894. return 0;
  895. RELOC(alloc_bottom) = addr + size;
  896. prom_debug(" -> %x\n", addr);
  897. prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom));
  898. prom_debug(" alloc_top : %x\n", RELOC(alloc_top));
  899. prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
  900. prom_debug(" rmo_top : %x\n", RELOC(rmo_top));
  901. prom_debug(" ram_top : %x\n", RELOC(ram_top));
  902. return addr;
  903. }
  904. /*
  905. * Allocates memory downward, either from top of RMO, or if highmem
  906. * is set, from the top of RAM. Note that this one doesn't handle
  907. * failures. It does claim memory if highmem is not set.
  908. */
  909. static unsigned long __init alloc_down(unsigned long size, unsigned long align,
  910. int highmem)
  911. {
  912. unsigned long base, addr = 0;
  913. prom_debug("alloc_down(%x, %x, %s)\n", size, align,
  914. highmem ? RELOC("(high)") : RELOC("(low)"));
  915. if (RELOC(ram_top) == 0)
  916. prom_panic("alloc_down() called with mem not initialized\n");
  917. if (highmem) {
  918. /* Carve out storage for the TCE table. */
  919. addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
  920. if (addr <= RELOC(alloc_bottom))
  921. return 0;
  922. /* Will we bump into the RMO ? If yes, check out that we
  923. * didn't overlap existing allocations there, if we did,
  924. * we are dead, we must be the first in town !
  925. */
  926. if (addr < RELOC(rmo_top)) {
  927. /* Good, we are first */
  928. if (RELOC(alloc_top) == RELOC(rmo_top))
  929. RELOC(alloc_top) = RELOC(rmo_top) = addr;
  930. else
  931. return 0;
  932. }
  933. RELOC(alloc_top_high) = addr;
  934. goto bail;
  935. }
  936. base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
  937. for (; base > RELOC(alloc_bottom);
  938. base = _ALIGN_DOWN(base - 0x100000, align)) {
  939. prom_debug(" trying: 0x%x\n\r", base);
  940. addr = (unsigned long)prom_claim(base, size, 0);
  941. if (addr != PROM_ERROR && addr != 0)
  942. break;
  943. addr = 0;
  944. }
  945. if (addr == 0)
  946. return 0;
  947. RELOC(alloc_top) = addr;
  948. bail:
  949. prom_debug(" -> %x\n", addr);
  950. prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom));
  951. prom_debug(" alloc_top : %x\n", RELOC(alloc_top));
  952. prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
  953. prom_debug(" rmo_top : %x\n", RELOC(rmo_top));
  954. prom_debug(" ram_top : %x\n", RELOC(ram_top));
  955. return addr;
  956. }
  957. /*
  958. * Parse a "reg" cell
  959. */
  960. static unsigned long __init prom_next_cell(int s, cell_t **cellp)
  961. {
  962. cell_t *p = *cellp;
  963. unsigned long r = 0;
  964. /* Ignore more than 2 cells */
  965. while (s > sizeof(unsigned long) / 4) {
  966. p++;
  967. s--;
  968. }
  969. r = *p++;
  970. #ifdef CONFIG_PPC64
  971. if (s > 1) {
  972. r <<= 32;
  973. r |= *(p++);
  974. }
  975. #endif
  976. *cellp = p;
  977. return r;
  978. }
  979. /*
  980. * Very dumb function for adding to the memory reserve list, but
  981. * we don't need anything smarter at this point
  982. *
  983. * XXX Eventually check for collisions. They should NEVER happen.
  984. * If problems seem to show up, it would be a good start to track
  985. * them down.
  986. */
  987. static void __init reserve_mem(u64 base, u64 size)
  988. {
  989. u64 top = base + size;
  990. unsigned long cnt = RELOC(mem_reserve_cnt);
  991. if (size == 0)
  992. return;
  993. /* We need to always keep one empty entry so that we
  994. * have our terminator with "size" set to 0 since we are
  995. * dumb and just copy this entire array to the boot params
  996. */
  997. base = _ALIGN_DOWN(base, PAGE_SIZE);
  998. top = _ALIGN_UP(top, PAGE_SIZE);
  999. size = top - base;
  1000. if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
  1001. prom_panic("Memory reserve map exhausted !\n");
  1002. RELOC(mem_reserve_map)[cnt].base = base;
  1003. RELOC(mem_reserve_map)[cnt].size = size;
  1004. RELOC(mem_reserve_cnt) = cnt + 1;
  1005. }
  1006. /*
  1007. * Initialize memory allocation mechanism, parse "memory" nodes and
  1008. * obtain that way the top of memory and RMO to setup out local allocator
  1009. */
  1010. static void __init prom_init_mem(void)
  1011. {
  1012. phandle node;
  1013. char *path, type[64];
  1014. unsigned int plen;
  1015. cell_t *p, *endp;
  1016. struct prom_t *_prom = &RELOC(prom);
  1017. u32 rac, rsc;
  1018. /*
  1019. * We iterate the memory nodes to find
  1020. * 1) top of RMO (first node)
  1021. * 2) top of memory
  1022. */
  1023. rac = 2;
  1024. prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac));
  1025. rsc = 1;
  1026. prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc));
  1027. prom_debug("root_addr_cells: %x\n", (unsigned long) rac);
  1028. prom_debug("root_size_cells: %x\n", (unsigned long) rsc);
  1029. prom_debug("scanning memory:\n");
  1030. path = RELOC(prom_scratch);
  1031. for (node = 0; prom_next_node(&node); ) {
  1032. type[0] = 0;
  1033. prom_getprop(node, "device_type", type, sizeof(type));
  1034. if (type[0] == 0) {
  1035. /*
  1036. * CHRP Longtrail machines have no device_type
  1037. * on the memory node, so check the name instead...
  1038. */
  1039. prom_getprop(node, "name", type, sizeof(type));
  1040. }
  1041. if (strcmp(type, RELOC("memory")))
  1042. continue;
  1043. plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
  1044. if (plen > sizeof(regbuf)) {
  1045. prom_printf("memory node too large for buffer !\n");
  1046. plen = sizeof(regbuf);
  1047. }
  1048. p = RELOC(regbuf);
  1049. endp = p + (plen / sizeof(cell_t));
  1050. #ifdef DEBUG_PROM
  1051. memset(path, 0, PROM_SCRATCH_SIZE);
  1052. call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
  1053. prom_debug(" node %s :\n", path);
  1054. #endif /* DEBUG_PROM */
  1055. while ((endp - p) >= (rac + rsc)) {
  1056. unsigned long base, size;
  1057. base = prom_next_cell(rac, &p);
  1058. size = prom_next_cell(rsc, &p);
  1059. if (size == 0)
  1060. continue;
  1061. prom_debug(" %x %x\n", base, size);
  1062. if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR))
  1063. RELOC(rmo_top) = size;
  1064. if ((base + size) > RELOC(ram_top))
  1065. RELOC(ram_top) = base + size;
  1066. }
  1067. }
  1068. RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000);
  1069. /* Check if we have an initrd after the kernel, if we do move our bottom
  1070. * point to after it
  1071. */
  1072. if (RELOC(prom_initrd_start)) {
  1073. if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
  1074. RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
  1075. }
  1076. /*
  1077. * If prom_memory_limit is set we reduce the upper limits *except* for
  1078. * alloc_top_high. This must be the real top of RAM so we can put
  1079. * TCE's up there.
  1080. */
  1081. RELOC(alloc_top_high) = RELOC(ram_top);
  1082. if (RELOC(prom_memory_limit)) {
  1083. if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
  1084. prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
  1085. RELOC(prom_memory_limit));
  1086. RELOC(prom_memory_limit) = 0;
  1087. } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
  1088. prom_printf("Ignoring mem=%x >= ram_top.\n",
  1089. RELOC(prom_memory_limit));
  1090. RELOC(prom_memory_limit) = 0;
  1091. } else {
  1092. RELOC(ram_top) = RELOC(prom_memory_limit);
  1093. RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
  1094. }
  1095. }
  1096. /*
  1097. * Setup our top alloc point, that is top of RMO or top of
  1098. * segment 0 when running non-LPAR.
  1099. * Some RS64 machines have buggy firmware where claims up at
  1100. * 1GB fail. Cap at 768MB as a workaround.
  1101. * Since 768MB is plenty of room, and we need to cap to something
  1102. * reasonable on 32-bit, cap at 768MB on all machines.
  1103. */
  1104. if (!RELOC(rmo_top))
  1105. RELOC(rmo_top) = RELOC(ram_top);
  1106. RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
  1107. RELOC(alloc_top) = RELOC(rmo_top);
  1108. RELOC(alloc_top_high) = RELOC(ram_top);
  1109. prom_printf("memory layout at init:\n");
  1110. prom_printf(" memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
  1111. prom_printf(" alloc_bottom : %x\n", RELOC(alloc_bottom));
  1112. prom_printf(" alloc_top : %x\n", RELOC(alloc_top));
  1113. prom_printf(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
  1114. prom_printf(" rmo_top : %x\n", RELOC(rmo_top));
  1115. prom_printf(" ram_top : %x\n", RELOC(ram_top));
  1116. }
  1117. static void __init prom_close_stdin(void)
  1118. {
  1119. struct prom_t *_prom = &RELOC(prom);
  1120. ihandle val;
  1121. if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
  1122. call_prom("close", 1, 0, val);
  1123. }
  1124. #ifdef CONFIG_PPC_POWERNV
  1125. static u64 __initdata prom_opal_size;
  1126. static u64 __initdata prom_opal_align;
  1127. static int __initdata prom_rtas_start_cpu;
  1128. static u64 __initdata prom_rtas_data;
  1129. static u64 __initdata prom_rtas_entry;
  1130. #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
  1131. static u64 __initdata prom_opal_base;
  1132. static u64 __initdata prom_opal_entry;
  1133. #endif
  1134. /* XXX Don't change this structure without updating opal-takeover.S */
  1135. static struct opal_secondary_data {
  1136. s64 ack; /* 0 */
  1137. u64 go; /* 8 */
  1138. struct opal_takeover_args args; /* 16 */
  1139. } opal_secondary_data;
  1140. extern char opal_secondary_entry;
  1141. static void prom_query_opal(void)
  1142. {
  1143. long rc;
  1144. prom_printf("Querying for OPAL presence... ");
  1145. rc = opal_query_takeover(&RELOC(prom_opal_size),
  1146. &RELOC(prom_opal_align));
  1147. prom_debug("(rc = %ld) ", rc);
  1148. if (rc != 0) {
  1149. prom_printf("not there.\n");
  1150. return;
  1151. }
  1152. RELOC(of_platform) = PLATFORM_OPAL;
  1153. prom_printf(" there !\n");
  1154. prom_debug(" opal_size = 0x%lx\n", RELOC(prom_opal_size));
  1155. prom_debug(" opal_align = 0x%lx\n", RELOC(prom_opal_align));
  1156. if (RELOC(prom_opal_align) < 0x10000)
  1157. RELOC(prom_opal_align) = 0x10000;
  1158. }
  1159. static int prom_rtas_call(int token, int nargs, int nret, int *outputs, ...)
  1160. {
  1161. struct rtas_args rtas_args;
  1162. va_list list;
  1163. int i;
  1164. rtas_args.token = token;
  1165. rtas_args.nargs = nargs;
  1166. rtas_args.nret = nret;
  1167. rtas_args.rets = (rtas_arg_t *)&(rtas_args.args[nargs]);
  1168. va_start(list, outputs);
  1169. for (i = 0; i < nargs; ++i)
  1170. rtas_args.args[i] = va_arg(list, rtas_arg_t);
  1171. va_end(list);
  1172. for (i = 0; i < nret; ++i)
  1173. rtas_args.rets[i] = 0;
  1174. opal_enter_rtas(&rtas_args, RELOC(prom_rtas_data),
  1175. RELOC(prom_rtas_entry));
  1176. if (nret > 1 && outputs != NULL)
  1177. for (i = 0; i < nret-1; ++i)
  1178. outputs[i] = rtas_args.rets[i+1];
  1179. return (nret > 0)? rtas_args.rets[0]: 0;
  1180. }
  1181. static void __init prom_opal_hold_cpus(void)
  1182. {
  1183. int i, cnt, cpu, rc;
  1184. long j;
  1185. phandle node;
  1186. char type[64];
  1187. u32 servers[8];
  1188. struct prom_t *_prom = &RELOC(prom);
  1189. void *entry = (unsigned long *)&RELOC(opal_secondary_entry);
  1190. struct opal_secondary_data *data = &RELOC(opal_secondary_data);
  1191. prom_debug("prom_opal_hold_cpus: start...\n");
  1192. prom_debug(" - entry = 0x%x\n", entry);
  1193. prom_debug(" - data = 0x%x\n", data);
  1194. data->ack = -1;
  1195. data->go = 0;
  1196. /* look for cpus */
  1197. for (node = 0; prom_next_node(&node); ) {
  1198. type[0] = 0;
  1199. prom_getprop(node, "device_type", type, sizeof(type));
  1200. if (strcmp(type, RELOC("cpu")) != 0)
  1201. continue;
  1202. /* Skip non-configured cpus. */
  1203. if (prom_getprop(node, "status", type, sizeof(type)) > 0)
  1204. if (strcmp(type, RELOC("okay")) != 0)
  1205. continue;
  1206. cnt = prom_getprop(node, "ibm,ppc-interrupt-server#s", servers,
  1207. sizeof(servers));
  1208. if (cnt == PROM_ERROR)
  1209. break;
  1210. cnt >>= 2;
  1211. for (i = 0; i < cnt; i++) {
  1212. cpu = servers[i];
  1213. prom_debug("CPU %d ... ", cpu);
  1214. if (cpu == _prom->cpu) {
  1215. prom_debug("booted !\n");
  1216. continue;
  1217. }
  1218. prom_debug("starting ... ");
  1219. /* Init the acknowledge var which will be reset by
  1220. * the secondary cpu when it awakens from its OF
  1221. * spinloop.
  1222. */
  1223. data->ack = -1;
  1224. rc = prom_rtas_call(RELOC(prom_rtas_start_cpu), 3, 1,
  1225. NULL, cpu, entry, data);
  1226. prom_debug("rtas rc=%d ...", rc);
  1227. for (j = 0; j < 100000000 && data->ack == -1; j++) {
  1228. HMT_low();
  1229. mb();
  1230. }
  1231. HMT_medium();
  1232. if (data->ack != -1)
  1233. prom_debug("done, PIR=0x%x\n", data->ack);
  1234. else
  1235. prom_debug("timeout !\n");
  1236. }
  1237. }
  1238. prom_debug("prom_opal_hold_cpus: end...\n");
  1239. }
  1240. static void prom_opal_takeover(void)
  1241. {
  1242. struct opal_secondary_data *data = &RELOC(opal_secondary_data);
  1243. struct opal_takeover_args *args = &data->args;
  1244. u64 align = RELOC(prom_opal_align);
  1245. u64 top_addr, opal_addr;
  1246. args->k_image = (u64)RELOC(_stext);
  1247. args->k_size = _end - _stext;
  1248. args->k_entry = 0;
  1249. args->k_entry2 = 0x60;
  1250. top_addr = _ALIGN_UP(args->k_size, align);
  1251. if (RELOC(prom_initrd_start) != 0) {
  1252. args->rd_image = RELOC(prom_initrd_start);
  1253. args->rd_size = RELOC(prom_initrd_end) - args->rd_image;
  1254. args->rd_loc = top_addr;
  1255. top_addr = _ALIGN_UP(args->rd_loc + args->rd_size, align);
  1256. }
  1257. /* Pickup an address for the HAL. We want to go really high
  1258. * up to avoid problem with future kexecs. On the other hand
  1259. * we don't want to be all over the TCEs on P5IOC2 machines
  1260. * which are going to be up there too. We assume the machine
  1261. * has plenty of memory, and we ask for the HAL for now to
  1262. * be just below the 1G point, or above the initrd
  1263. */
  1264. opal_addr = _ALIGN_DOWN(0x40000000 - RELOC(prom_opal_size), align);
  1265. if (opal_addr < top_addr)
  1266. opal_addr = top_addr;
  1267. args->hal_addr = opal_addr;
  1268. /* Copy the command line to the kernel image */
  1269. strlcpy(RELOC(boot_command_line), RELOC(prom_cmd_line),
  1270. COMMAND_LINE_SIZE);
  1271. prom_debug(" k_image = 0x%lx\n", args->k_image);
  1272. prom_debug(" k_size = 0x%lx\n", args->k_size);
  1273. prom_debug(" k_entry = 0x%lx\n", args->k_entry);
  1274. prom_debug(" k_entry2 = 0x%lx\n", args->k_entry2);
  1275. prom_debug(" hal_addr = 0x%lx\n", args->hal_addr);
  1276. prom_debug(" rd_image = 0x%lx\n", args->rd_image);
  1277. prom_debug(" rd_size = 0x%lx\n", args->rd_size);
  1278. prom_debug(" rd_loc = 0x%lx\n", args->rd_loc);
  1279. prom_printf("Performing OPAL takeover,this can take a few minutes..\n");
  1280. prom_close_stdin();
  1281. mb();
  1282. data->go = 1;
  1283. for (;;)
  1284. opal_do_takeover(args);
  1285. }
  1286. /*
  1287. * Allocate room for and instantiate OPAL
  1288. */
  1289. static void __init prom_instantiate_opal(void)
  1290. {
  1291. phandle opal_node;
  1292. ihandle opal_inst;
  1293. u64 base, entry;
  1294. u64 size = 0, align = 0x10000;
  1295. u32 rets[2];
  1296. prom_debug("prom_instantiate_opal: start...\n");
  1297. opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
  1298. prom_debug("opal_node: %x\n", opal_node);
  1299. if (!PHANDLE_VALID(opal_node))
  1300. return;
  1301. prom_getprop(opal_node, "opal-runtime-size", &size, sizeof(size));
  1302. if (size == 0)
  1303. return;
  1304. prom_getprop(opal_node, "opal-runtime-alignment", &align,
  1305. sizeof(align));
  1306. base = alloc_down(size, align, 0);
  1307. if (base == 0) {
  1308. prom_printf("OPAL allocation failed !\n");
  1309. return;
  1310. }
  1311. opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
  1312. if (!IHANDLE_VALID(opal_inst)) {
  1313. prom_printf("opening opal package failed (%x)\n", opal_inst);
  1314. return;
  1315. }
  1316. prom_printf("instantiating opal at 0x%x...", base);
  1317. if (call_prom_ret("call-method", 4, 3, rets,
  1318. ADDR("load-opal-runtime"),
  1319. opal_inst,
  1320. base >> 32, base & 0xffffffff) != 0
  1321. || (rets[0] == 0 && rets[1] == 0)) {
  1322. prom_printf(" failed\n");
  1323. return;
  1324. }
  1325. entry = (((u64)rets[0]) << 32) | rets[1];
  1326. prom_printf(" done\n");
  1327. reserve_mem(base, size);
  1328. prom_debug("opal base = 0x%x\n", base);
  1329. prom_debug("opal align = 0x%x\n", align);
  1330. prom_debug("opal entry = 0x%x\n", entry);
  1331. prom_debug("opal size = 0x%x\n", (long)size);
  1332. prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
  1333. &base, sizeof(base));
  1334. prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
  1335. &entry, sizeof(entry));
  1336. #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
  1337. RELOC(prom_opal_base) = base;
  1338. RELOC(prom_opal_entry) = entry;
  1339. #endif
  1340. prom_debug("prom_instantiate_opal: end...\n");
  1341. }
  1342. #endif /* CONFIG_PPC_POWERNV */
  1343. /*
  1344. * Allocate room for and instantiate RTAS
  1345. */
  1346. static void __init prom_instantiate_rtas(void)
  1347. {
  1348. phandle rtas_node;
  1349. ihandle rtas_inst;
  1350. u32 base, entry = 0;
  1351. u32 size = 0;
  1352. prom_debug("prom_instantiate_rtas: start...\n");
  1353. rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
  1354. prom_debug("rtas_node: %x\n", rtas_node);
  1355. if (!PHANDLE_VALID(rtas_node))
  1356. return;
  1357. prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
  1358. if (size == 0)
  1359. return;
  1360. base = alloc_down(size, PAGE_SIZE, 0);
  1361. if (base == 0) {
  1362. prom_printf("RTAS allocation failed !\n");
  1363. return;
  1364. }
  1365. rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
  1366. if (!IHANDLE_VALID(rtas_inst)) {
  1367. prom_printf("opening rtas package failed (%x)\n", rtas_inst);
  1368. return;
  1369. }
  1370. prom_printf("instantiating rtas at 0x%x...", base);
  1371. if (call_prom_ret("call-method", 3, 2, &entry,
  1372. ADDR("instantiate-rtas"),
  1373. rtas_inst, base) != 0
  1374. || entry == 0) {
  1375. prom_printf(" failed\n");
  1376. return;
  1377. }
  1378. prom_printf(" done\n");
  1379. reserve_mem(base, size);
  1380. prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
  1381. &base, sizeof(base));
  1382. prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
  1383. &entry, sizeof(entry));
  1384. #ifdef CONFIG_PPC_POWERNV
  1385. /* PowerVN takeover hack */
  1386. RELOC(prom_rtas_data) = base;
  1387. RELOC(prom_rtas_entry) = entry;
  1388. prom_getprop(rtas_node, "start-cpu", &RELOC(prom_rtas_start_cpu), 4);
  1389. #endif
  1390. prom_debug("rtas base = 0x%x\n", base);
  1391. prom_debug("rtas entry = 0x%x\n", entry);
  1392. prom_debug("rtas size = 0x%x\n", (long)size);
  1393. prom_debug("prom_instantiate_rtas: end...\n");
  1394. }
  1395. #ifdef CONFIG_PPC64
  1396. /*
  1397. * Allocate room for and initialize TCE tables
  1398. */
  1399. static void __init prom_initialize_tce_table(void)
  1400. {
  1401. phandle node;
  1402. ihandle phb_node;
  1403. char compatible[64], type[64], model[64];
  1404. char *path = RELOC(prom_scratch);
  1405. u64 base, align;
  1406. u32 minalign, minsize;
  1407. u64 tce_entry, *tce_entryp;
  1408. u64 local_alloc_top, local_alloc_bottom;
  1409. u64 i;
  1410. if (RELOC(prom_iommu_off))
  1411. return;
  1412. prom_debug("starting prom_initialize_tce_table\n");
  1413. /* Cache current top of allocs so we reserve a single block */
  1414. local_alloc_top = RELOC(alloc_top_high);
  1415. local_alloc_bottom = local_alloc_top;
  1416. /* Search all nodes looking for PHBs. */
  1417. for (node = 0; prom_next_node(&node); ) {
  1418. compatible[0] = 0;
  1419. type[0] = 0;
  1420. model[0] = 0;
  1421. prom_getprop(node, "compatible",
  1422. compatible, sizeof(compatible));
  1423. prom_getprop(node, "device_type", type, sizeof(type));
  1424. prom_getprop(node, "model", model, sizeof(model));
  1425. if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
  1426. continue;
  1427. /* Keep the old logic intact to avoid regression. */
  1428. if (compatible[0] != 0) {
  1429. if ((strstr(compatible, RELOC("python")) == NULL) &&
  1430. (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
  1431. (strstr(compatible, RELOC("Winnipeg")) == NULL))
  1432. continue;
  1433. } else if (model[0] != 0) {
  1434. if ((strstr(model, RELOC("ython")) == NULL) &&
  1435. (strstr(model, RELOC("peedwagon")) == NULL) &&
  1436. (strstr(model, RELOC("innipeg")) == NULL))
  1437. continue;
  1438. }
  1439. if (prom_getprop(node, "tce-table-minalign", &minalign,
  1440. sizeof(minalign)) == PROM_ERROR)
  1441. minalign = 0;
  1442. if (prom_getprop(node, "tce-table-minsize", &minsize,
  1443. sizeof(minsize)) == PROM_ERROR)
  1444. minsize = 4UL << 20;
  1445. /*
  1446. * Even though we read what OF wants, we just set the table
  1447. * size to 4 MB. This is enough to map 2GB of PCI DMA space.
  1448. * By doing this, we avoid the pitfalls of trying to DMA to
  1449. * MMIO space and the DMA alias hole.
  1450. *
  1451. * On POWER4, firmware sets the TCE region by assuming
  1452. * each TCE table is 8MB. Using this memory for anything
  1453. * else will impact performance, so we always allocate 8MB.
  1454. * Anton
  1455. */
  1456. if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
  1457. minsize = 8UL << 20;
  1458. else
  1459. minsize = 4UL << 20;
  1460. /* Align to the greater of the align or size */
  1461. align = max(minalign, minsize);
  1462. base = alloc_down(minsize, align, 1);
  1463. if (base == 0)
  1464. prom_panic("ERROR, cannot find space for TCE table.\n");
  1465. if (base < local_alloc_bottom)
  1466. local_alloc_bottom = base;
  1467. /* It seems OF doesn't null-terminate the path :-( */
  1468. memset(path, 0, PROM_SCRATCH_SIZE);
  1469. /* Call OF to setup the TCE hardware */
  1470. if (call_prom("package-to-path", 3, 1, node,
  1471. path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
  1472. prom_printf("package-to-path failed\n");
  1473. }
  1474. /* Save away the TCE table attributes for later use. */
  1475. prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
  1476. prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
  1477. prom_debug("TCE table: %s\n", path);
  1478. prom_debug("\tnode = 0x%x\n", node);
  1479. prom_debug("\tbase = 0x%x\n", base);
  1480. prom_debug("\tsize = 0x%x\n", minsize);
  1481. /* Initialize the table to have a one-to-one mapping
  1482. * over the allocated size.
  1483. */
  1484. tce_entryp = (u64 *)base;
  1485. for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
  1486. tce_entry = (i << PAGE_SHIFT);
  1487. tce_entry |= 0x3;
  1488. *tce_entryp = tce_entry;
  1489. }
  1490. prom_printf("opening PHB %s", path);
  1491. phb_node = call_prom("open", 1, 1, path);
  1492. if (phb_node == 0)
  1493. prom_printf("... failed\n");
  1494. else
  1495. prom_printf("... done\n");
  1496. call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
  1497. phb_node, -1, minsize,
  1498. (u32) base, (u32) (base >> 32));
  1499. call_prom("close", 1, 0, phb_node);
  1500. }
  1501. reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
  1502. /* These are only really needed if there is a memory limit in
  1503. * effect, but we don't know so export them always. */
  1504. RELOC(prom_tce_alloc_start) = local_alloc_bottom;
  1505. RELOC(prom_tce_alloc_end) = local_alloc_top;
  1506. /* Flag the first invalid entry */
  1507. prom_debug("ending prom_initialize_tce_table\n");
  1508. }
  1509. #endif
  1510. /*
  1511. * With CHRP SMP we need to use the OF to start the other processors.
  1512. * We can't wait until smp_boot_cpus (the OF is trashed by then)
  1513. * so we have to put the processors into a holding pattern controlled
  1514. * by the kernel (not OF) before we destroy the OF.
  1515. *
  1516. * This uses a chunk of low memory, puts some holding pattern
  1517. * code there and sends the other processors off to there until
  1518. * smp_boot_cpus tells them to do something. The holding pattern
  1519. * checks that address until its cpu # is there, when it is that
  1520. * cpu jumps to __secondary_start(). smp_boot_cpus() takes care
  1521. * of setting those values.
  1522. *
  1523. * We also use physical address 0x4 here to tell when a cpu
  1524. * is in its holding pattern code.
  1525. *
  1526. * -- Cort
  1527. */
  1528. /*
  1529. * We want to reference the copy of __secondary_hold_* in the
  1530. * 0 - 0x100 address range
  1531. */
  1532. #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff)
  1533. static void __init prom_hold_cpus(void)
  1534. {
  1535. unsigned long i;
  1536. unsigned int reg;
  1537. phandle node;
  1538. char type[64];
  1539. struct prom_t *_prom = &RELOC(prom);
  1540. unsigned long *spinloop
  1541. = (void *) LOW_ADDR(__secondary_hold_spinloop);
  1542. unsigned long *acknowledge
  1543. = (void *) LOW_ADDR(__secondary_hold_acknowledge);
  1544. unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
  1545. prom_debug("prom_hold_cpus: start...\n");
  1546. prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop);
  1547. prom_debug(" 1) *spinloop = 0x%x\n", *spinloop);
  1548. prom_debug(" 1) acknowledge = 0x%x\n",
  1549. (unsigned long)acknowledge);
  1550. prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge);
  1551. prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold);
  1552. /* Set the common spinloop variable, so all of the secondary cpus
  1553. * will block when they are awakened from their OF spinloop.
  1554. * This must occur for both SMP and non SMP kernels, since OF will
  1555. * be trashed when we move the kernel.
  1556. */
  1557. *spinloop = 0;
  1558. /* look for cpus */
  1559. for (node = 0; prom_next_node(&node); ) {
  1560. type[0] = 0;
  1561. prom_getprop(node, "device_type", type, sizeof(type));
  1562. if (strcmp(type, RELOC("cpu")) != 0)
  1563. continue;
  1564. /* Skip non-configured cpus. */
  1565. if (prom_getprop(node, "status", type, sizeof(type)) > 0)
  1566. if (strcmp(type, RELOC("okay")) != 0)
  1567. continue;
  1568. reg = -1;
  1569. prom_getprop(node, "reg", &reg, sizeof(reg));
  1570. prom_debug("cpu hw idx = %lu\n", reg);
  1571. /* Init the acknowledge var which will be reset by
  1572. * the secondary cpu when it awakens from its OF
  1573. * spinloop.
  1574. */
  1575. *acknowledge = (unsigned long)-1;
  1576. if (reg != _prom->cpu) {
  1577. /* Primary Thread of non-boot cpu or any thread */
  1578. prom_printf("starting cpu hw idx %lu... ", reg);
  1579. call_prom("start-cpu", 3, 0, node,
  1580. secondary_hold, reg);
  1581. for (i = 0; (i < 100000000) &&
  1582. (*acknowledge == ((unsigned long)-1)); i++ )
  1583. mb();
  1584. if (*acknowledge == reg)
  1585. prom_printf("done\n");
  1586. else
  1587. prom_printf("failed: %x\n", *acknowledge);
  1588. }
  1589. #ifdef CONFIG_SMP
  1590. else
  1591. prom_printf("boot cpu hw idx %lu\n", reg);
  1592. #endif /* CONFIG_SMP */
  1593. }
  1594. prom_debug("prom_hold_cpus: end...\n");
  1595. }
  1596. static void __init prom_init_client_services(unsigned long pp)
  1597. {
  1598. struct prom_t *_prom = &RELOC(prom);
  1599. /* Get a handle to the prom entry point before anything else */
  1600. RELOC(prom_entry) = pp;
  1601. /* get a handle for the stdout device */
  1602. _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
  1603. if (!PHANDLE_VALID(_prom->chosen))
  1604. prom_panic("cannot find chosen"); /* msg won't be printed :( */
  1605. /* get device tree root */
  1606. _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
  1607. if (!PHANDLE_VALID(_prom->root))
  1608. prom_panic("cannot find device tree root"); /* msg won't be printed :( */
  1609. _prom->mmumap = 0;
  1610. }
  1611. #ifdef CONFIG_PPC32
  1612. /*
  1613. * For really old powermacs, we need to map things we claim.
  1614. * For that, we need the ihandle of the mmu.
  1615. * Also, on the longtrail, we need to work around other bugs.
  1616. */
  1617. static void __init prom_find_mmu(void)
  1618. {
  1619. struct prom_t *_prom = &RELOC(prom);
  1620. phandle oprom;
  1621. char version[64];
  1622. oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
  1623. if (!PHANDLE_VALID(oprom))
  1624. return;
  1625. if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
  1626. return;
  1627. version[sizeof(version) - 1] = 0;
  1628. /* XXX might need to add other versions here */
  1629. if (strcmp(version, "Open Firmware, 1.0.5") == 0)
  1630. of_workarounds = OF_WA_CLAIM;
  1631. else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
  1632. of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
  1633. call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
  1634. } else
  1635. return;
  1636. _prom->memory = call_prom("open", 1, 1, ADDR("/memory"));
  1637. prom_getprop(_prom->chosen, "mmu", &_prom->mmumap,
  1638. sizeof(_prom->mmumap));
  1639. if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap))
  1640. of_workarounds &= ~OF_WA_CLAIM; /* hmmm */
  1641. }
  1642. #else
  1643. #define prom_find_mmu()
  1644. #endif
  1645. static void __init prom_init_stdout(void)
  1646. {
  1647. struct prom_t *_prom = &RELOC(prom);
  1648. char *path = RELOC(of_stdout_device);
  1649. char type[16];
  1650. u32 val;
  1651. if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
  1652. prom_panic("cannot find stdout");
  1653. _prom->stdout = val;
  1654. /* Get the full OF pathname of the stdout device */
  1655. memset(path, 0, 256);
  1656. call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
  1657. val = call_prom("instance-to-package", 1, 1, _prom->stdout);
  1658. prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package",
  1659. &val, sizeof(val));
  1660. prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
  1661. prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path",
  1662. path, strlen(path) + 1);
  1663. /* If it's a display, note it */
  1664. memset(type, 0, sizeof(type));
  1665. prom_getprop(val, "device_type", type, sizeof(type));
  1666. if (strcmp(type, RELOC("display")) == 0)
  1667. prom_setprop(val, path, "linux,boot-display", NULL, 0);
  1668. }
  1669. static int __init prom_find_machine_type(void)
  1670. {
  1671. struct prom_t *_prom = &RELOC(prom);
  1672. char compat[256];
  1673. int len, i = 0;
  1674. #ifdef CONFIG_PPC64
  1675. phandle rtas;
  1676. int x;
  1677. #endif
  1678. /* Look for a PowerMac or a Cell */
  1679. len = prom_getprop(_prom->root, "compatible",
  1680. compat, sizeof(compat)-1);
  1681. if (len > 0) {
  1682. compat[len] = 0;
  1683. while (i < len) {
  1684. char *p = &compat[i];
  1685. int sl = strlen(p);
  1686. if (sl == 0)
  1687. break;
  1688. if (strstr(p, RELOC("Power Macintosh")) ||
  1689. strstr(p, RELOC("MacRISC")))
  1690. return PLATFORM_POWERMAC;
  1691. #ifdef CONFIG_PPC64
  1692. /* We must make sure we don't detect the IBM Cell
  1693. * blades as pSeries due to some firmware issues,
  1694. * so we do it here.
  1695. */
  1696. if (strstr(p, RELOC("IBM,CBEA")) ||
  1697. strstr(p, RELOC("IBM,CPBW-1.0")))
  1698. return PLATFORM_GENERIC;
  1699. #endif /* CONFIG_PPC64 */
  1700. i += sl + 1;
  1701. }
  1702. }
  1703. #ifdef CONFIG_PPC64
  1704. /* Try to detect OPAL */
  1705. if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
  1706. return PLATFORM_OPAL;
  1707. /* Try to figure out if it's an IBM pSeries or any other
  1708. * PAPR compliant platform. We assume it is if :
  1709. * - /device_type is "chrp" (please, do NOT use that for future
  1710. * non-IBM designs !
  1711. * - it has /rtas
  1712. */
  1713. len = prom_getprop(_prom->root, "device_type",
  1714. compat, sizeof(compat)-1);
  1715. if (len <= 0)
  1716. return PLATFORM_GENERIC;
  1717. if (strcmp(compat, RELOC("chrp")))
  1718. return PLATFORM_GENERIC;
  1719. /* Default to pSeries. We need to know if we are running LPAR */
  1720. rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
  1721. if (!PHANDLE_VALID(rtas))
  1722. return PLATFORM_GENERIC;
  1723. x = prom_getproplen(rtas, "ibm,hypertas-functions");
  1724. if (x != PROM_ERROR) {
  1725. prom_debug("Hypertas detected, assuming LPAR !\n");
  1726. return PLATFORM_PSERIES_LPAR;
  1727. }
  1728. return PLATFORM_PSERIES;
  1729. #else
  1730. return PLATFORM_GENERIC;
  1731. #endif
  1732. }
  1733. static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
  1734. {
  1735. return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
  1736. }
  1737. /*
  1738. * If we have a display that we don't know how to drive,
  1739. * we will want to try to execute OF's open method for it
  1740. * later. However, OF will probably fall over if we do that
  1741. * we've taken over the MMU.
  1742. * So we check whether we will need to open the display,
  1743. * and if so, open it now.
  1744. */
  1745. static void __init prom_check_displays(void)
  1746. {
  1747. char type[16], *path;
  1748. phandle node;
  1749. ihandle ih;
  1750. int i;
  1751. static unsigned char default_colors[] = {
  1752. 0x00, 0x00, 0x00,
  1753. 0x00, 0x00, 0xaa,
  1754. 0x00, 0xaa, 0x00,
  1755. 0x00, 0xaa, 0xaa,
  1756. 0xaa, 0x00, 0x00,
  1757. 0xaa, 0x00, 0xaa,
  1758. 0xaa, 0xaa, 0x00,
  1759. 0xaa, 0xaa, 0xaa,
  1760. 0x55, 0x55, 0x55,
  1761. 0x55, 0x55, 0xff,
  1762. 0x55, 0xff, 0x55,
  1763. 0x55, 0xff, 0xff,
  1764. 0xff, 0x55, 0x55,
  1765. 0xff, 0x55, 0xff,
  1766. 0xff, 0xff, 0x55,
  1767. 0xff, 0xff, 0xff
  1768. };
  1769. const unsigned char *clut;
  1770. prom_debug("Looking for displays\n");
  1771. for (node = 0; prom_next_node(&node); ) {
  1772. memset(type, 0, sizeof(type));
  1773. prom_getprop(node, "device_type", type, sizeof(type));
  1774. if (strcmp(type, RELOC("display")) != 0)
  1775. continue;
  1776. /* It seems OF doesn't null-terminate the path :-( */
  1777. path = RELOC(prom_scratch);
  1778. memset(path, 0, PROM_SCRATCH_SIZE);
  1779. /*
  1780. * leave some room at the end of the path for appending extra
  1781. * arguments
  1782. */
  1783. if (call_prom("package-to-path", 3, 1, node, path,
  1784. PROM_SCRATCH_SIZE-10) == PROM_ERROR)
  1785. continue;
  1786. prom_printf("found display : %s, opening... ", path);
  1787. ih = call_prom("open", 1, 1, path);
  1788. if (ih == 0) {
  1789. prom_printf("failed\n");
  1790. continue;
  1791. }
  1792. /* Success */
  1793. prom_printf("done\n");
  1794. prom_setprop(node, path, "linux,opened", NULL, 0);
  1795. /* Setup a usable color table when the appropriate
  1796. * method is available. Should update this to set-colors */
  1797. clut = RELOC(default_colors);
  1798. for (i = 0; i < 32; i++, clut += 3)
  1799. if (prom_set_color(ih, i, clut[0], clut[1],
  1800. clut[2]) != 0)
  1801. break;
  1802. #ifdef CONFIG_LOGO_LINUX_CLUT224
  1803. clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
  1804. for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
  1805. if (prom_set_color(ih, i + 32, clut[0], clut[1],
  1806. clut[2]) != 0)
  1807. break;
  1808. #endif /* CONFIG_LOGO_LINUX_CLUT224 */
  1809. }
  1810. }
  1811. /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
  1812. static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
  1813. unsigned long needed, unsigned long align)
  1814. {
  1815. void *ret;
  1816. *mem_start = _ALIGN(*mem_start, align);
  1817. while ((*mem_start + needed) > *mem_end) {
  1818. unsigned long room, chunk;
  1819. prom_debug("Chunk exhausted, claiming more at %x...\n",
  1820. RELOC(alloc_bottom));
  1821. room = RELOC(alloc_top) - RELOC(alloc_bottom);
  1822. if (room > DEVTREE_CHUNK_SIZE)
  1823. room = DEVTREE_CHUNK_SIZE;
  1824. if (room < PAGE_SIZE)
  1825. prom_panic("No memory for flatten_device_tree "
  1826. "(no room)\n");
  1827. chunk = alloc_up(room, 0);
  1828. if (chunk == 0)
  1829. prom_panic("No memory for flatten_device_tree "
  1830. "(claim failed)\n");
  1831. *mem_end = chunk + room;
  1832. }
  1833. ret = (void *)*mem_start;
  1834. *mem_start += needed;
  1835. return ret;
  1836. }
  1837. #define dt_push_token(token, mem_start, mem_end) \
  1838. do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
  1839. static unsigned long __init dt_find_string(char *str)
  1840. {
  1841. char *s, *os;
  1842. s = os = (char *)RELOC(dt_string_start);
  1843. s += 4;
  1844. while (s < (char *)RELOC(dt_string_end)) {
  1845. if (strcmp(s, str) == 0)
  1846. return s - os;
  1847. s += strlen(s) + 1;
  1848. }
  1849. return 0;
  1850. }
  1851. /*
  1852. * The Open Firmware 1275 specification states properties must be 31 bytes or
  1853. * less, however not all firmwares obey this. Make it 64 bytes to be safe.
  1854. */
  1855. #define MAX_PROPERTY_NAME 64
  1856. static void __init scan_dt_build_strings(phandle node,
  1857. unsigned long *mem_start,
  1858. unsigned long *mem_end)
  1859. {
  1860. char *prev_name, *namep, *sstart;
  1861. unsigned long soff;
  1862. phandle child;
  1863. sstart = (char *)RELOC(dt_string_start);
  1864. /* get and store all property names */
  1865. prev_name = RELOC("");
  1866. for (;;) {
  1867. /* 64 is max len of name including nul. */
  1868. namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
  1869. if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
  1870. /* No more nodes: unwind alloc */
  1871. *mem_start = (unsigned long)namep;
  1872. break;
  1873. }
  1874. /* skip "name" */
  1875. if (strcmp(namep, RELOC("name")) == 0) {
  1876. *mem_start = (unsigned long)namep;
  1877. prev_name = RELOC("name");
  1878. continue;
  1879. }
  1880. /* get/create string entry */
  1881. soff = dt_find_string(namep);
  1882. if (soff != 0) {
  1883. *mem_start = (unsigned long)namep;
  1884. namep = sstart + soff;
  1885. } else {
  1886. /* Trim off some if we can */
  1887. *mem_start = (unsigned long)namep + strlen(namep) + 1;
  1888. RELOC(dt_string_end) = *mem_start;
  1889. }
  1890. prev_name = namep;
  1891. }
  1892. /* do all our children */
  1893. child = call_prom("child", 1, 1, node);
  1894. while (child != 0) {
  1895. scan_dt_build_strings(child, mem_start, mem_end);
  1896. child = call_prom("peer", 1, 1, child);
  1897. }
  1898. }
  1899. static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
  1900. unsigned long *mem_end)
  1901. {
  1902. phandle child;
  1903. char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
  1904. unsigned long soff;
  1905. unsigned char *valp;
  1906. static char pname[MAX_PROPERTY_NAME];
  1907. int l, room, has_phandle = 0;
  1908. dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
  1909. /* get the node's full name */
  1910. namep = (char *)*mem_start;
  1911. room = *mem_end - *mem_start;
  1912. if (room > 255)
  1913. room = 255;
  1914. l = call_prom("package-to-path", 3, 1, node, namep, room);
  1915. if (l >= 0) {
  1916. /* Didn't fit? Get more room. */
  1917. if (l >= room) {
  1918. if (l >= *mem_end - *mem_start)
  1919. namep = make_room(mem_start, mem_end, l+1, 1);
  1920. call_prom("package-to-path", 3, 1, node, namep, l);
  1921. }
  1922. namep[l] = '\0';
  1923. /* Fixup an Apple bug where they have bogus \0 chars in the
  1924. * middle of the path in some properties, and extract
  1925. * the unit name (everything after the last '/').
  1926. */
  1927. for (lp = p = namep, ep = namep + l; p < ep; p++) {
  1928. if (*p == '/')
  1929. lp = namep;
  1930. else if (*p != 0)
  1931. *lp++ = *p;
  1932. }
  1933. *lp = 0;
  1934. *mem_start = _ALIGN((unsigned long)lp + 1, 4);
  1935. }
  1936. /* get it again for debugging */
  1937. path = RELOC(prom_scratch);
  1938. memset(path, 0, PROM_SCRATCH_SIZE);
  1939. call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
  1940. /* get and store all properties */
  1941. prev_name = RELOC("");
  1942. sstart = (char *)RELOC(dt_string_start);
  1943. for (;;) {
  1944. if (call_prom("nextprop", 3, 1, node, prev_name,
  1945. RELOC(pname)) != 1)
  1946. break;
  1947. /* skip "name" */
  1948. if (strcmp(RELOC(pname), RELOC("name")) == 0) {
  1949. prev_name = RELOC("name");
  1950. continue;
  1951. }
  1952. /* find string offset */
  1953. soff = dt_find_string(RELOC(pname));
  1954. if (soff == 0) {
  1955. prom_printf("WARNING: Can't find string index for"
  1956. " <%s>, node %s\n", RELOC(pname), path);
  1957. break;
  1958. }
  1959. prev_name = sstart + soff;
  1960. /* get length */
  1961. l = call_prom("getproplen", 2, 1, node, RELOC(pname));
  1962. /* sanity checks */
  1963. if (l == PROM_ERROR)
  1964. continue;
  1965. if (l > MAX_PROPERTY_LENGTH) {
  1966. prom_printf("WARNING: ignoring large property ");
  1967. /* It seems OF doesn't null-terminate the path :-( */
  1968. prom_printf("[%s] ", path);
  1969. prom_printf("%s length 0x%x\n", RELOC(pname), l);
  1970. continue;
  1971. }
  1972. /* push property head */
  1973. dt_push_token(OF_DT_PROP, mem_start, mem_end);
  1974. dt_push_token(l, mem_start, mem_end);
  1975. dt_push_token(soff, mem_start, mem_end);
  1976. /* push property content */
  1977. valp = make_room(mem_start, mem_end, l, 4);
  1978. call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
  1979. *mem_start = _ALIGN(*mem_start, 4);
  1980. if (!strcmp(RELOC(pname), RELOC("phandle")))
  1981. has_phandle = 1;
  1982. }
  1983. /* Add a "linux,phandle" property if no "phandle" property already
  1984. * existed (can happen with OPAL)
  1985. */
  1986. if (!has_phandle) {
  1987. soff = dt_find_string(RELOC("linux,phandle"));
  1988. if (soff == 0)
  1989. prom_printf("WARNING: Can't find string index for"
  1990. " <linux-phandle> node %s\n", path);
  1991. else {
  1992. dt_push_token(OF_DT_PROP, mem_start, mem_end);
  1993. dt_push_token(4, mem_start, mem_end);
  1994. dt_push_token(soff, mem_start, mem_end);
  1995. valp = make_room(mem_start, mem_end, 4, 4);
  1996. *(u32 *)valp = node;
  1997. }
  1998. }
  1999. /* do all our children */
  2000. child = call_prom("child", 1, 1, node);
  2001. while (child != 0) {
  2002. scan_dt_build_struct(child, mem_start, mem_end);
  2003. child = call_prom("peer", 1, 1, child);
  2004. }
  2005. dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
  2006. }
  2007. static void __init flatten_device_tree(void)
  2008. {
  2009. phandle root;
  2010. unsigned long mem_start, mem_end, room;
  2011. struct boot_param_header *hdr;
  2012. struct prom_t *_prom = &RELOC(prom);
  2013. char *namep;
  2014. u64 *rsvmap;
  2015. /*
  2016. * Check how much room we have between alloc top & bottom (+/- a
  2017. * few pages), crop to 1MB, as this is our "chunk" size
  2018. */
  2019. room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
  2020. if (room > DEVTREE_CHUNK_SIZE)
  2021. room = DEVTREE_CHUNK_SIZE;
  2022. prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
  2023. /* Now try to claim that */
  2024. mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
  2025. if (mem_start == 0)
  2026. prom_panic("Can't allocate initial device-tree chunk\n");
  2027. mem_end = mem_start + room;
  2028. /* Get root of tree */
  2029. root = call_prom("peer", 1, 1, (phandle)0);
  2030. if (root == (phandle)0)
  2031. prom_panic ("couldn't get device tree root\n");
  2032. /* Build header and make room for mem rsv map */
  2033. mem_start = _ALIGN(mem_start, 4);
  2034. hdr = make_room(&mem_start, &mem_end,
  2035. sizeof(struct boot_param_header), 4);
  2036. RELOC(dt_header_start) = (unsigned long)hdr;
  2037. rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
  2038. /* Start of strings */
  2039. mem_start = PAGE_ALIGN(mem_start);
  2040. RELOC(dt_string_start) = mem_start;
  2041. mem_start += 4; /* hole */
  2042. /* Add "linux,phandle" in there, we'll need it */
  2043. namep = make_room(&mem_start, &mem_end, 16, 1);
  2044. strcpy(namep, RELOC("linux,phandle"));
  2045. mem_start = (unsigned long)namep + strlen(namep) + 1;
  2046. /* Build string array */
  2047. prom_printf("Building dt strings...\n");
  2048. scan_dt_build_strings(root, &mem_start, &mem_end);
  2049. RELOC(dt_string_end) = mem_start;
  2050. /* Build structure */
  2051. mem_start = PAGE_ALIGN(mem_start);
  2052. RELOC(dt_struct_start) = mem_start;
  2053. prom_printf("Building dt structure...\n");
  2054. scan_dt_build_struct(root, &mem_start, &mem_end);
  2055. dt_push_token(OF_DT_END, &mem_start, &mem_end);
  2056. RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
  2057. /* Finish header */
  2058. hdr->boot_cpuid_phys = _prom->cpu;
  2059. hdr->magic = OF_DT_HEADER;
  2060. hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
  2061. hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
  2062. hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
  2063. hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
  2064. hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
  2065. hdr->version = OF_DT_VERSION;
  2066. /* Version 16 is not backward compatible */
  2067. hdr->last_comp_version = 0x10;
  2068. /* Copy the reserve map in */
  2069. memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
  2070. #ifdef DEBUG_PROM
  2071. {
  2072. int i;
  2073. prom_printf("reserved memory map:\n");
  2074. for (i = 0; i < RELOC(mem_reserve_cnt); i++)
  2075. prom_printf(" %x - %x\n",
  2076. RELOC(mem_reserve_map)[i].base,
  2077. RELOC(mem_reserve_map)[i].size);
  2078. }
  2079. #endif
  2080. /* Bump mem_reserve_cnt to cause further reservations to fail
  2081. * since it's too late.
  2082. */
  2083. RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
  2084. prom_printf("Device tree strings 0x%x -> 0x%x\n",
  2085. RELOC(dt_string_start), RELOC(dt_string_end));
  2086. prom_printf("Device tree struct 0x%x -> 0x%x\n",
  2087. RELOC(dt_struct_start), RELOC(dt_struct_end));
  2088. }
  2089. #ifdef CONFIG_PPC_MAPLE
  2090. /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
  2091. * The values are bad, and it doesn't even have the right number of cells. */
  2092. static void __init fixup_device_tree_maple(void)
  2093. {
  2094. phandle isa;
  2095. u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
  2096. u32 isa_ranges[6];
  2097. char *name;
  2098. name = "/ht@0/isa@4";
  2099. isa = call_prom("finddevice", 1, 1, ADDR(name));
  2100. if (!PHANDLE_VALID(isa)) {
  2101. name = "/ht@0/isa@6";
  2102. isa = call_prom("finddevice", 1, 1, ADDR(name));
  2103. rloc = 0x01003000; /* IO space; PCI device = 6 */
  2104. }
  2105. if (!PHANDLE_VALID(isa))
  2106. return;
  2107. if (prom_getproplen(isa, "ranges") != 12)
  2108. return;
  2109. if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
  2110. == PROM_ERROR)
  2111. return;
  2112. if (isa_ranges[0] != 0x1 ||
  2113. isa_ranges[1] != 0xf4000000 ||
  2114. isa_ranges[2] != 0x00010000)
  2115. return;
  2116. prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
  2117. isa_ranges[0] = 0x1;
  2118. isa_ranges[1] = 0x0;
  2119. isa_ranges[2] = rloc;
  2120. isa_ranges[3] = 0x0;
  2121. isa_ranges[4] = 0x0;
  2122. isa_ranges[5] = 0x00010000;
  2123. prom_setprop(isa, name, "ranges",
  2124. isa_ranges, sizeof(isa_ranges));
  2125. }
  2126. #define CPC925_MC_START 0xf8000000
  2127. #define CPC925_MC_LENGTH 0x1000000
  2128. /* The values for memory-controller don't have right number of cells */
  2129. static void __init fixup_device_tree_maple_memory_controller(void)
  2130. {
  2131. phandle mc;
  2132. u32 mc_reg[4];
  2133. char *name = "/hostbridge@f8000000";
  2134. struct prom_t *_prom = &RELOC(prom);
  2135. u32 ac, sc;
  2136. mc = call_prom("finddevice", 1, 1, ADDR(name));
  2137. if (!PHANDLE_VALID(mc))
  2138. return;
  2139. if (prom_getproplen(mc, "reg") != 8)
  2140. return;
  2141. prom_getprop(_prom->root, "#address-cells", &ac, sizeof(ac));
  2142. prom_getprop(_prom->root, "#size-cells", &sc, sizeof(sc));
  2143. if ((ac != 2) || (sc != 2))
  2144. return;
  2145. if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
  2146. return;
  2147. if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
  2148. return;
  2149. prom_printf("Fixing up bogus hostbridge on Maple...\n");
  2150. mc_reg[0] = 0x0;
  2151. mc_reg[1] = CPC925_MC_START;
  2152. mc_reg[2] = 0x0;
  2153. mc_reg[3] = CPC925_MC_LENGTH;
  2154. prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
  2155. }
  2156. #else
  2157. #define fixup_device_tree_maple()
  2158. #define fixup_device_tree_maple_memory_controller()
  2159. #endif
  2160. #ifdef CONFIG_PPC_CHRP
  2161. /*
  2162. * Pegasos and BriQ lacks the "ranges" property in the isa node
  2163. * Pegasos needs decimal IRQ 14/15, not hexadecimal
  2164. * Pegasos has the IDE configured in legacy mode, but advertised as native
  2165. */
  2166. static void __init fixup_device_tree_chrp(void)
  2167. {
  2168. phandle ph;
  2169. u32 prop[6];
  2170. u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
  2171. char *name;
  2172. int rc;
  2173. name = "/pci@80000000/isa@c";
  2174. ph = call_prom("finddevice", 1, 1, ADDR(name));
  2175. if (!PHANDLE_VALID(ph)) {
  2176. name = "/pci@ff500000/isa@6";
  2177. ph = call_prom("finddevice", 1, 1, ADDR(name));
  2178. rloc = 0x01003000; /* IO space; PCI device = 6 */
  2179. }
  2180. if (PHANDLE_VALID(ph)) {
  2181. rc = prom_getproplen(ph, "ranges");
  2182. if (rc == 0 || rc == PROM_ERROR) {
  2183. prom_printf("Fixing up missing ISA range on Pegasos...\n");
  2184. prop[0] = 0x1;
  2185. prop[1] = 0x0;
  2186. prop[2] = rloc;
  2187. prop[3] = 0x0;
  2188. prop[4] = 0x0;
  2189. prop[5] = 0x00010000;
  2190. prom_setprop(ph, name, "ranges", prop, sizeof(prop));
  2191. }
  2192. }
  2193. name = "/pci@80000000/ide@C,1";
  2194. ph = call_prom("finddevice", 1, 1, ADDR(name));
  2195. if (PHANDLE_VALID(ph)) {
  2196. prom_printf("Fixing up IDE interrupt on Pegasos...\n");
  2197. prop[0] = 14;
  2198. prop[1] = 0x0;
  2199. prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
  2200. prom_printf("Fixing up IDE class-code on Pegasos...\n");
  2201. rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
  2202. if (rc == sizeof(u32)) {
  2203. prop[0] &= ~0x5;
  2204. prom_setprop(ph, name, "class-code", prop, sizeof(u32));
  2205. }
  2206. }
  2207. }
  2208. #else
  2209. #define fixup_device_tree_chrp()
  2210. #endif
  2211. #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
  2212. static void __init fixup_device_tree_pmac(void)
  2213. {
  2214. phandle u3, i2c, mpic;
  2215. u32 u3_rev;
  2216. u32 interrupts[2];
  2217. u32 parent;
  2218. /* Some G5s have a missing interrupt definition, fix it up here */
  2219. u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
  2220. if (!PHANDLE_VALID(u3))
  2221. return;
  2222. i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
  2223. if (!PHANDLE_VALID(i2c))
  2224. return;
  2225. mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
  2226. if (!PHANDLE_VALID(mpic))
  2227. return;
  2228. /* check if proper rev of u3 */
  2229. if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
  2230. == PROM_ERROR)
  2231. return;
  2232. if (u3_rev < 0x35 || u3_rev > 0x39)
  2233. return;
  2234. /* does it need fixup ? */
  2235. if (prom_getproplen(i2c, "interrupts") > 0)
  2236. return;
  2237. prom_printf("fixing up bogus interrupts for u3 i2c...\n");
  2238. /* interrupt on this revision of u3 is number 0 and level */
  2239. interrupts[0] = 0;
  2240. interrupts[1] = 1;
  2241. prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
  2242. &interrupts, sizeof(interrupts));
  2243. parent = (u32)mpic;
  2244. prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
  2245. &parent, sizeof(parent));
  2246. }
  2247. #else
  2248. #define fixup_device_tree_pmac()
  2249. #endif
  2250. #ifdef CONFIG_PPC_EFIKA
  2251. /*
  2252. * The MPC5200 FEC driver requires an phy-handle property to tell it how
  2253. * to talk to the phy. If the phy-handle property is missing, then this
  2254. * function is called to add the appropriate nodes and link it to the
  2255. * ethernet node.
  2256. */
  2257. static void __init fixup_device_tree_efika_add_phy(void)
  2258. {
  2259. u32 node;
  2260. char prop[64];
  2261. int rv;
  2262. /* Check if /builtin/ethernet exists - bail if it doesn't */
  2263. node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
  2264. if (!PHANDLE_VALID(node))
  2265. return;
  2266. /* Check if the phy-handle property exists - bail if it does */
  2267. rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
  2268. if (!rv)
  2269. return;
  2270. /*
  2271. * At this point the ethernet device doesn't have a phy described.
  2272. * Now we need to add the missing phy node and linkage
  2273. */
  2274. /* Check for an MDIO bus node - if missing then create one */
  2275. node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
  2276. if (!PHANDLE_VALID(node)) {
  2277. prom_printf("Adding Ethernet MDIO node\n");
  2278. call_prom("interpret", 1, 1,
  2279. " s\" /builtin\" find-device"
  2280. " new-device"
  2281. " 1 encode-int s\" #address-cells\" property"
  2282. " 0 encode-int s\" #size-cells\" property"
  2283. " s\" mdio\" device-name"
  2284. " s\" fsl,mpc5200b-mdio\" encode-string"
  2285. " s\" compatible\" property"
  2286. " 0xf0003000 0x400 reg"
  2287. " 0x2 encode-int"
  2288. " 0x5 encode-int encode+"
  2289. " 0x3 encode-int encode+"
  2290. " s\" interrupts\" property"
  2291. " finish-device");
  2292. };
  2293. /* Check for a PHY device node - if missing then create one and
  2294. * give it's phandle to the ethernet node */
  2295. node = call_prom("finddevice", 1, 1,
  2296. ADDR("/builtin/mdio/ethernet-phy"));
  2297. if (!PHANDLE_VALID(node)) {
  2298. prom_printf("Adding Ethernet PHY node\n");
  2299. call_prom("interpret", 1, 1,
  2300. " s\" /builtin/mdio\" find-device"
  2301. " new-device"
  2302. " s\" ethernet-phy\" device-name"
  2303. " 0x10 encode-int s\" reg\" property"
  2304. " my-self"
  2305. " ihandle>phandle"
  2306. " finish-device"
  2307. " s\" /builtin/ethernet\" find-device"
  2308. " encode-int"
  2309. " s\" phy-handle\" property"
  2310. " device-end");
  2311. }
  2312. }
  2313. static void __init fixup_device_tree_efika(void)
  2314. {
  2315. int sound_irq[3] = { 2, 2, 0 };
  2316. int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
  2317. 3,4,0, 3,5,0, 3,6,0, 3,7,0,
  2318. 3,8,0, 3,9,0, 3,10,0, 3,11,0,
  2319. 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
  2320. u32 node;
  2321. char prop[64];
  2322. int rv, len;
  2323. /* Check if we're really running on a EFIKA */
  2324. node = call_prom("finddevice", 1, 1, ADDR("/"));
  2325. if (!PHANDLE_VALID(node))
  2326. return;
  2327. rv = prom_getprop(node, "model", prop, sizeof(prop));
  2328. if (rv == PROM_ERROR)
  2329. return;
  2330. if (strcmp(prop, "EFIKA5K2"))
  2331. return;
  2332. prom_printf("Applying EFIKA device tree fixups\n");
  2333. /* Claiming to be 'chrp' is death */
  2334. node = call_prom("finddevice", 1, 1, ADDR("/"));
  2335. rv = prom_getprop(node, "device_type", prop, sizeof(prop));
  2336. if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
  2337. prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
  2338. /* CODEGEN,description is exposed in /proc/cpuinfo so
  2339. fix that too */
  2340. rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
  2341. if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
  2342. prom_setprop(node, "/", "CODEGEN,description",
  2343. "Efika 5200B PowerPC System",
  2344. sizeof("Efika 5200B PowerPC System"));
  2345. /* Fixup bestcomm interrupts property */
  2346. node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
  2347. if (PHANDLE_VALID(node)) {
  2348. len = prom_getproplen(node, "interrupts");
  2349. if (len == 12) {
  2350. prom_printf("Fixing bestcomm interrupts property\n");
  2351. prom_setprop(node, "/builtin/bestcom", "interrupts",
  2352. bcomm_irq, sizeof(bcomm_irq));
  2353. }
  2354. }
  2355. /* Fixup sound interrupts property */
  2356. node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
  2357. if (PHANDLE_VALID(node)) {
  2358. rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
  2359. if (rv == PROM_ERROR) {
  2360. prom_printf("Adding sound interrupts property\n");
  2361. prom_setprop(node, "/builtin/sound", "interrupts",
  2362. sound_irq, sizeof(sound_irq));
  2363. }
  2364. }
  2365. /* Make sure ethernet phy-handle property exists */
  2366. fixup_device_tree_efika_add_phy();
  2367. }
  2368. #else
  2369. #define fixup_device_tree_efika()
  2370. #endif
  2371. static void __init fixup_device_tree(void)
  2372. {
  2373. fixup_device_tree_maple();
  2374. fixup_device_tree_maple_memory_controller();
  2375. fixup_device_tree_chrp();
  2376. fixup_device_tree_pmac();
  2377. fixup_device_tree_efika();
  2378. }
  2379. static void __init prom_find_boot_cpu(void)
  2380. {
  2381. struct prom_t *_prom = &RELOC(prom);
  2382. u32 getprop_rval;
  2383. ihandle prom_cpu;
  2384. phandle cpu_pkg;
  2385. _prom->cpu = 0;
  2386. if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
  2387. return;
  2388. cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
  2389. prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
  2390. _prom->cpu = getprop_rval;
  2391. prom_debug("Booting CPU hw index = %lu\n", _prom->cpu);
  2392. }
  2393. static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
  2394. {
  2395. #ifdef CONFIG_BLK_DEV_INITRD
  2396. struct prom_t *_prom = &RELOC(prom);
  2397. if (r3 && r4 && r4 != 0xdeadbeef) {
  2398. unsigned long val;
  2399. RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
  2400. RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
  2401. val = RELOC(prom_initrd_start);
  2402. prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
  2403. &val, sizeof(val));
  2404. val = RELOC(prom_initrd_end);
  2405. prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
  2406. &val, sizeof(val));
  2407. reserve_mem(RELOC(prom_initrd_start),
  2408. RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
  2409. prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
  2410. prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
  2411. }
  2412. #endif /* CONFIG_BLK_DEV_INITRD */
  2413. }
  2414. /*
  2415. * We enter here early on, when the Open Firmware prom is still
  2416. * handling exceptions and the MMU hash table for us.
  2417. */
  2418. unsigned long __init prom_init(unsigned long r3, unsigned long r4,
  2419. unsigned long pp,
  2420. unsigned long r6, unsigned long r7,
  2421. unsigned long kbase)
  2422. {
  2423. struct prom_t *_prom;
  2424. unsigned long hdr;
  2425. #ifdef CONFIG_PPC32
  2426. unsigned long offset = reloc_offset();
  2427. reloc_got2(offset);
  2428. #endif
  2429. _prom = &RELOC(prom);
  2430. /*
  2431. * First zero the BSS
  2432. */
  2433. memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
  2434. /*
  2435. * Init interface to Open Firmware, get some node references,
  2436. * like /chosen
  2437. */
  2438. prom_init_client_services(pp);
  2439. /*
  2440. * See if this OF is old enough that we need to do explicit maps
  2441. * and other workarounds
  2442. */
  2443. prom_find_mmu();
  2444. /*
  2445. * Init prom stdout device
  2446. */
  2447. prom_init_stdout();
  2448. prom_printf("Preparing to boot %s", RELOC(linux_banner));
  2449. /*
  2450. * Get default machine type. At this point, we do not differentiate
  2451. * between pSeries SMP and pSeries LPAR
  2452. */
  2453. RELOC(of_platform) = prom_find_machine_type();
  2454. prom_printf("Detected machine type: %x\n", RELOC(of_platform));
  2455. #ifndef CONFIG_RELOCATABLE
  2456. /* Bail if this is a kdump kernel. */
  2457. if (PHYSICAL_START > 0)
  2458. prom_panic("Error: You can't boot a kdump kernel from OF!\n");
  2459. #endif
  2460. /*
  2461. * Check for an initrd
  2462. */
  2463. prom_check_initrd(r3, r4);
  2464. #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
  2465. /*
  2466. * On pSeries, inform the firmware about our capabilities
  2467. */
  2468. if (RELOC(of_platform) == PLATFORM_PSERIES ||
  2469. RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
  2470. prom_send_capabilities();
  2471. #endif
  2472. /*
  2473. * Copy the CPU hold code
  2474. */
  2475. if (RELOC(of_platform) != PLATFORM_POWERMAC)
  2476. copy_and_flush(0, kbase, 0x100, 0);
  2477. /*
  2478. * Do early parsing of command line
  2479. */
  2480. early_cmdline_parse();
  2481. /*
  2482. * Initialize memory management within prom_init
  2483. */
  2484. prom_init_mem();
  2485. /*
  2486. * Determine which cpu is actually running right _now_
  2487. */
  2488. prom_find_boot_cpu();
  2489. /*
  2490. * Initialize display devices
  2491. */
  2492. prom_check_displays();
  2493. #ifdef CONFIG_PPC64
  2494. /*
  2495. * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
  2496. * that uses the allocator, we need to make sure we get the top of memory
  2497. * available for us here...
  2498. */
  2499. if (RELOC(of_platform) == PLATFORM_PSERIES)
  2500. prom_initialize_tce_table();
  2501. #endif
  2502. /*
  2503. * On non-powermacs, try to instantiate RTAS. PowerMacs don't
  2504. * have a usable RTAS implementation.
  2505. */
  2506. if (RELOC(of_platform) != PLATFORM_POWERMAC &&
  2507. RELOC(of_platform) != PLATFORM_OPAL)
  2508. prom_instantiate_rtas();
  2509. #ifdef CONFIG_PPC_POWERNV
  2510. /* Detect HAL and try instanciating it & doing takeover */
  2511. if (RELOC(of_platform) == PLATFORM_PSERIES_LPAR) {
  2512. prom_query_opal();
  2513. if (RELOC(of_platform) == PLATFORM_OPAL) {
  2514. prom_opal_hold_cpus();
  2515. prom_opal_takeover();
  2516. }
  2517. } else if (RELOC(of_platform) == PLATFORM_OPAL)
  2518. prom_instantiate_opal();
  2519. #endif
  2520. /*
  2521. * On non-powermacs, put all CPUs in spin-loops.
  2522. *
  2523. * PowerMacs use a different mechanism to spin CPUs
  2524. */
  2525. if (RELOC(of_platform) != PLATFORM_POWERMAC &&
  2526. RELOC(of_platform) != PLATFORM_OPAL)
  2527. prom_hold_cpus();
  2528. /*
  2529. * Fill in some infos for use by the kernel later on
  2530. */
  2531. if (RELOC(prom_memory_limit))
  2532. prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
  2533. &RELOC(prom_memory_limit),
  2534. sizeof(prom_memory_limit));
  2535. #ifdef CONFIG_PPC64
  2536. if (RELOC(prom_iommu_off))
  2537. prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
  2538. NULL, 0);
  2539. if (RELOC(prom_iommu_force_on))
  2540. prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
  2541. NULL, 0);
  2542. if (RELOC(prom_tce_alloc_start)) {
  2543. prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
  2544. &RELOC(prom_tce_alloc_start),
  2545. sizeof(prom_tce_alloc_start));
  2546. prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
  2547. &RELOC(prom_tce_alloc_end),
  2548. sizeof(prom_tce_alloc_end));
  2549. }
  2550. #endif
  2551. /*
  2552. * Fixup any known bugs in the device-tree
  2553. */
  2554. fixup_device_tree();
  2555. /*
  2556. * Now finally create the flattened device-tree
  2557. */
  2558. prom_printf("copying OF device tree...\n");
  2559. flatten_device_tree();
  2560. /*
  2561. * in case stdin is USB and still active on IBM machines...
  2562. * Unfortunately quiesce crashes on some powermacs if we have
  2563. * closed stdin already (in particular the powerbook 101).
  2564. */
  2565. if (RELOC(of_platform) != PLATFORM_POWERMAC)
  2566. prom_close_stdin();
  2567. /*
  2568. * Call OF "quiesce" method to shut down pending DMA's from
  2569. * devices etc...
  2570. */
  2571. prom_printf("Calling quiesce...\n");
  2572. call_prom("quiesce", 0, 0);
  2573. /*
  2574. * And finally, call the kernel passing it the flattened device
  2575. * tree and NULL as r5, thus triggering the new entry point which
  2576. * is common to us and kexec
  2577. */
  2578. hdr = RELOC(dt_header_start);
  2579. prom_printf("returning from prom_init\n");
  2580. prom_debug("->dt_header_start=0x%x\n", hdr);
  2581. #ifdef CONFIG_PPC32
  2582. reloc_got2(-offset);
  2583. #endif
  2584. #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
  2585. /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
  2586. __start(hdr, kbase, 0, 0, 0,
  2587. RELOC(prom_opal_base), RELOC(prom_opal_entry));
  2588. #else
  2589. __start(hdr, kbase, 0, 0, 0, 0, 0);
  2590. #endif
  2591. return 0;
  2592. }