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"
47 #define DBG(fmt...) udbg_printf(fmt)
53 * These are created by the linker script at the start and end
54 * of the section containing all the strings marked with the DS macro.
56 extern char __dt_strings_start
[];
57 extern char __dt_strings_end
[];
60 static const char __s[] __attribute__((section(".dt_strings"))) = s; \
64 struct iseries_flat_dt
{
65 struct boot_param_header header
;
69 static void * __initdata dt_data
;
72 * Putting these strings here keeps them out of the .dt_strings section
73 * that we capture for the strings blob of the flattened device tree.
75 static char __initdata device_type_cpu
[] = "cpu";
76 static char __initdata device_type_memory
[] = "memory";
77 static char __initdata device_type_serial
[] = "serial";
78 static char __initdata device_type_network
[] = "network";
79 static char __initdata device_type_pci
[] = "pci";
80 static char __initdata device_type_vdevice
[] = "vdevice";
81 static char __initdata device_type_vscsi
[] = "vscsi";
84 /* EBCDIC to ASCII conversion routines */
86 static unsigned char __init
e2a(unsigned char x
)
90 return x
- 0x81 + 'a';
92 return x
- 0x91 + 'j';
94 return x
- 0xA2 + 's';
96 return x
- 0xC1 + 'A';
98 return x
- 0xD1 + 'J';
100 return x
- 0xE2 + 'S';
102 return x
- 0xF0 + '0';
107 static unsigned char * __init
strne2a(unsigned char *dest
,
108 const unsigned char *src
, size_t n
)
114 for (i
= 0; i
< n
; i
++)
115 dest
[i
] = e2a(src
[i
]);
120 static struct iseries_flat_dt
* __init
dt_init(void)
122 struct iseries_flat_dt
*dt
;
123 unsigned long str_len
;
125 str_len
= __dt_strings_end
- __dt_strings_start
;
126 dt
= (struct iseries_flat_dt
*)ALIGN(klimit
, 8);
127 dt
->header
.off_mem_rsvmap
=
128 offsetof(struct iseries_flat_dt
, reserve_map
);
129 dt
->header
.off_dt_strings
= ALIGN(sizeof(*dt
), 8);
130 dt
->header
.off_dt_struct
= dt
->header
.off_dt_strings
132 dt_data
= (void *)((unsigned long)dt
+ dt
->header
.off_dt_struct
);
133 dt
->header
.dt_strings_size
= str_len
;
135 /* There is no notion of hardware cpu id on iSeries */
136 dt
->header
.boot_cpuid_phys
= smp_processor_id();
138 memcpy((char *)dt
+ dt
->header
.off_dt_strings
, __dt_strings_start
,
141 dt
->header
.magic
= OF_DT_HEADER
;
142 dt
->header
.version
= 0x10;
143 dt
->header
.last_comp_version
= 0x10;
145 dt
->reserve_map
[0] = 0;
146 dt
->reserve_map
[1] = 0;
151 static void __init
dt_push_u32(struct iseries_flat_dt
*dt
, u32 value
)
153 *((u32
*)dt_data
) = value
;
154 dt_data
+= sizeof(u32
);
158 static void __init
dt_push_u64(struct iseries_flat_dt
*dt
, u64 value
)
160 *((u64
*)dt_data
) = value
;
161 dt_data
+= sizeof(u64
);
165 static void __init
dt_push_bytes(struct iseries_flat_dt
*dt
, const char *data
,
168 memcpy(dt_data
, data
, len
);
169 dt_data
+= ALIGN(len
, 4);
172 static void __init
dt_start_node(struct iseries_flat_dt
*dt
, const char *name
)
174 dt_push_u32(dt
, OF_DT_BEGIN_NODE
);
175 dt_push_bytes(dt
, name
, strlen(name
) + 1);
178 #define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
180 static void __init
__dt_prop(struct iseries_flat_dt
*dt
, const char *name
,
181 const void *data
, int len
)
183 unsigned long offset
;
185 dt_push_u32(dt
, OF_DT_PROP
);
187 /* Length of the data */
188 dt_push_u32(dt
, len
);
190 offset
= name
- __dt_strings_start
;
192 /* The offset of the properties name in the string blob. */
193 dt_push_u32(dt
, (u32
)offset
);
195 /* The actual data. */
196 dt_push_bytes(dt
, data
, len
);
198 #define dt_prop(dt, name, data, len) __dt_prop((dt), DS(name), (data), (len))
200 #define dt_prop_str(dt, name, data) \
201 dt_prop((dt), name, (data), strlen((data)) + 1); /* + 1 for NULL */
203 static void __init
__dt_prop_u32(struct iseries_flat_dt
*dt
, const char *name
,
206 __dt_prop(dt
, name
, &data
, sizeof(u32
));
208 #define dt_prop_u32(dt, name, data) __dt_prop_u32((dt), DS(name), (data))
210 static void __init __maybe_unused
__dt_prop_u64(struct iseries_flat_dt
*dt
,
211 const char *name
, u64 data
)
213 __dt_prop(dt
, name
, &data
, sizeof(u64
));
215 #define dt_prop_u64(dt, name, data) __dt_prop_u64((dt), DS(name), (data))
217 #define dt_prop_u64_list(dt, name, data, n) \
218 dt_prop((dt), name, (data), sizeof(u64) * (n))
220 #define dt_prop_u32_list(dt, name, data, n) \
221 dt_prop((dt), name, (data), sizeof(u32) * (n))
223 #define dt_prop_empty(dt, name) dt_prop((dt), name, NULL, 0)
225 static void __init
dt_cpus(struct iseries_flat_dt
*dt
)
227 unsigned char buf
[32];
229 unsigned int i
, index
;
230 struct IoHriProcessorVpd
*d
;
234 snprintf(buf
, 32, "PowerPC,%s", cur_cpu_spec
->cpu_name
);
235 p
= strchr(buf
, ' ');
236 if (!p
) p
= buf
+ strlen(buf
);
238 dt_start_node(dt
, "cpus");
239 dt_prop_u32(dt
, "#address-cells", 1);
240 dt_prop_u32(dt
, "#size-cells", 0);
242 pft_size
[0] = 0; /* NUMA CEC cookie, 0 for non NUMA */
243 pft_size
[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE
);
245 for (i
= 0; i
< NR_CPUS
; i
++) {
246 if (lppaca
[i
].dyn_proc_status
>= 2)
249 snprintf(p
, 32 - (p
- buf
), "@%d", i
);
250 dt_start_node(dt
, buf
);
252 dt_prop_str(dt
, "device_type", device_type_cpu
);
254 index
= lppaca
[i
].dyn_hv_phys_proc_index
;
255 d
= &xIoHriProcessorVpd
[index
];
257 dt_prop_u32(dt
, "i-cache-size", d
->xInstCacheSize
* 1024);
258 dt_prop_u32(dt
, "i-cache-line-size", d
->xInstCacheOperandSize
);
260 dt_prop_u32(dt
, "d-cache-size", d
->xDataL1CacheSizeKB
* 1024);
261 dt_prop_u32(dt
, "d-cache-line-size", d
->xDataCacheOperandSize
);
263 /* magic conversions to Hz copied from old code */
264 dt_prop_u32(dt
, "clock-frequency",
265 ((1UL << 34) * 1000000) / d
->xProcFreq
);
266 dt_prop_u32(dt
, "timebase-frequency",
267 ((1UL << 32) * 1000000) / d
->xTimeBaseFreq
);
269 dt_prop_u32(dt
, "reg", i
);
271 dt_prop_u32_list(dt
, "ibm,pft-size", pft_size
, 2);
279 static void __init
dt_model(struct iseries_flat_dt
*dt
)
281 char buf
[16] = "IBM,";
283 /* N.B. lparcfg.c knows about the "IBM," prefixes ... */
284 /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
285 strne2a(buf
+ 4, xItExtVpdPanel
.mfgID
+ 2, 2);
286 strne2a(buf
+ 6, xItExtVpdPanel
.systemSerial
+ 1, 5);
288 dt_prop_str(dt
, "system-id", buf
);
290 /* "IBM," + machineType[0:4] */
291 strne2a(buf
+ 4, xItExtVpdPanel
.machineType
, 4);
293 dt_prop_str(dt
, "model", buf
);
295 dt_prop_str(dt
, "compatible", "IBM,iSeries");
296 dt_prop_u32(dt
, "ibm,partition-no", HvLpConfig_getLpIndex());
299 static void __init
dt_initrd(struct iseries_flat_dt
*dt
)
301 #ifdef CONFIG_BLK_DEV_INITRD
303 dt_prop_u64(dt
, "linux,initrd-start", (u64
)naca
.xRamDisk
);
304 dt_prop_u64(dt
, "linux,initrd-end",
305 (u64
)naca
.xRamDisk
+ naca
.xRamDiskSize
* HW_PAGE_SIZE
);
310 static void __init
dt_do_vdevice(struct iseries_flat_dt
*dt
,
311 const char *name
, u32 reg
, int unit
,
312 const char *type
, const char *compat
, int end
)
316 snprintf(buf
, 32, "%s@%08x", name
, reg
+ ((unit
>= 0) ? unit
: 0));
317 dt_start_node(dt
, buf
);
318 dt_prop_str(dt
, "device_type", type
);
320 dt_prop_str(dt
, "compatible", compat
);
321 dt_prop_u32(dt
, "reg", reg
+ ((unit
>= 0) ? unit
: 0));
323 dt_prop_u32(dt
, "linux,unit_address", unit
);
328 static void __init
dt_vdevices(struct iseries_flat_dt
*dt
)
331 HvLpIndexMap vlan_map
;
334 dt_start_node(dt
, "vdevice");
335 dt_prop_str(dt
, "device_type", device_type_vdevice
);
336 dt_prop_str(dt
, "compatible", "IBM,iSeries-vdevice");
337 dt_prop_u32(dt
, "#address-cells", 1);
338 dt_prop_u32(dt
, "#size-cells", 0);
340 dt_do_vdevice(dt
, "vty", reg
, -1, device_type_serial
,
341 "IBM,iSeries-vty", 1);
344 dt_do_vdevice(dt
, "v-scsi", reg
, -1, device_type_vscsi
,
348 vlan_map
= HvLpConfig_getVirtualLanIndexMap();
349 for (i
= 0; i
< HVMAXARCHITECTEDVIRTUALLANS
; i
++) {
350 unsigned char mac_addr
[ETH_ALEN
];
352 if ((vlan_map
& (0x8000 >> i
)) == 0)
354 dt_do_vdevice(dt
, "l-lan", reg
, i
, device_type_network
,
355 "IBM,iSeries-l-lan", 0);
361 mac_addr
[5] = HvLpConfig_getLpIndex_outline();
362 dt_prop(dt
, "local-mac-address", (char *)mac_addr
, ETH_ALEN
);
363 dt_prop(dt
, "mac-address", (char *)mac_addr
, ETH_ALEN
);
364 dt_prop_u32(dt
, "max-frame-size", 9000);
365 dt_prop_u32(dt
, "address-bits", 48);
373 struct pci_class_name
{
379 static struct pci_class_name __initdata pci_class_name
[] = {
380 { PCI_CLASS_NETWORK_ETHERNET
, "ethernet", device_type_network
},
383 static struct pci_class_name
* __init
dt_find_pci_class_name(u16 class_code
)
385 struct pci_class_name
*cp
;
387 for (cp
= pci_class_name
;
388 cp
< &pci_class_name
[ARRAY_SIZE(pci_class_name
)]; cp
++)
389 if (cp
->code
== class_code
)
395 * This assumes that the node slot is always on the primary bus!
397 static void __init
scan_bridge_slot(struct iseries_flat_dt
*dt
,
398 HvBusNumber bus
, struct HvCallPci_BridgeInfo
*bridge_info
)
400 HvSubBusNumber sub_bus
= bridge_info
->subBusNumber
;
407 int id_sel
= ISERIES_GET_DEVICE_FROM_SUBBUS(sub_bus
);
408 int function
= ISERIES_GET_FUNCTION_FROM_SUBBUS(sub_bus
);
409 HvAgentId eads_id_sel
= ISERIES_PCI_AGENTID(id_sel
, function
);
411 struct pci_class_name
*cp
;
414 * Connect all functions of any device found.
416 for (id_sel
= 1; id_sel
<= bridge_info
->maxAgents
; id_sel
++) {
417 for (function
= 0; function
< 8; function
++) {
418 HvAgentId agent_id
= ISERIES_PCI_AGENTID(id_sel
,
420 err
= HvCallXm_connectBusUnit(bus
, sub_bus
,
424 DBG("connectBusUnit(%x, %x, %x) %x\n",
425 bus
, sub_bus
, agent_id
, err
);
429 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
430 PCI_VENDOR_ID
, &vendor_id
);
432 DBG("ReadVendor(%x, %x, %x) %x\n",
433 bus
, sub_bus
, agent_id
, err
);
436 err
= HvCallPci_configLoad16(bus
, sub_bus
, agent_id
,
437 PCI_DEVICE_ID
, &device_id
);
439 DBG("ReadDevice(%x, %x, %x) %x\n",
440 bus
, sub_bus
, agent_id
, err
);
443 err
= HvCallPci_configLoad32(bus
, sub_bus
, agent_id
,
444 PCI_CLASS_REVISION
, &class_id
);
446 DBG("ReadClass(%x, %x, %x) %x\n",
447 bus
, sub_bus
, agent_id
, err
);
451 devfn
= PCI_DEVFN(ISERIES_ENCODE_DEVICE(eads_id_sel
),
453 cp
= dt_find_pci_class_name(class_id
>> 16);
455 strncpy(buf
, cp
->name
, sizeof(buf
) - 1);
457 snprintf(buf
, sizeof(buf
), "pci%x,%x",
458 vendor_id
, device_id
);
459 buf
[sizeof(buf
) - 1] = '\0';
460 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
461 "@%x", PCI_SLOT(devfn
));
462 buf
[sizeof(buf
) - 1] = '\0';
464 snprintf(buf
+ strlen(buf
),
465 sizeof(buf
) - strlen(buf
),
467 dt_start_node(dt
, buf
);
468 reg
[0] = (bus
<< 16) | (devfn
<< 8);
473 dt_prop_u32_list(dt
, "reg", reg
, 5);
474 if (cp
&& (cp
->type
|| cp
->name
))
475 dt_prop_str(dt
, "device_type",
476 cp
->type
? cp
->type
: cp
->name
);
477 dt_prop_u32(dt
, "vendor-id", vendor_id
);
478 dt_prop_u32(dt
, "device-id", device_id
);
479 dt_prop_u32(dt
, "class-code", class_id
>> 8);
480 dt_prop_u32(dt
, "revision-id", class_id
& 0xff);
481 dt_prop_u32(dt
, "linux,subbus", sub_bus
);
482 dt_prop_u32(dt
, "linux,agent-id", agent_id
);
483 dt_prop_u32(dt
, "linux,logical-slot-number",
484 bridge_info
->logicalSlotNumber
);
491 static void __init
scan_bridge(struct iseries_flat_dt
*dt
, HvBusNumber bus
,
492 HvSubBusNumber sub_bus
, int id_sel
)
494 struct HvCallPci_BridgeInfo bridge_info
;
499 /* Note: hvSubBus and irq is always be 0 at this level! */
500 for (function
= 0; function
< 8; ++function
) {
501 agent_id
= ISERIES_PCI_AGENTID(id_sel
, function
);
502 ret
= HvCallXm_connectBusUnit(bus
, sub_bus
, agent_id
, 0);
505 DBG("connectBusUnit(%x, %x, %x) %x\n",
506 bus
, sub_bus
, agent_id
, ret
);
509 DBG("found device at bus %d idsel %d func %d (AgentId %x)\n",
510 bus
, id_sel
, function
, agent_id
);
511 ret
= HvCallPci_getBusUnitInfo(bus
, sub_bus
, agent_id
,
512 iseries_hv_addr(&bridge_info
),
513 sizeof(struct HvCallPci_BridgeInfo
));
516 DBG("bridge info: type %x subbus %x "
517 "maxAgents %x maxsubbus %x logslot %x\n",
518 bridge_info
.busUnitInfo
.deviceType
,
519 bridge_info
.subBusNumber
,
520 bridge_info
.maxAgents
,
521 bridge_info
.maxSubBusNumber
,
522 bridge_info
.logicalSlotNumber
);
523 if (bridge_info
.busUnitInfo
.deviceType
==
524 HvCallPci_BridgeDevice
)
525 scan_bridge_slot(dt
, bus
, &bridge_info
);
527 DBG("PCI: Invalid Bridge Configuration(0x%02X)",
528 bridge_info
.busUnitInfo
.deviceType
);
532 static void __init
scan_phb(struct iseries_flat_dt
*dt
, HvBusNumber bus
)
534 struct HvCallPci_DeviceInfo dev_info
;
535 const HvSubBusNumber sub_bus
= 0; /* EADs is always 0. */
538 const int max_agents
= 8;
541 * Probe for EADs Bridges
543 for (id_sel
= 1; id_sel
< max_agents
; ++id_sel
) {
544 err
= HvCallPci_getDeviceInfo(bus
, sub_bus
, id_sel
,
545 iseries_hv_addr(&dev_info
),
546 sizeof(struct HvCallPci_DeviceInfo
));
549 DBG("getDeviceInfo(%x, %x, %x) %x\n",
550 bus
, sub_bus
, id_sel
, err
);
553 if (dev_info
.deviceType
!= HvCallPci_NodeDevice
) {
554 DBG("PCI: Invalid System Configuration"
555 "(0x%02X) for bus 0x%02x id 0x%02x.\n",
556 dev_info
.deviceType
, bus
, id_sel
);
559 scan_bridge(dt
, bus
, sub_bus
, id_sel
);
563 static void __init
dt_pci_devices(struct iseries_flat_dt
*dt
)
570 /* Check all possible buses. */
571 for (bus
= 0; bus
< 256; bus
++) {
572 int err
= HvCallXm_testBus(bus
);
576 * Check for Unexpected Return code, a clue that
577 * something has gone wrong.
580 DBG("Unexpected Return on Probe(0x%02X) "
581 "0x%04X\n", bus
, err
);
584 DBG("bus %d appears to exist\n", bus
);
585 snprintf(buf
, 32, "pci@%d", phb_num
);
586 dt_start_node(dt
, buf
);
587 dt_prop_str(dt
, "device_type", device_type_pci
);
588 dt_prop_str(dt
, "compatible", "IBM,iSeries-Logical-PHB");
589 dt_prop_u32(dt
, "#address-cells", 3);
590 dt_prop_u32(dt
, "#size-cells", 2);
591 buses
[0] = buses
[1] = bus
;
592 dt_prop_u32_list(dt
, "bus-range", buses
, 2);
599 static void dt_finish(struct iseries_flat_dt
*dt
)
601 dt_push_u32(dt
, OF_DT_END
);
602 dt
->header
.totalsize
= (unsigned long)dt_data
- (unsigned long)dt
;
603 klimit
= ALIGN((unsigned long)dt_data
, 8);
606 void * __init
build_flat_dt(unsigned long phys_mem_size
)
608 struct iseries_flat_dt
*iseries_dt
;
611 iseries_dt
= dt_init();
613 dt_start_node(iseries_dt
, "");
615 dt_prop_u32(iseries_dt
, "#address-cells", 2);
616 dt_prop_u32(iseries_dt
, "#size-cells", 2);
617 dt_model(iseries_dt
);
620 dt_start_node(iseries_dt
, "memory@0");
621 dt_prop_str(iseries_dt
, "device_type", device_type_memory
);
623 tmp
[1] = phys_mem_size
;
624 dt_prop_u64_list(iseries_dt
, "reg", tmp
, 2);
625 dt_end_node(iseries_dt
);
628 dt_start_node(iseries_dt
, "chosen");
629 dt_prop_str(iseries_dt
, "bootargs", cmd_line
);
630 dt_initrd(iseries_dt
);
631 dt_end_node(iseries_dt
);
635 dt_vdevices(iseries_dt
);
636 dt_pci_devices(iseries_dt
);
638 dt_end_node(iseries_dt
);
640 dt_finish(iseries_dt
);