1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/cpu.h>
20#include <linux/errno.h>
21#include <linux/sched.h>
22#include <linux/kernel.h>
23#include <linux/mm.h>
24#include <linux/stddef.h>
25#include <linux/unistd.h>
26#include <linux/slab.h>
27#include <linux/user.h>
28#include <linux/tty.h>
29#include <linux/major.h>
30#include <linux/interrupt.h>
31#include <linux/reboot.h>
32#include <linux/init.h>
33#include <linux/ioport.h>
34#include <linux/console.h>
35#include <linux/pci.h>
36#include <linux/utsname.h>
37#include <linux/adb.h>
38#include <linux/module.h>
39#include <linux/delay.h>
40#include <linux/irq.h>
41#include <linux/seq_file.h>
42#include <linux/root_dev.h>
43
44#include <asm/mmu.h>
45#include <asm/processor.h>
46#include <asm/io.h>
47#include <asm/pgtable.h>
48#include <asm/prom.h>
49#include <asm/rtas.h>
50#include <asm/pci-bridge.h>
51#include <asm/iommu.h>
52#include <asm/dma.h>
53#include <asm/machdep.h>
54#include <asm/irq.h>
55#include <asm/time.h>
56#include <asm/nvram.h>
57#include "xics.h"
58#include <asm/pmc.h>
59#include <asm/mpic.h>
60#include <asm/ppc-pci.h>
61#include <asm/i8259.h>
62#include <asm/udbg.h>
63#include <asm/smp.h>
64#include <asm/firmware.h>
65#include <asm/eeh.h>
66#include <asm/pSeries_reconfig.h>
67
68#include "plpar_wrappers.h"
69#include "pseries.h"
70
71int CMO_PrPSP = -1;
72int CMO_SecPSP = -1;
73unsigned long CMO_PageSize = (ASM_CONST(1) << IOMMU_PAGE_SHIFT);
74EXPORT_SYMBOL(CMO_PageSize);
75
76int fwnmi_active;
77
78static void pseries_shared_idle_sleep(void);
79static void pseries_dedicated_idle_sleep(void);
80
81static struct device_node *pSeries_mpic_node;
82
83static void pSeries_show_cpuinfo(struct seq_file *m)
84{
85 struct device_node *root;
86 const char *model = "";
87
88 root = of_find_node_by_path("/");
89 if (root)
90 model = of_get_property(root, "model", NULL);
91 seq_printf(m, "machine\t\t: CHRP %s\n", model);
92 of_node_put(root);
93}
94
95
96
97
98static void __init fwnmi_init(void)
99{
100 unsigned long system_reset_addr, machine_check_addr;
101
102 int ibm_nmi_register = rtas_token("ibm,nmi-register");
103 if (ibm_nmi_register == RTAS_UNKNOWN_SERVICE)
104 return;
105
106
107
108 system_reset_addr = __pa(system_reset_fwnmi) - PHYSICAL_START;
109 machine_check_addr = __pa(machine_check_fwnmi) - PHYSICAL_START;
110
111 if (0 == rtas_call(ibm_nmi_register, 2, 1, NULL, system_reset_addr,
112 machine_check_addr))
113 fwnmi_active = 1;
114}
115
116static void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc)
117{
118 unsigned int cascade_irq = i8259_irq();
119 if (cascade_irq != NO_IRQ)
120 generic_handle_irq(cascade_irq);
121 desc->chip->eoi(irq);
122}
123
124static void __init pseries_setup_i8259_cascade(void)
125{
126 struct device_node *np, *old, *found = NULL;
127 unsigned int cascade;
128 const u32 *addrp;
129 unsigned long intack = 0;
130 int naddr;
131
132 for_each_node_by_type(np, "interrupt-controller") {
133 if (of_device_is_compatible(np, "chrp,iic")) {
134 found = np;
135 break;
136 }
137 }
138
139 if (found == NULL) {
140 printk(KERN_DEBUG "pic: no ISA interrupt controller\n");
141 return;
142 }
143
144 cascade = irq_of_parse_and_map(found, 0);
145 if (cascade == NO_IRQ) {
146 printk(KERN_ERR "pic: failed to map cascade interrupt");
147 return;
148 }
149 pr_debug("pic: cascade mapped to irq %d\n", cascade);
150
151 for (old = of_node_get(found); old != NULL ; old = np) {
152 np = of_get_parent(old);
153 of_node_put(old);
154 if (np == NULL)
155 break;
156 if (strcmp(np->name, "pci") != 0)
157 continue;
158 addrp = of_get_property(np, "8259-interrupt-acknowledge", NULL);
159 if (addrp == NULL)
160 continue;
161 naddr = of_n_addr_cells(np);
162 intack = addrp[naddr-1];
163 if (naddr > 1)
164 intack |= ((unsigned long)addrp[naddr-2]) << 32;
165 }
166 if (intack)
167 printk(KERN_DEBUG "pic: PCI 8259 intack at 0x%016lx\n", intack);
168 i8259_init(found, intack);
169 of_node_put(found);
170 set_irq_chained_handler(cascade, pseries_8259_cascade);
171}
172
173static void __init pseries_mpic_init_IRQ(void)
174{
175 struct device_node *np;
176 const unsigned int *opprop;
177 unsigned long openpic_addr = 0;
178 int naddr, n, i, opplen;
179 struct mpic *mpic;
180
181 np = of_find_node_by_path("/");
182 naddr = of_n_addr_cells(np);
183 opprop = of_get_property(np, "platform-open-pic", &opplen);
184 if (opprop != 0) {
185 openpic_addr = of_read_number(opprop, naddr);
186 printk(KERN_DEBUG "OpenPIC addr: %lx\n", openpic_addr);
187 }
188 of_node_put(np);
189
190 BUG_ON(openpic_addr == 0);
191
192
193 mpic = mpic_alloc(pSeries_mpic_node, openpic_addr,
194 MPIC_PRIMARY,
195 16, 250,
196 " MPIC ");
197 BUG_ON(mpic == NULL);
198
199
200 opplen /= sizeof(u32);
201 for (n = 0, i = naddr; i < opplen; i += naddr, n++) {
202 unsigned long isuaddr = of_read_number(opprop + i, naddr);
203 mpic_assign_isu(mpic, n, isuaddr);
204 }
205
206
207 mpic_init(mpic);
208
209
210 pseries_setup_i8259_cascade();
211}
212
213static void __init pseries_xics_init_IRQ(void)
214{
215 xics_init_IRQ();
216 pseries_setup_i8259_cascade();
217}
218
219static void pseries_lpar_enable_pmcs(void)
220{
221 unsigned long set, reset;
222
223 set = 1UL << 63;
224 reset = 0;
225 plpar_hcall_norets(H_PERFMON, set, reset);
226}
227
228static void __init pseries_discover_pic(void)
229{
230 struct device_node *np;
231 const char *typep;
232
233 for (np = NULL; (np = of_find_node_by_name(np,
234 "interrupt-controller"));) {
235 typep = of_get_property(np, "compatible", NULL);
236 if (strstr(typep, "open-pic")) {
237 pSeries_mpic_node = of_node_get(np);
238 ppc_md.init_IRQ = pseries_mpic_init_IRQ;
239 ppc_md.get_irq = mpic_get_irq;
240 setup_kexec_cpu_down_mpic();
241 smp_init_pseries_mpic();
242 return;
243 } else if (strstr(typep, "ppc-xicp")) {
244 ppc_md.init_IRQ = pseries_xics_init_IRQ;
245 setup_kexec_cpu_down_xics();
246 smp_init_pseries_xics();
247 return;
248 }
249 }
250 printk(KERN_ERR "pSeries_discover_pic: failed to recognize"
251 " interrupt-controller\n");
252}
253
254static int pci_dn_reconfig_notifier(struct notifier_block *nb, unsigned long action, void *node)
255{
256 struct device_node *np = node;
257 struct pci_dn *pci = NULL;
258 int err = NOTIFY_OK;
259
260 switch (action) {
261 case PSERIES_RECONFIG_ADD:
262 pci = np->parent->data;
263 if (pci)
264 update_dn_pci_info(np, pci->phb);
265 break;
266 default:
267 err = NOTIFY_DONE;
268 break;
269 }
270 return err;
271}
272
273static struct notifier_block pci_dn_reconfig_nb = {
274 .notifier_call = pci_dn_reconfig_notifier,
275};
276
277static void __init pSeries_setup_arch(void)
278{
279
280 pseries_discover_pic();
281
282
283
284
285
286
287 loops_per_jiffy = 50000000;
288
289 fwnmi_init();
290
291
292 init_pci_config_tokens();
293 find_and_init_phbs();
294 pSeries_reconfig_notifier_register(&pci_dn_reconfig_nb);
295 eeh_init();
296
297 pSeries_nvram_init();
298
299
300 if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
301 vpa_init(boot_cpuid);
302 if (get_lppaca()->shared_proc) {
303 printk(KERN_DEBUG "Using shared processor idle loop\n");
304 ppc_md.power_save = pseries_shared_idle_sleep;
305 } else {
306 printk(KERN_DEBUG "Using dedicated idle loop\n");
307 ppc_md.power_save = pseries_dedicated_idle_sleep;
308 }
309 } else {
310 printk(KERN_DEBUG "Using default idle loop\n");
311 }
312
313 if (firmware_has_feature(FW_FEATURE_LPAR))
314 ppc_md.enable_pmcs = pseries_lpar_enable_pmcs;
315 else
316 ppc_md.enable_pmcs = power4_enable_pmcs;
317}
318
319static int __init pSeries_init_panel(void)
320{
321
322 ppc_md.progress("Linux ppc64\n", 0);
323 ppc_md.progress(init_utsname()->version, 0);
324
325 return 0;
326}
327arch_initcall(pSeries_init_panel);
328
329static int pseries_set_dabr(unsigned long dabr)
330{
331 return plpar_hcall_norets(H_SET_DABR, dabr);
332}
333
334static int pseries_set_xdabr(unsigned long dabr)
335{
336
337 return plpar_hcall_norets(H_SET_XDABR, dabr,
338 H_DABRX_KERNEL | H_DABRX_USER);
339}
340
341#define CMO_CHARACTERISTICS_TOKEN 44
342#define CMO_MAXLENGTH 1026
343
344
345
346
347
348void pSeries_cmo_feature_init(void)
349{
350 char *ptr, *key, *value, *end;
351 int call_status;
352 int page_order = IOMMU_PAGE_SHIFT;
353
354 pr_debug(" -> fw_cmo_feature_init()\n");
355 spin_lock(&rtas_data_buf_lock);
356 memset(rtas_data_buf, 0, RTAS_DATA_BUF_SIZE);
357 call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
358 NULL,
359 CMO_CHARACTERISTICS_TOKEN,
360 __pa(rtas_data_buf),
361 RTAS_DATA_BUF_SIZE);
362
363 if (call_status != 0) {
364 spin_unlock(&rtas_data_buf_lock);
365 pr_debug("CMO not available\n");
366 pr_debug(" <- fw_cmo_feature_init()\n");
367 return;
368 }
369
370 end = rtas_data_buf + CMO_MAXLENGTH - 2;
371 ptr = rtas_data_buf + 2;
372 key = value = ptr;
373
374 while (*ptr && (ptr <= end)) {
375
376
377
378 if (ptr[0] == '=') {
379 ptr[0] = '\0';
380 value = ptr + 1;
381 } else if (ptr[0] == '\0' || ptr[0] == ',') {
382
383 ptr[0] = '\0';
384
385 if (key == value) {
386 pr_debug("Malformed key/value pair\n");
387
388 break;
389 }
390
391 if (0 == strcmp(key, "CMOPageSize"))
392 page_order = simple_strtol(value, NULL, 10);
393 else if (0 == strcmp(key, "PrPSP"))
394 CMO_PrPSP = simple_strtol(value, NULL, 10);
395 else if (0 == strcmp(key, "SecPSP"))
396 CMO_SecPSP = simple_strtol(value, NULL, 10);
397 value = key = ptr + 1;
398 }
399 ptr++;
400 }
401
402
403
404
405 CMO_PageSize = 1 << page_order;
406 pr_debug("CMO_PageSize = %lu\n", CMO_PageSize);
407
408 if (CMO_PrPSP != -1 || CMO_SecPSP != -1) {
409 pr_info("CMO enabled\n");
410 pr_debug("CMO enabled, PrPSP=%d, SecPSP=%d\n", CMO_PrPSP,
411 CMO_SecPSP);
412 powerpc_firmware_features |= FW_FEATURE_CMO;
413 } else
414 pr_debug("CMO not enabled, PrPSP=%d, SecPSP=%d\n", CMO_PrPSP,
415 CMO_SecPSP);
416 spin_unlock(&rtas_data_buf_lock);
417 pr_debug(" <- fw_cmo_feature_init()\n");
418}
419
420
421
422
423static void __init pSeries_init_early(void)
424{
425 pr_debug(" -> pSeries_init_early()\n");
426
427 if (firmware_has_feature(FW_FEATURE_LPAR))
428 find_udbg_vterm();
429
430 if (firmware_has_feature(FW_FEATURE_DABR))
431 ppc_md.set_dabr = pseries_set_dabr;
432 else if (firmware_has_feature(FW_FEATURE_XDABR))
433 ppc_md.set_dabr = pseries_set_xdabr;
434
435 pSeries_cmo_feature_init();
436 iommu_init_early_pSeries();
437
438 pr_debug(" <- pSeries_init_early()\n");
439}
440
441
442
443
444
445static int __init pSeries_probe_hypertas(unsigned long node,
446 const char *uname, int depth,
447 void *data)
448{
449 const char *hypertas;
450 unsigned long len;
451
452 if (depth != 1 ||
453 (strcmp(uname, "rtas") != 0 && strcmp(uname, "rtas@0") != 0))
454 return 0;
455
456 hypertas = of_get_flat_dt_prop(node, "ibm,hypertas-functions", &len);
457 if (!hypertas)
458 return 1;
459
460 powerpc_firmware_features |= FW_FEATURE_LPAR;
461 fw_feature_init(hypertas, len);
462
463 return 1;
464}
465
466static int __init pSeries_probe(void)
467{
468 unsigned long root = of_get_flat_dt_root();
469 char *dtype = of_get_flat_dt_prop(root, "device_type", NULL);
470
471 if (dtype == NULL)
472 return 0;
473 if (strcmp(dtype, "chrp"))
474 return 0;
475
476
477
478
479 if (of_flat_dt_is_compatible(root, "IBM,CPBW-1.0") ||
480 of_flat_dt_is_compatible(root, "IBM,CBEA"))
481 return 0;
482
483 pr_debug("pSeries detected, looking for LPAR capability...\n");
484
485
486 of_scan_flat_dt(pSeries_probe_hypertas, NULL);
487
488 if (firmware_has_feature(FW_FEATURE_LPAR))
489 hpte_init_lpar();
490 else
491 hpte_init_native();
492
493 pr_debug("Machine is%s LPAR !\n",
494 (powerpc_firmware_features & FW_FEATURE_LPAR) ? "" : " not");
495
496 return 1;
497}
498
499
500DECLARE_PER_CPU(unsigned long, smt_snooze_delay);
501
502static void pseries_dedicated_idle_sleep(void)
503{
504 unsigned int cpu = smp_processor_id();
505 unsigned long start_snooze;
506 unsigned long in_purr, out_purr;
507
508
509
510
511
512 get_lppaca()->idle = 1;
513 get_lppaca()->donate_dedicated_cpu = 1;
514 in_purr = mfspr(SPRN_PURR);
515
516
517
518
519
520
521 if (__get_cpu_var(smt_snooze_delay)) {
522 start_snooze = get_tb() +
523 __get_cpu_var(smt_snooze_delay) * tb_ticks_per_usec;
524 local_irq_enable();
525 set_thread_flag(TIF_POLLING_NRFLAG);
526
527 while (get_tb() < start_snooze) {
528 if (need_resched() || cpu_is_offline(cpu))
529 goto out;
530 ppc64_runlatch_off();
531 HMT_low();
532 HMT_very_low();
533 }
534
535 HMT_medium();
536 clear_thread_flag(TIF_POLLING_NRFLAG);
537 smp_mb();
538 local_irq_disable();
539 if (need_resched() || cpu_is_offline(cpu))
540 goto out;
541 }
542
543 cede_processor();
544
545out:
546 HMT_medium();
547 out_purr = mfspr(SPRN_PURR);
548 get_lppaca()->wait_state_cycles += out_purr - in_purr;
549 get_lppaca()->donate_dedicated_cpu = 0;
550 get_lppaca()->idle = 0;
551}
552
553static void pseries_shared_idle_sleep(void)
554{
555
556
557
558
559 get_lppaca()->idle = 1;
560
561
562
563
564
565
566
567
568 cede_processor();
569
570 get_lppaca()->idle = 0;
571}
572
573static int pSeries_pci_probe_mode(struct pci_bus *bus)
574{
575 if (firmware_has_feature(FW_FEATURE_LPAR))
576 return PCI_PROBE_DEVTREE;
577 return PCI_PROBE_NORMAL;
578}
579
580
581
582
583
584
585
586
587
588
589static void pSeries_power_off(void)
590{
591 int rc;
592 int rtas_poweroff_ups_token = rtas_token("ibm,power-off-ups");
593
594 if (rtas_flash_term_hook)
595 rtas_flash_term_hook(SYS_POWER_OFF);
596
597 if (rtas_poweron_auto == 0 ||
598 rtas_poweroff_ups_token == RTAS_UNKNOWN_SERVICE) {
599 rc = rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1);
600 printk(KERN_INFO "RTAS power-off returned %d\n", rc);
601 } else {
602 rc = rtas_call(rtas_poweroff_ups_token, 0, 1, NULL);
603 printk(KERN_INFO "RTAS ibm,power-off-ups returned %d\n", rc);
604 }
605 for (;;);
606}
607
608#ifndef CONFIG_PCI
609void pSeries_final_fixup(void) { }
610#endif
611
612define_machine(pseries) {
613 .name = "pSeries",
614 .probe = pSeries_probe,
615 .setup_arch = pSeries_setup_arch,
616 .init_early = pSeries_init_early,
617 .show_cpuinfo = pSeries_show_cpuinfo,
618 .log_error = pSeries_log_error,
619 .pcibios_fixup = pSeries_final_fixup,
620 .pci_probe_mode = pSeries_pci_probe_mode,
621 .restart = rtas_restart,
622 .power_off = pSeries_power_off,
623 .halt = rtas_halt,
624 .panic = rtas_os_term,
625 .get_boot_time = rtas_get_boot_time,
626 .get_rtc_time = rtas_get_rtc_time,
627 .set_rtc_time = rtas_set_rtc_time,
628 .calibrate_decr = generic_calibrate_decr,
629 .progress = rtas_progress,
630 .system_reset_exception = pSeries_system_reset_exception,
631 .machine_check_exception = pSeries_machine_check_exception,
632};
633