arch/arm/mach-tegra/pmc.c

   1 /*
   2  * Copyright (C) 2012,2013 NVIDIA CORPORATION. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/clk.h>
  20 #include <linux/io.h>
  21 #include <linux/of.h>
  22 #include <linux/of_address.h>
  23 #include <linux/export.h>
  24
  25 #include "pmc.h"
  26
  27 #define PMC_CTRL                        0x0
  28 #define PMC_CTRL_INTR_LOW               (1 << 17)
  29 #define PMC_PWRGATE_TOGGLE              0x30
  30 #define PMC_PWRGATE_TOGGLE_START        (1 << 8)
  31 #define PMC_REMOVE_CLAMPING             0x34
  32 #define PMC_PWRGATE_STATUS              0x38
  33
  34 #define PMC_CPUPWRGOOD_TIMER    0xc8
  35 #define PMC_CPUPWROFF_TIMER     0xcc
  36
  37 #define TEGRA_POWERGATE_PCIE    3
  38 #define TEGRA_POWERGATE_VDEC    4
  39 #define TEGRA_POWERGATE_CPU1    9
  40 #define TEGRA_POWERGATE_CPU2    10
  41 #define TEGRA_POWERGATE_CPU3    11
  42
  43 static u8 tegra_cpu_domains[] = {
  44         0xFF,                   /* not available for CPU0 */
  45         TEGRA_POWERGATE_CPU1,
  46         TEGRA_POWERGATE_CPU2,
  47         TEGRA_POWERGATE_CPU3,
  48 };
  49 static DEFINE_SPINLOCK(tegra_powergate_lock);
  50
  51 static void __iomem *tegra_pmc_base;
  52 static bool tegra_pmc_invert_interrupt;
  53 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
  54 static struct clk *tegra_pclk;
  55 #endif
  56
  57 #ifdef CONFIG_OF
  58 static struct pmc_pm_data pmc_pm_data;
  59 #endif
  60 struct pmc_pm_data *tegra_get_pm_data()
  61 {
  62 #ifdef CONFIG_OF
  63         /*
  64          * Some boards have CONFIG_OF defined but no dts files
  65          */
  66         if (!tegra_pmc_base)
  67                 return NULL;
  68         return &pmc_pm_data;
  69 #else
  70         return NULL;
  71 #endif
  72 }
  73 EXPORT_SYMBOL(tegra_get_pm_data);
  74
  75 static inline u32 tegra_pmc_readl(u32 reg)
  76 {
  77         return readl(tegra_pmc_base + reg);
  78 }
  79
  80 static inline void tegra_pmc_writel(u32 val, u32 reg)
  81 {
  82         writel(val, tegra_pmc_base + reg);
  83 }
  84
  85 static int tegra_pmc_get_cpu_powerdomain_id(int cpuid)
  86 {
  87         if (cpuid <= 0 || cpuid >= num_possible_cpus())
  88                 return -EINVAL;
  89         return tegra_cpu_domains[cpuid];
  90 }
  91
  92 static bool tegra_pmc_powergate_is_powered(int id)
  93 {
  94         return (tegra_pmc_readl(PMC_PWRGATE_STATUS) >> id) & 1;
  95 }
  96
  97 static int tegra_pmc_powergate_set(int id, bool new_state)
  98 {
  99         bool old_state;
 100         unsigned long flags;
 101
 102         spin_lock_irqsave(&tegra_powergate_lock, flags);
 103
 104         old_state = tegra_pmc_powergate_is_powered(id);
 105         WARN_ON(old_state == new_state);
 106
 107         tegra_pmc_writel(PMC_PWRGATE_TOGGLE_START | id, PMC_PWRGATE_TOGGLE);
 108
 109         spin_unlock_irqrestore(&tegra_powergate_lock, flags);
 110
 111         return 0;
 112 }
 113
 114 static int tegra_pmc_powergate_remove_clamping(int id)
 115 {
 116         u32 mask;
 117
 118         /*
 119          * Tegra has a bug where PCIE and VDE clamping masks are
 120          * swapped relatively to the partition ids.
 121          */
 122         if (id ==  TEGRA_POWERGATE_VDEC)
 123                 mask = (1 << TEGRA_POWERGATE_PCIE);
 124         else if (id == TEGRA_POWERGATE_PCIE)
 125                 mask = (1 << TEGRA_POWERGATE_VDEC);
 126         else
 127                 mask = (1 << id);
 128
 129         tegra_pmc_writel(mask, PMC_REMOVE_CLAMPING);
 130
 131         return 0;
 132 }
 133
 134 bool tegra_pmc_cpu_is_powered(int cpuid)
 135 {
 136         int id;
 137
 138         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
 139         if (id < 0)
 140                 return false;
 141         return tegra_pmc_powergate_is_powered(id);
 142 }
 143
 144 int tegra_pmc_cpu_power_on(int cpuid)
 145 {
 146         int id;
 147
 148         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
 149         if (id < 0)
 150                 return id;
 151         return tegra_pmc_powergate_set(id, true);
 152 }
 153
 154 int tegra_pmc_cpu_remove_clamping(int cpuid)
 155 {
 156         int id;
 157
 158         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
 159         if (id < 0)
 160                 return id;
 161         return tegra_pmc_powergate_remove_clamping(id);
 162 }
 163
 164 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) && defined(CONFIG_PM_SLEEP)
 165 void set_power_timers(unsigned long us_on, unsigned long us_off)
 166 {
 167         unsigned long long ticks;
 168         unsigned long long pclk;
 169         unsigned long rate;
 170         static unsigned long tegra_last_pclk;
 171
 172         rate = clk_get_rate(tegra_pclk);
 173         if (WARN_ON_ONCE(rate <= 0))
 174                 pclk = 100000000;
 175         else
 176                 pclk = rate;
 177
 178         if ((rate != tegra_last_pclk)) {
 179                 ticks = (us_on * pclk) + 999999ull;
 180                 do_div(ticks, 1000000);
 181                 tegra_pmc_writel((unsigned long)ticks, PMC_CPUPWRGOOD_TIMER);
 182
 183                 ticks = (us_off * pclk) + 999999ull;
 184                 do_div(ticks, 1000000);
 185                 tegra_pmc_writel((unsigned long)ticks, PMC_CPUPWROFF_TIMER);
 186                 wmb();
 187         }
 188         tegra_last_pclk = pclk;
 189 }
 190 #endif
 191
 192 static const struct of_device_id matches[] __initconst = {
 193         { .compatible = "nvidia,tegra124-pmc" },
 194         { .compatible = "nvidia,tegra148-pmc" },
 195         { .compatible = "nvidia,tegra114-pmc" },
 196         { .compatible = "nvidia,tegra30-pmc" },
 197         { .compatible = "nvidia,tegra20-pmc" },
 198         { }
 199 };
 200
 201 static void tegra_pmc_parse_dt(void)
 202 {
 203         struct device_node *np;
 204         u32 prop;
 205         enum tegra_suspend_mode suspend_mode;
 206         u32 core_good_time[2] = {0, 0};
 207         u32 lp0_vec[2] = {0, 0};
 208
 209         np = of_find_matching_node(NULL, matches);
 210         BUG_ON(!np);
 211
 212         tegra_pmc_base = of_iomap(np, 0);
 213
 214         tegra_pmc_invert_interrupt = of_property_read_bool(np,
 215                                      "nvidia,invert-interrupt");
 216 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
 217         tegra_pclk = of_clk_get_by_name(np, "pclk");
 218         WARN_ON(IS_ERR(tegra_pclk));
 219 #endif
 220
 221         /* Grabbing the power management configurations */
 222         if (of_property_read_u32(np, "nvidia,suspend-mode", &prop)) {
 223                 suspend_mode = TEGRA_SUSPEND_NONE;
 224         } else {
 225                 switch (prop) {
 226                 case 0:
 227                         suspend_mode = TEGRA_SUSPEND_LP0;
 228                         break;
 229                 case 1:
 230                         suspend_mode = TEGRA_SUSPEND_LP1;
 231                         break;
 232                 case 2:
 233                         suspend_mode = TEGRA_SUSPEND_LP2;
 234                         break;
 235                 default:
 236                         suspend_mode = TEGRA_SUSPEND_NONE;
 237                         break;
 238                 }
 239         }
 240
 241         if (of_property_read_u32(np, "nvidia,cpu-pwr-good-time", &prop))
 242                 suspend_mode = TEGRA_SUSPEND_NONE;
 243         pmc_pm_data.cpu_good_time = prop;
 244
 245         if (of_property_read_u32(np, "nvidia,cpu-pwr-off-time", &prop))
 246                 suspend_mode = TEGRA_SUSPEND_NONE;
 247         pmc_pm_data.cpu_off_time = prop;
 248
 249         if (of_property_read_u32_array(np, "nvidia,core-pwr-good-time",
 250                         core_good_time, ARRAY_SIZE(core_good_time)))
 251                 suspend_mode = TEGRA_SUSPEND_NONE;
 252         pmc_pm_data.core_osc_time = core_good_time[0];
 253         pmc_pm_data.core_pmu_time = core_good_time[1];
 254
 255         if (of_property_read_u32(np, "nvidia,core-pwr-off-time",
 256                                  &prop))
 257                 suspend_mode = TEGRA_SUSPEND_NONE;
 258         pmc_pm_data.core_off_time = prop;
 259
 260         pmc_pm_data.corereq_high = of_property_read_bool(np,
 261                                 "nvidia,core-power-req-active-high");
 262
 263         pmc_pm_data.sysclkreq_high = of_property_read_bool(np,
 264                                 "nvidia,sys-clock-req-active-high");
 265
 266         pmc_pm_data.combined_req = of_property_read_bool(np,
 267                                 "nvidia,combined-power-req");
 268
 269         pmc_pm_data.cpu_pwr_good_en = of_property_read_bool(np,
 270                                 "nvidia,cpu-pwr-good-en");
 271
 272         if (of_property_read_u32_array(np, "nvidia,lp0-vec", lp0_vec,
 273                                        ARRAY_SIZE(lp0_vec)))
 274                 if (suspend_mode == TEGRA_SUSPEND_LP0)
 275                         suspend_mode = TEGRA_SUSPEND_LP1;
 276
 277         pmc_pm_data.lp0_vec_phy_addr = lp0_vec[0];
 278         pmc_pm_data.lp0_vec_size = lp0_vec[1];
 279
 280         pmc_pm_data.suspend_mode = suspend_mode;
 281 }
 282
 283 void __init tegra_pmc_init(void)
 284 {
 285         u32 val;
 286
 287         tegra_pmc_parse_dt();
 288
 289         val = tegra_pmc_readl(PMC_CTRL);
 290         if (tegra_pmc_invert_interrupt)
 291                 val |= PMC_CTRL_INTR_LOW;
 292         else
 293                 val &= ~PMC_CTRL_INTR_LOW;
 294         tegra_pmc_writel(val, PMC_CTRL);
 295 }