1 // SPDX-License-Identifier: GPL-2.0
2 /* mdesc.c: Sun4V machine description handling.
4 * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
6 #include <linux/kernel.h>
7 #include <linux/types.h>
8 #include <linux/memblock.h>
9 #include <linux/log2.h>
10 #include <linux/list.h>
11 #include <linux/slab.h>
13 #include <linux/miscdevice.h>
14 #include <linux/bootmem.h>
15 #include <linux/export.h>
16 #include <linux/refcount.h>
18 #include <asm/cpudata.h>
19 #include <asm/hypervisor.h>
20 #include <asm/mdesc.h>
22 #include <linux/uaccess.h>
23 #include <asm/oplib.h>
27 /* Unlike the OBP device tree, the machine description is a full-on
28 * DAG. An arbitrary number of ARCs are possible from one
29 * node to other nodes and thus we can't use the OBP device_node
30 * data structure to represent these nodes inside of the kernel.
32 * Actually, it isn't even a DAG, because there are back pointers
33 * which create cycles in the graph.
35 * mdesc_hdr and mdesc_elem describe the layout of the data structure
36 * we get from the Hypervisor.
39 u32 version
; /* Transport version */
40 u32 node_sz
; /* node block size */
41 u32 name_sz
; /* name block size */
42 u32 data_sz
; /* data block size */
43 } __attribute__((aligned(16)));
47 #define MD_LIST_END 0x00
49 #define MD_NODE_END 0x45
51 #define MD_PROP_ARC 0x61
52 #define MD_PROP_VAL 0x76
53 #define MD_PROP_STR 0x73
54 #define MD_PROP_DATA 0x64
67 struct mdesc_mem_ops
{
68 struct mdesc_handle
*(*alloc
)(unsigned int mdesc_size
);
69 void (*free
)(struct mdesc_handle
*handle
);
73 struct list_head list
;
74 struct mdesc_mem_ops
*mops
;
77 unsigned int handle_size
;
78 struct mdesc_hdr mdesc
;
81 typedef int (*mdesc_node_info_get_f
)(struct mdesc_handle
*, u64
,
82 union md_node_info
*);
83 typedef void (*mdesc_node_info_rel_f
)(union md_node_info
*);
84 typedef bool (*mdesc_node_match_f
)(union md_node_info
*, union md_node_info
*);
88 mdesc_node_info_get_f get_info
;
89 mdesc_node_info_rel_f rel_info
;
90 mdesc_node_match_f node_match
;
93 static int get_vdev_port_node_info(struct mdesc_handle
*md
, u64 node
,
94 union md_node_info
*node_info
);
95 static void rel_vdev_port_node_info(union md_node_info
*node_info
);
96 static bool vdev_port_node_match(union md_node_info
*a_node_info
,
97 union md_node_info
*b_node_info
);
99 static int get_ds_port_node_info(struct mdesc_handle
*md
, u64 node
,
100 union md_node_info
*node_info
);
101 static void rel_ds_port_node_info(union md_node_info
*node_info
);
102 static bool ds_port_node_match(union md_node_info
*a_node_info
,
103 union md_node_info
*b_node_info
);
105 /* supported node types which can be registered */
106 static struct md_node_ops md_node_ops_table
[] = {
107 {"virtual-device-port", get_vdev_port_node_info
,
108 rel_vdev_port_node_info
, vdev_port_node_match
},
109 {"domain-services-port", get_ds_port_node_info
,
110 rel_ds_port_node_info
, ds_port_node_match
},
111 {NULL
, NULL
, NULL
, NULL
}
114 static void mdesc_get_node_ops(const char *node_name
,
115 mdesc_node_info_get_f
*get_info_f
,
116 mdesc_node_info_rel_f
*rel_info_f
,
117 mdesc_node_match_f
*match_f
)
133 for (i
= 0; md_node_ops_table
[i
].name
!= NULL
; i
++) {
134 if (strcmp(md_node_ops_table
[i
].name
, node_name
) == 0) {
136 *get_info_f
= md_node_ops_table
[i
].get_info
;
139 *rel_info_f
= md_node_ops_table
[i
].rel_info
;
142 *match_f
= md_node_ops_table
[i
].node_match
;
149 static void mdesc_handle_init(struct mdesc_handle
*hp
,
150 unsigned int handle_size
,
153 BUG_ON(((unsigned long)&hp
->mdesc
) & (16UL - 1));
155 memset(hp
, 0, handle_size
);
156 INIT_LIST_HEAD(&hp
->list
);
157 hp
->self_base
= base
;
158 refcount_set(&hp
->refcnt
, 1);
159 hp
->handle_size
= handle_size
;
162 static struct mdesc_handle
* __init
mdesc_memblock_alloc(unsigned int mdesc_size
)
164 unsigned int handle_size
, alloc_size
;
165 struct mdesc_handle
*hp
;
168 handle_size
= (sizeof(struct mdesc_handle
) -
169 sizeof(struct mdesc_hdr
) +
171 alloc_size
= PAGE_ALIGN(handle_size
);
173 paddr
= memblock_alloc(alloc_size
, PAGE_SIZE
);
178 mdesc_handle_init(hp
, handle_size
, hp
);
183 static void __init
mdesc_memblock_free(struct mdesc_handle
*hp
)
185 unsigned int alloc_size
;
188 BUG_ON(refcount_read(&hp
->refcnt
) != 0);
189 BUG_ON(!list_empty(&hp
->list
));
191 alloc_size
= PAGE_ALIGN(hp
->handle_size
);
193 free_bootmem_late(start
, alloc_size
);
196 static struct mdesc_mem_ops memblock_mdesc_ops
= {
197 .alloc
= mdesc_memblock_alloc
,
198 .free
= mdesc_memblock_free
,
201 static struct mdesc_handle
*mdesc_kmalloc(unsigned int mdesc_size
)
203 unsigned int handle_size
;
204 struct mdesc_handle
*hp
;
208 handle_size
= (sizeof(struct mdesc_handle
) -
209 sizeof(struct mdesc_hdr
) +
211 base
= kmalloc(handle_size
+ 15, GFP_KERNEL
| __GFP_RETRY_MAYFAIL
);
215 addr
= (unsigned long)base
;
216 addr
= (addr
+ 15UL) & ~15UL;
217 hp
= (struct mdesc_handle
*) addr
;
219 mdesc_handle_init(hp
, handle_size
, base
);
224 static void mdesc_kfree(struct mdesc_handle
*hp
)
226 BUG_ON(refcount_read(&hp
->refcnt
) != 0);
227 BUG_ON(!list_empty(&hp
->list
));
229 kfree(hp
->self_base
);
232 static struct mdesc_mem_ops kmalloc_mdesc_memops
= {
233 .alloc
= mdesc_kmalloc
,
237 static struct mdesc_handle
*mdesc_alloc(unsigned int mdesc_size
,
238 struct mdesc_mem_ops
*mops
)
240 struct mdesc_handle
*hp
= mops
->alloc(mdesc_size
);
248 static void mdesc_free(struct mdesc_handle
*hp
)
253 static struct mdesc_handle
*cur_mdesc
;
254 static LIST_HEAD(mdesc_zombie_list
);
255 static DEFINE_SPINLOCK(mdesc_lock
);
257 struct mdesc_handle
*mdesc_grab(void)
259 struct mdesc_handle
*hp
;
262 spin_lock_irqsave(&mdesc_lock
, flags
);
265 refcount_inc(&hp
->refcnt
);
266 spin_unlock_irqrestore(&mdesc_lock
, flags
);
270 EXPORT_SYMBOL(mdesc_grab
);
272 void mdesc_release(struct mdesc_handle
*hp
)
276 spin_lock_irqsave(&mdesc_lock
, flags
);
277 if (refcount_dec_and_test(&hp
->refcnt
)) {
278 list_del_init(&hp
->list
);
281 spin_unlock_irqrestore(&mdesc_lock
, flags
);
283 EXPORT_SYMBOL(mdesc_release
);
285 static DEFINE_MUTEX(mdesc_mutex
);
286 static struct mdesc_notifier_client
*client_list
;
288 void mdesc_register_notifier(struct mdesc_notifier_client
*client
)
290 bool supported
= false;
294 mutex_lock(&mdesc_mutex
);
296 /* check to see if the node is supported for registration */
297 for (i
= 0; md_node_ops_table
[i
].name
!= NULL
; i
++) {
298 if (strcmp(md_node_ops_table
[i
].name
, client
->node_name
) == 0) {
305 pr_err("MD: %s node not supported\n", client
->node_name
);
306 mutex_unlock(&mdesc_mutex
);
310 client
->next
= client_list
;
311 client_list
= client
;
313 mdesc_for_each_node_by_name(cur_mdesc
, node
, client
->node_name
)
314 client
->add(cur_mdesc
, node
, client
->node_name
);
316 mutex_unlock(&mdesc_mutex
);
319 static const u64
*parent_cfg_handle(struct mdesc_handle
*hp
, u64 node
)
325 mdesc_for_each_arc(a
, hp
, node
, MDESC_ARC_TYPE_BACK
) {
328 target
= mdesc_arc_target(hp
, a
);
329 id
= mdesc_get_property(hp
, target
,
338 static int get_vdev_port_node_info(struct mdesc_handle
*md
, u64 node
,
339 union md_node_info
*node_info
)
341 const u64
*parent_cfg_hdlp
;
346 * Virtual device nodes are distinguished by:
349 * 3. parent node "cfg-handle" property
351 idp
= mdesc_get_property(md
, node
, "id", NULL
);
352 name
= mdesc_get_property(md
, node
, "name", NULL
);
353 parent_cfg_hdlp
= parent_cfg_handle(md
, node
);
355 if (!idp
|| !name
|| !parent_cfg_hdlp
)
358 node_info
->vdev_port
.id
= *idp
;
359 node_info
->vdev_port
.name
= kstrdup_const(name
, GFP_KERNEL
);
360 node_info
->vdev_port
.parent_cfg_hdl
= *parent_cfg_hdlp
;
365 static void rel_vdev_port_node_info(union md_node_info
*node_info
)
367 if (node_info
&& node_info
->vdev_port
.name
) {
368 kfree_const(node_info
->vdev_port
.name
);
369 node_info
->vdev_port
.name
= NULL
;
373 static bool vdev_port_node_match(union md_node_info
*a_node_info
,
374 union md_node_info
*b_node_info
)
376 if (a_node_info
->vdev_port
.id
!= b_node_info
->vdev_port
.id
)
379 if (a_node_info
->vdev_port
.parent_cfg_hdl
!=
380 b_node_info
->vdev_port
.parent_cfg_hdl
)
383 if (strncmp(a_node_info
->vdev_port
.name
,
384 b_node_info
->vdev_port
.name
, MDESC_MAX_STR_LEN
) != 0)
390 static int get_ds_port_node_info(struct mdesc_handle
*md
, u64 node
,
391 union md_node_info
*node_info
)
395 /* DS port nodes use the "id" property to distinguish them */
396 idp
= mdesc_get_property(md
, node
, "id", NULL
);
400 node_info
->ds_port
.id
= *idp
;
405 static void rel_ds_port_node_info(union md_node_info
*node_info
)
409 static bool ds_port_node_match(union md_node_info
*a_node_info
,
410 union md_node_info
*b_node_info
)
412 if (a_node_info
->ds_port
.id
!= b_node_info
->ds_port
.id
)
418 /* Run 'func' on nodes which are in A but not in B. */
419 static void invoke_on_missing(const char *name
,
420 struct mdesc_handle
*a
,
421 struct mdesc_handle
*b
,
422 void (*func
)(struct mdesc_handle
*, u64
,
423 const char *node_name
))
425 mdesc_node_info_get_f get_info_func
;
426 mdesc_node_info_rel_f rel_info_func
;
427 mdesc_node_match_f node_match_func
;
428 union md_node_info a_node_info
;
429 union md_node_info b_node_info
;
436 * Find the get_info, rel_info and node_match ops for the given
439 mdesc_get_node_ops(name
, &get_info_func
, &rel_info_func
,
442 /* If we didn't find a match, the node type is not supported */
443 if (!get_info_func
|| !rel_info_func
|| !node_match_func
) {
444 pr_err("MD: %s node type is not supported\n", name
);
448 mdesc_for_each_node_by_name(a
, a_node
, name
) {
451 rv
= get_info_func(a
, a_node
, &a_node_info
);
453 pr_err("MD: Cannot find 1 or more required match properties for %s node.\n",
458 /* Check each node in B for node matching a_node */
459 mdesc_for_each_node_by_name(b
, b_node
, name
) {
460 rv
= get_info_func(b
, b_node
, &b_node_info
);
464 if (node_match_func(&a_node_info
, &b_node_info
)) {
466 rel_info_func(&b_node_info
);
470 rel_info_func(&b_node_info
);
473 rel_info_func(&a_node_info
);
476 func(a
, a_node
, name
);
480 static void notify_one(struct mdesc_notifier_client
*p
,
481 struct mdesc_handle
*old_hp
,
482 struct mdesc_handle
*new_hp
)
484 invoke_on_missing(p
->node_name
, old_hp
, new_hp
, p
->remove
);
485 invoke_on_missing(p
->node_name
, new_hp
, old_hp
, p
->add
);
488 static void mdesc_notify_clients(struct mdesc_handle
*old_hp
,
489 struct mdesc_handle
*new_hp
)
491 struct mdesc_notifier_client
*p
= client_list
;
494 notify_one(p
, old_hp
, new_hp
);
499 void mdesc_update(void)
501 unsigned long len
, real_len
, status
;
502 struct mdesc_handle
*hp
, *orig_hp
;
505 mutex_lock(&mdesc_mutex
);
507 (void) sun4v_mach_desc(0UL, 0UL, &len
);
509 hp
= mdesc_alloc(len
, &kmalloc_mdesc_memops
);
511 printk(KERN_ERR
"MD: mdesc alloc fails\n");
515 status
= sun4v_mach_desc(__pa(&hp
->mdesc
), len
, &real_len
);
516 if (status
!= HV_EOK
|| real_len
> len
) {
517 printk(KERN_ERR
"MD: mdesc reread fails with %lu\n",
519 refcount_dec(&hp
->refcnt
);
524 spin_lock_irqsave(&mdesc_lock
, flags
);
527 spin_unlock_irqrestore(&mdesc_lock
, flags
);
529 mdesc_notify_clients(orig_hp
, hp
);
531 spin_lock_irqsave(&mdesc_lock
, flags
);
532 if (refcount_dec_and_test(&orig_hp
->refcnt
))
535 list_add(&orig_hp
->list
, &mdesc_zombie_list
);
536 spin_unlock_irqrestore(&mdesc_lock
, flags
);
539 mutex_unlock(&mdesc_mutex
);
542 u64
mdesc_get_node(struct mdesc_handle
*hp
, const char *node_name
,
543 union md_node_info
*node_info
)
545 mdesc_node_info_get_f get_info_func
;
546 mdesc_node_info_rel_f rel_info_func
;
547 mdesc_node_match_f node_match_func
;
548 union md_node_info hp_node_info
;
552 if (hp
== NULL
|| node_name
== NULL
|| node_info
== NULL
)
553 return MDESC_NODE_NULL
;
555 /* Find the ops for the given node name */
556 mdesc_get_node_ops(node_name
, &get_info_func
, &rel_info_func
,
559 /* If we didn't find ops for the given node name, it is not supported */
560 if (!get_info_func
|| !rel_info_func
|| !node_match_func
) {
561 pr_err("MD: %s node is not supported\n", node_name
);
565 mdesc_for_each_node_by_name(hp
, hp_node
, node_name
) {
566 rv
= get_info_func(hp
, hp_node
, &hp_node_info
);
570 if (node_match_func(node_info
, &hp_node_info
))
573 rel_info_func(&hp_node_info
);
576 rel_info_func(&hp_node_info
);
580 EXPORT_SYMBOL(mdesc_get_node
);
582 int mdesc_get_node_info(struct mdesc_handle
*hp
, u64 node
,
583 const char *node_name
, union md_node_info
*node_info
)
585 mdesc_node_info_get_f get_info_func
;
588 if (hp
== NULL
|| node
== MDESC_NODE_NULL
||
589 node_name
== NULL
|| node_info
== NULL
)
592 /* Find the get_info op for the given node name */
593 mdesc_get_node_ops(node_name
, &get_info_func
, NULL
, NULL
);
595 /* If we didn't find a get_info_func, the node name is not supported */
596 if (get_info_func
== NULL
) {
597 pr_err("MD: %s node is not supported\n", node_name
);
601 rv
= get_info_func(hp
, node
, node_info
);
603 pr_err("MD: Cannot find 1 or more required match properties for %s node.\n",
610 EXPORT_SYMBOL(mdesc_get_node_info
);
612 static struct mdesc_elem
*node_block(struct mdesc_hdr
*mdesc
)
614 return (struct mdesc_elem
*) (mdesc
+ 1);
617 static void *name_block(struct mdesc_hdr
*mdesc
)
619 return ((void *) node_block(mdesc
)) + mdesc
->node_sz
;
622 static void *data_block(struct mdesc_hdr
*mdesc
)
624 return ((void *) name_block(mdesc
)) + mdesc
->name_sz
;
627 u64
mdesc_node_by_name(struct mdesc_handle
*hp
,
628 u64 from_node
, const char *name
)
630 struct mdesc_elem
*ep
= node_block(&hp
->mdesc
);
631 const char *names
= name_block(&hp
->mdesc
);
632 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
635 if (from_node
== MDESC_NODE_NULL
) {
637 } else if (from_node
>= last_node
) {
638 return MDESC_NODE_NULL
;
640 ret
= ep
[from_node
].d
.val
;
643 while (ret
< last_node
) {
644 if (ep
[ret
].tag
!= MD_NODE
)
645 return MDESC_NODE_NULL
;
646 if (!strcmp(names
+ ep
[ret
].name_offset
, name
))
650 if (ret
>= last_node
)
651 ret
= MDESC_NODE_NULL
;
654 EXPORT_SYMBOL(mdesc_node_by_name
);
656 const void *mdesc_get_property(struct mdesc_handle
*hp
, u64 node
,
657 const char *name
, int *lenp
)
659 const char *names
= name_block(&hp
->mdesc
);
660 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
661 void *data
= data_block(&hp
->mdesc
);
662 struct mdesc_elem
*ep
;
664 if (node
== MDESC_NODE_NULL
|| node
>= last_node
)
667 ep
= node_block(&hp
->mdesc
) + node
;
669 for (; ep
->tag
!= MD_NODE_END
; ep
++) {
681 val
= data
+ ep
->d
.data
.data_offset
;
682 len
= ep
->d
.data
.data_len
;
691 if (!strcmp(names
+ ep
->name_offset
, name
)) {
700 EXPORT_SYMBOL(mdesc_get_property
);
702 u64
mdesc_next_arc(struct mdesc_handle
*hp
, u64 from
, const char *arc_type
)
704 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
705 const char *names
= name_block(&hp
->mdesc
);
706 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
708 if (from
== MDESC_NODE_NULL
|| from
>= last_node
)
709 return MDESC_NODE_NULL
;
714 for (; ep
->tag
!= MD_NODE_END
; ep
++) {
715 if (ep
->tag
!= MD_PROP_ARC
)
718 if (strcmp(names
+ ep
->name_offset
, arc_type
))
724 return MDESC_NODE_NULL
;
726 EXPORT_SYMBOL(mdesc_next_arc
);
728 u64
mdesc_arc_target(struct mdesc_handle
*hp
, u64 arc
)
730 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
736 EXPORT_SYMBOL(mdesc_arc_target
);
738 const char *mdesc_node_name(struct mdesc_handle
*hp
, u64 node
)
740 struct mdesc_elem
*ep
, *base
= node_block(&hp
->mdesc
);
741 const char *names
= name_block(&hp
->mdesc
);
742 u64 last_node
= hp
->mdesc
.node_sz
/ 16;
744 if (node
== MDESC_NODE_NULL
|| node
>= last_node
)
748 if (ep
->tag
!= MD_NODE
)
751 return names
+ ep
->name_offset
;
753 EXPORT_SYMBOL(mdesc_node_name
);
755 static u64 max_cpus
= 64;
757 static void __init
report_platform_properties(void)
759 struct mdesc_handle
*hp
= mdesc_grab();
760 u64 pn
= mdesc_node_by_name(hp
, MDESC_NODE_NULL
, "platform");
764 if (pn
== MDESC_NODE_NULL
) {
765 prom_printf("No platform node in machine-description.\n");
769 s
= mdesc_get_property(hp
, pn
, "banner-name", NULL
);
770 printk("PLATFORM: banner-name [%s]\n", s
);
771 s
= mdesc_get_property(hp
, pn
, "name", NULL
);
772 printk("PLATFORM: name [%s]\n", s
);
774 v
= mdesc_get_property(hp
, pn
, "hostid", NULL
);
776 printk("PLATFORM: hostid [%08llx]\n", *v
);
777 v
= mdesc_get_property(hp
, pn
, "serial#", NULL
);
779 printk("PLATFORM: serial# [%08llx]\n", *v
);
780 v
= mdesc_get_property(hp
, pn
, "stick-frequency", NULL
);
781 printk("PLATFORM: stick-frequency [%08llx]\n", *v
);
782 v
= mdesc_get_property(hp
, pn
, "mac-address", NULL
);
784 printk("PLATFORM: mac-address [%llx]\n", *v
);
785 v
= mdesc_get_property(hp
, pn
, "watchdog-resolution", NULL
);
787 printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v
);
788 v
= mdesc_get_property(hp
, pn
, "watchdog-max-timeout", NULL
);
790 printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v
);
791 v
= mdesc_get_property(hp
, pn
, "max-cpus", NULL
);
794 printk("PLATFORM: max-cpus [%llu]\n", max_cpus
);
803 if (max_cpu
> NR_CPUS
)
808 for (i
= 0; i
< max_cpu
; i
++)
809 set_cpu_possible(i
, true);
816 static void fill_in_one_cache(cpuinfo_sparc
*c
, struct mdesc_handle
*hp
, u64 mp
)
818 const u64
*level
= mdesc_get_property(hp
, mp
, "level", NULL
);
819 const u64
*size
= mdesc_get_property(hp
, mp
, "size", NULL
);
820 const u64
*line_size
= mdesc_get_property(hp
, mp
, "line-size", NULL
);
824 type
= mdesc_get_property(hp
, mp
, "type", &type_len
);
828 if (of_find_in_proplist(type
, "instn", type_len
)) {
829 c
->icache_size
= *size
;
830 c
->icache_line_size
= *line_size
;
831 } else if (of_find_in_proplist(type
, "data", type_len
)) {
832 c
->dcache_size
= *size
;
833 c
->dcache_line_size
= *line_size
;
838 c
->ecache_size
= *size
;
839 c
->ecache_line_size
= *line_size
;
849 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_FWD
) {
850 u64 target
= mdesc_arc_target(hp
, a
);
851 const char *name
= mdesc_node_name(hp
, target
);
853 if (!strcmp(name
, "cache"))
854 fill_in_one_cache(c
, hp
, target
);
859 static void find_back_node_value(struct mdesc_handle
*hp
, u64 node
,
861 void (*func
)(struct mdesc_handle
*, u64
, int),
866 /* Since we have an estimate of recursion depth, do a sanity check. */
870 mdesc_for_each_arc(arc
, hp
, node
, MDESC_ARC_TYPE_BACK
) {
871 u64 n
= mdesc_arc_target(hp
, arc
);
872 const char *name
= mdesc_node_name(hp
, n
);
874 if (!strcmp(srch_val
, name
))
877 find_back_node_value(hp
, n
, srch_val
, func
, val
, depth
-1);
881 static void __mark_core_id(struct mdesc_handle
*hp
, u64 node
,
884 const u64
*id
= mdesc_get_property(hp
, node
, "id", NULL
);
886 if (*id
< num_possible_cpus())
887 cpu_data(*id
).core_id
= core_id
;
890 static void __mark_max_cache_id(struct mdesc_handle
*hp
, u64 node
,
893 const u64
*id
= mdesc_get_property(hp
, node
, "id", NULL
);
895 if (*id
< num_possible_cpus()) {
896 cpu_data(*id
).max_cache_id
= max_cache_id
;
899 * On systems without explicit socket descriptions socket
902 cpu_data(*id
).sock_id
= max_cache_id
;
906 static void mark_core_ids(struct mdesc_handle
*hp
, u64 mp
,
909 find_back_node_value(hp
, mp
, "cpu", __mark_core_id
, core_id
, 10);
912 static void mark_max_cache_ids(struct mdesc_handle
*hp
, u64 mp
,
915 find_back_node_value(hp
, mp
, "cpu", __mark_max_cache_id
,
919 static void set_core_ids(struct mdesc_handle
*hp
)
926 /* Identify unique cores by looking for cpus backpointed to by
927 * level 1 instruction caches.
929 mdesc_for_each_node_by_name(hp
, mp
, "cache") {
934 level
= mdesc_get_property(hp
, mp
, "level", NULL
);
938 type
= mdesc_get_property(hp
, mp
, "type", &len
);
939 if (!of_find_in_proplist(type
, "instn", len
))
942 mark_core_ids(hp
, mp
, idx
);
947 static int set_max_cache_ids_by_cache(struct mdesc_handle
*hp
, int level
)
954 * Identify unique highest level of shared cache by looking for cpus
955 * backpointed to by shared level N caches.
957 mdesc_for_each_node_by_name(hp
, mp
, "cache") {
960 cur_lvl
= mdesc_get_property(hp
, mp
, "level", NULL
);
961 if (*cur_lvl
!= level
)
963 mark_max_cache_ids(hp
, mp
, idx
);
970 static void set_sock_ids_by_socket(struct mdesc_handle
*hp
, u64 mp
)
974 mdesc_for_each_node_by_name(hp
, mp
, "socket") {
977 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_FWD
) {
978 u64 t
= mdesc_arc_target(hp
, a
);
982 name
= mdesc_node_name(hp
, t
);
983 if (strcmp(name
, "cpu"))
986 id
= mdesc_get_property(hp
, t
, "id", NULL
);
987 if (*id
< num_possible_cpus())
988 cpu_data(*id
).sock_id
= idx
;
994 static void set_sock_ids(struct mdesc_handle
*hp
)
999 * Find the highest level of shared cache which pre-T7 is also
1002 if (!set_max_cache_ids_by_cache(hp
, 3))
1003 set_max_cache_ids_by_cache(hp
, 2);
1005 /* If machine description exposes sockets data use it.*/
1006 mp
= mdesc_node_by_name(hp
, MDESC_NODE_NULL
, "sockets");
1007 if (mp
!= MDESC_NODE_NULL
)
1008 set_sock_ids_by_socket(hp
, mp
);
1011 static void mark_proc_ids(struct mdesc_handle
*hp
, u64 mp
, int proc_id
)
1015 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_BACK
) {
1016 u64 t
= mdesc_arc_target(hp
, a
);
1020 name
= mdesc_node_name(hp
, t
);
1021 if (strcmp(name
, "cpu"))
1024 id
= mdesc_get_property(hp
, t
, "id", NULL
);
1026 cpu_data(*id
).proc_id
= proc_id
;
1030 static void __set_proc_ids(struct mdesc_handle
*hp
, const char *exec_unit_name
)
1036 mdesc_for_each_node_by_name(hp
, mp
, exec_unit_name
) {
1040 type
= mdesc_get_property(hp
, mp
, "type", &len
);
1041 if (!of_find_in_proplist(type
, "int", len
) &&
1042 !of_find_in_proplist(type
, "integer", len
))
1045 mark_proc_ids(hp
, mp
, idx
);
1050 static void set_proc_ids(struct mdesc_handle
*hp
)
1052 __set_proc_ids(hp
, "exec_unit");
1053 __set_proc_ids(hp
, "exec-unit");
1056 static void get_one_mondo_bits(const u64
*p
, unsigned int *mask
,
1057 unsigned long def
, unsigned long max
)
1065 if (!val
|| val
>= 64)
1071 *mask
= ((1U << val
) * 64U) - 1U;
1075 *mask
= ((1U << def
) * 64U) - 1U;
1078 static void get_mondo_data(struct mdesc_handle
*hp
, u64 mp
,
1079 struct trap_per_cpu
*tb
)
1084 val
= mdesc_get_property(hp
, mp
, "q-cpu-mondo-#bits", NULL
);
1085 get_one_mondo_bits(val
, &tb
->cpu_mondo_qmask
, 7, ilog2(max_cpus
* 2));
1087 val
= mdesc_get_property(hp
, mp
, "q-dev-mondo-#bits", NULL
);
1088 get_one_mondo_bits(val
, &tb
->dev_mondo_qmask
, 7, 8);
1090 val
= mdesc_get_property(hp
, mp
, "q-resumable-#bits", NULL
);
1091 get_one_mondo_bits(val
, &tb
->resum_qmask
, 6, 7);
1093 val
= mdesc_get_property(hp
, mp
, "q-nonresumable-#bits", NULL
);
1094 get_one_mondo_bits(val
, &tb
->nonresum_qmask
, 2, 2);
1096 pr_info("SUN4V: Mondo queue sizes "
1097 "[cpu(%u) dev(%u) r(%u) nr(%u)]\n",
1098 tb
->cpu_mondo_qmask
+ 1,
1099 tb
->dev_mondo_qmask
+ 1,
1100 tb
->resum_qmask
+ 1,
1101 tb
->nonresum_qmask
+ 1);
1105 static void *mdesc_iterate_over_cpus(void *(*func
)(struct mdesc_handle
*, u64
, int, void *), void *arg
, cpumask_t
*mask
)
1107 struct mdesc_handle
*hp
= mdesc_grab();
1111 mdesc_for_each_node_by_name(hp
, mp
, "cpu") {
1112 const u64
*id
= mdesc_get_property(hp
, mp
, "id", NULL
);
1116 if (cpuid
>= NR_CPUS
) {
1117 printk(KERN_WARNING
"Ignoring CPU %d which is "
1118 ">= NR_CPUS (%d)\n",
1122 if (!cpumask_test_cpu(cpuid
, mask
))
1126 ret
= func(hp
, mp
, cpuid
, arg
);
1135 static void *record_one_cpu(struct mdesc_handle
*hp
, u64 mp
, int cpuid
,
1140 set_cpu_present(cpuid
, true);
1145 void mdesc_populate_present_mask(cpumask_t
*mask
)
1147 if (tlb_type
!= hypervisor
)
1151 mdesc_iterate_over_cpus(record_one_cpu
, NULL
, mask
);
1154 static void * __init
check_one_pgsz(struct mdesc_handle
*hp
, u64 mp
, int cpuid
, void *arg
)
1156 const u64
*pgsz_prop
= mdesc_get_property(hp
, mp
, "mmu-page-size-list", NULL
);
1157 unsigned long *pgsz_mask
= arg
;
1160 val
= (HV_PGSZ_MASK_8K
| HV_PGSZ_MASK_64K
|
1161 HV_PGSZ_MASK_512K
| HV_PGSZ_MASK_4MB
);
1172 void __init
mdesc_get_page_sizes(cpumask_t
*mask
, unsigned long *pgsz_mask
)
1175 mdesc_iterate_over_cpus(check_one_pgsz
, pgsz_mask
, mask
);
1178 static void *fill_in_one_cpu(struct mdesc_handle
*hp
, u64 mp
, int cpuid
,
1181 const u64
*cfreq
= mdesc_get_property(hp
, mp
, "clock-frequency", NULL
);
1182 struct trap_per_cpu
*tb
;
1187 /* On uniprocessor we only want the values for the
1188 * real physical cpu the kernel booted onto, however
1189 * cpu_data() only has one entry at index 0.
1191 if (cpuid
!= real_hard_smp_processor_id())
1196 c
= &cpu_data(cpuid
);
1197 c
->clock_tick
= *cfreq
;
1199 tb
= &trap_block
[cpuid
];
1200 get_mondo_data(hp
, mp
, tb
);
1202 mdesc_for_each_arc(a
, hp
, mp
, MDESC_ARC_TYPE_FWD
) {
1203 u64 j
, t
= mdesc_arc_target(hp
, a
);
1206 t_name
= mdesc_node_name(hp
, t
);
1207 if (!strcmp(t_name
, "cache")) {
1208 fill_in_one_cache(c
, hp
, t
);
1212 mdesc_for_each_arc(j
, hp
, t
, MDESC_ARC_TYPE_FWD
) {
1213 u64 n
= mdesc_arc_target(hp
, j
);
1216 n_name
= mdesc_node_name(hp
, n
);
1217 if (!strcmp(n_name
, "cache"))
1218 fill_in_one_cache(c
, hp
, n
);
1228 void mdesc_fill_in_cpu_data(cpumask_t
*mask
)
1230 struct mdesc_handle
*hp
;
1232 mdesc_iterate_over_cpus(fill_in_one_cpu
, NULL
, mask
);
1242 smp_fill_in_sib_core_maps();
1245 /* mdesc_open() - Grab a reference to mdesc_handle when /dev/mdesc is
1246 * opened. Hold this reference until /dev/mdesc is closed to ensure
1247 * mdesc data structure is not released underneath us. Store the
1248 * pointer to mdesc structure in private_data for read and seek to use
1250 static int mdesc_open(struct inode
*inode
, struct file
*file
)
1252 struct mdesc_handle
*hp
= mdesc_grab();
1257 file
->private_data
= hp
;
1262 static ssize_t
mdesc_read(struct file
*file
, char __user
*buf
,
1263 size_t len
, loff_t
*offp
)
1265 struct mdesc_handle
*hp
= file
->private_data
;
1266 unsigned char *mdesc
;
1267 int bytes_left
, count
= len
;
1269 if (*offp
>= hp
->handle_size
)
1272 bytes_left
= hp
->handle_size
- *offp
;
1273 if (count
> bytes_left
)
1276 mdesc
= (unsigned char *)&hp
->mdesc
;
1278 if (!copy_to_user(buf
, mdesc
, count
)) {
1286 static loff_t
mdesc_llseek(struct file
*file
, loff_t offset
, int whence
)
1288 struct mdesc_handle
*hp
= file
->private_data
;
1290 return no_seek_end_llseek_size(file
, offset
, whence
, hp
->handle_size
);
1293 /* mdesc_close() - /dev/mdesc is being closed, release the reference to
1296 static int mdesc_close(struct inode
*inode
, struct file
*file
)
1298 mdesc_release(file
->private_data
);
1302 static const struct file_operations mdesc_fops
= {
1305 .llseek
= mdesc_llseek
,
1306 .release
= mdesc_close
,
1307 .owner
= THIS_MODULE
,
1310 static struct miscdevice mdesc_misc
= {
1311 .minor
= MISC_DYNAMIC_MINOR
,
1313 .fops
= &mdesc_fops
,
1316 static int __init
mdesc_misc_init(void)
1318 return misc_register(&mdesc_misc
);
1321 __initcall(mdesc_misc_init
);
1323 void __init
sun4v_mdesc_init(void)
1325 struct mdesc_handle
*hp
;
1326 unsigned long len
, real_len
, status
;
1328 (void) sun4v_mach_desc(0UL, 0UL, &len
);
1330 printk("MDESC: Size is %lu bytes.\n", len
);
1332 hp
= mdesc_alloc(len
, &memblock_mdesc_ops
);
1334 prom_printf("MDESC: alloc of %lu bytes failed.\n", len
);
1338 status
= sun4v_mach_desc(__pa(&hp
->mdesc
), len
, &real_len
);
1339 if (status
!= HV_EOK
|| real_len
> len
) {
1340 prom_printf("sun4v_mach_desc fails, err(%lu), "
1341 "len(%lu), real_len(%lu)\n",
1342 status
, len
, real_len
);
1350 report_platform_properties();