1 /* mdesc.c: Sun4V machine description handling. 2 * 3 * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net> 4 */ 5 #include <linux/kernel.h> 6 #include <linux/types.h> 7 #include <linux/lmb.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 14 #include <asm/cpudata.h> 15 #include <asm/hypervisor.h> 16 #include <asm/mdesc.h> 17 #include <asm/prom.h> 18 #include <asm/oplib.h> 19 #include <asm/smp.h> 20 21 /* Unlike the OBP device tree, the machine description is a full-on 22 * DAG. An arbitrary number of ARCs are possible from one 23 * node to other nodes and thus we can't use the OBP device_node 24 * data structure to represent these nodes inside of the kernel. 25 * 26 * Actually, it isn't even a DAG, because there are back pointers 27 * which create cycles in the graph. 28 * 29 * mdesc_hdr and mdesc_elem describe the layout of the data structure 30 * we get from the Hypervisor. 31 */ 32 struct mdesc_hdr { 33 u32 version; /* Transport version */ 34 u32 node_sz; /* node block size */ 35 u32 name_sz; /* name block size */ 36 u32 data_sz; /* data block size */ 37 } __attribute__((aligned(16))); 38 39 struct mdesc_elem { 40 u8 tag; 41 #define MD_LIST_END 0x00 42 #define MD_NODE 0x4e 43 #define MD_NODE_END 0x45 44 #define MD_NOOP 0x20 45 #define MD_PROP_ARC 0x61 46 #define MD_PROP_VAL 0x76 47 #define MD_PROP_STR 0x73 48 #define MD_PROP_DATA 0x64 49 u8 name_len; 50 u16 resv; 51 u32 name_offset; 52 union { 53 struct { 54 u32 data_len; 55 u32 data_offset; 56 } data; 57 u64 val; 58 } d; 59 }; 60 61 struct mdesc_mem_ops { 62 struct mdesc_handle *(*alloc)(unsigned int mdesc_size); 63 void (*free)(struct mdesc_handle *handle); 64 }; 65 66 struct mdesc_handle { 67 struct list_head list; 68 struct mdesc_mem_ops *mops; 69 void *self_base; 70 atomic_t refcnt; 71 unsigned int handle_size; 72 struct mdesc_hdr mdesc; 73 }; 74 75 static void mdesc_handle_init(struct mdesc_handle *hp, 76 unsigned int handle_size, 77 void *base) 78 { 79 BUG_ON(((unsigned long)&hp->mdesc) & (16UL - 1)); 80 81 memset(hp, 0, handle_size); 82 INIT_LIST_HEAD(&hp->list); 83 hp->self_base = base; 84 atomic_set(&hp->refcnt, 1); 85 hp->handle_size = handle_size; 86 } 87 88 static struct mdesc_handle * __init mdesc_lmb_alloc(unsigned int mdesc_size) 89 { 90 unsigned int handle_size, alloc_size; 91 struct mdesc_handle *hp; 92 unsigned long paddr; 93 94 handle_size = (sizeof(struct mdesc_handle) - 95 sizeof(struct mdesc_hdr) + 96 mdesc_size); 97 alloc_size = PAGE_ALIGN(handle_size); 98 99 paddr = lmb_alloc(alloc_size, PAGE_SIZE); 100 101 hp = NULL; 102 if (paddr) { 103 hp = __va(paddr); 104 mdesc_handle_init(hp, handle_size, hp); 105 } 106 return hp; 107 } 108 109 static void mdesc_lmb_free(struct mdesc_handle *hp) 110 { 111 unsigned int alloc_size, handle_size = hp->handle_size; 112 unsigned long start, end; 113 114 BUG_ON(atomic_read(&hp->refcnt) != 0); 115 BUG_ON(!list_empty(&hp->list)); 116 117 alloc_size = PAGE_ALIGN(handle_size); 118 119 start = (unsigned long) hp; 120 end = start + alloc_size; 121 122 while (start < end) { 123 struct page *p; 124 125 p = virt_to_page(start); 126 ClearPageReserved(p); 127 __free_page(p); 128 start += PAGE_SIZE; 129 } 130 } 131 132 static struct mdesc_mem_ops lmb_mdesc_ops = { 133 .alloc = mdesc_lmb_alloc, 134 .free = mdesc_lmb_free, 135 }; 136 137 static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size) 138 { 139 unsigned int handle_size; 140 void *base; 141 142 handle_size = (sizeof(struct mdesc_handle) - 143 sizeof(struct mdesc_hdr) + 144 mdesc_size); 145 146 base = kmalloc(handle_size + 15, GFP_KERNEL | __GFP_NOFAIL); 147 if (base) { 148 struct mdesc_handle *hp; 149 unsigned long addr; 150 151 addr = (unsigned long)base; 152 addr = (addr + 15UL) & ~15UL; 153 hp = (struct mdesc_handle *) addr; 154 155 mdesc_handle_init(hp, handle_size, base); 156 return hp; 157 } 158 159 return NULL; 160 } 161 162 static void mdesc_kfree(struct mdesc_handle *hp) 163 { 164 BUG_ON(atomic_read(&hp->refcnt) != 0); 165 BUG_ON(!list_empty(&hp->list)); 166 167 kfree(hp->self_base); 168 } 169 170 static struct mdesc_mem_ops kmalloc_mdesc_memops = { 171 .alloc = mdesc_kmalloc, 172 .free = mdesc_kfree, 173 }; 174 175 static struct mdesc_handle *mdesc_alloc(unsigned int mdesc_size, 176 struct mdesc_mem_ops *mops) 177 { 178 struct mdesc_handle *hp = mops->alloc(mdesc_size); 179 180 if (hp) 181 hp->mops = mops; 182 183 return hp; 184 } 185 186 static void mdesc_free(struct mdesc_handle *hp) 187 { 188 hp->mops->free(hp); 189 } 190 191 static struct mdesc_handle *cur_mdesc; 192 static LIST_HEAD(mdesc_zombie_list); 193 static DEFINE_SPINLOCK(mdesc_lock); 194 195 struct mdesc_handle *mdesc_grab(void) 196 { 197 struct mdesc_handle *hp; 198 unsigned long flags; 199 200 spin_lock_irqsave(&mdesc_lock, flags); 201 hp = cur_mdesc; 202 if (hp) 203 atomic_inc(&hp->refcnt); 204 spin_unlock_irqrestore(&mdesc_lock, flags); 205 206 return hp; 207 } 208 EXPORT_SYMBOL(mdesc_grab); 209 210 void mdesc_release(struct mdesc_handle *hp) 211 { 212 unsigned long flags; 213 214 spin_lock_irqsave(&mdesc_lock, flags); 215 if (atomic_dec_and_test(&hp->refcnt)) { 216 list_del_init(&hp->list); 217 hp->mops->free(hp); 218 } 219 spin_unlock_irqrestore(&mdesc_lock, flags); 220 } 221 EXPORT_SYMBOL(mdesc_release); 222 223 static DEFINE_MUTEX(mdesc_mutex); 224 static struct mdesc_notifier_client *client_list; 225 226 void mdesc_register_notifier(struct mdesc_notifier_client *client) 227 { 228 u64 node; 229 230 mutex_lock(&mdesc_mutex); 231 client->next = client_list; 232 client_list = client; 233 234 mdesc_for_each_node_by_name(cur_mdesc, node, client->node_name) 235 client->add(cur_mdesc, node); 236 237 mutex_unlock(&mdesc_mutex); 238 } 239 240 static const u64 *parent_cfg_handle(struct mdesc_handle *hp, u64 node) 241 { 242 const u64 *id; 243 u64 a; 244 245 id = NULL; 246 mdesc_for_each_arc(a, hp, node, MDESC_ARC_TYPE_BACK) { 247 u64 target; 248 249 target = mdesc_arc_target(hp, a); 250 id = mdesc_get_property(hp, target, 251 "cfg-handle", NULL); 252 if (id) 253 break; 254 } 255 256 return id; 257 } 258 259 /* Run 'func' on nodes which are in A but not in B. */ 260 static void invoke_on_missing(const char *name, 261 struct mdesc_handle *a, 262 struct mdesc_handle *b, 263 void (*func)(struct mdesc_handle *, u64)) 264 { 265 u64 node; 266 267 mdesc_for_each_node_by_name(a, node, name) { 268 int found = 0, is_vdc_port = 0; 269 const char *name_prop; 270 const u64 *id; 271 u64 fnode; 272 273 name_prop = mdesc_get_property(a, node, "name", NULL); 274 if (name_prop && !strcmp(name_prop, "vdc-port")) { 275 is_vdc_port = 1; 276 id = parent_cfg_handle(a, node); 277 } else 278 id = mdesc_get_property(a, node, "id", NULL); 279 280 if (!id) { 281 printk(KERN_ERR "MD: Cannot find ID for %s node.\n", 282 (name_prop ? name_prop : name)); 283 continue; 284 } 285 286 mdesc_for_each_node_by_name(b, fnode, name) { 287 const u64 *fid; 288 289 if (is_vdc_port) { 290 name_prop = mdesc_get_property(b, fnode, 291 "name", NULL); 292 if (!name_prop || 293 strcmp(name_prop, "vdc-port")) 294 continue; 295 fid = parent_cfg_handle(b, fnode); 296 if (!fid) { 297 printk(KERN_ERR "MD: Cannot find ID " 298 "for vdc-port node.\n"); 299 continue; 300 } 301 } else 302 fid = mdesc_get_property(b, fnode, 303 "id", NULL); 304 305 if (*id == *fid) { 306 found = 1; 307 break; 308 } 309 } 310 if (!found) 311 func(a, node); 312 } 313 } 314 315 static void notify_one(struct mdesc_notifier_client *p, 316 struct mdesc_handle *old_hp, 317 struct mdesc_handle *new_hp) 318 { 319 invoke_on_missing(p->node_name, old_hp, new_hp, p->remove); 320 invoke_on_missing(p->node_name, new_hp, old_hp, p->add); 321 } 322 323 static void mdesc_notify_clients(struct mdesc_handle *old_hp, 324 struct mdesc_handle *new_hp) 325 { 326 struct mdesc_notifier_client *p = client_list; 327 328 while (p) { 329 notify_one(p, old_hp, new_hp); 330 p = p->next; 331 } 332 } 333 334 void mdesc_update(void) 335 { 336 unsigned long len, real_len, status; 337 struct mdesc_handle *hp, *orig_hp; 338 unsigned long flags; 339 340 mutex_lock(&mdesc_mutex); 341 342 (void) sun4v_mach_desc(0UL, 0UL, &len); 343 344 hp = mdesc_alloc(len, &kmalloc_mdesc_memops); 345 if (!hp) { 346 printk(KERN_ERR "MD: mdesc alloc fails\n"); 347 goto out; 348 } 349 350 status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len); 351 if (status != HV_EOK || real_len > len) { 352 printk(KERN_ERR "MD: mdesc reread fails with %lu\n", 353 status); 354 atomic_dec(&hp->refcnt); 355 mdesc_free(hp); 356 goto out; 357 } 358 359 spin_lock_irqsave(&mdesc_lock, flags); 360 orig_hp = cur_mdesc; 361 cur_mdesc = hp; 362 spin_unlock_irqrestore(&mdesc_lock, flags); 363 364 mdesc_notify_clients(orig_hp, hp); 365 366 spin_lock_irqsave(&mdesc_lock, flags); 367 if (atomic_dec_and_test(&orig_hp->refcnt)) 368 mdesc_free(orig_hp); 369 else 370 list_add(&orig_hp->list, &mdesc_zombie_list); 371 spin_unlock_irqrestore(&mdesc_lock, flags); 372 373 out: 374 mutex_unlock(&mdesc_mutex); 375 } 376 377 static struct mdesc_elem *node_block(struct mdesc_hdr *mdesc) 378 { 379 return (struct mdesc_elem *) (mdesc + 1); 380 } 381 382 static void *name_block(struct mdesc_hdr *mdesc) 383 { 384 return ((void *) node_block(mdesc)) + mdesc->node_sz; 385 } 386 387 static void *data_block(struct mdesc_hdr *mdesc) 388 { 389 return ((void *) name_block(mdesc)) + mdesc->name_sz; 390 } 391 392 u64 mdesc_node_by_name(struct mdesc_handle *hp, 393 u64 from_node, const char *name) 394 { 395 struct mdesc_elem *ep = node_block(&hp->mdesc); 396 const char *names = name_block(&hp->mdesc); 397 u64 last_node = hp->mdesc.node_sz / 16; 398 u64 ret; 399 400 if (from_node == MDESC_NODE_NULL) { 401 ret = from_node = 0; 402 } else if (from_node >= last_node) { 403 return MDESC_NODE_NULL; 404 } else { 405 ret = ep[from_node].d.val; 406 } 407 408 while (ret < last_node) { 409 if (ep[ret].tag != MD_NODE) 410 return MDESC_NODE_NULL; 411 if (!strcmp(names + ep[ret].name_offset, name)) 412 break; 413 ret = ep[ret].d.val; 414 } 415 if (ret >= last_node) 416 ret = MDESC_NODE_NULL; 417 return ret; 418 } 419 EXPORT_SYMBOL(mdesc_node_by_name); 420 421 const void *mdesc_get_property(struct mdesc_handle *hp, u64 node, 422 const char *name, int *lenp) 423 { 424 const char *names = name_block(&hp->mdesc); 425 u64 last_node = hp->mdesc.node_sz / 16; 426 void *data = data_block(&hp->mdesc); 427 struct mdesc_elem *ep; 428 429 if (node == MDESC_NODE_NULL || node >= last_node) 430 return NULL; 431 432 ep = node_block(&hp->mdesc) + node; 433 ep++; 434 for (; ep->tag != MD_NODE_END; ep++) { 435 void *val = NULL; 436 int len = 0; 437 438 switch (ep->tag) { 439 case MD_PROP_VAL: 440 val = &ep->d.val; 441 len = 8; 442 break; 443 444 case MD_PROP_STR: 445 case MD_PROP_DATA: 446 val = data + ep->d.data.data_offset; 447 len = ep->d.data.data_len; 448 break; 449 450 default: 451 break; 452 } 453 if (!val) 454 continue; 455 456 if (!strcmp(names + ep->name_offset, name)) { 457 if (lenp) 458 *lenp = len; 459 return val; 460 } 461 } 462 463 return NULL; 464 } 465 EXPORT_SYMBOL(mdesc_get_property); 466 467 u64 mdesc_next_arc(struct mdesc_handle *hp, u64 from, const char *arc_type) 468 { 469 struct mdesc_elem *ep, *base = node_block(&hp->mdesc); 470 const char *names = name_block(&hp->mdesc); 471 u64 last_node = hp->mdesc.node_sz / 16; 472 473 if (from == MDESC_NODE_NULL || from >= last_node) 474 return MDESC_NODE_NULL; 475 476 ep = base + from; 477 478 ep++; 479 for (; ep->tag != MD_NODE_END; ep++) { 480 if (ep->tag != MD_PROP_ARC) 481 continue; 482 483 if (strcmp(names + ep->name_offset, arc_type)) 484 continue; 485 486 return ep - base; 487 } 488 489 return MDESC_NODE_NULL; 490 } 491 EXPORT_SYMBOL(mdesc_next_arc); 492 493 u64 mdesc_arc_target(struct mdesc_handle *hp, u64 arc) 494 { 495 struct mdesc_elem *ep, *base = node_block(&hp->mdesc); 496 497 ep = base + arc; 498 499 return ep->d.val; 500 } 501 EXPORT_SYMBOL(mdesc_arc_target); 502 503 const char *mdesc_node_name(struct mdesc_handle *hp, u64 node) 504 { 505 struct mdesc_elem *ep, *base = node_block(&hp->mdesc); 506 const char *names = name_block(&hp->mdesc); 507 u64 last_node = hp->mdesc.node_sz / 16; 508 509 if (node == MDESC_NODE_NULL || node >= last_node) 510 return NULL; 511 512 ep = base + node; 513 if (ep->tag != MD_NODE) 514 return NULL; 515 516 return names + ep->name_offset; 517 } 518 EXPORT_SYMBOL(mdesc_node_name); 519 520 static void __init report_platform_properties(void) 521 { 522 struct mdesc_handle *hp = mdesc_grab(); 523 u64 pn = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform"); 524 const char *s; 525 const u64 *v; 526 527 if (pn == MDESC_NODE_NULL) { 528 prom_printf("No platform node in machine-description.\n"); 529 prom_halt(); 530 } 531 532 s = mdesc_get_property(hp, pn, "banner-name", NULL); 533 printk("PLATFORM: banner-name [%s]\n", s); 534 s = mdesc_get_property(hp, pn, "name", NULL); 535 printk("PLATFORM: name [%s]\n", s); 536 537 v = mdesc_get_property(hp, pn, "hostid", NULL); 538 if (v) 539 printk("PLATFORM: hostid [%08llx]\n", *v); 540 v = mdesc_get_property(hp, pn, "serial#", NULL); 541 if (v) 542 printk("PLATFORM: serial# [%08llx]\n", *v); 543 v = mdesc_get_property(hp, pn, "stick-frequency", NULL); 544 printk("PLATFORM: stick-frequency [%08llx]\n", *v); 545 v = mdesc_get_property(hp, pn, "mac-address", NULL); 546 if (v) 547 printk("PLATFORM: mac-address [%llx]\n", *v); 548 v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL); 549 if (v) 550 printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v); 551 v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL); 552 if (v) 553 printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v); 554 v = mdesc_get_property(hp, pn, "max-cpus", NULL); 555 if (v) 556 printk("PLATFORM: max-cpus [%llu]\n", *v); 557 558 #ifdef CONFIG_SMP 559 { 560 int max_cpu, i; 561 562 if (v) { 563 max_cpu = *v; 564 if (max_cpu > NR_CPUS) 565 max_cpu = NR_CPUS; 566 } else { 567 max_cpu = NR_CPUS; 568 } 569 for (i = 0; i < max_cpu; i++) 570 set_cpu_possible(i, true); 571 } 572 #endif 573 574 mdesc_release(hp); 575 } 576 577 static void __cpuinit fill_in_one_cache(cpuinfo_sparc *c, 578 struct mdesc_handle *hp, 579 u64 mp) 580 { 581 const u64 *level = mdesc_get_property(hp, mp, "level", NULL); 582 const u64 *size = mdesc_get_property(hp, mp, "size", NULL); 583 const u64 *line_size = mdesc_get_property(hp, mp, "line-size", NULL); 584 const char *type; 585 int type_len; 586 587 type = mdesc_get_property(hp, mp, "type", &type_len); 588 589 switch (*level) { 590 case 1: 591 if (of_find_in_proplist(type, "instn", type_len)) { 592 c->icache_size = *size; 593 c->icache_line_size = *line_size; 594 } else if (of_find_in_proplist(type, "data", type_len)) { 595 c->dcache_size = *size; 596 c->dcache_line_size = *line_size; 597 } 598 break; 599 600 case 2: 601 c->ecache_size = *size; 602 c->ecache_line_size = *line_size; 603 break; 604 605 default: 606 break; 607 } 608 609 if (*level == 1) { 610 u64 a; 611 612 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) { 613 u64 target = mdesc_arc_target(hp, a); 614 const char *name = mdesc_node_name(hp, target); 615 616 if (!strcmp(name, "cache")) 617 fill_in_one_cache(c, hp, target); 618 } 619 } 620 } 621 622 static void __cpuinit mark_core_ids(struct mdesc_handle *hp, u64 mp, int core_id) 623 { 624 u64 a; 625 626 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) { 627 u64 t = mdesc_arc_target(hp, a); 628 const char *name; 629 const u64 *id; 630 631 name = mdesc_node_name(hp, t); 632 if (!strcmp(name, "cpu")) { 633 id = mdesc_get_property(hp, t, "id", NULL); 634 if (*id < NR_CPUS) 635 cpu_data(*id).core_id = core_id; 636 } else { 637 u64 j; 638 639 mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_BACK) { 640 u64 n = mdesc_arc_target(hp, j); 641 const char *n_name; 642 643 n_name = mdesc_node_name(hp, n); 644 if (strcmp(n_name, "cpu")) 645 continue; 646 647 id = mdesc_get_property(hp, n, "id", NULL); 648 if (*id < NR_CPUS) 649 cpu_data(*id).core_id = core_id; 650 } 651 } 652 } 653 } 654 655 static void __cpuinit set_core_ids(struct mdesc_handle *hp) 656 { 657 int idx; 658 u64 mp; 659 660 idx = 1; 661 mdesc_for_each_node_by_name(hp, mp, "cache") { 662 const u64 *level; 663 const char *type; 664 int len; 665 666 level = mdesc_get_property(hp, mp, "level", NULL); 667 if (*level != 1) 668 continue; 669 670 type = mdesc_get_property(hp, mp, "type", &len); 671 if (!of_find_in_proplist(type, "instn", len)) 672 continue; 673 674 mark_core_ids(hp, mp, idx); 675 676 idx++; 677 } 678 } 679 680 static void __cpuinit mark_proc_ids(struct mdesc_handle *hp, u64 mp, int proc_id) 681 { 682 u64 a; 683 684 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_BACK) { 685 u64 t = mdesc_arc_target(hp, a); 686 const char *name; 687 const u64 *id; 688 689 name = mdesc_node_name(hp, t); 690 if (strcmp(name, "cpu")) 691 continue; 692 693 id = mdesc_get_property(hp, t, "id", NULL); 694 if (*id < NR_CPUS) 695 cpu_data(*id).proc_id = proc_id; 696 } 697 } 698 699 static void __cpuinit __set_proc_ids(struct mdesc_handle *hp, const char *exec_unit_name) 700 { 701 int idx; 702 u64 mp; 703 704 idx = 0; 705 mdesc_for_each_node_by_name(hp, mp, exec_unit_name) { 706 const char *type; 707 int len; 708 709 type = mdesc_get_property(hp, mp, "type", &len); 710 if (!of_find_in_proplist(type, "int", len) && 711 !of_find_in_proplist(type, "integer", len)) 712 continue; 713 714 mark_proc_ids(hp, mp, idx); 715 716 idx++; 717 } 718 } 719 720 static void __cpuinit set_proc_ids(struct mdesc_handle *hp) 721 { 722 __set_proc_ids(hp, "exec_unit"); 723 __set_proc_ids(hp, "exec-unit"); 724 } 725 726 static void __cpuinit get_one_mondo_bits(const u64 *p, unsigned int *mask, 727 unsigned char def) 728 { 729 u64 val; 730 731 if (!p) 732 goto use_default; 733 val = *p; 734 735 if (!val || val >= 64) 736 goto use_default; 737 738 *mask = ((1U << val) * 64U) - 1U; 739 return; 740 741 use_default: 742 *mask = ((1U << def) * 64U) - 1U; 743 } 744 745 static void __cpuinit get_mondo_data(struct mdesc_handle *hp, u64 mp, 746 struct trap_per_cpu *tb) 747 { 748 const u64 *val; 749 750 val = mdesc_get_property(hp, mp, "q-cpu-mondo-#bits", NULL); 751 get_one_mondo_bits(val, &tb->cpu_mondo_qmask, 7); 752 753 val = mdesc_get_property(hp, mp, "q-dev-mondo-#bits", NULL); 754 get_one_mondo_bits(val, &tb->dev_mondo_qmask, 7); 755 756 val = mdesc_get_property(hp, mp, "q-resumable-#bits", NULL); 757 get_one_mondo_bits(val, &tb->resum_qmask, 6); 758 759 val = mdesc_get_property(hp, mp, "q-nonresumable-#bits", NULL); 760 get_one_mondo_bits(val, &tb->nonresum_qmask, 2); 761 } 762 763 static void * __cpuinit mdesc_iterate_over_cpus(void *(*func)(struct mdesc_handle *, u64, int, void *), void *arg, cpumask_t *mask) 764 { 765 struct mdesc_handle *hp = mdesc_grab(); 766 void *ret = NULL; 767 u64 mp; 768 769 mdesc_for_each_node_by_name(hp, mp, "cpu") { 770 const u64 *id = mdesc_get_property(hp, mp, "id", NULL); 771 int cpuid = *id; 772 773 #ifdef CONFIG_SMP 774 if (cpuid >= NR_CPUS) { 775 printk(KERN_WARNING "Ignoring CPU %d which is " 776 ">= NR_CPUS (%d)\n", 777 cpuid, NR_CPUS); 778 continue; 779 } 780 if (!cpu_isset(cpuid, *mask)) 781 continue; 782 #endif 783 784 ret = func(hp, mp, cpuid, arg); 785 if (ret) 786 goto out; 787 } 788 out: 789 mdesc_release(hp); 790 return ret; 791 } 792 793 static void * __cpuinit record_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid, void *arg) 794 { 795 ncpus_probed++; 796 #ifdef CONFIG_SMP 797 set_cpu_present(cpuid, true); 798 #endif 799 return NULL; 800 } 801 802 void __cpuinit mdesc_populate_present_mask(cpumask_t *mask) 803 { 804 if (tlb_type != hypervisor) 805 return; 806 807 ncpus_probed = 0; 808 mdesc_iterate_over_cpus(record_one_cpu, NULL, mask); 809 } 810 811 static void * __cpuinit fill_in_one_cpu(struct mdesc_handle *hp, u64 mp, int cpuid, void *arg) 812 { 813 const u64 *cfreq = mdesc_get_property(hp, mp, "clock-frequency", NULL); 814 struct trap_per_cpu *tb; 815 cpuinfo_sparc *c; 816 u64 a; 817 818 #ifndef CONFIG_SMP 819 /* On uniprocessor we only want the values for the 820 * real physical cpu the kernel booted onto, however 821 * cpu_data() only has one entry at index 0. 822 */ 823 if (cpuid != real_hard_smp_processor_id()) 824 return NULL; 825 cpuid = 0; 826 #endif 827 828 c = &cpu_data(cpuid); 829 c->clock_tick = *cfreq; 830 831 tb = &trap_block[cpuid]; 832 get_mondo_data(hp, mp, tb); 833 834 mdesc_for_each_arc(a, hp, mp, MDESC_ARC_TYPE_FWD) { 835 u64 j, t = mdesc_arc_target(hp, a); 836 const char *t_name; 837 838 t_name = mdesc_node_name(hp, t); 839 if (!strcmp(t_name, "cache")) { 840 fill_in_one_cache(c, hp, t); 841 continue; 842 } 843 844 mdesc_for_each_arc(j, hp, t, MDESC_ARC_TYPE_FWD) { 845 u64 n = mdesc_arc_target(hp, j); 846 const char *n_name; 847 848 n_name = mdesc_node_name(hp, n); 849 if (!strcmp(n_name, "cache")) 850 fill_in_one_cache(c, hp, n); 851 } 852 } 853 854 c->core_id = 0; 855 c->proc_id = -1; 856 857 return NULL; 858 } 859 860 void __cpuinit mdesc_fill_in_cpu_data(cpumask_t *mask) 861 { 862 struct mdesc_handle *hp; 863 864 mdesc_iterate_over_cpus(fill_in_one_cpu, NULL, mask); 865 866 #ifdef CONFIG_SMP 867 sparc64_multi_core = 1; 868 #endif 869 870 hp = mdesc_grab(); 871 872 set_core_ids(hp); 873 set_proc_ids(hp); 874 875 mdesc_release(hp); 876 877 smp_fill_in_sib_core_maps(); 878 } 879 880 static ssize_t mdesc_read(struct file *file, char __user *buf, 881 size_t len, loff_t *offp) 882 { 883 struct mdesc_handle *hp = mdesc_grab(); 884 int err; 885 886 if (!hp) 887 return -ENODEV; 888 889 err = hp->handle_size; 890 if (len < hp->handle_size) 891 err = -EMSGSIZE; 892 else if (copy_to_user(buf, &hp->mdesc, hp->handle_size)) 893 err = -EFAULT; 894 mdesc_release(hp); 895 896 return err; 897 } 898 899 static const struct file_operations mdesc_fops = { 900 .read = mdesc_read, 901 .owner = THIS_MODULE, 902 }; 903 904 static struct miscdevice mdesc_misc = { 905 .minor = MISC_DYNAMIC_MINOR, 906 .name = "mdesc", 907 .fops = &mdesc_fops, 908 }; 909 910 static int __init mdesc_misc_init(void) 911 { 912 return misc_register(&mdesc_misc); 913 } 914 915 __initcall(mdesc_misc_init); 916 917 void __init sun4v_mdesc_init(void) 918 { 919 struct mdesc_handle *hp; 920 unsigned long len, real_len, status; 921 922 (void) sun4v_mach_desc(0UL, 0UL, &len); 923 924 printk("MDESC: Size is %lu bytes.\n", len); 925 926 hp = mdesc_alloc(len, &lmb_mdesc_ops); 927 if (hp == NULL) { 928 prom_printf("MDESC: alloc of %lu bytes failed.\n", len); 929 prom_halt(); 930 } 931 932 status = sun4v_mach_desc(__pa(&hp->mdesc), len, &real_len); 933 if (status != HV_EOK || real_len > len) { 934 prom_printf("sun4v_mach_desc fails, err(%lu), " 935 "len(%lu), real_len(%lu)\n", 936 status, len, real_len); 937 mdesc_free(hp); 938 prom_halt(); 939 } 940 941 cur_mdesc = hp; 942 943 report_platform_properties(); 944 } 945