2007-05-25 16:49:59 -06:00
|
|
|
/* mdesc.c: Sun4V machine description handling.
|
|
|
|
*
|
2008-02-13 20:22:23 -07:00
|
|
|
* Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
|
2007-05-25 16:49:59 -06:00
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/types.h>
|
2010-07-11 22:36:09 -06:00
|
|
|
#include <linux/memblock.h>
|
2007-05-25 16:49:59 -06:00
|
|
|
#include <linux/log2.h>
|
2007-07-12 14:47:50 -06:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
2007-07-14 01:54:55 -06:00
|
|
|
#include <linux/mm.h>
|
2007-08-15 22:02:23 -06:00
|
|
|
#include <linux/miscdevice.h>
|
2009-12-11 02:16:46 -07:00
|
|
|
#include <linux/bootmem.h>
|
2011-07-18 13:57:46 -06:00
|
|
|
#include <linux/export.h>
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2008-12-26 16:33:07 -07:00
|
|
|
#include <asm/cpudata.h>
|
2007-05-25 16:49:59 -06:00
|
|
|
#include <asm/hypervisor.h>
|
|
|
|
#include <asm/mdesc.h>
|
|
|
|
#include <asm/prom.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2007-05-25 16:49:59 -06:00
|
|
|
#include <asm/oplib.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
|
|
|
|
/* Unlike the OBP device tree, the machine description is a full-on
|
|
|
|
* DAG. An arbitrary number of ARCs are possible from one
|
|
|
|
* node to other nodes and thus we can't use the OBP device_node
|
|
|
|
* data structure to represent these nodes inside of the kernel.
|
|
|
|
*
|
|
|
|
* Actually, it isn't even a DAG, because there are back pointers
|
|
|
|
* which create cycles in the graph.
|
|
|
|
*
|
|
|
|
* mdesc_hdr and mdesc_elem describe the layout of the data structure
|
|
|
|
* we get from the Hypervisor.
|
|
|
|
*/
|
|
|
|
struct mdesc_hdr {
|
|
|
|
u32 version; /* Transport version */
|
|
|
|
u32 node_sz; /* node block size */
|
|
|
|
u32 name_sz; /* name block size */
|
|
|
|
u32 data_sz; /* data block size */
|
2007-07-12 14:47:50 -06:00
|
|
|
} __attribute__((aligned(16)));
|
2007-05-25 16:49:59 -06:00
|
|
|
|
|
|
|
struct mdesc_elem {
|
|
|
|
u8 tag;
|
|
|
|
#define MD_LIST_END 0x00
|
|
|
|
#define MD_NODE 0x4e
|
|
|
|
#define MD_NODE_END 0x45
|
|
|
|
#define MD_NOOP 0x20
|
|
|
|
#define MD_PROP_ARC 0x61
|
|
|
|
#define MD_PROP_VAL 0x76
|
|
|
|
#define MD_PROP_STR 0x73
|
|
|
|
#define MD_PROP_DATA 0x64
|
|
|
|
u8 name_len;
|
|
|
|
u16 resv;
|
|
|
|
u32 name_offset;
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
u32 data_len;
|
|
|
|
u32 data_offset;
|
|
|
|
} data;
|
|
|
|
u64 val;
|
|
|
|
} d;
|
|
|
|
};
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_mem_ops {
|
|
|
|
struct mdesc_handle *(*alloc)(unsigned int mdesc_size);
|
|
|
|
void (*free)(struct mdesc_handle *handle);
|
|
|
|
};
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle {
|
|
|
|
struct list_head list;
|
|
|
|
struct mdesc_mem_ops *mops;
|
|
|
|
void *self_base;
|
|
|
|
atomic_t refcnt;
|
|
|
|
unsigned int handle_size;
|
|
|
|
struct mdesc_hdr mdesc;
|
|
|
|
};
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static void mdesc_handle_init(struct mdesc_handle *hp,
|
|
|
|
unsigned int handle_size,
|
|
|
|
void *base)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
BUG_ON(((unsigned long)&hp->mdesc) & (16UL - 1));
|
|
|
|
|
|
|
|
memset(hp, 0, handle_size);
|
|
|
|
INIT_LIST_HEAD(&hp->list);
|
|
|
|
hp->self_base = base;
|
|
|
|
atomic_set(&hp->refcnt, 1);
|
|
|
|
hp->handle_size = handle_size;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2010-07-11 22:36:09 -06:00
|
|
|
static struct mdesc_handle * __init mdesc_memblock_alloc(unsigned int mdesc_size)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
unsigned int handle_size, alloc_size;
|
2008-02-13 20:22:23 -07:00
|
|
|
struct mdesc_handle *hp;
|
|
|
|
unsigned long paddr;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
handle_size = (sizeof(struct mdesc_handle) -
|
|
|
|
sizeof(struct mdesc_hdr) +
|
|
|
|
mdesc_size);
|
|
|
|
alloc_size = PAGE_ALIGN(handle_size);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2010-07-11 22:36:09 -06:00
|
|
|
paddr = memblock_alloc(alloc_size, PAGE_SIZE);
|
2007-07-12 14:47:50 -06:00
|
|
|
|
2008-02-13 20:22:23 -07:00
|
|
|
hp = NULL;
|
|
|
|
if (paddr) {
|
|
|
|
hp = __va(paddr);
|
|
|
|
mdesc_handle_init(hp, handle_size, hp);
|
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
return hp;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2011-03-30 18:37:56 -06:00
|
|
|
static void __init mdesc_memblock_free(struct mdesc_handle *hp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2009-12-11 02:16:46 -07:00
|
|
|
unsigned int alloc_size;
|
|
|
|
unsigned long start;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
BUG_ON(atomic_read(&hp->refcnt) != 0);
|
|
|
|
BUG_ON(!list_empty(&hp->list));
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2009-12-11 02:16:46 -07:00
|
|
|
alloc_size = PAGE_ALIGN(hp->handle_size);
|
|
|
|
start = __pa(hp);
|
|
|
|
free_bootmem_late(start, alloc_size);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2010-07-11 22:36:09 -06:00
|
|
|
static struct mdesc_mem_ops memblock_mdesc_ops = {
|
|
|
|
.alloc = mdesc_memblock_alloc,
|
|
|
|
.free = mdesc_memblock_free,
|
2007-07-12 14:47:50 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
unsigned int handle_size;
|
2015-04-14 16:47:11 -06:00
|
|
|
struct mdesc_handle *hp;
|
|
|
|
unsigned long addr;
|
2007-07-12 14:47:50 -06:00
|
|
|
void *base;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
handle_size = (sizeof(struct mdesc_handle) -
|
|
|
|
sizeof(struct mdesc_hdr) +
|
|
|
|
mdesc_size);
|
|
|
|
|
2015-04-14 16:47:11 -06:00
|
|
|
/*
|
|
|
|
* Allocation has to succeed because mdesc update would be missed
|
|
|
|
* and such events are not retransmitted.
|
|
|
|
*/
|
2007-07-17 22:37:35 -06:00
|
|
|
base = kmalloc(handle_size + 15, GFP_KERNEL | __GFP_NOFAIL);
|
2015-04-14 16:47:11 -06:00
|
|
|
addr = (unsigned long)base;
|
|
|
|
addr = (addr + 15UL) & ~15UL;
|
|
|
|
hp = (struct mdesc_handle *) addr;
|
2007-07-12 14:47:50 -06:00
|
|
|
|
2015-04-14 16:47:11 -06:00
|
|
|
mdesc_handle_init(hp, handle_size, base);
|
2007-07-12 14:47:50 -06:00
|
|
|
|
2015-04-14 16:47:11 -06:00
|
|
|
return hp;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static void mdesc_kfree(struct mdesc_handle *hp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
BUG_ON(atomic_read(&hp->refcnt) != 0);
|
|
|
|
BUG_ON(!list_empty(&hp->list));
|
|
|
|
|
|
|
|
kfree(hp->self_base);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static struct mdesc_mem_ops kmalloc_mdesc_memops = {
|
|
|
|
.alloc = mdesc_kmalloc,
|
|
|
|
.free = mdesc_kfree,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct mdesc_handle *mdesc_alloc(unsigned int mdesc_size,
|
|
|
|
struct mdesc_mem_ops *mops)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle *hp = mops->alloc(mdesc_size);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (hp)
|
|
|
|
hp->mops = mops;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
return hp;
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static void mdesc_free(struct mdesc_handle *hp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
hp->mops->free(hp);
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static struct mdesc_handle *cur_mdesc;
|
|
|
|
static LIST_HEAD(mdesc_zombie_list);
|
|
|
|
static DEFINE_SPINLOCK(mdesc_lock);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle *mdesc_grab(void)
|
|
|
|
{
|
|
|
|
struct mdesc_handle *hp;
|
|
|
|
unsigned long flags;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
spin_lock_irqsave(&mdesc_lock, flags);
|
|
|
|
hp = cur_mdesc;
|
|
|
|
if (hp)
|
|
|
|
atomic_inc(&hp->refcnt);
|
|
|
|
spin_unlock_irqrestore(&mdesc_lock, flags);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
return hp;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
EXPORT_SYMBOL(mdesc_grab);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
void mdesc_release(struct mdesc_handle *hp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
unsigned long flags;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
spin_lock_irqsave(&mdesc_lock, flags);
|
|
|
|
if (atomic_dec_and_test(&hp->refcnt)) {
|
|
|
|
list_del_init(&hp->list);
|
|
|
|
hp->mops->free(hp);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
spin_unlock_irqrestore(&mdesc_lock, flags);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
EXPORT_SYMBOL(mdesc_release);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-17 22:37:35 -06:00
|
|
|
static DEFINE_MUTEX(mdesc_mutex);
|
|
|
|
static struct mdesc_notifier_client *client_list;
|
|
|
|
|
|
|
|
void mdesc_register_notifier(struct mdesc_notifier_client *client)
|
|
|
|
{
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
mutex_lock(&mdesc_mutex);
|
|
|
|
client->next = client_list;
|
|
|
|
client_list = client;
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(cur_mdesc, node, client->node_name)
|
|
|
|
client->add(cur_mdesc, node);
|
|
|
|
|
|
|
|
mutex_unlock(&mdesc_mutex);
|
|
|
|
}
|
|
|
|
|
2007-07-18 16:15:45 -06:00
|
|
|
static const u64 *parent_cfg_handle(struct mdesc_handle *hp, u64 node)
|
|
|
|
{
|
|
|
|
const u64 *id;
|
|
|
|
u64 a;
|
|
|
|
|
|
|
|
id = NULL;
|
|
|
|
mdesc_for_each_arc(a, hp, node, MDESC_ARC_TYPE_BACK) {
|
|
|
|
u64 target;
|
|
|
|
|
|
|
|
target = mdesc_arc_target(hp, a);
|
|
|
|
id = mdesc_get_property(hp, target,
|
|
|
|
"cfg-handle", NULL);
|
|
|
|
if (id)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2007-07-17 22:37:35 -06:00
|
|
|
/* Run 'func' on nodes which are in A but not in B. */
|
|
|
|
static void invoke_on_missing(const char *name,
|
|
|
|
struct mdesc_handle *a,
|
|
|
|
struct mdesc_handle *b,
|
|
|
|
void (*func)(struct mdesc_handle *, u64))
|
|
|
|
{
|
|
|
|
u64 node;
|
|
|
|
|
|
|
|
mdesc_for_each_node_by_name(a, node, name) {
|
2007-07-18 16:15:45 -06:00
|
|
|
int found = 0, is_vdc_port = 0;
|
|
|
|
const char *name_prop;
|
|
|
|
const u64 *id;
|
2007-07-17 22:37:35 -06:00
|
|
|
u64 fnode;
|
|
|
|
|
2007-07-18 16:15:45 -06:00
|
|
|
name_prop = mdesc_get_property(a, node, "name", NULL);
|
|
|
|
if (name_prop && !strcmp(name_prop, "vdc-port")) {
|
|
|
|
is_vdc_port = 1;
|
|
|
|
id = parent_cfg_handle(a, node);
|
|
|
|
} else
|
|
|
|
id = mdesc_get_property(a, node, "id", NULL);
|
|
|
|
|
|
|
|
if (!id) {
|
|
|
|
printk(KERN_ERR "MD: Cannot find ID for %s node.\n",
|
|
|
|
(name_prop ? name_prop : name));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-07-17 22:37:35 -06:00
|
|
|
mdesc_for_each_node_by_name(b, fnode, name) {
|
2007-07-18 16:15:45 -06:00
|
|
|
const u64 *fid;
|
|
|
|
|
|
|
|
if (is_vdc_port) {
|
|
|
|
name_prop = mdesc_get_property(b, fnode,
|
|
|
|
"name", NULL);
|
|
|
|
if (!name_prop ||
|
|
|
|
strcmp(name_prop, "vdc-port"))
|
|
|
|
continue;
|
|
|
|
fid = parent_cfg_handle(b, fnode);
|
|
|
|
if (!fid) {
|
|
|
|
printk(KERN_ERR "MD: Cannot find ID "
|
|
|
|
"for vdc-port node.\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
fid = mdesc_get_property(b, fnode,
|
|
|
|
"id", NULL);
|
2007-07-17 22:37:35 -06:00
|
|
|
|
|
|
|
if (*id == *fid) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
func(a, node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void notify_one(struct mdesc_notifier_client *p,
|
|
|
|
struct mdesc_handle *old_hp,
|
|
|
|
struct mdesc_handle *new_hp)
|
|
|
|
{
|
|
|
|
invoke_on_missing(p->node_name, old_hp, new_hp, p->remove);
|
|
|
|
invoke_on_missing(p->node_name, new_hp, old_hp, p->add);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mdesc_notify_clients(struct mdesc_handle *old_hp,
|
|
|
|
struct mdesc_handle *new_hp)
|
|
|
|
{
|
|
|
|
struct mdesc_notifier_client *p = client_list;
|
|
|
|
|
|
|
|
while (p) {
|
|
|
|
notify_one(p, old_hp, new_hp);
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-16 17:50:36 -06:00
|
|
|
void mdesc_update(void)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
unsigned long len, real_len, status;
|
|
|
|
struct mdesc_handle *hp, *orig_hp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2007-07-17 22:37:35 -06:00
|
|
|
mutex_lock(&mdesc_mutex);
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
(void) sun4v_mach_desc(0UL, 0UL, &len);
|
|
|
|
|
|
|
|
hp = mdesc_alloc(len, &kmalloc_mdesc_memops);
|
|
|
|
if (!hp) {
|
|
|
|
printk(KERN_ERR "MD: mdesc alloc fails\n");
|
2007-07-17 22:37:35 -06:00
|
|
|
goto out;
|
2007-07-12 14:47:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
|
|
|
|
if (status != HV_EOK || real_len > len) {
|
|
|
|
printk(KERN_ERR "MD: mdesc reread fails with %lu\n",
|
|
|
|
status);
|
|
|
|
atomic_dec(&hp->refcnt);
|
|
|
|
mdesc_free(hp);
|
2007-07-17 22:37:35 -06:00
|
|
|
goto out;
|
2007-07-12 14:47:50 -06:00
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
spin_lock_irqsave(&mdesc_lock, flags);
|
|
|
|
orig_hp = cur_mdesc;
|
|
|
|
cur_mdesc = hp;
|
2007-07-17 22:37:35 -06:00
|
|
|
spin_unlock_irqrestore(&mdesc_lock, flags);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-17 22:37:35 -06:00
|
|
|
mdesc_notify_clients(orig_hp, hp);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mdesc_lock, flags);
|
2007-07-12 14:47:50 -06:00
|
|
|
if (atomic_dec_and_test(&orig_hp->refcnt))
|
|
|
|
mdesc_free(orig_hp);
|
|
|
|
else
|
|
|
|
list_add(&orig_hp->list, &mdesc_zombie_list);
|
|
|
|
spin_unlock_irqrestore(&mdesc_lock, flags);
|
2007-07-17 22:37:35 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&mdesc_mutex);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static struct mdesc_elem *node_block(struct mdesc_hdr *mdesc)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
|
|
|
return (struct mdesc_elem *) (mdesc + 1);
|
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static void *name_block(struct mdesc_hdr *mdesc)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
|
|
|
return ((void *) node_block(mdesc)) + mdesc->node_sz;
|
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
static void *data_block(struct mdesc_hdr *mdesc)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
|
|
|
return ((void *) name_block(mdesc)) + mdesc->name_sz;
|
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mdesc_node_by_name(struct mdesc_handle *hp,
|
|
|
|
u64 from_node, const char *name)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_elem *ep = node_block(&hp->mdesc);
|
|
|
|
const char *names = name_block(&hp->mdesc);
|
|
|
|
u64 last_node = hp->mdesc.node_sz / 16;
|
|
|
|
u64 ret;
|
|
|
|
|
2007-07-16 17:50:36 -06:00
|
|
|
if (from_node == MDESC_NODE_NULL) {
|
|
|
|
ret = from_node = 0;
|
|
|
|
} else if (from_node >= last_node) {
|
2007-07-12 14:47:50 -06:00
|
|
|
return MDESC_NODE_NULL;
|
2007-07-16 17:50:36 -06:00
|
|
|
} else {
|
|
|
|
ret = ep[from_node].d.val;
|
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
|
|
|
|
while (ret < last_node) {
|
|
|
|
if (ep[ret].tag != MD_NODE)
|
|
|
|
return MDESC_NODE_NULL;
|
|
|
|
if (!strcmp(names + ep[ret].name_offset, name))
|
|
|
|
break;
|
|
|
|
ret = ep[ret].d.val;
|
|
|
|
}
|
|
|
|
if (ret >= last_node)
|
|
|
|
ret = MDESC_NODE_NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdesc_node_by_name);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
const void *mdesc_get_property(struct mdesc_handle *hp, u64 node,
|
|
|
|
const char *name, int *lenp)
|
|
|
|
{
|
|
|
|
const char *names = name_block(&hp->mdesc);
|
|
|
|
u64 last_node = hp->mdesc.node_sz / 16;
|
|
|
|
void *data = data_block(&hp->mdesc);
|
|
|
|
struct mdesc_elem *ep;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (node == MDESC_NODE_NULL || node >= last_node)
|
|
|
|
return NULL;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
ep = node_block(&hp->mdesc) + node;
|
|
|
|
ep++;
|
|
|
|
for (; ep->tag != MD_NODE_END; ep++) {
|
|
|
|
void *val = NULL;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
switch (ep->tag) {
|
|
|
|
case MD_PROP_VAL:
|
|
|
|
val = &ep->d.val;
|
|
|
|
len = 8;
|
2007-05-25 16:49:59 -06:00
|
|
|
break;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
case MD_PROP_STR:
|
|
|
|
case MD_PROP_DATA:
|
|
|
|
val = data + ep->d.data.data_offset;
|
|
|
|
len = ep->d.data.data_len;
|
|
|
|
break;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
default:
|
2007-05-25 16:49:59 -06:00
|
|
|
break;
|
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
if (!val)
|
|
|
|
continue;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (!strcmp(names + ep->name_offset, name)) {
|
|
|
|
if (lenp)
|
|
|
|
*lenp = len;
|
|
|
|
return val;
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdesc_get_property);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mdesc_next_arc(struct mdesc_handle *hp, u64 from, const char *arc_type)
|
|
|
|
{
|
|
|
|
struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
|
|
|
|
const char *names = name_block(&hp->mdesc);
|
|
|
|
u64 last_node = hp->mdesc.node_sz / 16;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (from == MDESC_NODE_NULL || from >= last_node)
|
|
|
|
return MDESC_NODE_NULL;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
ep = base + from;
|
|
|
|
|
|
|
|
ep++;
|
|
|
|
for (; ep->tag != MD_NODE_END; ep++) {
|
|
|
|
if (ep->tag != MD_PROP_ARC)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (strcmp(names + ep->name_offset, arc_type))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return ep - base;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
|
|
|
|
return MDESC_NODE_NULL;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
EXPORT_SYMBOL(mdesc_next_arc);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mdesc_arc_target(struct mdesc_handle *hp, u64 arc)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
|
|
|
|
|
|
|
|
ep = base + arc;
|
|
|
|
|
|
|
|
return ep->d.val;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
EXPORT_SYMBOL(mdesc_arc_target);
|
|
|
|
|
|
|
|
const char *mdesc_node_name(struct mdesc_handle *hp, u64 node)
|
|
|
|
{
|
|
|
|
struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
|
|
|
|
const char *names = name_block(&hp->mdesc);
|
|
|
|
u64 last_node = hp->mdesc.node_sz / 16;
|
|
|
|
|
|
|
|
if (node == MDESC_NODE_NULL || node >= last_node)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ep = base + node;
|
|
|
|
if (ep->tag != MD_NODE)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return names + ep->name_offset;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mdesc_node_name);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2011-08-05 03:38:27 -06:00
|
|
|
static u64 max_cpus = 64;
|
|
|
|
|
2007-05-25 16:49:59 -06:00
|
|
|
static void __init report_platform_properties(void)
|
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle *hp = mdesc_grab();
|
|
|
|
u64 pn = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform");
|
2007-05-25 16:49:59 -06:00
|
|
|
const char *s;
|
|
|
|
const u64 *v;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (pn == MDESC_NODE_NULL) {
|
2007-05-25 16:49:59 -06:00
|
|
|
prom_printf("No platform node in machine-description.\n");
|
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
s = mdesc_get_property(hp, pn, "banner-name", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
printk("PLATFORM: banner-name [%s]\n", s);
|
2007-07-12 14:47:50 -06:00
|
|
|
s = mdesc_get_property(hp, pn, "name", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
printk("PLATFORM: name [%s]\n", s);
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "hostid", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (v)
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: hostid [%08llx]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "serial#", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (v)
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: serial# [%08llx]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: stick-frequency [%08llx]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "mac-address", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (v)
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: mac-address [%llx]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (v)
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (v)
|
2009-01-06 14:19:28 -07:00
|
|
|
printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v);
|
2007-07-12 14:47:50 -06:00
|
|
|
v = mdesc_get_property(hp, pn, "max-cpus", NULL);
|
2011-08-05 03:38:27 -06:00
|
|
|
if (v) {
|
|
|
|
max_cpus = *v;
|
|
|
|
printk("PLATFORM: max-cpus [%llu]\n", max_cpus);
|
|
|
|
}
|
2007-07-12 14:47:50 -06:00
|
|
|
|
[SPARC64]: Initial LDOM cpu hotplug support.
Only adding cpus is supports at the moment, removal
will come next.
When new cpus are configured, the machine description is
updated. When we get the configure request we pass in a
cpu mask of to-be-added cpus to the mdesc CPU node parser
so it only fetches information for those cpus. That code
also proceeds to update the SMT/multi-core scheduling bitmaps.
cpu_up() does all the work and we return the status back
over the DS channel.
CPUs via dr-cpu need to be booted straight out of the
hypervisor, and this requires:
1) A new trampoline mechanism. CPUs are booted straight
out of the hypervisor with MMU disabled and running in
physical addresses with no mappings installed in the TLB.
The new hvtramp.S code sets up the critical cpu state,
installs the locked TLB mappings for the kernel, and
turns the MMU on. It then proceeds to follow the logic
of the existing trampoline.S SMP cpu bringup code.
2) All calls into OBP have to be disallowed when domaining
is enabled. Since cpus boot straight into the kernel from
the hypervisor, OBP has no state about that cpu and therefore
cannot handle being invoked on that cpu.
Luckily it's only a handful of interfaces which can be called
after the OBP device tree is obtained. For example, rebooting,
halting, powering-off, and setting options node variables.
CPU removal support will require some infrastructure changes
here. Namely we'll have to process the requests via a true
kernel thread instead of in a workqueue. workqueues run on
a per-cpu thread, but when unconfiguring we might need to
force the thread to execute on another cpu if the current cpu
is the one being removed. Removal of a cpu also causes the kernel
to destroy that cpu's workqueue running thread.
Another issue on removal is that we may have interrupts still
pointing to the cpu-to-be-removed. So new code will be needed
to walk the active INO list and retarget those cpus as-needed.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-07-13 17:03:42 -06:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
{
|
|
|
|
int max_cpu, i;
|
|
|
|
|
|
|
|
if (v) {
|
|
|
|
max_cpu = *v;
|
|
|
|
if (max_cpu > NR_CPUS)
|
|
|
|
max_cpu = NR_CPUS;
|
|
|
|
} else {
|
|
|
|
max_cpu = NR_CPUS;
|
|
|
|
}
|
|
|
|
for (i = 0; i < max_cpu; i++)
|
2009-03-15 22:10:23 -06:00
|
|
|
set_cpu_possible(i, true);
|
[SPARC64]: Initial LDOM cpu hotplug support.
Only adding cpus is supports at the moment, removal
will come next.
When new cpus are configured, the machine description is
updated. When we get the configure request we pass in a
cpu mask of to-be-added cpus to the mdesc CPU node parser
so it only fetches information for those cpus. That code
also proceeds to update the SMT/multi-core scheduling bitmaps.
cpu_up() does all the work and we return the status back
over the DS channel.
CPUs via dr-cpu need to be booted straight out of the
hypervisor, and this requires:
1) A new trampoline mechanism. CPUs are booted straight
out of the hypervisor with MMU disabled and running in
physical addresses with no mappings installed in the TLB.
The new hvtramp.S code sets up the critical cpu state,
installs the locked TLB mappings for the kernel, and
turns the MMU on. It then proceeds to follow the logic
of the existing trampoline.S SMP cpu bringup code.
2) All calls into OBP have to be disallowed when domaining
is enabled. Since cpus boot straight into the kernel from
the hypervisor, OBP has no state about that cpu and therefore
cannot handle being invoked on that cpu.
Luckily it's only a handful of interfaces which can be called
after the OBP device tree is obtained. For example, rebooting,
halting, powering-off, and setting options node variables.
CPU removal support will require some infrastructure changes
here. Namely we'll have to process the requests via a true
kernel thread instead of in a workqueue. workqueues run on
a per-cpu thread, but when unconfiguring we might need to
force the thread to execute on another cpu if the current cpu
is the one being removed. Removal of a cpu also causes the kernel
to destroy that cpu's workqueue running thread.
Another issue on removal is that we may have interrupts still
pointing to the cpu-to-be-removed. So new code will be needed
to walk the active INO list and retarget those cpus as-needed.
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-07-13 17:03:42 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_release(hp);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void fill_in_one_cache(cpuinfo_sparc *c, struct mdesc_handle *hp, u64 mp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
const u64 *level = mdesc_get_property(hp, mp, "level", NULL);
|
|
|
|
const u64 *size = mdesc_get_property(hp, mp, "size", NULL);
|
|
|
|
const u64 *line_size = mdesc_get_property(hp, mp, "line-size", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
const char *type;
|
|
|
|
int type_len;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
type = mdesc_get_property(hp, mp, "type", &type_len);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
|
|
|
switch (*level) {
|
|
|
|
case 1:
|
2007-08-07 19:46:36 -06:00
|
|
|
if (of_find_in_proplist(type, "instn", type_len)) {
|
2007-05-25 16:49:59 -06:00
|
|
|
c->icache_size = *size;
|
|
|
|
c->icache_line_size = *line_size;
|
2007-08-07 19:46:36 -06:00
|
|
|
} else if (of_find_in_proplist(type, "data", type_len)) {
|
2007-05-25 16:49:59 -06:00
|
|
|
c->dcache_size = *size;
|
|
|
|
c->dcache_line_size = *line_size;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
c->ecache_size = *size;
|
|
|
|
c->ecache_line_size = *line_size;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*level == 1) {
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 a;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 target = mdesc_arc_target(hp, a);
|
|
|
|
const char *name = mdesc_node_name(hp, target);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
if (!strcmp(name, "cache"))
|
|
|
|
fill_in_one_cache(c, hp, target);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
static void find_back_node_value(struct mdesc_handle *hp, u64 node,
|
|
|
|
char *srch_val,
|
|
|
|
void (*func)(struct mdesc_handle *, u64, int),
|
|
|
|
u64 val, int depth)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2015-04-22 10:28:31 -06:00
|
|
|
u64 arc;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
/* Since we have an estimate of recursion depth, do a sanity check. */
|
|
|
|
if (depth == 0)
|
|
|
|
return;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
mdesc_for_each_arc(arc, hp, node, MDESC_ARC_TYPE_BACK) {
|
|
|
|
u64 n = mdesc_arc_target(hp, arc);
|
|
|
|
const char *name = mdesc_node_name(hp, n);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
if (!strcmp(srch_val, name))
|
|
|
|
(*func)(hp, n, val);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
find_back_node_value(hp, n, srch_val, func, val, depth-1);
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
static void __mark_core_id(struct mdesc_handle *hp, u64 node,
|
|
|
|
int core_id)
|
|
|
|
{
|
|
|
|
const u64 *id = mdesc_get_property(hp, node, "id", NULL);
|
|
|
|
|
|
|
|
if (*id < num_possible_cpus())
|
|
|
|
cpu_data(*id).core_id = core_id;
|
|
|
|
}
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
static void __mark_max_cache_id(struct mdesc_handle *hp, u64 node,
|
|
|
|
int max_cache_id)
|
2015-04-22 10:28:31 -06:00
|
|
|
{
|
|
|
|
const u64 *id = mdesc_get_property(hp, node, "id", NULL);
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
if (*id < num_possible_cpus()) {
|
|
|
|
cpu_data(*id).max_cache_id = max_cache_id;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On systems without explicit socket descriptions socket
|
|
|
|
* is max_cache_id
|
|
|
|
*/
|
|
|
|
cpu_data(*id).sock_id = max_cache_id;
|
|
|
|
}
|
2015-04-22 10:28:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mark_core_ids(struct mdesc_handle *hp, u64 mp,
|
|
|
|
int core_id)
|
|
|
|
{
|
|
|
|
find_back_node_value(hp, mp, "cpu", __mark_core_id, core_id, 10);
|
|
|
|
}
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
static void mark_max_cache_ids(struct mdesc_handle *hp, u64 mp,
|
|
|
|
int max_cache_id)
|
2015-04-22 10:28:31 -06:00
|
|
|
{
|
2016-10-19 18:33:29 -06:00
|
|
|
find_back_node_value(hp, mp, "cpu", __mark_max_cache_id,
|
|
|
|
max_cache_id, 10);
|
2015-04-22 10:28:31 -06:00
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void set_core_ids(struct mdesc_handle *hp)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
|
|
|
int idx;
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mp;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
|
|
|
idx = 1;
|
2015-04-22 10:28:31 -06:00
|
|
|
|
|
|
|
/* Identify unique cores by looking for cpus backpointed to by
|
|
|
|
* level 1 instruction caches.
|
|
|
|
*/
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_for_each_node_by_name(hp, mp, "cache") {
|
|
|
|
const u64 *level;
|
2007-05-25 16:49:59 -06:00
|
|
|
const char *type;
|
|
|
|
int len;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
level = mdesc_get_property(hp, mp, "level", NULL);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (*level != 1)
|
|
|
|
continue;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
type = mdesc_get_property(hp, mp, "type", &len);
|
2007-08-07 19:46:36 -06:00
|
|
|
if (!of_find_in_proplist(type, "instn", len))
|
2007-05-25 16:49:59 -06:00
|
|
|
continue;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mark_core_ids(hp, mp, idx);
|
2015-04-22 10:28:31 -06:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
static int set_max_cache_ids_by_cache(struct mdesc_handle *hp, int level)
|
2015-04-22 10:28:31 -06:00
|
|
|
{
|
|
|
|
u64 mp;
|
|
|
|
int idx = 1;
|
|
|
|
int fnd = 0;
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
/**
|
|
|
|
* Identify unique highest level of shared cache by looking for cpus
|
|
|
|
* backpointed to by shared level N caches.
|
2015-04-22 10:28:31 -06:00
|
|
|
*/
|
|
|
|
mdesc_for_each_node_by_name(hp, mp, "cache") {
|
|
|
|
const u64 *cur_lvl;
|
|
|
|
|
|
|
|
cur_lvl = mdesc_get_property(hp, mp, "level", NULL);
|
|
|
|
if (*cur_lvl != level)
|
|
|
|
continue;
|
2016-10-19 18:33:29 -06:00
|
|
|
mark_max_cache_ids(hp, mp, idx);
|
2015-04-22 10:28:31 -06:00
|
|
|
idx++;
|
|
|
|
fnd = 1;
|
|
|
|
}
|
|
|
|
return fnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_sock_ids_by_socket(struct mdesc_handle *hp, u64 mp)
|
|
|
|
{
|
|
|
|
int idx = 1;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
mdesc_for_each_node_by_name(hp, mp, "socket") {
|
|
|
|
u64 a;
|
|
|
|
|
|
|
|
mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 t = mdesc_arc_target(hp, a);
|
|
|
|
const char *name;
|
|
|
|
const u64 *id;
|
|
|
|
|
|
|
|
name = mdesc_node_name(hp, t);
|
|
|
|
if (strcmp(name, "cpu"))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
id = mdesc_get_property(hp, t, "id", NULL);
|
|
|
|
if (*id < num_possible_cpus())
|
|
|
|
cpu_data(*id).sock_id = idx;
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-22 10:28:31 -06:00
|
|
|
static void set_sock_ids(struct mdesc_handle *hp)
|
|
|
|
{
|
|
|
|
u64 mp;
|
|
|
|
|
2016-10-19 18:33:29 -06:00
|
|
|
/**
|
|
|
|
* Find the highest level of shared cache which pre-T7 is also
|
|
|
|
* the socket.
|
2015-04-22 10:28:31 -06:00
|
|
|
*/
|
2016-10-19 18:33:29 -06:00
|
|
|
if (!set_max_cache_ids_by_cache(hp, 3))
|
|
|
|
set_max_cache_ids_by_cache(hp, 2);
|
|
|
|
|
|
|
|
/* If machine description exposes sockets data use it.*/
|
2015-04-22 10:28:31 -06:00
|
|
|
mp = mdesc_node_by_name(hp, MDESC_NODE_NULL, "sockets");
|
|
|
|
if (mp != MDESC_NODE_NULL)
|
2016-10-19 18:33:29 -06:00
|
|
|
set_sock_ids_by_socket(hp, mp);
|
2015-04-22 10:28:31 -06:00
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void mark_proc_ids(struct mdesc_handle *hp, u64 mp, int proc_id)
|
2007-06-04 18:01:39 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 a;
|
2007-06-04 18:01:39 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
|
|
|
|
u64 t = mdesc_arc_target(hp, a);
|
|
|
|
const char *name;
|
2007-06-04 18:01:39 -06:00
|
|
|
const u64 *id;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
name = mdesc_node_name(hp, t);
|
|
|
|
if (strcmp(name, "cpu"))
|
2007-06-04 18:01:39 -06:00
|
|
|
continue;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
id = mdesc_get_property(hp, t, "id", NULL);
|
2007-06-04 18:01:39 -06:00
|
|
|
if (*id < NR_CPUS)
|
|
|
|
cpu_data(*id).proc_id = proc_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void __set_proc_ids(struct mdesc_handle *hp, const char *exec_unit_name)
|
2007-06-04 18:01:39 -06:00
|
|
|
{
|
|
|
|
int idx;
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mp;
|
2007-06-04 18:01:39 -06:00
|
|
|
|
|
|
|
idx = 0;
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_for_each_node_by_name(hp, mp, exec_unit_name) {
|
2007-06-04 18:01:39 -06:00
|
|
|
const char *type;
|
|
|
|
int len;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
type = mdesc_get_property(hp, mp, "type", &len);
|
2007-08-07 19:46:36 -06:00
|
|
|
if (!of_find_in_proplist(type, "int", len) &&
|
|
|
|
!of_find_in_proplist(type, "integer", len))
|
2007-06-04 18:01:39 -06:00
|
|
|
continue;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mark_proc_ids(hp, mp, idx);
|
2007-06-04 18:01:39 -06:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void set_proc_ids(struct mdesc_handle *hp)
|
2007-06-04 18:01:39 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
__set_proc_ids(hp, "exec_unit");
|
|
|
|
__set_proc_ids(hp, "exec-unit");
|
2007-06-04 18:01:39 -06:00
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void get_one_mondo_bits(const u64 *p, unsigned int *mask,
|
|
|
|
unsigned long def, unsigned long max)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
goto use_default;
|
|
|
|
val = *p;
|
|
|
|
|
|
|
|
if (!val || val >= 64)
|
|
|
|
goto use_default;
|
|
|
|
|
2011-08-05 03:38:27 -06:00
|
|
|
if (val > max)
|
|
|
|
val = max;
|
|
|
|
|
2007-05-25 16:49:59 -06:00
|
|
|
*mask = ((1U << val) * 64U) - 1U;
|
|
|
|
return;
|
|
|
|
|
|
|
|
use_default:
|
|
|
|
*mask = ((1U << def) * 64U) - 1U;
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void get_mondo_data(struct mdesc_handle *hp, u64 mp,
|
|
|
|
struct trap_per_cpu *tb)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2011-08-05 03:38:27 -06:00
|
|
|
static int printed;
|
2007-05-25 16:49:59 -06:00
|
|
|
const u64 *val;
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
val = mdesc_get_property(hp, mp, "q-cpu-mondo-#bits", NULL);
|
2011-08-05 03:38:27 -06:00
|
|
|
get_one_mondo_bits(val, &tb->cpu_mondo_qmask, 7, ilog2(max_cpus * 2));
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
val = mdesc_get_property(hp, mp, "q-dev-mondo-#bits", NULL);
|
2011-08-05 03:38:27 -06:00
|
|
|
get_one_mondo_bits(val, &tb->dev_mondo_qmask, 7, 8);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
val = mdesc_get_property(hp, mp, "q-resumable-#bits", NULL);
|
2011-08-05 03:38:27 -06:00
|
|
|
get_one_mondo_bits(val, &tb->resum_qmask, 6, 7);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
val = mdesc_get_property(hp, mp, "q-nonresumable-#bits", NULL);
|
2011-08-05 03:38:27 -06:00
|
|
|
get_one_mondo_bits(val, &tb->nonresum_qmask, 2, 2);
|
|
|
|
if (!printed++) {
|
|
|
|
pr_info("SUN4V: Mondo queue sizes "
|
|
|
|
"[cpu(%u) dev(%u) r(%u) nr(%u)]\n",
|
|
|
|
tb->cpu_mondo_qmask + 1,
|
|
|
|
tb->dev_mondo_qmask + 1,
|
|
|
|
tb->resum_qmask + 1,
|
|
|
|
tb->nonresum_qmask + 1);
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void *mdesc_iterate_over_cpus(void *(*func)(struct mdesc_handle *, u64, int, void *), void *arg, cpumask_t *mask)
|
2007-05-25 16:49:59 -06:00
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle *hp = mdesc_grab();
|
2009-04-08 20:55:47 -06:00
|
|
|
void *ret = NULL;
|
2007-07-12 14:47:50 -06:00
|
|
|
u64 mp;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_for_each_node_by_name(hp, mp, "cpu") {
|
|
|
|
const u64 *id = mdesc_get_property(hp, mp, "id", NULL);
|
2009-04-08 20:55:47 -06:00
|
|
|
int cpuid = *id;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2007-09-16 15:45:06 -06:00
|
|
|
if (cpuid >= NR_CPUS) {
|
|
|
|
printk(KERN_WARNING "Ignoring CPU %d which is "
|
|
|
|
">= NR_CPUS (%d)\n",
|
|
|
|
cpuid, NR_CPUS);
|
2007-05-25 16:49:59 -06:00
|
|
|
continue;
|
2007-09-16 15:45:06 -06:00
|
|
|
}
|
2011-05-16 14:38:07 -06:00
|
|
|
if (!cpumask_test_cpu(cpuid, mask))
|
2007-05-25 16:49:59 -06:00
|
|
|
continue;
|
|
|
|
#endif
|
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
ret = func(hp, mp, cpuid, arg);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mdesc_release(hp);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void *record_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid,
|
|
|
|
void *arg)
|
2009-04-08 20:55:47 -06:00
|
|
|
{
|
|
|
|
ncpus_probed++;
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
set_cpu_present(cpuid, true);
|
|
|
|
#endif
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
void mdesc_populate_present_mask(cpumask_t *mask)
|
2009-04-08 20:55:47 -06:00
|
|
|
{
|
|
|
|
if (tlb_type != hypervisor)
|
|
|
|
return;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
ncpus_probed = 0;
|
|
|
|
mdesc_iterate_over_cpus(record_one_cpu, NULL, mask);
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2012-09-06 20:01:25 -06:00
|
|
|
static void * __init check_one_pgsz(struct mdesc_handle *hp, u64 mp, int cpuid, void *arg)
|
|
|
|
{
|
|
|
|
const u64 *pgsz_prop = mdesc_get_property(hp, mp, "mmu-page-size-list", NULL);
|
|
|
|
unsigned long *pgsz_mask = arg;
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
val = (HV_PGSZ_MASK_8K | HV_PGSZ_MASK_64K |
|
|
|
|
HV_PGSZ_MASK_512K | HV_PGSZ_MASK_4MB);
|
|
|
|
if (pgsz_prop)
|
|
|
|
val = *pgsz_prop;
|
|
|
|
|
|
|
|
if (!*pgsz_mask)
|
|
|
|
*pgsz_mask = val;
|
|
|
|
else
|
|
|
|
*pgsz_mask &= val;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init mdesc_get_page_sizes(cpumask_t *mask, unsigned long *pgsz_mask)
|
|
|
|
{
|
|
|
|
*pgsz_mask = 0;
|
|
|
|
mdesc_iterate_over_cpus(check_one_pgsz, pgsz_mask, mask);
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
static void *fill_in_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid,
|
|
|
|
void *arg)
|
2009-04-08 20:55:47 -06:00
|
|
|
{
|
|
|
|
const u64 *cfreq = mdesc_get_property(hp, mp, "clock-frequency", NULL);
|
|
|
|
struct trap_per_cpu *tb;
|
|
|
|
cpuinfo_sparc *c;
|
|
|
|
u64 a;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
/* On uniprocessor we only want the values for the
|
|
|
|
* real physical cpu the kernel booted onto, however
|
|
|
|
* cpu_data() only has one entry at index 0.
|
|
|
|
*/
|
|
|
|
if (cpuid != real_hard_smp_processor_id())
|
|
|
|
return NULL;
|
|
|
|
cpuid = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
c = &cpu_data(cpuid);
|
|
|
|
c->clock_tick = *cfreq;
|
|
|
|
|
|
|
|
tb = &trap_block[cpuid];
|
|
|
|
get_mondo_data(hp, mp, tb);
|
|
|
|
|
|
|
|
mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 j, t = mdesc_arc_target(hp, a);
|
|
|
|
const char *t_name;
|
|
|
|
|
|
|
|
t_name = mdesc_node_name(hp, t);
|
|
|
|
if (!strcmp(t_name, "cache")) {
|
|
|
|
fill_in_one_cache(c, hp, t);
|
|
|
|
continue;
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_FWD) {
|
|
|
|
u64 n = mdesc_arc_target(hp, j);
|
|
|
|
const char *n_name;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
n_name = mdesc_node_name(hp, n);
|
|
|
|
if (!strcmp(n_name, "cache"))
|
|
|
|
fill_in_one_cache(c, hp, n);
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2009-04-08 20:55:47 -06:00
|
|
|
c->core_id = 0;
|
|
|
|
c->proc_id = -1;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
sparc: delete __cpuinit/__CPUINIT usage from all users
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/sparc uses of the __cpuinit macros from
C files and removes __CPUINIT from assembly files. Note that even
though arch/sparc/kernel/trampoline_64.S has instances of ".previous"
in it, they are all paired off against explicit ".section" directives,
and not implicitly paired with __CPUINIT (unlike mips and arm were).
[1] https://lkml.org/lkml/2013/5/20/589
Cc: "David S. Miller" <davem@davemloft.net>
Cc: sparclinux@vger.kernel.org
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-17 13:43:14 -06:00
|
|
|
void mdesc_fill_in_cpu_data(cpumask_t *mask)
|
2009-04-08 20:55:47 -06:00
|
|
|
{
|
|
|
|
struct mdesc_handle *hp;
|
|
|
|
|
2009-04-01 04:15:11 -06:00
|
|
|
mdesc_iterate_over_cpus(fill_in_one_cpu, NULL, mask);
|
2009-04-08 20:55:47 -06:00
|
|
|
|
|
|
|
hp = mdesc_grab();
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
set_core_ids(hp);
|
|
|
|
set_proc_ids(hp);
|
2015-04-22 10:28:31 -06:00
|
|
|
set_sock_ids(hp);
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_release(hp);
|
2009-04-08 20:55:47 -06:00
|
|
|
|
|
|
|
smp_fill_in_sib_core_maps();
|
2007-05-25 16:49:59 -06:00
|
|
|
}
|
|
|
|
|
2014-07-18 09:15:40 -06:00
|
|
|
/* mdesc_open() - Grab a reference to mdesc_handle when /dev/mdesc is
|
|
|
|
* opened. Hold this reference until /dev/mdesc is closed to ensure
|
|
|
|
* mdesc data structure is not released underneath us. Store the
|
|
|
|
* pointer to mdesc structure in private_data for read and seek to use
|
|
|
|
*/
|
|
|
|
static int mdesc_open(struct inode *inode, struct file *file)
|
2007-08-15 22:02:23 -06:00
|
|
|
{
|
|
|
|
struct mdesc_handle *hp = mdesc_grab();
|
|
|
|
|
|
|
|
if (!hp)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2014-07-18 09:15:40 -06:00
|
|
|
file->private_data = hp;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t mdesc_read(struct file *file, char __user *buf,
|
|
|
|
size_t len, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct mdesc_handle *hp = file->private_data;
|
|
|
|
unsigned char *mdesc;
|
|
|
|
int bytes_left, count = len;
|
|
|
|
|
|
|
|
if (*offp >= hp->handle_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bytes_left = hp->handle_size - *offp;
|
|
|
|
if (count > bytes_left)
|
|
|
|
count = bytes_left;
|
|
|
|
|
|
|
|
mdesc = (unsigned char *)&hp->mdesc;
|
|
|
|
mdesc += *offp;
|
|
|
|
if (!copy_to_user(buf, mdesc, count)) {
|
|
|
|
*offp += count;
|
|
|
|
return count;
|
|
|
|
} else {
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
}
|
2007-08-15 22:02:23 -06:00
|
|
|
|
2014-07-18 09:15:40 -06:00
|
|
|
static loff_t mdesc_llseek(struct file *file, loff_t offset, int whence)
|
|
|
|
{
|
2015-12-05 20:04:48 -07:00
|
|
|
struct mdesc_handle *hp = file->private_data;
|
2014-07-18 09:15:40 -06:00
|
|
|
|
2015-12-05 20:04:48 -07:00
|
|
|
return no_seek_end_llseek_size(file, offset, whence, hp->handle_size);
|
2014-07-18 09:15:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* mdesc_close() - /dev/mdesc is being closed, release the reference to
|
|
|
|
* mdesc structure.
|
|
|
|
*/
|
|
|
|
static int mdesc_close(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
mdesc_release(file->private_data);
|
|
|
|
return 0;
|
2007-08-15 22:02:23 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations mdesc_fops = {
|
2014-07-18 09:15:40 -06:00
|
|
|
.open = mdesc_open,
|
|
|
|
.read = mdesc_read,
|
|
|
|
.llseek = mdesc_llseek,
|
|
|
|
.release = mdesc_close,
|
|
|
|
.owner = THIS_MODULE,
|
2007-08-15 22:02:23 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice mdesc_misc = {
|
|
|
|
.minor = MISC_DYNAMIC_MINOR,
|
|
|
|
.name = "mdesc",
|
|
|
|
.fops = &mdesc_fops,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init mdesc_misc_init(void)
|
|
|
|
{
|
|
|
|
return misc_register(&mdesc_misc);
|
|
|
|
}
|
|
|
|
|
|
|
|
__initcall(mdesc_misc_init);
|
|
|
|
|
2007-05-25 16:49:59 -06:00
|
|
|
void __init sun4v_mdesc_init(void)
|
|
|
|
{
|
2007-07-12 14:47:50 -06:00
|
|
|
struct mdesc_handle *hp;
|
2007-05-25 16:49:59 -06:00
|
|
|
unsigned long len, real_len, status;
|
|
|
|
|
|
|
|
(void) sun4v_mach_desc(0UL, 0UL, &len);
|
|
|
|
|
|
|
|
printk("MDESC: Size is %lu bytes.\n", len);
|
|
|
|
|
2010-07-11 22:36:09 -06:00
|
|
|
hp = mdesc_alloc(len, &memblock_mdesc_ops);
|
2007-07-12 14:47:50 -06:00
|
|
|
if (hp == NULL) {
|
|
|
|
prom_printf("MDESC: alloc of %lu bytes failed.\n", len);
|
|
|
|
prom_halt();
|
|
|
|
}
|
2007-05-25 16:49:59 -06:00
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
|
2007-05-25 16:49:59 -06:00
|
|
|
if (status != HV_EOK || real_len > len) {
|
|
|
|
prom_printf("sun4v_mach_desc fails, err(%lu), "
|
|
|
|
"len(%lu), real_len(%lu)\n",
|
|
|
|
status, len, real_len);
|
2007-07-12 14:47:50 -06:00
|
|
|
mdesc_free(hp);
|
2007-05-25 16:49:59 -06:00
|
|
|
prom_halt();
|
|
|
|
}
|
|
|
|
|
2007-07-12 14:47:50 -06:00
|
|
|
cur_mdesc = hp;
|
2007-05-25 16:49:59 -06:00
|
|
|
|
|
|
|
report_platform_properties();
|
|
|
|
}
|