1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#undef DEBUG
17
18#include <stdarg.h>
19#include <linux/kernel.h>
20#include <linux/string.h>
21#include <linux/init.h>
22#include <linux/threads.h>
23#include <linux/spinlock.h>
24#include <linux/types.h>
25#include <linux/pci.h>
26#include <linux/stringify.h>
27#include <linux/delay.h>
28#include <linux/initrd.h>
29#include <linux/bitops.h>
30#include <linux/module.h>
31#include <linux/kexec.h>
32#include <linux/debugfs.h>
33#include <linux/irq.h>
34#include <linux/memblock.h>
35
36#include <asm/prom.h>
37#include <asm/rtas.h>
38#include <asm/page.h>
39#include <asm/processor.h>
40#include <asm/irq.h>
41#include <asm/io.h>
42#include <asm/kdump.h>
43#include <asm/smp.h>
44#include <asm/system.h>
45#include <asm/mmu.h>
46#include <asm/paca.h>
47#include <asm/pgtable.h>
48#include <asm/pci.h>
49#include <asm/iommu.h>
50#include <asm/btext.h>
51#include <asm/sections.h>
52#include <asm/machdep.h>
53#include <asm/pSeries_reconfig.h>
54#include <asm/pci-bridge.h>
55#include <asm/phyp_dump.h>
56#include <asm/kexec.h>
57#include <mm/mmu_decl.h>
58
59#ifdef DEBUG
60#define DBG(fmt...) printk(KERN_ERR fmt)
61#else
62#define DBG(fmt...)
63#endif
64
65#ifdef CONFIG_PPC64
66int __initdata iommu_is_off;
67int __initdata iommu_force_on;
68unsigned long tce_alloc_start, tce_alloc_end;
69u64 ppc64_rma_size;
70#endif
71
72static int __init early_parse_mem(char *p)
73{
74 if (!p)
75 return 1;
76
77 memory_limit = PAGE_ALIGN(memparse(p, &p));
78 DBG("memory limit = 0x%llx\n", (unsigned long long)memory_limit);
79
80 return 0;
81}
82early_param("mem", early_parse_mem);
83
84
85
86
87
88
89
90static void __init move_device_tree(void)
91{
92 unsigned long start, size;
93 void *p;
94
95 DBG("-> move_device_tree\n");
96
97 start = __pa(initial_boot_params);
98 size = be32_to_cpu(initial_boot_params->totalsize);
99
100 if ((memory_limit && (start + size) > memory_limit) ||
101 overlaps_crashkernel(start, size)) {
102 p = __va(memblock_alloc(size, PAGE_SIZE));
103 memcpy(p, initial_boot_params, size);
104 initial_boot_params = (struct boot_param_header *)p;
105 DBG("Moved device tree to 0x%p\n", p);
106 }
107
108 DBG("<- move_device_tree\n");
109}
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124static struct ibm_pa_feature {
125 unsigned long cpu_features;
126 unsigned int cpu_user_ftrs;
127 unsigned char pabyte;
128 unsigned char pabit;
129 unsigned char invert;
130} ibm_pa_features[] __initdata = {
131 {0, PPC_FEATURE_HAS_MMU, 0, 0, 0},
132 {0, PPC_FEATURE_HAS_FPU, 0, 1, 0},
133 {CPU_FTR_SLB, 0, 0, 2, 0},
134 {CPU_FTR_CTRL, 0, 0, 3, 0},
135 {CPU_FTR_NOEXECUTE, 0, 0, 6, 0},
136 {CPU_FTR_NODSISRALIGN, 0, 1, 1, 1},
137 {CPU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0},
138 {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0},
139};
140
141static void __init scan_features(unsigned long node, unsigned char *ftrs,
142 unsigned long tablelen,
143 struct ibm_pa_feature *fp,
144 unsigned long ft_size)
145{
146 unsigned long i, len, bit;
147
148
149 for (;;) {
150 if (tablelen < 3)
151 return;
152 len = 2 + ftrs[0];
153 if (tablelen < len)
154 return;
155 if (ftrs[1] == 0)
156 break;
157 tablelen -= len;
158 ftrs += len;
159 }
160
161
162 for (i = 0; i < ft_size; ++i, ++fp) {
163 if (fp->pabyte >= ftrs[0])
164 continue;
165 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
166 if (bit ^ fp->invert) {
167 cur_cpu_spec->cpu_features |= fp->cpu_features;
168 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
169 } else {
170 cur_cpu_spec->cpu_features &= ~fp->cpu_features;
171 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
172 }
173 }
174}
175
176static void __init check_cpu_pa_features(unsigned long node)
177{
178 unsigned char *pa_ftrs;
179 unsigned long tablelen;
180
181 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
182 if (pa_ftrs == NULL)
183 return;
184
185 scan_features(node, pa_ftrs, tablelen,
186 ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
187}
188
189#ifdef CONFIG_PPC_STD_MMU_64
190static void __init check_cpu_slb_size(unsigned long node)
191{
192 u32 *slb_size_ptr;
193
194 slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL);
195 if (slb_size_ptr != NULL) {
196 mmu_slb_size = *slb_size_ptr;
197 return;
198 }
199 slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
200 if (slb_size_ptr != NULL) {
201 mmu_slb_size = *slb_size_ptr;
202 }
203}
204#else
205#define check_cpu_slb_size(node) do { } while(0)
206#endif
207
208static struct feature_property {
209 const char *name;
210 u32 min_value;
211 unsigned long cpu_feature;
212 unsigned long cpu_user_ftr;
213} feature_properties[] __initdata = {
214#ifdef CONFIG_ALTIVEC
215 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
216 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
217#endif
218#ifdef CONFIG_VSX
219
220 {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX},
221#endif
222#ifdef CONFIG_PPC64
223 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
224 {"ibm,purr", 1, CPU_FTR_PURR, 0},
225 {"ibm,spurr", 1, CPU_FTR_SPURR, 0},
226#endif
227};
228
229#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
230static inline void identical_pvr_fixup(unsigned long node)
231{
232 unsigned int pvr;
233 char *model = of_get_flat_dt_prop(node, "model", NULL);
234
235
236
237
238
239
240
241
242 if (model && strstr(model, "440EP")) {
243 pvr = cur_cpu_spec->pvr_value | 0x8;
244 identify_cpu(0, pvr);
245 DBG("Using logical pvr %x for %s\n", pvr, model);
246 }
247}
248#else
249#define identical_pvr_fixup(node) do { } while(0)
250#endif
251
252static void __init check_cpu_feature_properties(unsigned long node)
253{
254 unsigned long i;
255 struct feature_property *fp = feature_properties;
256 const u32 *prop;
257
258 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
259 prop = of_get_flat_dt_prop(node, fp->name, NULL);
260 if (prop && *prop >= fp->min_value) {
261 cur_cpu_spec->cpu_features |= fp->cpu_feature;
262 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
263 }
264 }
265}
266
267static int __init early_init_dt_scan_cpus(unsigned long node,
268 const char *uname, int depth,
269 void *data)
270{
271 static int logical_cpuid = 0;
272 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
273 const u32 *prop;
274 const u32 *intserv;
275 int i, nthreads;
276 unsigned long len;
277 int found = 0;
278
279
280 if (type == NULL || strcmp(type, "cpu") != 0)
281 return 0;
282
283
284 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
285 if (intserv) {
286 nthreads = len / sizeof(int);
287 } else {
288 intserv = of_get_flat_dt_prop(node, "reg", NULL);
289 nthreads = 1;
290 }
291
292
293
294
295
296 for (i = 0; i < nthreads; i++) {
297
298
299
300
301 if (initial_boot_params && initial_boot_params->version >= 2) {
302 if (intserv[i] ==
303 initial_boot_params->boot_cpuid_phys) {
304 found = 1;
305 break;
306 }
307 } else {
308
309
310
311
312
313 if (of_get_flat_dt_prop(node,
314 "linux,boot-cpu", NULL) != NULL) {
315 found = 1;
316 break;
317 }
318 }
319
320#ifdef CONFIG_SMP
321
322 logical_cpuid++;
323#endif
324 }
325
326 if (found) {
327 DBG("boot cpu: logical %d physical %d\n", logical_cpuid,
328 intserv[i]);
329 boot_cpuid = logical_cpuid;
330 set_hard_smp_processor_id(boot_cpuid, intserv[i]);
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346 prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
347 if (prop && (*prop & 0xff000000) == 0x0f000000)
348 identify_cpu(0, *prop);
349
350 identical_pvr_fixup(node);
351 }
352
353 check_cpu_feature_properties(node);
354 check_cpu_pa_features(node);
355 check_cpu_slb_size(node);
356
357#ifdef CONFIG_PPC_PSERIES
358 if (nthreads > 1)
359 cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
360 else
361 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
362#endif
363
364 return 0;
365}
366
367int __init early_init_dt_scan_chosen_ppc(unsigned long node, const char *uname,
368 int depth, void *data)
369{
370 unsigned long *lprop;
371
372
373 if (early_init_dt_scan_chosen(node, uname, depth, data) == 0)
374 return 0;
375
376#ifdef CONFIG_PPC64
377
378 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
379 iommu_is_off = 1;
380 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
381 iommu_force_on = 1;
382#endif
383
384
385 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
386 if (lprop)
387 memory_limit = *lprop;
388
389#ifdef CONFIG_PPC64
390 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
391 if (lprop)
392 tce_alloc_start = *lprop;
393 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
394 if (lprop)
395 tce_alloc_end = *lprop;
396#endif
397
398#ifdef CONFIG_KEXEC
399 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
400 if (lprop)
401 crashk_res.start = *lprop;
402
403 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
404 if (lprop)
405 crashk_res.end = crashk_res.start + *lprop - 1;
406#endif
407
408
409 return 1;
410}
411
412#ifdef CONFIG_PPC_PSERIES
413
414
415
416
417
418
419static int __init early_init_dt_scan_drconf_memory(unsigned long node)
420{
421 __be32 *dm, *ls, *usm;
422 unsigned long l, n, flags;
423 u64 base, size, memblock_size;
424 unsigned int is_kexec_kdump = 0, rngs;
425
426 ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
427 if (ls == NULL || l < dt_root_size_cells * sizeof(__be32))
428 return 0;
429 memblock_size = dt_mem_next_cell(dt_root_size_cells, &ls);
430
431 dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
432 if (dm == NULL || l < sizeof(__be32))
433 return 0;
434
435 n = *dm++;
436 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(__be32))
437 return 0;
438
439
440 usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
441 &l);
442 if (usm != NULL)
443 is_kexec_kdump = 1;
444
445 for (; n != 0; --n) {
446 base = dt_mem_next_cell(dt_root_addr_cells, &dm);
447 flags = dm[3];
448
449 dm += 4;
450
451
452 if ((flags & 0x80) || !(flags & 0x8))
453 continue;
454 size = memblock_size;
455 rngs = 1;
456 if (is_kexec_kdump) {
457
458
459
460
461
462
463
464 rngs = dt_mem_next_cell(dt_root_size_cells, &usm);
465 if (!rngs)
466 continue;
467 }
468 do {
469 if (is_kexec_kdump) {
470 base = dt_mem_next_cell(dt_root_addr_cells,
471 &usm);
472 size = dt_mem_next_cell(dt_root_size_cells,
473 &usm);
474 }
475 if (iommu_is_off) {
476 if (base >= 0x80000000ul)
477 continue;
478 if ((base + size) > 0x80000000ul)
479 size = 0x80000000ul - base;
480 }
481 memblock_add(base, size);
482 } while (--rngs);
483 }
484 memblock_dump_all();
485 return 0;
486}
487#else
488#define early_init_dt_scan_drconf_memory(node) 0
489#endif
490
491static int __init early_init_dt_scan_memory_ppc(unsigned long node,
492 const char *uname,
493 int depth, void *data)
494{
495 if (depth == 1 &&
496 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
497 return early_init_dt_scan_drconf_memory(node);
498
499 return early_init_dt_scan_memory(node, uname, depth, data);
500}
501
502void __init early_init_dt_add_memory_arch(u64 base, u64 size)
503{
504#ifdef CONFIG_PPC64
505 if (iommu_is_off) {
506 if (base >= 0x80000000ul)
507 return;
508 if ((base + size) > 0x80000000ul)
509 size = 0x80000000ul - base;
510 }
511#endif
512
513
514 if (memstart_addr == ~(phys_addr_t)0)
515 setup_initial_memory_limit(base, size);
516 memstart_addr = min((u64)memstart_addr, base);
517
518
519 memblock_add(base, size);
520}
521
522void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
523{
524 return __va(memblock_alloc(size, align));
525}
526
527#ifdef CONFIG_BLK_DEV_INITRD
528void __init early_init_dt_setup_initrd_arch(unsigned long start,
529 unsigned long end)
530{
531 initrd_start = (unsigned long)__va(start);
532 initrd_end = (unsigned long)__va(end);
533 initrd_below_start_ok = 1;
534}
535#endif
536
537static void __init early_reserve_mem(void)
538{
539 u64 base, size;
540 u64 *reserve_map;
541 unsigned long self_base;
542 unsigned long self_size;
543
544 reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
545 initial_boot_params->off_mem_rsvmap);
546
547
548 self_base = __pa((unsigned long)initial_boot_params);
549 self_size = initial_boot_params->totalsize;
550 memblock_reserve(self_base, self_size);
551
552#ifdef CONFIG_BLK_DEV_INITRD
553
554 if (initrd_start && (initrd_end > initrd_start))
555 memblock_reserve(__pa(initrd_start), initrd_end - initrd_start);
556#endif
557
558#ifdef CONFIG_PPC32
559
560
561
562
563 if (*reserve_map > 0xffffffffull) {
564 u32 base_32, size_32;
565 u32 *reserve_map_32 = (u32 *)reserve_map;
566
567 while (1) {
568 base_32 = *(reserve_map_32++);
569 size_32 = *(reserve_map_32++);
570 if (size_32 == 0)
571 break;
572
573 if (base_32 == self_base && size_32 == self_size)
574 continue;
575 DBG("reserving: %x -> %x\n", base_32, size_32);
576 memblock_reserve(base_32, size_32);
577 }
578 return;
579 }
580#endif
581 while (1) {
582 base = *(reserve_map++);
583 size = *(reserve_map++);
584 if (size == 0)
585 break;
586 DBG("reserving: %llx -> %llx\n", base, size);
587 memblock_reserve(base, size);
588 }
589}
590
591#ifdef CONFIG_PHYP_DUMP
592
593
594
595
596
597
598
599
600
601
602static inline unsigned long phyp_dump_calculate_reserve_size(void)
603{
604 unsigned long tmp;
605
606 if (phyp_dump_info->reserve_bootvar)
607 return phyp_dump_info->reserve_bootvar;
608
609
610 tmp = memblock_end_of_DRAM();
611 do_div(tmp, 20);
612
613
614 tmp = tmp & ~0x0FFFFFFFUL;
615
616 return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END);
617}
618
619
620
621
622
623
624
625
626
627
628
629static void __init phyp_dump_reserve_mem(void)
630{
631 unsigned long base, size;
632 unsigned long variable_reserve_size;
633
634 if (!phyp_dump_info->phyp_dump_configured) {
635 printk(KERN_ERR "Phyp-dump not supported on this hardware\n");
636 return;
637 }
638
639 if (!phyp_dump_info->phyp_dump_at_boot) {
640 printk(KERN_INFO "Phyp-dump disabled at boot time\n");
641 return;
642 }
643
644 variable_reserve_size = phyp_dump_calculate_reserve_size();
645
646 if (phyp_dump_info->phyp_dump_is_active) {
647
648 base = variable_reserve_size;
649 size = memblock_end_of_DRAM() - base;
650
651
652
653 memblock_reserve(base, size);
654
655 phyp_dump_info->init_reserve_start = base;
656 phyp_dump_info->init_reserve_size = size;
657 } else {
658 size = phyp_dump_info->cpu_state_size +
659 phyp_dump_info->hpte_region_size +
660 variable_reserve_size;
661 base = memblock_end_of_DRAM() - size;
662 memblock_reserve(base, size);
663 phyp_dump_info->init_reserve_start = base;
664 phyp_dump_info->init_reserve_size = size;
665 }
666}
667#else
668static inline void __init phyp_dump_reserve_mem(void) {}
669#endif
670
671void __init early_init_devtree(void *params)
672{
673 phys_addr_t limit;
674
675 DBG(" -> early_init_devtree(%p)\n", params);
676
677
678 initial_boot_params = params;
679
680#ifdef CONFIG_PPC_RTAS
681
682 of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
683#endif
684
685#ifdef CONFIG_PHYP_DUMP
686
687 of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL);
688#endif
689
690
691
692
693
694 of_scan_flat_dt(early_init_dt_scan_chosen_ppc, NULL);
695
696
697 memblock_init();
698
699 of_scan_flat_dt(early_init_dt_scan_root, NULL);
700 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL);
701
702
703 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
704 parse_early_param();
705
706
707 memblock_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
708
709 if (PHYSICAL_START > MEMORY_START)
710 memblock_reserve(MEMORY_START, 0x8000);
711 reserve_kdump_trampoline();
712 reserve_crashkernel();
713 early_reserve_mem();
714 phyp_dump_reserve_mem();
715
716 limit = memory_limit;
717 if (! limit) {
718 phys_addr_t memsize;
719
720
721
722 memblock_analyze();
723 memsize = memblock_phys_mem_size();
724 if ((memsize & PAGE_MASK) != memsize)
725 limit = memsize & PAGE_MASK;
726 }
727 memblock_enforce_memory_limit(limit);
728
729 memblock_analyze();
730 memblock_dump_all();
731
732 DBG("Phys. mem: %llx\n", memblock_phys_mem_size());
733
734
735
736 move_device_tree();
737
738 allocate_pacas();
739
740 DBG("Scanning CPUs ...\n");
741
742
743
744
745 of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
746
747 DBG(" <- early_init_devtree()\n");
748}
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769struct device_node *of_find_next_cache_node(struct device_node *np)
770{
771 struct device_node *child;
772 const phandle *handle;
773
774 handle = of_get_property(np, "l2-cache", NULL);
775 if (!handle)
776 handle = of_get_property(np, "next-level-cache", NULL);
777
778 if (handle)
779 return of_find_node_by_phandle(*handle);
780
781
782
783
784 if (!strcmp(np->type, "cpu"))
785 for_each_child_of_node(np, child)
786 if (!strcmp(child->type, "cache"))
787 return child;
788
789 return NULL;
790}
791
792#ifdef CONFIG_PPC_PSERIES
793
794
795
796
797
798static int of_finish_dynamic_node(struct device_node *node)
799{
800 struct device_node *parent = of_get_parent(node);
801 int err = 0;
802 const phandle *ibm_phandle;
803
804 node->name = of_get_property(node, "name", NULL);
805 node->type = of_get_property(node, "device_type", NULL);
806
807 if (!node->name)
808 node->name = "<NULL>";
809 if (!node->type)
810 node->type = "<NULL>";
811
812 if (!parent) {
813 err = -ENODEV;
814 goto out;
815 }
816
817
818
819
820 if (machine_is(powermac))
821 return -ENODEV;
822
823
824 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
825 node->phandle = *ibm_phandle;
826
827out:
828 of_node_put(parent);
829 return err;
830}
831
832static int prom_reconfig_notifier(struct notifier_block *nb,
833 unsigned long action, void *node)
834{
835 int err;
836
837 switch (action) {
838 case PSERIES_RECONFIG_ADD:
839 err = of_finish_dynamic_node(node);
840 if (err < 0) {
841 printk(KERN_ERR "finish_node returned %d\n", err);
842 err = NOTIFY_BAD;
843 }
844 break;
845 default:
846 err = NOTIFY_DONE;
847 break;
848 }
849 return err;
850}
851
852static struct notifier_block prom_reconfig_nb = {
853 .notifier_call = prom_reconfig_notifier,
854 .priority = 10,
855};
856
857static int __init prom_reconfig_setup(void)
858{
859 return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
860}
861__initcall(prom_reconfig_setup);
862#endif
863
864
865
866
867
868struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
869{
870 int hardid;
871 struct device_node *np;
872
873 hardid = get_hard_smp_processor_id(cpu);
874
875 for_each_node_by_type(np, "cpu") {
876 const u32 *intserv;
877 unsigned int plen, t;
878
879
880
881
882 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
883 &plen);
884 if (intserv == NULL) {
885 const u32 *reg = of_get_property(np, "reg", NULL);
886 if (reg == NULL)
887 continue;
888 if (*reg == hardid) {
889 if (thread)
890 *thread = 0;
891 return np;
892 }
893 } else {
894 plen /= sizeof(u32);
895 for (t = 0; t < plen; t++) {
896 if (hardid == intserv[t]) {
897 if (thread)
898 *thread = t;
899 return np;
900 }
901 }
902 }
903 }
904 return NULL;
905}
906EXPORT_SYMBOL(of_get_cpu_node);
907
908#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
909static struct debugfs_blob_wrapper flat_dt_blob;
910
911static int __init export_flat_device_tree(void)
912{
913 struct dentry *d;
914
915 flat_dt_blob.data = initial_boot_params;
916 flat_dt_blob.size = initial_boot_params->totalsize;
917
918 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
919 powerpc_debugfs_root, &flat_dt_blob);
920 if (!d)
921 return 1;
922
923 return 0;
924}
925__initcall(export_flat_device_tree);
926#endif
927