PM: Introduce devfreq: generic DVFS framework with device-specific OPPs

With OPPs, a device may have multiple operable frequency and voltage
sets. However, there can be multiple possible operable sets and a system
will need to choose one from them. In order to reduce the power
consumption (by reducing frequency and voltage) without affecting the
performance too much, a Dynamic Voltage and Frequency Scaling (DVFS)
scheme may be used.

This patch introduces the DVFS capability to non-CPU devices with OPPs.
DVFS is a techique whereby the frequency and supplied voltage of a
device is adjusted on-the-fly. DVFS usually sets the frequency as low
as possible with given conditions (such as QoS assurance) and adjusts
voltage according to the chosen frequency in order to reduce power
consumption and heat dissipation.

The generic DVFS for devices, devfreq, may appear quite similar with
/drivers/cpufreq.  However, cpufreq does not allow to have multiple
devices registered and is not suitable to have multiple heterogenous
devices with different (but simple) governors.

Normally, DVFS mechanism controls frequency based on the demand for
the device, and then, chooses voltage based on the chosen frequency.
devfreq also controls the frequency based on the governor's frequency
recommendation and let OPP pick up the pair of frequency and voltage
based on the recommended frequency. Then, the chosen OPP is passed to
device driver's "target" callback.

When PM QoS is going to be used with the devfreq device, the device
driver should enable OPPs that are appropriate with the current PM QoS
requests. In order to do so, the device driver may call opp_enable and
opp_disable at the notifier callback of PM QoS so that PM QoS's
update_target() call enables the appropriate OPPs. Note that at least
one of OPPs should be enabled at any time; be careful when there is a
transition.

Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
Reviewed-by: Mike Turquette <mturquette@ti.com>
Acked-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

4 files changed, 596 insertions, 0 deletions

diff --git a/drivers/devfreq/Kconfig b/drivers/devfreq/Kconfig
new file mode 100644
index 000000000000..1fb42de4f420
--- /dev/null
+++ b/drivers/devfreq/Kconfig
@@ -0,0 +1,39 @@
+config ARCH_HAS_DEVFREQ
+        bool
+        depends on ARCH_HAS_OPP
+        help
+          Denotes that the architecture supports DEVFREQ. If the architecture
+          supports multiple OPP entries per device and the frequency of the
+          devices with OPPs may be altered dynamically, the architecture
+          supports DEVFREQ.
+
+menuconfig PM_DEVFREQ
+        bool "Generic Dynamic Voltage and Frequency Scaling (DVFS) support"
+        depends on PM_OPP && ARCH_HAS_DEVFREQ
+        help
+          With OPP support, a device may have a list of frequencies and
+          voltages available. DEVFREQ, a generic DVFS framework can be
+          registered for a device with OPP support in order to let the
+          governor provided to DEVFREQ choose an operating frequency
+          based on the OPP's list and the policy given with DEVFREQ.
+
+          Each device may have its own governor and policy. DEVFREQ can
+          reevaluate the device state periodically and/or based on the
+          OPP list changes (each frequency/voltage pair in OPP may be
+          disabled or enabled).
+
+          Like some CPUs with CPUFREQ, a device may have multiple clocks.
+          However, because the clock frequencies of a single device are
+          determined by the single device's state, an instance of DEVFREQ
+          is attached to a single device and returns a "representative"
+          clock frequency from the OPP of the device, which is also attached
+          to a device by 1-to-1. The device registering DEVFREQ takes the
+          responsiblity to "interpret" the frequency listed in OPP and
+          to set its every clock accordingly with the "target" callback
+          given to DEVFREQ.
+
+if PM_DEVFREQ
+
+comment "DEVFREQ Drivers"
+
+endif # PM_DEVFREQ
diff --git a/drivers/devfreq/Makefile b/drivers/devfreq/Makefile
new file mode 100644
index 000000000000..168934a12b38
--- /dev/null
+++ b/drivers/devfreq/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_PM_DEVFREQ)        += devfreq.o
diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
new file mode 100644
index 000000000000..f3100b19f798
--- /dev/null
+++ b/drivers/devfreq/devfreq.c
@@ -0,0 +1,532 @@
+/*
+ * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
+ *          for Non-CPU Devices.
+ *
+ * Copyright (C) 2011 Samsung Electronics
+ *      MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/opp.h>
+#include <linux/devfreq.h>
+#include <linux/workqueue.h>
+#include <linux/platform_device.h>
+#include <linux/list.h>
+#include <linux/printk.h>
+#include <linux/hrtimer.h>
+#include "governor.h"
+
+struct class *devfreq_class;
+
+/*
+ * devfreq_work periodically monitors every registered device.
+ * The minimum polling interval is one jiffy. The polling interval is
+ * determined by the minimum polling period among all polling devfreq
+ * devices. The resolution of polling interval is one jiffy.
+ */
+static bool polling;
+static struct workqueue_struct *devfreq_wq;
+static struct delayed_work devfreq_work;
+
+/* wait removing if this is to be removed */
+static struct devfreq *wait_remove_device;
+
+/* The list of all device-devfreq */
+static LIST_HEAD(devfreq_list);
+static DEFINE_MUTEX(devfreq_list_lock);
+
+/**
+ * find_device_devfreq() - find devfreq struct using device pointer
+ * @dev:        device pointer used to lookup device devfreq.
+ *
+ * Search the list of device devfreqs and return the matched device's
+ * devfreq info. devfreq_list_lock should be held by the caller.
+ */
+static struct devfreq *find_device_devfreq(struct device *dev)
+{
+        struct devfreq *tmp_devfreq;
+
+        if (unlikely(IS_ERR_OR_NULL(dev))) {
+                pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
+                return ERR_PTR(-EINVAL);
+        }
+        WARN(!mutex_is_locked(&devfreq_list_lock),
+             "devfreq_list_lock must be locked.");
+
+        list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
+                if (tmp_devfreq->dev.parent == dev)
+                        return tmp_devfreq;
+        }
+
+        return ERR_PTR(-ENODEV);
+}
+
+/**
+ * update_devfreq() - Reevaluate the device and configure frequency.
+ * @devfreq:    the devfreq instance.
+ *
+ * Note: Lock devfreq->lock before calling update_devfreq
+ *       This function is exported for governors.
+ */
+int update_devfreq(struct devfreq *devfreq)
+{
+        unsigned long freq;
+        int err = 0;
+
+        if (!mutex_is_locked(&devfreq->lock)) {
+                WARN(true, "devfreq->lock must be locked by the caller.\n");
+                return -EINVAL;
+        }
+
+        /* Reevaluate the proper frequency */
+        err = devfreq->governor->get_target_freq(devfreq, &freq);
+        if (err)
+                return err;
+
+        err = devfreq->profile->target(devfreq->dev.parent, &freq);
+        if (err)
+                return err;
+
+        devfreq->previous_freq = freq;
+        return err;
+}
+
+/**
+ * devfreq_notifier_call() - Notify that the device frequency requirements
+ *                         has been changed out of devfreq framework.
+ * @nb          the notifier_block (supposed to be devfreq->nb)
+ * @type        not used
+ * @devp        not used
+ *
+ * Called by a notifier that uses devfreq->nb.
+ */
+static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
+                                 void *devp)
+{
+        struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
+        int ret;
+
+        mutex_lock(&devfreq->lock);
+        ret = update_devfreq(devfreq);
+        mutex_unlock(&devfreq->lock);
+
+        return ret;
+}
+
+/**
+ * _remove_devfreq() - Remove devfreq from the device.
+ * @devfreq:    the devfreq struct
+ * @skip:       skip calling device_unregister().
+ *
+ * Note that the caller should lock devfreq->lock before calling
+ * this. _remove_devfreq() will unlock it and free devfreq
+ * internally. devfreq_list_lock should be locked by the caller
+ * as well (not relased at return)
+ *
+ * Lock usage:
+ * devfreq->lock: locked before call.
+ *                unlocked at return (and freed)
+ * devfreq_list_lock: locked before call.
+ *                    kept locked at return.
+ *                    if devfreq is centrally polled.
+ *