2 * Copyright (C) 2005-2006 Michael Ellerman, IBM Corporation
3 * Copyright (C) 2000-2004, IBM Corporation
6 * This file contains all the routines to build a flattened device
7 * tree for a legacy iSeries machine.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
17 #include <linux/types.h>
18 #include <linux/init.h>
19 #include <linux/pci.h>
20 #include <linux/pci_regs.h>
21 #include <linux/pci_ids.h>
22 #include <linux/threads.h>
23 #include <linux/bitops.h>
24 #include <linux/string.h>
25 #include <linux/kernel.h>
26 #include <linux/if_ether.h> /* ETH_ALEN */
28 #include <asm/machdep.h>
30 #include <asm/lppaca.h>
31 #include <asm/cputable.h>
32 #include <asm/abs_addr.h>
33 #include <asm/system.h>
34 #include <asm/iseries/hv_types.h>
35 #include <asm/iseries/hv_lp_config.h>
36 #include <asm/iseries/hv_call_xm.h>
39 #include "processor_vpd.h"
43 #include "it_exp_vpd_panel.h"
46 #define DBG(fmt...) udbg_printf(fmt)
52 * These are created by the linker script at the start and end
53 * of the section containing all the strings from this file.
55 extern char __dt_strings_start
[];
56 extern char __dt_strings_end
[];
58 struct iseries_flat_dt
{
59 struct boot_param_header header
;
63 static void * __initdata dt_data
;
66 * Putting these strings here keeps them out of the section
67 * that we rename to .dt_strings using objcopy and capture
68 * for the strings blob of the flattened device tree.
70 static char __initdata device_type_cpu
[] = "cpu";
71 static char __initdata device_type_memory
[] = "memory";
72 static char __initdata device_type_serial
[] = "serial";
73 static char __initdata device_type_network
[] = "network";
74 static char __initdata device_type_block
[] = "block";
75 static char __initdata device_type_byte
[] = "byte";
76 static char __initdata device_type_pci
[] = "pci";
77 static char __initdata device_type_vdevice
[] = "vdevice";
78 static char __initdata device_type_vscsi
[] = "vscsi";
81 /* EBCDIC to ASCII conversion routines */
83 static unsigned char __init
e2a(unsigned char x
)
87 return x
- 0x81 + 'a';
89 return x
- 0x91 + 'j';
91 return x
- 0xA2 + 's';
93 return x
- 0xC1 + 'A';
95 return x
- 0xD1 + 'J';
97 return x
- 0xE2 + 'S';
99 return x
- 0xF0 + '0';
104 static unsigned char * __init
strne2a(unsigned char *dest
,
105 const unsigned char *src
, size_t n
)
111 for (i
= 0; i
< n
; i
++)
112 dest
[i
] = e2a(src
[i
]);
117 static struct iseries_flat_dt
* __init
dt_init(void)
119 struct iseries_flat_dt
*dt
;
120 unsigned long str_len
;
122 str_len
= __dt_strings_end
- __dt_strings_start
;
123 dt
= (struct iseries_flat_dt
*)ALIGN(klimit
, 8);
124 dt
->header
.off_mem_rsvmap
=
125 offsetof(struct iseries_flat_dt
, reserve_map
);
126 dt
->header
.off_dt_strings
= ALIGN(sizeof(*dt
), 8);
127 dt
->header
.off_dt_struct
= dt
->header
.off_dt_strings
129 dt_data
= (void *)((unsigned long)dt
+ dt
->header
.off_dt_struct
);
130 dt
->header
.dt_strings_size
= str_len
;
132 /* There is no notion of hardware cpu id on iSeries */
133 dt
->header
.boot_cpuid_phys
= smp_processor_id();
135 memcpy((char *)dt
+ dt
->header
.off_dt_strings
, __dt_strings_start
,
138 dt
->header
.magic
= OF_DT_HEADER
;
139 dt
->header
.version
= 0x10;
140 dt
->header
.last_comp_version
= 0x10;
142 dt
->reserve_map
[0] = 0;
143 dt
->reserve_map
[1] = 0;
148 static void __init
dt_push_u32(struct iseries_flat_dt
*dt
, u32 value
)
150 *((u32
*)dt_data
) = value
;
151 dt_data
+= sizeof(u32
);
155 static void __init
dt_push_u64(struct iseries_flat_dt
*dt
, u64 value
)
157 *((u64
*)dt_data
) = value
;
158 dt_data
+= sizeof(u64
);
162 static void __init
dt_push_bytes(struct iseries_flat_dt
*dt
, const char *data
,
165 memcpy(dt_data
, data
, len
);
166 dt_data
+= ALIGN(len
, 4);
169 static void __init
dt_start_node(struct iseries_flat_dt
*dt
, const char *name
)
171 dt_push_u32(dt
, OF_DT_BEGIN_NODE
);
172 dt_push_bytes(dt
, name
, strlen(name
) + 1);
175 #define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
177 static void __init
dt_prop(struct iseries_flat_dt
*dt
, const char *name
,
178 const void *data
, int len
)
180 unsigned long offset
;
182 dt_push_u32(dt
, OF_DT_PROP
);
184 /* Length of the data */
185 dt_push_u32(dt
, len
);
187 offset
= name
- __dt_strings_start
;
189 /* The offset of the properties name in the string blob. */
190 dt_push_u32(dt
, (u32
)offset
);
192 /* The actual data. */
193 dt_push_bytes(dt
, data
, len
);
196 static void __init
dt_prop_str(struct iseries_flat_dt
*dt
, const char *name
,
199 dt_prop(dt
, name
, data
, strlen(data
) + 1); /* + 1 for NULL */
202 static void __init
dt_prop_u32(struct iseries_flat_dt
*dt
, const char *name
,
205 dt_prop(dt
, name
, &data
, sizeof(u32
));
209 static void __init
dt_prop_u64(struct iseries_flat_dt
*dt
, const char *name
,
212 dt_prop(dt
, name
, &data
, sizeof(u64
));
216 static void __init
dt_prop_u64_list(struct iseries_flat_dt
*dt
,
217 const char *name
, u64
*data
, int n
)
219 dt_prop(dt
, name
, data
, sizeof(u64
) * n
);
222 static void __init
dt_prop_u32_list(struct iseries_flat_dt
*dt
,
223 const char *name
, u32
*data
, int n
)
225 dt_prop(dt
, name
, data
, sizeof(u32
) * n
);
229 static void __init
dt_prop_empty(struct iseries_flat_dt
*dt
, const char *name
)
231 dt_prop(dt
, name
, NULL
, 0);
235 static void __init
dt_cpus(struct iseries_flat_dt
*dt
)
237 unsigned char buf
[32];
239 unsigned int i
, index
;
240 struct IoHriProcessorVpd
*d
;
244 snprintf(buf
, 32, "PowerPC,%s", cur_cpu_spec
->cpu_name
);
245 p
= strchr(buf
, ' ');
246 if (!p
) p
= buf
+ strlen(buf
);
248 dt_start_node(dt
, "cpus");
249 dt_prop_u32(dt
, "#address-cells", 1);
250 dt_prop_u32(dt
, "#size-cells", 0);
252 pft_size
[0] = 0; /* NUMA CEC cookie, 0 for non NUMA */
253 pft_size
[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE
);
255 for (i
= 0; i
< NR_CPUS
; i
++) {
256 if (lppaca
[i
].dyn_proc_status
>= 2)
259 snprintf(p
, 32 - (p
- buf
), "@%d", i
);
260 dt_start_node(dt
, buf
);
262 dt_prop_str(dt
, "device_type", device_type_cpu
);
264 index
= lppaca
[i
].dyn_hv_phys_proc_index
;
265 d
= &xIoHriProcessorVpd
[index
];
267 dt_prop_u32(dt
, "i-cache-size", d
->xInstCacheSize
* 1024);
268 dt_prop_u32(dt
, "i-cache-line-size", d
->xInstCacheOperandSize
);
270 dt_prop_u32(dt
, "d-cache-size", d
->xDataL1CacheSizeKB
* 1024);
271 dt_prop_u32(dt
, "d-cache-line-size", d
->xDataCacheOperandSize
);
273 /* magic conversions to Hz copied from old code */
274 dt_prop_u32(dt
, "clock-frequency",
275 ((1UL << 34) * 1000000) / d
->xProcFreq
);
276 dt_prop_u32(dt
, "timebase-frequency",
277 ((1UL << 32) * 1000000) / d
->xTimeBaseFreq
);
279 dt_prop_u32(dt
, "reg", i
);
281 dt_prop_u32_list(dt
, "ibm,pft-size", pft_size
, 2);
289 static void __init
dt_model(struct iseries_flat_dt
*dt
)
291 char buf
[16] = "IBM,";
293 /* N.B. lparcfg.c knows about the "IBM," prefixes ... */
294 /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
295 strne2a(buf
+ 4, xItExtVpdPanel
.mfgID
+ 2, 2);
296 strne2a(buf
+ 6, xItExtVpdPanel
.systemSerial
+ 1, 5);
298 dt_prop_str(dt
, "system-id", buf
);
300 /* "IBM," + machineType[0:4] */
301 strne2a(buf
+ 4, xItExtVpdPanel
.machineType
, 4);
303 dt_prop_str(dt
, "model", buf
);
305 dt_prop_str(dt
, "compatible", "IBM,iSeries");
306 dt_prop_u32(dt
, "ibm,partition-no", HvLpConfig_getLpIndex());
309 static void __init
dt_do_vdevice(struct iseries_flat_dt
*dt
,
310 const char *name
, u32 reg
, int unit
,
311 const char *type
, const char *compat
, int end
)
315 snprintf(buf
, 32, "%s@%08x", name
, reg
+ ((unit
>= 0) ? unit
: 0));
316 dt_start_node(dt
, buf
);
317 dt_prop_str(dt
, "device_type", type
);
319 dt_prop_str(dt
, "compatible", compat
);
320 dt_prop_u32(dt
, "reg", reg
+ ((unit
>= 0) ? unit
: 0));
322 dt_prop_u32(dt
, "linux,unit_address", unit
);
327 static void __init
dt_vdevices(struct iseries_flat_dt
*dt
)
330 HvLpIndexMap vlan_map
;
333 dt_start_node(dt
, "vdevice");
334 dt_prop_str(dt
, "device_type", device_type_vdevice
);
335 dt_prop_str(dt
, "compatible", "IBM,iSeries-vdevice");
336 dt_prop_u32(dt
, "#address-cells", 1);
337 dt_prop_u32(dt
, "#size-cells", 0);
339 dt_do_vdevice(dt
, "vty", reg
, -1, device_type_serial
, NULL
, 1);
342 dt_do_vdevice(dt
, "v-scsi", reg
, -1, device_type_vscsi
,
346 vlan_map
= HvLpConfig_getVirtualLanIndexMap();
347 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALLANS
; i
++) {
348 unsigned char mac_addr
[ETH_ALEN
];
350 if ((vlan_map
& (0x8000 >> i
)) == 0)
352 dt_do_vdevice(dt
, "l-lan", reg
, i
, device_type_network
,
353 "IBM,iSeries-l-lan", 0);
359 mac_addr
[5] = HvLpConfig_getLpIndex_outline();
360 dt_prop(dt
, "local-mac-address", (char *)mac_addr
, ETH_ALEN
);
361 dt_prop(dt
, "mac-address", (char *)mac_addr
, ETH_ALEN
);
362 dt_prop_u32(dt
, "max-frame-size", 9000);
363 dt_prop_u32(dt
, "address-bits", 48);
367 reg
+= HVMAXARCHITECTEDVIRTUALLANS
;
369 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALDISKS
; i
++)
370 dt_do_vdevice(dt
, "viodasd", reg
, i
, device_type_block
,
371 "IBM,iSeries-viodasd", 1);
372 reg
+= HVMAXARCHITECTEDVIRTUALDISKS
;
374 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALCDROMS
; i
++)
375 dt_do_vdevice(dt
, "viocd", reg
, i
, device_type_block
,
376 "IBM,iSeries-viocd", 1);
377 reg
+= HVMAXARCHITECTEDVIRTUALCDROMS
;
379 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALTAPES
; i
++)
380 dt_do_vdevice(dt
, "viotape", reg
, i
, device_type_byte
,
381 "IBM,iSeries-viotape", 1);
386 struct pci_class_name
{
392 static struct pci_class_name __initdata pci_class_name
[] = {
393 { PCI_CLASS_NETWORK_ETHERNET
, "ethernet", device_type_network
},
396 static struct pci_class_name
* __init
dt_find_pci_class_name(u16 class_code
)
398 struct pci_class_name
*cp
;
400 for (cp
= pci_class_name
;
401 cp
< &pci_class_name
[ARRAY_SIZE(pci_class_name
)]; cp
++)
402 if (cp
->code
== class_code
)
408 * This assumes that the node slot is always on the primary bus!
410 static void __init
scan_bridge_slot(struct iseries_flat_dt
*dt
,
411 HvBusNumber bus
, struct HvCallPci_BridgeInfo
*bridge_info
)
413 HvSubBusNumber sub_bus
= bridge_info
->subBusNumber
;
420 int id_sel
= ISERIES_GET_DEVICE_FROM_SUBBUS(sub_bus
);
421 int function
= ISERIES_GET_FUNCTION_FROM_SUBBUS(sub_bus
);
422 HvAgentId eads_id_sel
= ISERIES_PCI_AGENTID(id_sel
, function
);
424 struct pci_class_name
*cp
;
427 * Connect all functions of any device found.
429 for (id_sel
= 1; id_sel
<= bridge_info
->maxAgents
; id_sel
++) {
430 for (function
= 0; function
< 8; function
++) {
431 HvAgentId agent_id
= ISERIES_PCI_AGENTID(id_sel
,
433 err
= HvCallXm_connectBusUnit(bus
, sub_bus
,
437 DBG("connectBusUnit(%x, %x, %x) %x\n",
438 bus
, sub_bus
, agent_id
, err
);
442 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
443 PCI_VENDOR_ID
, &vendor_id
);
445 DBG("ReadVendor(%x, %x, %x) %x\n",
446 bus
, sub_bus
, agent_id
, err
);
449 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
450 PCI_DEVICE_ID
, &device_id
);
452 DBG("ReadDevice(%x, %x, %x) %x\n",
453 bus
, sub_bus
, agent_id
, err
);
456 err
= HvCallPci_configLoad32(bus
, sub_bus
, agent_id
,
457 PCI_CLASS_REVISION
, &class_id
);
459 DBG("ReadClass(%x, %x, %x) %x\n",
460 bus
, sub_bus
, agent_id
, err
);
464 devfn
= PCI_DEVFN(ISERIES_ENCODE_DEVICE(eads_id_sel
),
466 cp
= dt_find_pci_class_name(class_id
>> 16);
468 strncpy(buf
, cp
->name
, sizeof(buf
) - 1);
470 snprintf(buf
, sizeof(buf
), "pci%x,%x",
471 vendor_id
, device_id
);
472 buf
[sizeof(buf
) - 1] = '\0';
473 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
474 "@%x", PCI_SLOT(devfn
));
475 buf
[sizeof(buf
) - 1] = '\0';
477 snprintf(buf
+ strlen(buf
),
478 sizeof(buf
) - strlen(buf
),
480 dt_start_node(dt
, buf
);
481 reg
[0] = (bus
<< 16) | (devfn
<< 8);
486 dt_prop_u32_list(dt
, "reg", reg
, 5);
487 if (cp
&& (cp
->type
|| cp
->name
))
488 dt_prop_str(dt
, "device_type",
489 cp
->type
? cp
->type
: cp
->name
);
490 dt_prop_u32(dt
, "vendor-id", vendor_id
);
491 dt_prop_u32(dt
, "device-id", device_id
);
492 dt_prop_u32(dt
, "class-code", class_id
>> 8);
493 dt_prop_u32(dt
, "revision-id", class_id
& 0xff);
494 dt_prop_u32(dt
, "linux,subbus", sub_bus
);
495 dt_prop_u32(dt
, "linux,agent-id", agent_id
);
496 dt_prop_u32(dt
, "linux,logical-slot-number",
497 bridge_info
->logicalSlotNumber
);
504 static void __init
scan_bridge(struct iseries_flat_dt
*dt
, HvBusNumber bus
,
505 HvSubBusNumber sub_bus
, int id_sel
)
507 struct HvCallPci_BridgeInfo bridge_info
;
512 /* Note: hvSubBus and irq is always be 0 at this level! */
513 for (function
= 0; function
< 8; ++function
) {
514 agent_id
= ISERIES_PCI_AGENTID(id_sel
, function
);
515 ret
= HvCallXm_connectBusUnit(bus
, sub_bus
, agent_id
, 0);
518 DBG("connectBusUnit(%x, %x, %x) %x\n",
519 bus
, sub_bus
, agent_id
, ret
);
522 DBG("found device at bus %d idsel %d func %d (AgentId %x)\n",
523 bus
, id_sel
, function
, agent_id
);
524 ret
= HvCallPci_getBusUnitInfo(bus
, sub_bus
, agent_id
,
525 iseries_hv_addr(&bridge_info
),
526 sizeof(struct HvCallPci_BridgeInfo
));
529 DBG("bridge info: type %x subbus %x "
530 "maxAgents %x maxsubbus %x logslot %x\n",
531 bridge_info
.busUnitInfo
.deviceType
,
532 bridge_info
.subBusNumber
,
533 bridge_info
.maxAgents
,
534 bridge_info
.maxSubBusNumber
,
535 bridge_info
.logicalSlotNumber
);
536 if (bridge_info
.busUnitInfo
.deviceType
==
537 HvCallPci_BridgeDevice
)
538 scan_bridge_slot(dt
, bus
, &bridge_info
);
540 DBG("PCI: Invalid Bridge Configuration(0x%02X)",
541 bridge_info
.busUnitInfo
.deviceType
);
545 static void __init
scan_phb(struct iseries_flat_dt
*dt
, HvBusNumber bus
)
547 struct HvCallPci_DeviceInfo dev_info
;
548 const HvSubBusNumber sub_bus
= 0; /* EADs is always 0. */
551 const int max_agents
= 8;
554 * Probe for EADs Bridges
556 for (id_sel
= 1; id_sel
< max_agents
; ++id_sel
) {
557 err
= HvCallPci_getDeviceInfo(bus
, sub_bus
, id_sel
,
558 iseries_hv_addr(&dev_info
),
559 sizeof(struct HvCallPci_DeviceInfo
));
562 DBG("getDeviceInfo(%x, %x, %x) %x\n",
563 bus
, sub_bus
, id_sel
, err
);
566 if (dev_info
.deviceType
!= HvCallPci_NodeDevice
) {
567 DBG("PCI: Invalid System Configuration"
568 "(0x%02X) for bus 0x%02x id 0x%02x.\n",
569 dev_info
.deviceType
, bus
, id_sel
);
572 scan_bridge(dt
, bus
, sub_bus
, id_sel
);
576 static void __init
dt_pci_devices(struct iseries_flat_dt
*dt
)
583 /* Check all possible buses. */
584 for (bus
= 0; bus
< 256; bus
++) {
585 int err
= HvCallXm_testBus(bus
);
589 * Check for Unexpected Return code, a clue that
590 * something has gone wrong.
593 DBG("Unexpected Return on Probe(0x%02X) "
594 "0x%04X\n", bus
, err
);
597 DBG("bus %d appears to exist\n", bus
);
598 snprintf(buf
, 32, "pci@%d", phb_num
);
599 dt_start_node(dt
, buf
);
600 dt_prop_str(dt
, "device_type", device_type_pci
);
601 dt_prop_str(dt
, "compatible", "IBM,iSeries-Logical-PHB");
602 dt_prop_u32(dt
, "#address-cells", 3);
603 dt_prop_u32(dt
, "#size-cells", 2);
604 buses
[0] = buses
[1] = bus
;
605 dt_prop_u32_list(dt
, "bus-range", buses
, 2);
612 static void dt_finish(struct iseries_flat_dt
*dt
)
614 dt_push_u32(dt
, OF_DT_END
);
615 dt
->header
.totalsize
= (unsigned long)dt_data
- (unsigned long)dt
;
616 klimit
= ALIGN((unsigned long)dt_data
, 8);
619 void * __init
build_flat_dt(unsigned long phys_mem_size
)
621 struct iseries_flat_dt
*iseries_dt
;
624 iseries_dt
= dt_init();
626 dt_start_node(iseries_dt
, "");
628 dt_prop_u32(iseries_dt
, "#address-cells", 2);
629 dt_prop_u32(iseries_dt
, "#size-cells", 2);
630 dt_model(iseries_dt
);
633 dt_start_node(iseries_dt
, "memory@0");
634 dt_prop_str(iseries_dt
, "device_type", device_type_memory
);
636 tmp
[1] = phys_mem_size
;
637 dt_prop_u64_list(iseries_dt
, "reg", tmp
, 2);
638 dt_end_node(iseries_dt
);
641 dt_start_node(iseries_dt
, "chosen");
642 dt_prop_str(iseries_dt
, "bootargs", cmd_line
);
643 dt_end_node(iseries_dt
);
647 dt_vdevices(iseries_dt
);
648 dt_pci_devices(iseries_dt
);
650 dt_end_node(iseries_dt
);
652 dt_finish(iseries_dt
);