2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-10-26 15:05:24 +08:00
|
|
|
* 64-bit pSeries and RS/6000 setup code.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Copyright (C) 1995 Linus Torvalds
|
|
|
|
* Adapted from 'alpha' version by Gary Thomas
|
|
|
|
* Modified by Cort Dougan (cort@cs.nmt.edu)
|
|
|
|
* Modified by PPC64 Team, IBM Corp
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bootup setup stuff..
|
|
|
|
*/
|
|
|
|
|
2005-07-08 08:56:30 +08:00
|
|
|
#include <linux/cpu.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/user.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/pci.h>
|
2005-07-11 03:35:15 +08:00
|
|
|
#include <linux/utsname.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/adb.h>
|
2011-07-23 06:24:23 +08:00
|
|
|
#include <linux/export.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/root_dev.h>
|
2012-10-03 00:57:57 +08:00
|
|
|
#include <linux/of.h>
|
2012-11-08 13:40:28 +08:00
|
|
|
#include <linux/kexec.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <asm/mmu.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/rtas.h>
|
|
|
|
#include <asm/pci-bridge.h>
|
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/dma.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/time.h>
|
|
|
|
#include <asm/nvram.h>
|
2005-08-09 09:13:36 +08:00
|
|
|
#include <asm/pmc.h>
|
2005-09-27 11:51:59 +08:00
|
|
|
#include <asm/mpic.h>
|
2011-04-04 11:46:58 +08:00
|
|
|
#include <asm/xics.h>
|
2005-09-28 00:50:25 +08:00
|
|
|
#include <asm/ppc-pci.h>
|
2005-10-10 20:03:41 +08:00
|
|
|
#include <asm/i8259.h>
|
|
|
|
#include <asm/udbg.h>
|
2005-11-07 10:18:13 +08:00
|
|
|
#include <asm/smp.h>
|
2007-02-08 15:33:51 +08:00
|
|
|
#include <asm/firmware.h>
|
2007-03-04 14:04:44 +08:00
|
|
|
#include <asm/eeh.h>
|
2012-12-20 22:06:45 +08:00
|
|
|
#include <asm/reg.h>
|
2013-08-22 17:53:52 +08:00
|
|
|
#include <asm/plpar_wrappers.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-08 15:33:51 +08:00
|
|
|
#include "pseries.h"
|
2005-11-03 12:33:31 +08:00
|
|
|
|
2008-08-16 03:07:31 +08:00
|
|
|
int CMO_PrPSP = -1;
|
|
|
|
int CMO_SecPSP = -1;
|
2013-12-09 15:17:01 +08:00
|
|
|
unsigned long CMO_PageSize = (ASM_CONST(1) << IOMMU_PAGE_SHIFT_4K);
|
2008-08-21 09:16:26 +08:00
|
|
|
EXPORT_SYMBOL(CMO_PageSize);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
int fwnmi_active; /* TRUE if an FWNMI handler is present */
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static struct device_node *pSeries_mpic_node;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-11 08:00:02 +08:00
|
|
|
static void pSeries_show_cpuinfo(struct seq_file *m)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct device_node *root;
|
|
|
|
const char *model = "";
|
|
|
|
|
|
|
|
root = of_find_node_by_path("/");
|
|
|
|
if (root)
|
2007-04-03 20:26:41 +08:00
|
|
|
model = of_get_property(root, "model", NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
seq_printf(m, "machine\t\t: CHRP %s\n", model);
|
|
|
|
of_node_put(root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize firmware assisted non-maskable interrupts if
|
|
|
|
* the firmware supports this feature.
|
|
|
|
*/
|
|
|
|
static void __init fwnmi_init(void)
|
|
|
|
{
|
2005-12-04 15:39:33 +08:00
|
|
|
unsigned long system_reset_addr, machine_check_addr;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int ibm_nmi_register = rtas_token("ibm,nmi-register");
|
|
|
|
if (ibm_nmi_register == RTAS_UNKNOWN_SERVICE)
|
|
|
|
return;
|
2005-12-04 15:39:33 +08:00
|
|
|
|
|
|
|
/* If the kernel's not linked at zero we point the firmware at low
|
|
|
|
* addresses anyway, and use a trampoline to get to the real code. */
|
|
|
|
system_reset_addr = __pa(system_reset_fwnmi) - PHYSICAL_START;
|
|
|
|
machine_check_addr = __pa(machine_check_fwnmi) - PHYSICAL_START;
|
|
|
|
|
|
|
|
if (0 == rtas_call(ibm_nmi_register, 2, 1, NULL, system_reset_addr,
|
|
|
|
machine_check_addr))
|
2005-04-17 06:20:36 +08:00
|
|
|
fwnmi_active = 1;
|
|
|
|
}
|
|
|
|
|
2008-05-08 12:27:23 +08:00
|
|
|
static void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
2011-03-25 23:45:20 +08:00
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
2006-10-07 20:08:26 +08:00
|
|
|
unsigned int cascade_irq = i8259_irq();
|
2011-03-07 21:59:45 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
if (cascade_irq != NO_IRQ)
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
generic_handle_irq(cascade_irq);
|
2011-03-07 21:59:45 +08:00
|
|
|
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
2006-07-03 17:32:51 +08:00
|
|
|
}
|
|
|
|
|
2008-04-01 14:42:25 +08:00
|
|
|
static void __init pseries_setup_i8259_cascade(void)
|
2008-04-01 14:42:25 +08:00
|
|
|
{
|
|
|
|
struct device_node *np, *old, *found = NULL;
|
2008-04-01 14:42:25 +08:00
|
|
|
unsigned int cascade;
|
2008-04-01 14:42:25 +08:00
|
|
|
const u32 *addrp;
|
|
|
|
unsigned long intack = 0;
|
2008-04-01 14:42:25 +08:00
|
|
|
int naddr;
|
2008-04-01 14:42:25 +08:00
|
|
|
|
2008-04-01 14:42:25 +08:00
|
|
|
for_each_node_by_type(np, "interrupt-controller") {
|
2008-04-01 14:42:25 +08:00
|
|
|
if (of_device_is_compatible(np, "chrp,iic")) {
|
|
|
|
found = np;
|
|
|
|
break;
|
|
|
|
}
|
2008-04-01 14:42:25 +08:00
|
|
|
}
|
|
|
|
|
2008-04-01 14:42:25 +08:00
|
|
|
if (found == NULL) {
|
2008-04-01 14:42:25 +08:00
|
|
|
printk(KERN_DEBUG "pic: no ISA interrupt controller\n");
|
2008-04-01 14:42:25 +08:00
|
|
|
return;
|
|
|
|
}
|
2008-04-01 14:42:25 +08:00
|
|
|
|
2008-04-01 14:42:25 +08:00
|
|
|
cascade = irq_of_parse_and_map(found, 0);
|
|
|
|
if (cascade == NO_IRQ) {
|
2008-04-01 14:42:25 +08:00
|
|
|
printk(KERN_ERR "pic: failed to map cascade interrupt");
|
2008-04-01 14:42:25 +08:00
|
|
|
return;
|
|
|
|
}
|
2008-04-01 14:42:25 +08:00
|
|
|
pr_debug("pic: cascade mapped to irq %d\n", cascade);
|
2008-04-01 14:42:25 +08:00
|
|
|
|
|
|
|
for (old = of_node_get(found); old != NULL ; old = np) {
|
|
|
|
np = of_get_parent(old);
|
|
|
|
of_node_put(old);
|
|
|
|
if (np == NULL)
|
|
|
|
break;
|
|
|
|
if (strcmp(np->name, "pci") != 0)
|
|
|
|
continue;
|
|
|
|
addrp = of_get_property(np, "8259-interrupt-acknowledge", NULL);
|
|
|
|
if (addrp == NULL)
|
|
|
|
continue;
|
|
|
|
naddr = of_n_addr_cells(np);
|
|
|
|
intack = addrp[naddr-1];
|
|
|
|
if (naddr > 1)
|
|
|
|
intack |= ((unsigned long)addrp[naddr-2]) << 32;
|
|
|
|
}
|
|
|
|
if (intack)
|
2008-04-01 14:42:25 +08:00
|
|
|
printk(KERN_DEBUG "pic: PCI 8259 intack at 0x%016lx\n", intack);
|
2008-04-01 14:42:25 +08:00
|
|
|
i8259_init(found, intack);
|
|
|
|
of_node_put(found);
|
2011-03-25 23:45:20 +08:00
|
|
|
irq_set_chained_handler(cascade, pseries_8259_cascade);
|
2008-04-01 14:42:25 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void __init pseries_mpic_init_IRQ(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-04-01 14:42:26 +08:00
|
|
|
struct device_node *np;
|
2006-07-12 13:39:43 +08:00
|
|
|
const unsigned int *opprop;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long openpic_addr = 0;
|
2006-07-03 19:36:01 +08:00
|
|
|
int naddr, n, i, opplen;
|
|
|
|
struct mpic *mpic;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
np = of_find_node_by_path("/");
|
2007-04-03 08:56:50 +08:00
|
|
|
naddr = of_n_addr_cells(np);
|
2007-04-03 20:26:41 +08:00
|
|
|
opprop = of_get_property(np, "platform-open-pic", &opplen);
|
2013-08-07 00:01:24 +08:00
|
|
|
if (opprop != NULL) {
|
2006-07-03 19:36:01 +08:00
|
|
|
openpic_addr = of_read_number(opprop, naddr);
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_DEBUG "OpenPIC addr: %lx\n", openpic_addr);
|
|
|
|
}
|
2006-07-03 19:36:01 +08:00
|
|
|
of_node_put(np);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
BUG_ON(openpic_addr == 0);
|
|
|
|
|
|
|
|
/* Setup the openpic driver */
|
2011-12-22 18:19:14 +08:00
|
|
|
mpic = mpic_alloc(pSeries_mpic_node, openpic_addr,
|
|
|
|
MPIC_NO_RESET, 16, 0, " MPIC ");
|
2006-07-03 19:36:01 +08:00
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
/* Add ISUs */
|
|
|
|
opplen /= sizeof(u32);
|
|
|
|
for (n = 0, i = naddr; i < opplen; i += naddr, n++) {
|
|
|
|
unsigned long isuaddr = of_read_number(opprop + i, naddr);
|
|
|
|
mpic_assign_isu(mpic, n, isuaddr);
|
|
|
|
}
|
|
|
|
|
2011-04-04 11:46:58 +08:00
|
|
|
/* Setup top-level get_irq */
|
|
|
|
ppc_md.get_irq = mpic_get_irq;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* All ISUs are setup, complete initialization */
|
|
|
|
mpic_init(mpic);
|
|
|
|
|
|
|
|
/* Look for cascade */
|
2008-04-01 14:42:26 +08:00
|
|
|
pseries_setup_i8259_cascade();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-01 14:42:25 +08:00
|
|
|
static void __init pseries_xics_init_IRQ(void)
|
|
|
|
{
|
2011-04-04 11:46:58 +08:00
|
|
|
xics_init();
|
2008-04-01 14:42:25 +08:00
|
|
|
pseries_setup_i8259_cascade();
|
2008-04-01 14:42:25 +08:00
|
|
|
}
|
|
|
|
|
2005-08-09 09:13:36 +08:00
|
|
|
static void pseries_lpar_enable_pmcs(void)
|
|
|
|
{
|
|
|
|
unsigned long set, reset;
|
|
|
|
|
|
|
|
set = 1UL << 63;
|
|
|
|
reset = 0;
|
|
|
|
plpar_hcall_norets(H_PERFMON, set, reset);
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void __init pseries_discover_pic(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
2006-07-12 13:39:43 +08:00
|
|
|
const char *typep;
|
2006-07-03 19:36:01 +08:00
|
|
|
|
2014-06-04 23:42:26 +08:00
|
|
|
for_each_node_by_name(np, "interrupt-controller") {
|
2007-04-03 20:26:41 +08:00
|
|
|
typep = of_get_property(np, "compatible", NULL);
|
2006-07-03 19:36:01 +08:00
|
|
|
if (strstr(typep, "open-pic")) {
|
|
|
|
pSeries_mpic_node = of_node_get(np);
|
|
|
|
ppc_md.init_IRQ = pseries_mpic_init_IRQ;
|
2007-02-08 15:33:55 +08:00
|
|
|
setup_kexec_cpu_down_mpic();
|
2006-07-03 19:36:01 +08:00
|
|
|
smp_init_pseries_mpic();
|
|
|
|
return;
|
|
|
|
} else if (strstr(typep, "ppc-xicp")) {
|
2008-04-01 14:42:25 +08:00
|
|
|
ppc_md.init_IRQ = pseries_xics_init_IRQ;
|
2007-02-08 15:33:55 +08:00
|
|
|
setup_kexec_cpu_down_xics();
|
2006-07-03 19:36:01 +08:00
|
|
|
smp_init_pseries_xics();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printk(KERN_ERR "pSeries_discover_pic: failed to recognize"
|
|
|
|
" interrupt-controller\n");
|
|
|
|
}
|
|
|
|
|
2009-04-30 17:26:21 +08:00
|
|
|
static int pci_dn_reconfig_notifier(struct notifier_block *nb, unsigned long action, void *node)
|
|
|
|
{
|
|
|
|
struct device_node *np = node;
|
|
|
|
struct pci_dn *pci = NULL;
|
|
|
|
int err = NOTIFY_OK;
|
|
|
|
|
|
|
|
switch (action) {
|
2012-10-03 00:57:57 +08:00
|
|
|
case OF_RECONFIG_ATTACH_NODE:
|
2009-04-30 17:26:21 +08:00
|
|
|
pci = np->parent->data;
|
powerpc/eeh: Introduce EEH device
Original EEH implementation depends on struct pci_dn heavily. However,
EEH shouldn't depend on that actually because EEH needn't share much
information with other PCI components. That's to say, EEH should have
worked independently.
The patch introduces struct eeh_dev so that EEH core components needn't
be working based on struct pci_dn in future. Also, struct pci_dn, struct
eeh_dev instances are created in dynamic fasion and the binding with EEH
device, OF node, PCI device is implemented as well.
The EEH devices are created after PHBs are detected and initialized, but
PCI emunation hasn't started yet. Apart from that, PHB might be created
dynamically through DLPAR component and the EEH devices should be creatd
as well. Another case might be OF node is created dynamically by DR
(Dynamic Reconfiguration), which has been defined by PAPR. For those OF
nodes created by DR, EEH devices should be also created accordingly. The
binding between EEH device and OF node is done while the EEH device is
initially created.
The binding between EEH device and PCI device should be done after PCI
emunation is done. Besides, PCI hotplug also needs the binding so that
the EEH devices could be traced from the newly coming PCI buses or PCI
devices.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-02-28 04:04:04 +08:00
|
|
|
if (pci) {
|
2009-04-30 17:26:21 +08:00
|
|
|
update_dn_pci_info(np, pci->phb);
|
powerpc/eeh: Introduce EEH device
Original EEH implementation depends on struct pci_dn heavily. However,
EEH shouldn't depend on that actually because EEH needn't share much
information with other PCI components. That's to say, EEH should have
worked independently.
The patch introduces struct eeh_dev so that EEH core components needn't
be working based on struct pci_dn in future. Also, struct pci_dn, struct
eeh_dev instances are created in dynamic fasion and the binding with EEH
device, OF node, PCI device is implemented as well.
The EEH devices are created after PHBs are detected and initialized, but
PCI emunation hasn't started yet. Apart from that, PHB might be created
dynamically through DLPAR component and the EEH devices should be creatd
as well. Another case might be OF node is created dynamically by DR
(Dynamic Reconfiguration), which has been defined by PAPR. For those OF
nodes created by DR, EEH devices should be also created accordingly. The
binding between EEH device and OF node is done while the EEH device is
initially created.
The binding between EEH device and PCI device should be done after PCI
emunation is done. Besides, PCI hotplug also needs the binding so that
the EEH devices could be traced from the newly coming PCI buses or PCI
devices.
Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-02-28 04:04:04 +08:00
|
|
|
|
|
|
|
/* Create EEH device for the OF node */
|
|
|
|
eeh_dev_init(np, pci->phb);
|
|
|
|
}
|
2009-04-30 17:26:21 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = NOTIFY_DONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block pci_dn_reconfig_nb = {
|
|
|
|
.notifier_call = pci_dn_reconfig_notifier,
|
|
|
|
};
|
|
|
|
|
2011-05-04 20:54:16 +08:00
|
|
|
struct kmem_cache *dtl_cache;
|
|
|
|
|
2012-07-25 13:56:04 +08:00
|
|
|
#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
/*
|
|
|
|
* Allocate space for the dispatch trace log for all possible cpus
|
|
|
|
* and register the buffers with the hypervisor. This is used for
|
|
|
|
* computing time stolen by the hypervisor.
|
|
|
|
*/
|
|
|
|
static int alloc_dispatch_logs(void)
|
|
|
|
{
|
|
|
|
int cpu, ret;
|
|
|
|
struct paca_struct *pp;
|
|
|
|
struct dtl_entry *dtl;
|
|
|
|
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_SPLPAR))
|
|
|
|
return 0;
|
|
|
|
|
2011-05-04 20:54:16 +08:00
|
|
|
if (!dtl_cache)
|
2011-04-14 03:45:59 +08:00
|
|
|
return 0;
|
|
|
|
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
pp = &paca[cpu];
|
2011-04-14 03:45:59 +08:00
|
|
|
dtl = kmem_cache_alloc(dtl_cache, GFP_KERNEL);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
if (!dtl) {
|
|
|
|
pr_warn("Failed to allocate dispatch trace log for cpu %d\n",
|
|
|
|
cpu);
|
|
|
|
pr_warn("Stolen time statistics will be unreliable\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pp->dtl_ridx = 0;
|
|
|
|
pp->dispatch_log = dtl;
|
|
|
|
pp->dispatch_log_end = dtl + N_DISPATCH_LOG;
|
|
|
|
pp->dtl_curr = dtl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register the DTL for the current (boot) cpu */
|
|
|
|
dtl = get_paca()->dispatch_log;
|
|
|
|
get_paca()->dtl_ridx = 0;
|
|
|
|
get_paca()->dtl_curr = dtl;
|
|
|
|
get_paca()->lppaca_ptr->dtl_idx = 0;
|
|
|
|
|
|
|
|
/* hypervisor reads buffer length from this field */
|
2013-08-07 00:01:46 +08:00
|
|
|
dtl->enqueue_to_dispatch_time = cpu_to_be32(DISPATCH_LOG_BYTES);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
ret = register_dtl(hard_smp_processor_id(), __pa(dtl));
|
|
|
|
if (ret)
|
2011-07-25 09:46:33 +08:00
|
|
|
pr_err("WARNING: DTL registration of cpu %d (hw %d) failed "
|
|
|
|
"with %d\n", smp_processor_id(),
|
|
|
|
hard_smp_processor_id(), ret);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
get_paca()->lppaca_ptr->dtl_enable_mask = 2;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2012-07-25 13:56:04 +08:00
|
|
|
#else /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
|
2011-05-04 20:54:16 +08:00
|
|
|
static inline int alloc_dispatch_logs(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2012-07-25 13:56:04 +08:00
|
|
|
#endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-27 03:56:43 +08:00
|
|
|
|
2011-05-04 20:54:16 +08:00
|
|
|
static int alloc_dispatch_log_kmem_cache(void)
|
|
|
|
{
|
|
|
|
dtl_cache = kmem_cache_create("dtl", DISPATCH_LOG_BYTES,
|
|
|
|
DISPATCH_LOG_BYTES, 0, NULL);
|
|
|
|
if (!dtl_cache) {
|
|
|
|
pr_warn("Failed to create dispatch trace log buffer cache\n");
|
|
|
|
pr_warn("Stolen time statistics will be unreliable\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return alloc_dispatch_logs();
|
|
|
|
}
|
2014-07-16 10:02:43 +08:00
|
|
|
machine_early_initcall(pseries, alloc_dispatch_log_kmem_cache);
|
2011-05-04 20:54:16 +08:00
|
|
|
|
2013-09-06 02:55:06 +08:00
|
|
|
static void pseries_lpar_idle(void)
|
2011-11-30 10:46:55 +08:00
|
|
|
{
|
2014-01-30 01:45:10 +08:00
|
|
|
/*
|
|
|
|
* Default handler to go into low thread priority and possibly
|
|
|
|
* low power mode by cedeing processor to hypervisor
|
2011-11-30 10:46:55 +08:00
|
|
|
*/
|
2014-01-30 01:45:10 +08:00
|
|
|
|
|
|
|
/* Indicate to hypervisor that we are idle. */
|
|
|
|
get_lppaca()->idle = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Yield the processor to the hypervisor. We return if
|
|
|
|
* an external interrupt occurs (which are driven prior
|
|
|
|
* to returning here) or if a prod occurs from another
|
|
|
|
* processor. When returning here, external interrupts
|
|
|
|
* are enabled.
|
|
|
|
*/
|
|
|
|
cede_processor();
|
|
|
|
|
|
|
|
get_lppaca()->idle = 0;
|
2011-11-30 10:46:55 +08:00
|
|
|
}
|
|
|
|
|
2012-11-08 13:03:14 +08:00
|
|
|
/*
|
|
|
|
* Enable relocation on during exceptions. This has partition wide scope and
|
|
|
|
* may take a while to complete, if it takes longer than one second we will
|
|
|
|
* just give up rather than wasting any more time on this - if that turns out
|
|
|
|
* to ever be a problem in practice we can move this into a kernel thread to
|
|
|
|
* finish off the process later in boot.
|
|
|
|
*/
|
2012-12-04 02:36:13 +08:00
|
|
|
long pSeries_enable_reloc_on_exc(void)
|
2012-11-08 13:03:14 +08:00
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
unsigned int delay, total_delay = 0;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
rc = enable_reloc_on_exceptions();
|
|
|
|
if (!H_IS_LONG_BUSY(rc))
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
delay = get_longbusy_msecs(rc);
|
|
|
|
total_delay += delay;
|
|
|
|
if (total_delay > 1000) {
|
|
|
|
pr_warn("Warning: Giving up waiting to enable "
|
|
|
|
"relocation on exceptions (%u msec)!\n",
|
|
|
|
total_delay);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdelay(delay);
|
|
|
|
}
|
|
|
|
}
|
2012-12-04 02:36:13 +08:00
|
|
|
EXPORT_SYMBOL(pSeries_enable_reloc_on_exc);
|
2012-11-08 13:03:14 +08:00
|
|
|
|
2012-12-04 02:36:13 +08:00
|
|
|
long pSeries_disable_reloc_on_exc(void)
|
2012-11-08 13:40:28 +08:00
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
rc = disable_reloc_on_exceptions();
|
|
|
|
if (!H_IS_LONG_BUSY(rc))
|
|
|
|
return rc;
|
|
|
|
mdelay(get_longbusy_msecs(rc));
|
|
|
|
}
|
|
|
|
}
|
2012-12-04 02:36:13 +08:00
|
|
|
EXPORT_SYMBOL(pSeries_disable_reloc_on_exc);
|
2012-11-08 13:40:28 +08:00
|
|
|
|
2012-12-04 02:36:13 +08:00
|
|
|
#ifdef CONFIG_KEXEC
|
2012-11-08 13:40:28 +08:00
|
|
|
static void pSeries_machine_kexec(struct kimage *image)
|
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
|
2014-01-31 03:00:45 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_SET_MODE)) {
|
2012-11-08 13:40:28 +08:00
|
|
|
rc = pSeries_disable_reloc_on_exc();
|
|
|
|
if (rc != H_SUCCESS)
|
|
|
|
pr_warning("Warning: Failed to disable relocation on "
|
|
|
|
"exceptions: %ld\n", rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
default_machine_kexec(image);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-11-20 19:14:59 +08:00
|
|
|
#ifdef __LITTLE_ENDIAN__
|
|
|
|
long pseries_big_endian_exceptions(void)
|
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
rc = enable_big_endian_exceptions();
|
|
|
|
if (!H_IS_LONG_BUSY(rc))
|
|
|
|
return rc;
|
|
|
|
mdelay(get_longbusy_msecs(rc));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static long pseries_little_endian_exceptions(void)
|
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
rc = enable_little_endian_exceptions();
|
|
|
|
if (!H_IS_LONG_BUSY(rc))
|
|
|
|
return rc;
|
|
|
|
mdelay(get_longbusy_msecs(rc));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void __init pSeries_setup_arch(void)
|
|
|
|
{
|
2013-11-26 07:23:11 +08:00
|
|
|
set_arch_panic_timeout(10, ARCH_PANIC_TIMEOUT);
|
2011-11-30 08:23:14 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* Discover PIC type and setup ppc_md accordingly */
|
|
|
|
pseries_discover_pic();
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* openpic global configuration register (64-bit format). */
|
|
|
|
/* openpic Interrupt Source Unit pointer (64-bit format). */
|
|
|
|
/* python0 facility area (mmio) (64-bit format) REAL address. */
|
|
|
|
|
|
|
|
/* init to some ~sane value until calibrate_delay() runs */
|
|
|
|
loops_per_jiffy = 50000000;
|
|
|
|
|
|
|
|
fwnmi_init();
|
|
|
|
|
2012-02-24 11:18:58 +08:00
|
|
|
/* By default, only probe PCI (can be overriden by rtas_pci) */
|
|
|
|
pci_add_flags(PCI_PROBE_ONLY);
|
2012-02-24 11:18:58 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Find and initialize PCI host bridges */
|
|
|
|
init_pci_config_tokens();
|
|
|
|
find_and_init_phbs();
|
2012-10-03 00:57:57 +08:00
|
|
|
of_reconfig_notifier_register(&pci_dn_reconfig_nb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
pSeries_nvram_init();
|
|
|
|
|
2013-09-06 02:55:06 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR)) {
|
2005-08-03 12:40:16 +08:00
|
|
|
vpa_init(boot_cpuid);
|
2013-09-06 02:55:06 +08:00
|
|
|
ppc_md.power_save = pseries_lpar_idle;
|
2005-08-09 09:13:36 +08:00
|
|
|
ppc_md.enable_pmcs = pseries_lpar_enable_pmcs;
|
2013-09-06 02:55:06 +08:00
|
|
|
} else {
|
|
|
|
/* No special idle routine */
|
2005-08-09 09:13:36 +08:00
|
|
|
ppc_md.enable_pmcs = power4_enable_pmcs;
|
2013-09-06 02:55:06 +08:00
|
|
|
}
|
2012-11-08 13:03:14 +08:00
|
|
|
|
2013-05-03 20:43:12 +08:00
|
|
|
ppc_md.pcibios_root_bridge_prepare = pseries_root_bridge_prepare;
|
|
|
|
|
2012-11-08 13:03:14 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_SET_MODE)) {
|
|
|
|
long rc;
|
|
|
|
if ((rc = pSeries_enable_reloc_on_exc()) != H_SUCCESS) {
|
|
|
|
pr_warn("Unable to enable relocation on exceptions: "
|
|
|
|
"%ld\n", rc);
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init pSeries_init_panel(void)
|
|
|
|
{
|
|
|
|
/* Manually leave the kernel version on the panel. */
|
2014-03-12 16:17:07 +08:00
|
|
|
#ifdef __BIG_ENDIAN__
|
2005-04-17 06:20:36 +08:00
|
|
|
ppc_md.progress("Linux ppc64\n", 0);
|
2014-03-12 16:17:07 +08:00
|
|
|
#else
|
|
|
|
ppc_md.progress("Linux ppc64le\n", 0);
|
|
|
|
#endif
|
2006-10-02 17:18:13 +08:00
|
|
|
ppc_md.progress(init_utsname()->version, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-04-01 02:49:45 +08:00
|
|
|
machine_arch_initcall(pseries, pSeries_init_panel);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-09-07 05:24:56 +08:00
|
|
|
static int pseries_set_dabr(unsigned long dabr, unsigned long dabrx)
|
2005-11-03 12:30:49 +08:00
|
|
|
{
|
2005-11-07 10:12:03 +08:00
|
|
|
return plpar_hcall_norets(H_SET_DABR, dabr);
|
2005-11-03 12:30:49 +08:00
|
|
|
}
|
|
|
|
|
2012-09-07 05:24:56 +08:00
|
|
|
static int pseries_set_xdabr(unsigned long dabr, unsigned long dabrx)
|
2005-11-07 10:12:03 +08:00
|
|
|
{
|
2012-09-07 05:24:56 +08:00
|
|
|
/* Have to set at least one bit in the DABRX according to PAPR */
|
|
|
|
if (dabrx == 0 && dabr == 0)
|
|
|
|
dabrx = DABRX_USER;
|
|
|
|
/* PAPR says we can only set kernel and user bits */
|
2012-09-07 05:24:57 +08:00
|
|
|
dabrx &= DABRX_KERNEL | DABRX_USER;
|
2012-09-07 05:24:56 +08:00
|
|
|
|
|
|
|
return plpar_hcall_norets(H_SET_XDABR, dabr, dabrx);
|
2005-11-07 10:12:03 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-20 22:06:45 +08:00
|
|
|
static int pseries_set_dawr(unsigned long dawr, unsigned long dawrx)
|
|
|
|
{
|
|
|
|
/* PAPR says we can't set HYP */
|
|
|
|
dawrx &= ~DAWRX_HYP;
|
|
|
|
|
|
|
|
return plapr_set_watchpoint0(dawr, dawrx);
|
|
|
|
}
|
|
|
|
|
2008-07-24 02:29:03 +08:00
|
|
|
#define CMO_CHARACTERISTICS_TOKEN 44
|
|
|
|
#define CMO_MAXLENGTH 1026
|
|
|
|
|
2011-05-04 14:01:20 +08:00
|
|
|
void pSeries_coalesce_init(void)
|
|
|
|
{
|
|
|
|
struct hvcall_mpp_x_data mpp_x_data;
|
|
|
|
|
|
|
|
if (firmware_has_feature(FW_FEATURE_CMO) && !h_get_mpp_x(&mpp_x_data))
|
|
|
|
powerpc_firmware_features |= FW_FEATURE_XCMO;
|
|
|
|
else
|
|
|
|
powerpc_firmware_features &= ~FW_FEATURE_XCMO;
|
|
|
|
}
|
|
|
|
|
2008-07-24 02:29:03 +08:00
|
|
|
/**
|
|
|
|
* fw_cmo_feature_init - FW_FEATURE_CMO is not stored in ibm,hypertas-functions,
|
|
|
|
* handle that here. (Stolen from parse_system_parameter_string)
|
|
|
|
*/
|
2014-08-20 06:55:18 +08:00
|
|
|
static void pSeries_cmo_feature_init(void)
|
2008-07-24 02:29:03 +08:00
|
|
|
{
|
|
|
|
char *ptr, *key, *value, *end;
|
|
|
|
int call_status;
|
2013-12-09 15:17:01 +08:00
|
|
|
int page_order = IOMMU_PAGE_SHIFT_4K;
|
2008-07-24 02:29:03 +08:00
|
|
|
|
|
|
|
pr_debug(" -> fw_cmo_feature_init()\n");
|
|
|
|
spin_lock(&rtas_data_buf_lock);
|
|
|
|
memset(rtas_data_buf, 0, RTAS_DATA_BUF_SIZE);
|
|
|
|
call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
|
|
|
|
NULL,
|
|
|
|
CMO_CHARACTERISTICS_TOKEN,
|
|
|
|
__pa(rtas_data_buf),
|
|
|
|
RTAS_DATA_BUF_SIZE);
|
|
|
|
|
|
|
|
if (call_status != 0) {
|
|
|
|
spin_unlock(&rtas_data_buf_lock);
|
|
|
|
pr_debug("CMO not available\n");
|
|
|
|
pr_debug(" <- fw_cmo_feature_init()\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
end = rtas_data_buf + CMO_MAXLENGTH - 2;
|
|
|
|
ptr = rtas_data_buf + 2; /* step over strlen value */
|
|
|
|
key = value = ptr;
|
|
|
|
|
|
|
|
while (*ptr && (ptr <= end)) {
|
|
|
|
/* Separate the key and value by replacing '=' with '\0' and
|
|
|
|
* point the value at the string after the '='
|
|
|
|
*/
|
|
|
|
if (ptr[0] == '=') {
|
|
|
|
ptr[0] = '\0';
|
|
|
|
value = ptr + 1;
|
|
|
|
} else if (ptr[0] == '\0' || ptr[0] == ',') {
|
|
|
|
/* Terminate the string containing the key/value pair */
|
|
|
|
ptr[0] = '\0';
|
|
|
|
|
|
|
|
if (key == value) {
|
|
|
|
pr_debug("Malformed key/value pair\n");
|
|
|
|
/* Never found a '=', end processing */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-08-16 03:07:31 +08:00
|
|
|
if (0 == strcmp(key, "CMOPageSize"))
|
|
|
|
page_order = simple_strtol(value, NULL, 10);
|
|
|
|
else if (0 == strcmp(key, "PrPSP"))
|
|
|
|
CMO_PrPSP = simple_strtol(value, NULL, 10);
|
2008-07-24 02:29:03 +08:00
|
|
|
else if (0 == strcmp(key, "SecPSP"))
|
2008-08-16 03:07:31 +08:00
|
|
|
CMO_SecPSP = simple_strtol(value, NULL, 10);
|
2008-07-24 02:29:03 +08:00
|
|
|
value = key = ptr + 1;
|
|
|
|
}
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
|
2008-08-16 03:07:31 +08:00
|
|
|
/* Page size is returned as the power of 2 of the page size,
|
|
|
|
* convert to the page size in bytes before returning
|
|
|
|
*/
|
|
|
|
CMO_PageSize = 1 << page_order;
|
|
|
|
pr_debug("CMO_PageSize = %lu\n", CMO_PageSize);
|
|
|
|
|
|
|
|
if (CMO_PrPSP != -1 || CMO_SecPSP != -1) {
|
2008-07-24 02:29:03 +08:00
|
|
|
pr_info("CMO enabled\n");
|
2008-08-16 03:07:31 +08:00
|
|
|
pr_debug("CMO enabled, PrPSP=%d, SecPSP=%d\n", CMO_PrPSP,
|
|
|
|
CMO_SecPSP);
|
2008-07-24 02:29:03 +08:00
|
|
|
powerpc_firmware_features |= FW_FEATURE_CMO;
|
2011-05-04 14:01:20 +08:00
|
|
|
pSeries_coalesce_init();
|
2008-07-24 02:29:03 +08:00
|
|
|
} else
|
2008-08-16 03:07:31 +08:00
|
|
|
pr_debug("CMO not enabled, PrPSP=%d, SecPSP=%d\n", CMO_PrPSP,
|
|
|
|
CMO_SecPSP);
|
2008-07-24 02:29:03 +08:00
|
|
|
spin_unlock(&rtas_data_buf_lock);
|
|
|
|
pr_debug(" <- fw_cmo_feature_init()\n");
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Early initialization. Relocation is on but do not reference unbolted pages
|
|
|
|
*/
|
|
|
|
static void __init pSeries_init_early(void)
|
|
|
|
{
|
2008-04-24 13:13:19 +08:00
|
|
|
pr_debug(" -> pSeries_init_early()\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
powerpc/pseries: Re-implement HVSI as part of hvc_vio
On pseries machines, consoles are provided by the hypervisor using
a low level get_chars/put_chars type interface. However, this is
really just a transport to the service processor which implements
them either as "raw" console (networked consoles, HMC, ...) or as
"hvsi" serial ports.
The later is a simple packet protocol on top of the raw character
interface that is supposed to convey additional "serial port" style
semantics. In practice however, all it does is provide a way to
read the CD line and set/clear our DTR line, that's it.
We currently implement the "raw" protocol as an hvc console backend
(/dev/hvcN) and the "hvsi" protocol using a separate tty driver
(/dev/hvsi0).
However this is quite impractical. The arbitrary difference between
the two type of devices has been a major source of user (and distro)
confusion. Additionally, there's an additional mini -hvsi implementation
in the pseries platform code for our low level debug console and early
boot kernel messages, which means code duplication, though that low
level variant is impractical as it's incapable of doing the initial
protocol negociation to establish the link to the FSP.
This essentially replaces the dedicated hvsi driver and the platform
udbg code completely by extending the existing hvc_vio backend used
in "raw" mode so that:
- It now supports HVSI as well
- We add support for hvc backend providing tiocm{get,set}
- It also provides a udbg interface for early debug and boot console
This is overall less code, though this will only be obvious once we
remove the old "hvsi" driver, which is still available for now. When
the old driver is enabled, the new code still kicks in for the low
level udbg console, replacing the old mini implementation in the platform
code, it just doesn't provide the higher level "hvc" interface.
In addition to producing generally simler code, this has several benefits
over our current situation:
- The user/distro only has to deal with /dev/hvcN for the hypervisor
console, avoiding all sort of confusion that has plagued us in the past
- The tty, kernel and low level debug console all use the same code
base which supports the full protocol establishment process, thus the
console is now available much earlier than it used to be with the
old HVSI driver. The kernel console works much earlier and udbg is
available much earlier too. Hackers can enable a hard coded very-early
debug console as well that works with HVSI (previously that was only
supported for the "raw" mode).
I've tried to keep the same semantics as hvsi relative to how I react
to things like CD changes, with some subtle differences though:
- I clear DTR on close if HUPCL is set
- Current hvsi triggers a hangup if it detects a up->down transition
on CD (you can still open a console with CD down). My new implementation
triggers a hangup if the link to the FSP is severed, and severs it upon
detecting a up->down transition on CD.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2011-05-12 11:46:38 +08:00
|
|
|
#ifdef CONFIG_HVC_CONSOLE
|
2006-03-21 17:45:59 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
powerpc/pseries: Re-implement HVSI as part of hvc_vio
On pseries machines, consoles are provided by the hypervisor using
a low level get_chars/put_chars type interface. However, this is
really just a transport to the service processor which implements
them either as "raw" console (networked consoles, HMC, ...) or as
"hvsi" serial ports.
The later is a simple packet protocol on top of the raw character
interface that is supposed to convey additional "serial port" style
semantics. In practice however, all it does is provide a way to
read the CD line and set/clear our DTR line, that's it.
We currently implement the "raw" protocol as an hvc console backend
(/dev/hvcN) and the "hvsi" protocol using a separate tty driver
(/dev/hvsi0).
However this is quite impractical. The arbitrary difference between
the two type of devices has been a major source of user (and distro)
confusion. Additionally, there's an additional mini -hvsi implementation
in the pseries platform code for our low level debug console and early
boot kernel messages, which means code duplication, though that low
level variant is impractical as it's incapable of doing the initial
protocol negociation to establish the link to the FSP.
This essentially replaces the dedicated hvsi driver and the platform
udbg code completely by extending the existing hvc_vio backend used
in "raw" mode so that:
- It now supports HVSI as well
- We add support for hvc backend providing tiocm{get,set}
- It also provides a udbg interface for early debug and boot console
This is overall less code, though this will only be obvious once we
remove the old "hvsi" driver, which is still available for now. When
the old driver is enabled, the new code still kicks in for the low
level udbg console, replacing the old mini implementation in the platform
code, it just doesn't provide the higher level "hvc" interface.
In addition to producing generally simler code, this has several benefits
over our current situation:
- The user/distro only has to deal with /dev/hvcN for the hypervisor
console, avoiding all sort of confusion that has plagued us in the past
- The tty, kernel and low level debug console all use the same code
base which supports the full protocol establishment process, thus the
console is now available much earlier than it used to be with the
old HVSI driver. The kernel console works much earlier and udbg is
available much earlier too. Hackers can enable a hard coded very-early
debug console as well that works with HVSI (previously that was only
supported for the "raw" mode).
I've tried to keep the same semantics as hvsi relative to how I react
to things like CD changes, with some subtle differences though:
- I clear DTR on close if HUPCL is set
- Current hvsi triggers a hangup if it detects a up->down transition
on CD (you can still open a console with CD down). My new implementation
triggers a hangup if the link to the FSP is severed, and severs it upon
detecting a up->down transition on CD.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2011-05-12 11:46:38 +08:00
|
|
|
hvc_vio_init_early();
|
|
|
|
#endif
|
2012-09-06 03:17:49 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_XDABR))
|
2005-11-07 10:12:03 +08:00
|
|
|
ppc_md.set_dabr = pseries_set_xdabr;
|
2012-09-06 03:17:49 +08:00
|
|
|
else if (firmware_has_feature(FW_FEATURE_DABR))
|
|
|
|
ppc_md.set_dabr = pseries_set_dabr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-20 22:06:45 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_SET_MODE))
|
|
|
|
ppc_md.set_dawr = pseries_set_dawr;
|
|
|
|
|
2008-07-24 02:29:03 +08:00
|
|
|
pSeries_cmo_feature_init();
|
2005-04-17 06:20:36 +08:00
|
|
|
iommu_init_early_pSeries();
|
|
|
|
|
2008-04-24 13:13:19 +08:00
|
|
|
pr_debug(" <- pSeries_init_early()\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2014-10-13 22:01:09 +08:00
|
|
|
/**
|
|
|
|
* pseries_power_off - tell firmware about how to power off the system.
|
|
|
|
*
|
|
|
|
* This function calls either the power-off rtas token in normal cases
|
|
|
|
* or the ibm,power-off-ups token (if present & requested) in case of
|
|
|
|
* a power failure. If power-off token is used, power on will only be
|
|
|
|
* possible with power button press. If ibm,power-off-ups token is used
|
|
|
|
* it will allow auto poweron after power is restored.
|
|
|
|
*/
|
|
|
|
static void pseries_power_off(void)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
int rtas_poweroff_ups_token = rtas_token("ibm,power-off-ups");
|
|
|
|
|
|
|
|
if (rtas_flash_term_hook)
|
|
|
|
rtas_flash_term_hook(SYS_POWER_OFF);
|
|
|
|
|
|
|
|
if (rtas_poweron_auto == 0 ||
|
|
|
|
rtas_poweroff_ups_token == RTAS_UNKNOWN_SERVICE) {
|
|
|
|
rc = rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1);
|
|
|
|
printk(KERN_INFO "RTAS power-off returned %d\n", rc);
|
|
|
|
} else {
|
|
|
|
rc = rtas_call(rtas_poweroff_ups_token, 0, 1, NULL);
|
|
|
|
printk(KERN_INFO "RTAS ibm,power-off-ups returned %d\n", rc);
|
|
|
|
}
|
|
|
|
for (;;);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Called very early, MMU is off, device-tree isn't unflattened
|
|
|
|
*/
|
|
|
|
|
2013-04-24 13:57:18 +08:00
|
|
|
static int __init pseries_probe_fw_features(unsigned long node,
|
|
|
|
const char *uname, int depth,
|
|
|
|
void *data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-04-24 13:57:18 +08:00
|
|
|
const char *prop;
|
2014-04-02 12:49:03 +08:00
|
|
|
int len;
|
2013-04-24 13:57:18 +08:00
|
|
|
static int hypertas_found;
|
|
|
|
static int vec5_found;
|
2007-07-19 05:56:32 +08:00
|
|
|
|
2013-04-24 13:57:18 +08:00
|
|
|
if (depth != 1)
|
2007-07-19 05:56:32 +08:00
|
|
|
return 0;
|
|
|
|
|
2013-04-24 13:57:18 +08:00
|
|
|
if (!strcmp(uname, "rtas") || !strcmp(uname, "rtas@0")) {
|
|
|
|
prop = of_get_flat_dt_prop(node, "ibm,hypertas-functions",
|
|
|
|
&len);
|
|
|
|
if (prop) {
|
|
|
|
powerpc_firmware_features |= FW_FEATURE_LPAR;
|
|
|
|
fw_hypertas_feature_init(prop, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
hypertas_found = 1;
|
|
|
|
}
|
2006-03-28 20:15:54 +08:00
|
|
|
|
2013-04-24 13:57:18 +08:00
|
|
|
if (!strcmp(uname, "chosen")) {
|
|
|
|
prop = of_get_flat_dt_prop(node, "ibm,architecture-vec-5",
|
|
|
|
&len);
|
|
|
|
if (prop)
|
|
|
|
fw_vec5_feature_init(prop, len);
|
|
|
|
|
|
|
|
vec5_found = 1;
|
|
|
|
}
|
2006-03-28 20:15:54 +08:00
|
|
|
|
2013-04-24 13:57:18 +08:00
|
|
|
return hypertas_found && vec5_found;
|
2006-03-28 20:15:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init pSeries_probe(void)
|
|
|
|
{
|
2006-06-07 10:04:18 +08:00
|
|
|
unsigned long root = of_get_flat_dt_root();
|
2014-04-02 12:49:03 +08:00
|
|
|
const char *dtype = of_get_flat_dt_prop(root, "device_type", NULL);
|
2006-12-08 15:08:37 +08:00
|
|
|
|
2006-03-28 20:15:54 +08:00
|
|
|
if (dtype == NULL)
|
|
|
|
return 0;
|
|
|
|
if (strcmp(dtype, "chrp"))
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
2006-06-07 10:04:18 +08:00
|
|
|
/* Cell blades firmware claims to be chrp while it's not. Until this
|
|
|
|
* is fixed, we need to avoid those here.
|
|
|
|
*/
|
|
|
|
if (of_flat_dt_is_compatible(root, "IBM,CPBW-1.0") ||
|
|
|
|
of_flat_dt_is_compatible(root, "IBM,CBEA"))
|
|
|
|
return 0;
|
|
|
|
|
2008-04-24 13:13:19 +08:00
|
|
|
pr_debug("pSeries detected, looking for LPAR capability...\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-28 20:15:54 +08:00
|
|
|
/* Now try to figure out if we are running on LPAR */
|
2013-04-24 13:57:18 +08:00
|
|
|
of_scan_flat_dt(pseries_probe_fw_features, NULL);
|
2006-03-28 20:15:54 +08:00
|
|
|
|
2013-11-20 19:14:59 +08:00
|
|
|
#ifdef __LITTLE_ENDIAN__
|
|
|
|
if (firmware_has_feature(FW_FEATURE_SET_MODE)) {
|
|
|
|
long rc;
|
|
|
|
/*
|
|
|
|
* Tell the hypervisor that we want our exceptions to
|
|
|
|
* be taken in little endian mode. If this fails we don't
|
|
|
|
* want to use BUG() because it will trigger an exception.
|
|
|
|
*/
|
|
|
|
rc = pseries_little_endian_exceptions();
|
|
|
|
if (rc) {
|
|
|
|
ppc_md.progress("H_SET_MODE LE exception fail", 0);
|
|
|
|
panic("Could not enable little endian exceptions");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-12-08 15:22:09 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
hpte_init_lpar();
|
|
|
|
else
|
|
|
|
hpte_init_native();
|
|
|
|
|
2014-10-13 22:01:09 +08:00
|
|
|
pm_power_off = pseries_power_off;
|
|
|
|
|
2008-04-24 13:13:19 +08:00
|
|
|
pr_debug("Machine is%s LPAR !\n",
|
|
|
|
(powerpc_firmware_features & FW_FEATURE_LPAR) ? "" : " not");
|
2006-03-21 17:45:59 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
ppc64: Set up PCI tree from Open Firmware device tree
This adds code which gives us the option on ppc64 of instantiating the
PCI tree (the tree of pci_bus and pci_dev structs) from the Open
Firmware device tree rather than by probing PCI configuration space.
The OF device tree has a node for each PCI device and bridge in the
system, with properties that tell us what addresses the firmware has
configured for them and other details.
There are a couple of reasons why this is needed. First, on systems
with a hypervisor, there is a PCI-PCI bridge per slot under the PCI
host bridges. These PCI-PCI bridges have special isolation features
for virtualization. We can't write to their config space, and we are
not supposed to be reading their config space either. The firmware
tells us about the address ranges that they pass in the OF device
tree.
Secondly, on powermacs, the interrupt controller is in a PCI device
that may be behind a PCI-PCI bridge. If we happened to take an
interrupt just at the point when the device or a bridge on the path to
it was disabled for probing, we would crash when we try to access the
interrupt controller.
I have implemented a platform-specific function which is called for
each PCI bridge (host or PCI-PCI) to say whether the code should look
in the device tree or use normal PCI probing for the devices under
that bridge. On pSeries machines we use the device tree if we're
running under a hypervisor, otherwise we use normal probing. On
powermacs we use normal probing for the AGP bridge, since the device
for the AGP bridge itself isn't shown in the device tree (at least on
my G5), and the device tree for everything else.
This has been tested on a dual G5 powermac, a partition on a POWER5
machine (running under the hypervisor), and a legacy iSeries
partition.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-09-12 15:17:36 +08:00
|
|
|
static int pSeries_pci_probe_mode(struct pci_bus *bus)
|
|
|
|
{
|
2006-03-21 17:45:59 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
ppc64: Set up PCI tree from Open Firmware device tree
This adds code which gives us the option on ppc64 of instantiating the
PCI tree (the tree of pci_bus and pci_dev structs) from the Open
Firmware device tree rather than by probing PCI configuration space.
The OF device tree has a node for each PCI device and bridge in the
system, with properties that tell us what addresses the firmware has
configured for them and other details.
There are a couple of reasons why this is needed. First, on systems
with a hypervisor, there is a PCI-PCI bridge per slot under the PCI
host bridges. These PCI-PCI bridges have special isolation features
for virtualization. We can't write to their config space, and we are
not supposed to be reading their config space either. The firmware
tells us about the address ranges that they pass in the OF device
tree.
Secondly, on powermacs, the interrupt controller is in a PCI device
that may be behind a PCI-PCI bridge. If we happened to take an
interrupt just at the point when the device or a bridge on the path to
it was disabled for probing, we would crash when we try to access the
interrupt controller.
I have implemented a platform-specific function which is called for
each PCI bridge (host or PCI-PCI) to say whether the code should look
in the device tree or use normal PCI probing for the devices under
that bridge. On pSeries machines we use the device tree if we're
running under a hypervisor, otherwise we use normal probing. On
powermacs we use normal probing for the AGP bridge, since the device
for the AGP bridge itself isn't shown in the device tree (at least on
my G5), and the device tree for everything else.
This has been tested on a dual G5 powermac, a partition on a POWER5
machine (running under the hypervisor), and a legacy iSeries
partition.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-09-12 15:17:36 +08:00
|
|
|
return PCI_PROBE_DEVTREE;
|
|
|
|
return PCI_PROBE_NORMAL;
|
|
|
|
}
|
|
|
|
|
2007-03-04 14:04:44 +08:00
|
|
|
#ifndef CONFIG_PCI
|
|
|
|
void pSeries_final_fixup(void) { }
|
|
|
|
#endif
|
|
|
|
|
2006-03-28 20:15:54 +08:00
|
|
|
define_machine(pseries) {
|
|
|
|
.name = "pSeries",
|
2005-04-17 06:20:36 +08:00
|
|
|
.probe = pSeries_probe,
|
|
|
|
.setup_arch = pSeries_setup_arch,
|
|
|
|
.init_early = pSeries_init_early,
|
2005-10-20 18:48:19 +08:00
|
|
|
.show_cpuinfo = pSeries_show_cpuinfo,
|
2005-04-17 06:20:36 +08:00
|
|
|
.log_error = pSeries_log_error,
|
|
|
|
.pcibios_fixup = pSeries_final_fixup,
|
ppc64: Set up PCI tree from Open Firmware device tree
This adds code which gives us the option on ppc64 of instantiating the
PCI tree (the tree of pci_bus and pci_dev structs) from the Open
Firmware device tree rather than by probing PCI configuration space.
The OF device tree has a node for each PCI device and bridge in the
system, with properties that tell us what addresses the firmware has
configured for them and other details.
There are a couple of reasons why this is needed. First, on systems
with a hypervisor, there is a PCI-PCI bridge per slot under the PCI
host bridges. These PCI-PCI bridges have special isolation features
for virtualization. We can't write to their config space, and we are
not supposed to be reading their config space either. The firmware
tells us about the address ranges that they pass in the OF device
tree.
Secondly, on powermacs, the interrupt controller is in a PCI device
that may be behind a PCI-PCI bridge. If we happened to take an
interrupt just at the point when the device or a bridge on the path to
it was disabled for probing, we would crash when we try to access the
interrupt controller.
I have implemented a platform-specific function which is called for
each PCI bridge (host or PCI-PCI) to say whether the code should look
in the device tree or use normal PCI probing for the devices under
that bridge. On pSeries machines we use the device tree if we're
running under a hypervisor, otherwise we use normal probing. On
powermacs we use normal probing for the AGP bridge, since the device
for the AGP bridge itself isn't shown in the device tree (at least on
my G5), and the device tree for everything else.
This has been tested on a dual G5 powermac, a partition on a POWER5
machine (running under the hypervisor), and a legacy iSeries
partition.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-09-12 15:17:36 +08:00
|
|
|
.pci_probe_mode = pSeries_pci_probe_mode,
|
2005-11-03 11:41:19 +08:00
|
|
|
.restart = rtas_restart,
|
|
|
|
.halt = rtas_halt,
|
2007-12-03 06:30:04 +08:00
|
|
|
.panic = rtas_os_term,
|
2005-06-23 07:43:18 +08:00
|
|
|
.get_boot_time = rtas_get_boot_time,
|
|
|
|
.get_rtc_time = rtas_get_rtc_time,
|
|
|
|
.set_rtc_time = rtas_set_rtc_time,
|
2005-06-23 07:43:07 +08:00
|
|
|
.calibrate_decr = generic_calibrate_decr,
|
2005-06-23 07:43:28 +08:00
|
|
|
.progress = rtas_progress,
|
2005-04-17 06:20:36 +08:00
|
|
|
.system_reset_exception = pSeries_system_reset_exception,
|
|
|
|
.machine_check_exception = pSeries_machine_check_exception,
|
2012-11-08 13:40:28 +08:00
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
.machine_kexec = pSeries_machine_kexec,
|
|
|
|
#endif
|
2014-06-04 15:50:47 +08:00
|
|
|
#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
|
|
|
|
.memory_block_size = pseries_memory_block_size,
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|