Unverified Commit 1071a285 authored by openeuler-ci-bot's avatar openeuler-ci-bot Committed by Gitee
Browse files

!13850 intel: backport TPMI uncore frequency driver update from 6.10 

Merge Pull Request from: @jiayingbao 
 
backport update from 6.10
including version update and other fix

Test:
uncore-driver sysfs interface work as expected
 
 
Link:https://gitee.com/openeuler/kernel/pulls/13850

 

Reviewed-by: default avatarJason Zeng <jason.zeng@intel.com>
Signed-off-by: default avatarZhang Peng <zhangpeng362@huawei.com>
parents 866d8b3f ad7f6cc3

drivers/platform/x86/intel/uncore-frequency/uncore-frequency-common.c

+27 −56
Original line number Diff line number Diff line
@@ -19,9 +19,8 @@ static int uncore_instance_count; 
static DEFINE_IDA(intel_uncore_ida);



/* callbacks for actual HW read/write */

static int (*uncore_read)(struct uncore_data *data, unsigned int *min, unsigned int *max);

static int (*uncore_write)(struct uncore_data *data, unsigned int input, unsigned int min_max);

static int (*uncore_read_freq)(struct uncore_data *data, unsigned int *freq);

static int (*uncore_read)(struct uncore_data *data, unsigned int *value, enum uncore_index index);

static int (*uncore_write)(struct uncore_data *data, unsigned int input, enum uncore_index index);



static ssize_t show_domain_id(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

{
@@ -44,27 +43,22 @@ static ssize_t show_package_id(struct kobject *kobj, struct kobj_attribute *attr 
	return sprintf(buf, "%u\n", data->package_id);

}



static ssize_t show_min_max_freq_khz(struct uncore_data *data,

				      char *buf, int min_max)

static ssize_t show_attr(struct uncore_data *data, char *buf, enum uncore_index index)

{

	unsigned int min, max;

	unsigned int value;

	int ret;



	mutex_lock(&uncore_lock);

	ret = uncore_read(data, &min, &max);

	ret = uncore_read(data, &value, index);

	mutex_unlock(&uncore_lock);

	if (ret)

		return ret;



	if (min_max)

		return sprintf(buf, "%u\n", max);



	return sprintf(buf, "%u\n", min);

	return sprintf(buf, "%u\n", value);

}



static ssize_t store_min_max_freq_khz(struct uncore_data *data,

				      const char *buf, ssize_t count,

				      int min_max)

static ssize_t store_attr(struct uncore_data *data, const char *buf, ssize_t count,

			  enum uncore_index index)

{

	unsigned int input;

	int ret;
@@ -73,7 +67,7 @@ static ssize_t store_min_max_freq_khz(struct uncore_data *data, 
		return -EINVAL;



	mutex_lock(&uncore_lock);

	ret = uncore_write(data, input, min_max);

	ret = uncore_write(data, input, index);

	mutex_unlock(&uncore_lock);



	if (ret)
@@ -82,56 +76,32 @@ static ssize_t store_min_max_freq_khz(struct uncore_data *data, 
	return count;

}



static ssize_t show_perf_status_freq_khz(struct uncore_data *data, char *buf)

{

	unsigned int freq;

	int ret;



	mutex_lock(&uncore_lock);

	ret = uncore_read_freq(data, &freq);

	mutex_unlock(&uncore_lock);

	if (ret)

		return ret;



	return sprintf(buf, "%u\n", freq);

}



#define store_uncore_min_max(name, min_max)				\

#define store_uncore_attr(name, index)					\

	static ssize_t store_##name(struct kobject *kobj,		\

				     struct kobj_attribute *attr,	\

				     const char *buf, size_t count)	\

	{								\

		struct uncore_data *data = container_of(attr, struct uncore_data, name##_kobj_attr);\

									\

		return store_min_max_freq_khz(data, buf, count,	\

					      min_max);		\

	}



#define show_uncore_min_max(name, min_max)				\

	static ssize_t show_##name(struct kobject *kobj,		\

				    struct kobj_attribute *attr, char *buf)\

	{                                                               \

		struct uncore_data *data = container_of(attr, struct uncore_data, name##_kobj_attr);\

									\

		return show_min_max_freq_khz(data, buf, min_max);	\

		return store_attr(data, buf, count, index);		\

	}



#define show_uncore_perf_status(name)					\

#define show_uncore_attr(name, index)					\

	static ssize_t show_##name(struct kobject *kobj,		\

				    struct kobj_attribute *attr, char *buf)\

	{                                                               \

		struct uncore_data *data = container_of(attr, struct uncore_data, name##_kobj_attr);\

									\

		return show_perf_status_freq_khz(data, buf); \

		return show_attr(data, buf, index);			\

	}



store_uncore_min_max(min_freq_khz, 0);

store_uncore_min_max(max_freq_khz, 1);

store_uncore_attr(min_freq_khz, UNCORE_INDEX_MIN_FREQ);

store_uncore_attr(max_freq_khz, UNCORE_INDEX_MAX_FREQ);



show_uncore_min_max(min_freq_khz, 0);

show_uncore_min_max(max_freq_khz, 1);

show_uncore_attr(min_freq_khz, UNCORE_INDEX_MIN_FREQ);

show_uncore_attr(max_freq_khz, UNCORE_INDEX_MAX_FREQ);



show_uncore_perf_status(current_freq_khz);

show_uncore_attr(current_freq_khz, UNCORE_INDEX_CURRENT_FREQ);



#define show_uncore_data(member_name)					\

	static ssize_t show_##member_name(struct kobject *kobj,	\
@@ -198,7 +168,7 @@ static int create_attr_group(struct uncore_data *data, char *name) 
	data->uncore_attrs[index++] = &data->initial_min_freq_khz_kobj_attr.attr;

	data->uncore_attrs[index++] = &data->initial_max_freq_khz_kobj_attr.attr;



	ret = uncore_read_freq(data, &freq);

	ret = uncore_read(data, &freq, UNCORE_INDEX_CURRENT_FREQ);

	if (!ret)

		data->uncore_attrs[index++] = &data->current_freq_khz_kobj_attr.attr;
@@ -238,7 +208,8 @@ int uncore_freq_add_entry(struct uncore_data *data, int cpu) 
		sprintf(data->name, "package_%02d_die_%02d", data->package_id, data->die_id);

	}



	uncore_read(data, &data->initial_min_freq_khz, &data->initial_max_freq_khz);

	uncore_read(data, &data->initial_min_freq_khz, UNCORE_INDEX_MIN_FREQ);

	uncore_read(data, &data->initial_max_freq_khz, UNCORE_INDEX_MAX_FREQ);



	ret = create_attr_group(data, data->name);

	if (ret) {
@@ -269,15 +240,15 @@ void uncore_freq_remove_die_entry(struct uncore_data *data) 
}

EXPORT_SYMBOL_NS_GPL(uncore_freq_remove_die_entry, INTEL_UNCORE_FREQUENCY);



int uncore_freq_common_init(int (*read_control_freq)(struct uncore_data *data, unsigned int *min, unsigned int *max),

			     int (*write_control_freq)(struct uncore_data *data, unsigned int input, unsigned int set_max),

			     int (*read_freq)(struct uncore_data *data, unsigned int *freq))

int uncore_freq_common_init(int (*read)(struct uncore_data *data, unsigned int *value,

					enum uncore_index index),

			    int (*write)(struct uncore_data *data, unsigned int input,

					 enum uncore_index index))

{

	mutex_lock(&uncore_lock);



	uncore_read = read_control_freq;

	uncore_write = write_control_freq;

	uncore_read_freq = read_freq;

	uncore_read = read;

	uncore_write = write;



	if (!uncore_root_kobj) {

		struct device *dev_root = bus_get_dev_root(&cpu_subsys);

drivers/platform/x86/intel/uncore-frequency/uncore-frequency-common.h

+10 −3
Original line number Diff line number Diff line
@@ -66,9 +66,16 @@ struct uncore_data { 


#define UNCORE_DOMAIN_ID_INVALID	-1



int uncore_freq_common_init(int (*read_control_freq)(struct uncore_data *data, unsigned int *min, unsigned int *max),

			     int (*write_control_freq)(struct uncore_data *data, unsigned int input, unsigned int min_max),

			     int (*uncore_read_freq)(struct uncore_data *data, unsigned int *freq));

enum uncore_index {

	UNCORE_INDEX_MIN_FREQ,

	UNCORE_INDEX_MAX_FREQ,

	UNCORE_INDEX_CURRENT_FREQ,

};



int uncore_freq_common_init(int (*read)(struct uncore_data *data, unsigned int *value,

					enum uncore_index index),

			    int (*write)(struct uncore_data *data, unsigned int input,

					 enum uncore_index index));

void uncore_freq_common_exit(void);

int uncore_freq_add_entry(struct uncore_data *data, int cpu);

void uncore_freq_remove_die_entry(struct uncore_data *data);

drivers/platform/x86/intel/uncore-frequency/uncore-frequency-tpmi.c

+95 −39
Original line number Diff line number Diff line
@@ -28,7 +28,8 @@ 


#include "uncore-frequency-common.h"



#define	UNCORE_HEADER_VERSION		1

#define	UNCORE_MAJOR_VERSION		0

#define	UNCORE_MINOR_VERSION		2

#define UNCORE_HEADER_INDEX		0

#define UNCORE_FABRIC_CLUSTER_OFFSET	8
@@ -65,28 +66,34 @@ struct tpmi_uncore_struct { 
	int min_ratio;

	struct tpmi_uncore_power_domain_info *pd_info;

	struct tpmi_uncore_cluster_info root_cluster;

	bool write_blocked;

};



#define UNCORE_GENMASK_MIN_RATIO	GENMASK_ULL(21, 15)

#define UNCORE_GENMASK_MAX_RATIO	GENMASK_ULL(14, 8)

#define UNCORE_GENMASK_CURRENT_RATIO	GENMASK_ULL(6, 0)

/* Bit definitions for STATUS register */

#define UNCORE_CURRENT_RATIO_MASK			GENMASK_ULL(6, 0)



/* Bit definitions for CONTROL register */

#define UNCORE_MAX_RATIO_MASK				GENMASK_ULL(14, 8)

#define UNCORE_MIN_RATIO_MASK				GENMASK_ULL(21, 15)



/* Helper function to read MMIO offset for max/min control frequency */

static void read_control_freq(struct tpmi_uncore_cluster_info *cluster_info,

			     unsigned int *min, unsigned int *max)

			     unsigned int *value, enum uncore_index index)

{

	u64 control;



	control = readq(cluster_info->cluster_base + UNCORE_CONTROL_INDEX);

	*max = FIELD_GET(UNCORE_GENMASK_MAX_RATIO, control) * UNCORE_FREQ_KHZ_MULTIPLIER;

	*min = FIELD_GET(UNCORE_GENMASK_MIN_RATIO, control) * UNCORE_FREQ_KHZ_MULTIPLIER;

	if (index == UNCORE_INDEX_MAX_FREQ)

		*value = FIELD_GET(UNCORE_MAX_RATIO_MASK, control) * UNCORE_FREQ_KHZ_MULTIPLIER;

	else

		*value = FIELD_GET(UNCORE_MIN_RATIO_MASK, control) * UNCORE_FREQ_KHZ_MULTIPLIER;

}



#define UNCORE_MAX_RATIO	FIELD_MAX(UNCORE_GENMASK_MAX_RATIO)

#define UNCORE_MAX_RATIO	FIELD_MAX(UNCORE_MAX_RATIO_MASK)



/* Callback for sysfs read for max/min frequencies. Called under mutex locks */

static int uncore_read_control_freq(struct uncore_data *data, unsigned int *min,

				    unsigned int *max)

/* Helper for sysfs read for max/min frequencies. Called under mutex locks */

static int uncore_read_control_freq(struct uncore_data *data, unsigned int *value,

				    enum uncore_index index)

{

	struct tpmi_uncore_cluster_info *cluster_info;
@@ -94,10 +101,11 @@ static int uncore_read_control_freq(struct uncore_data *data, unsigned int *min, 


	if (cluster_info->root_domain) {

		struct tpmi_uncore_struct *uncore_root = cluster_info->uncore_root;

		int i, _min = 0, _max = 0;

		unsigned int min, max, v;

		int i;



		*min = UNCORE_MAX_RATIO * UNCORE_FREQ_KHZ_MULTIPLIER;

		*max = 0;

		min = UNCORE_MAX_RATIO * UNCORE_FREQ_KHZ_MULTIPLIER;

		max = 0;



		/*

		 * Get the max/min by looking at each cluster. Get the lowest
@@ -108,35 +116,41 @@ static int uncore_read_control_freq(struct uncore_data *data, unsigned int *min, 


			for (j = 0; j < uncore_root->pd_info[i].cluster_count; ++j) {

				read_control_freq(&uncore_root->pd_info[i].cluster_infos[j],

						  &_min, &_max);

				if (*min > _min)

					*min = _min;

				if (*max < _max)

					*max = _max;

						  &v, index);

				if (v < min)

					min = v;

				if (v > max)

					max = v;

			}

		}



		if (index == UNCORE_INDEX_MIN_FREQ)

			*value = min;

		else

			*value = max;



		return 0;

	}



	read_control_freq(cluster_info, min, max);

	read_control_freq(cluster_info, value, index);



	return 0;

}



/* Helper function to write MMIO offset for max/min control frequency */

static void write_control_freq(struct tpmi_uncore_cluster_info *cluster_info, unsigned int input,

			      unsigned int min_max)

			      unsigned int index)

{

	u64 control;



	control = readq(cluster_info->cluster_base + UNCORE_CONTROL_INDEX);



	if (min_max) {

		control &= ~UNCORE_GENMASK_MAX_RATIO;

		control |= FIELD_PREP(UNCORE_GENMASK_MAX_RATIO, input);

	if (index == UNCORE_INDEX_MAX_FREQ) {

		control &= ~UNCORE_MAX_RATIO_MASK;

		control |= FIELD_PREP(UNCORE_MAX_RATIO_MASK, input);

	} else {

		control &= ~UNCORE_GENMASK_MIN_RATIO;

		control |= FIELD_PREP(UNCORE_GENMASK_MIN_RATIO, input);

		control &= ~UNCORE_MIN_RATIO_MASK;

		control |= FIELD_PREP(UNCORE_MIN_RATIO_MASK, input);

	}



	writeq(control, (cluster_info->cluster_base + UNCORE_CONTROL_INDEX));
@@ -144,7 +158,7 @@ static void write_control_freq(struct tpmi_uncore_cluster_info *cluster_info, un 


/* Callback for sysfs write for max/min frequencies. Called under mutex locks */

static int uncore_write_control_freq(struct uncore_data *data, unsigned int input,

				     unsigned int min_max)

				     enum uncore_index index)

{

	struct tpmi_uncore_cluster_info *cluster_info;

	struct tpmi_uncore_struct *uncore_root;
@@ -156,6 +170,9 @@ static int uncore_write_control_freq(struct uncore_data *data, unsigned int inpu 
	cluster_info = container_of(data, struct tpmi_uncore_cluster_info, uncore_data);

	uncore_root = cluster_info->uncore_root;



	if (uncore_root->write_blocked)

		return -EPERM;



	/* Update each cluster in a package */

	if (cluster_info->root_domain) {

		struct tpmi_uncore_struct *uncore_root = cluster_info->uncore_root;
@@ -166,10 +183,10 @@ static int uncore_write_control_freq(struct uncore_data *data, unsigned int inpu 


			for (j = 0; j < uncore_root->pd_info[i].cluster_count; ++j)

				write_control_freq(&uncore_root->pd_info[i].cluster_infos[j],

						  input, min_max);

						  input, index);

		}



		if (min_max)

		if (index == UNCORE_INDEX_MAX_FREQ)

			uncore_root->max_ratio = input;

		else

			uncore_root->min_ratio = input;
@@ -177,18 +194,20 @@ static int uncore_write_control_freq(struct uncore_data *data, unsigned int inpu 
		return 0;

	}



	if (min_max && uncore_root->max_ratio && uncore_root->max_ratio < input)

	if (index == UNCORE_INDEX_MAX_FREQ && uncore_root->max_ratio &&

	    uncore_root->max_ratio < input)

		return -EINVAL;



	if (!min_max && uncore_root->min_ratio && uncore_root->min_ratio > input)

	if (index == UNCORE_INDEX_MIN_FREQ && uncore_root->min_ratio &&

	    uncore_root->min_ratio > input)

		return -EINVAL;



	write_control_freq(cluster_info, input, min_max);

	write_control_freq(cluster_info, input, index);



	return 0;

}



/* Callback for sysfs read for the current uncore frequency. Called under mutex locks */

/* Helper for sysfs read for the current uncore frequency. Called under mutex locks */

static int uncore_read_freq(struct uncore_data *data, unsigned int *freq)

{

	struct tpmi_uncore_cluster_info *cluster_info;
@@ -199,11 +218,29 @@ static int uncore_read_freq(struct uncore_data *data, unsigned int *freq) 
		return -ENODATA;



	status = readq((u8 __iomem *)cluster_info->cluster_base + UNCORE_STATUS_INDEX);

	*freq = FIELD_GET(UNCORE_GENMASK_CURRENT_RATIO, status) * UNCORE_FREQ_KHZ_MULTIPLIER;

	*freq = FIELD_GET(UNCORE_CURRENT_RATIO_MASK, status) * UNCORE_FREQ_KHZ_MULTIPLIER;



	return 0;

}



/* Callback for sysfs read for TPMI uncore values. Called under mutex locks. */

static int uncore_read(struct uncore_data *data, unsigned int *value, enum uncore_index index)

{

	switch (index) {

	case UNCORE_INDEX_MIN_FREQ:

	case UNCORE_INDEX_MAX_FREQ:

		return uncore_read_control_freq(data, value, index);



	case UNCORE_INDEX_CURRENT_FREQ:

		return uncore_read_freq(data, value);



	default:

		break;

	}



	return -EOPNOTSUPP;

}



static void remove_cluster_entries(struct tpmi_uncore_struct *tpmi_uncore)

{

	int i;
@@ -232,20 +269,29 @@ static void remove_cluster_entries(struct tpmi_uncore_struct *tpmi_uncore) 


static int uncore_probe(struct auxiliary_device *auxdev, const struct auxiliary_device_id *id)

{

	bool read_blocked = 0, write_blocked = 0;

	struct intel_tpmi_plat_info *plat_info;

	struct tpmi_uncore_struct *tpmi_uncore;

	bool uncore_sysfs_added = false;

	int ret, i, pkg = 0;

	int num_resources;



	ret = tpmi_get_feature_status(auxdev, TPMI_ID_UNCORE, &read_blocked, &write_blocked);

	if (ret)

		dev_info(&auxdev->dev, "Can't read feature status: ignoring blocked status\n");



	if (read_blocked) {

		dev_info(&auxdev->dev, "Firmware has blocked reads, exiting\n");

		return -ENODEV;

	}



	/* Get number of power domains, which is equal to number of resources */

	num_resources = tpmi_get_resource_count(auxdev);

	if (!num_resources)

		return -EINVAL;



	/* Register callbacks to uncore core */

	ret = uncore_freq_common_init(uncore_read_control_freq, uncore_write_control_freq,

				      uncore_read_freq);

	ret = uncore_freq_common_init(uncore_read, uncore_write_control_freq);

	if (ret)

		return ret;
@@ -266,6 +312,7 @@ static int uncore_probe(struct auxiliary_device *auxdev, const struct auxiliary_ 
	}



	tpmi_uncore->power_domain_count = num_resources;

	tpmi_uncore->write_blocked = write_blocked;



	/* Get the package ID from the TPMI core */

	plat_info = tpmi_get_platform_data(auxdev);
@@ -303,12 +350,21 @@ static int uncore_probe(struct auxiliary_device *auxdev, const struct auxiliary_ 
		/* Check for version and skip this resource if there is mismatch */

		header = readq(pd_info->uncore_base);

		pd_info->ufs_header_ver = header & UNCORE_VERSION_MASK;

		if (pd_info->ufs_header_ver != UNCORE_HEADER_VERSION) {

			dev_info(&auxdev->dev, "Uncore: Unsupported version:%d\n",

				pd_info->ufs_header_ver);



		if (pd_info->ufs_header_ver == TPMI_VERSION_INVALID)

			continue;



		if (TPMI_MAJOR_VERSION(pd_info->ufs_header_ver) != UNCORE_MAJOR_VERSION) {

			dev_err(&auxdev->dev, "Uncore: Unsupported major version:%lx\n",

				TPMI_MAJOR_VERSION(pd_info->ufs_header_ver));

			ret = -ENODEV;

			goto remove_clusters;

		}



		if (TPMI_MINOR_VERSION(pd_info->ufs_header_ver) > UNCORE_MINOR_VERSION)

			dev_info(&auxdev->dev, "Uncore: Ignore: Unsupported minor version:%lx\n",

				 TPMI_MINOR_VERSION(pd_info->ufs_header_ver));



		/* Get Cluster ID Mask */

		cluster_mask = FIELD_GET(UNCORE_LOCAL_FABRIC_CLUSTER_ID_MASK, header);

		if (!cluster_mask) {

drivers/platform/x86/intel/uncore-frequency/uncore-frequency.c

+38 −14
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 * Author: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>

 */



#include <linux/bitfield.h>

#include <linux/cpu.h>

#include <linux/module.h>

#include <linux/slab.h>
@@ -36,8 +37,13 @@ static enum cpuhp_state uncore_hp_state __read_mostly; 
#define MSR_UNCORE_PERF_STATUS	0x621

#define UNCORE_FREQ_KHZ_MULTIPLIER	100000



static int uncore_read_control_freq(struct uncore_data *data, unsigned int *min,

				    unsigned int *max)

#define UNCORE_MAX_RATIO_MASK	GENMASK_ULL(6, 0)

#define UNCORE_MIN_RATIO_MASK	GENMASK_ULL(14, 8)



#define UNCORE_CURRENT_RATIO_MASK	GENMASK_ULL(6, 0)



static int uncore_read_control_freq(struct uncore_data *data, unsigned int *value,

				    enum uncore_index index)

{

	u64 cap;

	int ret;
@@ -49,20 +55,22 @@ static int uncore_read_control_freq(struct uncore_data *data, unsigned int *min, 
	if (ret)

		return ret;



	*max = (cap & 0x7F) * UNCORE_FREQ_KHZ_MULTIPLIER;

	*min = ((cap & GENMASK(14, 8)) >> 8) * UNCORE_FREQ_KHZ_MULTIPLIER;

	if (index == UNCORE_INDEX_MAX_FREQ)

		*value = FIELD_GET(UNCORE_MAX_RATIO_MASK, cap) * UNCORE_FREQ_KHZ_MULTIPLIER;

	else

		*value = FIELD_GET(UNCORE_MIN_RATIO_MASK, cap) * UNCORE_FREQ_KHZ_MULTIPLIER;



	return 0;

}



static int uncore_write_control_freq(struct uncore_data *data, unsigned int input,

				     unsigned int min_max)

				     enum uncore_index index)

{

	int ret;

	u64 cap;



	input /= UNCORE_FREQ_KHZ_MULTIPLIER;

	if (!input || input > 0x7F)

	if (!input || input > FIELD_MAX(UNCORE_MAX_RATIO_MASK))

		return -EINVAL;



	if (data->control_cpu < 0)
@@ -72,12 +80,12 @@ static int uncore_write_control_freq(struct uncore_data *data, unsigned int inpu 
	if (ret)

		return ret;



	if (min_max) {

		cap &= ~0x7F;

		cap |= input;

	if (index == UNCORE_INDEX_MAX_FREQ) {

		cap &= ~UNCORE_MAX_RATIO_MASK;

		cap |= FIELD_PREP(UNCORE_MAX_RATIO_MASK, input);

	} else  {

		cap &= ~GENMASK(14, 8);

		cap |= (input << 8);

		cap &= ~UNCORE_MIN_RATIO_MASK;

		cap |= FIELD_PREP(UNCORE_MIN_RATIO_MASK, input);

	}



	ret = wrmsrl_on_cpu(data->control_cpu, MSR_UNCORE_RATIO_LIMIT, cap);
@@ -101,11 +109,28 @@ static int uncore_read_freq(struct uncore_data *data, unsigned int *freq) 
	if (ret)

		return ret;



	*freq = (ratio & 0x7F) * UNCORE_FREQ_KHZ_MULTIPLIER;

	*freq = FIELD_GET(UNCORE_CURRENT_RATIO_MASK, ratio) * UNCORE_FREQ_KHZ_MULTIPLIER;



	return 0;

}



static int uncore_read(struct uncore_data *data, unsigned int *value, enum uncore_index index)

{

	switch (index) {

	case UNCORE_INDEX_MIN_FREQ:

	case UNCORE_INDEX_MAX_FREQ:

		return uncore_read_control_freq(data, value, index);



	case UNCORE_INDEX_CURRENT_FREQ:

		return uncore_read_freq(data, value);



	default:

		break;

	}



	return -EOPNOTSUPP;

}



/* Caller provides protection */

static struct uncore_data *uncore_get_instance(unsigned int cpu)

{
@@ -235,8 +260,7 @@ static int __init intel_uncore_init(void) 
	if (!uncore_instances)

		return -ENOMEM;



	ret = uncore_freq_common_init(uncore_read_control_freq, uncore_write_control_freq,

				      uncore_read_freq);

	ret = uncore_freq_common_init(uncore_read, uncore_write_control_freq);

	if (ret)

		goto err_free;