// 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_obj(*adev);	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 intpeci_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 */		.x86_vfm = INTEL_HASWELL_X,		.data	= "hsx",	},	{ /* Broadwell Xeon */		.x86_vfm = INTEL_BROADWELL_X,		.data	= "bdx",	},	{ /* Broadwell Xeon D */		.x86_vfm = INTEL_BROADWELL_D,		.data	= "bdxd",	},	{ /* Skylake Xeon */		.x86_vfm = INTEL_SKYLAKE_X,		.data	= "skx",	},	{ /* Icelake Xeon */		.x86_vfm = INTEL_ICELAKE_X,		.data	= "icx",	},	{ /* Icelake Xeon D */		.x86_vfm = INTEL_ICELAKE_D,		.data	= "icxd",	},	{ /* Sapphire Rapids Xeon */		.x86_vfm = INTEL_SAPPHIRERAPIDS_X,		.data	= "spr",	},	{ /* Emerald Rapids Xeon */		.x86_vfm  = INTEL_EMERALDRAPIDS_X,		.data  = "emr",	},	{ }};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 <iwona.winiarska@intel.com>");MODULE_DESCRIPTION("PECI CPU driver");MODULE_LICENSE("GPL");MODULE_IMPORT_NS("PECI");