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