From patchwork Wed Aug 7 07:06:01 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Viresh Kumar X-Patchwork-Id: 170725 Delivered-To: patch@linaro.org Received: by 2002:a92:512:0:0:0:0:0 with SMTP id q18csp6742181ile; Wed, 7 Aug 2019 00:06:12 -0700 (PDT) X-Google-Smtp-Source: APXvYqxIJKLA5Zs96CJO43ojC8jdoUOI7ajj0RpS18y8HGZK3+XPEAlyydcNtn4zP36I7hAno7gs X-Received: by 2002:a62:e403:: with SMTP id r3mr7523385pfh.37.1565161572284; Wed, 07 Aug 2019 00:06:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1565161572; cv=none; d=google.com; s=arc-20160816; b=kZGBx6AquEDPJfFLwFDcx6Sv8tmldCwtdGgk3mnIIizGPCbg2LY+2XRfht1wdH1h3l KAT/lhM3BwI1bxzGPG3yzQoJdYktSpNfypG4eeSG0OcTI1F6nv43K/9mlID/W9hXXdPB HT7pwqBVIdBlW0k5bts/+YOb6AyD5l6KSHYvq8btBEn+JfYovgVEg3IjKmXTJJlyMwXx aVgSgkefR9gIbB1hDvWbxnP+Fy6dKoKyQTkV+zQAZqDE26vxUyCJ5sSUaml1mPz/J6XL t7XJEfYeFkDEXZqfOPe4mFpdMxU3Hphu4/DVNTA47d+w4voKg4QxlJrqsikxL2btyWAV WcZA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :message-id:date:subject:cc:to:from:dkim-signature; bh=qZIcf8cwa9igDXcslC8hIzH7Ja/YvdjdJITOrrBaFhM=; b=W47IBWyTgeHIUR12+yHg5y5bUUEFHGGhvXuTwl9a3V+xRM5luIEr8yE21HlYy1/PGB RxC+QL+r6T8GRbMjt1vCd52111ZV+Pgc+cQdlCaNPrvUlaTNF5ANkilcV6seye/K4hoZ uWJcBywH/1UenfAEngl5u41aYA2epfpUtBjru0o7ZnqyBdz+hdt5rtMtW6LtVhw6wjVN t4LgGj6rl0GJof3si8jZPrx9yGqB9T6Tdcwm8kAZfg5UzJ4y4a2Dw3rb8Wf809UpWSno SvSz0Y+wNJtSafZFhh7bGANGFGxEkVbvnEUocR1r8YeQXY3FEHRYwJGjZYIljMIx3gz4 BatQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=uGWRV7RE; spf=pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id y71si45833631pgd.271.2019.08.07.00.06.11; Wed, 07 Aug 2019 00:06:12 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=uGWRV7RE; spf=pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727673AbfHGHGK (ORCPT + 11 others); Wed, 7 Aug 2019 03:06:10 -0400 Received: from mail-pl1-f194.google.com ([209.85.214.194]:44498 "EHLO mail-pl1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727281AbfHGHGK (ORCPT ); Wed, 7 Aug 2019 03:06:10 -0400 Received: by mail-pl1-f194.google.com with SMTP id t14so39286040plr.11 for ; Wed, 07 Aug 2019 00:06:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=qZIcf8cwa9igDXcslC8hIzH7Ja/YvdjdJITOrrBaFhM=; b=uGWRV7REDU+/UifJJKwmcUdbbfC4+kwOlu/L+nhcItsXbS9UPMcFi7KVOdRDWbGf1q dRx1FjrW5TtVAPn5B7HMX1/W5eDB7o/iEVGTwe3yxgl4WRZVORhNkGMWxpZfqnlErHMb hji3OIQC0rxu9lxBbQnzsjqSwv2EsvVrEBLBxSYg5/cf0pLOrl96k/FannaVJcaklLjc HYf5DtgdzxJZbnA/z8yBce20TryrnPvNlAVrvFTRkGMkHRv2RAeqbSZ6gcq6/18qUt1Z 316qtvwaOJAwd/k0dSY0XSCLu4CtLuKCCUIb59IcZgwHPgdnF09QRh7sOw8W6tEheyEA pBeA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=qZIcf8cwa9igDXcslC8hIzH7Ja/YvdjdJITOrrBaFhM=; b=siBLwBEQTnKv8ShBwRSIUW9kT2ekWJdBv3Hd7cdL0aXLJj990xfZaPn5A7oSO8h7LD FqQ7rh5lgMYmOmQUiUYKG0+abUBruCFfHHqQFS/QUU2aDJkVNY3IZuHqxB8LPDIrqGw5 6a0hLZMZzAlb1xaq6misUZKF1OHI0wZlt40SAmL/3MfaTAMhaggvgN6ZchVOSuzG/VO8 tYkQ09za7hHCShBJFlWcpZWFsiaONwknY2DYh7QFgeHBIHPgC4hVcgl+KyDEuB0Yi/iu rGA4Zt7kpKFT2FvFNyac7vw5lpGBBNBx4HCQjV+3xBbkCWpuGbb4MLW5mjXh4FnZCa74 C/mA== X-Gm-Message-State: APjAAAVSxb5GGCThIWIJyab8tEaln8z5xD2r2g4FD/RoUsOmXug1YJpx 0fRkL5vDDU3WFDL7J2id/bc3Vw== X-Received: by 2002:a62:3347:: with SMTP id z68mr8065751pfz.174.1565161569245; Wed, 07 Aug 2019 00:06:09 -0700 (PDT) Received: from localhost ([122.172.76.219]) by smtp.gmail.com with ESMTPSA id c98sm25633299pje.1.2019.08.07.00.06.07 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 07 Aug 2019 00:06:08 -0700 (PDT) From: Viresh Kumar To: Rafael Wysocki , Viresh Kumar , Ingo Molnar , Peter Zijlstra Cc: linux-pm@vger.kernel.org, Vincent Guittot , "v4 . 18+" , Doug Smythies , linux-kernel@vger.kernel.org Subject: [PATCH V4 1/2] cpufreq: schedutil: Don't skip freq update when limits change Date: Wed, 7 Aug 2019 12:36:01 +0530 Message-Id: <70fce19e43bb825c3b2546e1211d262a59ae7378.1565161495.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.21.0.rc0.269.g1a574e7a288b MIME-Version: 1.0 Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org To avoid reducing the frequency of a CPU prematurely, we skip reducing the frequency if the CPU had been busy recently. This should not be done when the limits of the policy are changed, for example due to thermal throttling. We should always get the frequency within the new limits as soon as possible. Trying to fix this by using only one flag, i.e. need_freq_update, can lead to a race condition where the flag gets cleared without forcing us to change the frequency at least once. And so this patch introduces another flag to avoid that race condition. Fixes: ecd288429126 ("cpufreq: schedutil: Don't set next_freq to UINT_MAX") Cc: v4.18+ # v4.18+ Reported-by: Doug Smythies Tested-by: Doug Smythies Signed-off-by: Viresh Kumar --- V3->V4: - Rewrite "if" block to avoid setting variable to false at initialization. - Added Tested-by from Doug. kernel/sched/cpufreq_schedutil.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) -- 2.21.0.rc0.269.g1a574e7a288b diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c index 636ca6f88c8e..867b4bb6d4be 100644 --- a/kernel/sched/cpufreq_schedutil.c +++ b/kernel/sched/cpufreq_schedutil.c @@ -40,6 +40,7 @@ struct sugov_policy { struct task_struct *thread; bool work_in_progress; + bool limits_changed; bool need_freq_update; }; @@ -89,8 +90,11 @@ static bool sugov_should_update_freq(struct sugov_policy *sg_policy, u64 time) !cpufreq_this_cpu_can_update(sg_policy->policy)) return false; - if (unlikely(sg_policy->need_freq_update)) + if (unlikely(sg_policy->limits_changed)) { + sg_policy->limits_changed = false; + sg_policy->need_freq_update = true; return true; + } delta_ns = time - sg_policy->last_freq_update_time; @@ -437,7 +441,7 @@ static inline bool sugov_cpu_is_busy(struct sugov_cpu *sg_cpu) { return false; } static inline void ignore_dl_rate_limit(struct sugov_cpu *sg_cpu, struct sugov_policy *sg_policy) { if (cpu_bw_dl(cpu_rq(sg_cpu->cpu)) > sg_cpu->bw_dl) - sg_policy->need_freq_update = true; + sg_policy->limits_changed = true; } static void sugov_update_single(struct update_util_data *hook, u64 time, @@ -457,7 +461,8 @@ static void sugov_update_single(struct update_util_data *hook, u64 time, if (!sugov_should_update_freq(sg_policy, time)) return; - busy = sugov_cpu_is_busy(sg_cpu); + /* Limits may have changed, don't skip frequency update */ + busy = !sg_policy->need_freq_update && sugov_cpu_is_busy(sg_cpu); util = sugov_get_util(sg_cpu); max = sg_cpu->max; @@ -831,6 +836,7 @@ static int sugov_start(struct cpufreq_policy *policy) sg_policy->last_freq_update_time = 0; sg_policy->next_freq = 0; sg_policy->work_in_progress = false; + sg_policy->limits_changed = false; sg_policy->need_freq_update = false; sg_policy->cached_raw_freq = 0; @@ -879,7 +885,7 @@ static void sugov_limits(struct cpufreq_policy *policy) mutex_unlock(&sg_policy->work_lock); } - sg_policy->need_freq_update = true; + sg_policy->limits_changed = true; } struct cpufreq_governor schedutil_gov = { From patchwork Wed Aug 7 07:06:02 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Viresh Kumar X-Patchwork-Id: 170726 Delivered-To: patch@linaro.org Received: by 2002:a92:512:0:0:0:0:0 with SMTP id q18csp6742233ile; Wed, 7 Aug 2019 00:06:15 -0700 (PDT) X-Google-Smtp-Source: APXvYqxrlFWZg+mDA0Tyk1cVQz0Hz7bHZ5mnHTLEJivuBS+tP8gkT6zPuyfS2ls0yuJzLs9sFnJq X-Received: by 2002:aa7:8a99:: with SMTP id a25mr7904164pfc.127.1565161575051; Wed, 07 Aug 2019 00:06:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1565161575; cv=none; d=google.com; s=arc-20160816; b=oT54+EcQNgIx4IfP66tP3kD+l3WjyhiXT4wsZALoMy9L9MDnMFOELvG9o7oSNOVN/2 WFAZ2zwtGnW9P1D3vX+f4dexUcfAFH3RZ/DAvuNshMA7gpRgygE84lrruy9fCf0YkCYy +RUls13rS8MfsaMev+eJ14E99sQJyI0WZlH61L4Uuep7PNyD5dIo+vd2hDb9HYt+/sUZ eft//ArWReNj2fQWhkM5j1C45TvS/91jXYIZrOCOU6fHal0yj+qdX1fwRL2VnFmO2Vst EGrc/Wg0Lx3TPTC3r8YmZJd2bS5kl2KFsftG7lJXZhLfb1aIbWjUjgTbZx1mYMcuC19o YxqA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=lP7WtIX8WuuPc2QyYwkR7MBl6FcTzg8DxX/JykR288c=; b=NjbCI3S2zSbMpdxm1g7YkqB9C+6rrfQQStLUq6Sm/w3VUilzHczsA0diH/jQcVAGUA WHZMI0O/9kaPxNQfKhM615ErR4BOMN0blPSPgb+E6PFwBRoq59oU+196WIPf6g1kiH/9 HYsi9xutZmWAtWZcSCOEL0CoC0gixOrlZkiNp8laCGq7mbDQD7crMlOzmqjhtHggG15e 84jCaC66BSiDiypcQBmQ7lyTNEyvVnA+das15KCIq/zy3bj5wPGMFJHQW8z8jeHImrjc qrJry7qwIpm4UnK7DtYy8JqRl8juaPFWe+QKt/cAiW+CTzEhclZLQGIQ4T99Bm6EWG8T sCZg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=RRKviTX6; spf=pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id o21si51052760pgm.453.2019.08.07.00.06.14; Wed, 07 Aug 2019 00:06:15 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=RRKviTX6; spf=pass (google.com: best guess record for domain of linux-pm-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-pm-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727187AbfHGHGN (ORCPT + 11 others); Wed, 7 Aug 2019 03:06:13 -0400 Received: from mail-pl1-f193.google.com ([209.85.214.193]:35691 "EHLO mail-pl1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727280AbfHGHGN (ORCPT ); Wed, 7 Aug 2019 03:06:13 -0400 Received: by mail-pl1-f193.google.com with SMTP id w24so39312676plp.2 for ; Wed, 07 Aug 2019 00:06:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=lP7WtIX8WuuPc2QyYwkR7MBl6FcTzg8DxX/JykR288c=; b=RRKviTX6toH/7yNLtlJODs7ECpfQ76vl7lQIacOecjZHLqg6iofmuELQjUqeqNtLyr ILArp90c75xLvJAVLRpjKs7VtH426mMBbvjaGkvTlUHtR+ID1Qrqria2ow8XPLbB5YfV JHQC5eD115e/vQmH/QKK4fAoJD/AVmr3ssvI238PeJ1W/sUba8j+ThIw9E08shuMCP4U W7lO53n6viOQpB0lEdM8WlXnjPB1diQqQ//x6nF8snusbShJApRw85KOKtQQnqZC1oIP 6hlGs5O+O23RQ7G+v3+Mib3CLwG5rCNmpgp68pHlb02sJbkcJPVX0R1yWv6zxcdaOVBy hZ/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=lP7WtIX8WuuPc2QyYwkR7MBl6FcTzg8DxX/JykR288c=; b=TQCd1EIYrj6XMzkFQpZEMva4AoUbw+uxpNUdz52Ru0ScDxQwM3xA+fIOm5VC9xUY11 9Ix/s+pdePhfc0GPudWL1x3q8vnb96ndVEe/zTLCMYMUIzYn7K5f+a3rWdzmXNB6u0zD q9gK+tLGqkkDHqWHl8TB3C7Fc9aJG3WcVmpF6Ry0drPRdUfCqUngDilE3l6Ai5raIif+ mJ8KKzP0LtvS7r6plRjXq/BJTwZCPbgjpxPJKUdWWQom10PxXYyGiYlz4gKs77jhoUNF UqGRHWNGHCMCdzGiBlHH6yTa8MlLx/6TPp/MAszmorF+wxyxlfuIO9ZmF61YjBmrKnrT sUEA== X-Gm-Message-State: APjAAAX0TFhNve+Y0vaMUqc/p2VtzSCoMqwB8yALfYSbnWvnzksvyXQe 6Mi/LrqUkMlOJCKZtc1jrA3BYg== X-Received: by 2002:a63:903:: with SMTP id 3mr6416426pgj.371.1565161571879; Wed, 07 Aug 2019 00:06:11 -0700 (PDT) Received: from localhost ([122.172.76.219]) by smtp.gmail.com with ESMTPSA id bg3sm36281178pjb.9.2019.08.07.00.06.11 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 07 Aug 2019 00:06:11 -0700 (PDT) From: Viresh Kumar To: Rafael Wysocki , Srinivas Pandruvada , Len Brown , Viresh Kumar Cc: linux-pm@vger.kernel.org, Vincent Guittot , Doug Smythies , linux-kernel@vger.kernel.org Subject: [PATCH V4 2/2] cpufreq: intel_pstate: Implement QoS supported freq constraints Date: Wed, 7 Aug 2019 12:36:02 +0530 Message-Id: X-Mailer: git-send-email 2.21.0.rc0.269.g1a574e7a288b In-Reply-To: <70fce19e43bb825c3b2546e1211d262a59ae7378.1565161495.git.viresh.kumar@linaro.org> References: <70fce19e43bb825c3b2546e1211d262a59ae7378.1565161495.git.viresh.kumar@linaro.org> MIME-Version: 1.0 Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org Intel pstate driver exposes min_perf_pct and max_perf_pct sysfs files, which can be used to force a limit on the min/max P state of the driver. Though these files eventually control the min/max frequencies that the CPUs will run at, they don't make a change to policy->min/max values. When the values of these files are changed (in passive mode of the driver), it leads to calling ->limits() callback of the cpufreq governors, like schedutil. On a call to it the governors shall forcefully update the frequency to come within the limits. Since the limits, i.e. policy->min/max, aren't updated by the driver, the governors fails to get the target freq within limit and sometimes aborts the update believing that the frequency is already set to the target value. This patch implements the QoS supported frequency constraints to update policy->min/max values whenever min_perf_pct or max_perf_pct files are updated. This is only done for the passive mode as of now, as the driver is already working fine in active mode. Fixes: ecd288429126 ("cpufreq: schedutil: Don't set next_freq to UINT_MAX") Reported-by: Doug Smythies Signed-off-by: Viresh Kumar --- V3->V4: - Reimplemented the solution using QoS constraints instead of resolve_freq() callback. drivers/cpufreq/intel_pstate.c | 120 +++++++++++++++++++++++++++++++-- 1 file changed, 116 insertions(+), 4 deletions(-) -- 2.21.0.rc0.269.g1a574e7a288b diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c index cc27d4c59dca..e9fbd6c36822 100644 --- a/drivers/cpufreq/intel_pstate.c +++ b/drivers/cpufreq/intel_pstate.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include @@ -1085,6 +1086,47 @@ static ssize_t store_no_turbo(struct kobject *a, struct kobj_attribute *b, return count; } +static struct cpufreq_driver intel_pstate; + +static void update_qos_request(enum dev_pm_qos_req_type type) +{ + int max_state, turbo_max, freq, i, perf_pct; + struct dev_pm_qos_request *req; + struct cpufreq_policy *policy; + + for_each_possible_cpu(i) { + struct cpudata *cpu = all_cpu_data[i]; + + policy = cpufreq_cpu_get(i); + if (!policy) + continue; + + req = policy->driver_data; + cpufreq_cpu_put(policy); + + if (!req) + continue; + + if (hwp_active) + intel_pstate_get_hwp_max(i, &turbo_max, &max_state); + else + turbo_max = cpu->pstate.turbo_pstate; + + if (type == DEV_PM_QOS_MIN_FREQUENCY) { + perf_pct = global.min_perf_pct; + } else { + req++; + perf_pct = global.max_perf_pct; + } + + freq = DIV_ROUND_UP(turbo_max * perf_pct, 100); + freq *= cpu->pstate.scaling; + + if (dev_pm_qos_update_request(req, freq)) + pr_warn("Failed to update freq constraint: CPU%d\n", i); + } +} + static ssize_t store_max_perf_pct(struct kobject *a, struct kobj_attribute *b, const char *buf, size_t count) { @@ -1108,7 +1150,10 @@ static ssize_t store_max_perf_pct(struct kobject *a, struct kobj_attribute *b, mutex_unlock(&intel_pstate_limits_lock); - intel_pstate_update_policies(); + if (intel_pstate_driver == &intel_pstate) + intel_pstate_update_policies(); + else + update_qos_request(DEV_PM_QOS_MAX_FREQUENCY); mutex_unlock(&intel_pstate_driver_lock); @@ -1139,7 +1184,10 @@ static ssize_t store_min_perf_pct(struct kobject *a, struct kobj_attribute *b, mutex_unlock(&intel_pstate_limits_lock); - intel_pstate_update_policies(); + if (intel_pstate_driver == &intel_pstate) + intel_pstate_update_policies(); + else + update_qos_request(DEV_PM_QOS_MIN_FREQUENCY); mutex_unlock(&intel_pstate_driver_lock); @@ -2332,8 +2380,16 @@ static unsigned int intel_cpufreq_fast_switch(struct cpufreq_policy *policy, static int intel_cpufreq_cpu_init(struct cpufreq_policy *policy) { - int ret = __intel_pstate_cpu_init(policy); + int max_state, turbo_max, min_freq, max_freq, ret; + struct dev_pm_qos_request *req; + struct cpudata *cpu; + struct device *dev; + + dev = get_cpu_device(policy->cpu); + if (!dev) + return -ENODEV; + ret = __intel_pstate_cpu_init(policy); if (ret) return ret; @@ -2342,7 +2398,63 @@ static int intel_cpufreq_cpu_init(struct cpufreq_policy *policy) /* This reflects the intel_pstate_get_cpu_pstates() setting. */ policy->cur = policy->cpuinfo.min_freq; + req = kcalloc(2, sizeof(*req), GFP_KERNEL); + if (!req) { + ret = -ENOMEM; + goto pstate_exit; + } + + cpu = all_cpu_data[policy->cpu]; + + if (hwp_active) + intel_pstate_get_hwp_max(policy->cpu, &turbo_max, &max_state); + else + turbo_max = cpu->pstate.turbo_pstate; + + min_freq = DIV_ROUND_UP(turbo_max * global.min_perf_pct, 100); + min_freq *= cpu->pstate.scaling; + max_freq = DIV_ROUND_UP(turbo_max * global.max_perf_pct, 100); + max_freq *= cpu->pstate.scaling; + + ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_MIN_FREQUENCY, + min_freq); + if (ret < 0) { + dev_err(dev, "Failed to add min-freq constraint (%d)\n", ret); + goto free_req; + } + + ret = dev_pm_qos_add_request(dev, req + 1, DEV_PM_QOS_MAX_FREQUENCY, + max_freq); + if (ret < 0) { + dev_err(dev, "Failed to add max-freq constraint (%d)\n", ret); + goto remove_min_req; + } + + policy->driver_data = req; + return 0; + +remove_min_req: + dev_pm_qos_remove_request(req); +free_req: + kfree(req); +pstate_exit: + intel_pstate_exit_perf_limits(policy); + + return ret; +} + +static int intel_cpufreq_cpu_exit(struct cpufreq_policy *policy) +{ + struct dev_pm_qos_request *req; + + req = policy->driver_data; + + dev_pm_qos_remove_request(req + 1); + dev_pm_qos_remove_request(req); + kfree(req); + + return intel_pstate_cpu_exit(policy); } static struct cpufreq_driver intel_cpufreq = { @@ -2351,7 +2463,7 @@ static struct cpufreq_driver intel_cpufreq = { .target = intel_cpufreq_target, .fast_switch = intel_cpufreq_fast_switch, .init = intel_cpufreq_cpu_init, - .exit = intel_pstate_cpu_exit, + .exit = intel_cpufreq_cpu_exit, .stop_cpu = intel_cpufreq_stop_cpu, .update_limits = intel_pstate_update_limits, .name = "intel_cpufreq",