Commit 887ef35a authored by Paul Mackerras's avatar Paul Mackerras

[POWERPC] Fix sleep on powerbook 3400

Sleep on the powerbook 3400 has been broken since the change that made
powerbook_sleep_3400 call pmac_suspend_devices(), which disables
interrupts.  There are a couple of loops in powerbook_sleep_3400 that
depend on interrupts being enabled, and in fact it has to have
interrupts enabled at the point of going to sleep since it is an
interrupt from the PMU that wakes it up.

This fixes it by using pmu_wait_complete() instead of a spinloop, and
by explicitly enabling interrupts before putting the CPU into sleep
mode (which is OK since all interrupts except the PMU interrupt have
been disabled at the interrupt controller by this stage).

This changes the logic so that it keeps putting the CPU into sleep mode
until the completion of the interrupt transaction from the PMU that
signals the end of sleep.  Also, we now call pmu_unlock() before sleep
so that the via_pmu_interrupt() code can process the interrupt event
from the PMU properly.

Now that generic code saves and restores PCI state, it is no longer
necessary to do that here.  Thus pbook_pci_save/restore and related
functions are no longer necessary, so this removes them.

Lastly, this moves the ioremap of the memory controller to init code
rather than doing it on every sleep/wakeup cycle.
Signed-off-by: default avatarPaul Mackerras <paulus@samba.org>
parent 98f6740e
...@@ -202,6 +202,12 @@ static int proc_read_options(char *page, char **start, off_t off, ...@@ -202,6 +202,12 @@ static int proc_read_options(char *page, char **start, off_t off,
static int proc_write_options(struct file *file, const char __user *buffer, static int proc_write_options(struct file *file, const char __user *buffer,
unsigned long count, void *data); unsigned long count, void *data);
#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PPC32)
static void powerbook_sleep_init_3400(void);
#else
#define powerbook_sleep_init_3400() do { } while (0)
#endif
#ifdef CONFIG_ADB #ifdef CONFIG_ADB
struct adb_driver via_pmu_driver = { struct adb_driver via_pmu_driver = {
"PMU", "PMU",
...@@ -449,6 +455,10 @@ static int __init via_pmu_start(void) ...@@ -449,6 +455,10 @@ static int __init via_pmu_start(void)
pmu_poll(); pmu_poll();
} while (pmu_state != idle); } while (pmu_state != idle);
/* Do allocations and ioremaps that will be needed for sleep */
if (pmu_kind == PMU_OHARE_BASED)
powerbook_sleep_init_3400();
return 0; return 0;
} }
...@@ -1719,108 +1729,6 @@ pmu_present(void) ...@@ -1719,108 +1729,6 @@ pmu_present(void)
} }
#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PPC32) #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PPC32)
/*
* This struct is used to store config register values for
* PCI devices which may get powered off when we sleep.
*/
static struct pci_save {
u16 command;
u16 cache_lat;
u16 intr;
u32 rom_address;
} *pbook_pci_saves;
static int pbook_npci_saves;
static void
pbook_alloc_pci_save(void)
{
int npci;
struct pci_dev *pd = NULL;
npci = 0;
while ((pd = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pd)) != NULL) {
++npci;
}
if (npci == 0)
return;
pbook_pci_saves = (struct pci_save *)
kmalloc(npci * sizeof(struct pci_save), GFP_KERNEL);
pbook_npci_saves = npci;
}
static void
pbook_free_pci_save(void)
{
if (pbook_pci_saves == NULL)
return;
kfree(pbook_pci_saves);
pbook_pci_saves = NULL;
pbook_npci_saves = 0;
}
static void
pbook_pci_save(void)
{
struct pci_save *ps = pbook_pci_saves;
struct pci_dev *pd = NULL;
int npci = pbook_npci_saves;
if (ps == NULL)
return;
while ((pd = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pd)) != NULL) {
if (npci-- == 0) {
pci_dev_put(pd);
return;
}
pci_read_config_word(pd, PCI_COMMAND, &ps->command);
pci_read_config_word(pd, PCI_CACHE_LINE_SIZE, &ps->cache_lat);
pci_read_config_word(pd, PCI_INTERRUPT_LINE, &ps->intr);
pci_read_config_dword(pd, PCI_ROM_ADDRESS, &ps->rom_address);
++ps;
}
}
/* For this to work, we must take care of a few things: If gmac was enabled
* during boot, it will be in the pci dev list. If it's disabled at this point
* (and it will probably be), then you can't access it's config space.
*/
static void
pbook_pci_restore(void)
{
u16 cmd;
struct pci_save *ps = pbook_pci_saves - 1;
struct pci_dev *pd = NULL;
int npci = pbook_npci_saves;
int j;
while ((pd = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pd)) != NULL) {
if (npci-- == 0)
return;
ps++;
if (ps->command == 0)
continue;
pci_read_config_word(pd, PCI_COMMAND, &cmd);
if ((ps->command & ~cmd) == 0)
continue;
switch (pd->hdr_type) {
case PCI_HEADER_TYPE_NORMAL:
for (j = 0; j < 6; ++j)
pci_write_config_dword(pd,
PCI_BASE_ADDRESS_0 + j*4,
pd->resource[j].start);
pci_write_config_dword(pd, PCI_ROM_ADDRESS,
ps->rom_address);
pci_write_config_word(pd, PCI_CACHE_LINE_SIZE,
ps->cache_lat);
pci_write_config_word(pd, PCI_INTERRUPT_LINE,
ps->intr);
pci_write_config_word(pd, PCI_COMMAND, ps->command);
break;
}
}
}
#ifdef DEBUG_SLEEP #ifdef DEBUG_SLEEP
/* N.B. This doesn't work on the 3400 */ /* N.B. This doesn't work on the 3400 */
void void
...@@ -2200,37 +2108,34 @@ powerbook_sleep_Core99(void) ...@@ -2200,37 +2108,34 @@ powerbook_sleep_Core99(void)
#define PB3400_MEM_CTRL 0xf8000000 #define PB3400_MEM_CTRL 0xf8000000
#define PB3400_MEM_CTRL_SLEEP 0x70 #define PB3400_MEM_CTRL_SLEEP 0x70
static int static void __iomem *pb3400_mem_ctrl;
powerbook_sleep_3400(void)
static void powerbook_sleep_init_3400(void)
{
/* map in the memory controller registers */
pb3400_mem_ctrl = ioremap(PB3400_MEM_CTRL, 0x100);
if (pb3400_mem_ctrl == NULL)
printk(KERN_WARNING "ioremap failed: sleep won't be possible");
}
static int powerbook_sleep_3400(void)
{ {
int ret, i, x; int ret, i, x;
unsigned int hid0; unsigned int hid0;
unsigned long p; unsigned long msr;
struct adb_request sleep_req; struct adb_request sleep_req;
void __iomem *mem_ctrl;
unsigned int __iomem *mem_ctrl_sleep; unsigned int __iomem *mem_ctrl_sleep;
/* first map in the memory controller registers */ if (pb3400_mem_ctrl == NULL)
mem_ctrl = ioremap(PB3400_MEM_CTRL, 0x100);
if (mem_ctrl == NULL) {
printk("powerbook_sleep_3400: ioremap failed\n");
return -ENOMEM; return -ENOMEM;
} mem_ctrl_sleep = pb3400_mem_ctrl + PB3400_MEM_CTRL_SLEEP;
mem_ctrl_sleep = mem_ctrl + PB3400_MEM_CTRL_SLEEP;
/* Allocate room for PCI save */
pbook_alloc_pci_save();
ret = pmac_suspend_devices(); ret = pmac_suspend_devices();
if (ret) { if (ret) {
pbook_free_pci_save();
printk(KERN_ERR "Sleep rejected by devices\n"); printk(KERN_ERR "Sleep rejected by devices\n");
return ret; return ret;
} }
/* Save the state of PCI config space for some slots */
pbook_pci_save();
/* Set the memory controller to keep the memory refreshed /* Set the memory controller to keep the memory refreshed
while we're asleep */ while we're asleep */
for (i = 0x403f; i >= 0x4000; --i) { for (i = 0x403f; i >= 0x4000; --i) {
...@@ -2244,36 +2149,31 @@ powerbook_sleep_3400(void) ...@@ -2244,36 +2149,31 @@ powerbook_sleep_3400(void)
/* Ask the PMU to put us to sleep */ /* Ask the PMU to put us to sleep */
pmu_request(&sleep_req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T'); pmu_request(&sleep_req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
while (!sleep_req.complete) pmu_wait_complete(&sleep_req);
mb(); pmu_unlock();
pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,1); pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 1);
/* displacement-flush the L2 cache - necessary? */
for (p = KERNELBASE; p < KERNELBASE + 0x100000; p += 0x1000)
i = *(volatile int *)p;
asleep = 1; asleep = 1;
/* Put the CPU into sleep mode */ /* Put the CPU into sleep mode */
hid0 = mfspr(SPRN_HID0); hid0 = mfspr(SPRN_HID0);
hid0 = (hid0 & ~(HID0_NAP | HID0_DOZE)) | HID0_SLEEP; hid0 = (hid0 & ~(HID0_NAP | HID0_DOZE)) | HID0_SLEEP;
mtspr(SPRN_HID0, hid0); mtspr(SPRN_HID0, hid0);
mtmsr(mfmsr() | MSR_POW | MSR_EE); local_irq_enable();
udelay(10); msr = mfmsr() | MSR_POW;
while (asleep) {
mb();
mtmsr(msr);
isync();
}
local_irq_disable();
/* OK, we're awake again, start restoring things */ /* OK, we're awake again, start restoring things */
out_be32(mem_ctrl_sleep, 0x3f); out_be32(mem_ctrl_sleep, 0x3f);
pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,0); pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 0);
pbook_pci_restore();
pmu_unlock();
/* wait for the PMU interrupt sequence to complete */
while (asleep)
mb();
pmac_wakeup_devices(); pmac_wakeup_devices();
pbook_free_pci_save();
iounmap(mem_ctrl);
return 0; return 0;
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment