From patchwork Thu Mar 24 04:25:15 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chanwoo Choi X-Patchwork-Id: 8657491 Return-Path: X-Original-To: patchwork-linux-pm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 631C5C0553 for ; Thu, 24 Mar 2016 04:30:22 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 2B5FA20375 for ; Thu, 24 Mar 2016 04:30:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3F50220376 for ; Thu, 24 Mar 2016 04:30:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932803AbcCXE3a (ORCPT ); Thu, 24 Mar 2016 00:29:30 -0400 Received: from mailout2.samsung.com ([203.254.224.25]:42767 "EHLO mailout2.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751281AbcCXEZk (ORCPT ); Thu, 24 Mar 2016 00:25:40 -0400 Received: from epcpsbgr1.samsung.com (u141.gpu120.samsung.co.kr [203.254.230.141]) by mailout2.samsung.com (Oracle Communications Messaging Server 7.0.5.31.0 64bit (built May 5 2014)) with ESMTP id <0O4J02UEY0ALETE0@mailout2.samsung.com>; Thu, 24 Mar 2016 13:25:33 +0900 (KST) Received: from epcpsbgm1new.samsung.com ( [172.20.52.115]) by epcpsbgr1.samsung.com (EPCPMTA) with SMTP id D8.BD.04949.D3C63F65; Thu, 24 Mar 2016 13:25:33 +0900 (KST) X-AuditID: cbfee68d-f79646d000001355-2f-56f36c3d6033 Received: from epmmp1.local.host ( [203.254.227.16]) by epcpsbgm1new.samsung.com (EPCPMTA) with SMTP id AD.01.13906.D3C63F65; Thu, 24 Mar 2016 13:25:33 +0900 (KST) Received: from chan.10.32.193.11 ([10.113.62.212]) by mmp1.samsung.com (Oracle Communications Messaging Server 7.0.5.31.0 64bit (built May 5 2014)) with ESMTPA id <0O4J007XC0AJOI80@mmp1.samsung.com>; Thu, 24 Mar 2016 13:25:32 +0900 (KST) From: Chanwoo Choi To: myungjoo.ham@samsung.com, kyungmin.park@samsung.com, k.kozlowski@samsung.com, kgene@kernel.org Cc: rjw@rjwysocki.net, robh+dt@kernel.org, pawel.moll@arm.com, mark.rutland@arm.com, ijc+devicetree@hellion.org.uk, galak@codeaurora.org, linux@arm.linux.org.uk, linux.amoon@gmail.com, tjakobi@math.uni-bielefeld.de, cw00.choi@samsung.com, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, linux-samsung-soc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, devicetree@vger.kernel.org Subject: [PATCH v5 06/21] PM / devfreq: Add new passive governor Date: Thu, 24 Mar 2016 13:25:15 +0900 Message-id: <1458793530-31897-7-git-send-email-cw00.choi@samsung.com> X-Mailer: git-send-email 1.8.0 In-reply-to: <1458793530-31897-1-git-send-email-cw00.choi@samsung.com> References: <1458793530-31897-1-git-send-email-cw00.choi@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFtrIIsWRmVeSWpSXmKPExsWyRsSkWNc253OYwf8VShbXvzxntZh/5Byr Rf+bhawW516tZLR4/cLQov/xa2aLs01v2C02Pb7GanF51xw2i8+9RxgtZpzfx2SxbuMtdovb l3ktll6/yGRxu3EFm8WE6WtZLM6cvsRq0br3CLtF2+oPrA7CHmvmrWH0aGnuYfO43NfL5LFz 1l12j5XLv7B5bFrVyeaxeUm9x79j7B5brrazePRtWcXo8XmTXAB3FJdNSmpOZllqkb5dAlfG 0Zs7GQuORVVs6DBuYFzr3cXIySEhYCLx+EMvE4QtJnHh3nq2LkYuDiGBFYwS1xZuZ4Qp+rNs MQtEYimjxPrm/+wgCSGBL4wSqx/Xg9hsAloS+1/cYAOxRQRSJB4/PAk2iVlgCrPE8unNLCAJ YQEHiUWbboLZLAKqEjM2rwXbwCvgKjFv0hk2iG1yEh/2PAJbwCngJjG1oYkFYpmrxNPHm1hB hkoIzOSQOP17PSPEIAGJb5MPARVxACVkJTYdYIaYIylxcMUNlgmMwgsYGVYxiqYWJBcUJ6UX GeoVJ+YWl+al6yXn525iBMbk6X/Pencw3j5gfYhRgINRiYe3geNzmBBrYllxZe4hRlOgDROZ pUST84GRn1cSb2hsZmRhamJqbGRuaaYkzqso9TNYSCA9sSQ1OzW1ILUovqg0J7X4ECMTB6dU A+NJ3/K3Mka3/gRfFPX78eRiJ4f1Cp1tznfO/Joe+dvK+BDXtsmr32q6TpLf6rXP79qKxsts Mg7yE45eeHV9g+VjLfuqdt5fr17NFH37ovfOtc2N8zoXvv7OJT5RKrEwcNurpRyq22QNfA/k zN30LsEj9ZCyasbNBXU/xLbGTto+YcuCP/KCCw6uVmIpzkg01GIuKk4EAJFlVVbEAgAA X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFvrHIsWRmVeSWpSXmKPExsVy+t9jAV3bnM9hBrOvSVlc//Kc1WL+kXOs Fv1vFrJanHu1ktHi9QtDi/7Hr5ktzja9YbfY9Pgaq8XlXXPYLD73HmG0mHF+H5PFuo232C1u X+a1WHr9IpPF7cYVbBYTpq9lsThz+hKrReveI+wWbas/sDoIe6yZt4bRo6W5h83jcl8vk8fO WXfZPVYu/8LmsWlVJ5vH5iX1Hv+OsXtsudrO4tG3ZRWjx+dNcgHcUQ2MNhmpiSmpRQqpecn5 KZl56bZK3sHxzvGmZgaGuoaWFuZKCnmJuam2Si4+AbpumTlA3ykplCXmlAKFAhKLi5X07TBN CA1x07WAaYzQ9Q0JgusxMkADCWsYM47e3MlYcCyqYkOHcQPjWu8uRk4OCQETiT/LFrNA2GIS F+6tZ+ti5OIQEljKKLG++T87SEJI4AujxOrH9SA2m4CWxP4XN9hAbBGBFInHD0+CNTALTGGW WD69GWySsICDxKJNN8FsFgFViRmb1zKC2LwCrhLzJp1hg9gmJ/FhzyOwBZwCbhJTG5pYIJa5 Sjx9vIl1AiPvAkaGVYwSqQXJBcVJ6bmGeanlesWJucWleel6yfm5mxjBcf9MagfjwV3uhxgF OBiVeHhvcH0OE2JNLCuuzD3EKMHBrCTCuz4cKMSbklhZlVqUH19UmpNafIjRFOiwicxSosn5 wJSUVxJvaGxiZmRpZG5oYWRsriTO+/j/ujAhgfTEktTs1NSC1CKYPiYOTqkGxgDD0FlMm9zf KYUt2sLx/hCXMG+Ia/S7yEq3B1FsdztSzQoPFV8M+cWeqqqTW9f041SPSa16oMn92kvX22J/ zekoW+mQeXbKiU1381292hlXlGp7K1i7PfHli7Rjzn5wsShJYO6G6QGTL1WUfS7UaCrf+Wiy /5ecY/1rJVV5rhsItZ+fvPWKEktxRqKhFnNRcSIAeLi6fREDAAA= DLP-Filter: Pass X-MTR: 20000000000000000@CPGS X-CFilter-Loop: Reflected Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP This patch adds the new passive governor for DEVFREQ framework. The following governors are already present and used for DVFS (Dynamic Voltage and Frequency Scaling) drivers. The following governors are independently used for one device driver which don't give the influence to other device drviers and also don't receive the effect from other device drivers. - ondemand / performance / powersave / userspace The passive governor depends on operation of parent driver with specific governos extremely and is not able to decide the new frequency by oneself. According to the decided new frequency of parent driver with governor, the passive governor uses it to decide the appropriate frequency for own device driver. The passive governor must need the following information from device tree: - the source clock and OPP tables - the instance of parent device For exameple, there are one more devfreq device drivers which need to change their source clock according to their utilization on runtime. But, they share the same power line (e.g., regulator). So, specific device driver is operated as parent with ondemand governor and then the rest device driver with passive governor is influenced by parent device. Suggested-by: Myungjoo Ham [tjakobi: Reported RCU locking issue and cw00.choi fix it.] Reported-by: Tobias Jakobi Signed-off-by: Chanwoo Choi --- drivers/devfreq/Kconfig | 7 ++ drivers/devfreq/Makefile | 1 + drivers/devfreq/devfreq.c | 17 ++++ drivers/devfreq/governor.h | 15 +++ drivers/devfreq/governor_passive.c | 192 +++++++++++++++++++++++++++++++++++++ include/linux/devfreq.h | 3 + 6 files changed, 235 insertions(+) create mode 100644 drivers/devfreq/governor_passive.c diff --git a/drivers/devfreq/Kconfig b/drivers/devfreq/Kconfig index 55ec774f794c..ae689ad375fa 100644 --- a/drivers/devfreq/Kconfig +++ b/drivers/devfreq/Kconfig @@ -64,6 +64,13 @@ config DEVFREQ_GOV_USERSPACE Otherwise, the governor does not change the frequnecy given at the initialization. +config DEVFREQ_GOV_PASSIVE + tristate "Passive" + help + Sets the frequency based on the frequency of its parent devfreq + device. This governor does not change the frequency by itself + through sysfs entries. + comment "DEVFREQ Drivers" config ARM_EXYNOS_BUS_DEVFREQ diff --git a/drivers/devfreq/Makefile b/drivers/devfreq/Makefile index 8af8aaf922a8..2633087d5c63 100644 --- a/drivers/devfreq/Makefile +++ b/drivers/devfreq/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND) += governor_simpleondemand.o obj-$(CONFIG_DEVFREQ_GOV_PERFORMANCE) += governor_performance.o obj-$(CONFIG_DEVFREQ_GOV_POWERSAVE) += governor_powersave.o obj-$(CONFIG_DEVFREQ_GOV_USERSPACE) += governor_userspace.o +obj-$(CONFIG_DEVFREQ_GOV_PASSIVE) += governor_passive.o # DEVFREQ Drivers obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ) += exynos-bus.o diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c index 1d6c803804d5..9f84bbc2994c 100644 --- a/drivers/devfreq/devfreq.c +++ b/drivers/devfreq/devfreq.c @@ -478,7 +478,13 @@ static void _remove_devfreq(struct devfreq *devfreq) dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n"); return; } + + if (devfreq->governor->type == DEVFREQ_GOV_PASSIVE) + devfreq_passive_unregister_notifier(devfreq); + list_del(&devfreq->node); + list_del_init(&devfreq->passive_node); + mutex_unlock(&devfreq_list_lock); if (devfreq->governor) @@ -598,6 +604,17 @@ struct devfreq *devfreq_add_device(struct device *dev, goto err_init; } + if (devfreq->governor->type == DEVFREQ_GOV_PASSIVE) { + struct devfreq *parent_devfreq = (struct devfreq *)data; + list_add(&devfreq->passive_node, &parent_devfreq->passive_node); + + err = devfreq_passive_register_notifier(devfreq); + if (err <0) + goto err_init; + } else { + INIT_LIST_HEAD(&devfreq->passive_node); + } + return devfreq; err_init: diff --git a/drivers/devfreq/governor.h b/drivers/devfreq/governor.h index cf19b923c362..64d1dffcdb43 100644 --- a/drivers/devfreq/governor.h +++ b/drivers/devfreq/governor.h @@ -23,6 +23,7 @@ #define DEVFREQ_GOV_PERFORMANCE 0x2 #define DEVFREQ_GOV_POWERSAVE 0x3 #define DEVFREQ_GOV_USERSPACE 0x4 +#define DEVFREQ_GOV_PASSIVE 0x5 /* Devfreq events */ #define DEVFREQ_GOV_START 0x1 @@ -44,4 +45,18 @@ extern void devfreq_interval_update(struct devfreq *devfreq, extern int devfreq_add_governor(struct devfreq_governor *governor); extern int devfreq_remove_governor(struct devfreq_governor *governor); +#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE) +extern int devfreq_passive_register_notifier(struct devfreq *passive); +extern void devfreq_passive_unregister_notifier(struct devfreq *passive); +#else +static inline int devfreq_passive_register_notifier(struct devfreq *passive) +{ + return 0; +} + +static inline void devfreq_passive_unregister_notifier(struct devfreq *passive) +{ +} +#endif + #endif /* _GOVERNOR_H */ diff --git a/drivers/devfreq/governor_passive.c b/drivers/devfreq/governor_passive.c new file mode 100644 index 000000000000..521e93b68c11 --- /dev/null +++ b/drivers/devfreq/governor_passive.c @@ -0,0 +1,192 @@ +/* + * linux/drivers/devfreq/governor_passive.c + * + * Copyright (C) 2016 Samsung Electronics + * Author: Chanwoo Choi + * + * 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 "governor.h" + +static int devfreq_passive_get_target_freq(struct devfreq *passive, + unsigned long *freq) +{ + struct devfreq *parent_devfreq = (struct devfreq *)passive->data; + unsigned long child_freq = ULONG_MAX; + struct dev_pm_opp *opp; + int i, count; + u32 flags; + + /* + * Each devfreq has the OPP table. After deciding the new frequency + * from the governor of parent devfreq device, the passive governor + * need to get the index of new frequency on OPP table of parent + * device. And then the index is used for getting the suitable + * new frequency for passive devfreq device. + */ + + if (!passive->profile || !passive->profile->freq_table + || passive->profile->max_state <= 0) + return -EINVAL; + + /* + * The passive governor have to get the correct frequency from OPP + * list of parent device. Because in this case, *freq is temporary + * value which is decided by ondemand governor. + */ + if (parent_devfreq->previous_freq < *freq) + flags = DEVFREQ_FLAG_LEAST_UPPER_BOUND; + + rcu_read_lock(); + opp = devfreq_recommended_opp(parent_devfreq->dev.parent, freq, flags); + rcu_read_unlock(); + if (IS_ERR_OR_NULL(opp)) + return PTR_ERR(opp); + + /* + * Get the OPP table's index of decided freqeuncy by governor + * of parent device. + */ + for (i = 0; i < parent_devfreq->profile->max_state; i++) + if (parent_devfreq->profile->freq_table[i] == *freq) + break; + + if (i == parent_devfreq->profile->max_state) + return -EINVAL; + + /* Get the suitable frequency by using index of parent device. */ + if (i < passive->profile->max_state) { + child_freq = passive->profile->freq_table[i]; + } else { + count = passive->profile->max_state; + child_freq = passive->profile->freq_table[count - 1]; + } + + /* Return the suitable frequency for passive device. */ + *freq = child_freq; + + return 0; +} + +static int devfreq_passive_event_handler(struct devfreq *devfreq, + unsigned int event, void *data) +{ + return 0; +} + +static struct devfreq_governor devfreq_passive = { + .name = "passive", + .type = DEVFREQ_GOV_PASSIVE, + .get_target_freq = devfreq_passive_get_target_freq, + .event_handler = devfreq_passive_event_handler, +}; + +static int update_devfreq_passive(struct devfreq *parent, unsigned long freq) +{ + struct devfreq *passive; + unsigned long rate; + int ret; + + list_for_each_entry(passive, &parent->passive_node, passive_node) { + if (!passive->governor) + continue; + rate = freq; + + ret = passive->governor->get_target_freq(passive, &rate); + if (ret) + return ret; + + ret = passive->profile->target(passive->dev.parent, &rate, 0); + if (ret) + return ret; + + passive->previous_freq = rate; + } + + return 0; +} + +static int devfreq_passive_notifier_call(struct notifier_block *nb, + unsigned long event, void *ptr) +{ + struct devfreq *passive = container_of(nb, struct devfreq, passive_nb); + struct devfreq *parent = (struct devfreq *)passive->data; + struct devfreq_freqs *freqs = (struct devfreq_freqs *)ptr; + unsigned long freq = freqs->new; + + switch (event) { + case DEVFREQ_PRECHANGE: + if (parent->previous_freq > freq); + update_devfreq_passive(parent, freq); + break; + case DEVFREQ_POSTCHANGE: + if (parent->previous_freq < freq); + update_devfreq_passive(parent, freq); + break; + } + + return NOTIFY_DONE; +} + +/** + * devfreq_passive_register_notifier() - Register notifier block of passive + * devfreq to parent devfreq device. + * @passive: The parent devfreq object using passive governor. + * + * Register notifier block of passive devfreq device to receive the changed + * frequency of parent devfreq device through DEVFREQ_TRANSITION_NOTIFIER. + */ +int devfreq_passive_register_notifier(struct devfreq *passive) +{ + struct device *dev = passive->dev.parent; + struct devfreq *parent = (struct devfreq *)passive->data; + struct notifier_block *nb = &passive->passive_nb; + + nb->notifier_call = devfreq_passive_notifier_call; + return devm_devfreq_register_notifier(dev, parent, nb, + DEVFREQ_TRANSITION_NOTIFIER); +} + +/** + * devfreq_passive_register_notifier() - Unregister notifier block of passive + * devfreq from parent devfreq device. + * @passive: The parent devfreq object using passive governor. + */ +void devfreq_passive_unregister_notifier(struct devfreq *passive) +{ + struct devfreq *parent = (struct devfreq *)passive->data; + struct device *dev = passive->dev.parent; + struct notifier_block *nb = &passive->passive_nb; + + devm_devfreq_unregister_notifier(dev, parent, nb, + DEVFREQ_TRANSITION_NOTIFIER); +} + +static int __init devfreq_passive_init(void) +{ + return devfreq_add_governor(&devfreq_passive); +} +subsys_initcall(devfreq_passive_init); + +static void __exit devfreq_passive_exit(void) +{ + int ret; + + ret = devfreq_remove_governor(&devfreq_passive); + if (ret) + pr_err("%s: failed remove governor %d\n", __func__, ret); + + return; +} +module_exit(devfreq_passive_exit); + +MODULE_AUTHOR("Chanwoo Choi "); +MODULE_DESCRIPTION("DEVFREQ Passive governor"); +MODULE_LICENSE("GPL v2"); diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h index 9baf45f661ad..bf073c74134f 100644 --- a/include/linux/devfreq.h +++ b/include/linux/devfreq.h @@ -188,6 +188,9 @@ struct devfreq { unsigned long last_stat_updated; struct srcu_notifier_head transition_notifier_list; + + struct list_head passive_node; + struct notifier_block passive_nb; }; struct devfreq_freqs {