1 /* mdesc.c: Sun4V machine description handling.
3 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
5 #include <linux/kernel.h>
6 #include <linux/types.h>
7 #include <linux/bootmem.h>
8 #include <linux/log2.h>
9 #include <linux/list.h>
10 #include <linux/slab.h>
13 #include <asm/hypervisor.h>
14 #include <asm/mdesc.h>
16 #include <asm/oplib.h>
19 /* Unlike the OBP device tree, the machine description is a full-on
20 * DAG. An arbitrary number of ARCs are possible from one
21 * node to other nodes and thus we can't use the OBP device_node
22 * data structure to represent these nodes inside of the kernel.
24 * Actually, it isn't even a DAG, because there are back pointers
25 * which create cycles in the graph.
27 * mdesc_hdr and mdesc_elem describe the layout of the data structure
28 * we get from the Hypervisor.
31 u32 version
; /* Transport version */
32 u32 node_sz
; /* node block size */
33 u32 name_sz
; /* name block size */
34 u32 data_sz
; /* data block size */
35 } __attribute__((aligned(16)));
39 #define MD_LIST_END 0x00
41 #define MD_NODE_END 0x45
43 #define MD_PROP_ARC 0x61
44 #define MD_PROP_VAL 0x76
45 #define MD_PROP_STR 0x73
46 #define MD_PROP_DATA 0x64
59 struct mdesc_mem_ops
{
60 struct mdesc_handle
*(*alloc
)(unsigned int mdesc_size
);
61 void (*free
)(struct mdesc_handle
*handle
);
65 struct list_head list
;
66 struct mdesc_mem_ops
*mops
;
69 unsigned int handle_size
;
70 struct mdesc_hdr mdesc
;
73 static void mdesc_handle_init(struct mdesc_handle
*hp
,
74 unsigned int handle_size
,
77 BUG_ON(((unsigned long)&hp
->mdesc
) & (16UL - 1));
79 memset(hp
, 0, handle_size
);
80 INIT_LIST_HEAD(&hp
->list
);
82 atomic_set(&hp
->refcnt
, 1);
83 hp
->handle_size
= handle_size
;
86 static struct mdesc_handle
* __init
mdesc_bootmem_alloc(unsigned int mdesc_size
)
88 struct mdesc_handle
*hp
;
89 unsigned int handle_size
, alloc_size
;
91 handle_size
= (sizeof(struct mdesc_handle
) -
92 sizeof(struct mdesc_hdr
) +
94 alloc_size
= PAGE_ALIGN(handle_size
);
96 hp
= __alloc_bootmem(alloc_size
, PAGE_SIZE
, 0UL);
98 mdesc_handle_init(hp
, handle_size
, hp
);
103 static void mdesc_bootmem_free(struct mdesc_handle
*hp
)
105 unsigned int alloc_size
, handle_size
= hp
->handle_size
;
106 unsigned long start
, end
;
108 BUG_ON(atomic_read(&hp
->refcnt
) != 0);
109 BUG_ON(!list_empty(&hp
->list
));
111 alloc_size
= PAGE_ALIGN(handle_size
);
113 start
= (unsigned long) hp
;
114 end
= start
+ alloc_size
;
116 while (start
< end
) {
119 p
= virt_to_page(start
);
120 ClearPageReserved(p
);
126 static struct mdesc_mem_ops bootmem_mdesc_ops
= {
127 .alloc
= mdesc_bootmem_alloc
,
128 .free
= mdesc_bootmem_free
,
131 static struct mdesc_handle
*mdesc_kmalloc(unsigned int mdesc_size
)
133 unsigned int handle_size
;
136 handle_size
= (sizeof(struct mdesc_handle
) -
137 sizeof(struct mdesc_hdr
) +
140 base
= kmalloc(handle_size
+ 15, GFP_KERNEL
| __GFP_NOFAIL
);
142 struct mdesc_handle
*hp
;
145 addr
= (unsigned long)base
;
146 addr
= (addr
+ 15UL) & ~15UL;
147 hp
= (struct mdesc_handle
*) addr
;
149 mdesc_handle_init(hp
, handle_size
, base
);
156 static void mdesc_kfree(struct mdesc_handle
*hp
)
158 BUG_ON(atomic_read(&hp
->refcnt
) != 0);
159 BUG_ON(!list_empty(&hp
->list
));
161 kfree(hp
->self_base
);
164 static struct mdesc_mem_ops kmalloc_mdesc_memops
= {
165 .alloc
= mdesc_kmalloc
,
169 static struct mdesc_handle
*mdesc_alloc(unsigned int mdesc_size
,
170 struct mdesc_mem_ops
*mops
)
172 struct mdesc_handle
*hp
= mops
->alloc(mdesc_size
);
180 static void mdesc_free(struct mdesc_handle
*hp
)
185 static struct mdesc_handle
*cur_mdesc
;
186 static LIST_HEAD(mdesc_zombie_list
);
187 static DEFINE_SPINLOCK(mdesc_lock
);
189 struct mdesc_handle
*mdesc_grab(void)
191 struct mdesc_handle
*hp
;
194 spin_lock_irqsave(&mdesc_lock
, flags
);
197 atomic_inc(&hp
->refcnt
);
198 spin_unlock_irqrestore(&mdesc_lock
, flags
);
202 EXPORT_SYMBOL(mdesc_grab
);
204 void mdesc_release(struct mdesc_handle
*hp
)
208 spin_lock_irqsave(&mdesc_lock
, flags
);
209 if (atomic_dec_and_test(&hp
->refcnt
)) {
210 list_del_init(&hp
->list
);
213 spin_unlock_irqrestore(&mdesc_lock
, flags
);
215 EXPORT_SYMBOL(mdesc_release
);
217 static DEFINE_MUTEX(mdesc_mutex
);
218 static struct mdesc_notifier_client
*client_list
;
220 void mdesc_register_notifier(struct mdesc_notifier_client
*client
)
224 mutex_lock(&mdesc_mutex
);
225 client
->next
= client_list
;
226 client_list
= client
;
228 mdesc_for_each_node_by_name(cur_mdesc
, node
, client
->node_name
)
229 client
->add(cur_mdesc
, node
);
231 mutex_unlock(&mdesc_mutex
);
234 static const u64
*parent_cfg_handle(struct mdesc_handle
*hp
, u64 node
)
240 mdesc_for_each_arc(a
, hp
, node
, MDESC_ARC_TYPE_BACK
) {
243 target
= mdesc_arc_target(hp
, a
);
244 id
= mdesc_get_property(hp
, target
,
253 /* Run 'func' on nodes which are in A but not in B. */
254 static void invoke_on_missing(const char *name
,
255 struct mdesc_handle
*a
,
256 struct mdesc_handle
*b
,
257 void (*func
)(struct mdesc_handle
*, u64
))
261 mdesc_for_each_node_by_name(a
, node
, name
) {
262 int found
= 0, is_vdc_port
= 0;
263 const char *name_prop
;
267 name_prop
= mdesc_get_property(a
, node
, "name", NULL
);
268 if (name_prop
&& !strcmp(name_prop
, "vdc-port")) {
270 id
= parent_cfg_handle(a
, node
);
272 id
= mdesc_get_property(a
, node
, "id", NULL
);
275 printk(KERN_ERR
"MD: Cannot find ID for %s node.\n",
276 (name_prop
? name_prop
: name
));
280 mdesc_for_each_node_by_name(b
, fnode
, name
) {
284 name_prop
= mdesc_get_property(b
, fnode
,
287 strcmp(name_prop
, "vdc-port"))
289 fid
= parent_cfg_handle(b
, fnode
);
291 printk(KERN_ERR
"MD: Cannot find ID "
292 "for vdc-port node.\n");
296 fid
= mdesc_get_property(b
, fnode
,
309 static void notify_one(struct mdesc_notifier_client
*p
,
310 struct mdesc_handle
*old_hp
,
311 struct mdesc_handle
*new_hp
)
313 invoke_on_missing(p
->node_name
, old_hp
, new_hp
, p
->remove
);
314 invoke_on_missing(p
->node_name
, new_hp
, old_hp
, p
->add
);
317 static void mdesc_notify_clients(struct mdesc_handle
*old_hp
,
318 struct mdesc_handle
*new_hp
)
320 struct mdesc_notifier_client
*p
= client_list
;
323 notify_one(p
, old_hp
, new_hp
);
328 void mdesc_update(void)
330 unsigned long len
, real_len
, status
;
331 struct mdesc_handle
*hp
, *orig_hp
;
334 mutex_lock(&mdesc_mutex
);
336 (void) sun4v_mach_desc(0UL, 0UL, &len
);
338 hp
= mdesc_alloc(len
, &kmalloc_mdesc_memops
);
340 printk(KERN_ERR
"MD: mdesc alloc fails\n");
344 status
= sun4v_mach_desc(__pa(&hp
->mdesc
), len
, &real_len
);
345 if (status
!= HV_EOK
|| real_len
> len
) {
346 printk(KERN_ERR
"MD: mdesc reread fails with %lu\n",
348 atomic_dec(&hp
->refcnt
);
353 spin_lock_irqsave(&mdesc_lock
, flags
);
356 spin_unlock_irqrestore(&mdesc_lock
, flags
);
358 mdesc_notify_clients(orig_hp
, hp
);
360 spin_lock_irqsave(&mdesc_lock
, flags
);
361 if (atomic_dec_and_test(&orig_hp
->refcnt
))
364 list_add(&orig_hp
->list
, &mdesc_zombie_list
);
365 spin_unlock_irqrestore(&mdesc_lock
, flags
);
368 mutex_unlock(&mdesc_mutex
);
371 static struct mdesc_elem
*node_block(struct mdesc_hdr
*mdesc
)
373 return (struct mdesc_elem
*) (mdesc
+ 1);
376 static void *name_block(struct mdesc_hdr
*mdesc
)
378 return ((void *) node_block(mdesc
)) + mdesc
->node_sz
;
381 static void *data_block(struct mdesc_hdr
*mdesc
)
383 return ((void *) name_block(mdesc
)) + mdesc
->name_sz
;
386 u64
mdesc_node_by_name(struct mdesc_handle
*hp
,
387 u64 from_node
, const char *name
)
389 struct mdesc_elem
*ep
= node_block(&hp
->mdesc
);
390 const char *names
= name_block(&hp
->mdesc
);
391 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
394 if (from_node
== MDESC_NODE_NULL
) {
396 } else if (from_node
>= last_node
) {
397 return MDESC_NODE_NULL
;
399 ret
= ep
[from_node
].d
.val
;
402 while (ret
< last_node
) {
403 if (ep
[ret
].tag
!= MD_NODE
)
404 return MDESC_NODE_NULL
;
405 if (!strcmp(names
+ ep
[ret
].name_offset
, name
))
409 if (ret
>= last_node
)
410 ret
= MDESC_NODE_NULL
;
413 EXPORT_SYMBOL(mdesc_node_by_name
);
415 const void *mdesc_get_property(struct mdesc_handle
*hp
, u64 node
,
416 const char *name
, int *lenp
)
418 const char *names
= name_block(&hp
->mdesc
);
419 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
420 void *data
= data_block(&hp
->mdesc
);
421 struct mdesc_elem
*ep
;
423 if (node
== MDESC_NODE_NULL
|| node
>= last_node
)
426 ep
= node_block(&hp
->mdesc
) + node
;
428 for (; ep
->tag
!= MD_NODE_END
; ep
++) {
440 val
= data
+ ep
->d
.data
.data_offset
;
441 len
= ep
->d
.data
.data_len
;
450 if (!strcmp(names
+ ep
->name_offset
, name
)) {
459 EXPORT_SYMBOL(mdesc_get_property
);
461 u64
mdesc_next_arc(struct mdesc_handle
*hp
, u64 from
, const char *arc_type
)
463 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
464 const char *names
= name_block(&hp
->mdesc
);
465 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
467 if (from
== MDESC_NODE_NULL
|| from
>= last_node
)
468 return MDESC_NODE_NULL
;
473 for (; ep
->tag
!= MD_NODE_END
; ep
++) {
474 if (ep
->tag
!= MD_PROP_ARC
)
477 if (strcmp(names
+ ep
->name_offset
, arc_type
))
483 return MDESC_NODE_NULL
;
485 EXPORT_SYMBOL(mdesc_next_arc
);
487 u64
mdesc_arc_target(struct mdesc_handle
*hp
, u64 arc
)
489 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
495 EXPORT_SYMBOL(mdesc_arc_target
);
497 const char *mdesc_node_name(struct mdesc_handle
*hp
, u64 node
)
499 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
500 const char *names
= name_block(&hp
->mdesc
);
501 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
503 if (node
== MDESC_NODE_NULL
|| node
>= last_node
)
507 if (ep
->tag
!= MD_NODE
)
510 return names
+ ep
->name_offset
;
512 EXPORT_SYMBOL(mdesc_node_name
);
514 static void __init
report_platform_properties(void)
516 struct mdesc_handle
*hp
= mdesc_grab();
517 u64 pn
= mdesc_node_by_name(hp
, MDESC_NODE_NULL
, "platform");
521 if (pn
== MDESC_NODE_NULL
) {
522 prom_printf("No platform node in machine-description.\n");
526 s
= mdesc_get_property(hp
, pn
, "banner-name", NULL
);
527 printk("PLATFORM: banner-name [%s]\n", s
);
528 s
= mdesc_get_property(hp
, pn
, "name", NULL
);
529 printk("PLATFORM: name [%s]\n", s
);
531 v
= mdesc_get_property(hp
, pn
, "hostid", NULL
);
533 printk("PLATFORM: hostid [%08lx]\n", *v
);
534 v
= mdesc_get_property(hp
, pn
, "serial#", NULL
);
536 printk("PLATFORM: serial# [%08lx]\n", *v
);
537 v
= mdesc_get_property(hp
, pn
, "stick-frequency", NULL
);
538 printk("PLATFORM: stick-frequency [%08lx]\n", *v
);
539 v
= mdesc_get_property(hp
, pn
, "mac-address", NULL
);
541 printk("PLATFORM: mac-address [%lx]\n", *v
);
542 v
= mdesc_get_property(hp
, pn
, "watchdog-resolution", NULL
);
544 printk("PLATFORM: watchdog-resolution [%lu ms]\n", *v
);
545 v
= mdesc_get_property(hp
, pn
, "watchdog-max-timeout", NULL
);
547 printk("PLATFORM: watchdog-max-timeout [%lu ms]\n", *v
);
548 v
= mdesc_get_property(hp
, pn
, "max-cpus", NULL
);
550 printk("PLATFORM: max-cpus [%lu]\n", *v
);
558 if (max_cpu
> NR_CPUS
)
563 for (i
= 0; i
< max_cpu
; i
++)
564 cpu_set(i
, cpu_possible_map
);
571 static void __devinit
fill_in_one_cache(cpuinfo_sparc
*c
,
572 struct mdesc_handle
*hp
,
575 const u64
*level
= mdesc_get_property(hp
, mp
, "level", NULL
);
576 const u64
*size
= mdesc_get_property(hp
, mp
, "size", NULL
);
577 const u64
*line_size
= mdesc_get_property(hp
, mp
, "line-size", NULL
);
581 type
= mdesc_get_property(hp
, mp
, "type", &type_len
);
585 if (of_find_in_proplist(type
, "instn", type_len
)) {
586 c
->icache_size
= *size
;
587 c
->icache_line_size
= *line_size
;
588 } else if (of_find_in_proplist(type
, "data", type_len
)) {
589 c
->dcache_size
= *size
;
590 c
->dcache_line_size
= *line_size
;
595 c
->ecache_size
= *size
;
596 c
->ecache_line_size
= *line_size
;
606 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_FWD
) {
607 u64 target
= mdesc_arc_target(hp
, a
);
608 const char *name
= mdesc_node_name(hp
, target
);
610 if (!strcmp(name
, "cache"))
611 fill_in_one_cache(c
, hp
, target
);
616 static void __devinit
mark_core_ids(struct mdesc_handle
*hp
, u64 mp
,
621 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_BACK
) {
622 u64 t
= mdesc_arc_target(hp
, a
);
626 name
= mdesc_node_name(hp
, t
);
627 if (!strcmp(name
, "cpu")) {
628 id
= mdesc_get_property(hp
, t
, "id", NULL
);
630 cpu_data(*id
).core_id
= core_id
;
634 mdesc_for_each_arc(j
, hp
, t
, MDESC_ARC_TYPE_BACK
) {
635 u64 n
= mdesc_arc_target(hp
, j
);
638 n_name
= mdesc_node_name(hp
, n
);
639 if (strcmp(n_name
, "cpu"))
642 id
= mdesc_get_property(hp
, n
, "id", NULL
);
644 cpu_data(*id
).core_id
= core_id
;
650 static void __devinit
set_core_ids(struct mdesc_handle
*hp
)
656 mdesc_for_each_node_by_name(hp
, mp
, "cache") {
661 level
= mdesc_get_property(hp
, mp
, "level", NULL
);
665 type
= mdesc_get_property(hp
, mp
, "type", &len
);
666 if (!of_find_in_proplist(type
, "instn", len
))
669 mark_core_ids(hp
, mp
, idx
);
675 static void __devinit
mark_proc_ids(struct mdesc_handle
*hp
, u64 mp
,
680 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_BACK
) {
681 u64 t
= mdesc_arc_target(hp
, a
);
685 name
= mdesc_node_name(hp
, t
);
686 if (strcmp(name
, "cpu"))
689 id
= mdesc_get_property(hp
, t
, "id", NULL
);
691 cpu_data(*id
).proc_id
= proc_id
;
695 static void __devinit
__set_proc_ids(struct mdesc_handle
*hp
,
696 const char *exec_unit_name
)
702 mdesc_for_each_node_by_name(hp
, mp
, exec_unit_name
) {
706 type
= mdesc_get_property(hp
, mp
, "type", &len
);
707 if (!of_find_in_proplist(type
, "int", len
) &&
708 !of_find_in_proplist(type
, "integer", len
))
711 mark_proc_ids(hp
, mp
, idx
);
717 static void __devinit
set_proc_ids(struct mdesc_handle
*hp
)
719 __set_proc_ids(hp
, "exec_unit");
720 __set_proc_ids(hp
, "exec-unit");
723 static void __devinit
get_one_mondo_bits(const u64
*p
, unsigned int *mask
,
732 if (!val
|| val
>= 64)
735 *mask
= ((1U << val
) * 64U) - 1U;
739 *mask
= ((1U << def
) * 64U) - 1U;
742 static void __devinit
get_mondo_data(struct mdesc_handle
*hp
, u64 mp
,
743 struct trap_per_cpu
*tb
)
747 val
= mdesc_get_property(hp
, mp
, "q-cpu-mondo-#bits", NULL
);
748 get_one_mondo_bits(val
, &tb
->cpu_mondo_qmask
, 7);
750 val
= mdesc_get_property(hp
, mp
, "q-dev-mondo-#bits", NULL
);
751 get_one_mondo_bits(val
, &tb
->dev_mondo_qmask
, 7);
753 val
= mdesc_get_property(hp
, mp
, "q-resumable-#bits", NULL
);
754 get_one_mondo_bits(val
, &tb
->resum_qmask
, 6);
756 val
= mdesc_get_property(hp
, mp
, "q-nonresumable-#bits", NULL
);
757 get_one_mondo_bits(val
, &tb
->nonresum_qmask
, 2);
760 void __devinit
mdesc_fill_in_cpu_data(cpumask_t mask
)
762 struct mdesc_handle
*hp
= mdesc_grab();
766 mdesc_for_each_node_by_name(hp
, mp
, "cpu") {
767 const u64
*id
= mdesc_get_property(hp
, mp
, "id", NULL
);
768 const u64
*cfreq
= mdesc_get_property(hp
, mp
, "clock-frequency", NULL
);
769 struct trap_per_cpu
*tb
;
779 if (cpuid
>= NR_CPUS
)
781 if (!cpu_isset(cpuid
, mask
))
784 /* On uniprocessor we only want the values for the
785 * real physical cpu the kernel booted onto, however
786 * cpu_data() only has one entry at index 0.
788 if (cpuid
!= real_hard_smp_processor_id())
793 c
= &cpu_data(cpuid
);
794 c
->clock_tick
= *cfreq
;
796 tb
= &trap_block
[cpuid
];
797 get_mondo_data(hp
, mp
, tb
);
799 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_FWD
) {
800 u64 j
, t
= mdesc_arc_target(hp
, a
);
803 t_name
= mdesc_node_name(hp
, t
);
804 if (!strcmp(t_name
, "cache")) {
805 fill_in_one_cache(c
, hp
, t
);
809 mdesc_for_each_arc(j
, hp
, t
, MDESC_ARC_TYPE_FWD
) {
810 u64 n
= mdesc_arc_target(hp
, j
);
813 n_name
= mdesc_node_name(hp
, n
);
814 if (!strcmp(n_name
, "cache"))
815 fill_in_one_cache(c
, hp
, n
);
820 cpu_set(cpuid
, cpu_present_map
);
828 sparc64_multi_core
= 1;
834 smp_fill_in_sib_core_maps();
839 void __init
sun4v_mdesc_init(void)
841 struct mdesc_handle
*hp
;
842 unsigned long len
, real_len
, status
;
845 (void) sun4v_mach_desc(0UL, 0UL, &len
);
847 printk("MDESC: Size is %lu bytes.\n", len
);
849 hp
= mdesc_alloc(len
, &bootmem_mdesc_ops
);
851 prom_printf("MDESC: alloc of %lu bytes failed.\n", len
);
855 status
= sun4v_mach_desc(__pa(&hp
->mdesc
), len
, &real_len
);
856 if (status
!= HV_EOK
|| real_len
> len
) {
857 prom_printf("sun4v_mach_desc fails, err(%lu), "
858 "len(%lu), real_len(%lu)\n",
859 status
, len
, real_len
);
866 report_platform_properties();
869 mdesc_fill_in_cpu_data(mask
);