[linux.git] / drivers / peci / cpu.c

// SPDX-License-Identifier: GPL-2.0-only
// Copyright (c) 2021 Intel Corporation

#include <linux/auxiliary_bus.h>
#include <linux/module.h>
#include <linux/peci.h>
#include <linux/peci-cpu.h>
#include <linux/slab.h>

#include "internal.h"

/**
 * peci_temp_read() - read the maximum die temperature from PECI target device
 * @device: PECI device to which request is going to be sent
 * @temp_raw: where to store the read temperature
 *
 * It uses GetTemp PECI command.
 *
 * Return: 0 if succeeded, other values in case errors.
 */
int peci_temp_read(struct peci_device *device, s16 *temp_raw)
{
	struct peci_request *req;

	req = peci_xfer_get_temp(device);
	if (IS_ERR(req))
		return PTR_ERR(req);

	*temp_raw = peci_request_temp_read(req);

	peci_request_free(req);

	return 0;
}
EXPORT_SYMBOL_NS_GPL(peci_temp_read, PECI_CPU);

/**
 * peci_pcs_read() - read PCS register
 * @device: PECI device to which request is going to be sent
 * @index: PCS index
 * @param: PCS parameter
 * @data: where to store the read data
 *
 * It uses RdPkgConfig PECI command.
 *
 * Return: 0 if succeeded, other values in case errors.
 */
int peci_pcs_read(struct peci_device *device, u8 index, u16 param, u32 *data)
{
	struct peci_request *req;
	int ret;

	req = peci_xfer_pkg_cfg_readl(device, index, param);
	if (IS_ERR(req))
		return PTR_ERR(req);

	ret = peci_request_status(req);
	if (ret)
		goto out_req_free;

	*data = peci_request_data_readl(req);
out_req_free:
	peci_request_free(req);

	return ret;
}
EXPORT_SYMBOL_NS_GPL(peci_pcs_read, PECI_CPU);

/**
 * peci_pci_local_read() - read 32-bit memory location using raw address
 * @device: PECI device to which request is going to be sent
 * @bus: bus
 * @dev: device
 * @func: function
 * @reg: register
 * @data: where to store the read data
 *
 * It uses RdPCIConfigLocal PECI command.
 *
 * Return: 0 if succeeded, other values in case errors.
 */
int peci_pci_local_read(struct peci_device *device, u8 bus, u8 dev, u8 func,
			u16 reg, u32 *data)
{
	struct peci_request *req;
	int ret;

	req = peci_xfer_pci_cfg_local_readl(device, bus, dev, func, reg);
	if (IS_ERR(req))
		return PTR_ERR(req);

	ret = peci_request_status(req);
	if (ret)
		goto out_req_free;

	*data = peci_request_data_readl(req);
out_req_free:
	peci_request_free(req);

	return ret;
}
EXPORT_SYMBOL_NS_GPL(peci_pci_local_read, PECI_CPU);

/**
 * peci_ep_pci_local_read() - read 32-bit memory location using raw address
 * @device: PECI device to which request is going to be sent
 * @seg: PCI segment
 * @bus: bus
 * @dev: device
 * @func: function
 * @reg: register
 * @data: where to store the read data
 *
 * Like &peci_pci_local_read, but it uses RdEndpointConfig PECI command.
 *
 * Return: 0 if succeeded, other values in case errors.
 */
int peci_ep_pci_local_read(struct peci_device *device, u8 seg,
			   u8 bus, u8 dev, u8 func, u16 reg, u32 *data)
{
	struct peci_request *req;
	int ret;

	req = peci_xfer_ep_pci_cfg_local_readl(device, seg, bus, dev, func, reg);
	if (IS_ERR(req))
		return PTR_ERR(req);

	ret = peci_request_status(req);
	if (ret)
		goto out_req_free;

	*data = peci_request_data_readl(req);
out_req_free:
	peci_request_free(req);

	return ret;
}
EXPORT_SYMBOL_NS_GPL(peci_ep_pci_local_read, PECI_CPU);

/**
 * peci_mmio_read() - read 32-bit memory location using 64-bit bar offset address
 * @device: PECI device to which request is going to be sent
 * @bar: PCI bar
 * @seg: PCI segment
 * @bus: bus
 * @dev: device
 * @func: function
 * @address: 64-bit MMIO address
 * @data: where to store the read data
 *
 * It uses RdEndpointConfig PECI command.
 *
 * Return: 0 if succeeded, other values in case errors.
 */
int peci_mmio_read(struct peci_device *device, u8 bar, u8 seg,
		   u8 bus, u8 dev, u8 func, u64 address, u32 *data)
{
	struct peci_request *req;
	int ret;

	req = peci_xfer_ep_mmio64_readl(device, bar, seg, bus, dev, func, address);
	if (IS_ERR(req))
		return PTR_ERR(req);

	ret = peci_request_status(req);
	if (ret)
		goto out_req_free;

	*data = peci_request_data_readl(req);
out_req_free:
	peci_request_free(req);

	return ret;
}
EXPORT_SYMBOL_NS_GPL(peci_mmio_read, PECI_CPU);

static const char * const peci_adev_types[] = {
	"cputemp",
	"dimmtemp",
};

struct peci_cpu {
	struct peci_device *device;
	const struct peci_device_id *id;
};

static void adev_release(struct device *dev)
{
	struct auxiliary_device *adev = to_auxiliary_dev(dev);

	kfree(adev->name);
	kfree(adev);
}

static struct auxiliary_device *adev_alloc(struct peci_cpu *priv, int idx)
{
	struct peci_controller *controller = to_peci_controller(priv->device->dev.parent);
	struct auxiliary_device *adev;
	const char *name;
	int ret;

	adev = kzalloc(sizeof(*adev), GFP_KERNEL);
	if (!adev)
		return ERR_PTR(-ENOMEM);

	name = kasprintf(GFP_KERNEL, "%s.%s", peci_adev_types[idx], (const char *)priv->id->data);
	if (!name) {
		ret = -ENOMEM;
		goto free_adev;
	}

	adev->name = name;
	adev->dev.parent = &priv->device->dev;
	adev->dev.release = adev_release;
	adev->id = (controller->id << 16) | (priv->device->addr);

	ret = auxiliary_device_init(adev);
	if (ret)
		goto free_name;

	return adev;

free_name:
	kfree(name);
free_adev:
	kfree(adev);
	return ERR_PTR(ret);
}

static void unregister_adev(void *_adev)
{
	struct auxiliary_device *adev = _adev;

	auxiliary_device_delete(adev);
	auxiliary_device_uninit(adev);
}

static int devm_adev_add(struct device *dev, int idx)
{
	struct peci_cpu *priv = dev_get_drvdata(dev);
	struct auxiliary_device *adev;
	int ret;

	adev = adev_alloc(priv, idx);
	if (IS_ERR(adev))
		return PTR_ERR(adev);

	ret = auxiliary_device_add(adev);
	if (ret) {
		auxiliary_device_uninit(adev);
		return ret;
	}

	ret = devm_add_action_or_reset(&priv->device->dev, unregister_adev, adev);
	if (ret)
		return ret;

	return 0;
}

static void peci_cpu_add_adevices(struct peci_cpu *priv)
{
	struct device *dev = &priv->device->dev;
	int ret, i;

	for (i = 0; i < ARRAY_SIZE(peci_adev_types); i++) {
		ret = devm_adev_add(dev, i);
		if (ret) {
			dev_warn(dev, "Failed to register PECI auxiliary: %s, ret = %d\n",
				 peci_adev_types[i], ret);
			continue;
		}
	}
}

static int
peci_cpu_probe(struct peci_device *device, const struct peci_device_id *id)
{
	struct device *dev = &device->dev;
	struct peci_cpu *priv;

	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	dev_set_drvdata(dev, priv);
	priv->device = device;
	priv->id = id;

	peci_cpu_add_adevices(priv);

	return 0;
}

static const struct peci_device_id peci_cpu_device_ids[] = {
	{ /* Haswell Xeon */
		.family	= 6,
		.model	= INTEL_FAM6_HASWELL_X,
		.data	= "hsx",
	},
	{ /* Broadwell Xeon */
		.family	= 6,
		.model	= INTEL_FAM6_BROADWELL_X,
		.data	= "bdx",
	},
	{ /* Broadwell Xeon D */
		.family	= 6,
		.model	= INTEL_FAM6_BROADWELL_D,
		.data	= "bdxd",
	},
	{ /* Skylake Xeon */
		.family	= 6,
		.model	= INTEL_FAM6_SKYLAKE_X,
		.data	= "skx",
	},
	{ /* Icelake Xeon */
		.family	= 6,
		.model	= INTEL_FAM6_ICELAKE_X,
		.data	= "icx",
	},
	{ /* Icelake Xeon D */
		.family	= 6,
		.model	= INTEL_FAM6_ICELAKE_D,
		.data	= "icxd",
	},
	{ /* Sapphire Rapids Xeon */
		.family	= 6,
		.model	= INTEL_FAM6_SAPPHIRERAPIDS_X,
		.data	= "spr",
	},
	{ }
};
MODULE_DEVICE_TABLE(peci, peci_cpu_device_ids);

static struct peci_driver peci_cpu_driver = {
	.probe		= peci_cpu_probe,
	.id_table	= peci_cpu_device_ids,
	.driver		= {
		.name		= "peci-cpu",
	},
};
module_peci_driver(peci_cpu_driver);

MODULE_AUTHOR("Iwona Winiarska <[email protected]>");
MODULE_DESCRIPTION("PECI CPU driver");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(PECI);
Commit	Line	Data
93e1821c IW	1	// SPDX-License-Identifier: GPL-2.0-only
	2	// Copyright (c) 2021 Intel Corporation
	3
	4	#include <linux/auxiliary_bus.h>
	5	#include <linux/module.h>
	6	#include <linux/peci.h>
	7	#include <linux/peci-cpu.h>
	8	#include <linux/slab.h>
	9
	10	#include "internal.h"
	11
	12	/**
	13	* peci_temp_read() - read the maximum die temperature from PECI target device
	14	* @device: PECI device to which request is going to be sent
	15	* @temp_raw: where to store the read temperature
	16	*
	17	* It uses GetTemp PECI command.
	18	*
	19	* Return: 0 if succeeded, other values in case errors.
	20	*/
	21	int peci_temp_read(struct peci_device device, s16 temp_raw)
	22	{
	23	struct peci_request *req;
	24
	25	req = peci_xfer_get_temp(device);
	26	if (IS_ERR(req))
	27	return PTR_ERR(req);
	28
	29	*temp_raw = peci_request_temp_read(req);
	30
	31	peci_request_free(req);
	32
	33	return 0;
	34	}
	35	EXPORT_SYMBOL_NS_GPL(peci_temp_read, PECI_CPU);
	36
	37	/**
	38	* peci_pcs_read() - read PCS register
	39	* @device: PECI device to which request is going to be sent
	40	* @index: PCS index
	41	* @param: PCS parameter
	42	* @data: where to store the read data
	43	*
	44	* It uses RdPkgConfig PECI command.
	45	*
	46	* Return: 0 if succeeded, other values in case errors.
	47	*/
	48	int peci_pcs_read(struct peci_device device, u8 index, u16 param, u32 data)
	49	{
	50	struct peci_request *req;
	51	int ret;
	52
	53	req = peci_xfer_pkg_cfg_readl(device, index, param);
	54	if (IS_ERR(req))
	55	return PTR_ERR(req);
	56
	57	ret = peci_request_status(req);
	58	if (ret)
	59	goto out_req_free;
	60
	61	*data = peci_request_data_readl(req);
	62	out_req_free:
	63	peci_request_free(req);
	64
65	return ret;
66	}
67	EXPORT_SYMBOL_NS_GPL(peci_pcs_read, PECI_CPU);
68
69	/**
70	* peci_pci_local_read() - read 32-bit memory location using raw address
71	* @device: PECI device to which request is going to be sent
72	* @bus: bus
73	* @dev: device
74	* @func: function
75	* @reg: register
76	* @data: where to store the read data
77	*
78	* It uses RdPCIConfigLocal PECI command.
79	*
80	* Return: 0 if succeeded, other values in case errors.
81	*/
82	int peci_pci_local_read(struct peci_device *device, u8 bus, u8 dev, u8 func,
83	u16 reg, u32 *data)
84	{
85	struct peci_request *req;
86	int ret;
87
88	req = peci_xfer_pci_cfg_local_readl(device, bus, dev, func, reg);
89	if (IS_ERR(req))
90	return PTR_ERR(req);
91
92	ret = peci_request_status(req);
93	if (ret)
94	goto out_req_free;
95
96	*data = peci_request_data_readl(req);
97	out_req_free:
98	peci_request_free(req);
99
100	return ret;
101	}
102	EXPORT_SYMBOL_NS_GPL(peci_pci_local_read, PECI_CPU);
103
104	/**
105	* peci_ep_pci_local_read() - read 32-bit memory location using raw address
106	* @device: PECI device to which request is going to be sent
107	* @seg: PCI segment
108	* @bus: bus
109	* @dev: device
110	* @func: function
111	* @reg: register
112	* @data: where to store the read data
113	*
114	* Like &peci_pci_local_read, but it uses RdEndpointConfig PECI command.
115	*
116	* Return: 0 if succeeded, other values in case errors.
117	*/
118	int peci_ep_pci_local_read(struct peci_device *device, u8 seg,
119	u8 bus, u8 dev, u8 func, u16 reg, u32 *data)
120	{
121	struct peci_request *req;
122	int ret;
123
124	req = peci_xfer_ep_pci_cfg_local_readl(device, seg, bus, dev, func, reg);
125	if (IS_ERR(req))
126	return PTR_ERR(req);
127
128	ret = peci_request_status(req);
129	if (ret)
130	goto out_req_free;
131
132	*data = peci_request_data_readl(req);
133	out_req_free:
134	peci_request_free(req);
135
136	return ret;
137	}
138	EXPORT_SYMBOL_NS_GPL(peci_ep_pci_local_read, PECI_CPU);
139
140	/**
141	* peci_mmio_read() - read 32-bit memory location using 64-bit bar offset address
142	* @device: PECI device to which request is going to be sent
143	* @bar: PCI bar
144	* @seg: PCI segment
145	* @bus: bus
146	* @dev: device
147	* @func: function
148	* @address: 64-bit MMIO address
149	* @data: where to store the read data
150	*
151	* It uses RdEndpointConfig PECI command.
152	*
153	* Return: 0 if succeeded, other values in case errors.
154	*/
155	int peci_mmio_read(struct peci_device *device, u8 bar, u8 seg,
156	u8 bus, u8 dev, u8 func, u64 address, u32 *data)
157	{
158	struct peci_request *req;
159	int ret;
160
161	req = peci_xfer_ep_mmio64_readl(device, bar, seg, bus, dev, func, address);
162	if (IS_ERR(req))
163	return PTR_ERR(req);
164
165	ret = peci_request_status(req);
166	if (ret)
167	goto out_req_free;
168
169	*data = peci_request_data_readl(req);
170	out_req_free:
171	peci_request_free(req);
172
173	return ret;
174	}
175	EXPORT_SYMBOL_NS_GPL(peci_mmio_read, PECI_CPU);
176
177	static const char * const peci_adev_types[] = {
178	"cputemp",
179	"dimmtemp",
180	};
181
182	struct peci_cpu {
183	struct peci_device *device;
184	const struct peci_device_id *id;
185	};
186
187	static void adev_release(struct device *dev)
188	{
189	struct auxiliary_device *adev = to_auxiliary_dev(dev);
190
93e1821c IW	191	kfree(adev->name);
	192	kfree(adev);
	193	}
	194
	195	static struct auxiliary_device adev_alloc(struct peci_cpu priv, int idx)
	196	{
	197	struct peci_controller *controller = to_peci_controller(priv->device->dev.parent);
	198	struct auxiliary_device *adev;
	199	const char *name;
	200	int ret;
	201
	202	adev = kzalloc(sizeof(*adev), GFP_KERNEL);
	203	if (!adev)
	204	return ERR_PTR(-ENOMEM);
	205
	206	name = kasprintf(GFP_KERNEL, "%s.%s", peci_adev_types[idx], (const char *)priv->id->data);
	207	if (!name) {
	208	ret = -ENOMEM;
	209	goto free_adev;
	210	}
	211
	212	adev->name = name;
	213	adev->dev.parent = &priv->device->dev;
	214	adev->dev.release = adev_release;
	215	adev->id = (controller->id << 16) \| (priv->device->addr);
	216
	217	ret = auxiliary_device_init(adev);
	218	if (ret)
	219	goto free_name;
	220
	221	return adev;
	222
	223	free_name:
	224	kfree(name);
	225	free_adev:
	226	kfree(adev);
	227	return ERR_PTR(ret);
	228	}
	229
	230	static void unregister_adev(void *_adev)
	231	{
	232	struct auxiliary_device *adev = _adev;
	233
	234	auxiliary_device_delete(adev);
1c11289b	235	auxiliary_device_uninit(adev);
93e1821c IW	236	}
	237
	238	static int devm_adev_add(struct device *dev, int idx)
	239	{
	240	struct peci_cpu *priv = dev_get_drvdata(dev);
	241	struct auxiliary_device *adev;
	242	int ret;
	243
	244	adev = adev_alloc(priv, idx);
	245	if (IS_ERR(adev))
	246	return PTR_ERR(adev);
	247
	248	ret = auxiliary_device_add(adev);
	249	if (ret) {
	250	auxiliary_device_uninit(adev);
	251	return ret;
	252	}
	253
	254	ret = devm_add_action_or_reset(&priv->device->dev, unregister_adev, adev);
	255	if (ret)
	256	return ret;
	257
	258	return 0;
	259	}
	260
	261	static void peci_cpu_add_adevices(struct peci_cpu *priv)
	262	{
	263	struct device *dev = &priv->device->dev;
	264	int ret, i;
	265
	266	for (i = 0; i < ARRAY_SIZE(peci_adev_types); i++) {
	267	ret = devm_adev_add(dev, i);
	268	if (ret) {
	269	dev_warn(dev, "Failed to register PECI auxiliary: %s, ret = %d\n",
	270	peci_adev_types[i], ret);
	271	continue;
	272	}
	273	}
	274	}
	275
	276	static int
	277	peci_cpu_probe(struct peci_device device, const struct peci_device_id id)
	278	{
	279	struct device *dev = &device->dev;
	280	struct peci_cpu *priv;
	281
	282	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	283	if (!priv)
	284	return -ENOMEM;
	285
	286	dev_set_drvdata(dev, priv);
	287	priv->device = device;
	288	priv->id = id;
	289
	290	peci_cpu_add_adevices(priv);
	291
	292	return 0;
	293	}
	294
	295	static const struct peci_device_id peci_cpu_device_ids[] = {
	296	{ /* Haswell Xeon */
	297	.family = 6,
	298	.model = INTEL_FAM6_HASWELL_X,
	299	.data = "hsx",
300	},
301	{ /* Broadwell Xeon */
302	.family = 6,
303	.model = INTEL_FAM6_BROADWELL_X,
304	.data = "bdx",
305	},
306	{ /* Broadwell Xeon D */
307	.family = 6,
308	.model = INTEL_FAM6_BROADWELL_D,
309	.data = "bdxd",
310	},
311	{ /* Skylake Xeon */
312	.family = 6,
313	.model = INTEL_FAM6_SKYLAKE_X,
314	.data = "skx",
315	},
316	{ /* Icelake Xeon */
317	.family = 6,
318	.model = INTEL_FAM6_ICELAKE_X,
319	.data = "icx",
320	},
321	{ /* Icelake Xeon D */
322	.family = 6,
323	.model = INTEL_FAM6_ICELAKE_D,
324	.data = "icxd",
325	},
37dd6b9f NS	326	{ /* Sapphire Rapids Xeon */
	327	.family = 6,
	328	.model = INTEL_FAM6_SAPPHIRERAPIDS_X,
	329	.data = "spr",
	330	},
93e1821c IW	331	{ }
	332	};
	333	MODULE_DEVICE_TABLE(peci, peci_cpu_device_ids);
	334
	335	static struct peci_driver peci_cpu_driver = {
	336	.probe = peci_cpu_probe,
	337	.id_table = peci_cpu_device_ids,
	338	.driver = {
	339	.name = "peci-cpu",
	340	},
	341	};
	342	module_peci_driver(peci_cpu_driver);
	343
	344	MODULE_AUTHOR("Iwona Winiarska <[email protected]>");
	345	MODULE_DESCRIPTION("PECI CPU driver");
	346	MODULE_LICENSE("GPL");
	347	MODULE_IMPORT_NS(PECI);