static int try_set_cmode(int new_cmode)
{
if (new_cmode > 15)
return -EINVAL;
if (!(clock_cmodes_permitted & (1<<new_cmode)))
return -EINVAL;
/* tell all the drivers we're suspending */
pm_send_all(PM_SUSPEND, (void *)3);
/* now change cmode */
local_irq_disable();
frv_dma_pause_all();
frv_change_cmode(new_cmode);
determine_clocks(0);
time_divisor_init();
#ifdef DEBUG
determine_clocks(1);
#endif
frv_dma_resume_all();
local_irq_enable();
/* tell all the drivers we're resuming */
pm_send_all(PM_RESUME, (void *)0);
return 0;
}
static int pm_do_sleep(ctl_table * ctl, int write, struct file *file,
void *buffer, size_t * len)
{
int retval = 0;
#ifdef SLEEP_TEST_TIMEOUT
#define TMPBUFLEN2 16
char buf[TMPBUFLEN2], *p;
#endif
if (!write) {
*len = 0;
} else {
#ifdef SLEEP_TEST_TIMEOUT
if (*len > TMPBUFLEN2 - 1) {
return -EFAULT;
}
if (copy_from_user(buf, buffer, *len)) {
return -EFAULT;
}
buf[*len] = 0;
p = buf;
sleep_ticks = simple_strtoul(p, &p, 0);
#endif
retval = pm_send_all(PM_SUSPEND, (void *) 2);
if (retval)
return retval;
au_sleep();
retval = pm_send_all(PM_RESUME, (void *) 0);
}
return retval;
}
void pm_do_poweroff(void)
{
unsigned long start, flags;
PWER &= ~0x8000ffff;
local_irq_save(flags);
printk("Poweroff, Begin to wait BP_RDY signal.\n");
pm_send_all(PM_SUSPEND, (void *)3);
start = OSCR;
*(unsigned long *)(phys_to_virt(BPSIG_ADDR)) = NO_FLAG;
do {
if( !(GPLR(GPIO_BP_RDY) & GPIO_bit(GPIO_BP_RDY))){
printk(KERN_DEBUG"got BP_RDY signal.\n");
GPDR(GPIO_WDI_AP) |= GPIO_bit(GPIO_WDI_AP);
GPCR(GPIO_WDI_AP) = GPIO_bit(GPIO_WDI_AP);
while(1);
}
if ((OSCR - start) >= POWER_OFF_TIMEOUT) {
printk(KERN_DEBUG "timeout when power down\n");
mdelay(1);
GPDR(GPIO_WDI_AP) |= GPIO_bit(GPIO_WDI_AP);
GPCR(GPIO_WDI_AP) = GPIO_bit(GPIO_WDI_AP);
while(1);
}
} while(1);
pm_do_useroff();
printk(KERN_DEBUG "resume from useroff\n");
pm_send_all(PM_SUSPEND, (void *)0);
local_irq_restore(flags);
}
static int pm_go_sleep(int arg)
{
unsigned long flags;
sleep_jiffy = 0;
#ifdef CONFIG_NO_USB_SUSPEND_RESUME
return 0;
#endif
if ((can_sleep && (!ipc_is_active()) && (!periodic_wake)) || arg) {
local_irq_save(flags);
if (pm_send_all(PM_SUSPEND, (void *)3) == 0) {
ezx_i2c_pm_suspend();
wmmx_ohci_suspend_call();
if (!irq_pending()) {
if(usb_host_suspended)
UP3OCR = 0x3;
pm_do_suspend(CPUMODE_SLEEP);
clear_dpcsr();
}
APM_DPRINTK("resume\n");
ezx_i2c_pm_resume();
pm_send_all(PM_RESUME, (void *)0);
check_wakeup();
}
local_irq_restore(flags);
}
return 0;
}
/*
* Send us to sleep.
*/
static int sysctl_pm_do_suspend(void)
{
int retval;
retval = pm_send_all(PM_SUSPEND, (void *)3);
if (retval == 0) {
retval = pm_do_suspend();
pm_send_all(PM_RESUME, (void *)0);
}
return retval;
}
static int pm_do_suspend(ctl_table * ctl, int write, struct file *file,
void *buffer, size_t * len)
{
int retval = 0;
if (!write) {
*len = 0;
} else {
retval = pm_send_all(PM_SUSPEND, (void *) 2);
if (retval)
return retval;
suspend_mode = 1;
retval = pm_send_all(PM_RESUME, (void *) 0);
}
return retval;
}
/* Put CPU to SLEEP mode */
int jz_pm_sleep(void)
{
int retval;
#ifndef CONFIG_JZ_POWEROFF
if ((retval = request_irq (IRQ_GPIO_0 + GPIO_WAKEUP, pm_irq_handler, IRQF_DISABLED,
"PM", NULL))) {
printk ("PM could not get IRQ for GPIO_WAKEUP\n");
return retval;
}
#endif
pm_send_all(PM_SUSPEND, (void *)3);
retval = jz_pm_do_sleep();
pm_send_all(PM_RESUME, (void *)0);
#ifndef CONFIG_JZ_POWEROFF
free_irq (IRQ_GPIO_0 + GPIO_WAKEUP, NULL);
#endif
return retval;
}
/*
* Send us to sleep.
*/
static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp,
void __user *buffer, size_t *lenp, loff_t *fpos)
{
int retval, mode;
if (*lenp <= 0)
return -EIO;
mode = user_atoi(buffer, *lenp);
if ((mode != 1) && (mode != 5))
return -EINVAL;
retval = pm_send_all(PM_SUSPEND, (void *)3);
if (retval == 0) {
if (mode == 5)
retval = pm_do_bus_sleep();
else
retval = pm_do_suspend();
pm_send_all(PM_RESUME, (void *)0);
}
return retval;
}
/**
* acpi_system_restore_state - OS-specific restoration of state
* @state: sleep state we're exiting
*
* Note that if we're coming back from S4, the memory image should have
* already been loaded from the disk and is already in place. (Otherwise how
* else would we be here?).
*/
acpi_status
acpi_system_restore_state(
u32 state)
{
/*
* We should only be here if we're coming back from STR or STD.
* And, in the case of the latter, the memory image should have already
* been loaded from disk.
*/
if (state > ACPI_STATE_S1) {
acpi_restore_state_mem();
/* Do _early_ resume for irqs. Required by
* ACPI specs.
*/
/* TBD: call arch dependant reinitialization of the
* interrupts.
*/
#ifdef CONFIG_X86
init_8259A(0);
#endif
/* wait for power to come back */
mdelay(1000);
}
/* Be really sure that irqs are disabled. */
ACPI_DISABLE_IRQS();
/* Wait a little again, just in case... */
mdelay(1000);
/* enable interrupts once again */
ACPI_ENABLE_IRQS();
/* turn all the devices back on */
if (state > ACPI_STATE_S1)
pm_send_all(PM_RESUME, (void *)0);
return AE_OK;
}
/**
* acpi_system_save_state - save OS specific state and power down devices
* @state: sleep state we're entering.
*
* This handles saving all context to memory, and possibly disk.
* First, we call to the device driver layer to save device state.
* Once we have that, we save whatevery processor and kernel state we
* need to memory.
* If we're entering S4, we then write the memory image to disk.
*
* Only then it is safe for us to power down devices, since we may need
* the disks and upstream buses to write to.
*/
acpi_status
acpi_system_save_state(
u32 state)
{
int error = 0;
/* Send notification to devices that they will be suspended.
* If any device or driver cannot make the transition, either up
* or down, we'll get an error back.
*/
if (state > ACPI_STATE_S1) {
error = pm_send_all(PM_SAVE_STATE, (void *)3);
if (error)
return AE_ERROR;
}
if (state <= ACPI_STATE_S5) {
/* Tell devices to stop I/O and actually save their state.
* It is theoretically possible that something could fail,
* so handle that gracefully..
*/
if (state > ACPI_STATE_S1 && state != ACPI_STATE_S5) {
error = pm_send_all(PM_SUSPEND, (void *)3);
if (error) {
/* Tell devices to restore state if they have
* it saved and to start taking I/O requests.
*/
pm_send_all(PM_RESUME, (void *)0);
return error;
}
}
/* flush caches */
ACPI_FLUSH_CPU_CACHE();
/* Do arch specific saving of state. */
if (state > ACPI_STATE_S1) {
error = acpi_save_state_mem();
/* TBD: if no s4bios, write codes for
* acpi_save_state_disk()...
*/
#if 0
if (!error && (state == ACPI_STATE_S4))
error = acpi_save_state_disk();
#endif
if (error) {
pm_send_all(PM_RESUME, (void *)0);
return error;
}
}
}
/* disable interrupts
* Note that acpi_suspend -- our caller -- will do this once we return.
* But, we want it done early, so we don't get any suprises during
* the device suspend sequence.
*/
ACPI_DISABLE_IRQS();
/* Unconditionally turn off devices.
* Obvious if we enter a sleep state.
* If entering S5 (soft off), this should put devices in a
* quiescent state.
*/
if (state > ACPI_STATE_S1) {
error = pm_send_all(PM_SUSPEND, (void *)3);
/* We're pretty screwed if we got an error from this.
* We try to recover by simply calling our own restore_state
* function; see above for definition.
*
* If it's S5 though, go through with it anyway..
*/
if (error && state != ACPI_STATE_S5)
acpi_system_restore_state(state);
}
return error ? AE_ERROR : AE_OK;
}
static int do_ioctl(struct inode * inode, struct file *filp,
u_int cmd, u_long arg)
{
struct apm_user * as;
struct pm_dev * pm;
struct ipm_config conf;
as = filp->private_data;
if (check_apm_user(as, "ioctl"))
return -EIO;
memset(&conf, 0, sizeof(conf));
switch (cmd) {
case APM_IOC_SUSPEND:
pm_do_suspend(CPUMODE_SLEEP);
break;
case APM_IOC_SET_WAKEUP:
if ((pm = pm_find((pm_dev_t)arg,NULL)) == NULL)
return -EINVAL;
pm_send(pm,PM_SET_WAKEUP,NULL);
break;
case APM_IOC_SLEEP:
pm_go_sleep(arg);
break;
case APM_IOC_SET_SPROF_WIN:
sleep_to = arg * HZ;
APM_DPRINTK("do_ioctl: sleep timeout %ld\n", arg);
break;
case APM_IOC_WAKEUP_ENABLE:
PWER |= arg;
APM_DPRINTK("do_ioctl: enable wakeup source:PWER=0x%x\n", PWER);
break;
case APM_IOC_WAKEUP_DISABLE:
PWER &= ~arg;
APM_DPRINTK("do_ioctl: disable wakeup source:PWER=0x%x\n", PWER);
break;
case APM_IOC_POWEROFF:
APM_DPRINTK("do_ioctl: do power off\n");
/* here all device should response ok */
pm_send_all(PM_SUSPEND, (void *)3);
pm_do_poweroff();
pm_send_all(PM_RESUME, (void *)0);
break;
case APM_IOC_RESET_BP:
APM_DPRINTK("do_ioctl: reset bp\n");
GPCR(GPIO_BB_RESET) = GPIO_bit(GPIO_BB_RESET);
mdelay(1);
GPSR(GPIO_BB_RESET) = GPIO_bit(GPIO_BB_RESET);
break;
case APM_IOC_USEROFF_ENABLE:
APM_DPRINTK("do_ioctl: useroff support enable\n");
user_off_available = (int)arg;
break;
case APM_IOC_NOTIFY_BP:
break;
case APM_IOC_REFLASH:
cpu_proc_fin();
*(unsigned long *)(phys_to_virt(FLAG_ADDR)) = REFLASH_FLAG;
// power_ic_periph_set_usb_pull_up(0);
//LIN mdelay(1000);
//LIN let GPIO control the connectivity
#include <linux/power_ic.h>
set_GPIO_mode(GPIO_USB_READY|GPIO_OUT);
clr_GPIO(GPIO_USB_READY);
power_ic_periph_set_usb_pull_up(0);
mdelay(10);
power_ic_set_reg_bit(POWER_IC_REG_EOC_CONN_CONTROL,19,1);//LIN set USB_CNTRL(bit19) to disable emu control
mdelay(1000);
//LIN power_ic_periph_set_usb_pull_up(1);
/* Initialize the watchdog and let it fire */
OWER = OWER_WME;
OSSR = OSSR_M3;
OSMR3 = OSCR + CLOCK_TICK_RATE/100; /* ... in 10 ms */
MDREFR |= MDREFR_SLFRSH;
while(1);
break;
case APM_IOC_PASSTHRU:
cpu_proc_fin();
*(unsigned long *)(phys_to_virt(FLAG_ADDR)) = PASS_THRU_FLAG;
power_ic_periph_set_usb_pull_up(0);
mdelay(1000);
power_ic_periph_set_usb_pull_up(1);
/* Initialize the watchdog and let it fire */
OWER = OWER_WME;
OSSR = OSSR_M3;
OSMR3 = OSCR + CLOCK_TICK_RATE/100; /* ... in 10 ms */
MDREFR |= MDREFR_SLFRSH;
while(1);
break;
case APM_IOC_SET_IPROF_WIN:
/* set profile window size */
break;
case APM_IOC_STARTPMU:
if( pipm_start_pmu !=NULL )
pipm_start_pmu();
break;
case APM_IOC_GET_IPM_CONFIG:
get_ipm_config(&conf);
return (copy_to_user((void *)arg, &conf,sizeof(conf)))? -EFAULT:0;
break;
case APM_IOC_SET_IPM_CONFIG:
if(copy_from_user(&conf,(void *)arg,sizeof(conf)))
return -EFAULT;
return set_ipm_config(&conf);
break;
default:
return -EINVAL;
}
return 0;
}