Merge branch 'for-linus' of git://brick.kernel.dk/data/git/linux-2.6-block
[linux-2.6] / arch / powerpc / platforms / ps3 / repository.c
1 /*
2  *  PS3 repository routines.
3  *
4  *  Copyright (C) 2006 Sony Computer Entertainment Inc.
5  *  Copyright 2006 Sony Corp.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; version 2 of the License.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <asm/ps3.h>
22 #include <asm/lv1call.h>
23
24 enum ps3_vendor_id {
25         PS3_VENDOR_ID_NONE = 0,
26         PS3_VENDOR_ID_SONY = 0x8000000000000000UL,
27 };
28
29 enum ps3_lpar_id {
30         PS3_LPAR_ID_CURRENT = 0,
31         PS3_LPAR_ID_PME = 1,
32 };
33
34 #define dump_field(_a, _b) _dump_field(_a, _b, __func__, __LINE__)
35 static void _dump_field(const char *hdr, u64 n, const char* func, int line)
36 {
37 #if defined(DEBUG)
38         char s[16];
39         const char *const in = (const char *)&n;
40         unsigned int i;
41
42         for (i = 0; i < 8; i++)
43                 s[i] = (in[i] <= 126 && in[i] >= 32) ? in[i] : '.';
44         s[i] = 0;
45
46         pr_debug("%s:%d: %s%016lx : %s\n", func, line, hdr, n, s);
47 #endif
48 }
49
50 #define dump_node_name(_a, _b, _c, _d, _e) \
51         _dump_node_name(_a, _b, _c, _d, _e, __func__, __LINE__)
52 static void _dump_node_name (unsigned int lpar_id, u64 n1, u64 n2, u64 n3,
53         u64 n4, const char* func, int line)
54 {
55         pr_debug("%s:%d: lpar: %u\n", func, line, lpar_id);
56         _dump_field("n1: ", n1, func, line);
57         _dump_field("n2: ", n2, func, line);
58         _dump_field("n3: ", n3, func, line);
59         _dump_field("n4: ", n4, func, line);
60 }
61
62 #define dump_node(_a, _b, _c, _d, _e, _f, _g) \
63         _dump_node(_a, _b, _c, _d, _e, _f, _g, __func__, __LINE__)
64 static void _dump_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
65         u64 v1, u64 v2, const char* func, int line)
66 {
67         pr_debug("%s:%d: lpar: %u\n", func, line, lpar_id);
68         _dump_field("n1: ", n1, func, line);
69         _dump_field("n2: ", n2, func, line);
70         _dump_field("n3: ", n3, func, line);
71         _dump_field("n4: ", n4, func, line);
72         pr_debug("%s:%d: v1: %016lx\n", func, line, v1);
73         pr_debug("%s:%d: v2: %016lx\n", func, line, v2);
74 }
75
76 /**
77  * make_first_field - Make the first field of a repository node name.
78  * @text: Text portion of the field.
79  * @index: Numeric index portion of the field.  Use zero for 'don't care'.
80  *
81  * This routine sets the vendor id to zero (non-vendor specific).
82  * Returns field value.
83  */
84
85 static u64 make_first_field(const char *text, u64 index)
86 {
87         u64 n;
88
89         strncpy((char *)&n, text, 8);
90         return PS3_VENDOR_ID_NONE + (n >> 32) + index;
91 }
92
93 /**
94  * make_field - Make subsequent fields of a repository node name.
95  * @text: Text portion of the field.  Use "" for 'don't care'.
96  * @index: Numeric index portion of the field.  Use zero for 'don't care'.
97  *
98  * Returns field value.
99  */
100
101 static u64 make_field(const char *text, u64 index)
102 {
103         u64 n;
104
105         strncpy((char *)&n, text, 8);
106         return n + index;
107 }
108
109 /**
110  * read_node - Read a repository node from raw fields.
111  * @n1: First field of node name.
112  * @n2: Second field of node name.  Use zero for 'don't care'.
113  * @n3: Third field of node name.  Use zero for 'don't care'.
114  * @n4: Fourth field of node name.  Use zero for 'don't care'.
115  * @v1: First repository value (high word).
116  * @v2: Second repository value (low word).  Optional parameter, use zero
117  *      for 'don't care'.
118  */
119
120 static int read_node(unsigned int lpar_id, u64 n1, u64 n2, u64 n3, u64 n4,
121         u64 *_v1, u64 *_v2)
122 {
123         int result;
124         u64 v1;
125         u64 v2;
126
127         if (lpar_id == PS3_LPAR_ID_CURRENT) {
128                 u64 id;
129                 lv1_get_logical_partition_id(&id);
130                 lpar_id = id;
131         }
132
133         result = lv1_get_repository_node_value(lpar_id, n1, n2, n3, n4, &v1,
134                 &v2);
135
136         if (result) {
137                 pr_debug("%s:%d: lv1_get_repository_node_value failed: %s\n",
138                         __func__, __LINE__, ps3_result(result));
139                 dump_node_name(lpar_id, n1, n2, n3, n4);
140                 return result;
141         }
142
143         dump_node(lpar_id, n1, n2, n3, n4, v1, v2);
144
145         if (_v1)
146                 *_v1 = v1;
147         if (_v2)
148                 *_v2 = v2;
149
150         if (v1 && !_v1)
151                 pr_debug("%s:%d: warning: discarding non-zero v1: %016lx\n",
152                         __func__, __LINE__, v1);
153         if (v2 && !_v2)
154                 pr_debug("%s:%d: warning: discarding non-zero v2: %016lx\n",
155                         __func__, __LINE__, v2);
156
157         return result;
158 }
159
160 int ps3_repository_read_bus_str(unsigned int bus_index, const char *bus_str,
161         u64 *value)
162 {
163         return read_node(PS3_LPAR_ID_PME,
164                 make_first_field("bus", bus_index),
165                 make_field(bus_str, 0),
166                 0, 0,
167                 value, 0);
168 }
169
170 int ps3_repository_read_bus_id(unsigned int bus_index, unsigned int *bus_id)
171 {
172         int result;
173         u64 v1;
174         u64 v2; /* unused */
175
176         result = read_node(PS3_LPAR_ID_PME,
177                 make_first_field("bus", bus_index),
178                 make_field("id", 0),
179                 0, 0,
180                 &v1, &v2);
181         *bus_id = v1;
182         return result;
183 }
184
185 int ps3_repository_read_bus_type(unsigned int bus_index,
186         enum ps3_bus_type *bus_type)
187 {
188         int result;
189         u64 v1;
190
191         result = read_node(PS3_LPAR_ID_PME,
192                 make_first_field("bus", bus_index),
193                 make_field("type", 0),
194                 0, 0,
195                 &v1, 0);
196         *bus_type = v1;
197         return result;
198 }
199
200 int ps3_repository_read_bus_num_dev(unsigned int bus_index,
201         unsigned int *num_dev)
202 {
203         int result;
204         u64 v1;
205
206         result = read_node(PS3_LPAR_ID_PME,
207                 make_first_field("bus", bus_index),
208                 make_field("num_dev", 0),
209                 0, 0,
210                 &v1, 0);
211         *num_dev = v1;
212         return result;
213 }
214
215 int ps3_repository_read_dev_str(unsigned int bus_index,
216         unsigned int dev_index, const char *dev_str, u64 *value)
217 {
218         return read_node(PS3_LPAR_ID_PME,
219                 make_first_field("bus", bus_index),
220                 make_field("dev", dev_index),
221                 make_field(dev_str, 0),
222                 0,
223                 value, 0);
224 }
225
226 int ps3_repository_read_dev_id(unsigned int bus_index, unsigned int dev_index,
227         unsigned int *dev_id)
228 {
229         int result;
230         u64 v1;
231
232         result = read_node(PS3_LPAR_ID_PME,
233                 make_first_field("bus", bus_index),
234                 make_field("dev", dev_index),
235                 make_field("id", 0),
236                 0,
237                 &v1, 0);
238         *dev_id = v1;
239         return result;
240 }
241
242 int ps3_repository_read_dev_type(unsigned int bus_index,
243         unsigned int dev_index, enum ps3_dev_type *dev_type)
244 {
245         int result;
246         u64 v1;
247
248         result = read_node(PS3_LPAR_ID_PME,
249                 make_first_field("bus", bus_index),
250                 make_field("dev", dev_index),
251                 make_field("type", 0),
252                 0,
253                 &v1, 0);
254         *dev_type = v1;
255         return result;
256 }
257
258 int ps3_repository_read_dev_intr(unsigned int bus_index,
259         unsigned int dev_index, unsigned int intr_index,
260         unsigned int *intr_type, unsigned int* interrupt_id)
261 {
262         int result;
263         u64 v1;
264         u64 v2;
265
266         result = read_node(PS3_LPAR_ID_PME,
267                 make_first_field("bus", bus_index),
268                 make_field("dev", dev_index),
269                 make_field("intr", intr_index),
270                 0,
271                 &v1, &v2);
272         *intr_type = v1;
273         *interrupt_id = v2;
274         return result;
275 }
276
277 int ps3_repository_read_dev_reg_type(unsigned int bus_index,
278         unsigned int dev_index, unsigned int reg_index, unsigned int *reg_type)
279 {
280         int result;
281         u64 v1;
282
283         result = read_node(PS3_LPAR_ID_PME,
284                 make_first_field("bus", bus_index),
285                 make_field("dev", dev_index),
286                 make_field("reg", reg_index),
287                 make_field("type", 0),
288                 &v1, 0);
289         *reg_type = v1;
290         return result;
291 }
292
293 int ps3_repository_read_dev_reg_addr(unsigned int bus_index,
294         unsigned int dev_index, unsigned int reg_index, u64 *bus_addr, u64 *len)
295 {
296         return read_node(PS3_LPAR_ID_PME,
297                 make_first_field("bus", bus_index),
298                 make_field("dev", dev_index),
299                 make_field("reg", reg_index),
300                 make_field("data", 0),
301                 bus_addr, len);
302 }
303
304 int ps3_repository_read_dev_reg(unsigned int bus_index,
305         unsigned int dev_index, unsigned int reg_index, unsigned int *reg_type,
306         u64 *bus_addr, u64 *len)
307 {
308         int result = ps3_repository_read_dev_reg_type(bus_index, dev_index,
309                 reg_index, reg_type);
310         return result ? result
311                 : ps3_repository_read_dev_reg_addr(bus_index, dev_index,
312                 reg_index, bus_addr, len);
313 }
314
315 #if defined(DEBUG)
316 int ps3_repository_dump_resource_info(unsigned int bus_index,
317         unsigned int dev_index)
318 {
319         int result = 0;
320         unsigned int res_index;
321
322         pr_debug(" -> %s:%d: (%u:%u)\n", __func__, __LINE__,
323                 bus_index, dev_index);
324
325         for (res_index = 0; res_index < 10; res_index++) {
326                 enum ps3_interrupt_type intr_type;
327                 unsigned int interrupt_id;
328
329                 result = ps3_repository_read_dev_intr(bus_index, dev_index,
330                         res_index, &intr_type, &interrupt_id);
331
332                 if (result) {
333                         if (result !=  LV1_NO_ENTRY)
334                                 pr_debug("%s:%d ps3_repository_read_dev_intr"
335                                         " (%u:%u) failed\n", __func__, __LINE__,
336                                         bus_index, dev_index);
337                         break;
338                 }
339
340                 pr_debug("%s:%d (%u:%u) intr_type %u, interrupt_id %u\n",
341                         __func__, __LINE__, bus_index, dev_index, intr_type,
342                         interrupt_id);
343         }
344
345         for (res_index = 0; res_index < 10; res_index++) {
346                 enum ps3_region_type reg_type;
347                 u64 bus_addr;
348                 u64 len;
349
350                 result = ps3_repository_read_dev_reg(bus_index, dev_index,
351                         res_index, &reg_type, &bus_addr, &len);
352
353                 if (result) {
354                         if (result !=  LV1_NO_ENTRY)
355                                 pr_debug("%s:%d ps3_repository_read_dev_reg"
356                                         " (%u:%u) failed\n", __func__, __LINE__,
357                                         bus_index, dev_index);
358                         break;
359                 }
360
361                 pr_debug("%s:%d (%u:%u) reg_type %u, bus_addr %lxh, len %lxh\n",
362                         __func__, __LINE__, bus_index, dev_index, reg_type,
363                         bus_addr, len);
364         }
365
366         pr_debug(" <- %s:%d\n", __func__, __LINE__);
367         return result;
368 }
369
370 static int dump_device_info(unsigned int bus_index, unsigned int num_dev)
371 {
372         int result = 0;
373         unsigned int dev_index;
374
375         pr_debug(" -> %s:%d: bus_%u\n", __func__, __LINE__, bus_index);
376
377         for (dev_index = 0; dev_index < num_dev; dev_index++) {
378                 enum ps3_dev_type dev_type;
379                 unsigned int dev_id;
380
381                 result = ps3_repository_read_dev_type(bus_index, dev_index,
382                         &dev_type);
383
384                 if (result) {
385                         pr_debug("%s:%d ps3_repository_read_dev_type"
386                                 " (%u:%u) failed\n", __func__, __LINE__,
387                                 bus_index, dev_index);
388                         break;
389                 }
390
391                 result = ps3_repository_read_dev_id(bus_index, dev_index,
392                         &dev_id);
393
394                 if (result) {
395                         pr_debug("%s:%d ps3_repository_read_dev_id"
396                                 " (%u:%u) failed\n", __func__, __LINE__,
397                                 bus_index, dev_index);
398                         continue;
399                 }
400
401                 pr_debug("%s:%d  (%u:%u): dev_type %u, dev_id %u\n", __func__,
402                         __LINE__, bus_index, dev_index, dev_type, dev_id);
403
404                 ps3_repository_dump_resource_info(bus_index, dev_index);
405         }
406
407         pr_debug(" <- %s:%d\n", __func__, __LINE__);
408         return result;
409 }
410
411 int ps3_repository_dump_bus_info(void)
412 {
413         int result = 0;
414         unsigned int bus_index;
415
416         pr_debug(" -> %s:%d\n", __func__, __LINE__);
417
418         for (bus_index = 0; bus_index < 10; bus_index++) {
419                 enum ps3_bus_type bus_type;
420                 unsigned int bus_id;
421                 unsigned int num_dev;
422
423                 result = ps3_repository_read_bus_type(bus_index, &bus_type);
424
425                 if (result) {
426                         pr_debug("%s:%d read_bus_type(%u) failed\n",
427                                 __func__, __LINE__, bus_index);
428                         break;
429                 }
430
431                 result = ps3_repository_read_bus_id(bus_index, &bus_id);
432
433                 if (result) {
434                         pr_debug("%s:%d read_bus_id(%u) failed\n",
435                                 __func__, __LINE__, bus_index);
436                         continue;
437                 }
438
439                 if (bus_index != bus_id)
440                         pr_debug("%s:%d bus_index != bus_id\n",
441                                 __func__, __LINE__);
442
443                 result = ps3_repository_read_bus_num_dev(bus_index, &num_dev);
444
445                 if (result) {
446                         pr_debug("%s:%d read_bus_num_dev(%u) failed\n",
447                                 __func__, __LINE__, bus_index);
448                         continue;
449                 }
450
451                 pr_debug("%s:%d bus_%u: bus_type %u, bus_id %u, num_dev %u\n",
452                         __func__, __LINE__, bus_index, bus_type, bus_id,
453                         num_dev);
454
455                 dump_device_info(bus_index, num_dev);
456         }
457
458         pr_debug(" <- %s:%d\n", __func__, __LINE__);
459         return result;
460 }
461 #endif /* defined(DEBUG) */
462
463 static int find_device(unsigned int bus_index, unsigned int num_dev,
464         unsigned int start_dev_index, enum ps3_dev_type dev_type,
465         struct ps3_repository_device *dev)
466 {
467         int result = 0;
468         unsigned int dev_index;
469
470         pr_debug("%s:%d: find dev_type %u\n", __func__, __LINE__, dev_type);
471
472         dev->dev_index = UINT_MAX;
473
474         for (dev_index = start_dev_index; dev_index < num_dev; dev_index++) {
475                 enum ps3_dev_type x;
476
477                 result = ps3_repository_read_dev_type(bus_index, dev_index,
478                         &x);
479
480                 if (result) {
481                         pr_debug("%s:%d read_dev_type failed\n",
482                                 __func__, __LINE__);
483                         return result;
484                 }
485
486                 if (x == dev_type)
487                         break;
488         }
489
490         BUG_ON(dev_index == num_dev);
491
492         pr_debug("%s:%d: found dev_type %u at dev_index %u\n",
493                 __func__, __LINE__, dev_type, dev_index);
494
495         result = ps3_repository_read_dev_id(bus_index, dev_index,
496                 &dev->did.dev_id);
497
498         if (result) {
499                 pr_debug("%s:%d read_dev_id failed\n",
500                         __func__, __LINE__);
501                 return result;
502         }
503
504         dev->dev_index = dev_index;
505
506         pr_debug("%s:%d found: dev_id %u\n", __func__, __LINE__,
507                 dev->did.dev_id);
508
509         return result;
510 }
511
512 int ps3_repository_find_device (enum ps3_bus_type bus_type,
513         enum ps3_dev_type dev_type,
514         const struct ps3_repository_device *start_dev,
515         struct ps3_repository_device *dev)
516 {
517         int result = 0;
518         unsigned int bus_index;
519         unsigned int num_dev;
520
521         pr_debug("%s:%d: find bus_type %u, dev_type %u\n", __func__, __LINE__,
522                 bus_type, dev_type);
523
524         dev->bus_index = UINT_MAX;
525
526         for (bus_index = start_dev ? start_dev->bus_index : 0; bus_index < 10;
527                 bus_index++) {
528                 enum ps3_bus_type x;
529
530                 result = ps3_repository_read_bus_type(bus_index, &x);
531
532                 if (result) {
533                         pr_debug("%s:%d read_bus_type failed\n",
534                                 __func__, __LINE__);
535                         return result;
536                 }
537                 if (x == bus_type)
538                         break;
539         }
540
541         BUG_ON(bus_index == 10);
542
543         pr_debug("%s:%d: found bus_type %u at bus_index %u\n",
544                 __func__, __LINE__, bus_type, bus_index);
545
546         result = ps3_repository_read_bus_num_dev(bus_index, &num_dev);
547
548         if (result) {
549                 pr_debug("%s:%d read_bus_num_dev failed\n",
550                         __func__, __LINE__);
551                 return result;
552         }
553
554         result = find_device(bus_index, num_dev, start_dev
555                 ? start_dev->dev_index + 1 : 0, dev_type, dev);
556
557         if (result) {
558                 pr_debug("%s:%d get_did failed\n", __func__, __LINE__);
559                 return result;
560         }
561
562         result = ps3_repository_read_bus_id(bus_index, &dev->did.bus_id);
563
564         if (result) {
565                 pr_debug("%s:%d read_bus_id failed\n",
566                         __func__, __LINE__);
567                 return result;
568         }
569
570         dev->bus_index = bus_index;
571
572         pr_debug("%s:%d found: bus_id %u, dev_id %u\n",
573                 __func__, __LINE__, dev->did.bus_id, dev->did.dev_id);
574
575         return result;
576 }
577
578 int ps3_repository_find_interrupt(const struct ps3_repository_device *dev,
579         enum ps3_interrupt_type intr_type, unsigned int *interrupt_id)
580 {
581         int result = 0;
582         unsigned int res_index;
583
584         pr_debug("%s:%d: find intr_type %u\n", __func__, __LINE__, intr_type);
585
586         *interrupt_id = UINT_MAX;
587
588         for (res_index = 0; res_index < 10; res_index++) {
589                 enum ps3_interrupt_type t;
590                 unsigned int id;
591
592                 result = ps3_repository_read_dev_intr(dev->bus_index,
593                         dev->dev_index, res_index, &t, &id);
594
595                 if (result) {
596                         pr_debug("%s:%d read_dev_intr failed\n",
597                                 __func__, __LINE__);
598                         return result;
599                 }
600
601                 if (t == intr_type) {
602                         *interrupt_id = id;
603                         break;
604                 }
605         }
606
607         BUG_ON(res_index == 10);
608
609         pr_debug("%s:%d: found intr_type %u at res_index %u\n",
610                 __func__, __LINE__, intr_type, res_index);
611
612         return result;
613 }
614
615 int ps3_repository_find_region(const struct ps3_repository_device *dev,
616         enum ps3_region_type reg_type, u64 *bus_addr, u64 *len)
617 {
618         int result = 0;
619         unsigned int res_index;
620
621         pr_debug("%s:%d: find reg_type %u\n", __func__, __LINE__, reg_type);
622
623         *bus_addr = *len = 0;
624
625         for (res_index = 0; res_index < 10; res_index++) {
626                 enum ps3_region_type t;
627                 u64 a;
628                 u64 l;
629
630                 result = ps3_repository_read_dev_reg(dev->bus_index,
631                         dev->dev_index, res_index, &t, &a, &l);
632
633                 if (result) {
634                         pr_debug("%s:%d read_dev_reg failed\n",
635                                 __func__, __LINE__);
636                         return result;
637                 }
638
639                 if (t == reg_type) {
640                         *bus_addr = a;
641                         *len = l;
642                         break;
643                 }
644         }
645
646         BUG_ON(res_index == 10);
647
648         pr_debug("%s:%d: found reg_type %u at res_index %u\n",
649                 __func__, __LINE__, reg_type, res_index);
650
651         return result;
652 }
653
654 int ps3_repository_read_rm_size(unsigned int ppe_id, u64 *rm_size)
655 {
656         return read_node(PS3_LPAR_ID_CURRENT,
657                 make_first_field("bi", 0),
658                 make_field("pu", 0),
659                 ppe_id,
660                 make_field("rm_size", 0),
661                 rm_size, 0);
662 }
663
664 int ps3_repository_read_region_total(u64 *region_total)
665 {
666         return read_node(PS3_LPAR_ID_CURRENT,
667                 make_first_field("bi", 0),
668                 make_field("rgntotal", 0),
669                 0, 0,
670                 region_total, 0);
671 }
672
673 /**
674  * ps3_repository_read_mm_info - Read mm info for single pu system.
675  * @rm_base: Real mode memory base address.
676  * @rm_size: Real mode memory size.
677  * @region_total: Maximum memory region size.
678  */
679
680 int ps3_repository_read_mm_info(u64 *rm_base, u64 *rm_size, u64 *region_total)
681 {
682         int result;
683         u64 ppe_id;
684
685         lv1_get_logical_ppe_id(&ppe_id);
686         *rm_base = 0;
687         result = ps3_repository_read_rm_size(ppe_id, rm_size);
688         return result ? result
689                 : ps3_repository_read_region_total(region_total);
690 }
691
692 /**
693  * ps3_repository_read_num_spu_reserved - Number of physical spus reserved.
694  * @num_spu: Number of physical spus.
695  */
696
697 int ps3_repository_read_num_spu_reserved(unsigned int *num_spu_reserved)
698 {
699         int result;
700         u64 v1;
701
702         result = read_node(PS3_LPAR_ID_CURRENT,
703                 make_first_field("bi", 0),
704                 make_field("spun", 0),
705                 0, 0,
706                 &v1, 0);
707         *num_spu_reserved = v1;
708         return result;
709 }
710
711 /**
712  * ps3_repository_read_num_spu_resource_id - Number of spu resource reservations.
713  * @num_resource_id: Number of spu resource ids.
714  */
715
716 int ps3_repository_read_num_spu_resource_id(unsigned int *num_resource_id)
717 {
718         int result;
719         u64 v1;
720
721         result = read_node(PS3_LPAR_ID_CURRENT,
722                 make_first_field("bi", 0),
723                 make_field("spursvn", 0),
724                 0, 0,
725                 &v1, 0);
726         *num_resource_id = v1;
727         return result;
728 }
729
730 /**
731  * ps3_repository_read_spu_resource_id - spu resource reservation id value.
732  * @res_index: Resource reservation index.
733  * @resource_type: Resource reservation type.
734  * @resource_id: Resource reservation id.
735  */
736
737 int ps3_repository_read_spu_resource_id(unsigned int res_index,
738         enum ps3_spu_resource_type* resource_type, unsigned int *resource_id)
739 {
740         int result;
741         u64 v1;
742         u64 v2;
743
744         result = read_node(PS3_LPAR_ID_CURRENT,
745                 make_first_field("bi", 0),
746                 make_field("spursv", 0),
747                 res_index,
748                 0,
749                 &v1, &v2);
750         *resource_type = v1;
751         *resource_id = v2;
752         return result;
753 }
754
755 int ps3_repository_read_boot_dat_address(u64 *address)
756 {
757         return read_node(PS3_LPAR_ID_CURRENT,
758                 make_first_field("bi", 0),
759                 make_field("boot_dat", 0),
760                 make_field("address", 0),
761                 0,
762                 address, 0);
763 }
764
765 int ps3_repository_read_boot_dat_size(unsigned int *size)
766 {
767         int result;
768         u64 v1;
769
770         result = read_node(PS3_LPAR_ID_CURRENT,
771                 make_first_field("bi", 0),
772                 make_field("boot_dat", 0),
773                 make_field("size", 0),
774                 0,
775                 &v1, 0);
776         *size = v1;
777         return result;
778 }
779
780 /**
781   * ps3_repository_read_boot_dat_info - Get address and size of cell_ext_os_area.
782   * address: lpar address of cell_ext_os_area
783   * @size: size of cell_ext_os_area
784   */
785
786 int ps3_repository_read_boot_dat_info(u64 *lpar_addr, unsigned int *size)
787 {
788         int result;
789
790         *size = 0;
791         result = ps3_repository_read_boot_dat_address(lpar_addr);
792         return result ? result
793                 : ps3_repository_read_boot_dat_size(size);
794 }
795
796 int ps3_repository_read_num_be(unsigned int *num_be)
797 {
798         int result;
799         u64 v1;
800
801         result = read_node(PS3_LPAR_ID_PME,
802                 make_first_field("ben", 0),
803                 0,
804                 0,
805                 0,
806                 &v1, 0);
807         *num_be = v1;
808         return result;
809 }
810
811 int ps3_repository_read_be_node_id(unsigned int be_index, u64 *node_id)
812 {
813         return read_node(PS3_LPAR_ID_PME,
814                 make_first_field("be", be_index),
815                 0,
816                 0,
817                 0,
818                 node_id, 0);
819 }
820
821 int ps3_repository_read_tb_freq(u64 node_id, u64 *tb_freq)
822 {
823         return read_node(PS3_LPAR_ID_PME,
824                 make_first_field("be", 0),
825                 node_id,
826                 make_field("clock", 0),
827                 0,
828                 tb_freq, 0);
829 }
830
831 int ps3_repository_read_be_tb_freq(unsigned int be_index, u64 *tb_freq)
832 {
833         int result;
834         u64 node_id;
835
836         *tb_freq = 0;
837         result = ps3_repository_read_be_node_id(0, &node_id);
838         return result ? result
839                 : ps3_repository_read_tb_freq(node_id, tb_freq);
840 }