2019-05-27 13:55:01 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2006-04-03 05:42:40 +07:00
|
|
|
/*
|
|
|
|
* MPC85xx setup and early boot code plus other random bits.
|
|
|
|
*
|
|
|
|
* Maintained by Kumar Gala (see MAINTAINERS for contact information)
|
|
|
|
*
|
2012-03-14 17:15:27 +07:00
|
|
|
* Copyright 2005, 2011-2012 Freescale Semiconductor Inc.
|
2006-04-03 05:42:40 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/kdev_t.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/initrd.h>
|
2007-06-07 06:26:15 +07:00
|
|
|
#include <linux/interrupt.h>
|
2006-04-03 05:42:40 +07:00
|
|
|
#include <linux/fsl_devices.h>
|
2008-06-17 05:36:17 +07:00
|
|
|
#include <linux/of_platform.h>
|
2006-04-03 05:42:40 +07:00
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/page.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2006-04-03 05:42:40 +07:00
|
|
|
#include <asm/time.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/ipic.h>
|
|
|
|
#include <asm/pci-bridge.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <mm/mmu_decl.h>
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/udbg.h>
|
|
|
|
#include <asm/mpic.h>
|
|
|
|
#include <asm/i8259.h>
|
|
|
|
|
|
|
|
#include <sysdev/fsl_soc.h>
|
2007-07-10 17:47:06 +07:00
|
|
|
#include <sysdev/fsl_pci.h>
|
2006-04-03 05:42:40 +07:00
|
|
|
|
2011-11-18 00:56:16 +07:00
|
|
|
#include "mpc85xx.h"
|
|
|
|
|
2012-03-06 16:06:42 +07:00
|
|
|
/*
|
|
|
|
* The CDS board contains an FPGA/CPLD called "Cadmus", which collects
|
|
|
|
* various logic and performs system control functions.
|
|
|
|
* Here is the FPGA/CPLD register map.
|
|
|
|
*/
|
|
|
|
struct cadmus_reg {
|
|
|
|
u8 cm_ver; /* Board version */
|
|
|
|
u8 cm_csr; /* General control/status */
|
|
|
|
u8 cm_rst; /* Reset control */
|
|
|
|
u8 cm_hsclk; /* High speed clock */
|
|
|
|
u8 cm_hsxclk; /* High speed clock extended */
|
|
|
|
u8 cm_led; /* LED data */
|
|
|
|
u8 cm_pci; /* PCI control/status */
|
|
|
|
u8 cm_dma; /* DMA control */
|
|
|
|
u8 res[248]; /* Total 256 bytes */
|
|
|
|
};
|
2007-10-11 21:13:41 +07:00
|
|
|
|
2012-03-06 16:06:42 +07:00
|
|
|
static struct cadmus_reg *cadmus;
|
2006-04-03 05:42:40 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
|
|
|
|
#define ARCADIA_HOST_BRIDGE_IDSEL 17
|
|
|
|
#define ARCADIA_2ND_BRIDGE_IDSEL 3
|
|
|
|
|
2007-06-22 12:23:57 +07:00
|
|
|
static int mpc85xx_exclude_device(struct pci_controller *hose,
|
|
|
|
u_char bus, u_char devfn)
|
2006-04-03 05:42:40 +07:00
|
|
|
{
|
|
|
|
/* We explicitly do not go past the Tundra 320 Bridge */
|
|
|
|
if ((bus == 1) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
|
|
|
|
return PCIBIOS_DEVICE_NOT_FOUND;
|
|
|
|
if ((bus == 0) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
|
|
|
|
return PCIBIOS_DEVICE_NOT_FOUND;
|
|
|
|
else
|
|
|
|
return PCIBIOS_SUCCESSFUL;
|
|
|
|
}
|
|
|
|
|
2016-07-29 06:07:18 +07:00
|
|
|
static int mpc85xx_cds_restart(struct notifier_block *this,
|
|
|
|
unsigned long mode, void *cmd)
|
2007-03-24 05:43:37 +07:00
|
|
|
{
|
|
|
|
struct pci_dev *dev;
|
|
|
|
u_char tmp;
|
|
|
|
|
|
|
|
if ((dev = pci_get_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686,
|
|
|
|
NULL))) {
|
|
|
|
|
|
|
|
/* Use the VIA Super Southbridge to force a PCI reset */
|
|
|
|
pci_read_config_byte(dev, 0x47, &tmp);
|
|
|
|
pci_write_config_byte(dev, 0x47, tmp | 1);
|
|
|
|
|
|
|
|
/* Flush the outbound PCI write queues */
|
|
|
|
pci_read_config_byte(dev, 0x47, &tmp);
|
|
|
|
|
|
|
|
/*
|
2016-02-25 01:51:11 +07:00
|
|
|
* At this point, the hardware reset should have triggered.
|
2007-03-24 05:43:37 +07:00
|
|
|
* However, if it doesn't work for some mysterious reason,
|
|
|
|
* just fall through to the default reset below.
|
|
|
|
*/
|
|
|
|
|
|
|
|
pci_dev_put(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-07-29 06:07:18 +07:00
|
|
|
* If we can't find the VIA chip (maybe the P2P bridge is
|
|
|
|
* disabled) or the VIA chip reset didn't work, just return
|
|
|
|
* and let default reset sequence happen.
|
2007-03-24 05:43:37 +07:00
|
|
|
*/
|
2016-07-29 06:07:18 +07:00
|
|
|
return NOTIFY_DONE;
|
2007-03-24 05:43:37 +07:00
|
|
|
}
|
|
|
|
|
2016-07-29 06:07:18 +07:00
|
|
|
static int mpc85xx_cds_restart_register(void)
|
|
|
|
{
|
|
|
|
static struct notifier_block restart_handler;
|
|
|
|
|
|
|
|
restart_handler.notifier_call = mpc85xx_cds_restart;
|
|
|
|
restart_handler.priority = 192;
|
|
|
|
|
|
|
|
return register_restart_handler(&restart_handler);
|
|
|
|
}
|
|
|
|
machine_arch_initcall(mpc85xx_cds, mpc85xx_cds_restart_register);
|
|
|
|
|
|
|
|
|
2007-06-01 15:05:38 +07:00
|
|
|
static void __init mpc85xx_cds_pci_irq_fixup(struct pci_dev *dev)
|
2006-04-03 05:42:40 +07:00
|
|
|
{
|
2007-06-01 15:05:38 +07:00
|
|
|
u_char c;
|
|
|
|
if (dev->vendor == PCI_VENDOR_ID_VIA) {
|
|
|
|
switch (dev->device) {
|
|
|
|
case PCI_DEVICE_ID_VIA_82C586_1:
|
|
|
|
/*
|
|
|
|
* U-Boot does not set the enable bits
|
|
|
|
* for the IDE device. Force them on here.
|
|
|
|
*/
|
|
|
|
pci_read_config_byte(dev, 0x40, &c);
|
|
|
|
c |= 0x03; /* IDE: Chip Enable Bits */
|
|
|
|
pci_write_config_byte(dev, 0x40, c);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since only primary interface works, force the
|
|
|
|
* IDE function to standard primary IDE interrupt
|
|
|
|
* w/ 8259 offset
|
|
|
|
*/
|
|
|
|
dev->irq = 14;
|
|
|
|
pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
|
|
|
|
break;
|
2006-04-03 05:42:40 +07:00
|
|
|
/*
|
2007-06-01 15:05:38 +07:00
|
|
|
* Force legacy USB interrupt routing
|
2006-04-03 05:42:40 +07:00
|
|
|
*/
|
2007-06-01 15:05:38 +07:00
|
|
|
case PCI_DEVICE_ID_VIA_82C586_2:
|
|
|
|
/* There are two USB controllers.
|
|
|
|
* Identify them by functon number
|
2006-04-03 05:42:40 +07:00
|
|
|
*/
|
2007-07-20 00:40:53 +07:00
|
|
|
if (PCI_FUNC(dev->devfn) == 3)
|
2007-06-01 15:05:38 +07:00
|
|
|
dev->irq = 11;
|
|
|
|
else
|
|
|
|
dev->irq = 10;
|
|
|
|
pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-04-03 05:42:40 +07:00
|
|
|
}
|
2006-08-18 08:24:48 +07:00
|
|
|
}
|
|
|
|
|
2012-12-22 05:04:10 +07:00
|
|
|
static void skip_fake_bridge(struct pci_dev *dev)
|
2007-07-20 03:39:24 +07:00
|
|
|
{
|
|
|
|
/* Make it an error to skip the fake bridge
|
|
|
|
* in pci_setup_device() in probe.c */
|
|
|
|
dev->hdr_type = 0x7f;
|
|
|
|
}
|
|
|
|
DECLARE_PCI_FIXUP_EARLY(0x1957, 0x3fff, skip_fake_bridge);
|
|
|
|
DECLARE_PCI_FIXUP_EARLY(0x3fff, 0x1957, skip_fake_bridge);
|
|
|
|
DECLARE_PCI_FIXUP_EARLY(0xff3f, 0x5719, skip_fake_bridge);
|
|
|
|
|
2012-03-14 17:15:27 +07:00
|
|
|
#define PCI_DEVICE_ID_IDT_TSI310 0x01a7
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix Tsi310 PCI-X bridge resource.
|
|
|
|
* Force the bridge to open a window from 0x0000-0x1fff in PCI I/O space.
|
|
|
|
* This allows legacy I/O(i8259, etc) on the VIA southbridge to be accessed.
|
|
|
|
*/
|
|
|
|
void mpc85xx_cds_fixup_bus(struct pci_bus *bus)
|
|
|
|
{
|
|
|
|
struct pci_dev *dev = bus->self;
|
|
|
|
struct resource *res = bus->resource[0];
|
|
|
|
|
|
|
|
if (dev != NULL &&
|
|
|
|
dev->vendor == PCI_VENDOR_ID_IBM &&
|
|
|
|
dev->device == PCI_DEVICE_ID_IDT_TSI310) {
|
|
|
|
if (res) {
|
|
|
|
res->start = 0;
|
|
|
|
res->end = 0x1fff;
|
|
|
|
res->flags = IORESOURCE_IO;
|
|
|
|
pr_info("mpc85xx_cds: PCI bridge resource fixup applied\n");
|
|
|
|
pr_info("mpc85xx_cds: %pR\n", res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fsl_pcibios_fixup_bus(bus);
|
|
|
|
}
|
|
|
|
|
2006-08-18 08:24:48 +07:00
|
|
|
#ifdef CONFIG_PPC_I8259
|
2015-09-14 15:42:37 +07:00
|
|
|
static void mpc85xx_8259_cascade_handler(struct irq_desc *desc)
|
2006-08-18 08:24:48 +07:00
|
|
|
{
|
2006-10-07 19:08:26 +07:00
|
|
|
unsigned int cascade_irq = i8259_irq();
|
2006-08-18 08:24:48 +07:00
|
|
|
|
2016-09-06 18:53:24 +07:00
|
|
|
if (cascade_irq)
|
2007-06-07 06:26:15 +07:00
|
|
|
/* handle an interrupt from the 8259 */
|
2006-10-06 08:31:10 +07:00
|
|
|
generic_handle_irq(cascade_irq);
|
2006-08-18 08:24:48 +07:00
|
|
|
|
2007-06-07 06:26:15 +07:00
|
|
|
/* check for any interrupts from the shared IRQ line */
|
2015-09-14 15:42:37 +07:00
|
|
|
handle_fasteoi_irq(desc);
|
2006-04-03 05:42:40 +07:00
|
|
|
}
|
2007-06-07 06:26:15 +07:00
|
|
|
|
|
|
|
static irqreturn_t mpc85xx_8259_cascade_action(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct irqaction mpc85xxcds_8259_irqaction = {
|
|
|
|
.handler = mpc85xx_8259_cascade_action,
|
2011-10-05 09:30:49 +07:00
|
|
|
.flags = IRQF_SHARED | IRQF_NO_THREAD,
|
2007-06-07 06:26:15 +07:00
|
|
|
.name = "8259 cascade",
|
|
|
|
};
|
2006-08-18 08:24:48 +07:00
|
|
|
#endif /* PPC_I8259 */
|
2006-04-03 05:42:40 +07:00
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2007-02-09 22:30:45 +07:00
|
|
|
static void __init mpc85xx_cds_pic_init(void)
|
2006-04-03 05:42:40 +07:00
|
|
|
{
|
2006-08-18 08:24:48 +07:00
|
|
|
struct mpic *mpic;
|
2011-12-22 17:19:14 +07:00
|
|
|
mpic = mpic_alloc(NULL, 0, MPIC_BIG_ENDIAN,
|
2007-07-03 14:35:35 +07:00
|
|
|
0, 256, " OpenPIC ");
|
2006-08-18 08:24:48 +07:00
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
mpic_init(mpic);
|
2007-06-15 01:02:54 +07:00
|
|
|
}
|
2006-08-18 08:24:48 +07:00
|
|
|
|
2007-06-07 06:26:15 +07:00
|
|
|
#if defined(CONFIG_PPC_I8259) && defined(CONFIG_PCI)
|
2007-06-15 01:02:54 +07:00
|
|
|
static int mpc85xx_cds_8259_attach(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct device_node *np = NULL;
|
|
|
|
struct device_node *cascade_node = NULL;
|
|
|
|
int cascade_irq;
|
|
|
|
|
2006-08-18 08:24:48 +07:00
|
|
|
/* Initialize the i8259 controller */
|
|
|
|
for_each_node_by_type(np, "interrupt-controller")
|
2007-05-03 14:26:52 +07:00
|
|
|
if (of_device_is_compatible(np, "chrp,iic")) {
|
2006-08-18 08:24:48 +07:00
|
|
|
cascade_node = np;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cascade_node == NULL) {
|
|
|
|
printk(KERN_DEBUG "Could not find i8259 PIC\n");
|
2007-06-15 01:02:54 +07:00
|
|
|
return -ENODEV;
|
2006-08-18 08:24:48 +07:00
|
|
|
}
|
2006-04-03 05:42:40 +07:00
|
|
|
|
2006-08-18 08:24:48 +07:00
|
|
|
cascade_irq = irq_of_parse_and_map(cascade_node, 0);
|
2016-09-06 18:53:24 +07:00
|
|
|
if (!cascade_irq) {
|
2006-08-18 08:24:48 +07:00
|
|
|
printk(KERN_ERR "Failed to map cascade interrupt\n");
|
2007-06-15 01:02:54 +07:00
|
|
|
return -ENXIO;
|
2006-08-18 08:24:48 +07:00
|
|
|
}
|
2006-04-03 05:42:40 +07:00
|
|
|
|
2006-08-18 08:24:48 +07:00
|
|
|
i8259_init(cascade_node, 0);
|
|
|
|
of_node_put(cascade_node);
|
|
|
|
|
2007-06-07 06:26:15 +07:00
|
|
|
/*
|
|
|
|
* Hook the interrupt to make sure desc->action is never NULL.
|
|
|
|
* This is required to ensure that the interrupt does not get
|
|
|
|
* disabled when the last user of the shared IRQ line frees their
|
|
|
|
* interrupt.
|
|
|
|
*/
|
2007-06-15 01:02:54 +07:00
|
|
|
if ((ret = setup_irq(cascade_irq, &mpc85xxcds_8259_irqaction))) {
|
2007-06-07 06:26:15 +07:00
|
|
|
printk(KERN_ERR "Failed to setup cascade interrupt\n");
|
2007-06-15 01:02:54 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Success. Connect our low-level cascade handler. */
|
2011-03-25 22:45:20 +07:00
|
|
|
irq_set_handler(cascade_irq, mpc85xx_8259_cascade_handler);
|
2007-06-15 01:02:54 +07:00
|
|
|
|
|
|
|
return 0;
|
2006-04-03 05:42:40 +07:00
|
|
|
}
|
2008-01-15 22:42:36 +07:00
|
|
|
machine_device_initcall(mpc85xx_cds, mpc85xx_cds_8259_attach);
|
2007-06-15 01:02:54 +07:00
|
|
|
|
|
|
|
#endif /* CONFIG_PPC_I8259 */
|
|
|
|
|
2012-08-28 14:44:08 +07:00
|
|
|
static void mpc85xx_cds_pci_assign_primary(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
if (fsl_pci_primary)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MPC85xx_CDS has ISA bridge but unfortunately there is no
|
|
|
|
* isa node in device tree. We now looking for i8259 node as
|
|
|
|
* a workaround for such a broken device tree. This routine
|
|
|
|
* is for complying to all device trees.
|
|
|
|
*/
|
|
|
|
np = of_find_node_by_name(NULL, "i8259");
|
|
|
|
while ((fsl_pci_primary = of_get_parent(np))) {
|
|
|
|
of_node_put(np);
|
|
|
|
np = fsl_pci_primary;
|
|
|
|
|
|
|
|
if ((of_device_is_compatible(np, "fsl,mpc8540-pci") ||
|
|
|
|
of_device_is_compatible(np, "fsl,mpc8548-pcie")) &&
|
|
|
|
of_device_is_available(np))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-04-03 05:42:40 +07:00
|
|
|
/*
|
|
|
|
* Setup the architecture
|
|
|
|
*/
|
2007-02-09 22:30:45 +07:00
|
|
|
static void __init mpc85xx_cds_setup_arch(void)
|
2006-04-03 05:42:40 +07:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
2012-03-06 16:06:42 +07:00
|
|
|
int cds_pci_slot;
|
2006-04-03 05:42:40 +07:00
|
|
|
|
|
|
|
if (ppc_md.progress)
|
|
|
|
ppc_md.progress("mpc85xx_cds_setup_arch()", 0);
|
|
|
|
|
2012-03-06 16:06:42 +07:00
|
|
|
np = of_find_compatible_node(NULL, NULL, "fsl,mpc8548cds-fpga");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("Could not find FPGA node.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cadmus = of_iomap(np, 0);
|
|
|
|
of_node_put(np);
|
|
|
|
if (!cadmus) {
|
|
|
|
pr_err("Fail to map FPGA area.\n");
|
|
|
|
return;
|
|
|
|
}
|
2006-04-03 05:42:40 +07:00
|
|
|
|
|
|
|
if (ppc_md.progress) {
|
|
|
|
char buf[40];
|
2012-03-06 16:06:42 +07:00
|
|
|
cds_pci_slot = ((in_8(&cadmus->cm_csr) >> 6) & 0x3) + 1;
|
2006-04-03 05:42:40 +07:00
|
|
|
snprintf(buf, 40, "CDS Version = 0x%x in slot %d\n",
|
2012-03-06 16:06:42 +07:00
|
|
|
in_8(&cadmus->cm_ver), cds_pci_slot);
|
2006-04-03 05:42:40 +07:00
|
|
|
ppc_md.progress(buf, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
2007-06-01 15:05:38 +07:00
|
|
|
ppc_md.pci_irq_fixup = mpc85xx_cds_pci_irq_fixup;
|
2006-04-03 05:42:40 +07:00
|
|
|
ppc_md.pci_exclude_device = mpc85xx_exclude_device;
|
|
|
|
#endif
|
2012-08-28 14:44:08 +07:00
|
|
|
|
|
|
|
mpc85xx_cds_pci_assign_primary();
|
|
|
|
fsl_pci_assign_primary();
|
2006-04-03 05:42:40 +07:00
|
|
|
}
|
|
|
|
|
2007-02-09 22:30:45 +07:00
|
|
|
static void mpc85xx_cds_show_cpuinfo(struct seq_file *m)
|
2006-04-03 05:42:40 +07:00
|
|
|
{
|
|
|
|
uint pvid, svid, phid1;
|
|
|
|
|
|
|
|
pvid = mfspr(SPRN_PVR);
|
|
|
|
svid = mfspr(SPRN_SVR);
|
|
|
|
|
|
|
|
seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
|
2012-03-06 16:06:42 +07:00
|
|
|
seq_printf(m, "Machine\t\t: MPC85xx CDS (0x%x)\n",
|
|
|
|
in_8(&cadmus->cm_ver));
|
2006-04-03 05:42:40 +07:00
|
|
|
seq_printf(m, "PVR\t\t: 0x%x\n", pvid);
|
|
|
|
seq_printf(m, "SVR\t\t: 0x%x\n", svid);
|
|
|
|
|
|
|
|
/* Display cpu Pll setting */
|
|
|
|
phid1 = mfspr(SPRN_HID1);
|
|
|
|
seq_printf(m, "PLL setting\t: 0x%x\n", ((phid1 >> 24) & 0x3f));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called very early, device-tree isn't unflattened
|
|
|
|
*/
|
|
|
|
static int __init mpc85xx_cds_probe(void)
|
|
|
|
{
|
2016-07-05 12:04:05 +07:00
|
|
|
return of_machine_is_compatible("MPC85xxCDS");
|
2006-04-03 05:42:40 +07:00
|
|
|
}
|
|
|
|
|
2012-08-28 14:44:08 +07:00
|
|
|
machine_arch_initcall(mpc85xx_cds, mpc85xx_common_publish_devices);
|
2008-06-17 05:36:17 +07:00
|
|
|
|
2006-04-03 05:42:40 +07:00
|
|
|
define_machine(mpc85xx_cds) {
|
|
|
|
.name = "MPC85xx CDS",
|
|
|
|
.probe = mpc85xx_cds_probe,
|
|
|
|
.setup_arch = mpc85xx_cds_setup_arch,
|
|
|
|
.init_IRQ = mpc85xx_cds_pic_init,
|
|
|
|
.show_cpuinfo = mpc85xx_cds_show_cpuinfo,
|
|
|
|
.get_irq = mpic_get_irq,
|
2007-03-24 05:43:37 +07:00
|
|
|
#ifdef CONFIG_PCI
|
2012-03-14 17:15:27 +07:00
|
|
|
.pcibios_fixup_bus = mpc85xx_cds_fixup_bus,
|
fsl/pci: The new pci suspend/resume implementation
If we do nothing in suspend/resume, some platform PCIe ip-block
can't guarantee the link back to L0 state from sleep, then, when
we read the EP device will hang. Only we send pme turnoff message
in pci controller suspend, and send pme exit message in resume, the
link state will be normal.
When we send pme turnoff message in pci controller suspend, the
links will into l2/l3 ready, then, host cannot communicate with
ep device, but pci-driver will call back EP device to save them
state. So we need to change platform_driver->suspend/resume to
syscore->suspend/resume.
So the new suspend/resume implementation, send pme turnoff message
in suspend, and send pme exit message in resume. And add a PME handler,
to response PME & message interrupt.
Change platform_driver->suspend/resume to syscore->suspend/resume.
pci-driver will call back EP device, to save EP state in
pci_pm_suspend_noirq, so we need to keep the link, until
pci_pm_suspend_noirq finish.
Signed-off-by: Wang Dongsheng <dongsheng.wang@freescale.com>
Signed-off-by: Scott Wood <scottwood@freescale.com>
2014-03-20 10:19:37 +07:00
|
|
|
.pcibios_fixup_phb = fsl_pcibios_fixup_phb,
|
2007-03-24 05:43:37 +07:00
|
|
|
#endif
|
2006-04-03 05:42:40 +07:00
|
|
|
.calibrate_decr = generic_calibrate_decr,
|
|
|
|
.progress = udbg_progress,
|
|
|
|
};
|