From patchwork Tue Apr 26 08:43:21 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: MyungJoo Ham X-Patchwork-Id: 731962 Received: from smtp1.linux-foundation.org (smtp1.linux-foundation.org [140.211.169.13]) by demeter1.kernel.org (8.14.4/8.14.3) with ESMTP id p3Q8lFuj002905 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=FAIL) for ; Tue, 26 Apr 2011 08:47:35 GMT Received: from daredevil.linux-foundation.org (localhost [127.0.0.1]) by smtp1.linux-foundation.org (8.14.2/8.13.5/Debian-3ubuntu1.1) with ESMTP id p3Q8ilog014507; Tue, 26 Apr 2011 01:44:58 -0700 Received: from mailout4.samsung.com (mailout4.samsung.com [203.254.224.34]) by smtp1.linux-foundation.org (8.14.2/8.13.5/Debian-3ubuntu1.1) with ESMTP id p3Q8hSwl014437 for ; Tue, 26 Apr 2011 01:43:32 -0700 Received: from epcpsbgm1.samsung.com (mailout4.samsung.com [203.254.224.34]) by mailout4.samsung.com (Oracle Communications Messaging Exchange Server 7u4-19.01 64bit (built Sep 7 2010)) with ESMTP id <0LK900EM545RO4B0@mailout4.samsung.com> for linux-pm@lists.linux-foundation.org; Tue, 26 Apr 2011 17:43:23 +0900 (KST) X-AuditID: cbfee61a-b7cdcae000005cc9-e8-4db685aad5cc Received: from epmmp2 ( [203.254.227.17]) by epcpsbgm1.samsung.com (MMPCPMTA) with SMTP id 21.CD.23753.AA586BD4; Tue, 26 Apr 2011 17:43:22 +0900 (KST) Received: from TNRNDGASPAPP1.tn.corp.samsungelectronics.net ([165.213.149.150]) by mmp2.samsung.com (iPlanet Messaging Server 5.2 Patch 2 (built Jul 14 2004)) with ESMTPA id <0LK9000W548BMQ@mmp2.samsung.com> for linux-pm@lists.linux-foundation.org; Tue, 26 Apr 2011 17:43:23 +0900 (KST) Received: from Hisui ([165.213.219.116]) by TNRNDGASPAPP1.tn.corp.samsungelectronics.net with Microsoft SMTPSVC(6.0.3790.4675); Tue, 26 Apr 2011 17:43:22 +0900 Date: Tue, 26 Apr 2011 17:43:21 +0900 From: MyungJoo Ham To: linux-pm@lists.linux-foundation.org Message-id: <1303807401-16350-1-git-send-email-myungjoo.ham@samsung.com> X-Mailer: git-send-email 1.7.1 X-OriginalArrivalTime: 26 Apr 2011 08:43:22.0536 (UTC) FILETIME=[0014BA80:01CC03EE] X-Brightmail-Tracker: AAAAAA== Received-SPF: pass (localhost is always allowed.) X-Spam-Status: No, hits=-12.181 required=5 tests=AWL, BAYES_00, OSDL_HEADER_SUBJECT_BRACKETED, SAMSUNG_WEBMAIL_OSDL X-Spam-Checker-Version: SpamAssassin 3.2.4-osdl_revision__1.47__ X-MIMEDefang-Filter: lf$Revision: 1.188 $ X-Scanned-By: MIMEDefang 2.63 on 140.211.169.21 Cc: Nishanth Menon , Len Brown , Kevin Hilman , Greg Kroah-Hartman , Kyungmin Park Subject: [linux-pm] [RFC PATCH] PM: Introduce generic DVFS framework with device-specific OPPs X-BeenThere: linux-pm@lists.linux-foundation.org X-Mailman-Version: 2.1.9 Precedence: list List-Id: Linux power management List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: linux-pm-bounces@lists.linux-foundation.org Errors-To: linux-pm-bounces@lists.linux-foundation.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.6 (demeter1.kernel.org [140.211.167.41]); Tue, 26 Apr 2011 08:47:35 +0000 (UTC) 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 DVFS scheme may be used. This patch introduces the DVFS capability to non-CPU devices with OPPs. In this RTC version, we do not have specific gorvernors or device support, yet. However, we plan to test and use DVFS scheme on DRAM/BUS/GPU for our test boards (Exynos4-NURI), which have DVFS capability and have seperated DVFS-like drivers without any common code. The generic DVFS 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. Signed-off-by: MyungJoo Ham Signed-off-by: Kyungmin Park --- drivers/base/power/Makefile | 1 + drivers/base/power/dvfs.c | 401 +++++++++++++++++++++++++++++++++++++++++++ drivers/base/power/opp.c | 7 + include/linux/dvfs.h | 69 ++++++++ kernel/power/Kconfig | 9 + 5 files changed, 487 insertions(+), 0 deletions(-) create mode 100644 drivers/base/power/dvfs.c create mode 100644 include/linux/dvfs.h diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile index 118c1b9..4d92d7f 100644 --- a/drivers/base/power/Makefile +++ b/drivers/base/power/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP) += main.o wakeup.o obj-$(CONFIG_PM_RUNTIME) += runtime.o obj-$(CONFIG_PM_TRACE_RTC) += trace.o obj-$(CONFIG_PM_OPP) += opp.o +obj-$(CONFIG_PM_GENERIC_DVFS) += dvfs.o ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG ccflags-$(CONFIG_PM_VERBOSE) += -DDEBUG diff --git a/drivers/base/power/dvfs.c b/drivers/base/power/dvfs.c new file mode 100644 index 0000000..867ad70 --- /dev/null +++ b/drivers/base/power/dvfs.c @@ -0,0 +1,401 @@ +/* + * Generic DVFS Interface for Non-CPU Devices + * Based on OPP. + * + * Copyright (C) 2011 Samsung Electronics + * MyungJoo Ham + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DVFS_INTERVAL 20 +/** + * struct dvfs - Device DVFS structure + * @node list node - contains the devices with DVFS that have been + * registered. + * @dev device pointer + * @profile device-specific dvfs profile + * @governor method how to choose frequency based on the usage. + * @previous_freq previously configured frequency value. + * @next_polling the number of remaining "dvfs_monitor" executions to + * reevaluate frequency/voltage of the device. Set by + * profile's polling_ms interval. + * @tickle positive if DVFS-tickling is activated for the device. + * at each executino of dvfs_monitor, tickle is decremented. + * User may tickle a device-dvfs in order to set maximum + * frequency instaneously with some guaranteed duration. + * + * This structure stores the DVFS information for a give device. + */ +struct dvfs { + struct list_head node; + + struct device *dev; + struct dvfs_device_profile *profile; + struct dvfs_governor *governor; + + unsigned long previous_freq; + unsigned int next_polling; + unsigned int tickle; +}; + +/* + * dvfs_work periodically (given by DVFS_INTERVAL) monitors every + * registered device. + */ +static struct delayed_work dvfs_work; +/* The list of all device-dvfs */ +static LIST_HEAD(dvfs_list); +/* Exclusive access to dvfs_list and its elements */ +static DEFINE_MUTEX(dvfs_list_lock); + +/** + * find_device_dvfs() - find dvfs struct using device pointer + * @dev: device pointer used to lookup device DVFS. + * + * Search the list of device DVFSs and return the matched device's DVFS info. + */ +static struct dvfs *find_device_dvfs(struct device *dev) +{ + struct dvfs *tmp_dvfs, *dvfs = ERR_PTR(-ENODEV); + + if (unlikely(IS_ERR_OR_NULL(dev))) { + pr_err("%s: Invalid parameters\n", __func__); + return ERR_PTR(-EINVAL); + } + + list_for_each_entry(tmp_dvfs, &dvfs_list, node) { + if (tmp_dvfs->dev == dev) { + dvfs = tmp_dvfs; + break; + } + } + + return dvfs; +} + +/** + * dvfs_next_polling() - the number of dvfs-monitor iterations to satisfy + * the given polling interval. The interval is rounded by + * dvfs-monitor poling interval (DVFS_INTERVAL) with ceiling + * function. + * @ms: the length of polling interval in milli-second + */ +static unsigned int dvfs_next_polling(int ms) +{ + unsigned int ret; + + if (ms <= 0) + return 0; + + ret = ms / DVFS_INTERVAL; + if (ms % DVFS_INTERVAL) + ret++; + + return ret; +} + +/** + * dvfs_do() - Check the usage profile of a given device and configure + * frequency and voltage accordingly + * @dvfs: DVFS info of the given device + */ +static int dvfs_do(struct dvfs *dvfs) +{ + struct dvfs_usage_profile profile; + struct opp *opp; + unsigned long freq; + int err; + + err = dvfs->profile->get_usage_profile(dvfs->dev, &profile); + if (err) { + dev_err(dvfs->dev, "%s: Cannot get usage profile (%d)\n", + __func__, err); + return err; + } + + err = dvfs->governor->get_target_freq(&profile, dvfs->governor, &freq); + if (err) { + dev_err(dvfs->dev, "%s: Cannot get target frequency (%d)\n", + __func__, err); + return err; + } + + opp = opp_find_freq_ceil(dvfs->dev, &freq); + if (opp == ERR_PTR(-ENODEV)) + opp = opp_find_freq_floor(dvfs->dev, &freq); + + if (IS_ERR(opp)) { + dev_err(dvfs->dev, "%s: Cannot find opp with %luHz.\n", + __func__, freq); + return PTR_ERR(opp); + } + + freq = opp_get_freq(opp); + if (dvfs->previous_freq != freq) { + err = dvfs->profile->target(dvfs->dev, freq, + opp_get_voltage(opp)); + dvfs->previous_freq = freq; + } + + if (err) + dev_err(dvfs->dev, "%s: Cannot set %luHz/%luuV\n", __func__, + opp_get_freq(opp), opp_get_voltage(opp)); + return err; +} + +/** + * dvfs_monitor() - Regularly run dvfs_do() and support device DVFS tickle. + * @work: the work struct used to run dvfs_monitor periodically. + */ +static void dvfs_monitor(struct work_struct *work) +{ + struct dvfs *dvfs; + + mutex_lock(&dvfs_list_lock); + + list_for_each_entry(dvfs, &dvfs_list, node) { + if (dvfs->next_polling == 0) + continue; + if (dvfs->tickle) { + dvfs->tickle--; + continue; + } + if (dvfs->next_polling == 1) { + dvfs_do(dvfs); + dvfs->next_polling = dvfs_next_polling( + dvfs->profile->polling_ms); + } else { + dvfs->next_polling--; + } + } + + schedule_delayed_work(&dvfs_work, msecs_to_jiffies(DVFS_INTERVAL)); + mutex_unlock(&dvfs_list_lock); +} + +/** + * dvfs_add_device() - Add dvfs feature to the device + * @dev: the device to add dvfs feature. + * @profile: device-specific profile to run dvfs. + * @governor: the policy to choose frequency. + */ +int dvfs_add_device(struct device *dev, struct dvfs_device_profile *profile, + struct dvfs_governor *governor) +{ + struct dvfs *new_dvfs, *dvfs; + struct cpufreq_frequency_table *table; + int err; + + if (!dev || !profile || !governor) { + dev_err(dev, "%s: Invalid parameters.\n", __func__); + return -EINVAL; + } + + err = opp_init_cpufreq_table(dev, &table); + if (err) { + dev_err(dev, "%s: Device OPP cannot provide DVFS table (%d)\n", + __func__, err); + return err; + } + + new_dvfs = kzalloc(sizeof(struct dvfs), GFP_KERNEL); + if (!new_dvfs) { + dev_err(dev, "%s: Unable to create DVFS for the device\n", + __func__); + return -ENOMEM; + } + + mutex_lock(&dvfs_list_lock); + + dvfs = find_device_dvfs(dev); + if (!IS_ERR(dvfs)) { + dev_err(dev, "%s: Unable to create DVFS for the device. " + "It already has one.\n", __func__); + mutex_unlock(&dvfs_list_lock); + kfree(new_dvfs); + return -EINVAL; + } + + new_dvfs->dev = dev; + new_dvfs->profile = profile; + new_dvfs->governor = governor; + new_dvfs->next_polling = dvfs_next_polling(profile->polling_ms); + new_dvfs->previous_freq = 0; + + list_add(&new_dvfs->node, &dvfs_list); + + mutex_unlock(&dvfs_list_lock); + + return 0; +} + +/** + * dvfs_remove_device() - Remove DVFS feature from a device. + * @device: the device to remove dvfs feature. + */ +int dvfs_remove_device(struct device *dev) +{ + struct dvfs *dvfs; + + if (!dev) + return -EINVAL; + + mutex_lock(&dvfs_list_lock); + dvfs = find_device_dvfs(dev); + if (IS_ERR(dvfs)) { + dev_err(dev, "%s: Unable to find DVFS entry for the device.\n", + __func__); + mutex_unlock(&dvfs_list_lock); + return -EINVAL; + } + + list_del(&dvfs->node); + + kfree(dvfs); + + mutex_unlock(&dvfs_list_lock); + + return 0; +} + +/** + * dvfs_update() - Notify that the device OPP has been changed. + * @dev: the device whose OPP has been changed. + * @may_not_exist: do not print error message even if the device + * does not have dvfs entry. + */ +int dvfs_update(struct device *dev, bool may_not_exist) +{ + struct dvfs *dvfs; + int err = 0; + + mutex_lock(&dvfs_list_lock); + dvfs = find_device_dvfs(dev); + if (!IS_ERR(dvfs)) { + if (dvfs->tickle) { + unsigned long freq = dvfs->profile->max_freq; + struct opp *opp = opp_find_freq_floor(dvfs->dev, &freq); + + freq = opp_get_freq(opp); + if (dvfs->previous_freq != freq) { + err = dvfs->profile->target(dvfs->dev, freq, + opp_get_voltage(opp)); + dvfs->previous_freq = freq; + } + } else { + err = dvfs_do(dvfs); + } + } + mutex_unlock(&dvfs_list_lock); + + if (IS_ERR(dvfs)) { + if (may_not_exist && PTR_ERR(dvfs) == -EINVAL) + return 0; + + dev_err(dev, "%s: Device DVFS not found (%ld)\n", __func__, + PTR_ERR(dvfs)); + return PTR_ERR(dvfs); + } + + return err; +} + +/** + * dvfs_tickle_device() - Guarantee maximum operation speed for a while + * instaneously. + * @dev: the device to be tickled. + * @duration_ms: the duration of tickle effect. + * + * Tickle sets the device at the maximum frequency instaneously and + * the maximul frequency is guaranteed to be used for the given duration. + * For faster user reponse time, an input event may tickle a related device + * so that the input event does not need to wait for the DVFS to react with + * normal interval. + */ +int dvfs_tickle_device(struct device *dev, unsigned long duration_ms) +{ + struct dvfs *dvfs; + struct opp *opp; + unsigned long freq; + int err = 0; + + mutex_lock(&dvfs_list_lock); + dvfs = find_device_dvfs(dev); + if (!IS_ERR(dvfs)) { + freq = dvfs->profile->max_freq; + opp = opp_find_freq_floor(dvfs->dev, &freq); + freq = opp_get_freq(opp); + if (dvfs->previous_freq != freq) { + err = dvfs->profile->target(dvfs->dev, freq, + opp_get_voltage(opp)); + dvfs->previous_freq = freq; + } + if (err) + dev_err(dev, "%s: Cannot set frequency.\n", __func__); + else + dvfs->tickle = dvfs_next_polling(duration_ms); + } + mutex_unlock(&dvfs_list_lock); + + if (IS_ERR(dvfs)) { + dev_err(dev, "%s: Cannot find dvfs.\n", __func__); + err = PTR_ERR(dvfs); + } + + return err; +} + +#ifdef CONFIG_PM_SLEEP +static int dvfs_pause(struct device *dev) +{ + cancel_delayed_work_sync(&dvfs_work); + return 0; +} + +static void dvfs_continue(struct device *dev) +{ + schedule_delayed_work(&dvfs_work, msecs_to_jiffies(DVFS_INTERVAL)); +} +#else +#define dvfs_pause NULL +#define dvfs_continue NULL +#endif +static const struct dev_pm_ops dvfs_pm = { + .prepare = dvfs_pause, + .complete = dvfs_continue, +}; +static struct platform_driver dvfs_pm_drv = { + .driver = { + .name = "generic_dvfs_pm", + .pm = &dvfs_pm, + }, +}; +static struct platform_device dvfs_pm_dev = { + .name = "generic_dvfs_pm", +}; + +static int __init dvfs_init(void) +{ + platform_driver_register(&dvfs_pm_drv); + platform_device_register(&dvfs_pm_dev); + + INIT_DELAYED_WORK_DEFERRABLE(&dvfs_work, dvfs_monitor); + schedule_delayed_work(&dvfs_work, msecs_to_jiffies(DVFS_INTERVAL)); + + return 0; +} +late_initcall(dvfs_init); diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c index 56a6899..df74655 100644 --- a/drivers/base/power/opp.c +++ b/drivers/base/power/opp.c @@ -21,6 +21,7 @@ #include #include #include +#include /* * Internal data structure organization with the OPP layer library is as @@ -428,6 +429,9 @@ int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt) list_add_rcu(&new_opp->node, head); mutex_unlock(&dev_opp_list_lock); + /* Notify generic dvfs for the change */ + dvfs_update(dev, true); + return 0; } @@ -512,6 +516,9 @@ unlock: mutex_unlock(&dev_opp_list_lock); out: kfree(new_opp); + + /* Notify generic dvfs for the change */ + dvfs_update(dev, true); return r; } diff --git a/include/linux/dvfs.h b/include/linux/dvfs.h new file mode 100644 index 0000000..de3e53d --- /dev/null +++ b/include/linux/dvfs.h @@ -0,0 +1,69 @@ +/* + * Generic DVFS Interface for Non-CPU Devices + * + * Copyright (C) 2011 Samsung Electronics + * MyungJoo Ham + * + * 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. + */ + +#ifndef __LINUX_DVFS_H__ +#define __LINUX_DVFS_H__ + +struct dvfs; + +struct dvfs_usage_profile { + /* both since the last measure */ + unsigned long total_time; + unsigned long busy_time; +}; + +struct dvfs_device_profile { + unsigned long max_freq; /* may be larger than the actual value */ + int (*target)(struct device *dev, unsigned long freq, + unsigned long u_volt); + int (*get_usage_profile)(struct device *dev, + struct dvfs_usage_profile *profile); + int polling_ms; /* 0 for at opp change only */ +}; + +struct dvfs_governor { + void *data; /* private data for get_target_freq */ + int (*get_target_freq)(struct dvfs_usage_profile *profile, + struct dvfs_governor *this, unsigned long *freq); +}; + +#if defined(CONFIG_PM_GENERIC_DVFS) +extern int dvfs_add_device(struct device *ev, + struct dvfs_device_profile *profile, + struct dvfs_governor *governor); +extern int dvfs_remove_device(struct device *dev); +extern int dvfs_update(struct device *dev, bool may_not_exist); +extern int dvfs_tickle_device(struct device *dev, unsigned long duration_ms); +#else /* !CONFIG_PM_GENERIC_DVFS */ +static int dvfs_add_device(struct device *ev, + struct dvfs_device_profile *profile, + struct dvfs_governor *governor) +{ + return 0; +} + +static int dvfs_remove_device(struct device *dev) +{ + return 0; +} + +static int dvfs_update(struct device *dev, bool may_not_exist) +{ + return 0; +} + +static int dvfs_tickle_device(struct device *dev, unsigned long duration_ms) +{ + return 0; +} +#endif /* CONFIG_PM_GENERIC_DVFS */ + +#endif /* __LINUX_DVFS_H__ */ diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 4603f08..7d191ec 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -225,3 +225,12 @@ config PM_OPP representing individual voltage domains and provides SOC implementations a ready to use framework to manage OPPs. For more information, read + +config PM_GENERIC_DVFS + bool "Generic DVFS framework" + depends on PM_OPP + help + With OPP support, a device may have a list of frequencies and + voltages available. Generic DVFS framework provides a method to + control frequency/voltage of a device with OPP with given profile + and governor per device.