arch/frv/kernel/pm.c

   1 /*
   2  * FR-V Power Management Routines
   3  *
   4  * Copyright (c) 2004 Red Hat, Inc.
   5  *
   6  * Based on SA1100 version:
   7  * Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License.
  11  *
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/pm.h>
  17 #include <linux/pm_legacy.h>
  18 #include <linux/sched.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/sysctl.h>
  21 #include <linux/errno.h>
  22 #include <linux/delay.h>
  23 #include <asm/uaccess.h>
  24
  25 #include <asm/mb86943a.h>
  26
  27 #include "local.h"
  28
  29 /*
  30  * Debug macros
  31  */
  32 #define DEBUG
  33
  34 int pm_do_suspend(void)
  35 {
  36         local_irq_disable();
  37
  38         __set_LEDS(0xb1);
  39
  40         /* go zzz */
  41         frv_cpu_suspend(pdm_suspend_mode);
  42
  43         __set_LEDS(0xb2);
  44
  45         local_irq_enable();
  46
  47         return 0;
  48 }
  49
  50 static unsigned long __irq_mask;
  51
  52 /*
  53  * Setup interrupt masks, etc to enable wakeup by power switch
  54  */
  55 static void __default_power_switch_setup(void)
  56 {
  57         /* default is to mask all interrupt sources. */
  58         __irq_mask = *(unsigned long *)0xfeff9820;
  59         *(unsigned long *)0xfeff9820 = 0xfffe0000;
  60 }
  61
  62 /*
  63  * Cleanup interrupt masks, etc after wakeup by power switch
  64  */
  65 static void __default_power_switch_cleanup(void)
  66 {
  67         *(unsigned long *)0xfeff9820 = __irq_mask;
  68 }
  69
  70 /*
  71  * Return non-zero if wakeup irq was caused by power switch
  72  */
  73 static int __default_power_switch_check(void)
  74 {
  75         return 1;
  76 }
  77
  78 void (*__power_switch_wake_setup)(void) = __default_power_switch_setup;
  79 int  (*__power_switch_wake_check)(void) = __default_power_switch_check;
  80 void (*__power_switch_wake_cleanup)(void) = __default_power_switch_cleanup;
  81
  82 int pm_do_bus_sleep(void)
  83 {
  84         local_irq_disable();
  85
  86         /*
  87          * Here is where we need some platform-dependent setup
  88          * of the interrupt state so that appropriate wakeup
  89          * sources are allowed and all others are masked.
  90          */
  91         __power_switch_wake_setup();
  92
  93         __set_LEDS(0xa1);
  94
  95         /* go zzz
  96          *
  97          * This is in a loop in case power switch shares an irq with other
  98          * devices. The wake_check() tells us if we need to finish waking
  99          * or go back to sleep.
 100          */
 101         do {
 102                 frv_cpu_suspend(HSR0_PDM_BUS_SLEEP);
 103         } while (__power_switch_wake_check && !__power_switch_wake_check());
 104
 105         __set_LEDS(0xa2);
 106
 107         /*
 108          * Here is where we need some platform-dependent restore
 109          * of the interrupt state prior to being called.
 110          */
 111         __power_switch_wake_cleanup();
 112
 113         local_irq_enable();
 114
 115         return 0;
 116 }
 117
 118 unsigned long sleep_phys_sp(void *sp)
 119 {
 120         return virt_to_phys(sp);
 121 }
 122
 123 #ifdef CONFIG_SYSCTL
 124 /*
 125  * Use a temporary sysctl number. Horrid, but will be cleaned up in 2.6
 126  * when all the PM interfaces exist nicely.
 127  */
 128 #define CTL_PM 9899
 129 #define CTL_PM_SUSPEND 1
 130 #define CTL_PM_CMODE 2
 131 #define CTL_PM_P0 4
 132 #define CTL_PM_CM 5
 133
 134 static int user_atoi(char __user *ubuf, size_t len)
 135 {
 136         char buf[16];
 137         unsigned long ret;
 138
 139         if (len > 15)
 140                 return -EINVAL;
 141
 142         if (copy_from_user(buf, ubuf, len))
 143                 return -EFAULT;
 144
 145         buf[len] = 0;
 146         ret = simple_strtoul(buf, NULL, 0);
 147         if (ret > INT_MAX)
 148                 return -ERANGE;
 149         return ret;
 150 }
 151
 152 /*
 153  * Send us to sleep.
 154  */
 155 static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp,
 156                                 void __user *buffer, size_t *lenp, loff_t *fpos)
 157 {
 158         int retval, mode;
 159
 160         if (*lenp <= 0)
 161                 return -EIO;
 162
 163         mode = user_atoi(buffer, *lenp);
 164         if ((mode != 1) && (mode != 5))
 165                 return -EINVAL;
 166
 167         retval = pm_send_all(PM_SUSPEND, (void *)3);
 168
 169         if (retval == 0) {
 170                 if (mode == 5)
 171                     retval = pm_do_bus_sleep();
 172                 else
 173                     retval = pm_do_suspend();
 174                 pm_send_all(PM_RESUME, (void *)0);
 175         }
 176
 177         return retval;
 178 }
 179
 180 static int try_set_cmode(int new_cmode)
 181 {
 182         if (new_cmode > 15)
 183                 return -EINVAL;
 184         if (!(clock_cmodes_permitted & (1<<new_cmode)))
 185                 return -EINVAL;
 186
 187         /* tell all the drivers we're suspending */
 188         pm_send_all(PM_SUSPEND, (void *)3);
 189
 190         /* now change cmode */
 191         local_irq_disable();
 192         frv_dma_pause_all();
 193
 194         frv_change_cmode(new_cmode);
 195
 196         determine_clocks(0);
 197         time_divisor_init();
 198
 199 #ifdef DEBUG
 200         determine_clocks(1);
 201 #endif
 202         frv_dma_resume_all();
 203         local_irq_enable();
 204
 205         /* tell all the drivers we're resuming */
 206         pm_send_all(PM_RESUME, (void *)0);
 207         return 0;
 208 }
 209
 210
 211 static int cmode_procctl(ctl_table *ctl, int write, struct file *filp,
 212                          void __user *buffer, size_t *lenp, loff_t *fpos)
 213 {
 214         int new_cmode;
 215
 216         if (!write)
 217                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 218
 219         new_cmode = user_atoi(buffer, *lenp);
 220
 221         return try_set_cmode(new_cmode)?:*lenp;
 222 }
 223
 224 static int cmode_sysctl(ctl_table *table, int __user *name, int nlen,
 225                         void __user *oldval, size_t __user *oldlenp,
 226                         void __user *newval, size_t newlen, void **context)
 227 {
 228         if (oldval && oldlenp) {
 229                 size_t oldlen;
 230
 231                 if (get_user(oldlen, oldlenp))
 232                         return -EFAULT;
 233
 234                 if (oldlen != sizeof(int))
 235                         return -EINVAL;
 236
 237                 if (put_user(clock_cmode_current, (unsigned __user *)oldval) ||
 238                     put_user(sizeof(int), oldlenp))
 239                         return -EFAULT;
 240         }
 241         if (newval && newlen) {
 242                 int new_cmode;
 243
 244                 if (newlen != sizeof(int))
 245                         return -EINVAL;
 246
 247                 if (get_user(new_cmode, (int __user *)newval))
 248                         return -EFAULT;
 249
 250                 return try_set_cmode(new_cmode)?:1;
 251         }
 252         return 1;
 253 }
 254
 255 static int try_set_p0(int new_p0)
 256 {
 257         unsigned long flags, clkc;
 258
 259         if (new_p0 < 0 || new_p0 > 1)
 260                 return -EINVAL;
 261
 262         local_irq_save(flags);
 263         __set_PSR(flags & ~PSR_ET);
 264
 265         frv_dma_pause_all();
 266
 267         clkc = __get_CLKC();
 268         if (new_p0)
 269                 clkc |= CLKC_P0;
 270         else
 271                 clkc &= ~CLKC_P0;
 272         __set_CLKC(clkc);
 273
 274         determine_clocks(0);
 275         time_divisor_init();
 276
 277 #ifdef DEBUG
 278         determine_clocks(1);
 279 #endif
 280         frv_dma_resume_all();
 281         local_irq_restore(flags);
 282         return 0;
 283 }
 284
 285 static int try_set_cm(int new_cm)
 286 {
 287         unsigned long flags, clkc;
 288
 289         if (new_cm < 0 || new_cm > 1)
 290                 return -EINVAL;
 291
 292         local_irq_save(flags);
 293         __set_PSR(flags & ~PSR_ET);
 294
 295         frv_dma_pause_all();
 296
 297         clkc = __get_CLKC();
 298         clkc &= ~CLKC_CM;
 299         clkc |= new_cm;
 300         __set_CLKC(clkc);
 301
 302         determine_clocks(0);
 303         time_divisor_init();
 304
 305 #if 1 //def DEBUG
 306         determine_clocks(1);
 307 #endif
 308
 309         frv_dma_resume_all();
 310         local_irq_restore(flags);
 311         return 0;
 312 }
 313
 314 static int p0_procctl(ctl_table *ctl, int write, struct file *filp,
 315                       void __user *buffer, size_t *lenp, loff_t *fpos)
 316 {
 317         int new_p0;
 318
 319         if (!write)
 320                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 321
 322         new_p0 = user_atoi(buffer, *lenp);
 323
 324         return try_set_p0(new_p0)?:*lenp;
 325 }
 326
 327 static int p0_sysctl(ctl_table *table, int __user *name, int nlen,
 328                      void __user *oldval, size_t __user *oldlenp,
 329                      void __user *newval, size_t newlen, void **context)
 330 {
 331         if (oldval && oldlenp) {
 332                 size_t oldlen;
 333
 334                 if (get_user(oldlen, oldlenp))
 335                         return -EFAULT;
 336
 337                 if (oldlen != sizeof(int))
 338                         return -EINVAL;
 339
 340                 if (put_user(clock_p0_current, (unsigned __user *)oldval) ||
 341                     put_user(sizeof(int), oldlenp))
 342                         return -EFAULT;
 343         }
 344         if (newval && newlen) {
 345                 int new_p0;
 346
 347                 if (newlen != sizeof(int))
 348                         return -EINVAL;
 349
 350                 if (get_user(new_p0, (int __user *)newval))
 351                         return -EFAULT;
 352
 353                 return try_set_p0(new_p0)?:1;
 354         }
 355         return 1;
 356 }
 357
 358 static int cm_procctl(ctl_table *ctl, int write, struct file *filp,
 359                       void __user *buffer, size_t *lenp, loff_t *fpos)
 360 {
 361         int new_cm;
 362
 363         if (!write)
 364                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 365
 366         new_cm = user_atoi(buffer, *lenp);
 367
 368         return try_set_cm(new_cm)?:*lenp;
 369 }
 370
 371 static int cm_sysctl(ctl_table *table, int __user *name, int nlen,
 372                      void __user *oldval, size_t __user *oldlenp,
 373                      void __user *newval, size_t newlen, void **context)
 374 {
 375         if (oldval && oldlenp) {
 376                 size_t oldlen;
 377
 378                 if (get_user(oldlen, oldlenp))
 379                         return -EFAULT;
 380
 381                 if (oldlen != sizeof(int))
 382                         return -EINVAL;
 383
 384                 if (put_user(clock_cm_current, (unsigned __user *)oldval) ||
 385                     put_user(sizeof(int), oldlenp))
 386                         return -EFAULT;
 387         }
 388         if (newval && newlen) {
 389                 int new_cm;
 390
 391                 if (newlen != sizeof(int))
 392                         return -EINVAL;
 393
 394                 if (get_user(new_cm, (int __user *)newval))
 395                         return -EFAULT;
 396
 397                 return try_set_cm(new_cm)?:1;
 398         }
 399         return 1;
 400 }
 401
 402
 403 static struct ctl_table pm_table[] =
 404 {
 405         {CTL_PM_SUSPEND, "suspend", NULL, 0, 0200, NULL, &sysctl_pm_do_suspend},
 406         {CTL_PM_CMODE, "cmode", &clock_cmode_current, sizeof(int), 0644, NULL, &cmode_procctl, &cmode_sysctl, NULL},
 407         {CTL_PM_P0, "p0", &clock_p0_current, sizeof(int), 0644, NULL, &p0_procctl, &p0_sysctl, NULL},
 408         {CTL_PM_CM, "cm", &clock_cm_current, sizeof(int), 0644, NULL, &cm_procctl, &cm_sysctl, NULL},
 409         {0}
 410 };
 411
 412 static struct ctl_table pm_dir_table[] =
 413 {
 414         {CTL_PM, "pm", NULL, 0, 0555, pm_table},
 415         {0}
 416 };
 417
 418 /*
 419  * Initialize power interface
 420  */
 421 static int __init pm_init(void)
 422 {
 423         register_sysctl_table(pm_dir_table, 1);
 424         return 0;
 425 }
 426
 427 __initcall(pm_init);
 428
 429 #endif