// SPDX-License-Identifier: GPL-2.0-only// Copyright (c) 2018-2021 Intel Corporation #include <linux/bug.h>#include <linux/device.h>#include <linux/export.h>#include <linux/idr.h>#include <linux/module.h>#include <linux/of.h>#include <linux/peci.h>#include <linux/pm_runtime.h>#include <linux/property.h>#include <linux/slab.h> #include "internal.h" static DEFINE_IDA(peci_controller_ida); static void peci_controller_dev_release(struct device *dev){	struct peci_controller *controller = to_peci_controller(dev); 	mutex_destroy(&controller->bus_lock);	ida_free(&peci_controller_ida, controller->id);	kfree(controller);} const struct device_type peci_controller_type = {	.release	= peci_controller_dev_release,}; int peci_controller_scan_devices(struct peci_controller *controller){	int ret;	u8 addr; 	for (addr = PECI_BASE_ADDR; addr < PECI_BASE_ADDR + PECI_DEVICE_NUM_MAX; addr++) {		ret = peci_device_create(controller, addr);		if (ret)			return ret;	} 	return 0;} static struct peci_controller *peci_controller_alloc(struct device *dev,						     const struct peci_controller_ops *ops){	struct peci_controller *controller;	int ret; 	if (!ops->xfer)		return ERR_PTR(-EINVAL); 	controller = kzalloc_obj(*controller);	if (!controller)		return ERR_PTR(-ENOMEM); 	ret = ida_alloc_max(&peci_controller_ida, U8_MAX, GFP_KERNEL);	if (ret < 0)		goto err;	controller->id = ret; 	controller->ops = ops; 	controller->dev.parent = dev;	controller->dev.bus = &peci_bus_type;	controller->dev.type = &peci_controller_type; 	device_initialize(&controller->dev); 	mutex_init(&controller->bus_lock); 	return controller; err:	kfree(controller);	return ERR_PTR(ret);} static int unregister_child(struct device *dev, void *dummy){	peci_device_destroy(to_peci_device(dev)); 	return 0;} static void unregister_controller(void *_controller){	struct peci_controller *controller = _controller; 	/*	 * Detach any active PECI devices. This can't fail, thus we do not	 * check the returned value.	 */	device_for_each_child_reverse(&controller->dev, NULL, unregister_child); 	device_unregister(&controller->dev); 	fwnode_handle_put(controller->dev.fwnode); 	pm_runtime_disable(&controller->dev);} /** * devm_peci_controller_add() - add PECI controller * @dev: device for devm operations * @ops: pointer to controller specific methods * * In final stage of its probe(), peci_controller driver calls * devm_peci_controller_add() to register itself with the PECI bus. * * Return: Pointer to the newly allocated controller or ERR_PTR() in case of failure. */struct peci_controller *devm_peci_controller_add(struct device *dev,						 const struct peci_controller_ops *ops){	struct peci_controller *controller;	int ret; 	controller = peci_controller_alloc(dev, ops);	if (IS_ERR(controller))		return controller; 	ret = dev_set_name(&controller->dev, "peci-%d", controller->id);	if (ret)		goto err_put; 	pm_runtime_no_callbacks(&controller->dev);	pm_suspend_ignore_children(&controller->dev, true);	pm_runtime_enable(&controller->dev); 	device_set_node(&controller->dev, fwnode_handle_get(dev_fwnode(dev))); 	ret = device_add(&controller->dev);	if (ret)		goto err_fwnode; 	ret = devm_add_action_or_reset(dev, unregister_controller, controller);	if (ret)		return ERR_PTR(ret); 	/*	 * Ignoring retval since failures during scan are non-critical for	 * controller itself.	 */	peci_controller_scan_devices(controller); 	return controller; err_fwnode:	fwnode_handle_put(controller->dev.fwnode); 	pm_runtime_disable(&controller->dev); err_put:	put_device(&controller->dev); 	return ERR_PTR(ret);}EXPORT_SYMBOL_NS_GPL(devm_peci_controller_add, "PECI"); static const struct peci_device_id *peci_bus_match_device_id(const struct peci_device_id *id, struct peci_device *device){	while (id->x86_vfm != 0) {		if (id->x86_vfm == device->info.x86_vfm)			return id;		id++;	} 	return NULL;} static int peci_bus_device_match(struct device *dev, const struct device_driver *drv){	struct peci_device *device = to_peci_device(dev);	const struct peci_driver *peci_drv = to_peci_driver(drv); 	if (dev->type != &peci_device_type)		return 0; 	return !!peci_bus_match_device_id(peci_drv->id_table, device);} static int peci_bus_device_probe(struct device *dev){	struct peci_device *device = to_peci_device(dev);	struct peci_driver *driver = to_peci_driver(dev->driver); 	return driver->probe(device, peci_bus_match_device_id(driver->id_table, device));} static void peci_bus_device_remove(struct device *dev){	struct peci_device *device = to_peci_device(dev);	struct peci_driver *driver = to_peci_driver(dev->driver); 	if (driver->remove)		driver->remove(device);} const struct bus_type peci_bus_type = {	.name		= "peci",	.match		= peci_bus_device_match,	.probe		= peci_bus_device_probe,	.remove		= peci_bus_device_remove,	.bus_groups	= peci_bus_groups,}; static int __init peci_init(void){	int ret; 	ret = bus_register(&peci_bus_type);	if (ret < 0) {		pr_err("peci: failed to register PECI bus type!\n");		return ret;	} 	return 0;}module_init(peci_init); static void __exit peci_exit(void){	bus_unregister(&peci_bus_type);}module_exit(peci_exit); MODULE_AUTHOR("Jason M Bills <jason.m.bills@linux.intel.com>");MODULE_AUTHOR("Jae Hyun Yoo <jae.hyun.yoo@linux.intel.com>");MODULE_AUTHOR("Iwona Winiarska <iwona.winiarska@intel.com>");MODULE_DESCRIPTION("PECI bus core module");MODULE_LICENSE("GPL");