From patchwork Wed Apr 6 07:44:13 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Huang Rui X-Patchwork-Id: 8758901 Return-Path: X-Original-To: patchwork-linux-hwmon@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 E751BC0553 for ; Wed, 6 Apr 2016 07:44:21 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id ADD0D20212 for ; Wed, 6 Apr 2016 07:44:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D7D0F20263 for ; Wed, 6 Apr 2016 07:44:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1760203AbcDFHoK (ORCPT ); Wed, 6 Apr 2016 03:44:10 -0400 Received: from mail-bn1on0091.outbound.protection.outlook.com ([157.56.110.91]:20251 "EHLO na01-bn1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1760045AbcDFHoH convert rfc822-to-8bit (ORCPT ); Wed, 6 Apr 2016 03:44:07 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amdcloud.onmicrosoft.com; s=selector1-amd-com; h=From:To:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=aekHiOKAFDn4G+im86pynOzyXQ/fbjPh49OHsFxmUsM=; b=ft9Yo4m6n5kvvTWVBYFZJ1yaDnJ09EFcNhCQU91Ej/47LLifiF8t3zTnTVgDY/v8VOUsqMT546uDNPLczjxSqrgK5H+1xdiFKWlWHuCQ3vCxBoEDKes2OfuC4rYLG40j0FF3FpALL7nUvKUMM02SjWGrwroKxzGREB34sf3mld0= Received: from DM3PR12CA0026.namprd12.prod.outlook.com (10.164.12.164) by BLUPR12MB0708.namprd12.prod.outlook.com (10.163.218.146) with Microsoft SMTP Server (TLS) id 15.1.447.15; Wed, 6 Apr 2016 07:43:54 +0000 Received: from BY2NAM03FT039.eop-NAM03.prod.protection.outlook.com (2a01:111:f400:7e4a::201) by DM3PR12CA0026.outlook.office365.com (2a01:111:e400:599f::36) with Microsoft SMTP Server (TLS) id 15.1.447.15 via Frontend Transport; Wed, 6 Apr 2016 07:43:53 +0000 Authentication-Results: spf=none (sender IP is 165.204.84.221) smtp.mailfrom=amd.com; alien8.de; dkim=none (message not signed) header.d=none; alien8.de; dmarc=permerror action=none header.from=amd.com; Received-SPF: None (protection.outlook.com: amd.com does not designate permitted sender hosts) Received: from atltwp01.amd.com (165.204.84.221) by BY2NAM03FT039.mail.protection.outlook.com (10.152.85.205) with Microsoft SMTP Server id 15.1.453.6 via Frontend Transport; Wed, 6 Apr 2016 07:43:52 +0000 X-WSS-ID: 0O57C53-07-34X-02 X-M-MSG: Received: from satlvexedge01.amd.com (satlvexedge01.amd.com [10.177.96.28]) (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by atltwp01.amd.com (Axway MailGate 5.3.1) with ESMTPS id 209B7CAE7E5; Wed, 6 Apr 2016 03:43:50 -0400 (EDT) Received: from SATLEXDAG05.amd.com (10.181.40.11) by satlvexedge01.amd.com (10.177.96.28) with Microsoft SMTP Server (TLS) id 14.3.195.1; Wed, 6 Apr 2016 02:44:16 -0500 Received: from SCYBEXDAG03.amd.com (10.34.11.13) by satlexdag05.amd.com (10.181.40.11) with Microsoft SMTP Server (TLS) id 14.3.266.1; Wed, 6 Apr 2016 03:43:50 -0400 Received: from hr-ub.amd.com (10.237.74.43) by SCYBEXDAG03.amd.com (10.34.11.13) with Microsoft SMTP Server id 14.3.266.1; Wed, 6 Apr 2016 15:43:44 +0800 From: Huang Rui To: Guenter Roeck , Jean Delvare CC: , , "Borislav Petkov" , Sherry Hurwitz , Huang Rui Subject: [PATCH v6 4/6] hwmon: (fam15h_power) Introduce a cpu accumulated power reporting algorithm Date: Wed, 6 Apr 2016 15:44:13 +0800 Message-ID: <1459928655-6071-5-git-send-email-ray.huang@amd.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1459928655-6071-1-git-send-email-ray.huang@amd.com> References: <1459928655-6071-1-git-send-email-ray.huang@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:165.204.84.221; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(2980300002)(428002)(189002)(199003)(53416004)(87936001)(77096005)(92566002)(50226001)(19580395003)(5003600100002)(229853001)(106466001)(33646002)(19580405001)(50466002)(4326007)(105586002)(36756003)(2906002)(5008740100001)(2950100001)(23676002)(86362001)(50986999)(1220700001)(5820100001)(76176999)(5001770100001)(1096002)(101416001)(81166005)(189998001)(47776003)(586003); DIR:OUT; SFP:1101; SCL:1; SRVR:BLUPR12MB0708; H:atltwp01.amd.com; FPR:; SPF:None; MLV:sfv; MX:1; A:1; LANG:en; X-MS-Office365-Filtering-Correlation-Id: d709ac54-d091-420f-de83-08d35def33a5 X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0708; 2:uNyoVgpBFgRsBOlJ+vMAa0hwVpMb26GgW/XjpozC58LCkVO1yyDKL+Xt1yOgVVfMgJad/pKrtZs+DN99DFxcxiXAazEeTi/HGNHCtPSrBzZkp3R3iDh5CPmwtH8XDsl4qPvA54R+2e20a5d2LHxO7SVLHDhllvkPykJirS0Nz7PTHwpSAzTLZnY27jg40J61; 3:BhUkH6ja9GidS7I0pLvLt1YIu6lD9Kv2my3Au3MM6kYUjlsQ9GuxN21rO0xl0fH/LwAsFuRz6z1gyL8hONV4tWiWOg6rpIRYN6C8l9iWx/W4C68Im/DXRlO833a1UK+pTg6/w+dpyah82oAT5vIWELCFTpn+qcspgNYWa4I2DcXgd6tfd06KSJZpkzi6QBLjFjihdX4Ah4I7ZxzkEP9JwDD7+kEDgLZIKupTBcvwSPY=; 25:kPiY1ps3ayG7n7VuK9mkfFYQjdUJWMhedA6l8tzk39+qKPS1fhqQYMp2QIMs6++PB954WVRz7SCApf0YE7MrGDnntWHL4ckdRqPhIwVeMQRmXeoWaVfaV6u+B4mcUp/1p6qxcqDPKkZed2b+qe5brRuCsMYc9VcGzekwJQKUDkWr0Pea1Lhyq4twdOC5WrBIiBY7AnmSGdqHNRwpAatUOoeQ733MO3BcFb9wbc5+aNjl2USdPHQgG1QDgdxDtrhObLJrkT1fNGM4OPhspQ5wtd+jREf9n8tHIpRoaKKEUp1x8+BOMlhDUGp6wOvn/6zKx2lXim0yzOQDP8eztdajZA== X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR12MB0708; X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0708; 20:kvanRAcndGsANq5oodVAGrvaqZvwPHpoedNGGZwDpGuLxE/QjShwZwt4HJ9vQzcqS+6C4BFItfIS00Ri1NTm2RF0TIrVUlXHtgwSIPJRicE84Kl276pZhY8Xt6QX7idQ3FAEP0ih1or5npdhB1iJRYoJCf9WBrTxT6HLEMxeEZ0NY1k8O9Co1ATKxhIclaMQHmxDc94/5d/zrGySGhgu0DaTgEl+gzrkp2LN0tF8D5e3fXkO5rlQkkoN9Z6VWGWR/ISxnVn2Ow7zR6jRWBZGZOvKBaHDwhfB8Ls1BJE99oYejsT1rLtnMrkvrZujJu3qp7dGmWsJTHvT35itAiRMKXBuPtXA4rWlqQ6pvEy2M0RBrE7N64tJ8iafZKN3aV92LUr5O2X6dcD3eaQRbu2oDy2XbpjvFKqi4Y8uRPK2o4fgfCeI0xE1ec5pasZxIViULEmINo3W0+bzqO3OQKEfutxFxFzdh62g7ucYoRfyKGj2ipQQnTjqzj01HrXBGDQ1 X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(601004)(2401047)(13024025)(8121501046)(13018025)(5005006)(13017025)(13023025)(13015025)(10201501046)(3002001); SRVR:BLUPR12MB0708; BCL:0; PCL:0; RULEID:; SRVR:BLUPR12MB0708; X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0708; 4:I3VZLMqyyWU9ZNseL/ErtY4seskyFqeDVsgpAHuvGr3BXEIm9T/LnmcnUiyk6ZYmg6AklbFklT0y0JZJr3m8qMcz0Ov79JAkNgjti0iAafy6uBVszmDLi/Csqd/4aqnkTobv6NJdy9aRbiMWj+DYnPOHtlOLLmTazLqPt1J56i2AekjrtTZn3ioCyaxF3+q3kCayxYK6AqcxwAVdBsP301uzF+PVw4i87+KHZi+XKBgJoeUcRNwzDHE4lZIkvj2FVqVigJ1G3MhtrZRSoQ4gtNyOtjzJVLlcYLaO6VdaxVvNOQPhE8cEN2lsizrGZkfnZtwDWX4u8QJREmIvTQnzrw7EchQrWFGSfA4ZGJ6UBXNigCEVfy+Sg2/rVPXuKTj2n4BFrtiHr9ppw75f8wsWgK5CvJNJcHW8wFu0mAtwNteMDAocFmuYkmF6w3lPCyg2IW0Z9MSux1JyJB9yeMSHAg== X-Forefront-PRVS: 0904004ECB X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtCTFVQUjEyTUIwNzA4OzIzOm1nZkhzbUNWQjRKeC85U0RUbWRrSGdQZFlw?= =?utf-8?B?U3Axa3NuZUNJcURJOTdXdFM1Rys2a2JrMUEvREs3TjZta0d4V1pDY1BNeGd1?= =?utf-8?B?UTIycDlCTmxncEM0RVZ1amkrSmhqcmtNbEZHOUVXRGJRWVF6Q2lIZmtwbTF1?= =?utf-8?B?SHdzMGJ1d0FOb0dHSlZ3LzAwdEk4Q2l6VmdhL3hIYy9LZkJhMnY2K1M1WjhU?= =?utf-8?B?R0phaitZbkhodGdZQU44UXBpVjNva1BvRlgwTWtMMVpFc01lSkt2eFYzYlZL?= =?utf-8?B?TDJZd2NrWHl2aUxEdDV4SnVvQ3RESTZXendNK3RrK1E4ZHVTMEhOcHNacHEw?= =?utf-8?B?eFVPd1pnV0lnanhBQ2JLQ1FYakNwU0pJQWRPLzFsTmgraVROOVltZElLQmZM?= =?utf-8?B?eVpzNy85VFRBNUN5OUJ5NnNkNUp5SDlveWdqRjl6cVJraGtJVHR0VHJUQmxn?= =?utf-8?B?ZnE2UmZKNXU0ODJwUTFQZkJNRGtNUkZpU2gxWWpBTnNPSE9aaWZkZVJFd3Y2?= =?utf-8?B?eEtBdEtoWUpGd1BZay93WEhEb1NzWUdXeUZmTzcwdnFXNVBOZXhXSDhDaFJa?= =?utf-8?B?aUJGc0dKWDhiTnlOaDRuV3RITFJNZ2dLbytPSDMxWGhHV2MxOXR0L1NLdXJ4?= =?utf-8?B?aXNXaG41aTVlb1VWZWNuTmIrc09nZzlDaXZjK0VQS2k3bnJOU0MvMmVMOUJs?= =?utf-8?B?aDlXalZVRGdBSTV5YVdGTVl2L29KNEh6Mmo1dC84bGhOR2s1YWd0MmJmYXJQ?= =?utf-8?B?UGhmTm40U2NtMHdIMlZrS0h5bWhpd1MvOUYwUm5haVRyRG1vcG4zRmswNjBY?= =?utf-8?B?WjBYR09kckcrT0tuT2RNbG5EL3pzVWhEcGpta09CeGd5d1lIdFpnbDZWMmN2?= =?utf-8?B?WDg5SlRnV2pFc1Frd0JVNzhSb2pzdXh1TVBqVlhwUUsyWVh2VG13S21SV2FD?= =?utf-8?B?S2VhYzE4MkRCd1NwMXVHV2dZeW5kWlVRUnFFZS96TUVUcGZFTXkyWUo0R3ZF?= =?utf-8?B?cFlTVWJ2QXZKZWxYWEQyUW9oM1RIY004QVRnWm5mRTNldDlIbysrV2pySlpi?= =?utf-8?B?QmlNMXMxUjJGNG5DRGNOT1ZzMVlsdUNidmdhZnhvYmF0RDZFRkVhR3VwQ3ph?= =?utf-8?B?bEtiOHROR1Z4NVVHUE43Rkw2SVg1ODVUZ2lsWTEwZFNwS2t6eDY4bldpcTdi?= =?utf-8?B?SVNWM2xiQ1VmK1dValNNUWlIY1UvcWQ4N2RON1AwZ2d6ek1sMzljWlh4d1ZK?= =?utf-8?B?TFlJRWRBS0VZVEtXVkUzNHNRbGNFcmNlRkQzWmduMkxBV2N1M2JCZ0I5bnpZ?= =?utf-8?B?dVh6Q1pVZUphYnc9PQ==?= X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0708; 5:4Z3fuOAYhNAcr+fz5lMbVuzTCYJELETWASH7+jKnV+/0bcEu2zKtd4CdcSpTu21JY4ywqFFI1PaW3YBsv4Cc3CxKHAbzkaetY6Zp6Cdk9eEvss7LaFGWEyJemnbBs1NUKAFIGmJzuNf6ndp3h2wgvA==; 24:K7wJlW+4i+SNruKEgw/xHIK/1ajaE+CRqKGJD7z1egwb/ViNzXxaY8fiBy2pwAB7wqUi4RWVk9MuEeLBexFfReYIfxb0xqNMYUuRng+td1c=; 20:+8E75tlQM9YzWojd/Zu1y3JhwQkacpDOvm0+oRHP/fZew8DEQsH7YG1pFXkLaJbkiDjanfcrNRI+2Zx0KJN4Ahl2x+/r7aykNYNQU9M22zlKgHqj43Sjtn324zuer8ADqF2chRYCd6jWlpQbIBOPn5vykCpr7tnLlXEBVNu+rURhwU8C6xIM8a/OebM6f8qYV15MBephxkEUNb6nrZ5a0etI9JPfeDVjhGhPusb161DxaqtePrxeXwGdGESJAVDX SpamDiagnosticOutput: 1:23 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Apr 2016 07:43:52.8978 (UTC) X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d; Ip=[165.204.84.221]; Helo=[atltwp01.amd.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR12MB0708 Sender: linux-hwmon-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-hwmon@vger.kernel.org X-Spam-Status: No, score=-7.8 required=5.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_HI,RP_MATCHES_RCVD,T_DKIM_INVALID,UNPARSEABLE_RELAY autolearn=ham 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 introduces an algorithm that computes the average power by reading a delta value of “core power accumulator” register during measurement interval, and then dividing delta value by the length of the time interval. User is able to use power1_average entry to measure the processor power consumption and power1_average_interval entry to set the interval. A simple example: ray@hr-ub:~/tip$ sensors fam15h_power-pci-00c4 Adapter: PCI adapter power1: 19.58 mW (avg = 2.55 mW, interval = 0.01 s) (crit = 15.00 W) ... The result is current average processor power consumption in 10 millisecond. The unit of the result is uWatt. Suggested-by: Guenter Roeck Signed-off-by: Huang Rui Cc: Borislav Petkov --- drivers/hwmon/fam15h_power.c | 128 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 124 insertions(+), 4 deletions(-) diff --git a/drivers/hwmon/fam15h_power.c b/drivers/hwmon/fam15h_power.c index 336d422..5abbfa8 100644 --- a/drivers/hwmon/fam15h_power.c +++ b/drivers/hwmon/fam15h_power.c @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include #include @@ -48,6 +50,9 @@ MODULE_LICENSE("GPL"); #define FAM15H_NUM_GROUPS 2 #define MAX_CUS 8 +/* set maximum interval as 1 second */ +#define MAX_INTERVAL 1000 + #define MSR_F15H_CU_PWR_ACCUMULATOR 0xc001007a #define MSR_F15H_CU_MAX_PWR_ACCUMULATOR 0xc001007b #define MSR_F15H_PTSC 0xc0010280 @@ -68,6 +73,9 @@ struct fam15h_power_data { u64 cu_acc_power[MAX_CUS]; /* performance timestamp counter */ u64 cpu_sw_pwr_ptsc[MAX_CUS]; + /* online/offline status of current compute unit */ + int cu_on[MAX_CUS]; + unsigned long power_period; }; static ssize_t show_power(struct device *dev, @@ -149,6 +157,8 @@ static void do_read_registers_on_cu(void *_data) rdmsrl_safe(MSR_F15H_CU_PWR_ACCUMULATOR, &data->cu_acc_power[cu]); rdmsrl_safe(MSR_F15H_PTSC, &data->cpu_sw_pwr_ptsc[cu]); + + data->cu_on[cu] = 1; } /* @@ -165,6 +175,8 @@ static int read_registers(struct fam15h_power_data *data) if (!ret) return -ENOMEM; + memset(data->cu_on, 0, sizeof(int) * MAX_CUS); + get_online_cpus(); this_cpu = smp_processor_id(); @@ -199,6 +211,98 @@ static int read_registers(struct fam15h_power_data *data) return 0; } +static ssize_t acc_show_power(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct fam15h_power_data *data = dev_get_drvdata(dev); + u64 prev_cu_acc_power[MAX_CUS], prev_ptsc[MAX_CUS], + jdelta[MAX_CUS]; + u64 tdelta, avg_acc; + int cu, cu_num, ret; + signed long leftover; + + /* + * With the new x86 topology modelling, x86_max_cores is the + * compute unit number. + */ + cu_num = boot_cpu_data.x86_max_cores; + + ret = read_registers(data); + if (ret) + return 0; + + for (cu = 0; cu < cu_num; cu++) { + prev_cu_acc_power[cu] = data->cu_acc_power[cu]; + prev_ptsc[cu] = data->cpu_sw_pwr_ptsc[cu]; + } + + leftover = schedule_timeout_interruptible(msecs_to_jiffies(data->power_period)); + if (leftover) + return 0; + + ret = read_registers(data); + if (ret) + return 0; + + for (cu = 0, avg_acc = 0; cu < cu_num; cu++) { + /* check if current compute unit is online */ + if (data->cu_on[cu] == 0) + continue; + + if (data->cu_acc_power[cu] < prev_cu_acc_power[cu]) { + jdelta[cu] = data->max_cu_acc_power + data->cu_acc_power[cu]; + jdelta[cu] -= prev_cu_acc_power[cu]; + } else { + jdelta[cu] = data->cu_acc_power[cu] - prev_cu_acc_power[cu]; + } + tdelta = data->cpu_sw_pwr_ptsc[cu] - prev_ptsc[cu]; + jdelta[cu] *= data->cpu_pwr_sample_ratio * 1000; + do_div(jdelta[cu], tdelta); + + /* the unit is microWatt */ + avg_acc += jdelta[cu]; + } + + return sprintf(buf, "%llu\n", (unsigned long long)avg_acc); +} +static DEVICE_ATTR(power1_average, S_IRUGO, acc_show_power, NULL); + +static ssize_t acc_show_power_period(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct fam15h_power_data *data = dev_get_drvdata(dev); + + return sprintf(buf, "%lu\n", data->power_period); +} + +static ssize_t acc_set_power_period(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fam15h_power_data *data = dev_get_drvdata(dev); + unsigned long temp; + int ret; + + ret = kstrtoul(buf, 10, &temp); + if (ret) + return ret; + + if (temp > MAX_INTERVAL) + return -EINVAL; + + /* the interval value should be greater than 0 */ + if (temp <= 0) + return -EINVAL; + + data->power_period = temp; + + return count; +} +static DEVICE_ATTR(power1_average_interval, S_IRUGO | S_IWUSR, + acc_show_power_period, acc_set_power_period); + static int fam15h_power_init_attrs(struct pci_dev *pdev, struct fam15h_power_data *data) { @@ -211,6 +315,10 @@ static int fam15h_power_init_attrs(struct pci_dev *pdev, (c->x86_model >= 0x60 && c->x86_model <= 0x7f))) n += 1; + /* check if processor supports accumulated power */ + if (boot_cpu_has(X86_FEATURE_ACC_POWER)) + n += 2; + fam15h_power_attrs = devm_kcalloc(&pdev->dev, n, sizeof(*fam15h_power_attrs), GFP_KERNEL); @@ -225,6 +333,11 @@ static int fam15h_power_init_attrs(struct pci_dev *pdev, (c->x86_model >= 0x60 && c->x86_model <= 0x7f))) fam15h_power_attrs[n++] = &dev_attr_power1_input.attr; + if (boot_cpu_has(X86_FEATURE_ACC_POWER)) { + fam15h_power_attrs[n++] = &dev_attr_power1_average.attr; + fam15h_power_attrs[n++] = &dev_attr_power1_average_interval.attr; + } + data->group.attrs = fam15h_power_attrs; return 0; @@ -290,7 +403,7 @@ static int fam15h_power_resume(struct pci_dev *pdev) static int fam15h_power_init_data(struct pci_dev *f4, struct fam15h_power_data *data) { - u32 val, eax, ebx, ecx, edx; + u32 val; u64 tmp; int ret; @@ -317,10 +430,9 @@ static int fam15h_power_init_data(struct pci_dev *f4, if (ret) return ret; - cpuid(0x80000007, &eax, &ebx, &ecx, &edx); /* CPUID Fn8000_0007:EDX[12] indicates to support accumulated power */ - if (!(edx & BIT(12))) + if (!boot_cpu_has(X86_FEATURE_ACC_POWER)) return 0; /* @@ -328,7 +440,7 @@ static int fam15h_power_init_data(struct pci_dev *f4, * sample period to the PTSC counter period by executing CPUID * Fn8000_0007:ECX */ - data->cpu_pwr_sample_ratio = ecx; + data->cpu_pwr_sample_ratio = cpuid_ecx(0x80000007); if (rdmsrl_safe(MSR_F15H_CU_MAX_PWR_ACCUMULATOR, &tmp)) { pr_err("Failed to read max compute unit power accumulator MSR\n"); @@ -337,6 +449,14 @@ static int fam15h_power_init_data(struct pci_dev *f4, data->max_cu_acc_power = tmp; + /* + * Milliseconds are a reasonable interval for the measurement. + * But it shouldn't set too long here, because several seconds + * would cause the read function to hang. So set default + * interval as 10 ms. + */ + data->power_period = 10; + return read_registers(data); }