[mirror_ubuntu-hirsute-kernel.git] / drivers / mfd / stmfx.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
 *
 * Copyright (C) 2019 STMicroelectronics
 * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
 */
#include <linux/bitfield.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/mfd/core.h>
#include <linux/mfd/stmfx.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>

static bool stmfx_reg_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case STMFX_REG_SYS_CTRL:
	case STMFX_REG_IRQ_SRC_EN:
	case STMFX_REG_IRQ_PENDING:
	case STMFX_REG_IRQ_GPI_PENDING1:
	case STMFX_REG_IRQ_GPI_PENDING2:
	case STMFX_REG_IRQ_GPI_PENDING3:
	case STMFX_REG_GPIO_STATE1:
	case STMFX_REG_GPIO_STATE2:
	case STMFX_REG_GPIO_STATE3:
	case STMFX_REG_IRQ_GPI_SRC1:
	case STMFX_REG_IRQ_GPI_SRC2:
	case STMFX_REG_IRQ_GPI_SRC3:
	case STMFX_REG_GPO_SET1:
	case STMFX_REG_GPO_SET2:
	case STMFX_REG_GPO_SET3:
	case STMFX_REG_GPO_CLR1:
	case STMFX_REG_GPO_CLR2:
	case STMFX_REG_GPO_CLR3:
		return true;
	default:
		return false;
	}
}

static bool stmfx_reg_writeable(struct device *dev, unsigned int reg)
{
	return (reg >= STMFX_REG_SYS_CTRL);
}

static const struct regmap_config stmfx_regmap_config = {
	.reg_bits	= 8,
	.reg_stride	= 1,
	.val_bits	= 8,
	.max_register	= STMFX_REG_MAX,
	.volatile_reg	= stmfx_reg_volatile,
	.writeable_reg	= stmfx_reg_writeable,
	.cache_type	= REGCACHE_RBTREE,
};

static const struct resource stmfx_pinctrl_resources[] = {
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
};

static const struct resource stmfx_idd_resources[] = {
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_IDD),
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_ERROR),
};

static const struct resource stmfx_ts_resources[] = {
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_DET),
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_NE),
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_TH),
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_FULL),
	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_OVF),
};

static struct mfd_cell stmfx_cells[] = {
	{
		.of_compatible = "st,stmfx-0300-pinctrl",
		.name = "stmfx-pinctrl",
		.resources = stmfx_pinctrl_resources,
		.num_resources = ARRAY_SIZE(stmfx_pinctrl_resources),
	},
	{
		.of_compatible = "st,stmfx-0300-idd",
		.name = "stmfx-idd",
		.resources = stmfx_idd_resources,
		.num_resources = ARRAY_SIZE(stmfx_idd_resources),
	},
	{
		.of_compatible = "st,stmfx-0300-ts",
		.name = "stmfx-ts",
		.resources = stmfx_ts_resources,
		.num_resources = ARRAY_SIZE(stmfx_ts_resources),
	},
};

static u8 stmfx_func_to_mask(u32 func)
{
	u8 mask = 0;

	if (func & STMFX_FUNC_GPIO)
		mask |= STMFX_REG_SYS_CTRL_GPIO_EN;

	if ((func & STMFX_FUNC_ALTGPIO_LOW) || (func & STMFX_FUNC_ALTGPIO_HIGH))
		mask |= STMFX_REG_SYS_CTRL_ALTGPIO_EN;

	if (func & STMFX_FUNC_TS)
		mask |= STMFX_REG_SYS_CTRL_TS_EN;

	if (func & STMFX_FUNC_IDD)
		mask |= STMFX_REG_SYS_CTRL_IDD_EN;

	return mask;
}

int stmfx_function_enable(struct stmfx *stmfx, u32 func)
{
	u32 sys_ctrl;
	u8 mask;
	int ret;

	ret = regmap_read(stmfx->map, STMFX_REG_SYS_CTRL, &sys_ctrl);
	if (ret)
		return ret;

	/*
	 * IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
	 * ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
	 * the number of aGPIO available decreases. To avoid GPIO management
	 * disturbance, abort IDD or TS function enable in this case.
	 */
	if (((func & STMFX_FUNC_IDD) || (func & STMFX_FUNC_TS)) &&
	    (sys_ctrl & STMFX_REG_SYS_CTRL_ALTGPIO_EN)) {
		dev_err(stmfx->dev, "ALTGPIO function already enabled\n");
		return -EBUSY;
	}

	/* If TS is enabled, aGPIO[3:0] cannot be used */
	if ((func & STMFX_FUNC_ALTGPIO_LOW) &&
	    (sys_ctrl & STMFX_REG_SYS_CTRL_TS_EN)) {
		dev_err(stmfx->dev, "TS in use, aGPIO[3:0] unavailable\n");
		return -EBUSY;
	}

	/* If IDD is enabled, aGPIO[7:4] cannot be used */
	if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
	    (sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
		dev_err(stmfx->dev, "IDD in use, aGPIO[7:4] unavailable\n");
		return -EBUSY;
	}

	mask = stmfx_func_to_mask(func);

	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, mask);
}
EXPORT_SYMBOL_GPL(stmfx_function_enable);

int stmfx_function_disable(struct stmfx *stmfx, u32 func)
{
	u8 mask = stmfx_func_to_mask(func);

	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, 0);
}
EXPORT_SYMBOL_GPL(stmfx_function_disable);

static void stmfx_irq_bus_lock(struct irq_data *data)
{
	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);

	mutex_lock(&stmfx->lock);
}

static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
{
	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);

	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, stmfx->irq_src);

	mutex_unlock(&stmfx->lock);
}

static void stmfx_irq_mask(struct irq_data *data)
{
	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);

	stmfx->irq_src &= ~BIT(data->hwirq % 8);
}

static void stmfx_irq_unmask(struct irq_data *data)
{
	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);

	stmfx->irq_src |= BIT(data->hwirq % 8);
}

static struct irq_chip stmfx_irq_chip = {
	.name			= "stmfx-core",
	.irq_bus_lock		= stmfx_irq_bus_lock,
	.irq_bus_sync_unlock	= stmfx_irq_bus_sync_unlock,
	.irq_mask		= stmfx_irq_mask,
	.irq_unmask		= stmfx_irq_unmask,
};

static irqreturn_t stmfx_irq_handler(int irq, void *data)
{
	struct stmfx *stmfx = data;
	unsigned long bits;
	u32 pending, ack;
	int n, ret;

	ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
	if (ret)
		return IRQ_NONE;

	/*
	 * There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
	 * of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
	 */
	ack = pending & ~BIT(STMFX_REG_IRQ_SRC_EN_GPIO);
	if (ack) {
		ret = regmap_write(stmfx->map, STMFX_REG_IRQ_ACK, ack);
		if (ret)
			return IRQ_NONE;
	}

	bits = pending;
	for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
		handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));

	return IRQ_HANDLED;
}

static int stmfx_irq_map(struct irq_domain *d, unsigned int virq,
			 irq_hw_number_t hwirq)
{
	irq_set_chip_data(virq, d->host_data);
	irq_set_chip_and_handler(virq, &stmfx_irq_chip, handle_simple_irq);
	irq_set_nested_thread(virq, 1);
	irq_set_noprobe(virq);

	return 0;
}

static void stmfx_irq_unmap(struct irq_domain *d, unsigned int virq)
{
	irq_set_chip_and_handler(virq, NULL, NULL);
	irq_set_chip_data(virq, NULL);
}

static const struct irq_domain_ops stmfx_irq_ops = {
	.map	= stmfx_irq_map,
	.unmap	= stmfx_irq_unmap,
};

static void stmfx_irq_exit(struct i2c_client *client)
{
	struct stmfx *stmfx = i2c_get_clientdata(client);
	int hwirq;

	for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
		irq_dispose_mapping(irq_find_mapping(stmfx->irq_domain, hwirq));

	irq_domain_remove(stmfx->irq_domain);
}

static int stmfx_irq_init(struct i2c_client *client)
{
	struct stmfx *stmfx = i2c_get_clientdata(client);
	u32 irqoutpin = 0, irqtrigger;
	int ret;

	stmfx->irq_domain = irq_domain_add_simple(stmfx->dev->of_node,
						  STMFX_REG_IRQ_SRC_MAX, 0,
						  &stmfx_irq_ops, stmfx);
	if (!stmfx->irq_domain) {
		dev_err(stmfx->dev, "Failed to create IRQ domain\n");
		return -EINVAL;
	}

	if (!of_property_read_bool(stmfx->dev->of_node, "drive-open-drain"))
		irqoutpin |= STMFX_REG_IRQ_OUT_PIN_TYPE;

	irqtrigger = irq_get_trigger_type(client->irq);
	if ((irqtrigger & IRQ_TYPE_EDGE_RISING) ||
	    (irqtrigger & IRQ_TYPE_LEVEL_HIGH))
		irqoutpin |= STMFX_REG_IRQ_OUT_PIN_POL;

	ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
	if (ret)
		goto irq_exit;

	ret = devm_request_threaded_irq(stmfx->dev, client->irq,
					NULL, stmfx_irq_handler,
					irqtrigger | IRQF_ONESHOT,
					"stmfx", stmfx);
	if (ret)
		goto irq_exit;

	stmfx->irq = client->irq;

	return 0;

irq_exit:
	stmfx_irq_exit(client);

	return ret;
}

static int stmfx_chip_reset(struct stmfx *stmfx)
{
	int ret;

	ret = regmap_write(stmfx->map, STMFX_REG_SYS_CTRL,
			   STMFX_REG_SYS_CTRL_SWRST);
	if (ret)
		return ret;

	msleep(STMFX_BOOT_TIME_MS);

	return ret;
}

static int stmfx_chip_init(struct i2c_client *client)
{
	struct stmfx *stmfx = i2c_get_clientdata(client);
	u32 id;
	u8 version[2];
	int ret;

	stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd");
	ret = PTR_ERR_OR_ZERO(stmfx->vdd);
	if (ret) {
		if (ret == -ENODEV)
			stmfx->vdd = NULL;
		else
			return dev_err_probe(&client->dev, ret, "Failed to get VDD regulator\n");
	}

	if (stmfx->vdd) {
		ret = regulator_enable(stmfx->vdd);
		if (ret) {
			dev_err(&client->dev, "VDD enable failed: %d\n", ret);
			return ret;
		}
	}

	ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
	if (ret) {
		dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
		goto err;
	}

	/*
	 * Check that ID is the complement of the I2C address:
	 * STMFX I2C address follows the 7-bit format (MSB), that's why
	 * client->addr is shifted.
	 *
	 * STMFX_I2C_ADDR|       STMFX         |        Linux
	 *   input pin   | I2C device address  | I2C device address
	 *---------------------------------------------------------
	 *       0       | b: 1000 010x h:0x84 |       0x42
	 *       1       | b: 1000 011x h:0x86 |       0x43
	 */
	if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
		dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
		ret = -EINVAL;
		goto err;
	}

	ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
			       version, ARRAY_SIZE(version));
	if (ret) {
		dev_err(&client->dev, "Error reading FW version: %d\n", ret);
		goto err;
	}

	dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
		 id, version[0], version[1]);

	ret = stmfx_chip_reset(stmfx);
	if (ret) {
		dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
		goto err;
	}

	return 0;

err:
	if (stmfx->vdd)
		return regulator_disable(stmfx->vdd);

	return ret;
}

static int stmfx_chip_exit(struct i2c_client *client)
{
	struct stmfx *stmfx = i2c_get_clientdata(client);

	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
	regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);

	if (stmfx->vdd)
		return regulator_disable(stmfx->vdd);

	return 0;
}

static int stmfx_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct stmfx *stmfx;
	int ret;

	stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
	if (!stmfx)
		return -ENOMEM;

	i2c_set_clientdata(client, stmfx);

	stmfx->dev = dev;

	stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
	if (IS_ERR(stmfx->map)) {
		ret = PTR_ERR(stmfx->map);
		dev_err(dev, "Failed to allocate register map: %d\n", ret);
		return ret;
	}

	mutex_init(&stmfx->lock);

	ret = stmfx_chip_init(client);
	if (ret) {
		if (ret == -ETIMEDOUT)
			return -EPROBE_DEFER;
		return ret;
	}

	if (client->irq < 0) {
		dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
		ret = client->irq;
		goto err_chip_exit;
	}

	ret = stmfx_irq_init(client);
	if (ret)
		goto err_chip_exit;

	ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
				   stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
				   0, stmfx->irq_domain);
	if (ret)
		goto err_irq_exit;

	return 0;

err_irq_exit:
	stmfx_irq_exit(client);
err_chip_exit:
	stmfx_chip_exit(client);

	return ret;
}

static int stmfx_remove(struct i2c_client *client)
{
	stmfx_irq_exit(client);

	return stmfx_chip_exit(client);
}

#ifdef CONFIG_PM_SLEEP
static int stmfx_suspend(struct device *dev)
{
	struct stmfx *stmfx = dev_get_drvdata(dev);
	int ret;

	ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
			      &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
	if (ret)
		return ret;

	ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
			      &stmfx->bkp_irqoutpin,
			      sizeof(stmfx->bkp_irqoutpin));
	if (ret)
		return ret;

	disable_irq(stmfx->irq);

	if (stmfx->vdd)
		return regulator_disable(stmfx->vdd);

	return 0;
}

static int stmfx_resume(struct device *dev)
{
	struct stmfx *stmfx = dev_get_drvdata(dev);
	int ret;

	if (stmfx->vdd) {
		ret = regulator_enable(stmfx->vdd);
		if (ret) {
			dev_err(stmfx->dev,
				"VDD enable failed: %d\n", ret);
			return ret;
		}
	}

	/* Reset STMFX - supply has been stopped during suspend */
	ret = stmfx_chip_reset(stmfx);
	if (ret) {
		dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
		return ret;
	}

	ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
			       &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
	if (ret)
		return ret;

	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
			       &stmfx->bkp_irqoutpin,
			       sizeof(stmfx->bkp_irqoutpin));
	if (ret)
		return ret;

	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
			       &stmfx->irq_src, sizeof(stmfx->irq_src));
	if (ret)
		return ret;

	enable_irq(stmfx->irq);

	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);

static const struct of_device_id stmfx_of_match[] = {
	{ .compatible = "st,stmfx-0300", },
	{},
};
MODULE_DEVICE_TABLE(of, stmfx_of_match);

static struct i2c_driver stmfx_driver = {
	.driver = {
		.name = "stmfx-core",
		.of_match_table = stmfx_of_match,
		.pm = &stmfx_dev_pm_ops,
	},
	.probe = stmfx_probe,
	.remove = stmfx_remove,
};
module_i2c_driver(stmfx_driver);

MODULE_DESCRIPTION("STMFX core driver");
MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
06252ade AD	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
	4	*
	5	* Copyright (C) 2019 STMicroelectronics
	6	* Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
	7	*/
	8	#include <linux/bitfield.h>
	9	#include <linux/i2c.h>
	10	#include <linux/interrupt.h>
	11	#include <linux/irq.h>
	12	#include <linux/mfd/core.h>
	13	#include <linux/mfd/stmfx.h>
	14	#include <linux/module.h>
	15	#include <linux/regulator/consumer.h>
	16
	17	static bool stmfx_reg_volatile(struct device *dev, unsigned int reg)
	18	{
	19	switch (reg) {
	20	case STMFX_REG_SYS_CTRL:
	21	case STMFX_REG_IRQ_SRC_EN:
	22	case STMFX_REG_IRQ_PENDING:
	23	case STMFX_REG_IRQ_GPI_PENDING1:
	24	case STMFX_REG_IRQ_GPI_PENDING2:
	25	case STMFX_REG_IRQ_GPI_PENDING3:
	26	case STMFX_REG_GPIO_STATE1:
	27	case STMFX_REG_GPIO_STATE2:
	28	case STMFX_REG_GPIO_STATE3:
	29	case STMFX_REG_IRQ_GPI_SRC1:
	30	case STMFX_REG_IRQ_GPI_SRC2:
	31	case STMFX_REG_IRQ_GPI_SRC3:
	32	case STMFX_REG_GPO_SET1:
	33	case STMFX_REG_GPO_SET2:
	34	case STMFX_REG_GPO_SET3:
	35	case STMFX_REG_GPO_CLR1:
	36	case STMFX_REG_GPO_CLR2:
	37	case STMFX_REG_GPO_CLR3:
	38	return true;
	39	default:
	40	return false;
	41	}
	42	}
	43
	44	static bool stmfx_reg_writeable(struct device *dev, unsigned int reg)
	45	{
	46	return (reg >= STMFX_REG_SYS_CTRL);
	47	}
	48
	49	static const struct regmap_config stmfx_regmap_config = {
	50	.reg_bits = 8,
	51	.reg_stride = 1,
	52	.val_bits = 8,
	53	.max_register = STMFX_REG_MAX,
	54	.volatile_reg = stmfx_reg_volatile,
	55	.writeable_reg = stmfx_reg_writeable,
	56	.cache_type = REGCACHE_RBTREE,
	57	};
	58
	59	static const struct resource stmfx_pinctrl_resources[] = {
	60	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
	61	};
	62
	63	static const struct resource stmfx_idd_resources[] = {
	64	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_IDD),
65	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_ERROR),
66	};
67
68	static const struct resource stmfx_ts_resources[] = {
69	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_DET),
70	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_NE),
71	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_TH),
72	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_FULL),
73	DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_TS_OVF),
74	};
75
76	static struct mfd_cell stmfx_cells[] = {
77	{
78	.of_compatible = "st,stmfx-0300-pinctrl",
79	.name = "stmfx-pinctrl",
80	.resources = stmfx_pinctrl_resources,
81	.num_resources = ARRAY_SIZE(stmfx_pinctrl_resources),
82	},
83	{
84	.of_compatible = "st,stmfx-0300-idd",
85	.name = "stmfx-idd",
86	.resources = stmfx_idd_resources,
87	.num_resources = ARRAY_SIZE(stmfx_idd_resources),
88	},
89	{
90	.of_compatible = "st,stmfx-0300-ts",
91	.name = "stmfx-ts",
92	.resources = stmfx_ts_resources,
93	.num_resources = ARRAY_SIZE(stmfx_ts_resources),
94	},
95	};
96
97	static u8 stmfx_func_to_mask(u32 func)
98	{
99	u8 mask = 0;
100
101	if (func & STMFX_FUNC_GPIO)
102	mask \|= STMFX_REG_SYS_CTRL_GPIO_EN;
103
104	if ((func & STMFX_FUNC_ALTGPIO_LOW) \|\| (func & STMFX_FUNC_ALTGPIO_HIGH))
105	mask \|= STMFX_REG_SYS_CTRL_ALTGPIO_EN;
106
107	if (func & STMFX_FUNC_TS)
108	mask \|= STMFX_REG_SYS_CTRL_TS_EN;
109
110	if (func & STMFX_FUNC_IDD)
111	mask \|= STMFX_REG_SYS_CTRL_IDD_EN;
112
113	return mask;
114	}
115
116	int stmfx_function_enable(struct stmfx *stmfx, u32 func)
117	{
118	u32 sys_ctrl;
119	u8 mask;
120	int ret;
121
122	ret = regmap_read(stmfx->map, STMFX_REG_SYS_CTRL, &sys_ctrl);
123	if (ret)
124	return ret;
125
126	/*
127	* IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
128	* ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
129	* the number of aGPIO available decreases. To avoid GPIO management
130	* disturbance, abort IDD or TS function enable in this case.
131	*/
132	if (((func & STMFX_FUNC_IDD) \|\| (func & STMFX_FUNC_TS)) &&
133	(sys_ctrl & STMFX_REG_SYS_CTRL_ALTGPIO_EN)) {
134	dev_err(stmfx->dev, "ALTGPIO function already enabled\n");
135	return -EBUSY;
136	}
137
138	/* If TS is enabled, aGPIO[3:0] cannot be used */
139	if ((func & STMFX_FUNC_ALTGPIO_LOW) &&
140	(sys_ctrl & STMFX_REG_SYS_CTRL_TS_EN)) {
141	dev_err(stmfx->dev, "TS in use, aGPIO[3:0] unavailable\n");
142	return -EBUSY;
143	}
144
145	/* If IDD is enabled, aGPIO[7:4] cannot be used */
146	if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
147	(sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
148	dev_err(stmfx->dev, "IDD in use, aGPIO[7:4] unavailable\n");
149	return -EBUSY;
150	}
151
152	mask = stmfx_func_to_mask(func);
153
154	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, mask);
155	}
156	EXPORT_SYMBOL_GPL(stmfx_function_enable);
157
158	int stmfx_function_disable(struct stmfx *stmfx, u32 func)
159	{
160	u8 mask = stmfx_func_to_mask(func);
161
162	return regmap_update_bits(stmfx->map, STMFX_REG_SYS_CTRL, mask, 0);
163	}
164	EXPORT_SYMBOL_GPL(stmfx_function_disable);
165
166	static void stmfx_irq_bus_lock(struct irq_data *data)
167	{
168	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
169
170	mutex_lock(&stmfx->lock);
171	}
172
173	static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
174	{
175	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
176
177	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, stmfx->irq_src);
178
179	mutex_unlock(&stmfx->lock);
180	}
181
182	static void stmfx_irq_mask(struct irq_data *data)
183	{
184	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
185
186	stmfx->irq_src &= ~BIT(data->hwirq % 8);
187	}
188
189	static void stmfx_irq_unmask(struct irq_data *data)
190	{
191	struct stmfx *stmfx = irq_data_get_irq_chip_data(data);
192
193	stmfx->irq_src \|= BIT(data->hwirq % 8);
194	}
195
196	static struct irq_chip stmfx_irq_chip = {
197	.name = "stmfx-core",
198	.irq_bus_lock = stmfx_irq_bus_lock,
199	.irq_bus_sync_unlock = stmfx_irq_bus_sync_unlock,
200	.irq_mask = stmfx_irq_mask,
201	.irq_unmask = stmfx_irq_unmask,
202	};
203
204	static irqreturn_t stmfx_irq_handler(int irq, void *data)
205	{
206	struct stmfx *stmfx = data;
63b2de12	207	unsigned long bits;
cd49b84d DC	208	u32 pending, ack;
cd49b84d DC	209	int n, ret;
06252ade	210
cd49b84d	211	ret = regmap_read(stmfx->map, STMFX_REG_IRQ_PENDING, &pending);
06252ade AD	212	if (ret)
	213	return IRQ_NONE;
	214
	215	/*
	216	* There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
	217	* of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
	218	*/
	219	ack = pending & ~BIT(STMFX_REG_IRQ_SRC_EN_GPIO);
	220	if (ack) {
	221	ret = regmap_write(stmfx->map, STMFX_REG_IRQ_ACK, ack);
	222	if (ret)
	223	return IRQ_NONE;
	224	}
	225
63b2de12 DC	226	bits = pending;
63b2de12 DC	227	for_each_set_bit(n, &bits, STMFX_REG_IRQ_SRC_MAX)
06252ade AD	228	handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));
	229
	230	return IRQ_HANDLED;
	231	}
	232
	233	static int stmfx_irq_map(struct irq_domain *d, unsigned int virq,
	234	irq_hw_number_t hwirq)
	235	{
	236	irq_set_chip_data(virq, d->host_data);
	237	irq_set_chip_and_handler(virq, &stmfx_irq_chip, handle_simple_irq);
	238	irq_set_nested_thread(virq, 1);
	239	irq_set_noprobe(virq);
	240
	241	return 0;
	242	}
	243
	244	static void stmfx_irq_unmap(struct irq_domain *d, unsigned int virq)
	245	{
	246	irq_set_chip_and_handler(virq, NULL, NULL);
	247	irq_set_chip_data(virq, NULL);
	248	}
	249
	250	static const struct irq_domain_ops stmfx_irq_ops = {
	251	.map = stmfx_irq_map,
	252	.unmap = stmfx_irq_unmap,
	253	};
	254
	255	static void stmfx_irq_exit(struct i2c_client *client)
	256	{
	257	struct stmfx *stmfx = i2c_get_clientdata(client);
	258	int hwirq;
	259
	260	for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
	261	irq_dispose_mapping(irq_find_mapping(stmfx->irq_domain, hwirq));
	262
	263	irq_domain_remove(stmfx->irq_domain);
	264	}
	265
	266	static int stmfx_irq_init(struct i2c_client *client)
	267	{
	268	struct stmfx *stmfx = i2c_get_clientdata(client);
	269	u32 irqoutpin = 0, irqtrigger;
	270	int ret;
	271
	272	stmfx->irq_domain = irq_domain_add_simple(stmfx->dev->of_node,
	273	STMFX_REG_IRQ_SRC_MAX, 0,
	274	&stmfx_irq_ops, stmfx);
	275	if (!stmfx->irq_domain) {
	276	dev_err(stmfx->dev, "Failed to create IRQ domain\n");
	277	return -EINVAL;
	278	}
	279
	280	if (!of_property_read_bool(stmfx->dev->of_node, "drive-open-drain"))
	281	irqoutpin \|= STMFX_REG_IRQ_OUT_PIN_TYPE;
	282
	283	irqtrigger = irq_get_trigger_type(client->irq);
	284	if ((irqtrigger & IRQ_TYPE_EDGE_RISING) \|\|
	285	(irqtrigger & IRQ_TYPE_LEVEL_HIGH))
	286	irqoutpin \|= STMFX_REG_IRQ_OUT_PIN_POL;
	287
	288	ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
	289	if (ret)
60c2c4bc	290	goto irq_exit;
06252ade AD	291
	292	ret = devm_request_threaded_irq(stmfx->dev, client->irq,
	293	NULL, stmfx_irq_handler,
	294	irqtrigger \| IRQF_ONESHOT,
	295	"stmfx", stmfx);
	296	if (ret)
60c2c4bc AD	297	goto irq_exit;
60c2c4bc AD	298
97eda5dc AD	299	stmfx->irq = client->irq;
97eda5dc AD	300
60c2c4bc AD	301	return 0;
	302
	303	irq_exit:
	304	stmfx_irq_exit(client);
06252ade AD	305
	306	return ret;
	307	}
	308
	309	static int stmfx_chip_reset(struct stmfx *stmfx)
	310	{
	311	int ret;
	312
	313	ret = regmap_write(stmfx->map, STMFX_REG_SYS_CTRL,
	314	STMFX_REG_SYS_CTRL_SWRST);
	315	if (ret)
	316	return ret;
	317
	318	msleep(STMFX_BOOT_TIME_MS);
	319
	320	return ret;
	321	}
	322
	323	static int stmfx_chip_init(struct i2c_client *client)
	324	{
	325	struct stmfx *stmfx = i2c_get_clientdata(client);
	326	u32 id;
	327	u8 version[2];
	328	int ret;
	329
	330	stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd");
	331	ret = PTR_ERR_OR_ZERO(stmfx->vdd);
d75846ed AD	332	if (ret) {
	333	if (ret == -ENODEV)
	334	stmfx->vdd = NULL;
	335	else
	336	return dev_err_probe(&client->dev, ret, "Failed to get VDD regulator\n");
06252ade AD	337	}
	338
	339	if (stmfx->vdd) {
	340	ret = regulator_enable(stmfx->vdd);
	341	if (ret) {
	342	dev_err(&client->dev, "VDD enable failed: %d\n", ret);
	343	return ret;
	344	}
	345	}
	346
	347	ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
	348	if (ret) {
	349	dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
	350	goto err;
	351	}
	352
	353	/*
	354	* Check that ID is the complement of the I2C address:
	355	* STMFX I2C address follows the 7-bit format (MSB), that's why
	356	* client->addr is shifted.
	357	*
	358	* STMFX_I2C_ADDR\| STMFX \| Linux
	359	* input pin \| I2C device address \| I2C device address
	360	*---------------------------------------------------------
	361	* 0 \| b: 1000 010x h:0x84 \| 0x42
	362	* 1 \| b: 1000 011x h:0x86 \| 0x43
	363	*/
	364	if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
	365	dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
	366	ret = -EINVAL;
	367	goto err;
	368	}
	369
	370	ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
	371	version, ARRAY_SIZE(version));
	372	if (ret) {
	373	dev_err(&client->dev, "Error reading FW version: %d\n", ret);
	374	goto err;
	375	}
	376
	377	dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
	378	id, version[0], version[1]);
	379
	380	ret = stmfx_chip_reset(stmfx);
	381	if (ret) {
	382	dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
	383	goto err;
	384	}
	385
	386	return 0;
	387
	388	err:
	389	if (stmfx->vdd)
	390	return regulator_disable(stmfx->vdd);
	391
	392	return ret;
	393	}
	394
	395	static int stmfx_chip_exit(struct i2c_client *client)
	396	{
	397	struct stmfx *stmfx = i2c_get_clientdata(client);
	398
	399	regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
	400	regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);
401
402	if (stmfx->vdd)
403	return regulator_disable(stmfx->vdd);
404
405	return 0;
406	}
407
408	static int stmfx_probe(struct i2c_client *client,
409	const struct i2c_device_id *id)
410	{
411	struct device *dev = &client->dev;
412	struct stmfx *stmfx;
413	int ret;
414
415	stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
416	if (!stmfx)
417	return -ENOMEM;
418
419	i2c_set_clientdata(client, stmfx);
420
421	stmfx->dev = dev;
422
423	stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
424	if (IS_ERR(stmfx->map)) {
425	ret = PTR_ERR(stmfx->map);
426	dev_err(dev, "Failed to allocate register map: %d\n", ret);
427	return ret;
428	}
429
430	mutex_init(&stmfx->lock);
431
432	ret = stmfx_chip_init(client);
433	if (ret) {
434	if (ret == -ETIMEDOUT)
435	return -EPROBE_DEFER;
436	return ret;
437	}
438
439	if (client->irq < 0) {
440	dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
441	ret = client->irq;
442	goto err_chip_exit;
443	}
444
445	ret = stmfx_irq_init(client);
446	if (ret)
447	goto err_chip_exit;
448
449	ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
450	stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
451	0, stmfx->irq_domain);
452	if (ret)
453	goto err_irq_exit;
454
455	return 0;
456
457	err_irq_exit:
458	stmfx_irq_exit(client);
459	err_chip_exit:
460	stmfx_chip_exit(client);
461
462	return ret;
463	}
464
465	static int stmfx_remove(struct i2c_client *client)
466	{
467	stmfx_irq_exit(client);
468
469	return stmfx_chip_exit(client);
470	}
471
472	#ifdef CONFIG_PM_SLEEP
473	static int stmfx_suspend(struct device *dev)
474	{
475	struct stmfx *stmfx = dev_get_drvdata(dev);
476	int ret;
477
478	ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
479	&stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
480	if (ret)
481	return ret;
482
483	ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
484	&stmfx->bkp_irqoutpin,
485	sizeof(stmfx->bkp_irqoutpin));
486	if (ret)
487	return ret;
488
97eda5dc AD	489	disable_irq(stmfx->irq);
97eda5dc AD	490
06252ade AD	491	if (stmfx->vdd)
	492	return regulator_disable(stmfx->vdd);
	493
	494	return 0;
	495	}
	496
	497	static int stmfx_resume(struct device *dev)
	498	{
	499	struct stmfx *stmfx = dev_get_drvdata(dev);
	500	int ret;
	501
	502	if (stmfx->vdd) {
	503	ret = regulator_enable(stmfx->vdd);
	504	if (ret) {
	505	dev_err(stmfx->dev,
	506	"VDD enable failed: %d\n", ret);
	507	return ret;
	508	}
	509	}
	510
e583649d AD	511	/* Reset STMFX - supply has been stopped during suspend */
	512	ret = stmfx_chip_reset(stmfx);
	513	if (ret) {
	514	dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
	515	return ret;
	516	}
	517
06252ade AD	518	ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
	519	&stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
	520	if (ret)
	521	return ret;
	522
	523	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
	524	&stmfx->bkp_irqoutpin,
	525	sizeof(stmfx->bkp_irqoutpin));
	526	if (ret)
	527	return ret;
	528
	529	ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
	530	&stmfx->irq_src, sizeof(stmfx->irq_src));
	531	if (ret)
	532	return ret;
	533
97eda5dc AD	534	enable_irq(stmfx->irq);
97eda5dc AD	535
06252ade AD	536	return 0;
	537	}
	538	#endif
	539
	540	static SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);
	541
	542	static const struct of_device_id stmfx_of_match[] = {
	543	{ .compatible = "st,stmfx-0300", },
	544	{},
	545	};
	546	MODULE_DEVICE_TABLE(of, stmfx_of_match);
	547
	548	static struct i2c_driver stmfx_driver = {
	549	.driver = {
	550	.name = "stmfx-core",
a06d0dc4	551	.of_match_table = stmfx_of_match,
06252ade AD	552	.pm = &stmfx_dev_pm_ops,
	553	},
	554	.probe = stmfx_probe,
	555	.remove = stmfx_remove,
	556	};
	557	module_i2c_driver(stmfx_driver);
	558
	559	MODULE_DESCRIPTION("STMFX core driver");
	560	MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
	561	MODULE_LICENSE("GPL v2");