arch/sparc/kernel/mdesc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* mdesc.c: Sun4V machine description handling.
   3  *
   4  * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/types.h>
   8 #include <linux/log2.h>
   9 #include <linux/list.h>
  10 #include <linux/slab.h>
  11 #include <linux/mm.h>
  12 #include <linux/miscdevice.h>
  13 #include <linux/memblock.h>
  14 #include <linux/export.h>
  15 #include <linux/refcount.h>
  16
  17 #include <asm/cpudata.h>
  18 #include <asm/hypervisor.h>
  19 #include <asm/mdesc.h>
  20 #include <asm/prom.h>
  21 #include <linux/uaccess.h>
  22 #include <asm/oplib.h>
  23 #include <asm/smp.h>
  24 #include <asm/adi.h>
  25
  26 /* Unlike the OBP device tree, the machine description is a full-on
  27  * DAG.  An arbitrary number of ARCs are possible from one
  28  * node to other nodes and thus we can't use the OBP device_node
  29  * data structure to represent these nodes inside of the kernel.
  30  *
  31  * Actually, it isn't even a DAG, because there are back pointers
  32  * which create cycles in the graph.
  33  *
  34  * mdesc_hdr and mdesc_elem describe the layout of the data structure
  35  * we get from the Hypervisor.
  36  */
  37 struct mdesc_hdr {
  38         u32     version; /* Transport version */
  39         u32     node_sz; /* node block size */
  40         u32     name_sz; /* name block size */
  41         u32     data_sz; /* data block size */
  42 } __attribute__((aligned(16)));
  43
  44 struct mdesc_elem {
  45         u8      tag;
  46 #define MD_LIST_END     0x00
  47 #define MD_NODE         0x4e
  48 #define MD_NODE_END     0x45
  49 #define MD_NOOP         0x20
  50 #define MD_PROP_ARC     0x61
  51 #define MD_PROP_VAL     0x76
  52 #define MD_PROP_STR     0x73
  53 #define MD_PROP_DATA    0x64
  54         u8      name_len;
  55         u16     resv;
  56         u32     name_offset;
  57         union {
  58                 struct {
  59                         u32     data_len;
  60                         u32     data_offset;
  61                 } data;
  62                 u64     val;
  63         } d;
  64 };
  65
  66 struct mdesc_mem_ops {
  67         struct mdesc_handle *(*alloc)(unsigned int mdesc_size);
  68         void (*free)(struct mdesc_handle *handle);
  69 };
  70
  71 struct mdesc_handle {
  72         struct list_head        list;
  73         struct mdesc_mem_ops    *mops;
  74         void                    *self_base;
  75         refcount_t              refcnt;
  76         unsigned int            handle_size;
  77         struct mdesc_hdr        mdesc;
  78 };
  79
  80 typedef int (*mdesc_node_info_get_f)(struct mdesc_handle *, u64,
  81                                      union md_node_info *);
  82 typedef void (*mdesc_node_info_rel_f)(union md_node_info *);
  83 typedef bool (*mdesc_node_match_f)(union md_node_info *, union md_node_info *);
  84
  85 struct md_node_ops {
  86         char                    *name;
  87         mdesc_node_info_get_f   get_info;
  88         mdesc_node_info_rel_f   rel_info;
  89         mdesc_node_match_f      node_match;
  90 };
  91
  92 static int get_vdev_port_node_info(struct mdesc_handle *md, u64 node,
  93                                    union md_node_info *node_info);
  94 static void rel_vdev_port_node_info(union md_node_info *node_info);
  95 static bool vdev_port_node_match(union md_node_info *a_node_info,
  96                                  union md_node_info *b_node_info);
  97
  98 static int get_ds_port_node_info(struct mdesc_handle *md, u64 node,
  99                                  union md_node_info *node_info);
 100 static void rel_ds_port_node_info(union md_node_info *node_info);
 101 static bool ds_port_node_match(union md_node_info *a_node_info,
 102                                union md_node_info *b_node_info);
 103
 104 /* supported node types which can be registered */
 105 static struct md_node_ops md_node_ops_table[] = {
 106         {"virtual-device-port", get_vdev_port_node_info,
 107          rel_vdev_port_node_info, vdev_port_node_match},
 108         {"domain-services-port", get_ds_port_node_info,
 109          rel_ds_port_node_info, ds_port_node_match},
 110         {NULL, NULL, NULL, NULL}
 111 };
 112
 113 static void mdesc_get_node_ops(const char *node_name,
 114                                mdesc_node_info_get_f *get_info_f,
 115                                mdesc_node_info_rel_f *rel_info_f,
 116                                mdesc_node_match_f *match_f)
 117 {
 118         int i;
 119
 120         if (get_info_f)
 121                 *get_info_f = NULL;
 122
 123         if (rel_info_f)
 124                 *rel_info_f = NULL;
 125
 126         if (match_f)
 127                 *match_f = NULL;
 128
 129         if (!node_name)
 130                 return;
 131
 132         for (i = 0; md_node_ops_table[i].name != NULL; i++) {
 133                 if (strcmp(md_node_ops_table[i].name, node_name) == 0) {
 134                         if (get_info_f)
 135                                 *get_info_f = md_node_ops_table[i].get_info;
 136
 137                         if (rel_info_f)
 138                                 *rel_info_f = md_node_ops_table[i].rel_info;
 139
 140                         if (match_f)
 141                                 *match_f = md_node_ops_table[i].node_match;
 142
 143                         break;
 144                 }
 145         }
 146 }
 147
 148 static void mdesc_handle_init(struct mdesc_handle *hp,
 149                               unsigned int handle_size,
 150                               void *base)
 151 {
 152         BUG_ON(((unsigned long)&hp->mdesc) & (16UL - 1));
 153
 154         memset(hp, 0, handle_size);
 155         INIT_LIST_HEAD(&hp->list);
 156         hp->self_base = base;
 157         refcount_set(&hp->refcnt, 1);
 158         hp->handle_size = handle_size;
 159 }
 160
 161 static struct mdesc_handle * __init mdesc_memblock_alloc(unsigned int mdesc_size)
 162 {
 163         unsigned int handle_size, alloc_size;
 164         struct mdesc_handle *hp;
 165         unsigned long paddr;
 166
 167         handle_size = (sizeof(struct mdesc_handle) -
 168                        sizeof(struct mdesc_hdr) +
 169                        mdesc_size);
 170         alloc_size = PAGE_ALIGN(handle_size);
 171
 172         paddr = memblock_phys_alloc(alloc_size, PAGE_SIZE);
 173
 174         hp = NULL;
 175         if (paddr) {
 176                 hp = __va(paddr);
 177                 mdesc_handle_init(hp, handle_size, hp);
 178         }
 179         return hp;
 180 }
 181
 182 static void __init mdesc_memblock_free(struct mdesc_handle *hp)
 183 {
 184         unsigned int alloc_size;
 185         unsigned long start;
 186
 187         BUG_ON(refcount_read(&hp->refcnt) != 0);
 188         BUG_ON(!list_empty(&hp->list));
 189
 190         alloc_size = PAGE_ALIGN(hp->handle_size);
 191         start = __pa(hp);
 192         memblock_free_late(start, alloc_size);
 193 }
 194
 195 static struct mdesc_mem_ops memblock_mdesc_ops = {
 196         .alloc = mdesc_memblock_alloc,
 197         .free  = mdesc_memblock_free,
 198 };
 199
 200 static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
 201 {
 202         unsigned int handle_size;
 203         struct mdesc_handle *hp;
 204         unsigned long addr;
 205         void *base;
 206
 207         handle_size = (sizeof(struct mdesc_handle) -
 208                        sizeof(struct mdesc_hdr) +
 209                        mdesc_size);
 210         base = kmalloc(handle_size + 15, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
 211         if (!base)
 212                 return NULL;
 213
 214         addr = (unsigned long)base;
 215         addr = (addr + 15UL) & ~15UL;
 216         hp = (struct mdesc_handle *) addr;
 217
 218         mdesc_handle_init(hp, handle_size, base);
 219
 220         return hp;
 221 }
 222
 223 static void mdesc_kfree(struct mdesc_handle *hp)
 224 {
 225         BUG_ON(refcount_read(&hp->refcnt) != 0);
 226         BUG_ON(!list_empty(&hp->list));
 227
 228         kfree(hp->self_base);
 229 }
 230
 231 static struct mdesc_mem_ops kmalloc_mdesc_memops = {
 232         .alloc = mdesc_kmalloc,
 233         .free  = mdesc_kfree,
 234 };
 235
 236 static struct mdesc_handle *mdesc_alloc(unsigned int mdesc_size,
 237                                         struct mdesc_mem_ops *mops)
 238 {
 239         struct mdesc_handle *hp = mops->alloc(mdesc_size);
 240
 241         if (hp)
 242                 hp->mops = mops;
 243
 244         return hp;
 245 }
 246
 247 static void mdesc_free(struct mdesc_handle *hp)
 248 {
 249         hp->mops->free(hp);
 250 }
 251
 252 static struct mdesc_handle *cur_mdesc;
 253 static LIST_HEAD(mdesc_zombie_list);
 254 static DEFINE_SPINLOCK(mdesc_lock);
 255
 256 struct mdesc_handle *mdesc_grab(void)
 257 {
 258         struct mdesc_handle *hp;
 259         unsigned long flags;
 260
 261         spin_lock_irqsave(&mdesc_lock, flags);
 262         hp = cur_mdesc;
 263         if (hp)
 264                 refcount_inc(&hp->refcnt);
 265         spin_unlock_irqrestore(&mdesc_lock, flags);
 266
 267         return hp;
 268 }
 269 EXPORT_SYMBOL(mdesc_grab);
 270
 271 void mdesc_release(struct mdesc_handle *hp)
 272 {
 273         unsigned long flags;
 274
 275         spin_lock_irqsave(&mdesc_lock, flags);
 276         if (refcount_dec_and_test(&hp->refcnt)) {
 277                 list_del_init(&hp->list);
 278                 hp->mops->free(hp);
 279         }
 280         spin_unlock_irqrestore(&mdesc_lock, flags);
 281 }
 282 EXPORT_SYMBOL(mdesc_release);
 283
 284 static DEFINE_MUTEX(mdesc_mutex);
 285 static struct mdesc_notifier_client *client_list;
 286
 287 void mdesc_register_notifier(struct mdesc_notifier_client *client)
 288 {
 289         bool supported = false;
 290         u64 node;
 291         int i;
 292
 293         mutex_lock(&mdesc_mutex);
 294
 295         /* check to see if the node is supported for registration */
 296         for (i = 0; md_node_ops_table[i].name != NULL; i++) {
 297                 if (strcmp(md_node_ops_table[i].name, client->node_name) == 0) {
 298                         supported = true;
 299                         break;
 300                 }
 301         }
 302
 303         if (!supported) {
 304                 pr_err("MD: %s node not supported\n", client->node_name);
 305                 mutex_unlock(&mdesc_mutex);
 306                 return;
 307         }
 308
 309         client->next = client_list;
 310         client_list = client;
 311
 312         mdesc_for_each_node_by_name(cur_mdesc, node, client->node_name)
 313                 client->add(cur_mdesc, node, client->node_name);
 314
 315         mutex_unlock(&mdesc_mutex);
 316 }
 317
 318 static const u64 *parent_cfg_handle(struct mdesc_handle *hp, u64 node)
 319 {
 320         const u64 *id;
 321         u64 a;
 322
 323         id = NULL;
 324         mdesc_for_each_arc(a, hp, node, MDESC_ARC_TYPE_BACK) {
 325                 u64 target;
 326
 327                 target = mdesc_arc_target(hp, a);
 328                 id = mdesc_get_property(hp, target,
 329                                         "cfg-handle", NULL);
 330                 if (id)
 331                         break;
 332         }
 333
 334         return id;
 335 }
 336
 337 static int get_vdev_port_node_info(struct mdesc_handle *md, u64 node,
 338                                    union md_node_info *node_info)
 339 {
 340         const u64 *parent_cfg_hdlp;
 341         const char *name;
 342         const u64 *idp;
 343
 344         /*
 345          * Virtual device nodes are distinguished by:
 346          * 1. "id" property
 347          * 2. "name" property
 348          * 3. parent node "cfg-handle" property
 349          */
 350         idp = mdesc_get_property(md, node, "id", NULL);
 351         name = mdesc_get_property(md, node, "name", NULL);
 352         parent_cfg_hdlp = parent_cfg_handle(md, node);
 353
 354         if (!idp || !name || !parent_cfg_hdlp)
 355                 return -1;
 356
 357         node_info->vdev_port.id = *idp;
 358         node_info->vdev_port.name = kstrdup_const(name, GFP_KERNEL);
 359         if (!node_info->vdev_port.name)
 360                 return -1;
 361         node_info->vdev_port.parent_cfg_hdl = *parent_cfg_hdlp;
 362
 363         return 0;
 364 }
 365
 366 static void rel_vdev_port_node_info(union md_node_info *node_info)
 367 {
 368         if (node_info && node_info->vdev_port.name) {
 369                 kfree_const(node_info->vdev_port.name);
 370                 node_info->vdev_port.name = NULL;
 371         }
 372 }
 373
 374 static bool vdev_port_node_match(union md_node_info *a_node_info,
 375                                  union md_node_info *b_node_info)
 376 {
 377         if (a_node_info->vdev_port.id != b_node_info->vdev_port.id)
 378                 return false;
 379
 380         if (a_node_info->vdev_port.parent_cfg_hdl !=
 381             b_node_info->vdev_port.parent_cfg_hdl)
 382                 return false;
 383
 384         if (strncmp(a_node_info->vdev_port.name,
 385                     b_node_info->vdev_port.name, MDESC_MAX_STR_LEN) != 0)
 386                 return false;
 387
 388         return true;
 389 }
 390
 391 static int get_ds_port_node_info(struct mdesc_handle *md, u64 node,
 392                                  union md_node_info *node_info)
 393 {
 394         const u64 *idp;
 395
 396         /* DS port nodes use the "id" property to distinguish them */
 397         idp = mdesc_get_property(md, node, "id", NULL);
 398         if (!idp)
 399                 return -1;
 400
 401         node_info->ds_port.id = *idp;
 402
 403         return 0;
 404 }
 405
 406 static void rel_ds_port_node_info(union md_node_info *node_info)
 407 {
 408 }
 409
 410 static bool ds_port_node_match(union md_node_info *a_node_info,
 411                                union md_node_info *b_node_info)
 412 {
 413         if (a_node_info->ds_port.id != b_node_info->ds_port.id)
 414                 return false;
 415
 416         return true;
 417 }
 418
 419 /* Run 'func' on nodes which are in A but not in B.  */
 420 static void invoke_on_missing(const char *name,
 421                               struct mdesc_handle *a,
 422                               struct mdesc_handle *b,
 423                               void (*func)(struct mdesc_handle *, u64,
 424                                            const char *node_name))
 425 {
 426         mdesc_node_info_get_f get_info_func;
 427         mdesc_node_info_rel_f rel_info_func;
 428         mdesc_node_match_f node_match_func;
 429         union md_node_info a_node_info;
 430         union md_node_info b_node_info;
 431         bool found;
 432         u64 a_node;
 433         u64 b_node;
 434         int rv;
 435
 436         /*
 437          * Find the get_info, rel_info and node_match ops for the given
 438          * node name
 439          */
 440         mdesc_get_node_ops(name, &get_info_func, &rel_info_func,
 441                            &node_match_func);
 442
 443         /* If we didn't find a match, the node type is not supported */
 444         if (!get_info_func || !rel_info_func || !node_match_func) {
 445                 pr_err("MD: %s node type is not supported\n", name);
 446                 return;
 447         }
 448
 449         mdesc_for_each_node_by_name(a, a_node, name) {
 450                 found = false;
 451
 452                 rv = get_info_func(a, a_node, &a_node_info);
 453                 if (rv != 0) {
 454                         pr_err("MD: Cannot find 1 or more required match properties for %s node.\n",
 455                                name);
 456                         continue;
 457                 }
 458
 459                 /* Check each node in B for node matching a_node */
 460                 mdesc_for_each_node_by_name(b, b_node, name) {
 461                         rv = get_info_func(b, b_node, &b_node_info);
 462                         if (rv != 0)
 463                                 continue;
 464
 465                         if (node_match_func(&a_node_info, &b_node_info)) {
 466                                 found = true;
 467                                 rel_info_func(&b_node_info);
 468                                 break;
 469                         }
 470
 471                         rel_info_func(&b_node_info);
 472                 }
 473
 474                 rel_info_func(&a_node_info);
 475
 476                 if (!found)
 477                         func(a, a_node, name);
 478         }
 479 }
 480
 481 static void notify_one(struct mdesc_notifier_client *p,
 482                        struct mdesc_handle *old_hp,
 483                        struct mdesc_handle *new_hp)
 484 {
 485         invoke_on_missing(p->node_name, old_hp, new_hp, p->remove);
 486         invoke_on_missing(p->node_name, new_hp, old_hp, p->add);
 487 }
 488
 489 static void mdesc_notify_clients(struct mdesc_handle *old_hp,
 490                                  struct mdesc_handle *new_hp)
 491 {
 492         struct mdesc_notifier_client *p = client_list;
 493
 494         while (p) {
 495                 notify_one(p, old_hp, new_hp);
 496                 p = p->next;
 497         }
 498 }
 499
 500 void mdesc_update(void)
 501 {
 502         unsigned long len, real_len, status;
 503         struct mdesc_handle *hp, *orig_hp;
 504         unsigned long flags;
 505
 506         mutex_lock(&mdesc_mutex);
 507
 508         (void) sun4v_mach_desc(0UL, 0UL, &len);
 509
 510         hp = mdesc_alloc(len, &kmalloc_mdesc_memops);
 511         if (!hp) {
 512                 printk(KERN_ERR "MD: mdesc alloc fails\n");
 513                 goto out;
 514         }
 515
 516         status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
 517         if (status != HV_EOK || real_len > len) {
 518                 printk(KERN_ERR "MD: mdesc reread fails with %lu\n",
 519                        status);
 520                 refcount_dec(&hp->refcnt);
 521                 mdesc_free(hp);
 522                 goto out;
 523         }
 524
 525         spin_lock_irqsave(&mdesc_lock, flags);
 526         orig_hp = cur_mdesc;
 527         cur_mdesc = hp;
 528         spin_unlock_irqrestore(&mdesc_lock, flags);
 529
 530         mdesc_notify_clients(orig_hp, hp);
 531
 532         spin_lock_irqsave(&mdesc_lock, flags);
 533         if (refcount_dec_and_test(&orig_hp->refcnt))
 534                 mdesc_free(orig_hp);
 535         else
 536                 list_add(&orig_hp->list, &mdesc_zombie_list);
 537         spin_unlock_irqrestore(&mdesc_lock, flags);
 538
 539 out:
 540         mutex_unlock(&mdesc_mutex);
 541 }
 542
 543 u64 mdesc_get_node(struct mdesc_handle *hp, const char *node_name,
 544                    union md_node_info *node_info)
 545 {
 546         mdesc_node_info_get_f get_info_func;
 547         mdesc_node_info_rel_f rel_info_func;
 548         mdesc_node_match_f node_match_func;
 549         union md_node_info hp_node_info;
 550         u64 hp_node;
 551         int rv;
 552
 553         if (hp == NULL || node_name == NULL || node_info == NULL)
 554                 return MDESC_NODE_NULL;
 555
 556         /* Find the ops for the given node name */
 557         mdesc_get_node_ops(node_name, &get_info_func, &rel_info_func,
 558                            &node_match_func);
 559
 560         /* If we didn't find ops for the given node name, it is not supported */
 561         if (!get_info_func || !rel_info_func || !node_match_func) {
 562                 pr_err("MD: %s node is not supported\n", node_name);
 563                 return -EINVAL;
 564         }
 565
 566         mdesc_for_each_node_by_name(hp, hp_node, node_name) {
 567                 rv = get_info_func(hp, hp_node, &hp_node_info);
 568                 if (rv != 0)
 569                         continue;
 570
 571                 if (node_match_func(node_info, &hp_node_info))
 572                         break;
 573
 574                 rel_info_func(&hp_node_info);
 575         }
 576
 577         rel_info_func(&hp_node_info);
 578
 579         return hp_node;
 580 }
 581 EXPORT_SYMBOL(mdesc_get_node);
 582
 583 int mdesc_get_node_info(struct mdesc_handle *hp, u64 node,
 584                         const char *node_name, union md_node_info *node_info)
 585 {
 586         mdesc_node_info_get_f get_info_func;
 587         int rv;
 588
 589         if (hp == NULL || node == MDESC_NODE_NULL ||
 590             node_name == NULL || node_info == NULL)
 591                 return -EINVAL;
 592
 593         /* Find the get_info op for the given node name */
 594         mdesc_get_node_ops(node_name, &get_info_func, NULL, NULL);
 595
 596         /* If we didn't find a get_info_func, the node name is not supported */
 597         if (get_info_func == NULL) {
 598                 pr_err("MD: %s node is not supported\n", node_name);
 599                 return -EINVAL;
 600         }
 601
 602         rv = get_info_func(hp, node, node_info);
 603         if (rv != 0) {
 604                 pr_err("MD: Cannot find 1 or more required match properties for %s node.\n",
 605                        node_name);
 606                 return -1;
 607         }
 608
 609         return 0;
 610 }
 611 EXPORT_SYMBOL(mdesc_get_node_info);
 612
 613 static struct mdesc_elem *node_block(struct mdesc_hdr *mdesc)
 614 {
 615         return (struct mdesc_elem *) (mdesc + 1);
 616 }
 617
 618 static void *name_block(struct mdesc_hdr *mdesc)
 619 {
 620         return ((void *) node_block(mdesc)) + mdesc->node_sz;
 621 }
 622
 623 static void *data_block(struct mdesc_hdr *mdesc)
 624 {
 625         return ((void *) name_block(mdesc)) + mdesc->name_sz;
 626 }
 627
 628 u64 mdesc_node_by_name(struct mdesc_handle *hp,
 629                        u64 from_node, const char *name)
 630 {
 631         struct mdesc_elem *ep = node_block(&hp->mdesc);
 632         const char *names = name_block(&hp->mdesc);
 633         u64 last_node = hp->mdesc.node_sz / 16;
 634         u64 ret;
 635
 636         if (from_node == MDESC_NODE_NULL) {
 637                 ret = from_node = 0;
 638         } else if (from_node >= last_node) {
 639                 return MDESC_NODE_NULL;
 640         } else {
 641                 ret = ep[from_node].d.val;
 642         }
 643
 644         while (ret < last_node) {
 645                 if (ep[ret].tag != MD_NODE)
 646                         return MDESC_NODE_NULL;
 647                 if (!strcmp(names + ep[ret].name_offset, name))
 648                         break;
 649                 ret = ep[ret].d.val;
 650         }
 651         if (ret >= last_node)
 652                 ret = MDESC_NODE_NULL;
 653         return ret;
 654 }
 655 EXPORT_SYMBOL(mdesc_node_by_name);
 656
 657 const void *mdesc_get_property(struct mdesc_handle *hp, u64 node,
 658                                const char *name, int *lenp)
 659 {
 660         const char *names = name_block(&hp->mdesc);
 661         u64 last_node = hp->mdesc.node_sz / 16;
 662         void *data = data_block(&hp->mdesc);
 663         struct mdesc_elem *ep;
 664
 665         if (node == MDESC_NODE_NULL || node >= last_node)
 666                 return NULL;
 667
 668         ep = node_block(&hp->mdesc) + node;
 669         ep++;
 670         for (; ep->tag != MD_NODE_END; ep++) {
 671                 void *val = NULL;
 672                 int len = 0;
 673
 674                 switch (ep->tag) {
 675                 case MD_PROP_VAL:
 676                         val = &ep->d.val;
 677                         len = 8;
 678                         break;
 679
 680                 case MD_PROP_STR:
 681                 case MD_PROP_DATA:
 682                         val = data + ep->d.data.data_offset;
 683                         len = ep->d.data.data_len;
 684                         break;
 685
 686                 default:
 687                         break;
 688                 }
 689                 if (!val)
 690                         continue;
 691
 692                 if (!strcmp(names + ep->name_offset, name)) {
 693                         if (lenp)
 694                                 *lenp = len;
 695                         return val;
 696                 }
 697         }
 698
 699         return NULL;
 700 }
 701 EXPORT_SYMBOL(mdesc_get_property);
 702
 703 u64 mdesc_next_arc(struct mdesc_handle *hp, u64 from, const char *arc_type)
 704 {
 705         struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
 706         const char *names = name_block(&hp->mdesc);
 707         u64 last_node = hp->mdesc.node_sz / 16;
 708
 709         if (from == MDESC_NODE_NULL || from >= last_node)
 710                 return MDESC_NODE_NULL;
 711
 712         ep = base + from;
 713
 714         ep++;
 715         for (; ep->tag != MD_NODE_END; ep++) {
 716                 if (ep->tag != MD_PROP_ARC)
 717                         continue;
 718
 719                 if (strcmp(names + ep->name_offset, arc_type))
 720                         continue;
 721
 722                 return ep - base;
 723         }
 724
 725         return MDESC_NODE_NULL;
 726 }
 727 EXPORT_SYMBOL(mdesc_next_arc);
 728
 729 u64 mdesc_arc_target(struct mdesc_handle *hp, u64 arc)
 730 {
 731         struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
 732
 733         ep = base + arc;
 734
 735         return ep->d.val;
 736 }
 737 EXPORT_SYMBOL(mdesc_arc_target);
 738
 739 const char *mdesc_node_name(struct mdesc_handle *hp, u64 node)
 740 {
 741         struct mdesc_elem *ep, *base = node_block(&hp->mdesc);
 742         const char *names = name_block(&hp->mdesc);
 743         u64 last_node = hp->mdesc.node_sz / 16;
 744
 745         if (node == MDESC_NODE_NULL || node >= last_node)
 746                 return NULL;
 747
 748         ep = base + node;
 749         if (ep->tag != MD_NODE)
 750                 return NULL;
 751
 752         return names + ep->name_offset;
 753 }
 754 EXPORT_SYMBOL(mdesc_node_name);
 755
 756 static u64 max_cpus = 64;
 757
 758 static void __init report_platform_properties(void)
 759 {
 760         struct mdesc_handle *hp = mdesc_grab();
 761         u64 pn = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform");
 762         const char *s;
 763         const u64 *v;
 764
 765         if (pn == MDESC_NODE_NULL) {
 766                 prom_printf("No platform node in machine-description.\n");
 767                 prom_halt();
 768         }
 769
 770         s = mdesc_get_property(hp, pn, "banner-name", NULL);
 771         printk("PLATFORM: banner-name [%s]\n", s);
 772         s = mdesc_get_property(hp, pn, "name", NULL);
 773         printk("PLATFORM: name [%s]\n", s);
 774
 775         v = mdesc_get_property(hp, pn, "hostid", NULL);
 776         if (v)
 777                 printk("PLATFORM: hostid [%08llx]\n", *v);
 778         v = mdesc_get_property(hp, pn, "serial#", NULL);
 779         if (v)
 780                 printk("PLATFORM: serial# [%08llx]\n", *v);
 781         v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
 782         printk("PLATFORM: stick-frequency [%08llx]\n", *v);
 783         v = mdesc_get_property(hp, pn, "mac-address", NULL);
 784         if (v)
 785                 printk("PLATFORM: mac-address [%llx]\n", *v);
 786         v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
 787         if (v)
 788                 printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v);
 789         v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
 790         if (v)
 791                 printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v);
 792         v = mdesc_get_property(hp, pn, "max-cpus", NULL);
 793         if (v) {
 794                 max_cpus = *v;
 795                 printk("PLATFORM: max-cpus [%llu]\n", max_cpus);
 796         }
 797
 798 #ifdef CONFIG_SMP
 799         {
 800                 int max_cpu, i;
 801
 802                 if (v) {
 803                         max_cpu = *v;
 804                         if (max_cpu > NR_CPUS)
 805                                 max_cpu = NR_CPUS;
 806                 } else {
 807                         max_cpu = NR_CPUS;
 808                 }
 809                 for (i = 0; i < max_cpu; i++)
 810                         set_cpu_possible(i, true);
 811         }
 812 #endif
 813
 814         mdesc_release(hp);
 815 }
 816
 817 static void fill_in_one_cache(cpuinfo_sparc *c, struct mdesc_handle *hp, u64 mp)
 818 {
 819         const u64 *level = mdesc_get_property(hp, mp, "level", NULL);
 820         const u64 *size = mdesc_get_property(hp, mp, "size", NULL);
 821         const u64 *line_size = mdesc_get_property(hp, mp, "line-size", NULL);
 822         const char *type;
 823         int type_len;
 824
 825         type = mdesc_get_property(hp, mp, "type", &type_len);
 826
 827         switch (*level) {
 828         case 1:
 829                 if (of_find_in_proplist(type, "instn", type_len)) {
 830                         c->icache_size = *size;
 831                         c->icache_line_size = *line_size;
 832                 } else if (of_find_in_proplist(type, "data", type_len)) {
 833                         c->dcache_size = *size;
 834                         c->dcache_line_size = *line_size;
 835                 }
 836                 break;
 837
 838         case 2:
 839                 c->ecache_size = *size;
 840                 c->ecache_line_size = *line_size;
 841                 break;
 842
 843         default:
 844                 break;
 845         }
 846
 847         if (*level == 1) {
 848                 u64 a;
 849
 850                 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
 851                         u64 target = mdesc_arc_target(hp, a);
 852                         const char *name = mdesc_node_name(hp, target);
 853
 854                         if (!strcmp(name, "cache"))
 855                                 fill_in_one_cache(c, hp, target);
 856                 }
 857         }
 858 }
 859
 860 static void find_back_node_value(struct mdesc_handle *hp, u64 node,
 861                                  char *srch_val,
 862                                  void (*func)(struct mdesc_handle *, u64, int),
 863                                  u64 val, int depth)
 864 {
 865         u64 arc;
 866
 867         /* Since we have an estimate of recursion depth, do a sanity check. */
 868         if (depth == 0)
 869                 return;
 870
 871         mdesc_for_each_arc(arc, hp, node, MDESC_ARC_TYPE_BACK) {
 872                 u64 n = mdesc_arc_target(hp, arc);
 873                 const char *name = mdesc_node_name(hp, n);
 874
 875                 if (!strcmp(srch_val, name))
 876                         (*func)(hp, n, val);
 877
 878                 find_back_node_value(hp, n, srch_val, func, val, depth-1);
 879         }
 880 }
 881
 882 static void __mark_core_id(struct mdesc_handle *hp, u64 node,
 883                            int core_id)
 884 {
 885         const u64 *id = mdesc_get_property(hp, node, "id", NULL);
 886
 887         if (*id < num_possible_cpus())
 888                 cpu_data(*id).core_id = core_id;
 889 }
 890
 891 static void __mark_max_cache_id(struct mdesc_handle *hp, u64 node,
 892                                 int max_cache_id)
 893 {
 894         const u64 *id = mdesc_get_property(hp, node, "id", NULL);
 895
 896         if (*id < num_possible_cpus()) {
 897                 cpu_data(*id).max_cache_id = max_cache_id;
 898
 899                 /**
 900                  * On systems without explicit socket descriptions socket
 901                  * is max_cache_id
 902                  */
 903                 cpu_data(*id).sock_id = max_cache_id;
 904         }
 905 }
 906
 907 static void mark_core_ids(struct mdesc_handle *hp, u64 mp,
 908                           int core_id)
 909 {
 910         find_back_node_value(hp, mp, "cpu", __mark_core_id, core_id, 10);
 911 }
 912
 913 static void mark_max_cache_ids(struct mdesc_handle *hp, u64 mp,
 914                                int max_cache_id)
 915 {
 916         find_back_node_value(hp, mp, "cpu", __mark_max_cache_id,
 917                              max_cache_id, 10);
 918 }
 919
 920 static void set_core_ids(struct mdesc_handle *hp)
 921 {
 922         int idx;
 923         u64 mp;
 924
 925         idx = 1;
 926
 927         /* Identify unique cores by looking for cpus backpointed to by
 928          * level 1 instruction caches.
 929          */
 930         mdesc_for_each_node_by_name(hp, mp, "cache") {
 931                 const u64 *level;
 932                 const char *type;
 933                 int len;
 934
 935                 level = mdesc_get_property(hp, mp, "level", NULL);
 936                 if (*level != 1)
 937                         continue;
 938
 939                 type = mdesc_get_property(hp, mp, "type", &len);
 940                 if (!of_find_in_proplist(type, "instn", len))
 941                         continue;
 942
 943                 mark_core_ids(hp, mp, idx);
 944                 idx++;
 945         }
 946 }
 947
 948 static int set_max_cache_ids_by_cache(struct mdesc_handle *hp, int level)
 949 {
 950         u64 mp;
 951         int idx = 1;
 952         int fnd = 0;
 953
 954         /**
 955          * Identify unique highest level of shared cache by looking for cpus
 956          * backpointed to by shared level N caches.
 957          */
 958         mdesc_for_each_node_by_name(hp, mp, "cache") {
 959                 const u64 *cur_lvl;
 960
 961                 cur_lvl = mdesc_get_property(hp, mp, "level", NULL);
 962                 if (*cur_lvl != level)
 963                         continue;
 964                 mark_max_cache_ids(hp, mp, idx);
 965                 idx++;
 966                 fnd = 1;
 967         }
 968         return fnd;
 969 }
 970
 971 static void set_sock_ids_by_socket(struct mdesc_handle *hp, u64 mp)
 972 {
 973         int idx = 1;
 974
 975         mdesc_for_each_node_by_name(hp, mp, "socket") {
 976                 u64 a;
 977
 978                 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
 979                         u64 t = mdesc_arc_target(hp, a);
 980                         const char *name;
 981                         const u64 *id;
 982
 983                         name = mdesc_node_name(hp, t);
 984                         if (strcmp(name, "cpu"))
 985                                 continue;
 986
 987                         id = mdesc_get_property(hp, t, "id", NULL);
 988                         if (*id < num_possible_cpus())
 989                                 cpu_data(*id).sock_id = idx;
 990                 }
 991                 idx++;
 992         }
 993 }
 994
 995 static void set_sock_ids(struct mdesc_handle *hp)
 996 {
 997         u64 mp;
 998
 999         /**
1000          * Find the highest level of shared cache which pre-T7 is also
1001          * the socket.
1002          */
1003         if (!set_max_cache_ids_by_cache(hp, 3))
1004                 set_max_cache_ids_by_cache(hp, 2);
1005
1006         /* If machine description exposes sockets data use it.*/
1007         mp = mdesc_node_by_name(hp, MDESC_NODE_NULL, "sockets");
1008         if (mp != MDESC_NODE_NULL)
1009                 set_sock_ids_by_socket(hp, mp);
1010 }
1011
1012 static void mark_proc_ids(struct mdesc_handle *hp, u64 mp, int proc_id)
1013 {
1014         u64 a;
1015
1016         mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) {
1017                 u64 t = mdesc_arc_target(hp, a);
1018                 const char *name;
1019                 const u64 *id;
1020
1021                 name = mdesc_node_name(hp, t);
1022                 if (strcmp(name, "cpu"))
1023                         continue;
1024
1025                 id = mdesc_get_property(hp, t, "id", NULL);
1026                 if (*id < NR_CPUS)
1027                         cpu_data(*id).proc_id = proc_id;
1028         }
1029 }
1030
1031 static void __set_proc_ids(struct mdesc_handle *hp, const char *exec_unit_name)
1032 {
1033         int idx;
1034         u64 mp;
1035
1036         idx = 0;
1037         mdesc_for_each_node_by_name(hp, mp, exec_unit_name) {
1038                 const char *type;
1039                 int len;
1040
1041                 type = mdesc_get_property(hp, mp, "type", &len);
1042                 if (!of_find_in_proplist(type, "int", len) &&
1043                     !of_find_in_proplist(type, "integer", len))
1044                         continue;
1045
1046                 mark_proc_ids(hp, mp, idx);
1047                 idx++;
1048         }
1049 }
1050
1051 static void set_proc_ids(struct mdesc_handle *hp)
1052 {
1053         __set_proc_ids(hp, "exec_unit");
1054         __set_proc_ids(hp, "exec-unit");
1055 }
1056
1057 static void get_one_mondo_bits(const u64 *p, unsigned int *mask,
1058                                unsigned long def, unsigned long max)
1059 {
1060         u64 val;
1061
1062         if (!p)
1063                 goto use_default;
1064         val = *p;
1065
1066         if (!val || val >= 64)
1067                 goto use_default;
1068
1069         if (val > max)
1070                 val = max;
1071
1072         *mask = ((1U << val) * 64U) - 1U;
1073         return;
1074
1075 use_default:
1076         *mask = ((1U << def) * 64U) - 1U;
1077 }
1078
1079 static void get_mondo_data(struct mdesc_handle *hp, u64 mp,
1080                            struct trap_per_cpu *tb)
1081 {
1082         static int printed;
1083         const u64 *val;
1084
1085         val = mdesc_get_property(hp, mp, "q-cpu-mondo-#bits", NULL);
1086         get_one_mondo_bits(val, &tb->cpu_mondo_qmask, 7, ilog2(max_cpus * 2));
1087
1088         val = mdesc_get_property(hp, mp, "q-dev-mondo-#bits", NULL);
1089         get_one_mondo_bits(val, &tb->dev_mondo_qmask, 7, 8);
1090
1091         val = mdesc_get_property(hp, mp, "q-resumable-#bits", NULL);
1092         get_one_mondo_bits(val, &tb->resum_qmask, 6, 7);
1093
1094         val = mdesc_get_property(hp, mp, "q-nonresumable-#bits", NULL);
1095         get_one_mondo_bits(val, &tb->nonresum_qmask, 2, 2);
1096         if (!printed++) {
1097                 pr_info("SUN4V: Mondo queue sizes "
1098                         "[cpu(%u) dev(%u) r(%u) nr(%u)]\n",
1099                         tb->cpu_mondo_qmask + 1,
1100                         tb->dev_mondo_qmask + 1,
1101                         tb->resum_qmask + 1,
1102                         tb->nonresum_qmask + 1);
1103         }
1104 }
1105
1106 static void *mdesc_iterate_over_cpus(void *(*func)(struct mdesc_handle *, u64, int, void *), void *arg, cpumask_t *mask)
1107 {
1108         struct mdesc_handle *hp = mdesc_grab();
1109         void *ret = NULL;
1110         u64 mp;
1111
1112         mdesc_for_each_node_by_name(hp, mp, "cpu") {
1113                 const u64 *id = mdesc_get_property(hp, mp, "id", NULL);
1114                 int cpuid = *id;
1115
1116 #ifdef CONFIG_SMP
1117                 if (cpuid >= NR_CPUS) {
1118                         printk(KERN_WARNING "Ignoring CPU %d which is "
1119                                ">= NR_CPUS (%d)\n",
1120                                cpuid, NR_CPUS);
1121                         continue;
1122                 }
1123                 if (!cpumask_test_cpu(cpuid, mask))
1124                         continue;
1125 #endif
1126
1127                 ret = func(hp, mp, cpuid, arg);
1128                 if (ret)
1129                         goto out;
1130         }
1131 out:
1132         mdesc_release(hp);
1133         return ret;
1134 }
1135
1136 static void *record_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid,
1137                             void *arg)
1138 {
1139         ncpus_probed++;
1140 #ifdef CONFIG_SMP
1141         set_cpu_present(cpuid, true);
1142 #endif
1143         return NULL;
1144 }
1145
1146 void mdesc_populate_present_mask(cpumask_t *mask)
1147 {
1148         if (tlb_type != hypervisor)
1149                 return;
1150
1151         ncpus_probed = 0;
1152         mdesc_iterate_over_cpus(record_one_cpu, NULL, mask);
1153 }
1154
1155 static void * __init check_one_pgsz(struct mdesc_handle *hp, u64 mp, int cpuid, void *arg)
1156 {
1157         const u64 *pgsz_prop = mdesc_get_property(hp, mp, "mmu-page-size-list", NULL);
1158         unsigned long *pgsz_mask = arg;
1159         u64 val;
1160
1161         val = (HV_PGSZ_MASK_8K | HV_PGSZ_MASK_64K |
1162                HV_PGSZ_MASK_512K | HV_PGSZ_MASK_4MB);
1163         if (pgsz_prop)
1164                 val = *pgsz_prop;
1165
1166         if (!*pgsz_mask)
1167                 *pgsz_mask = val;
1168         else
1169                 *pgsz_mask &= val;
1170         return NULL;
1171 }
1172
1173 void __init mdesc_get_page_sizes(cpumask_t *mask, unsigned long *pgsz_mask)
1174 {
1175         *pgsz_mask = 0;
1176         mdesc_iterate_over_cpus(check_one_pgsz, pgsz_mask, mask);
1177 }
1178
1179 static void *fill_in_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid,
1180                              void *arg)
1181 {
1182         const u64 *cfreq = mdesc_get_property(hp, mp, "clock-frequency", NULL);
1183         struct trap_per_cpu *tb;
1184         cpuinfo_sparc *c;
1185         u64 a;
1186
1187 #ifndef CONFIG_SMP
1188         /* On uniprocessor we only want the values for the
1189          * real physical cpu the kernel booted onto, however
1190          * cpu_data() only has one entry at index 0.
1191          */
1192         if (cpuid != real_hard_smp_processor_id())
1193                 return NULL;
1194         cpuid = 0;
1195 #endif
1196
1197         c = &cpu_data(cpuid);
1198         c->clock_tick = *cfreq;
1199
1200         tb = &trap_block[cpuid];
1201         get_mondo_data(hp, mp, tb);
1202
1203         mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) {
1204                 u64 j, t = mdesc_arc_target(hp, a);
1205                 const char *t_name;
1206
1207                 t_name = mdesc_node_name(hp, t);
1208                 if (!strcmp(t_name, "cache")) {
1209                         fill_in_one_cache(c, hp, t);
1210                         continue;
1211                 }
1212
1213                 mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_FWD) {
1214                         u64 n = mdesc_arc_target(hp, j);
1215                         const char *n_name;
1216
1217                         n_name = mdesc_node_name(hp, n);
1218                         if (!strcmp(n_name, "cache"))
1219                                 fill_in_one_cache(c, hp, n);
1220                 }
1221         }
1222
1223         c->core_id = 0;
1224         c->proc_id = -1;
1225
1226         return NULL;
1227 }
1228
1229 void mdesc_fill_in_cpu_data(cpumask_t *mask)
1230 {
1231         struct mdesc_handle *hp;
1232
1233         mdesc_iterate_over_cpus(fill_in_one_cpu, NULL, mask);
1234
1235         hp = mdesc_grab();
1236
1237         set_core_ids(hp);
1238         set_proc_ids(hp);
1239         set_sock_ids(hp);
1240
1241         mdesc_release(hp);
1242
1243         smp_fill_in_sib_core_maps();
1244 }
1245
1246 /* mdesc_open() - Grab a reference to mdesc_handle when /dev/mdesc is
1247  * opened. Hold this reference until /dev/mdesc is closed to ensure
1248  * mdesc data structure is not released underneath us. Store the
1249  * pointer to mdesc structure in private_data for read and seek to use
1250  */
1251 static int mdesc_open(struct inode *inode, struct file *file)
1252 {
1253         struct mdesc_handle *hp = mdesc_grab();
1254
1255         if (!hp)
1256                 return -ENODEV;
1257
1258         file->private_data = hp;
1259
1260         return 0;
1261 }
1262
1263 static ssize_t mdesc_read(struct file *file, char __user *buf,
1264                           size_t len, loff_t *offp)
1265 {
1266         struct mdesc_handle *hp = file->private_data;
1267         unsigned char *mdesc;
1268         int bytes_left, count = len;
1269
1270         if (*offp >= hp->handle_size)
1271                 return 0;
1272
1273         bytes_left = hp->handle_size - *offp;
1274         if (count > bytes_left)
1275                 count = bytes_left;
1276
1277         mdesc = (unsigned char *)&hp->mdesc;
1278         mdesc += *offp;
1279         if (!copy_to_user(buf, mdesc, count)) {
1280                 *offp += count;
1281                 return count;
1282         } else {
1283                 return -EFAULT;
1284         }
1285 }
1286
1287 static loff_t mdesc_llseek(struct file *file, loff_t offset, int whence)
1288 {
1289         struct mdesc_handle *hp = file->private_data;
1290
1291         return no_seek_end_llseek_size(file, offset, whence, hp->handle_size);
1292 }
1293
1294 /* mdesc_close() - /dev/mdesc is being closed, release the reference to
1295  * mdesc structure.
1296  */
1297 static int mdesc_close(struct inode *inode, struct file *file)
1298 {
1299         mdesc_release(file->private_data);
1300         return 0;
1301 }
1302
1303 static const struct file_operations mdesc_fops = {
1304         .open    = mdesc_open,
1305         .read    = mdesc_read,
1306         .llseek  = mdesc_llseek,
1307         .release = mdesc_close,
1308         .owner   = THIS_MODULE,
1309 };
1310
1311 static struct miscdevice mdesc_misc = {
1312         .minor  = MISC_DYNAMIC_MINOR,
1313         .name   = "mdesc",
1314         .fops   = &mdesc_fops,
1315 };
1316
1317 static int __init mdesc_misc_init(void)
1318 {
1319         return misc_register(&mdesc_misc);
1320 }
1321
1322 __initcall(mdesc_misc_init);
1323
1324 void __init sun4v_mdesc_init(void)
1325 {
1326         struct mdesc_handle *hp;
1327         unsigned long len, real_len, status;
1328
1329         (void) sun4v_mach_desc(0UL, 0UL, &len);
1330
1331         printk("MDESC: Size is %lu bytes.\n", len);
1332
1333         hp = mdesc_alloc(len, &memblock_mdesc_ops);
1334         if (hp == NULL) {
1335                 prom_printf("MDESC: alloc of %lu bytes failed.\n", len);
1336                 prom_halt();
1337         }
1338
1339         status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len);
1340         if (status != HV_EOK || real_len > len) {
1341                 prom_printf("sun4v_mach_desc fails, err(%lu), "
1342                             "len(%lu), real_len(%lu)\n",
1343                             status, len, real_len);
1344                 mdesc_free(hp);
1345                 prom_halt();
1346         }
1347
1348         cur_mdesc = hp;
1349
1350         mdesc_adi_init();
1351         report_platform_properties();
1352 }