// SPDX-License-Identifier: GPL-2.0+/* * ipmi_si_platform.c * * Handling for platform devices in IPMI (ACPI, OF, and things * coming from the platform. */ #define pr_fmt(fmt) "ipmi_platform: " fmt#define dev_fmt pr_fmt #include <linux/types.h>#include <linux/module.h>#include <linux/of.h>#include <linux/of_address.h>#include <linux/of_irq.h>#include <linux/platform_device.h>#include <linux/property.h>#include <linux/acpi.h>#include "ipmi_si.h"#include "ipmi_dmi.h" static bool platform_registered;static bool si_tryplatform = true;#ifdef CONFIG_ACPIstatic bool          si_tryacpi = true;#endif#ifdef CONFIG_OFstatic bool          si_tryopenfirmware = true;#endif#ifdef CONFIG_DMIstatic bool          si_trydmi = true;#elsestatic bool          si_trydmi = false;#endif module_param_named(tryplatform, si_tryplatform, bool, 0);MODULE_PARM_DESC(tryplatform,		 "Setting this to zero will disable the default scan of the interfaces identified via platform interfaces besides ACPI, OpenFirmware, and DMI");#ifdef CONFIG_ACPImodule_param_named(tryacpi, si_tryacpi, bool, 0);MODULE_PARM_DESC(tryacpi,		 "Setting this to zero will disable the default scan of the interfaces identified via ACPI");#endif#ifdef CONFIG_OFmodule_param_named(tryopenfirmware, si_tryopenfirmware, bool, 0);MODULE_PARM_DESC(tryopenfirmware,		 "Setting this to zero will disable the default scan of the interfaces identified via OpenFirmware");#endif#ifdef CONFIG_DMImodule_param_named(trydmi, si_trydmi, bool, 0);MODULE_PARM_DESC(trydmi,		 "Setting this to zero will disable the default scan of the interfaces identified via DMI");#endif #ifdef CONFIG_ACPI/* For GPE-type interrupts. */static u32 ipmi_acpi_gpe(acpi_handle gpe_device,	u32 gpe_number, void *context){	struct si_sm_io *io = context; 	ipmi_si_irq_handler(io->irq, io->irq_handler_data);	return ACPI_INTERRUPT_HANDLED;} static void acpi_gpe_irq_cleanup(struct si_sm_io *io){	if (!io->irq)		return; 	ipmi_irq_start_cleanup(io);	acpi_remove_gpe_handler(NULL, io->irq, &ipmi_acpi_gpe);} static int acpi_gpe_irq_setup(struct si_sm_io *io){	acpi_status status; 	if (!io->irq)		return 0; 	status = acpi_install_gpe_handler(NULL,					  io->irq,					  ACPI_GPE_LEVEL_TRIGGERED,					  &ipmi_acpi_gpe,					  io);	if (ACPI_FAILURE(status)) {		dev_warn(io->dev,			 "Unable to claim ACPI GPE %d, running polled\n",			 io->irq);		io->irq = 0;		return -EINVAL;	} 	io->irq_cleanup = acpi_gpe_irq_cleanup;	ipmi_irq_finish_setup(io);	dev_info(io->dev, "Using ACPI GPE %d\n", io->irq);	return 0;}#endif static void ipmi_set_addr_data_and_space(struct resource *r, struct si_sm_io *io){	if (resource_type(r) == IORESOURCE_IO)		io->addr_space = IPMI_IO_ADDR_SPACE;	else		io->addr_space = IPMI_MEM_ADDR_SPACE;	io->addr_data = r->start;} static struct resource *ipmi_get_info_from_resources(struct platform_device *pdev,			     struct si_sm_io *io){	struct resource *res, *res_second; 	res = platform_get_mem_or_io(pdev, 0);	if (!res) {		dev_err(&pdev->dev, "no I/O or memory address\n");		return NULL;	}	ipmi_set_addr_data_and_space(res, io); 	io->regspacing = DEFAULT_REGSPACING;	res_second = platform_get_mem_or_io(pdev, 1);	if (res_second && resource_type(res_second) == resource_type(res)) {		if (res_second->start > io->addr_data)			io->regspacing = res_second->start - io->addr_data;	} 	return res;} static int platform_ipmi_probe(struct platform_device *pdev){	struct si_sm_io io;	u8 type, slave_addr, addr_source, regsize, regshift;	int rv; 	rv = device_property_read_u8(&pdev->dev, "addr-source", &addr_source);	if (rv)		addr_source = SI_PLATFORM;	if (addr_source >= SI_LAST)		return -EINVAL; 	if (addr_source == SI_SMBIOS) {		if (!si_trydmi)			return -ENODEV;	} else if (addr_source != SI_HARDCODED) {		if (!si_tryplatform)			return -ENODEV;	} 	rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type);	if (rv)		return -ENODEV; 	memset(&io, 0, sizeof(io));	io.addr_source = addr_source;	dev_info(&pdev->dev, "probing via %s\n",		 ipmi_addr_src_to_str(addr_source)); 	switch (type) {	case SI_KCS:		io.si_info = &ipmi_kcs_si_info;		break;	case SI_SMIC:		io.si_info = &ipmi_smic_si_info;		break;	case SI_BT:		io.si_info = &ipmi_bt_si_info;		break;	case SI_TYPE_INVALID: /* User disabled this in hardcode. */		return -ENODEV;	default:		dev_err(&pdev->dev, "ipmi-type property is invalid\n");		return -EINVAL;	} 	io.regsize = DEFAULT_REGSIZE;	rv = device_property_read_u8(&pdev->dev, "reg-size", &regsize);	if (!rv)		io.regsize = regsize; 	io.regshift = 0;	rv = device_property_read_u8(&pdev->dev, "reg-shift", &regshift);	if (!rv)		io.regshift = regshift; 	if (!ipmi_get_info_from_resources(pdev, &io))		return -EINVAL; 	rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);	if (rv)		io.slave_addr = 0x20;	else		io.slave_addr = slave_addr; 	io.irq = platform_get_irq_optional(pdev, 0);	if (io.irq > 0)		io.irq_setup = ipmi_std_irq_setup;	else		io.irq = 0; 	io.dev = &pdev->dev; 	pr_info("ipmi_si: %s: %s %#lx regsize %d spacing %d irq %d\n",		ipmi_addr_src_to_str(addr_source),		(io.addr_space == IPMI_IO_ADDR_SPACE) ? "io" : "mem",		io.addr_data, io.regsize, io.regspacing, io.irq); 	ipmi_si_add_smi(&io); 	return 0;} #ifdef CONFIG_OFstatic const struct of_device_id of_ipmi_match[] = {	{ .type = "ipmi", .compatible = "ipmi-kcs", .data = &ipmi_kcs_si_info },	{ .type = "ipmi", .compatible = "ipmi-smic", .data = &ipmi_smic_si_info },	{ .type = "ipmi", .compatible = "ipmi-bt", .data = &ipmi_bt_si_info },	{}};MODULE_DEVICE_TABLE(of, of_ipmi_match); static int of_ipmi_probe(struct platform_device *pdev){	struct si_sm_io io;	struct resource resource;	const __be32 *regsize, *regspacing, *regshift;	struct device_node *np = pdev->dev.of_node;	int ret;	int proplen; 	if (!si_tryopenfirmware)		return -ENODEV; 	dev_info(&pdev->dev, "probing via device tree\n"); 	if (!of_device_is_available(np))		return -EINVAL; 	ret = of_address_to_resource(np, 0, &resource);	if (ret) {		dev_warn(&pdev->dev, "invalid address from OF\n");		return ret;	} 	regsize = of_get_property(np, "reg-size", &proplen);	if (regsize && proplen != 4) {		dev_warn(&pdev->dev, "invalid regsize from OF\n");		return -EINVAL;	} 	regspacing = of_get_property(np, "reg-spacing", &proplen);	if (regspacing && proplen != 4) {		dev_warn(&pdev->dev, "invalid regspacing from OF\n");		return -EINVAL;	} 	regshift = of_get_property(np, "reg-shift", &proplen);	if (regshift && proplen != 4) {		dev_warn(&pdev->dev, "invalid regshift from OF\n");		return -EINVAL;	} 	memset(&io, 0, sizeof(io));	io.si_info	= device_get_match_data(&pdev->dev);	io.addr_source	= SI_DEVICETREE;	io.irq_setup	= ipmi_std_irq_setup; 	ipmi_set_addr_data_and_space(&resource, &io); 	io.regsize	= regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;	io.regspacing	= regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;	io.regshift	= regshift ? be32_to_cpup(regshift) : 0; 	io.irq = platform_get_irq_optional(pdev, 0);	if (io.irq < 0)		io.irq = 0; 	io.dev		= &pdev->dev; 	dev_dbg(&pdev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",		io.addr_data, io.regsize, io.regspacing, io.irq); 	return ipmi_si_add_smi(&io);}#else#define of_ipmi_match NULLstatic int of_ipmi_probe(struct platform_device *dev){	return -ENODEV;}#endif #ifdef CONFIG_ACPIstatic int find_slave_address(struct si_sm_io *io, int slave_addr){#ifdef CONFIG_IPMI_DMI_DECODE	if (!slave_addr)		slave_addr = ipmi_dmi_get_slave_addr(io->si_info->type,						     io->addr_space,						     io->addr_data);#endif 	return slave_addr;} static int acpi_ipmi_probe(struct platform_device *pdev){	struct device *dev = &pdev->dev;	struct si_sm_io io;	acpi_handle handle;	acpi_status status;	unsigned long long tmp;	struct resource *res; 	if (!si_tryacpi)		return -ENODEV; 	handle = ACPI_HANDLE(dev);	if (!handle)		return -ENODEV; 	memset(&io, 0, sizeof(io));	io.addr_source = SI_ACPI;	dev_info(dev, "probing via ACPI\n"); 	io.addr_info.acpi_info.acpi_handle = handle; 	/* _IFT tells us the interface type: KCS, BT, etc */	status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);	if (ACPI_FAILURE(status)) {		dev_err(dev, "Could not find ACPI IPMI interface type\n");		return -EINVAL;	} 	switch (tmp) {	case 1:		io.si_info = &ipmi_kcs_si_info;		break;	case 2:		io.si_info = &ipmi_smic_si_info;		break;	case 3:		io.si_info = &ipmi_bt_si_info;		break;	case 4: /* SSIF, just ignore */		return -ENODEV;	default:		dev_info(dev, "unknown IPMI type %lld\n", tmp);		return -EINVAL;	} 	io.dev = dev;	io.regsize = DEFAULT_REGSIZE;	io.regshift = 0; 	res = ipmi_get_info_from_resources(pdev, &io);	if (!res)		return -EINVAL; 	/* If _GPE exists, use it; otherwise use standard interrupts */	status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);	if (ACPI_SUCCESS(status)) {		io.irq = tmp;		io.irq_setup = acpi_gpe_irq_setup;	} else {		int irq = platform_get_irq_optional(pdev, 0); 		if (irq > 0) {			io.irq = irq;			io.irq_setup = ipmi_std_irq_setup;		}	} 	io.slave_addr = find_slave_address(&io, io.slave_addr); 	dev_info(dev, "%pR regsize %d spacing %d irq %d\n",		 res, io.regsize, io.regspacing, io.irq); 	request_module_nowait("acpi_ipmi"); 	return ipmi_si_add_smi(&io);} static const struct acpi_device_id acpi_ipmi_match[] = {	{ .id = "IPI0001" },	{ }};MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);#elsestatic int acpi_ipmi_probe(struct platform_device *dev){	return -ENODEV;}#endif static int ipmi_probe(struct platform_device *pdev){	if (pdev->dev.of_node && of_ipmi_probe(pdev) == 0)		return 0; 	if (acpi_ipmi_probe(pdev) == 0)		return 0; 	return platform_ipmi_probe(pdev);} static void ipmi_remove(struct platform_device *pdev){	ipmi_si_remove_by_dev(&pdev->dev);} static int pdev_match_name(struct device *dev, const void *data){	struct platform_device *pdev = to_platform_device(dev);	const char *name = data; 	return strcmp(pdev->name, name) == 0;} void ipmi_remove_platform_device_by_name(char *name){	struct device *dev; 	while ((dev = bus_find_device(&platform_bus_type, NULL, name,				      pdev_match_name))) {		struct platform_device *pdev = to_platform_device(dev); 		platform_device_unregister(pdev);		put_device(dev);	}} static const struct platform_device_id si_plat_ids[] = {	{ .name = "dmi-ipmi-si" },	{ .name = "hardcode-ipmi-si" },	{ .name = "hotmod-ipmi-si" },	{ }}; struct platform_driver ipmi_platform_driver = {	.driver = {		.name = SI_DEVICE_NAME,		.of_match_table = of_ipmi_match,		.acpi_match_table = ACPI_PTR(acpi_ipmi_match),	},	.probe		= ipmi_probe,	.remove		= ipmi_remove,	.id_table       = si_plat_ids}; void ipmi_si_platform_init(void){	int rv = platform_driver_register(&ipmi_platform_driver);	if (rv)		pr_err("Unable to register driver: %d\n", rv);	else		platform_registered = true;} void ipmi_si_platform_shutdown(void){	if (platform_registered)		platform_driver_unregister(&ipmi_platform_driver);}