2 * PS3 repository routines.
4 * Copyright (C) 2006 Sony Computer Entertainment Inc.
5 * Copyright 2006 Sony Corp.
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.
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.
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
21 #include <asm/lv1call.h>
26 PS3_VENDOR_ID_NONE
= 0,
27 PS3_VENDOR_ID_SONY
= 0x8000000000000000UL
,
31 PS3_LPAR_ID_CURRENT
= 0,
35 #define dump_field(_a, _b) _dump_field(_a, _b, __func__, __LINE__)
36 static void _dump_field(const char *hdr
, u64 n
, const char* func
, int line
)
40 const char *const in
= (const char *)&n
;
43 for (i
= 0; i
< 8; i
++)
44 s
[i
] = (in
[i
] <= 126 && in
[i
] >= 32) ? in
[i
] : '.';
47 pr_debug("%s:%d: %s%016lx : %s\n", func
, line
, hdr
, n
, s
);
51 #define dump_node_name(_a, _b, _c, _d, _e) \
52 _dump_node_name(_a, _b, _c, _d, _e, __func__, __LINE__)
53 static void _dump_node_name (unsigned int lpar_id
, u64 n1
, u64 n2
, u64 n3
,
54 u64 n4
, const char* func
, int line
)
56 pr_debug("%s:%d: lpar: %u\n", func
, line
, lpar_id
);
57 _dump_field("n1: ", n1
, func
, line
);
58 _dump_field("n2: ", n2
, func
, line
);
59 _dump_field("n3: ", n3
, func
, line
);
60 _dump_field("n4: ", n4
, func
, line
);
63 #define dump_node(_a, _b, _c, _d, _e, _f, _g) \
64 _dump_node(_a, _b, _c, _d, _e, _f, _g, __func__, __LINE__)
65 static void _dump_node(unsigned int lpar_id
, u64 n1
, u64 n2
, u64 n3
, u64 n4
,
66 u64 v1
, u64 v2
, const char* func
, int line
)
68 pr_debug("%s:%d: lpar: %u\n", func
, line
, lpar_id
);
69 _dump_field("n1: ", n1
, func
, line
);
70 _dump_field("n2: ", n2
, func
, line
);
71 _dump_field("n3: ", n3
, func
, line
);
72 _dump_field("n4: ", n4
, func
, line
);
73 pr_debug("%s:%d: v1: %016lx\n", func
, line
, v1
);
74 pr_debug("%s:%d: v2: %016lx\n", func
, line
, v2
);
78 * make_first_field - Make the first field of a repository node name.
79 * @text: Text portion of the field.
80 * @index: Numeric index portion of the field. Use zero for 'don't care'.
82 * This routine sets the vendor id to zero (non-vendor specific).
83 * Returns field value.
86 static u64
make_first_field(const char *text
, u64 index
)
90 strncpy((char *)&n
, text
, 8);
91 return PS3_VENDOR_ID_NONE
+ (n
>> 32) + index
;
95 * make_field - Make subsequent fields of a repository node name.
96 * @text: Text portion of the field. Use "" for 'don't care'.
97 * @index: Numeric index portion of the field. Use zero for 'don't care'.
99 * Returns field value.
102 static u64
make_field(const char *text
, u64 index
)
106 strncpy((char *)&n
, text
, 8);
111 * read_node - Read a repository node from raw fields.
112 * @n1: First field of node name.
113 * @n2: Second field of node name. Use zero for 'don't care'.
114 * @n3: Third field of node name. Use zero for 'don't care'.
115 * @n4: Fourth field of node name. Use zero for 'don't care'.
116 * @v1: First repository value (high word).
117 * @v2: Second repository value (low word). Optional parameter, use zero
121 static int read_node(unsigned int lpar_id
, u64 n1
, u64 n2
, u64 n3
, u64 n4
,
128 if (lpar_id
== PS3_LPAR_ID_CURRENT
) {
130 lv1_get_logical_partition_id(&id
);
134 result
= lv1_get_repository_node_value(lpar_id
, n1
, n2
, n3
, n4
, &v1
,
138 pr_debug("%s:%d: lv1_get_repository_node_value failed: %s\n",
139 __func__
, __LINE__
, ps3_result(result
));
140 dump_node_name(lpar_id
, n1
, n2
, n3
, n4
);
144 dump_node(lpar_id
, n1
, n2
, n3
, n4
, v1
, v2
);
152 pr_debug("%s:%d: warning: discarding non-zero v1: %016lx\n",
153 __func__
, __LINE__
, v1
);
155 pr_debug("%s:%d: warning: discarding non-zero v2: %016lx\n",
156 __func__
, __LINE__
, v2
);
161 int ps3_repository_read_bus_str(unsigned int bus_index
, const char *bus_str
,
164 return read_node(PS3_LPAR_ID_PME
,
165 make_first_field("bus", bus_index
),
166 make_field(bus_str
, 0),
171 int ps3_repository_read_bus_id(unsigned int bus_index
, u64
*bus_id
)
175 result
= read_node(PS3_LPAR_ID_PME
,
176 make_first_field("bus", bus_index
),
183 int ps3_repository_read_bus_type(unsigned int bus_index
,
184 enum ps3_bus_type
*bus_type
)
189 result
= read_node(PS3_LPAR_ID_PME
,
190 make_first_field("bus", bus_index
),
191 make_field("type", 0),
198 int ps3_repository_read_bus_num_dev(unsigned int bus_index
,
199 unsigned int *num_dev
)
204 result
= read_node(PS3_LPAR_ID_PME
,
205 make_first_field("bus", bus_index
),
206 make_field("num_dev", 0),
213 int ps3_repository_read_dev_str(unsigned int bus_index
,
214 unsigned int dev_index
, const char *dev_str
, u64
*value
)
216 return read_node(PS3_LPAR_ID_PME
,
217 make_first_field("bus", bus_index
),
218 make_field("dev", dev_index
),
219 make_field(dev_str
, 0),
224 int ps3_repository_read_dev_id(unsigned int bus_index
, unsigned int dev_index
,
229 result
= read_node(PS3_LPAR_ID_PME
,
230 make_first_field("bus", bus_index
),
231 make_field("dev", dev_index
),
238 int ps3_repository_read_dev_type(unsigned int bus_index
,
239 unsigned int dev_index
, enum ps3_dev_type
*dev_type
)
244 result
= read_node(PS3_LPAR_ID_PME
,
245 make_first_field("bus", bus_index
),
246 make_field("dev", dev_index
),
247 make_field("type", 0),
254 int ps3_repository_read_dev_intr(unsigned int bus_index
,
255 unsigned int dev_index
, unsigned int intr_index
,
256 enum ps3_interrupt_type
*intr_type
, unsigned int* interrupt_id
)
262 result
= read_node(PS3_LPAR_ID_PME
,
263 make_first_field("bus", bus_index
),
264 make_field("dev", dev_index
),
265 make_field("intr", intr_index
),
273 int ps3_repository_read_dev_reg_type(unsigned int bus_index
,
274 unsigned int dev_index
, unsigned int reg_index
,
275 enum ps3_reg_type
*reg_type
)
280 result
= read_node(PS3_LPAR_ID_PME
,
281 make_first_field("bus", bus_index
),
282 make_field("dev", dev_index
),
283 make_field("reg", reg_index
),
284 make_field("type", 0),
290 int ps3_repository_read_dev_reg_addr(unsigned int bus_index
,
291 unsigned int dev_index
, unsigned int reg_index
, u64
*bus_addr
, u64
*len
)
293 return read_node(PS3_LPAR_ID_PME
,
294 make_first_field("bus", bus_index
),
295 make_field("dev", dev_index
),
296 make_field("reg", reg_index
),
297 make_field("data", 0),
301 int ps3_repository_read_dev_reg(unsigned int bus_index
,
302 unsigned int dev_index
, unsigned int reg_index
,
303 enum ps3_reg_type
*reg_type
, u64
*bus_addr
, u64
*len
)
305 int result
= ps3_repository_read_dev_reg_type(bus_index
, dev_index
,
306 reg_index
, reg_type
);
307 return result
? result
308 : ps3_repository_read_dev_reg_addr(bus_index
, dev_index
,
309 reg_index
, bus_addr
, len
);
314 int ps3_repository_find_device(struct ps3_repository_device
*repo
)
317 struct ps3_repository_device tmp
= *repo
;
318 unsigned int num_dev
;
320 BUG_ON(repo
->bus_index
> 10);
321 BUG_ON(repo
->dev_index
> 10);
323 result
= ps3_repository_read_bus_num_dev(tmp
.bus_index
, &num_dev
);
326 pr_debug("%s:%d read_bus_num_dev failed\n", __func__
, __LINE__
);
330 pr_debug("%s:%d: bus_type %u, bus_index %u, bus_id %lu, num_dev %u\n",
331 __func__
, __LINE__
, tmp
.bus_type
, tmp
.bus_index
, tmp
.bus_id
,
334 if (tmp
.dev_index
>= num_dev
) {
335 pr_debug("%s:%d: no device found\n", __func__
, __LINE__
);
339 result
= ps3_repository_read_dev_type(tmp
.bus_index
, tmp
.dev_index
,
343 pr_debug("%s:%d read_dev_type failed\n", __func__
, __LINE__
);
347 if (tmp
.bus_type
== PS3_BUS_TYPE_STORAGE
) {
349 * A storage device may show up in the repository before the
350 * hypervisor has finished probing its type and regions
352 unsigned int num_regions
;
354 if (tmp
.dev_type
== PS3_DEV_TYPE_STOR_DUMMY
) {
355 pr_debug("%s:%u storage device not ready\n", __func__
,
360 result
= ps3_repository_read_stor_dev_num_regions(tmp
.bus_index
,
364 pr_debug("%s:%d read_stor_dev_num_regions failed\n",
370 pr_debug("%s:%u storage device has no regions yet\n",
376 result
= ps3_repository_read_dev_id(tmp
.bus_index
, tmp
.dev_index
,
380 pr_debug("%s:%d ps3_repository_read_dev_id failed\n", __func__
,
385 pr_debug("%s:%d: found: dev_type %u, dev_index %u, dev_id %lu\n",
386 __func__
, __LINE__
, tmp
.dev_type
, tmp
.dev_index
, tmp
.dev_id
);
392 int __devinit
ps3_repository_find_devices(enum ps3_bus_type bus_type
,
393 int (*callback
)(const struct ps3_repository_device
*repo
))
396 struct ps3_repository_device repo
;
398 pr_debug(" -> %s:%d: find bus_type %u\n", __func__
, __LINE__
, bus_type
);
400 for (repo
.bus_index
= 0; repo
.bus_index
< 10; repo
.bus_index
++) {
402 result
= ps3_repository_read_bus_type(repo
.bus_index
,
406 pr_debug("%s:%d read_bus_type(%u) failed\n",
407 __func__
, __LINE__
, repo
.bus_index
);
411 if (repo
.bus_type
!= bus_type
) {
412 pr_debug("%s:%d: skip, bus_type %u\n", __func__
,
413 __LINE__
, repo
.bus_type
);
417 result
= ps3_repository_read_bus_id(repo
.bus_index
,
421 pr_debug("%s:%d read_bus_id(%u) failed\n",
422 __func__
, __LINE__
, repo
.bus_index
);
426 for (repo
.dev_index
= 0; ; repo
.dev_index
++) {
427 result
= ps3_repository_find_device(&repo
);
429 if (result
== -ENODEV
) {
435 result
= callback(&repo
);
438 pr_debug("%s:%d: abort at callback\n", __func__
,
446 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
450 int ps3_repository_find_bus(enum ps3_bus_type bus_type
, unsigned int from
,
451 unsigned int *bus_index
)
454 enum ps3_bus_type type
;
457 for (i
= from
; i
< 10; i
++) {
458 error
= ps3_repository_read_bus_type(i
, &type
);
460 pr_debug("%s:%d read_bus_type failed\n",
462 *bus_index
= UINT_MAX
;
465 if (type
== bus_type
) {
470 *bus_index
= UINT_MAX
;
474 int ps3_repository_find_interrupt(const struct ps3_repository_device
*repo
,
475 enum ps3_interrupt_type intr_type
, unsigned int *interrupt_id
)
478 unsigned int res_index
;
480 pr_debug("%s:%d: find intr_type %u\n", __func__
, __LINE__
, intr_type
);
482 *interrupt_id
= UINT_MAX
;
484 for (res_index
= 0; res_index
< 10; res_index
++) {
485 enum ps3_interrupt_type t
;
488 result
= ps3_repository_read_dev_intr(repo
->bus_index
,
489 repo
->dev_index
, res_index
, &t
, &id
);
492 pr_debug("%s:%d read_dev_intr failed\n",
497 if (t
== intr_type
) {
506 pr_debug("%s:%d: found intr_type %u at res_index %u\n",
507 __func__
, __LINE__
, intr_type
, res_index
);
512 int ps3_repository_find_reg(const struct ps3_repository_device
*repo
,
513 enum ps3_reg_type reg_type
, u64
*bus_addr
, u64
*len
)
516 unsigned int res_index
;
518 pr_debug("%s:%d: find reg_type %u\n", __func__
, __LINE__
, reg_type
);
520 *bus_addr
= *len
= 0;
522 for (res_index
= 0; res_index
< 10; res_index
++) {
527 result
= ps3_repository_read_dev_reg(repo
->bus_index
,
528 repo
->dev_index
, res_index
, &t
, &a
, &l
);
531 pr_debug("%s:%d read_dev_reg failed\n",
546 pr_debug("%s:%d: found reg_type %u at res_index %u\n",
547 __func__
, __LINE__
, reg_type
, res_index
);
552 int ps3_repository_read_stor_dev_port(unsigned int bus_index
,
553 unsigned int dev_index
, u64
*port
)
555 return read_node(PS3_LPAR_ID_PME
,
556 make_first_field("bus", bus_index
),
557 make_field("dev", dev_index
),
558 make_field("port", 0),
562 int ps3_repository_read_stor_dev_blk_size(unsigned int bus_index
,
563 unsigned int dev_index
, u64
*blk_size
)
565 return read_node(PS3_LPAR_ID_PME
,
566 make_first_field("bus", bus_index
),
567 make_field("dev", dev_index
),
568 make_field("blk_size", 0),
572 int ps3_repository_read_stor_dev_num_blocks(unsigned int bus_index
,
573 unsigned int dev_index
, u64
*num_blocks
)
575 return read_node(PS3_LPAR_ID_PME
,
576 make_first_field("bus", bus_index
),
577 make_field("dev", dev_index
),
578 make_field("n_blocks", 0),
582 int ps3_repository_read_stor_dev_num_regions(unsigned int bus_index
,
583 unsigned int dev_index
, unsigned int *num_regions
)
588 result
= read_node(PS3_LPAR_ID_PME
,
589 make_first_field("bus", bus_index
),
590 make_field("dev", dev_index
),
591 make_field("n_regs", 0),
597 int ps3_repository_read_stor_dev_region_id(unsigned int bus_index
,
598 unsigned int dev_index
, unsigned int region_index
,
599 unsigned int *region_id
)
604 result
= read_node(PS3_LPAR_ID_PME
,
605 make_first_field("bus", bus_index
),
606 make_field("dev", dev_index
),
607 make_field("region", region_index
),
614 int ps3_repository_read_stor_dev_region_size(unsigned int bus_index
,
615 unsigned int dev_index
, unsigned int region_index
, u64
*region_size
)
617 return read_node(PS3_LPAR_ID_PME
,
618 make_first_field("bus", bus_index
),
619 make_field("dev", dev_index
),
620 make_field("region", region_index
),
621 make_field("size", 0),
625 int ps3_repository_read_stor_dev_region_start(unsigned int bus_index
,
626 unsigned int dev_index
, unsigned int region_index
, u64
*region_start
)
628 return read_node(PS3_LPAR_ID_PME
,
629 make_first_field("bus", bus_index
),
630 make_field("dev", dev_index
),
631 make_field("region", region_index
),
632 make_field("start", 0),
636 int ps3_repository_read_stor_dev_info(unsigned int bus_index
,
637 unsigned int dev_index
, u64
*port
, u64
*blk_size
,
638 u64
*num_blocks
, unsigned int *num_regions
)
642 result
= ps3_repository_read_stor_dev_port(bus_index
, dev_index
, port
);
646 result
= ps3_repository_read_stor_dev_blk_size(bus_index
, dev_index
,
651 result
= ps3_repository_read_stor_dev_num_blocks(bus_index
, dev_index
,
656 result
= ps3_repository_read_stor_dev_num_regions(bus_index
, dev_index
,
661 int ps3_repository_read_stor_dev_region(unsigned int bus_index
,
662 unsigned int dev_index
, unsigned int region_index
,
663 unsigned int *region_id
, u64
*region_start
, u64
*region_size
)
667 result
= ps3_repository_read_stor_dev_region_id(bus_index
, dev_index
,
668 region_index
, region_id
);
672 result
= ps3_repository_read_stor_dev_region_start(bus_index
, dev_index
,
673 region_index
, region_start
);
677 result
= ps3_repository_read_stor_dev_region_size(bus_index
, dev_index
,
678 region_index
, region_size
);
682 int ps3_repository_read_rm_size(unsigned int ppe_id
, u64
*rm_size
)
684 return read_node(PS3_LPAR_ID_CURRENT
,
685 make_first_field("bi", 0),
688 make_field("rm_size", 0),
692 int ps3_repository_read_region_total(u64
*region_total
)
694 return read_node(PS3_LPAR_ID_CURRENT
,
695 make_first_field("bi", 0),
696 make_field("rgntotal", 0),
702 * ps3_repository_read_mm_info - Read mm info for single pu system.
703 * @rm_base: Real mode memory base address.
704 * @rm_size: Real mode memory size.
705 * @region_total: Maximum memory region size.
708 int ps3_repository_read_mm_info(u64
*rm_base
, u64
*rm_size
, u64
*region_total
)
713 lv1_get_logical_ppe_id(&ppe_id
);
715 result
= ps3_repository_read_rm_size(ppe_id
, rm_size
);
716 return result
? result
717 : ps3_repository_read_region_total(region_total
);
721 * ps3_repository_read_num_spu_reserved - Number of physical spus reserved.
722 * @num_spu: Number of physical spus.
725 int ps3_repository_read_num_spu_reserved(unsigned int *num_spu_reserved
)
730 result
= read_node(PS3_LPAR_ID_CURRENT
,
731 make_first_field("bi", 0),
732 make_field("spun", 0),
735 *num_spu_reserved
= v1
;
740 * ps3_repository_read_num_spu_resource_id - Number of spu resource reservations.
741 * @num_resource_id: Number of spu resource ids.
744 int ps3_repository_read_num_spu_resource_id(unsigned int *num_resource_id
)
749 result
= read_node(PS3_LPAR_ID_CURRENT
,
750 make_first_field("bi", 0),
751 make_field("spursvn", 0),
754 *num_resource_id
= v1
;
759 * ps3_repository_read_spu_resource_id - spu resource reservation id value.
760 * @res_index: Resource reservation index.
761 * @resource_type: Resource reservation type.
762 * @resource_id: Resource reservation id.
765 int ps3_repository_read_spu_resource_id(unsigned int res_index
,
766 enum ps3_spu_resource_type
* resource_type
, unsigned int *resource_id
)
772 result
= read_node(PS3_LPAR_ID_CURRENT
,
773 make_first_field("bi", 0),
774 make_field("spursv", 0),
783 int ps3_repository_read_boot_dat_address(u64
*address
)
785 return read_node(PS3_LPAR_ID_CURRENT
,
786 make_first_field("bi", 0),
787 make_field("boot_dat", 0),
788 make_field("address", 0),
793 int ps3_repository_read_boot_dat_size(unsigned int *size
)
798 result
= read_node(PS3_LPAR_ID_CURRENT
,
799 make_first_field("bi", 0),
800 make_field("boot_dat", 0),
801 make_field("size", 0),
808 int ps3_repository_read_vuart_av_port(unsigned int *port
)
813 result
= read_node(PS3_LPAR_ID_CURRENT
,
814 make_first_field("bi", 0),
815 make_field("vir_uart", 0),
816 make_field("port", 0),
817 make_field("avset", 0),
823 int ps3_repository_read_vuart_sysmgr_port(unsigned int *port
)
828 result
= read_node(PS3_LPAR_ID_CURRENT
,
829 make_first_field("bi", 0),
830 make_field("vir_uart", 0),
831 make_field("port", 0),
832 make_field("sysmgr", 0),
839 * ps3_repository_read_boot_dat_info - Get address and size of cell_ext_os_area.
840 * address: lpar address of cell_ext_os_area
841 * @size: size of cell_ext_os_area
844 int ps3_repository_read_boot_dat_info(u64
*lpar_addr
, unsigned int *size
)
849 result
= ps3_repository_read_boot_dat_address(lpar_addr
);
850 return result
? result
851 : ps3_repository_read_boot_dat_size(size
);
854 int ps3_repository_read_num_be(unsigned int *num_be
)
859 result
= read_node(PS3_LPAR_ID_PME
,
860 make_first_field("ben", 0),
869 int ps3_repository_read_be_node_id(unsigned int be_index
, u64
*node_id
)
871 return read_node(PS3_LPAR_ID_PME
,
872 make_first_field("be", be_index
),
879 int ps3_repository_read_tb_freq(u64 node_id
, u64
*tb_freq
)
881 return read_node(PS3_LPAR_ID_PME
,
882 make_first_field("be", 0),
884 make_field("clock", 0),
889 int ps3_repository_read_be_tb_freq(unsigned int be_index
, u64
*tb_freq
)
895 result
= ps3_repository_read_be_node_id(0, &node_id
);
896 return result
? result
897 : ps3_repository_read_tb_freq(node_id
, tb_freq
);
902 int ps3_repository_dump_resource_info(const struct ps3_repository_device
*repo
)
905 unsigned int res_index
;
907 pr_debug(" -> %s:%d: (%u:%u)\n", __func__
, __LINE__
,
908 repo
->bus_index
, repo
->dev_index
);
910 for (res_index
= 0; res_index
< 10; res_index
++) {
911 enum ps3_interrupt_type intr_type
;
912 unsigned int interrupt_id
;
914 result
= ps3_repository_read_dev_intr(repo
->bus_index
,
915 repo
->dev_index
, res_index
, &intr_type
, &interrupt_id
);
918 if (result
!= LV1_NO_ENTRY
)
919 pr_debug("%s:%d ps3_repository_read_dev_intr"
920 " (%u:%u) failed\n", __func__
, __LINE__
,
921 repo
->bus_index
, repo
->dev_index
);
925 pr_debug("%s:%d (%u:%u) intr_type %u, interrupt_id %u\n",
926 __func__
, __LINE__
, repo
->bus_index
, repo
->dev_index
,
927 intr_type
, interrupt_id
);
930 for (res_index
= 0; res_index
< 10; res_index
++) {
931 enum ps3_reg_type reg_type
;
935 result
= ps3_repository_read_dev_reg(repo
->bus_index
,
936 repo
->dev_index
, res_index
, ®_type
, &bus_addr
, &len
);
939 if (result
!= LV1_NO_ENTRY
)
940 pr_debug("%s:%d ps3_repository_read_dev_reg"
941 " (%u:%u) failed\n", __func__
, __LINE__
,
942 repo
->bus_index
, repo
->dev_index
);
946 pr_debug("%s:%d (%u:%u) reg_type %u, bus_addr %lxh, len %lxh\n",
947 __func__
, __LINE__
, repo
->bus_index
, repo
->dev_index
,
948 reg_type
, bus_addr
, len
);
951 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
955 static int dump_stor_dev_info(struct ps3_repository_device
*repo
)
958 unsigned int num_regions
, region_index
;
959 u64 port
, blk_size
, num_blocks
;
961 pr_debug(" -> %s:%d: (%u:%u)\n", __func__
, __LINE__
,
962 repo
->bus_index
, repo
->dev_index
);
964 result
= ps3_repository_read_stor_dev_info(repo
->bus_index
,
965 repo
->dev_index
, &port
, &blk_size
, &num_blocks
, &num_regions
);
967 pr_debug("%s:%d ps3_repository_read_stor_dev_info"
968 " (%u:%u) failed\n", __func__
, __LINE__
,
969 repo
->bus_index
, repo
->dev_index
);
973 pr_debug("%s:%d (%u:%u): port %lu, blk_size %lu, num_blocks "
974 "%lu, num_regions %u\n",
975 __func__
, __LINE__
, repo
->bus_index
, repo
->dev_index
, port
,
976 blk_size
, num_blocks
, num_regions
);
978 for (region_index
= 0; region_index
< num_regions
; region_index
++) {
979 unsigned int region_id
;
980 u64 region_start
, region_size
;
982 result
= ps3_repository_read_stor_dev_region(repo
->bus_index
,
983 repo
->dev_index
, region_index
, ®ion_id
,
984 ®ion_start
, ®ion_size
);
986 pr_debug("%s:%d ps3_repository_read_stor_dev_region"
987 " (%u:%u) failed\n", __func__
, __LINE__
,
988 repo
->bus_index
, repo
->dev_index
);
992 pr_debug("%s:%d (%u:%u) region_id %u, start %lxh, size %lxh\n",
993 __func__
, __LINE__
, repo
->bus_index
, repo
->dev_index
,
994 region_id
, region_start
, region_size
);
998 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
1002 static int dump_device_info(struct ps3_repository_device
*repo
,
1003 unsigned int num_dev
)
1007 pr_debug(" -> %s:%d: bus_%u\n", __func__
, __LINE__
, repo
->bus_index
);
1009 for (repo
->dev_index
= 0; repo
->dev_index
< num_dev
;
1010 repo
->dev_index
++) {
1012 result
= ps3_repository_read_dev_type(repo
->bus_index
,
1013 repo
->dev_index
, &repo
->dev_type
);
1016 pr_debug("%s:%d ps3_repository_read_dev_type"
1017 " (%u:%u) failed\n", __func__
, __LINE__
,
1018 repo
->bus_index
, repo
->dev_index
);
1022 result
= ps3_repository_read_dev_id(repo
->bus_index
,
1023 repo
->dev_index
, &repo
->dev_id
);
1026 pr_debug("%s:%d ps3_repository_read_dev_id"
1027 " (%u:%u) failed\n", __func__
, __LINE__
,
1028 repo
->bus_index
, repo
->dev_index
);
1032 pr_debug("%s:%d (%u:%u): dev_type %u, dev_id %lu\n", __func__
,
1033 __LINE__
, repo
->bus_index
, repo
->dev_index
,
1034 repo
->dev_type
, repo
->dev_id
);
1036 ps3_repository_dump_resource_info(repo
);
1038 if (repo
->bus_type
== PS3_BUS_TYPE_STORAGE
)
1039 dump_stor_dev_info(repo
);
1042 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
1046 int ps3_repository_dump_bus_info(void)
1049 struct ps3_repository_device repo
;
1051 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
1053 memset(&repo
, 0, sizeof(repo
));
1055 for (repo
.bus_index
= 0; repo
.bus_index
< 10; repo
.bus_index
++) {
1056 unsigned int num_dev
;
1058 result
= ps3_repository_read_bus_type(repo
.bus_index
,
1062 pr_debug("%s:%d read_bus_type(%u) failed\n",
1063 __func__
, __LINE__
, repo
.bus_index
);
1067 result
= ps3_repository_read_bus_id(repo
.bus_index
,
1071 pr_debug("%s:%d read_bus_id(%u) failed\n",
1072 __func__
, __LINE__
, repo
.bus_index
);
1076 if (repo
.bus_index
!= repo
.bus_id
)
1077 pr_debug("%s:%d bus_index != bus_id\n",
1078 __func__
, __LINE__
);
1080 result
= ps3_repository_read_bus_num_dev(repo
.bus_index
,
1084 pr_debug("%s:%d read_bus_num_dev(%u) failed\n",
1085 __func__
, __LINE__
, repo
.bus_index
);
1089 pr_debug("%s:%d bus_%u: bus_type %u, bus_id %lu, num_dev %u\n",
1090 __func__
, __LINE__
, repo
.bus_index
, repo
.bus_type
,
1091 repo
.bus_id
, num_dev
);
1093 dump_device_info(&repo
, num_dev
);
1096 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
1100 #endif /* defined(DEBUG) */