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_SUSPEND 1
 129 #define CTL_PM_CMODE 2
 130 #define CTL_PM_P0 4
 131 #define CTL_PM_CM 5
 132
 133 static int user_atoi(char __user *ubuf, size_t len)
 134 {
 135         char buf[16];
 136         unsigned long ret;
 137
 138         if (len > 15)
 139                 return -EINVAL;
 140
 141         if (copy_from_user(buf, ubuf, len))
 142                 return -EFAULT;
 143
 144         buf[len] = 0;
 145         ret = simple_strtoul(buf, NULL, 0);
 146         if (ret > INT_MAX)
 147                 return -ERANGE;
 148         return ret;
 149 }
 150
 151 /*
 152  * Send us to sleep.
 153  */
 154 static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp,
 155                                 void __user *buffer, size_t *lenp, loff_t *fpos)
 156 {
 157         int retval, mode;
 158
 159         if (*lenp <= 0)
 160                 return -EIO;
 161
 162         mode = user_atoi(buffer, *lenp);
 163         if ((mode != 1) && (mode != 5))
 164                 return -EINVAL;
 165
 166         retval = pm_send_all(PM_SUSPEND, (void *)3);
 167
 168         if (retval == 0) {
 169                 if (mode == 5)
 170                     retval = pm_do_bus_sleep();
 171                 else
 172                     retval = pm_do_suspend();
 173                 pm_send_all(PM_RESUME, (void *)0);
 174         }
 175
 176         return retval;
 177 }
 178
 179 static int try_set_cmode(int new_cmode)
 180 {
 181         if (new_cmode > 15)
 182                 return -EINVAL;
 183         if (!(clock_cmodes_permitted & (1<<new_cmode)))
 184                 return -EINVAL;
 185
 186         /* tell all the drivers we're suspending */
 187         pm_send_all(PM_SUSPEND, (void *)3);
 188
 189         /* now change cmode */
 190         local_irq_disable();
 191         frv_dma_pause_all();
 192
 193         frv_change_cmode(new_cmode);
 194
 195         determine_clocks(0);
 196         time_divisor_init();
 197
 198 #ifdef DEBUG
 199         determine_clocks(1);
 200 #endif
 201         frv_dma_resume_all();
 202         local_irq_enable();
 203
 204         /* tell all the drivers we're resuming */
 205         pm_send_all(PM_RESUME, (void *)0);
 206         return 0;
 207 }
 208
 209
 210 static int cmode_procctl(ctl_table *ctl, int write, struct file *filp,
 211                          void __user *buffer, size_t *lenp, loff_t *fpos)
 212 {
 213         int new_cmode;
 214
 215         if (!write)
 216                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 217
 218         new_cmode = user_atoi(buffer, *lenp);
 219
 220         return try_set_cmode(new_cmode)?:*lenp;
 221 }
 222
 223 static int cmode_sysctl(ctl_table *table, int __user *name, int nlen,
 224                         void __user *oldval, size_t __user *oldlenp,
 225                         void __user *newval, size_t newlen)
 226 {
 227         if (oldval && oldlenp) {
 228                 size_t oldlen;
 229
 230                 if (get_user(oldlen, oldlenp))
 231                         return -EFAULT;
 232
 233                 if (oldlen != sizeof(int))
 234                         return -EINVAL;
 235
 236                 if (put_user(clock_cmode_current, (unsigned __user *)oldval) ||
 237                     put_user(sizeof(int), oldlenp))
 238                         return -EFAULT;
 239         }
 240         if (newval && newlen) {
 241                 int new_cmode;
 242
 243                 if (newlen != sizeof(int))
 244                         return -EINVAL;
 245
 246                 if (get_user(new_cmode, (int __user *)newval))
 247                         return -EFAULT;
 248
 249                 return try_set_cmode(new_cmode)?:1;
 250         }
 251         return 1;
 252 }
 253
 254 static int try_set_p0(int new_p0)
 255 {
 256         unsigned long flags, clkc;
 257
 258         if (new_p0 < 0 || new_p0 > 1)
 259                 return -EINVAL;
 260
 261         local_irq_save(flags);
 262         __set_PSR(flags & ~PSR_ET);
 263
 264         frv_dma_pause_all();
 265
 266         clkc = __get_CLKC();
 267         if (new_p0)
 268                 clkc |= CLKC_P0;
 269         else
 270                 clkc &= ~CLKC_P0;
 271         __set_CLKC(clkc);
 272
 273         determine_clocks(0);
 274         time_divisor_init();
 275
 276 #ifdef DEBUG
 277         determine_clocks(1);
 278 #endif
 279         frv_dma_resume_all();
 280         local_irq_restore(flags);
 281         return 0;
 282 }
 283
 284 static int try_set_cm(int new_cm)
 285 {
 286         unsigned long flags, clkc;
 287
 288         if (new_cm < 0 || new_cm > 1)
 289                 return -EINVAL;
 290
 291         local_irq_save(flags);
 292         __set_PSR(flags & ~PSR_ET);
 293
 294         frv_dma_pause_all();
 295
 296         clkc = __get_CLKC();
 297         clkc &= ~CLKC_CM;
 298         clkc |= new_cm;
 299         __set_CLKC(clkc);
 300
 301         determine_clocks(0);
 302         time_divisor_init();
 303
 304 #if 1 //def DEBUG
 305         determine_clocks(1);
 306 #endif
 307
 308         frv_dma_resume_all();
 309         local_irq_restore(flags);
 310         return 0;
 311 }
 312
 313 static int p0_procctl(ctl_table *ctl, int write, struct file *filp,
 314                       void __user *buffer, size_t *lenp, loff_t *fpos)
 315 {
 316         int new_p0;
 317
 318         if (!write)
 319                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 320
 321         new_p0 = user_atoi(buffer, *lenp);
 322
 323         return try_set_p0(new_p0)?:*lenp;
 324 }
 325
 326 static int p0_sysctl(ctl_table *table, int __user *name, int nlen,
 327                      void __user *oldval, size_t __user *oldlenp,
 328                      void __user *newval, size_t newlen)
 329 {
 330         if (oldval && oldlenp) {
 331                 size_t oldlen;
 332
 333                 if (get_user(oldlen, oldlenp))
 334                         return -EFAULT;
 335
 336                 if (oldlen != sizeof(int))
 337                         return -EINVAL;
 338
 339                 if (put_user(clock_p0_current, (unsigned __user *)oldval) ||
 340                     put_user(sizeof(int), oldlenp))
 341                         return -EFAULT;
 342         }
 343         if (newval && newlen) {
 344                 int new_p0;
 345
 346                 if (newlen != sizeof(int))
 347                         return -EINVAL;
 348
 349                 if (get_user(new_p0, (int __user *)newval))
 350                         return -EFAULT;
 351
 352                 return try_set_p0(new_p0)?:1;
 353         }
 354         return 1;
 355 }
 356
 357 static int cm_procctl(ctl_table *ctl, int write, struct file *filp,
 358                       void __user *buffer, size_t *lenp, loff_t *fpos)
 359 {
 360         int new_cm;
 361
 362         if (!write)
 363                 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
 364
 365         new_cm = user_atoi(buffer, *lenp);
 366
 367         return try_set_cm(new_cm)?:*lenp;
 368 }
 369
 370 static int cm_sysctl(ctl_table *table, int __user *name, int nlen,
 371                      void __user *oldval, size_t __user *oldlenp,
 372                      void __user *newval, size_t newlen)
 373 {
 374         if (oldval && oldlenp) {
 375                 size_t oldlen;
 376
 377                 if (get_user(oldlen, oldlenp))
 378                         return -EFAULT;
 379
 380                 if (oldlen != sizeof(int))
 381                         return -EINVAL;
 382
 383                 if (put_user(clock_cm_current, (unsigned __user *)oldval) ||
 384                     put_user(sizeof(int), oldlenp))
 385                         return -EFAULT;
 386         }
 387         if (newval && newlen) {
 388                 int new_cm;
 389
 390                 if (newlen != sizeof(int))
 391                         return -EINVAL;
 392
 393                 if (get_user(new_cm, (int __user *)newval))
 394                         return -EFAULT;
 395
 396                 return try_set_cm(new_cm)?:1;
 397         }
 398         return 1;
 399 }
 400
 401
 402 static struct ctl_table pm_table[] =
 403 {
 404         {
 405                 .ctl_name       = CTL_PM_SUSPEND,
 406                 .procname       = "suspend",
 407                 .data           = NULL,
 408                 .maxlen         = 0,
 409                 .mode           = 0200,
 410                 .proc_handler   = &sysctl_pm_do_suspend,
 411         },
 412         {
 413                 .ctl_name       = CTL_PM_CMODE,
 414                 .procname       = "cmode",
 415                 .data           = &clock_cmode_current,
 416                 .maxlen         = sizeof(int),
 417                 .mode           = 0644,
 418                 .proc_handler   = &cmode_procctl,
 419                 .strategy       = &cmode_sysctl,
 420         },
 421         {
 422                 .ctl_name       = CTL_PM_P0,
 423                 .procname       = "p0",
 424                 .data           = &clock_p0_current,
 425                 .maxlen         = sizeof(int),
 426                 .mode           = 0644,
 427                 .proc_handler   = &p0_procctl,
 428                 .strategy       = &p0_sysctl,
 429         },
 430         {
 431                 .ctl_name       = CTL_PM_CM,
 432                 .procname       = "cm",
 433                 .data           = &clock_cm_current,
 434                 .maxlen         = sizeof(int),
 435                 .mode           = 0644,
 436                 .proc_handler   = &cm_procctl,
 437                 .strategy       = &cm_sysctl,
 438         },
 439         { .ctl_name = 0}
 440 };
 441
 442 static struct ctl_table pm_dir_table[] =
 443 {
 444         {
 445                 .ctl_name       = CTL_PM,
 446                 .procname       = "pm",
 447                 .mode           = 0555,
 448                 .child          = pm_table,
 449         },
 450         { .ctl_name = 0}
 451 };
 452
 453 /*
 454  * Initialize power interface
 455  */
 456 static int __init pm_init(void)
 457 {
 458         register_sysctl_table(pm_dir_table);
 459         return 0;
 460 }
 461
 462 __initcall(pm_init);
 463
 464 #endif