2 * Copyright (c) 2005-2006 Michael Ellerman, IBM Corporation
5 * This file contains all the routines to build a flattened device
6 * tree for a legacy iSeries machine.
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
16 #include <linux/types.h>
17 #include <linux/init.h>
18 #include <linux/pci.h>
19 #include <linux/pci_regs.h>
20 #include <linux/pci_ids.h>
21 #include <linux/threads.h>
22 #include <linux/bitops.h>
23 #include <linux/string.h>
24 #include <linux/kernel.h>
25 #include <linux/if_ether.h> /* ETH_ALEN */
27 #include <asm/machdep.h>
29 #include <asm/lppaca.h>
30 #include <asm/cputable.h>
31 #include <asm/abs_addr.h>
32 #include <asm/system.h>
33 #include <asm/iseries/hv_types.h>
34 #include <asm/iseries/hv_lp_config.h>
35 #include <asm/iseries/hv_call_xm.h>
36 #include <asm/iseries/it_exp_vpd_panel.h>
39 #include "processor_vpd.h"
45 #define DBG(fmt...) udbg_printf(fmt)
51 * These are created by the linker script at the start and end
52 * of the section containing all the strings from this file.
54 extern char __dt_strings_start
[];
55 extern char __dt_strings_end
[];
57 struct iseries_flat_dt
{
58 struct boot_param_header header
;
62 static void * __initdata dt_data
;
65 * Putting these strings here keeps them out of the section
66 * that we rename to .dt_strings using objcopy and capture
67 * for the strings blob of the flattened device tree.
69 static char __initdata device_type_cpu
[] = "cpu";
70 static char __initdata device_type_memory
[] = "memory";
71 static char __initdata device_type_serial
[] = "serial";
72 static char __initdata device_type_network
[] = "network";
73 static char __initdata device_type_block
[] = "block";
74 static char __initdata device_type_byte
[] = "byte";
75 static char __initdata device_type_pci
[] = "pci";
76 static char __initdata device_type_vdevice
[] = "vdevice";
77 static char __initdata device_type_vscsi
[] = "vscsi";
79 static struct iseries_flat_dt
* __init
dt_init(void)
81 struct iseries_flat_dt
*dt
;
82 unsigned long str_len
;
84 str_len
= __dt_strings_end
- __dt_strings_start
;
85 dt
= (struct iseries_flat_dt
*)ALIGN(klimit
, 8);
86 dt
->header
.off_mem_rsvmap
=
87 offsetof(struct iseries_flat_dt
, reserve_map
);
88 dt
->header
.off_dt_strings
= ALIGN(sizeof(*dt
), 8);
89 dt
->header
.off_dt_struct
= dt
->header
.off_dt_strings
91 dt_data
= (void *)((unsigned long)dt
+ dt
->header
.off_dt_struct
);
92 dt
->header
.dt_strings_size
= str_len
;
94 /* There is no notion of hardware cpu id on iSeries */
95 dt
->header
.boot_cpuid_phys
= smp_processor_id();
97 memcpy((char *)dt
+ dt
->header
.off_dt_strings
, __dt_strings_start
,
100 dt
->header
.magic
= OF_DT_HEADER
;
101 dt
->header
.version
= 0x10;
102 dt
->header
.last_comp_version
= 0x10;
104 dt
->reserve_map
[0] = 0;
105 dt
->reserve_map
[1] = 0;
110 static void __init
dt_push_u32(struct iseries_flat_dt
*dt
, u32 value
)
112 *((u32
*)dt_data
) = value
;
113 dt_data
+= sizeof(u32
);
117 static void __init
dt_push_u64(struct iseries_flat_dt
*dt
, u64 value
)
119 *((u64
*)dt_data
) = value
;
120 dt_data
+= sizeof(u64
);
124 static void __init
dt_push_bytes(struct iseries_flat_dt
*dt
, const char *data
,
127 memcpy(dt_data
, data
, len
);
128 dt_data
+= ALIGN(len
, 4);
131 static void __init
dt_start_node(struct iseries_flat_dt
*dt
, const char *name
)
133 dt_push_u32(dt
, OF_DT_BEGIN_NODE
);
134 dt_push_bytes(dt
, name
, strlen(name
) + 1);
137 #define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
139 static void __init
dt_prop(struct iseries_flat_dt
*dt
, const char *name
,
140 const void *data
, int len
)
142 unsigned long offset
;
144 dt_push_u32(dt
, OF_DT_PROP
);
146 /* Length of the data */
147 dt_push_u32(dt
, len
);
149 offset
= name
- __dt_strings_start
;
151 /* The offset of the properties name in the string blob. */
152 dt_push_u32(dt
, (u32
)offset
);
154 /* The actual data. */
155 dt_push_bytes(dt
, data
, len
);
158 static void __init
dt_prop_str(struct iseries_flat_dt
*dt
, const char *name
,
161 dt_prop(dt
, name
, data
, strlen(data
) + 1); /* + 1 for NULL */
164 static void __init
dt_prop_u32(struct iseries_flat_dt
*dt
, const char *name
,
167 dt_prop(dt
, name
, &data
, sizeof(u32
));
171 static void __init
dt_prop_u64(struct iseries_flat_dt
*dt
, const char *name
,
174 dt_prop(dt
, name
, &data
, sizeof(u64
));
178 static void __init
dt_prop_u64_list(struct iseries_flat_dt
*dt
,
179 const char *name
, u64
*data
, int n
)
181 dt_prop(dt
, name
, data
, sizeof(u64
) * n
);
184 static void __init
dt_prop_u32_list(struct iseries_flat_dt
*dt
,
185 const char *name
, u32
*data
, int n
)
187 dt_prop(dt
, name
, data
, sizeof(u32
) * n
);
191 static void __init
dt_prop_empty(struct iseries_flat_dt
*dt
, const char *name
)
193 dt_prop(dt
, name
, NULL
, 0);
197 static void __init
dt_cpus(struct iseries_flat_dt
*dt
)
199 unsigned char buf
[32];
201 unsigned int i
, index
;
202 struct IoHriProcessorVpd
*d
;
206 snprintf(buf
, 32, "PowerPC,%s", cur_cpu_spec
->cpu_name
);
207 p
= strchr(buf
, ' ');
208 if (!p
) p
= buf
+ strlen(buf
);
210 dt_start_node(dt
, "cpus");
211 dt_prop_u32(dt
, "#address-cells", 1);
212 dt_prop_u32(dt
, "#size-cells", 0);
214 pft_size
[0] = 0; /* NUMA CEC cookie, 0 for non NUMA */
215 pft_size
[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE
);
217 for (i
= 0; i
< NR_CPUS
; i
++) {
218 if (lppaca
[i
].dyn_proc_status
>= 2)
221 snprintf(p
, 32 - (p
- buf
), "@%d", i
);
222 dt_start_node(dt
, buf
);
224 dt_prop_str(dt
, "device_type", device_type_cpu
);
226 index
= lppaca
[i
].dyn_hv_phys_proc_index
;
227 d
= &xIoHriProcessorVpd
[index
];
229 dt_prop_u32(dt
, "i-cache-size", d
->xInstCacheSize
* 1024);
230 dt_prop_u32(dt
, "i-cache-line-size", d
->xInstCacheOperandSize
);
232 dt_prop_u32(dt
, "d-cache-size", d
->xDataL1CacheSizeKB
* 1024);
233 dt_prop_u32(dt
, "d-cache-line-size", d
->xDataCacheOperandSize
);
235 /* magic conversions to Hz copied from old code */
236 dt_prop_u32(dt
, "clock-frequency",
237 ((1UL << 34) * 1000000) / d
->xProcFreq
);
238 dt_prop_u32(dt
, "timebase-frequency",
239 ((1UL << 32) * 1000000) / d
->xTimeBaseFreq
);
241 dt_prop_u32(dt
, "reg", i
);
243 dt_prop_u32_list(dt
, "ibm,pft-size", pft_size
, 2);
251 static void __init
dt_model(struct iseries_flat_dt
*dt
)
253 char buf
[16] = "IBM,";
255 /* N.B. lparcfg.c knows about the "IBM," prefixes ... */
256 /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
257 strne2a(buf
+ 4, xItExtVpdPanel
.mfgID
+ 2, 2);
258 strne2a(buf
+ 6, xItExtVpdPanel
.systemSerial
+ 1, 5);
260 dt_prop_str(dt
, "system-id", buf
);
262 /* "IBM," + machineType[0:4] */
263 strne2a(buf
+ 4, xItExtVpdPanel
.machineType
, 4);
265 dt_prop_str(dt
, "model", buf
);
267 dt_prop_str(dt
, "compatible", "IBM,iSeries");
268 dt_prop_u32(dt
, "ibm,partition-no", HvLpConfig_getLpIndex());
271 static void __init
dt_do_vdevice(struct iseries_flat_dt
*dt
,
272 const char *name
, u32 reg
, int unit
,
273 const char *type
, const char *compat
, int end
)
277 snprintf(buf
, 32, "%s@%08x", name
, reg
+ ((unit
>= 0) ? unit
: 0));
278 dt_start_node(dt
, buf
);
279 dt_prop_str(dt
, "device_type", type
);
281 dt_prop_str(dt
, "compatible", compat
);
282 dt_prop_u32(dt
, "reg", reg
+ ((unit
>= 0) ? unit
: 0));
284 dt_prop_u32(dt
, "linux,unit_address", unit
);
289 static void __init
dt_vdevices(struct iseries_flat_dt
*dt
)
292 HvLpIndexMap vlan_map
;
295 dt_start_node(dt
, "vdevice");
296 dt_prop_str(dt
, "device_type", device_type_vdevice
);
297 dt_prop_str(dt
, "compatible", "IBM,iSeries-vdevice");
298 dt_prop_u32(dt
, "#address-cells", 1);
299 dt_prop_u32(dt
, "#size-cells", 0);
301 dt_do_vdevice(dt
, "vty", reg
, -1, device_type_serial
,
302 "IBM,iSeries-vty", 1);
305 dt_do_vdevice(dt
, "v-scsi", reg
, -1, device_type_vscsi
,
309 vlan_map
= HvLpConfig_getVirtualLanIndexMap();
310 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALLANS
; i
++) {
311 unsigned char mac_addr
[ETH_ALEN
];
313 if ((vlan_map
& (0x8000 >> i
)) == 0)
315 dt_do_vdevice(dt
, "l-lan", reg
, i
, device_type_network
,
316 "IBM,iSeries-l-lan", 0);
322 mac_addr
[5] = HvLpConfig_getLpIndex_outline();
323 dt_prop(dt
, "local-mac-address", (char *)mac_addr
, ETH_ALEN
);
324 dt_prop(dt
, "mac-address", (char *)mac_addr
, ETH_ALEN
);
325 dt_prop_u32(dt
, "max-frame-size", 9000);
326 dt_prop_u32(dt
, "address-bits", 48);
330 reg
+= HVMAXARCHITECTEDVIRTUALLANS
;
332 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALDISKS
; i
++)
333 dt_do_vdevice(dt
, "viodasd", reg
, i
, device_type_block
,
334 "IBM,iSeries-viodasd", 1);
335 reg
+= HVMAXARCHITECTEDVIRTUALDISKS
;
337 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALCDROMS
; i
++)
338 dt_do_vdevice(dt
, "viocd", reg
, i
, device_type_block
,
339 "IBM,iSeries-viocd", 1);
340 reg
+= HVMAXARCHITECTEDVIRTUALCDROMS
;
342 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALTAPES
; i
++)
343 dt_do_vdevice(dt
, "viotape", reg
, i
, device_type_byte
,
344 "IBM,iSeries-viotape", 1);
349 struct pci_class_name
{
355 static struct pci_class_name __initdata pci_class_name
[] = {
356 { PCI_CLASS_NETWORK_ETHERNET
, "ethernet", device_type_network
},
359 static struct pci_class_name
* __init
dt_find_pci_class_name(u16 class_code
)
361 struct pci_class_name
*cp
;
363 for (cp
= pci_class_name
;
364 cp
< &pci_class_name
[ARRAY_SIZE(pci_class_name
)]; cp
++)
365 if (cp
->code
== class_code
)
371 * This assumes that the node slot is always on the primary bus!
373 static void __init
scan_bridge_slot(struct iseries_flat_dt
*dt
,
374 HvBusNumber bus
, struct HvCallPci_BridgeInfo
*bridge_info
)
376 HvSubBusNumber sub_bus
= bridge_info
->subBusNumber
;
383 int id_sel
= ISERIES_GET_DEVICE_FROM_SUBBUS(sub_bus
);
384 int function
= ISERIES_GET_FUNCTION_FROM_SUBBUS(sub_bus
);
385 HvAgentId eads_id_sel
= ISERIES_PCI_AGENTID(id_sel
, function
);
387 struct pci_class_name
*cp
;
390 * Connect all functions of any device found.
392 for (id_sel
= 1; id_sel
<= bridge_info
->maxAgents
; id_sel
++) {
393 for (function
= 0; function
< 8; function
++) {
394 HvAgentId agent_id
= ISERIES_PCI_AGENTID(id_sel
,
396 err
= HvCallXm_connectBusUnit(bus
, sub_bus
,
400 DBG("connectBusUnit(%x, %x, %x) %x\n",
401 bus
, sub_bus
, agent_id
, err
);
405 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
406 PCI_VENDOR_ID
, &vendor_id
);
408 DBG("ReadVendor(%x, %x, %x) %x\n",
409 bus
, sub_bus
, agent_id
, err
);
412 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
413 PCI_DEVICE_ID
, &device_id
);
415 DBG("ReadDevice(%x, %x, %x) %x\n",
416 bus
, sub_bus
, agent_id
, err
);
419 err
= HvCallPci_configLoad32(bus
, sub_bus
, agent_id
,
420 PCI_CLASS_REVISION
, &class_id
);
422 DBG("ReadClass(%x, %x, %x) %x\n",
423 bus
, sub_bus
, agent_id
, err
);
427 devfn
= PCI_DEVFN(ISERIES_ENCODE_DEVICE(eads_id_sel
),
429 cp
= dt_find_pci_class_name(class_id
>> 16);
431 strncpy(buf
, cp
->name
, sizeof(buf
) - 1);
433 snprintf(buf
, sizeof(buf
), "pci%x,%x",
434 vendor_id
, device_id
);
435 buf
[sizeof(buf
) - 1] = '\0';
436 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
437 "@%x", PCI_SLOT(devfn
));
438 buf
[sizeof(buf
) - 1] = '\0';
440 snprintf(buf
+ strlen(buf
),
441 sizeof(buf
) - strlen(buf
),
443 dt_start_node(dt
, buf
);
444 reg
[0] = (bus
<< 16) | (devfn
<< 8);
449 dt_prop_u32_list(dt
, "reg", reg
, 5);
450 if (cp
&& (cp
->type
|| cp
->name
))
451 dt_prop_str(dt
, "device_type",
452 cp
->type
? cp
->type
: cp
->name
);
453 dt_prop_u32(dt
, "vendor-id", vendor_id
);
454 dt_prop_u32(dt
, "device-id", device_id
);
455 dt_prop_u32(dt
, "class-code", class_id
>> 8);
456 dt_prop_u32(dt
, "revision-id", class_id
& 0xff);
457 dt_prop_u32(dt
, "linux,subbus", sub_bus
);
458 dt_prop_u32(dt
, "linux,agent-id", agent_id
);
459 dt_prop_u32(dt
, "linux,logical-slot-number",
460 bridge_info
->logicalSlotNumber
);
467 static void __init
scan_bridge(struct iseries_flat_dt
*dt
, HvBusNumber bus
,
468 HvSubBusNumber sub_bus
, int id_sel
)
470 struct HvCallPci_BridgeInfo bridge_info
;
475 /* Note: hvSubBus and irq is always be 0 at this level! */
476 for (function
= 0; function
< 8; ++function
) {
477 agent_id
= ISERIES_PCI_AGENTID(id_sel
, function
);
478 ret
= HvCallXm_connectBusUnit(bus
, sub_bus
, agent_id
, 0);
481 DBG("connectBusUnit(%x, %x, %x) %x\n",
482 bus
, sub_bus
, agent_id
, ret
);
485 DBG("found device at bus %d idsel %d func %d (AgentId %x)\n",
486 bus
, id_sel
, function
, agent_id
);
487 ret
= HvCallPci_getBusUnitInfo(bus
, sub_bus
, agent_id
,
488 iseries_hv_addr(&bridge_info
),
489 sizeof(struct HvCallPci_BridgeInfo
));
492 DBG("bridge info: type %x subbus %x "
493 "maxAgents %x maxsubbus %x logslot %x\n",
494 bridge_info
.busUnitInfo
.deviceType
,
495 bridge_info
.subBusNumber
,
496 bridge_info
.maxAgents
,
497 bridge_info
.maxSubBusNumber
,
498 bridge_info
.logicalSlotNumber
);
499 if (bridge_info
.busUnitInfo
.deviceType
==
500 HvCallPci_BridgeDevice
)
501 scan_bridge_slot(dt
, bus
, &bridge_info
);
503 DBG("PCI: Invalid Bridge Configuration(0x%02X)",
504 bridge_info
.busUnitInfo
.deviceType
);
508 static void __init
scan_phb(struct iseries_flat_dt
*dt
, HvBusNumber bus
)
510 struct HvCallPci_DeviceInfo dev_info
;
511 const HvSubBusNumber sub_bus
= 0; /* EADs is always 0. */
514 const int max_agents
= 8;
517 * Probe for EADs Bridges
519 for (id_sel
= 1; id_sel
< max_agents
; ++id_sel
) {
520 err
= HvCallPci_getDeviceInfo(bus
, sub_bus
, id_sel
,
521 iseries_hv_addr(&dev_info
),
522 sizeof(struct HvCallPci_DeviceInfo
));
525 DBG("getDeviceInfo(%x, %x, %x) %x\n",
526 bus
, sub_bus
, id_sel
, err
);
529 if (dev_info
.deviceType
!= HvCallPci_NodeDevice
) {
530 DBG("PCI: Invalid System Configuration"
531 "(0x%02X) for bus 0x%02x id 0x%02x.\n",
532 dev_info
.deviceType
, bus
, id_sel
);
535 scan_bridge(dt
, bus
, sub_bus
, id_sel
);
539 static void __init
dt_pci_devices(struct iseries_flat_dt
*dt
)
546 /* Check all possible buses. */
547 for (bus
= 0; bus
< 256; bus
++) {
548 int err
= HvCallXm_testBus(bus
);
552 * Check for Unexpected Return code, a clue that
553 * something has gone wrong.
556 DBG("Unexpected Return on Probe(0x%02X) "
557 "0x%04X\n", bus
, err
);
560 DBG("bus %d appears to exist\n", bus
);
561 snprintf(buf
, 32, "pci@%d", phb_num
);
562 dt_start_node(dt
, buf
);
563 dt_prop_str(dt
, "device_type", device_type_pci
);
564 dt_prop_str(dt
, "compatible", "IBM,iSeries-Logical-PHB");
565 dt_prop_u32(dt
, "#address-cells", 3);
566 dt_prop_u32(dt
, "#size-cells", 2);
567 buses
[0] = buses
[1] = bus
;
568 dt_prop_u32_list(dt
, "bus-range", buses
, 2);
575 static void dt_finish(struct iseries_flat_dt
*dt
)
577 dt_push_u32(dt
, OF_DT_END
);
578 dt
->header
.totalsize
= (unsigned long)dt_data
- (unsigned long)dt
;
579 klimit
= ALIGN((unsigned long)dt_data
, 8);
582 void * __init
build_flat_dt(unsigned long phys_mem_size
)
584 struct iseries_flat_dt
*iseries_dt
;
587 iseries_dt
= dt_init();
589 dt_start_node(iseries_dt
, "");
591 dt_prop_u32(iseries_dt
, "#address-cells", 2);
592 dt_prop_u32(iseries_dt
, "#size-cells", 2);
593 dt_model(iseries_dt
);
596 dt_start_node(iseries_dt
, "memory@0");
597 dt_prop_str(iseries_dt
, "device_type", device_type_memory
);
599 tmp
[1] = phys_mem_size
;
600 dt_prop_u64_list(iseries_dt
, "reg", tmp
, 2);
601 dt_end_node(iseries_dt
);
604 dt_start_node(iseries_dt
, "chosen");
605 dt_prop_str(iseries_dt
, "bootargs", cmd_line
);
606 dt_end_node(iseries_dt
);
610 dt_vdevices(iseries_dt
);
611 dt_pci_devices(iseries_dt
);
613 dt_end_node(iseries_dt
);
615 dt_finish(iseries_dt
);