[linux-2.6-block.git] / drivers / char / ipmi / ipmi_si_platform.c

// 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_device.h>
#include <linux/of_platform.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/acpi.h>
#include "ipmi_si.h"
#include "ipmi_dmi.h"

static bool si_tryplatform = true;
#ifdef CONFIG_ACPI
static bool          si_tryacpi = true;
#endif
#ifdef CONFIG_OF
static bool          si_tryopenfirmware = true;
#endif
#ifdef CONFIG_DMI
static bool          si_trydmi = true;
#else
static 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_ACPI
module_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_OF
module_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_DMI
module_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 (status != AE_OK) {
		dev_warn(io->dev,
			 "Unable to claim ACPI GPE %d, running polled\n",
			 io->irq);
		io->irq = 0;
		return -EINVAL;
	} else {
		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 struct resource *
ipmi_get_info_from_resources(struct platform_device *pdev,
			     struct si_sm_io *io)
{
	struct resource *res, *res_second;

	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	if (res) {
		io->addr_space = IPMI_IO_ADDR_SPACE;
	} else {
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		if (res)
			io->addr_space = IPMI_MEM_ADDR_SPACE;
	}
	if (!res) {
		dev_err(&pdev->dev, "no I/O or memory address\n");
		return NULL;
	}
	io->addr_data = res->start;

	io->regspacing = DEFAULT_REGSPACING;
	res_second = platform_get_resource(pdev,
			       (io->addr_space == IPMI_IO_ADDR_SPACE) ?
					IORESOURCE_IO : IORESOURCE_MEM,
			       1);
	if (res_second) {
		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:
	case SI_SMIC:
	case SI_BT:
		io.si_type = type;
		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) {
		dev_warn(&pdev->dev, "device has no slave-addr property\n");
		io.slave_addr = 0x20;
	} else {
		io.slave_addr = slave_addr;
	}

	io.irq = platform_get_irq(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_OF
static const struct of_device_id of_ipmi_match[] = {
	{ .type = "ipmi", .compatible = "ipmi-kcs",
	  .data = (void *)(unsigned long) SI_KCS },
	{ .type = "ipmi", .compatible = "ipmi-smic",
	  .data = (void *)(unsigned long) SI_SMIC },
	{ .type = "ipmi", .compatible = "ipmi-bt",
	  .data = (void *)(unsigned long) SI_BT },
	{},
};
MODULE_DEVICE_TABLE(of, of_ipmi_match);

static int of_ipmi_probe(struct platform_device *pdev)
{
	const struct of_device_id *match;
	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");

	match = of_match_device(of_ipmi_match, &pdev->dev);
	if (!match)
		return -ENODEV;

	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_type	= (enum si_type) match->data;
	io.addr_source	= SI_DEVICETREE;
	io.irq_setup	= ipmi_std_irq_setup;

	if (resource.flags & IORESOURCE_IO)
		io.addr_space = IPMI_IO_ADDR_SPACE;
	else
		io.addr_space = IPMI_MEM_ADDR_SPACE;

	io.addr_data	= resource.start;

	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		= irq_of_parse_and_map(pdev->dev.of_node, 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 NULL
static int of_ipmi_probe(struct platform_device *dev)
{
	return -ENODEV;
}
#endif

#ifdef CONFIG_ACPI
static 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_type,
						     io->addr_space,
						     io->addr_data);
#endif

	return slave_addr;
}

static int acpi_ipmi_probe(struct platform_device *pdev)
{
	struct si_sm_io io;
	acpi_handle handle;
	acpi_status status;
	unsigned long long tmp;
	struct resource *res;
	int rv = -EINVAL;

	if (!si_tryacpi)
		return -ENODEV;

	handle = ACPI_HANDLE(&pdev->dev);
	if (!handle)
		return -ENODEV;

	memset(&io, 0, sizeof(io));
	io.addr_source = SI_ACPI;
	dev_info(&pdev->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(&pdev->dev,
			"Could not find ACPI IPMI interface type\n");
		goto err_free;
	}

	switch (tmp) {
	case 1:
		io.si_type = SI_KCS;
		break;
	case 2:
		io.si_type = SI_SMIC;
		break;
	case 3:
		io.si_type = SI_BT;
		break;
	case 4: /* SSIF, just ignore */
		rv = -ENODEV;
		goto err_free;
	default:
		dev_info(&pdev->dev, "unknown IPMI type %lld\n", tmp);
		goto err_free;
	}

	io.regsize = DEFAULT_REGSIZE;
	io.regshift = 0;

	res = ipmi_get_info_from_resources(pdev, &io);
	if (!res) {
		rv = -EINVAL;
		goto err_free;
	}

	/* 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(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);

	io.dev = &pdev->dev;

	dev_info(io.dev, "%pR regsize %d spacing %d irq %d\n",
		 res, io.regsize, io.regspacing, io.irq);

	return ipmi_si_add_smi(&io);

err_free:
	return rv;
}

static const struct acpi_device_id acpi_ipmi_match[] = {
	{ "IPI0001", 0 },
	{ },
};
MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);
#else
static 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 int ipmi_remove(struct platform_device *pdev)
{
	return ipmi_si_remove_by_dev(&pdev->dev);
}

static const struct platform_device_id si_plat_ids[] = {
	{ "dmi-ipmi-si", 0 },
	{ "hardcode-ipmi-si", 0 },
	{ "hotmod-ipmi-si", 0 },
	{ }
};

struct platform_driver ipmi_platform_driver = {
	.driver = {
		.name = 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);
}

void ipmi_si_platform_shutdown(void)
{
	platform_driver_unregister(&ipmi_platform_driver);
}
Commit	Line	Data
243ac210	1	// SPDX-License-Identifier: GPL-2.0+
9d70029e CM	2	/*
	3	* ipmi_si_platform.c
	4	*
	5	* Handling for platform devices in IPMI (ACPI, OF, and things
	6	* coming from the platform.
	7	*/
25880f7d JP	8
	9	#define pr_fmt(fmt) "ipmi_platform: " fmt
	10	#define dev_fmt pr_fmt
	11
9d70029e CM	12	#include <linux/types.h>
9d70029e CM	13	#include <linux/module.h>
9d70029e CM	14	#include <linux/of_device.h>
	15	#include <linux/of_platform.h>
	16	#include <linux/of_address.h>
	17	#include <linux/of_irq.h>
	18	#include <linux/acpi.h>
	19	#include "ipmi_si.h"
95e300c0	20	#include "ipmi_dmi.h"
9d70029e	21
9d70029e CM	22	static bool si_tryplatform = true;
	23	#ifdef CONFIG_ACPI
	24	static bool si_tryacpi = true;
	25	#endif
95e300c0 CM	26	#ifdef CONFIG_OF
	27	static bool si_tryopenfirmware = true;
	28	#endif
9d70029e CM	29	#ifdef CONFIG_DMI
9d70029e CM	30	static bool si_trydmi = true;
95e300c0 CM	31	#else
95e300c0 CM	32	static bool si_trydmi = false;
9d70029e CM	33	#endif
	34
	35	module_param_named(tryplatform, si_tryplatform, bool, 0);
	36	MODULE_PARM_DESC(tryplatform, "Setting this to zero will disable the"
	37	" default scan of the interfaces identified via platform"
95e300c0	38	" interfaces besides ACPI, OpenFirmware, and DMI");
9d70029e CM	39	#ifdef CONFIG_ACPI
	40	module_param_named(tryacpi, si_tryacpi, bool, 0);
	41	MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
	42	" default scan of the interfaces identified via ACPI");
	43	#endif
95e300c0 CM	44	#ifdef CONFIG_OF
95e300c0 CM	45	module_param_named(tryopenfirmware, si_tryopenfirmware, bool, 0);
180153ef	46	MODULE_PARM_DESC(tryopenfirmware, "Setting this to zero will disable the"
95e300c0 CM	47	" default scan of the interfaces identified via OpenFirmware");
95e300c0 CM	48	#endif
9d70029e CM	49	#ifdef CONFIG_DMI
	50	module_param_named(trydmi, si_trydmi, bool, 0);
	51	MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
	52	" default scan of the interfaces identified via DMI");
	53	#endif
	54
	55	#ifdef CONFIG_ACPI
9d70029e CM	56	/* For GPE-type interrupts. */
	57	static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
	58	u32 gpe_number, void *context)
	59	{
	60	struct si_sm_io *io = context;
	61
	62	ipmi_si_irq_handler(io->irq, io->irq_handler_data);
	63	return ACPI_INTERRUPT_HANDLED;
	64	}
	65
	66	static void acpi_gpe_irq_cleanup(struct si_sm_io *io)
	67	{
	68	if (!io->irq)
	69	return;
	70
	71	ipmi_irq_start_cleanup(io);
	72	acpi_remove_gpe_handler(NULL, io->irq, &ipmi_acpi_gpe);
	73	}
	74
	75	static int acpi_gpe_irq_setup(struct si_sm_io *io)
	76	{
	77	acpi_status status;
	78
	79	if (!io->irq)
	80	return 0;
	81
	82	status = acpi_install_gpe_handler(NULL,
	83	io->irq,
	84	ACPI_GPE_LEVEL_TRIGGERED,
	85	&ipmi_acpi_gpe,
	86	io);
	87	if (status != AE_OK) {
	88	dev_warn(io->dev,
	89	"Unable to claim ACPI GPE %d, running polled\n",
	90	io->irq);
	91	io->irq = 0;
	92	return -EINVAL;
	93	} else {
	94	io->irq_cleanup = acpi_gpe_irq_cleanup;
	95	ipmi_irq_finish_setup(io);
	96	dev_info(io->dev, "Using ACPI GPE %d\n", io->irq);
	97	return 0;
	98	}
	99	}
9d70029e CM	100	#endif
9d70029e CM	101
9d70029e CM	102	static struct resource *
	103	ipmi_get_info_from_resources(struct platform_device *pdev,
	104	struct si_sm_io *io)
	105	{
	106	struct resource res, res_second;
	107
	108	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
	109	if (res) {
f6296bdc	110	io->addr_space = IPMI_IO_ADDR_SPACE;
9d70029e CM	111	} else {
	112	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	113	if (res)
f6296bdc	114	io->addr_space = IPMI_MEM_ADDR_SPACE;
9d70029e CM	115	}
	116	if (!res) {
	117	dev_err(&pdev->dev, "no I/O or memory address\n");
	118	return NULL;
	119	}
	120	io->addr_data = res->start;
	121
	122	io->regspacing = DEFAULT_REGSPACING;
	123	res_second = platform_get_resource(pdev,
f6296bdc	124	(io->addr_space == IPMI_IO_ADDR_SPACE) ?
9d70029e CM	125	IORESOURCE_IO : IORESOURCE_MEM,
	126	1);
	127	if (res_second) {
	128	if (res_second->start > io->addr_data)
	129	io->regspacing = res_second->start - io->addr_data;
	130	}
9d70029e CM	131
	132	return res;
	133	}
	134
95e300c0	135	static int platform_ipmi_probe(struct platform_device *pdev)
9d70029e CM	136	{
9d70029e CM	137	struct si_sm_io io;
41b766d6	138	u8 type, slave_addr, addr_source, regsize, regshift;
9d70029e CM	139	int rv;
9d70029e CM	140
95e300c0 CM	141	rv = device_property_read_u8(&pdev->dev, "addr-source", &addr_source);
	142	if (rv)
	143	addr_source = SI_PLATFORM;
	144	if (addr_source >= SI_LAST)
	145	return -EINVAL;
	146
	147	if (addr_source == SI_SMBIOS) {
	148	if (!si_trydmi)
	149	return -ENODEV;
41b766d6	150	} else if (addr_source != SI_HARDCODED) {
95e300c0 CM	151	if (!si_tryplatform)
	152	return -ENODEV;
	153	}
9d70029e CM	154
	155	rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type);
	156	if (rv)
	157	return -ENODEV;
	158
	159	memset(&io, 0, sizeof(io));
95e300c0	160	io.addr_source = addr_source;
25880f7d	161	dev_info(&pdev->dev, "probing via %s\n",
95e300c0	162	ipmi_addr_src_to_str(addr_source));
9d70029e CM	163
9d70029e CM	164	switch (type) {
95e300c0 CM	165	case SI_KCS:
	166	case SI_SMIC:
	167	case SI_BT:
	168	io.si_type = type;
9d70029e	169	break;
41b766d6 CM	170	case SI_TYPE_INVALID: /* User disabled this in hardcode. */
41b766d6 CM	171	return -ENODEV;
9d70029e	172	default:
95e300c0	173	dev_err(&pdev->dev, "ipmi-type property is invalid\n");
9d70029e CM	174	return -EINVAL;
	175	}
	176
41b766d6 CM	177	io.regsize = DEFAULT_REGSIZE;
	178	rv = device_property_read_u8(&pdev->dev, "reg-size", &regsize);
	179	if (!rv)
	180	io.regsize = regsize;
	181
	182	io.regshift = 0;
	183	rv = device_property_read_u8(&pdev->dev, "reg-shift", &regshift);
	184	if (!rv)
	185	io.regshift = regshift;
	186
95e300c0 CM	187	if (!ipmi_get_info_from_resources(pdev, &io))
95e300c0 CM	188	return -EINVAL;
9d70029e CM	189
	190	rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
	191	if (rv) {
95e300c0	192	dev_warn(&pdev->dev, "device has no slave-addr property\n");
9d70029e CM	193	io.slave_addr = 0x20;
	194	} else {
	195	io.slave_addr = slave_addr;
	196	}
	197
	198	io.irq = platform_get_irq(pdev, 0);
	199	if (io.irq > 0)
	200	io.irq_setup = ipmi_std_irq_setup;
	201	else
	202	io.irq = 0;
	203
	204	io.dev = &pdev->dev;
	205
41b766d6 CM	206	pr_info("ipmi_si: %s: %s %#lx regsize %d spacing %d irq %d\n",
41b766d6 CM	207	ipmi_addr_src_to_str(addr_source),
f6296bdc	208	(io.addr_space == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
9d70029e CM	209	io.addr_data, io.regsize, io.regspacing, io.irq);
	210
	211	ipmi_si_add_smi(&io);
	212
	213	return 0;
9d70029e	214	}
9d70029e CM	215
	216	#ifdef CONFIG_OF
	217	static const struct of_device_id of_ipmi_match[] = {
	218	{ .type = "ipmi", .compatible = "ipmi-kcs",
	219	.data = (void *)(unsigned long) SI_KCS },
	220	{ .type = "ipmi", .compatible = "ipmi-smic",
	221	.data = (void *)(unsigned long) SI_SMIC },
	222	{ .type = "ipmi", .compatible = "ipmi-bt",
	223	.data = (void *)(unsigned long) SI_BT },
	224	{},
	225	};
	226	MODULE_DEVICE_TABLE(of, of_ipmi_match);
	227
	228	static int of_ipmi_probe(struct platform_device *pdev)
	229	{
	230	const struct of_device_id *match;
	231	struct si_sm_io io;
	232	struct resource resource;
	233	const __be32 regsize, regspacing, *regshift;
	234	struct device_node *np = pdev->dev.of_node;
	235	int ret;
	236	int proplen;
	237
95e300c0 CM	238	if (!si_tryopenfirmware)
	239	return -ENODEV;
	240
9d70029e CM	241	dev_info(&pdev->dev, "probing via device tree\n");
	242
	243	match = of_match_device(of_ipmi_match, &pdev->dev);
	244	if (!match)
	245	return -ENODEV;
	246
	247	if (!of_device_is_available(np))
	248	return -EINVAL;
	249
	250	ret = of_address_to_resource(np, 0, &resource);
	251	if (ret) {
25880f7d	252	dev_warn(&pdev->dev, "invalid address from OF\n");
9d70029e CM	253	return ret;
	254	}
	255
	256	regsize = of_get_property(np, "reg-size", &proplen);
	257	if (regsize && proplen != 4) {
25880f7d	258	dev_warn(&pdev->dev, "invalid regsize from OF\n");
9d70029e CM	259	return -EINVAL;
	260	}
	261
	262	regspacing = of_get_property(np, "reg-spacing", &proplen);
	263	if (regspacing && proplen != 4) {
25880f7d	264	dev_warn(&pdev->dev, "invalid regspacing from OF\n");
9d70029e CM	265	return -EINVAL;
	266	}
	267
	268	regshift = of_get_property(np, "reg-shift", &proplen);
	269	if (regshift && proplen != 4) {
25880f7d	270	dev_warn(&pdev->dev, "invalid regshift from OF\n");
9d70029e CM	271	return -EINVAL;
	272	}
	273
	274	memset(&io, 0, sizeof(io));
	275	io.si_type = (enum si_type) match->data;
	276	io.addr_source = SI_DEVICETREE;
	277	io.irq_setup = ipmi_std_irq_setup;
	278
	279	if (resource.flags & IORESOURCE_IO)
f6296bdc	280	io.addr_space = IPMI_IO_ADDR_SPACE;
9d70029e	281	else
f6296bdc	282	io.addr_space = IPMI_MEM_ADDR_SPACE;
9d70029e CM	283
	284	io.addr_data = resource.start;
	285
	286	io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
	287	io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
	288	io.regshift = regshift ? be32_to_cpup(regshift) : 0;
	289
	290	io.irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
	291	io.dev = &pdev->dev;
	292
	293	dev_dbg(&pdev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
	294	io.addr_data, io.regsize, io.regspacing, io.irq);
	295
	296	return ipmi_si_add_smi(&io);
	297	}
	298	#else
	299	#define of_ipmi_match NULL
	300	static int of_ipmi_probe(struct platform_device *dev)
	301	{
	302	return -ENODEV;
	303	}
	304	#endif
	305
	306	#ifdef CONFIG_ACPI
	307	static int find_slave_address(struct si_sm_io *io, int slave_addr)
	308	{
	309	#ifdef CONFIG_IPMI_DMI_DECODE
3cd83bac CM	310	if (!slave_addr)
	311	slave_addr = ipmi_dmi_get_slave_addr(io->si_type,
	312	io->addr_space,
9d70029e	313	io->addr_data);
9d70029e CM	314	#endif
	315
	316	return slave_addr;
	317	}
	318
	319	static int acpi_ipmi_probe(struct platform_device *pdev)
	320	{
	321	struct si_sm_io io;
	322	acpi_handle handle;
	323	acpi_status status;
	324	unsigned long long tmp;
	325	struct resource *res;
	326	int rv = -EINVAL;
	327
	328	if (!si_tryacpi)
	329	return -ENODEV;
	330
	331	handle = ACPI_HANDLE(&pdev->dev);
	332	if (!handle)
	333	return -ENODEV;
	334
	335	memset(&io, 0, sizeof(io));
	336	io.addr_source = SI_ACPI;
25880f7d	337	dev_info(&pdev->dev, "probing via ACPI\n");
9d70029e CM	338
	339	io.addr_info.acpi_info.acpi_handle = handle;
	340
	341	/* _IFT tells us the interface type: KCS, BT, etc */
	342	status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
	343	if (ACPI_FAILURE(status)) {
	344	dev_err(&pdev->dev,
	345	"Could not find ACPI IPMI interface type\n");
	346	goto err_free;
	347	}
	348
	349	switch (tmp) {
	350	case 1:
	351	io.si_type = SI_KCS;
	352	break;
	353	case 2:
	354	io.si_type = SI_SMIC;
	355	break;
	356	case 3:
	357	io.si_type = SI_BT;
	358	break;
	359	case 4: /* SSIF, just ignore */
	360	rv = -ENODEV;
	361	goto err_free;
	362	default:
	363	dev_info(&pdev->dev, "unknown IPMI type %lld\n", tmp);
	364	goto err_free;
	365	}
	366
41b766d6 CM	367	io.regsize = DEFAULT_REGSIZE;
	368	io.regshift = 0;
	369
9d70029e CM	370	res = ipmi_get_info_from_resources(pdev, &io);
	371	if (!res) {
	372	rv = -EINVAL;
	373	goto err_free;
	374	}
	375
	376	/* If _GPE exists, use it; otherwise use standard interrupts */
	377	status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
	378	if (ACPI_SUCCESS(status)) {
	379	io.irq = tmp;
	380	io.irq_setup = acpi_gpe_irq_setup;
	381	} else {
	382	int irq = platform_get_irq(pdev, 0);
	383
	384	if (irq > 0) {
	385	io.irq = irq;
	386	io.irq_setup = ipmi_std_irq_setup;
	387	}
	388	}
	389
	390	io.slave_addr = find_slave_address(&io, io.slave_addr);
	391
	392	io.dev = &pdev->dev;
	393
	394	dev_info(io.dev, "%pR regsize %d spacing %d irq %d\n",
	395	res, io.regsize, io.regspacing, io.irq);
	396
	397	return ipmi_si_add_smi(&io);
	398
	399	err_free:
	400	return rv;
	401	}
	402
	403	static const struct acpi_device_id acpi_ipmi_match[] = {
	404	{ "IPI0001", 0 },
	405	{ },
	406	};
	407	MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);
	408	#else
	409	static int acpi_ipmi_probe(struct platform_device *dev)
	410	{
	411	return -ENODEV;
	412	}
	413	#endif
	414
	415	static int ipmi_probe(struct platform_device *pdev)
	416	{
	417	if (pdev->dev.of_node && of_ipmi_probe(pdev) == 0)
	418	return 0;
	419
	420	if (acpi_ipmi_probe(pdev) == 0)
	421	return 0;
	422
95e300c0	423	return platform_ipmi_probe(pdev);
9d70029e CM	424	}
	425
	426	static int ipmi_remove(struct platform_device *pdev)
	427	{
	428	return ipmi_si_remove_by_dev(&pdev->dev);
	429	}
	430
b3096c70	431	static const struct platform_device_id si_plat_ids[] = {
41b766d6 CM	432	{ "dmi-ipmi-si", 0 },
41b766d6 CM	433	{ "hardcode-ipmi-si", 0 },
3bb8ea40	434	{ "hotmod-ipmi-si", 0 },
41b766d6	435	{ }
b3096c70 CM	436	};
b3096c70 CM	437
9d70029e CM	438	struct platform_driver ipmi_platform_driver = {
	439	.driver = {
	440	.name = DEVICE_NAME,
	441	.of_match_table = of_ipmi_match,
	442	.acpi_match_table = ACPI_PTR(acpi_ipmi_match),
	443	},
	444	.probe = ipmi_probe,
	445	.remove = ipmi_remove,
b3096c70	446	.id_table = si_plat_ids
9d70029e CM	447	};
	448
	449	void ipmi_si_platform_init(void)
	450	{
95e300c0 CM	451	int rv = platform_driver_register(&ipmi_platform_driver);
95e300c0 CM	452	if (rv)
25880f7d	453	pr_err("Unable to register driver: %d\n", rv);
9d70029e CM	454	}
	455
	456	void ipmi_si_platform_shutdown(void)
	457	{
	458	platform_driver_unregister(&ipmi_platform_driver);
	459	}