Added missing tegra files.HEADmaster

1 files changed, 846 insertions, 0 deletions

diff --git a/arch/arm/mach-tegra/dvfs.c b/arch/arm/mach-tegra/dvfs.c
new file mode 100644
index 00000000000..8723e6fa60d
--- /dev/null
+++ b/arch/arm/mach-tegra/dvfs.c
@@ -0,0 +1,846 @@
+/*
+ *
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *      Colin Cross <ccross@google.com>
+ *
+ * Copyright (C) 2010-2011 NVIDIA Corporation.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/clkdev.h>
+#include <linux/debugfs.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/list_sort.h>
+#include <linux/module.h>
+#include <linux/regulator/consumer.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/suspend.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+
+#include <mach/clk.h>
+
+#include "board.h"
+#include "clock.h"
+#include "dvfs.h"
+
+#define DVFS_RAIL_STATS_BIN     25
+#define DVFS_RAIL_STATS_SCALE   2
+#define DVFS_RAIL_STATS_RANGE   ((DVFS_RAIL_STATS_TOP_BIN - 1) * \
+                                 DVFS_RAIL_STATS_BIN / DVFS_RAIL_STATS_SCALE)
+
+static LIST_HEAD(dvfs_rail_list);
+static DEFINE_MUTEX(dvfs_lock);
+static DEFINE_MUTEX(rail_disable_lock);
+
+static int dvfs_rail_update(struct dvfs_rail *rail);
+
+void tegra_dvfs_add_relationships(struct dvfs_relationship *rels, int n)
+{
+        int i;
+        struct dvfs_relationship *rel;
+
+        mutex_lock(&dvfs_lock);
+
+        for (i = 0; i < n; i++) {
+                rel = &rels[i];
+                list_add_tail(&rel->from_node, &rel->to->relationships_from);
+                list_add_tail(&rel->to_node, &rel->from->relationships_to);
+        }
+
+        mutex_unlock(&dvfs_lock);
+}
+
+int tegra_dvfs_init_rails(struct dvfs_rail *rails[], int n)
+{
+        int i;
+
+        mutex_lock(&dvfs_lock);
+
+        for (i = 0; i < n; i++) {
+                INIT_LIST_HEAD(&rails[i]->dvfs);
+                INIT_LIST_HEAD(&rails[i]->relationships_from);
+                INIT_LIST_HEAD(&rails[i]->relationships_to);
+                rails[i]->millivolts = rails[i]->nominal_millivolts;
+                rails[i]->new_millivolts = rails[i]->nominal_millivolts;
+                if (!rails[i]->step)
+                        rails[i]->step = rails[i]->max_millivolts;
+
+                list_add_tail(&rails[i]->node, &dvfs_rail_list);
+        }
+
+        mutex_unlock(&dvfs_lock);
+
+        return 0;
+};
+
+static int dvfs_solve_relationship(struct dvfs_relationship *rel)
+{
+        return rel->solve(rel->from, rel->to);
+}
+
+/* rail statistic - called during rail init, or under dfs_lock, or with
+   CPU0 only on-line, and interrupts disabled */
+static void dvfs_rail_stats_init(struct dvfs_rail *rail, int millivolts)
+{
+        rail->stats.last_update = ktime_get();
+        if (millivolts >= rail->min_millivolts) {
+                int i = 1 + (2 * (millivolts - rail->min_millivolts) *
+                        DVFS_RAIL_STATS_SCALE + DVFS_RAIL_STATS_BIN) /
+                        (2 * DVFS_RAIL_STATS_BIN);
+                rail->stats.last_index = min(i, DVFS_RAIL_STATS_TOP_BIN);
+        }
+
+        if (rail->max_millivolts >
+            rail->min_millivolts + DVFS_RAIL_STATS_RANGE)
+                pr_warn("tegra_dvfs: %s: stats above %d mV will be squashed\n",
+                        rail->reg_id,
+                        rail->min_millivolts + DVFS_RAIL_STATS_RANGE);
+}
+
+static void dvfs_rail_stats_update(
+        struct dvfs_rail *rail, int millivolts, ktime_t now)
+{
+        rail->stats.time_at_mv[rail->stats.last_index] = ktime_add(
+                rail->stats.time_at_mv[rail->stats.last_index], ktime_sub(
+                        now, rail->stats.last_update));
+        rail->stats.last_update = now;
+
+        if (rail->stats.off)
+                return;
+
+        if (millivolts >= rail->min_millivolts) {
+                int i = 1 + (2 * (millivolts - rail->min_millivolts) *
+                        DVFS_RAIL_STATS_SCALE + DVFS_RAIL_STATS_BIN) /
+                        (2 * DVFS_RAIL_STATS_BIN);
+                rail->stats.last_index = min(i, DVFS_RAIL_STATS_TOP_BIN);
+        } else if (millivolts == 0)
+                        rail->stats.last_index = 0;
+}
+
+static void dvfs_rail_stats_pause(struct dvfs_rail *rail,
+                                  ktime_t delta, bool on)
+{
+        int i = on ? rail->stats.last_index : 0;
+        rail->stats.time_at_mv[i] = ktime_add(rail->stats.time_at_mv[i], delta);
+}
+
+void tegra_dvfs_rail_off(struct dvfs_rail *rail, ktime_t now)
+{
+        if (rail) {
+                dvfs_rail_stats_update(rail, 0, now);
+                rail->stats.off = true;
+        }
+}
+
+void tegra_dvfs_rail_on(struct dvfs_rail *rail, ktime_t now)
+{
+        if (rail) {
+                rail->stats.off = false;
+                dvfs_rail_stats_update(rail, rail->millivolts, now);
+        }
+}
+
+void tegra_dvfs_rail_pause(struct dvfs_rail *rail, ktime_t delta, bool on)
+{
+        if (rail)
+                dvfs_rail_stats_pause(rail, delta, on);
+}
+
+/* Sets the voltage on a dvfs rail to a specific value, and updates any
+ * rails that depend on this rail. */
+static int dvfs_rail_set_voltage(struct dvfs_rail *rail, int millivolts)
+{
+        int ret = 0;
+        struct dvfs_relationship *rel;
+        int step = (millivolts > rail->millivolts) ? rail->step : -rail->step;
+        int i;
+        int steps;
+        bool jmp_to_zero;
+
+        if (!rail->reg) {
+                if (millivolts == rail->millivolts)
+                        return 0;
+                else
+                        return -EINVAL;
+        }
+
+        if (rail->disabled)
+                return 0;
+
+        rail->resolving_to = true;
+        jmp_to_zero = rail->jmp_to_zero &&
+                        ((millivolts == 0) || (rail->millivolts == 0));
+        steps = jmp_to_zero ? 1 :
+                DIV_ROUND_UP(abs(millivolts - rail->millivolts), rail->step);
+
+        for (i = 0; i < steps; i++) {
+                if (!jmp_to_zero &&
+                    (abs(millivolts - rail->millivolts) > rail->step))
+                        rail->new_millivolts = rail->millivolts + step;
+                else
+                        rail->new_millivolts = millivolts;
+
+                /* Before changing the voltage, tell each rail that depends
+                 * on this rail that the voltage will change.
+                 * This rail will be the "from" rail in the relationship,
+                 * the rail that depends on this rail will be the "to" rail.
+                 * from->millivolts will be the old voltage
+                 * from->new_millivolts will be the new voltage */
+                list_for_each_entry(rel, &rail->relationships_to, to_node) {
+                        ret = dvfs_rail_update(rel->to);
+                        if (ret)
+                                goto out;
+                }
+
+                if (!rail->disabled) {
+                        rail->updating = true;
+                        ret = regulator_set_voltage(rail->reg,