开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
prom_init.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：23k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

prom_init.c：源码内容
  1. /*
  2.  * Procedures for interfacing to the Open Firmware PROM on
  3.  * Power Macintosh computers.
  4.  *
  5.  * In particular, we are interested in the device tree
  6.  * and in using some of its services (exit, write to stdout).
  7.  *
  8.  * Paul Mackerras August 1996.
  9.  * Copyright (C) 1996 Paul Mackerras.
  10.  */
  11. /*
  12.  * Note that prom_init() and anything called from prom_init()
  13.  * may be running at an address that is different from the address
  14.  * that it was linked at.  References to static data items are
  15.  * handled by compiling this file with -mrelocatable-lib.
  16.  */
  18. #include <linux/config.h>
  19. #include <linux/kernel.h>
  20. #include <linux/init.h>
  22. #include <asm/prom.h>
  23. #include <asm/io.h>
  24. #include <asm/bootx.h>
  25. #include <asm/btext.h>
  26. #include <asm/mmu.h>
  27. #include <asm/pgtable.h>
  29. #ifdef CONFIG_FB
  30. #include <asm/linux_logo.h>
  31. #endif
  33. /*
  34.  * Properties whose value is longer than this get excluded from our
  35.  * copy of the device tree.  This way we don't waste space storing
  36.  * things like "driver,AAPL,MacOS,PowerPC" properties.  But this value
  37.  * does need to be big enough to ensure that we don't lose things
  38.  * like the interrupt-map property on a PCI-PCI bridge.
  39.  */
  40. #define MAX_PROPERTY_LENGTH 4096
  42. #ifndef FB_MAX /* avoid pulling in all of the fb stuff */
  43. #define FB_MAX 8
  44. #endif
  46. #define ALIGN(x) (((x) + sizeof(unsigned long)-1) & -sizeof(unsigned long))
  48. struct prom_args {
  49. const char *service;
  50. int nargs;
  51. int nret;
  52. void *args[10];
  53. };
  55. struct pci_address {
  56. unsigned a_hi;
  57. unsigned a_mid;
  58. unsigned a_lo;
  59. };
  61. struct pci_reg_property {
  62. struct pci_address addr;
  63. unsigned size_hi;
  64. unsigned size_lo;
  65. };
  67. struct pci_range {
  68. struct pci_address addr;
  69. unsigned phys;
  70. unsigned size_hi;
  71. unsigned size_lo;
  72. };
  74. struct isa_reg_property {
  75. unsigned space;
  76. unsigned address;
  77. unsigned size;
  78. };
  80. struct pci_intr_map {
  81. struct pci_address addr;
  82. unsigned dunno;
  83. phandle int_ctrler;
  84. unsigned intr;
  85. };
  87. static void prom_exit(void);
  88. static void *call_prom(const char *service, int nargs, int nret, ...);
  89. static void *call_prom_ret(const char *service, int nargs, int nret,
  90.    void **rets, ...);
  91. static void prom_print_hex(unsigned int v);
  92. static int  prom_set_color(ihandle ih, int i, int r, int g, int b);
  93. static int  prom_next_node(phandle *nodep);
  94. static unsigned long check_display(unsigned long mem);
  95. static void setup_disp_fake_bi(ihandle dp);
  96. static unsigned long copy_device_tree(unsigned long mem_start,
  97. unsigned long mem_end);
  98. static unsigned long inspect_node(phandle node, struct device_node *dad,
  99. unsigned long mem_start, unsigned long mem_end,
  100. struct device_node ***allnextpp);
  101. static void prom_hold_cpus(unsigned long mem);
  102. static void prom_instantiate_rtas(void);
  103. static void * early_get_property(unsigned long base, unsigned long node,
  104. char *prop);
  106. prom_entry prom __initdata = 0;
  107. ihandle prom_chosen __initdata = 0;
  108. ihandle prom_stdout __initdata = 0;
  110. char *prom_display_paths[FB_MAX] __initdata = { 0, };
  111. phandle prom_display_nodes[FB_MAX] __initdata;
  112. unsigned int prom_num_displays __initdata = 0;
  113. static char *of_stdout_device __initdata = 0;
  114. static ihandle prom_disp_node __initdata = 0;
  116. unsigned int rtas_data;   /* physical pointer */
  117. unsigned int rtas_entry;  /* physical pointer */
  118. unsigned int rtas_size;
  119. unsigned int old_rtas;
  121. boot_infos_t *boot_infos;
  122. char *bootpath;
  123. char *bootdevice;
  124. struct device_node *allnodes;
  126. extern char *klimit;
  127. extern char _stext;
  129. static void __init
  130. prom_exit(void)
  131. {
  132. struct prom_args args;
  134. args.service = "exit";
  135. args.nargs = 0;
  136. args.nret = 0;
  137. prom(&args);
  138. for (;;) /* should never get here */
  139. ;
  140. }
  142. static void * __init
  143. call_prom(const char *service, int nargs, int nret, ...)
  144. {
  145. va_list list;
  146. int i;
  147. struct prom_args prom_args;
  149. prom_args.service = service;
  150. prom_args.nargs = nargs;
  151. prom_args.nret = nret;
  152. va_start(list, nret);
  153. for (i = 0; i < nargs; ++i)
  154. prom_args.args[i] = va_arg(list, void *);
  155. va_end(list);
  156. for (i = 0; i < nret; ++i)
  157. prom_args.args[i + nargs] = 0;
  158. prom(&prom_args);
  159. return prom_args.args[nargs];
  160. }
  162. static void * __init
  163. call_prom_ret(const char *service, int nargs, int nret, void **rets, ...)
  164. {
  165. va_list list;
  166. int i;
  167. struct prom_args prom_args;
  169. prom_args.service = service;
  170. prom_args.nargs = nargs;
  171. prom_args.nret = nret;
  172. va_start(list, rets);
  173. for (i = 0; i < nargs; ++i)
  174. prom_args.args[i] = va_arg(list, void *);
  175. va_end(list);
  176. for (i = 0; i < nret; ++i)
  177. prom_args.args[i + nargs] = 0;
  178. prom(&prom_args);
  179. for (i = 1; i < nret; ++i)
  180. rets[i-1] = prom_args.args[nargs + i];
  181. return prom_args.args[nargs];
  182. }
  184. void __init
  185. prom_print(const char *msg)
  186. {
  187. const char *p, *q;
  189. if (prom_stdout == 0)
  190. return;
  192. for (p = msg; *p != 0; p = q) {
  193. for (q = p; *q != 0 && *q != 'n'; ++q)
  194. ;
  195. if (q > p)
  196. call_prom("write", 3, 1, prom_stdout, p, q - p);
  197. if (*q != 0) {
  198. ++q;
  199. call_prom("write", 3, 1, prom_stdout, "rn", 2);
  200. }
  201. }
  202. }
  204. static void __init
  205. prom_print_hex(unsigned int v)
  206. {
  207. char buf[16];
  208. int i, c;
  210. for (i = 0; i < 8; ++i) {
  211. c = (v >> ((7-i)*4)) & 0xf;
  212. c += (c >= 10)? ('a' - 10): '0';
  213. buf[i] = c;
  214. }
  215. buf[i] = ' ';
  216. buf[i+1] = 0;
  217. prom_print(buf);
  218. }
  220. static int __init
  221. prom_set_color(ihandle ih, int i, int r, int g, int b)
  222. {
  223. struct prom_args prom_args;
  225. prom_args.service = "call-method";
  226. prom_args.nargs = 6;
  227. prom_args.nret = 1;
  228. prom_args.args[0] = "color!";
  229. prom_args.args[1] = ih;
  230. prom_args.args[2] = (void *) i;
  231. prom_args.args[3] = (void *) b;
  232. prom_args.args[4] = (void *) g;
  233. prom_args.args[5] = (void *) r;
  234. prom(&prom_args);
  235. return (int) prom_args.args[6];
  236. }
  238. static int __init
  239. prom_next_node(phandle *nodep)
  240. {
  241. phandle node;
  243. if ((node = *nodep) != 0
  244.     && (*nodep = call_prom("child", 1, 1, node)) != 0)
  245. return 1;
  246. if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
  247. return 1;
  248. for (;;) {
  249. if ((node = call_prom("parent", 1, 1, node)) == 0)
  250. return 0;
  251. if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
  252. return 1;
  253. }
  254. }
  256. /*
  257.  * If we have a display that we don't know how to drive,
  258.  * we will want to try to execute OF's open method for it
  259.  * later.  However, OF will probably fall over if we do that
  260.  * we've taken over the MMU.
  261.  * So we check whether we will need to open the display,
  262.  * and if so, open it now.
  263.  */
  264. static unsigned long __init
  265. check_display(unsigned long mem)
  266. {
  267. phandle node;
  268. ihandle ih;
  269. int i;
  270. char type[16], *path;
  271. static unsigned char default_colors[] = {
  272. 0x00, 0x00, 0x00,
  273. 0x00, 0x00, 0xaa,
  274. 0x00, 0xaa, 0x00,
  275. 0x00, 0xaa, 0xaa,
  276. 0xaa, 0x00, 0x00,
  277. 0xaa, 0x00, 0xaa,
  278. 0xaa, 0xaa, 0x00,
  279. 0xaa, 0xaa, 0xaa,
  280. 0x55, 0x55, 0x55,
  281. 0x55, 0x55, 0xff,
  282. 0x55, 0xff, 0x55,
  283. 0x55, 0xff, 0xff,
  284. 0xff, 0x55, 0x55,
  285. 0xff, 0x55, 0xff,
  286. 0xff, 0xff, 0x55,
  287. 0xff, 0xff, 0xff
  288. };
  290. prom_disp_node = 0;
  292. for (node = 0; prom_next_node(&node); ) {
  293. type[0] = 0;
  294. call_prom("getprop", 4, 1, node, "device_type",
  295.   type, sizeof(type));
  296. if (strcmp(type, "display") != 0)
  297. continue;
  298. /* It seems OF doesn't null-terminate the path :-( */
  299. path = (char *) mem;
  300. memset(path, 0, 256);
  301. if ((int) call_prom("package-to-path", 3, 1,
  302.     node, path, 255) < 0)
  303. continue;
  305. /*
  306.  * If this display is the device that OF is using for stdout,
  307.  * move it to the front of the list.
  308.  */
  309. mem += strlen(path) + 1;
  310. i = prom_num_displays++;
  311. if (of_stdout_device != 0 && i > 0
  312.     && strcmp(of_stdout_device, path) == 0) {
  313. for (; i > 0; --i) {
  314. prom_display_paths[i]
  315. = prom_display_paths[i-1];
  316. prom_display_nodes[i]
  317. = prom_display_nodes[i-1];
  318. }
  319. }
  320. prom_display_paths[i] = path;
  321. prom_display_nodes[i] = node;
  322. if (i == 0)
  323. prom_disp_node = node;
  324. if (prom_num_displays >= FB_MAX)
  325. break;
  326. }
  328. try_again:
  329. /*
  330.  * Open the first display and set its colormap.
  331.  */
  332. if (prom_num_displays > 0) {
  333. path = prom_display_paths[0];
  334. prom_print("opening display ");
  335. prom_print(path);
  336. ih = call_prom("open", 1, 1, path);
  337. if (ih == 0 || ih == (ihandle) -1) {
  338. prom_print("... failedn");
  339. for (i=1; i<prom_num_displays; i++) {
  340. prom_display_paths[i-1] = prom_display_paths[i];
  341. prom_display_nodes[i-1] = prom_display_nodes[i];
  342. }
  343. if (--prom_num_displays > 0)
  344. prom_disp_node = prom_display_nodes[0];
  345. else
  346. prom_disp_node = NULL;
  347. goto try_again;
  348. } else {
  349. prom_print("... okn");
  350. /*
  351.  * Setup a usable color table when the appropriate
  352.  * method is available.
  353.  * Should update this to use set-colors.
  354.  */
  355. for (i = 0; i < 32; i++)
  356. if (prom_set_color(ih, i, default_colors[i*3],
  357.    default_colors[i*3+1],
  358.    default_colors[i*3+2]) != 0)
  359. break;
  361. #ifdef CONFIG_FB
  362. for (i = 0; i < LINUX_LOGO_COLORS; i++)
  363. if (prom_set_color(ih, i + 32,
  364.    linux_logo_red[i],
  365.    linux_logo_green[i],
  366.    linux_logo_blue[i]) != 0)
  367. break;
  368. #endif /* CONFIG_FB */
  369. }
  370. }
  372. return ALIGN(mem);
  373. }
  375. /* This function will enable the early boot text when doing OF booting. This
  376.  * way, xmon output should work too
  377.  */
  378. static void __init
  379. setup_disp_fake_bi(ihandle dp)
  380. {
  381. #ifdef CONFIG_BOOTX_TEXT
  382. int width = 640, height = 480, depth = 8, pitch;
  383. unsigned address;
  384. struct pci_reg_property addrs[8];
  385. int i, naddrs;
  386. char name[32];
  387. char *getprop = "getprop";
  389. prom_print("Initializing fake screen: ");
  391. memset(name, 0, sizeof(name));
  392. call_prom(getprop, 4, 1, dp, "name", name, sizeof(name));
  393. name[sizeof(name)-1] = 0;
  394. prom_print(name);
  395. prom_print("n");
  396. call_prom(getprop, 4, 1, dp, "width", &width, sizeof(width));
  397. call_prom(getprop, 4, 1, dp, "height", &height, sizeof(height));
  398. call_prom(getprop, 4, 1, dp, "depth", &depth, sizeof(depth));
  399. pitch = width * ((depth + 7) / 8);
  400. call_prom(getprop, 4, 1, dp, "linebytes",
  401.   &pitch, sizeof(pitch));
  402. if (pitch == 1)
  403. pitch = 0x1000; /* for strange IBM display */
  404. address = 0;
  405. call_prom(getprop, 4, 1, dp, "address",
  406.   &address, sizeof(address));
  407. if (address == 0) {
  408. /* look for an assigned address with a size of >= 1MB */
  409. naddrs = (int) call_prom(getprop, 4, 1, dp,
  410. "assigned-addresses",
  411. addrs, sizeof(addrs));
  412. naddrs /= sizeof(struct pci_reg_property);
  413. for (i = 0; i < naddrs; ++i) {
  414. if (addrs[i].size_lo >= (1 << 20)) {
  415. address = addrs[i].addr.a_lo;
  416. /* use the BE aperture if possible */
  417. if (addrs[i].size_lo >= (16 << 20))
  418. address += (8 << 20);
  419. break;
  420. }
  421. }
  422. if (address == 0) {
  423. prom_print("Failed to get addressn");
  424. return;
  425. }
  426. }
  427. /* kludge for valkyrie */
  428. if (strcmp(name, "valkyrie") == 0)
  429. address += 0x1000;
  431. btext_setup_display(width, height, depth, pitch, address);
  433. btext_prepare_BAT();
  434. #endif /* CONFIG_BOOTX_TEXT */
  435. }
  437. /*
  438.  * Make a copy of the device tree from the PROM.
  439.  */
  440. static unsigned long __init
  441. copy_device_tree(unsigned long mem_start, unsigned long mem_end)
  442. {
  443. phandle root;
  444. unsigned long new_start;
  445. struct device_node **allnextp;
  447. root = call_prom("peer", 1, 1, (phandle)0);
  448. if (root == (phandle)0) {
  449. prom_print("couldn't get device tree rootn");
  450. prom_exit();
  451. }
  452. allnextp = &allnodes;
  453. mem_start = ALIGN(mem_start);
  454. new_start = inspect_node(root, 0, mem_start, mem_end, &allnextp);
  455. *allnextp = 0;
  456. return new_start;
  457. }
  459. static unsigned long __init
  460. inspect_node(phandle node, struct device_node *dad,
  461.      unsigned long mem_start, unsigned long mem_end,
  462.      struct device_node ***allnextpp)
  463. {
  464. int l;
  465. phandle child;
  466. struct device_node *np;
  467. struct property *pp, **prev_propp;
  468. char *prev_name, *namep;
  469. unsigned char *valp;
  471. np = (struct device_node *) mem_start;
  472. mem_start += sizeof(struct device_node);
  473. memset(np, 0, sizeof(*np));
  474. np->node = node;
  475. **allnextpp = PTRUNRELOC(np);
  476. *allnextpp = &np->allnext;
  477. if (dad != 0) {
  478. np->parent = PTRUNRELOC(dad);
  479. /* we temporarily use the `next' field as `last_child'. */
  480. if (dad->next == 0)
  481. dad->child = PTRUNRELOC(np);
  482. else
  483. dad->next->sibling = PTRUNRELOC(np);
  484. dad->next = np;
  485. }
  487. /* get and store all properties */
  488. prev_propp = &np->properties;
  489. prev_name = "";
  490. for (;;) {
  491. pp = (struct property *) mem_start;
  492. namep = (char *) (pp + 1);
  493. pp->name = PTRUNRELOC(namep);
  494. if ((int) call_prom("nextprop", 3, 1, node, prev_name,
  495.     namep) <= 0)
  496. break;
  497. mem_start = ALIGN((unsigned long)namep + strlen(namep) + 1);
  498. prev_name = namep;
  499. valp = (unsigned char *) mem_start;
  500. pp->value = PTRUNRELOC(valp);
  501. pp->length = (int)
  502. call_prom("getprop", 4, 1, node, namep,
  503.   valp, mem_end - mem_start);
  504. if (pp->length < 0)
  505. continue;
  506. #ifdef MAX_PROPERTY_LENGTH
  507. if (pp->length > MAX_PROPERTY_LENGTH)
  508. continue; /* ignore this property */
  509. #endif
  510. mem_start = ALIGN(mem_start + pp->length);
  511. *prev_propp = PTRUNRELOC(pp);
  512. prev_propp = &pp->next;
  513. }
  514. if (np->node != NULL) {
  515. /* Add a "linux,phandle" property" */
  516. pp = (struct property *) mem_start;
  517. *prev_propp = PTRUNRELOC(pp);
  518. prev_propp = &pp->next;
  519. namep = (char *) (pp + 1);
  520. pp->name = PTRUNRELOC(namep);
  521. strcpy(namep, "linux,phandle");
  522. mem_start = ALIGN((unsigned long)namep + strlen(namep) + 1);
  523. pp->value = (unsigned char *) PTRUNRELOC(&np->node);
  524. pp->length = sizeof(np->node);
  525. }
  526. *prev_propp = NULL;
  528. /* get the node's full name */
  529. l = (int) call_prom("package-to-path", 3, 1, node,
  530.     (char *) mem_start, mem_end - mem_start);
  531. if (l >= 0) {
  532. np->full_name = PTRUNRELOC((char *) mem_start);
  533. *(char *)(mem_start + l) = 0;
  534. mem_start = ALIGN(mem_start + l + 1);
  535. }
  537. /* do all our children */
  538. child = call_prom("child", 1, 1, node);
  539. while (child != (void *)0) {
  540. mem_start = inspect_node(child, np, mem_start, mem_end,
  541.  allnextpp);
  542. child = call_prom("peer", 1, 1, child);
  543. }
  545. return mem_start;
  546. }
  548. unsigned long smp_chrp_cpu_nr __initdata = 0;
  550. /*
  551.  * With CHRP SMP we need to use the OF to start the other
  552.  * processors so we can't wait until smp_boot_cpus (the OF is
  553.  * trashed by then) so we have to put the processors into
  554.  * a holding pattern controlled by the kernel (not OF) before
  555.  * we destroy the OF.
  556.  *
  557.  * This uses a chunk of high memory, puts some holding pattern
  558.  * code there and sends the other processors off to there until
  559.  * smp_boot_cpus tells them to do something.  We do that by using
  560.  * physical address 0x0.  The holding pattern checks that address
  561.  * until its cpu # is there, when it is that cpu jumps to
  562.  * __secondary_start().  smp_boot_cpus() takes care of setting those
  563.  * values.
  564.  *
  565.  * We also use physical address 0x4 here to tell when a cpu
  566.  * is in its holding pattern code.
  567.  *
  568.  * -- Cort
  569.  *
  570.  * Note that we have to do this if we have more than one CPU,
  571.  * even if this is a UP kernel.  Otherwise when we trash OF
  572.  * the other CPUs will start executing some random instructions
  573.  * and crash the system.  -- paulus
  574.  */
  575. static void __init
  576. prom_hold_cpus(unsigned long mem)
  577. {
  578. extern void __secondary_hold(void);
  579. unsigned long i;
  580. int cpu;
  581. phandle node;
  582. char type[16], *path;
  583. unsigned int reg;
  585. /*
  586.  * XXX: hack to make sure we're chrp, assume that if we're
  587.  *      chrp we have a device_type property -- Cort
  588.  */
  589. node = call_prom("finddevice", 1, 1, "/");
  590. if ((int)call_prom("getprop", 4, 1, node,
  591.    "device_type",type, sizeof(type)) <= 0)
  592. return;
  594. /* copy the holding pattern code to someplace safe (0) */
  595. /* the holding pattern is now within the first 0x100
  596.    bytes of the kernel image -- paulus */
  597. memcpy((void *)0, &_stext, 0x100);
  598. flush_icache_range(0, 0x100);
  600. /* look for cpus */
  601. *(unsigned long *)(0x0) = 0;
  602. asm volatile("dcbf 0,%0": : "r" (0) : "memory");
  603. for (node = 0; prom_next_node(&node); ) {
  604. type[0] = 0;
  605. call_prom("getprop", 4, 1, node, "device_type",
  606.   type, sizeof(type));
  607. if (strcmp(type, "cpu") != 0)
  608. continue;
  609. path = (char *) mem;
  610. memset(path, 0, 256);
  611. if ((int) call_prom("package-to-path", 3, 1,
  612.     node, path, 255) < 0)
  613. continue;
  614. reg = -1;
  615. call_prom("getprop", 4, 1, node, "reg", &reg, sizeof(reg));
  616. cpu = smp_chrp_cpu_nr++;
  617. #ifdef CONFIG_SMP
  618. smp_hw_index[cpu] = reg;
  619. #endif /* CONFIG_SMP */
  620. /* XXX: hack - don't start cpu 0, this cpu -- Cort */
  621. if (cpu == 0)
  622. continue;
  623. prom_print("starting cpu ");
  624. prom_print(path);
  625. *(ulong *)(0x4) = 0;
  626. call_prom("start-cpu", 3, 0, node,
  627.   (char *)__secondary_hold - &_stext, cpu);
  628. prom_print("...");
  629. for ( i = 0 ; (i < 10000) && (*(ulong *)(0x4) == 0); i++ )
  630. ;
  631. if (*(ulong *)(0x4) == cpu)
  632. prom_print("okn");
  633. else {
  634. prom_print("failed: ");
  635. prom_print_hex(*(ulong *)0x4);
  636. prom_print("n");
  637. }
  638. }
  639. }
  641. static void __init
  642. prom_instantiate_rtas(void)
  643. {
  644. ihandle prom_rtas;
  645. unsigned int i;
  646. struct prom_args prom_args;
  648. prom_rtas = call_prom("finddevice", 1, 1, "/rtas");
  649. if (prom_rtas == (void *) -1)
  650. return;
  652. rtas_size = 0;
  653. call_prom("getprop", 4, 1, prom_rtas,
  654.   "rtas-size", &rtas_size, sizeof(rtas_size));
  655. prom_print("instantiating rtas");
  656. if (rtas_size == 0) {
  657. rtas_data = 0;
  658. } else {
  659. /*
  660.  * Ask OF for some space for RTAS.
  661.  * Actually OF has bugs so we just arbitrarily
  662.  * use memory at the 6MB point.
  663.  */
  664. rtas_data = 6 << 20;
  665. prom_print(" at ");
  666. prom_print_hex(rtas_data);
  667. }
  669. prom_rtas = call_prom("open", 1, 1, "/rtas");
  670. prom_print("...");
  671. prom_args.service = "call-method";
  672. prom_args.nargs = 3;
  673. prom_args.nret = 2;
  674. prom_args.args[0] = "instantiate-rtas";
  675. prom_args.args[1] = prom_rtas;
  676. prom_args.args[2] = (void *) rtas_data;
  677. prom(&prom_args);
  678. i = 0;
  679. if (prom_args.args[3] == 0)
  680. i = (unsigned int)prom_args.args[4];
  681. rtas_entry = i;
  682. if ((rtas_entry == -1) || (rtas_entry == 0))
  683. prom_print(" failedn");
  684. else
  685. prom_print(" donen");
  686. }
  688. /*
  689.  * We enter here early on, when the Open Firmware prom is still
  690.  * handling exceptions and the MMU hash table for us.
  691.  */
  692. unsigned long __init
  693. prom_init(int r3, int r4, prom_entry pp)
  694. {
  695. unsigned long mem;
  696. ihandle prom_mmu;
  697. unsigned long offset = reloc_offset();
  698. int i, l;
  699. char *p, *d;
  700.   unsigned long phys;
  701. void *result[3];
  703.   /* Default */
  704.   phys = (unsigned long) &_stext;
  706. /* First get a handle for the stdout device */
  707. prom = pp;
  708. prom_chosen = call_prom("finddevice", 1, 1,
  709.        "/chosen");
  710. if (prom_chosen == (void *)-1)
  711. prom_exit();
  712. if ((int) call_prom("getprop", 4, 1, prom_chosen,
  713.     "stdout", &prom_stdout,
  714.     sizeof(prom_stdout)) <= 0)
  715. prom_exit();
  717. /* Get the full OF pathname of the stdout device */
  718. mem = (unsigned long) klimit + offset;
  719. p = (char *) mem;
  720. memset(p, 0, 256);
  721. call_prom("instance-to-path", 3, 1, prom_stdout, p, 255);
  722. of_stdout_device = p;
  723. mem += strlen(p) + 1;
  725. /* Get the boot device and translate it to a full OF pathname. */
  726. p = (char *) mem;
  727. l = (int) call_prom("getprop", 4, 1, prom_chosen,
  728.     "bootpath", p, 1<<20);
  729. if (l > 0) {
  730. p[l] = 0; /* should already be null-terminated */
  731. bootpath = PTRUNRELOC(p);
  732. mem += l + 1;
  733. d = (char *) mem;
  734. *d = 0;
  735. call_prom("canon", 3, 1, p, d, 1<<20);
  736. bootdevice = PTRUNRELOC(d);
  737. mem = ALIGN(mem + strlen(d) + 1);
  738. }
  740. prom_instantiate_rtas();
  742. mem = check_display(mem);
  744. prom_print("copying OF device tree...");
  745. mem = copy_device_tree(mem, mem + (1<<20));
  746. prom_print("donen");
  748. prom_hold_cpus(mem);
  750. klimit = (char *) (mem - offset);
  752. /* If we are already running at 0xc0000000, we assume we were
  753.  * loaded by an OF bootloader which did set a BAT for us.
  754.  * This breaks OF translate so we force phys to be 0.
  755.  */
  756. if (offset == 0)
  757. phys = 0;
  758. else if ((int) call_prom("getprop", 4, 1, prom_chosen, "mmu",
  759.  &prom_mmu, sizeof(prom_mmu)) <= 0) {
  760. prom_print(" no MMU foundn");
  761. } else if ((int)call_prom_ret("call-method", 4, 4, result, "translate",
  762.       prom_mmu, &_stext, 1) != 0) {
  763. prom_print(" (translate failed)n");
  764. } else {
  765. /* We assume the phys. address size is 3 cells */
  766. phys = (unsigned long)result[2];
  767. }
  769. if (prom_disp_node != 0)
  770. setup_disp_fake_bi(prom_disp_node);
  772. /* Use quiesce call to get OF to shut down any devices it's using */
  773. prom_print("Calling quiesce ...n");
  774. call_prom("quiesce", 0, 0);
  776. /* Relocate various pointers which will be used once the
  777.    kernel is running at the address it was linked at. */
  778. for (i = 0; i < prom_num_displays; ++i)
  779. prom_display_paths[i] = PTRUNRELOC(prom_display_paths[i]);
  781. prom_print("returning 0x");
  782. prom_print_hex(phys);
  783. prom_print("from prom_initn");
  784. prom_stdout = 0;
  786. return phys;
  787. }
  789. /*
  790.  * early_get_property is used to access the device tree image prepared
  791.  * by BootX very early on, before the pointers in it have been relocated.
  792.  */
  793. static void * __init
  794. early_get_property(unsigned long base, unsigned long node, char *prop)
  795. {
  796. struct device_node *np = (struct device_node *)(base + node);
  797. struct property *pp;
  799. for (pp = np->properties; pp != 0; pp = pp->next) {
  800. pp = (struct property *) (base + (unsigned long)pp);
  801. if (strcmp((char *)((unsigned long)pp->name + base),
  802.    prop) == 0) {
  803. return (void *)((unsigned long)pp->value + base);
  804. }
  805. }
  806. return 0;
  807. }
  809. /* Is boot-info compatible ? */
  810. #define BOOT_INFO_IS_COMPATIBLE(bi) ((bi)->compatible_version <= BOOT_INFO_VERSION)
  811. #define BOOT_INFO_IS_V2_COMPATIBLE(bi) ((bi)->version >= 2)
  812. #define BOOT_INFO_IS_V4_COMPATIBLE(bi) ((bi)->version >= 4)
  814. void __init
  815. bootx_init(unsigned long r4, unsigned long phys)
  816. {
  817. boot_infos_t *bi = (boot_infos_t *) r4;
  818. unsigned long space;
  819. unsigned long ptr, x;
  820. char *model;
  822. boot_infos = PTRUNRELOC(bi);
  823. if (!BOOT_INFO_IS_V2_COMPATIBLE(bi))
  824. bi->logicalDisplayBase = 0;
  826. #ifdef CONFIG_BOOTX_TEXT
  827. btext_init(bi);
  829. /*
  830.  * Test if boot-info is compatible.  Done only in config
  831.  * CONFIG_BOOTX_TEXT since there is nothing much we can do
  832.  * with an incompatible version, except display a message
  833.  * and eventually hang the processor...
  834.  *
  835.  * I'll try to keep enough of boot-info compatible in the
  836.  * future to always allow display of this message;
  837.  */
  838. if (!BOOT_INFO_IS_COMPATIBLE(bi)) {
  839. btext_drawstring(" !!! WARNING - Incompatible version of BootX !!!nnn");
  840. btext_flushscreen();
  841. }
  842. #endif /* CONFIG_BOOTX_TEXT */
  844. /* New BootX enters kernel with MMU off, i/os are not allowed
  845.    here. This hack will have been done by the boostrap anyway.
  846. */
  847. if (bi->version < 4) {
  848. /*
  849.  * XXX If this is an iMac, turn off the USB controller.
  850.  */
  851. model = (char *) early_get_property
  852. (r4 + bi->deviceTreeOffset, 4, "model");
  853. if (model
  854.     && (strcmp(model, "iMac,1") == 0
  855. || strcmp(model, "PowerMac1,1") == 0)) {
  856. out_le32((unsigned *)0x80880008, 1); /* XXX */
  857. }
  858. }
  860. /* Move klimit to enclose device tree, args, ramdisk, etc... */
  861. if (bi->version < 5) {
  862. space = bi->deviceTreeOffset + bi->deviceTreeSize;
  863. if (bi->ramDisk)
  864. space = bi->ramDisk + bi->ramDiskSize;
  865. } else
  866. space = bi->totalParamsSize;
  867. klimit = PTRUNRELOC((char *) bi + space);
  869. /* New BootX will have flushed all TLBs and enters kernel with
  870.    MMU switched OFF, so this should not be useful anymore.
  871. */
  872. if (bi->version < 4) {
  873. /*
  874.  * Touch each page to make sure the PTEs for them
  875.  * are in the hash table - the aim is to try to avoid
  876.  * getting DSI exceptions while copying the kernel image.
  877.  */
  878. for (ptr = ((unsigned long) &_stext) & PAGE_MASK;
  879.      ptr < (unsigned long)bi + space; ptr += PAGE_SIZE)
  880. x = *(volatile unsigned long *)ptr;
  881. }
  883. #ifdef CONFIG_BOOTX_TEXT
  884. /*
  885.  * Note that after we call btext_prepare_BAT, we can't do
  886.  * prom_draw*, flushscreen or clearscreen until we turn the MMU
  887.  * on, since btext_prepare_BAT sets disp_bi.logicalDisplayBase
  888.  * to a virtual address.
  889.  */
  890. btext_prepare_BAT();
  891. #endif
  892. }