Commit 78ca0c05 authored by Andrew Jeffery's avatar Andrew Jeffery Committed by Corey Minyard
Browse files

ipmi: kcs_bmc_aspeed: Use of match data to extract KCS properties 



Unpack and remove the aspeed_kcs_probe_of_v[12]() functions to aid
rearranging how the private device-driver memory is allocated.

Signed-off-by: default avatarAndrew Jeffery <andrew@aj.id.au>
Message-Id: <20210608104757.582199-2-andrew@aj.id.au>
Reviewed-by: default avatarZev Weiss <zweiss@equinix.com>
Signed-off-by: default avatarCorey Minyard <cminyard@mvista.com>
parent 2253042d

drivers/char/ipmi/kcs_bmc_aspeed.c

+76 −76
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/poll.h>

#include <linux/regmap.h>
@@ -63,6 +64,10 @@ struct aspeed_kcs_bmc { 
	struct regmap *map;

};



struct aspeed_kcs_of_ops {

	int (*get_channel)(struct platform_device *pdev);

	int (*get_io_address)(struct platform_device *pdev);

};



static u8 aspeed_kcs_inb(struct kcs_bmc *kcs_bmc, u32 reg)

{
@@ -231,13 +236,10 @@ static const struct kcs_ioreg ast_kcs_bmc_ioregs[KCS_CHANNEL_MAX] = { 
	{ .idr = LPC_IDR4, .odr = LPC_ODR4, .str = LPC_STR4 },

};



static struct kcs_bmc *aspeed_kcs_probe_of_v1(struct platform_device *pdev)

static int aspeed_kcs_of_v1_get_channel(struct platform_device *pdev)

{

	struct aspeed_kcs_bmc *priv;

	struct device_node *np;

	struct kcs_bmc *kcs;

	u32 channel;

	u32 slave;

	int rc;



	np = pdev->dev.of_node;
@@ -245,105 +247,81 @@ static struct kcs_bmc *aspeed_kcs_probe_of_v1(struct platform_device *pdev) 
	rc = of_property_read_u32(np, "kcs_chan", &channel);

	if ((rc != 0) || (channel == 0 || channel > KCS_CHANNEL_MAX)) {

		dev_err(&pdev->dev, "no valid 'kcs_chan' configured\n");

		return ERR_PTR(-EINVAL);

	}



	kcs = kcs_bmc_alloc(&pdev->dev, sizeof(struct aspeed_kcs_bmc), channel);

	if (!kcs)

		return ERR_PTR(-ENOMEM);



	priv = kcs_bmc_priv(kcs);

	priv->map = syscon_node_to_regmap(pdev->dev.parent->of_node);

	if (IS_ERR(priv->map)) {

		dev_err(&pdev->dev, "Couldn't get regmap\n");

		return ERR_PTR(-ENODEV);

	}



	rc = of_property_read_u32(np, "kcs_addr", &slave);

	if (rc) {

		dev_err(&pdev->dev, "no valid 'kcs_addr' configured\n");

		return ERR_PTR(-EINVAL);

		return -EINVAL;

	}



	kcs->ioreg = ast_kcs_bmc_ioregs[channel - 1];

	aspeed_kcs_set_address(kcs, slave);



	return kcs;

	return channel;

}



static int aspeed_kcs_calculate_channel(const struct kcs_ioreg *regs)

static int aspeed_kcs_of_v1_get_io_address(struct platform_device *pdev)

{

	int i;

	u32 slave;

	int rc;



	for (i = 0; i < ARRAY_SIZE(ast_kcs_bmc_ioregs); i++) {

		if (!memcmp(&ast_kcs_bmc_ioregs[i], regs, sizeof(*regs)))

			return i + 1;

	rc = of_property_read_u32(pdev->dev.of_node, "kcs_addr", &slave);

	if (rc || slave > 0xffff) {

		dev_err(&pdev->dev, "no valid 'kcs_addr' configured\n");

		return -EINVAL;

	}



	return -EINVAL;

	return slave;

}



static struct kcs_bmc *aspeed_kcs_probe_of_v2(struct platform_device *pdev)

static int aspeed_kcs_of_v2_get_channel(struct platform_device *pdev)

{

	struct aspeed_kcs_bmc *priv;

	struct device_node *np;

	struct kcs_ioreg ioreg;

	struct kcs_bmc *kcs;

	const __be32 *reg;

	int channel;

	u32 slave;

	int rc;

	int i;



	np = pdev->dev.of_node;



	/* Don't translate addresses, we want offsets for the regmaps */

	reg = of_get_address(np, 0, NULL, NULL);

	if (!reg)

		return ERR_PTR(-EINVAL);

		return -EINVAL;

	ioreg.idr = be32_to_cpup(reg);



	reg = of_get_address(np, 1, NULL, NULL);

	if (!reg)

		return ERR_PTR(-EINVAL);

		return -EINVAL;

	ioreg.odr = be32_to_cpup(reg);



	reg = of_get_address(np, 2, NULL, NULL);

	if (!reg)

		return ERR_PTR(-EINVAL);

		return -EINVAL;

	ioreg.str = be32_to_cpup(reg);



	channel = aspeed_kcs_calculate_channel(&ioreg);

	if (channel < 0)

		return ERR_PTR(channel);



	kcs = kcs_bmc_alloc(&pdev->dev, sizeof(struct aspeed_kcs_bmc), channel);

	if (!kcs)

		return ERR_PTR(-ENOMEM);



	kcs->ioreg = ioreg;

	for (i = 0; i < ARRAY_SIZE(ast_kcs_bmc_ioregs); i++) {

		if (!memcmp(&ast_kcs_bmc_ioregs[i], &ioreg, sizeof(ioreg)))

			return i + 1;

	}



	priv = kcs_bmc_priv(kcs);

	priv->map = syscon_node_to_regmap(pdev->dev.parent->of_node);

	if (IS_ERR(priv->map)) {

		dev_err(&pdev->dev, "Couldn't get regmap\n");

		return ERR_PTR(-ENODEV);

	return -EINVAL;

}



	rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &slave);

	if (rc)

		return ERR_PTR(rc);

static int aspeed_kcs_of_v2_get_io_address(struct platform_device *pdev)

{

	uint32_t slave;

	int rc;



	aspeed_kcs_set_address(kcs, slave);

	rc = of_property_read_u32(pdev->dev.of_node, "aspeed,lpc-io-reg", &slave);

	if (rc || slave > 0xffff) {

		dev_err(&pdev->dev, "no valid 'aspeed,lpc-io-reg' configured\n");

		return -EINVAL;

	}



	return kcs;

	return slave;

}



static int aspeed_kcs_probe(struct platform_device *pdev)

{

	const struct aspeed_kcs_of_ops *ops;

	struct device *dev = &pdev->dev;

	struct aspeed_kcs_bmc *priv;

	struct kcs_bmc *kcs_bmc;

	struct device_node *np;

	int rc;

	int rc, channel, addr;



	np = dev->of_node->parent;

	if (!of_device_is_compatible(np, "aspeed,ast2400-lpc-v2") &&
@@ -352,23 +330,35 @@ static int aspeed_kcs_probe(struct platform_device *pdev) 
		dev_err(dev, "unsupported LPC device binding\n");

		return -ENODEV;

	}



	np = dev->of_node;

	if (of_device_is_compatible(np, "aspeed,ast2400-kcs-bmc") ||

	    of_device_is_compatible(np, "aspeed,ast2500-kcs-bmc"))

		kcs_bmc = aspeed_kcs_probe_of_v1(pdev);

	else if (of_device_is_compatible(np, "aspeed,ast2400-kcs-bmc-v2") ||

		 of_device_is_compatible(np, "aspeed,ast2500-kcs-bmc-v2"))

		kcs_bmc = aspeed_kcs_probe_of_v2(pdev);

	else

	ops = of_device_get_match_data(&pdev->dev);

	if (!ops)

		return -EINVAL;



	if (IS_ERR(kcs_bmc))

		return PTR_ERR(kcs_bmc);

	channel = ops->get_channel(pdev);

	if (channel < 0)

		return channel;



	kcs_bmc = kcs_bmc_alloc(&pdev->dev, sizeof(struct aspeed_kcs_bmc), channel);

	if (!kcs_bmc)

		return -ENOMEM;



	kcs_bmc->ioreg = ast_kcs_bmc_ioregs[channel - 1];

	kcs_bmc->io_inputb = aspeed_kcs_inb;

	kcs_bmc->io_outputb = aspeed_kcs_outb;



	addr = ops->get_io_address(pdev);

	if (addr < 0)

		return addr;



	priv = kcs_bmc_priv(kcs_bmc);

	priv->map = syscon_node_to_regmap(pdev->dev.parent->of_node);

	if (IS_ERR(priv->map)) {

		dev_err(&pdev->dev, "Couldn't get regmap\n");

		return -ENODEV;

	}



	aspeed_kcs_set_address(kcs_bmc, addr);



	rc = aspeed_kcs_config_irq(kcs_bmc, pdev);

	if (rc)

		return rc;
@@ -400,11 +390,21 @@ static int aspeed_kcs_remove(struct platform_device *pdev) 
	return 0;

}



static const struct aspeed_kcs_of_ops of_v1_ops = {

	.get_channel = aspeed_kcs_of_v1_get_channel,

	.get_io_address = aspeed_kcs_of_v1_get_io_address,

};



static const struct aspeed_kcs_of_ops of_v2_ops = {

	.get_channel = aspeed_kcs_of_v2_get_channel,

	.get_io_address = aspeed_kcs_of_v2_get_io_address,

};



static const struct of_device_id ast_kcs_bmc_match[] = {

	{ .compatible = "aspeed,ast2400-kcs-bmc" },

	{ .compatible = "aspeed,ast2500-kcs-bmc" },

	{ .compatible = "aspeed,ast2400-kcs-bmc-v2" },

	{ .compatible = "aspeed,ast2500-kcs-bmc-v2" },

	{ .compatible = "aspeed,ast2400-kcs-bmc", .data = &of_v1_ops },

	{ .compatible = "aspeed,ast2500-kcs-bmc", .data = &of_v1_ops },

	{ .compatible = "aspeed,ast2400-kcs-bmc-v2", .data = &of_v2_ops },

	{ .compatible = "aspeed,ast2500-kcs-bmc-v2", .data = &of_v2_ops },

	{ }

};

MODULE_DEVICE_TABLE(of, ast_kcs_bmc_match);