int s3cfb_resume(struct platform_device *dev)
{
struct fb_info *fbinfo = platform_get_drvdata(dev);
s3cfb_info_t *info = fbinfo->par;
clk_enable(info->clk);
s3c6410_pm_do_restore(s3c_lcd_save, ARRAY_SIZE(s3c_lcd_save));
s3cfb_init_hw();
s3cfb_start_lcd();
return 0;
}
static int s3c_keypad_resume(struct platform_device *dev)
{
// struct s3c_keypad *s3c_keypad =
// (struct s3c_keypad *)platform_get_drvdata(dev);
// struct input_dev *iDev = s3c_keypad->dev;
// unsigned int key_temp_data = 0;
printk(KERN_DEBUG "++++ %s\n", __FUNCTION__);
clk_enable(keypad_clock);
writel(KEYIFCON_INIT, key_base + S3C_KEYIFCON);
writel(keyiffc, key_base + S3C_KEYIFFC);
writel(KEYIFCOL_CLEAR, key_base + S3C_KEYIFCOL);
s3c6410_pm_do_restore(s3c_keypad_save, ARRAY_SIZE(s3c_keypad_save));
enable_irq(IRQ_KEYPAD);
printk(KERN_DEBUG "---- %s\n", __FUNCTION__);
return 0;
}
/*
* s3c6410_spi_resume - resume spi driver
* @pdev : platform device struct
*
* platform driver member function to resume spi driver
*/
static int s3c6410_spi_resume(struct platform_device *pdev)
{
struct s3c6410_spi *hw = platform_get_drvdata(pdev);
printk("%s\n",__func__);
/* for the moment, permanently enable the clock */
clk_enable(hw->clk);
s3c6410_pm_do_restore(s3c_spi_save, ARRAY_SIZE(s3c_spi_save));
/* sw reset */
writel(readl(hw->regs + S3C_CH_CFG) | SPI_CH_SW_RST, hw->regs + S3C_CH_CFG);
udelay(100);
writel(readl(hw->regs + S3C_CH_CFG) & (~SPI_CH_SW_RST), hw->regs + S3C_CH_CFG);
udelay(100);
return 0;
}
static int s3c_serial_resume(struct platform_device *dev)
{
struct uart_port *port = s3c_dev_to_port(&dev->dev);
struct s3c_uart_port *ourport = to_ourport(port);
unsigned int gpadata = 0;
if (port) {
clk_enable(ourport->clk);
s3c_serial_resetport(port, s3c_port_to_cfg(port));
clk_disable(ourport->clk);
s3c6410_pm_do_restore(uart_save + port->line * SAVE_UART_PORT, SAVE_UART_PORT);
uart_resume_port(&s3c_uart_drv, port);
}
if (port->line == 0) {
gpadata = __raw_readl(S3C64XX_GPADAT);
gpadata &= ~(1<<3);
__raw_writel(gpadata, S3C64XX_GPADAT);
} else if(port->line == 1) {
s3c_gpio_cfgpin(S3C64XX_GPA(7), S3C_GPIO_SFN(1));
gpadata = __raw_readl(S3C64XX_GPADAT);
gpadata &= ~(1<<7);
__raw_writel(gpadata, S3C64XX_GPADAT);
s3c_gpio_setpull(S3C64XX_GPA(7), S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(S3C64XX_GPA(7), S3C_GPIO_SFN(2));
}
return 0;
}
static int s3c6410_pm_enter(suspend_state_t state)
{
unsigned long regs_save[16];
unsigned int tmp;
unsigned int wakeup_stat = 0x0;
unsigned int eint0pend = 0x0;
/* ensure the debug is initialised (if enabled) */
DBG("s3c6410_pm_enter(%d)\n", state);
if (pm_cpu_prep == NULL || pm_cpu_sleep == NULL) {
printk(KERN_ERR PFX "error: no cpu sleep functions set\n");
return -EINVAL;
}
/* prepare check area if configured */
s3c6410_pm_check_prepare();
/* store the physical address of the register recovery block */
s3c6410_sleep_save_phys = virt_to_phys(regs_save);
DBG("s3c6410_sleep_save_phys=0x%08lx\n", s3c6410_sleep_save_phys);
/* save all necessary core registers not covered by the drivers */
s3c6410_pm_do_save(gpio_save, ARRAY_SIZE(gpio_save));
s3c6410_pm_do_save(irq_save, ARRAY_SIZE(irq_save));
s3c6410_pm_do_save(core_save, ARRAY_SIZE(core_save));
s3c6410_pm_do_save(sromc_save, ARRAY_SIZE(sromc_save));
//bss s3c6410_pm_do_save(onenand_save, ARRAY_SIZE(onenand_save));
s3c6410_pm_do_save(uart_save, ARRAY_SIZE(uart_save));
/* ensure INF_REG0 has the resume address */
__raw_writel(0xE240000C, (phys_to_virt(0x50008000)));
__raw_writel(0xE5901000, (phys_to_virt(0x50008004)));
__raw_writel(0xE1a0f001, (phys_to_virt(0x50008008)));
__raw_writel(0xe320f000, (phys_to_virt(0x5000800C)));
__raw_writel(0xe320f000, (phys_to_virt(0x50008010)));
__raw_writel(0xe320f000, (phys_to_virt(0x50008014)));
__raw_writel(virt_to_phys(s3c6410_cpu_resume), S3C_INFORM0);
/* set the irq configuration for wake */
s3c6410_pm_configure_extint();
/* call cpu specific preperation */
__raw_writel(0xF, S3C_INFORM3);
pm_cpu_prep();
/* flush cache back to ram */
flush_cache_all();
s3c6410_pm_check_store();
s3c_config_sleep_gpio();
tmp = __raw_readl(S3C64XX_SPCONSLP);
tmp &= ~(0x3 << 12);
__raw_writel(tmp | (0x1 << 12), S3C64XX_SPCONSLP);
/* send the cpu to sleep... */
__raw_writel(0xffffffff, S3C64XX_VIC0INTENCLEAR);
__raw_writel(0xffffffff, S3C64XX_VIC1INTENCLEAR);
__raw_writel(0xffffffff, S3C64XX_VIC0SOFTINTCLEAR);
__raw_writel(0xffffffff, S3C64XX_VIC1SOFTINTCLEAR);
/* Unmask clock gating and block power turn on */
__raw_writel(0x43E00041, S3C_HCLK_GATE);
__raw_writel(0xF2040000, S3C_PCLK_GATE);
__raw_writel(0x80000011, S3C_SCLK_GATE);
__raw_writel(0x00000000, S3C_MEM0_CLK_GATE);
__raw_writel(0x1, S3C_OSC_STABLE);
__raw_writel(0x3, S3C_PWR_STABLE);
/* Set WFI instruction to SLEEP mode */
tmp = __raw_readl(S3C_PWR_CFG);
tmp &= ~(0x3<<5);
tmp |= (0x3<<5);
__raw_writel(tmp, S3C_PWR_CFG);
tmp = __raw_readl(S3C_SLEEP_CFG);
tmp &= ~(0x61<<0);
__raw_writel(tmp, S3C_SLEEP_CFG);
__raw_writel(0x2, S3C64XX_SLPEN);
/* Clear WAKEUP_STAT register for next wakeup -jc.lee */
/* If this register do not be cleared, Wakeup will be failed */
__raw_writel(__raw_readl(S3C_WAKEUP_STAT), S3C_WAKEUP_STAT);
/* s3c6410_cpu_save will also act as our return point from when
* we resume as it saves its own register state, so use the return
* code to differentiate return from save and return from sleep */
if (s3c6410_cpu_save(regs_save) == 0) {
flush_cache_all();
pm_cpu_sleep();
}
/* restore the cpu state */
cpu_init();
__raw_writel(s3c_eint_mask_val, S3C_EINT_MASK);
/* restore the system state */
s3c6410_pm_do_restore_core(core_save, ARRAY_SIZE(core_save));
s3c6410_pm_do_restore(sromc_save, ARRAY_SIZE(sromc_save));
s3c6410_pm_do_restore(gpio_save, ARRAY_SIZE(gpio_save));
s3c6410_pm_do_restore(irq_save, ARRAY_SIZE(irq_save));
//bss s3c6410_pm_do_restore(onenand_save, ARRAY_SIZE(onenand_save));
s3c6410_pm_do_restore(uart_save, ARRAY_SIZE(uart_save));
__raw_writel(0x0, S3C64XX_SLPEN);
wakeup_stat = __raw_readl(S3C_WAKEUP_STAT);
eint0pend = __raw_readl(S3C64XX_EINT0PEND);
__raw_writel(eint0pend, S3C64XX_EINT0PEND);
DBG("post sleep, preparing to return\n");
s3c6410_pm_check_restore();
extra_eint0pend = eint0pend;
extra_wakeup_stat = wakeup_stat;
pr_info("%s: WAKEUP_STAT(0x%08x), EINT0PEND(0x%08x)\n",
__func__, wakeup_stat, eint0pend);
s3c_config_wakeup_gpio();
/* ok, let's return from sleep */
DBG("S3C6410 PM Resume (post-restore)\n");
return 0;
}
static int s3c_keypad_resume(struct platform_device *pdev)
{
struct s3c_keypad *s3c_keypad = platform_get_drvdata(pdev);
struct s3c_keypad_extra *extra = s3c_keypad->extra;
struct s3c_keypad_slide *slide = extra->slide;
struct s3c_keypad_gpio_key *gpio_key = extra->gpio_key;
struct input_dev *dev = s3c_keypad->dev;
clk_enable(keypad_clock);
if (is_timer_on)
del_timer (&keypad_timer);
is_timer_on = TRUE;
prevmask_low = 0;
prevmask_high = 0;
s3c_keypad_isr (0, NULL);
enable_irq(IRQ_KEYPAD);
if (slide)
{
enable_irq(slide->eint);
slide_int_handler (slide->eint, (void *) s3c_keypad);
}
printk("%s, extra_eint0pend: 0x%08x\n", __func__, extra_eint0pend);
if(gpio_key) {
enable_irq(gpio_key->eint);
if(extra_eint0pend == 0x00000020)
{
input_report_key(dev, gpio_key->keycode, 1);
DPRINTK(": Pressed (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
dprintk(KPD_PRS, ": Pressed with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("[KPD_DBG] Pressed with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("%s, gpio_key->gpio level: %d\n", __func__, gpio_get_value(gpio_key->gpio));
if(gpio_get_value(gpio_key->gpio))
{
input_report_key(dev, gpio_key->keycode, 0);
DPRINTK(": Released (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
dprintk(KPD_RLS, ": Released with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("[KPD_DBG] Released with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
}
}
}
#if 0
if (gpio_key)
{
int i;
for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1)
{
enable_irq(gpio_key->eint);
gpio_int_handler (gpio_key->eint, (void *) s3c_keypad);
}
}
#endif
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);
s3c6410_pm_do_restore(s3c_keypad_save, ARRAY_SIZE(s3c_keypad_save));
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
return 0;
}
static int s3c_keypad_resume(struct platform_device *pdev)
{
struct s3c_keypad *s3c_keypad = platform_get_drvdata(pdev);
struct s3c_keypad_extra *extra = s3c_keypad->extra;
struct s3c_keypad_slide *slide = extra->slide;
struct s3c_keypad_gpio_key *gpio_key = extra->gpio_key;
struct input_dev *dev = s3c_keypad->dev;
clk_enable(keypad_clock);
prevmask_low = 0;
prevmask_high = 0;
s3c_keypad_isr (0, NULL);
enable_irq(IRQ_KEYPAD);
#if defined (CONFIG_MACH_MAX)
if(extra_eint0pend == 0x200000) // Headset wakeup event
{
input_report_key(dev, 249, 1); // Power Key press
DPRINTK(": Force Power Key press for headset\n");
input_report_key(dev, 249, 0); // Power Key release
DPRINTK(": Force Power Key release for headset\n");
}
if(keypad_wakeup)
{
printk("%s, extra_wakeup_stat: 0x%08x\n", __FUNCTION__, extra_wakeup_stat);
// exception for H/W Key pressing bug
if(extra_wakeup_stat == 0x00000010) // Keypad wakeup event
{
input_report_key(dev, 249, 1); // Power Key press
DPRINTK(": Force Power Key press\n");
input_report_key(dev, 249, 0); // Power Key release
DPRINTK(": Force Power Key release\n");
}
}
#endif
#if !defined (CONFIG_MACH_MAX)
printk("%s, slide (%u) (%d)\n", __func__, extra->slide, slide->eint);
#endif
if (slide)
{
enable_irq(slide->eint);
slide_int_handler (slide->eint, (void *) s3c_keypad);
}
printk("%s, extra_eint0pend: 0x%08x\n", __func__, extra_eint0pend);
if(gpio_key) {
enable_irq(gpio_key->eint);
if(extra_eint0pend & 0x00000020)
{
input_report_key(dev, gpio_key->keycode, 1);
DPRINTK(": Pressed (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
DPRINTK(": Pressed with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("[KPD_DBG] Pressed with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("%s, gpio_key->gpio level: %d\n", __func__, gpio_get_value(gpio_key->gpio));
if(gpio_get_value(gpio_key->gpio))
{
input_report_key(dev, gpio_key->keycode, 0);
DPRINTK(": Released (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
DPRINTK(": Released with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
// printk("[KPD_DBG] Released with Resume (Keycode: %d, GPIO KEY)\n", gpio_key->keycode);
}
}
}
#if 0
if (gpio_key)
{
int i;
for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1)
{
enable_irq(gpio_key->eint);
gpio_int_handler (gpio_key->eint, (void *) s3c_keypad);
}
}
#endif
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);
s3c6410_pm_do_restore(s3c_keypad_save, ARRAY_SIZE(s3c_keypad_save));
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
return 0;
}
