lkml.org 
[lkml]   [2019]   [Feb]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
From
SubjectRe: [PATCH v3 2/7] mfd: Add ST Multi-Function eXpander (STMFX) core driver
Date
On 10/9/18 11:55 AM, Lee Jones wrote:
> On Thu, 27 Sep 2018, Amelie Delaunay wrote:
>
>> STMicroelectronics Multi-Function eXpander (STMFX) is a slave controller
>> using I2C for communication with the main MCU. Main features are:
>> - 16 fast GPIOs individually configurable in input/output
>> - 8 alternate GPIOs individually configurable in input/output when other
>> STMFX functions are not used
>> - Main MCU IDD measurement
>> - Resistive touchscreen controller
>>
>> Signed-off-by: Amelie Delaunay <amelie.delaunay@st.com>
>> Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
>> ---
>> drivers/mfd/Kconfig | 14 ++
>> drivers/mfd/Makefile | 2 +-
>> drivers/mfd/stmfx.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++
>> include/linux/mfd/stmfx.h | 27 ++
>> 4 files changed, 668 insertions(+), 1 deletion(-)
>> create mode 100644 drivers/mfd/stmfx.c
>> create mode 100644 include/linux/mfd/stmfx.h
>>
>> diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
>> index f3a5f8d..8c41342 100644
>> --- a/drivers/mfd/Kconfig
>> +++ b/drivers/mfd/Kconfig
>> @@ -1862,6 +1862,20 @@ config MFD_STM32_TIMERS
>> for PWM and IIO Timer. This driver allow to share the
>> registers between the others drivers.
>>
>> +config MFD_STMFX
>> + tristate "Support for STMicroelectronics Multi-Function eXpander (STMFX)"
>> + depends on I2C
>> + depends on OF || COMPILE_TEST
>> + select MFD_CORE
>> + select REGMAP_I2C
>> + help
>> + Support for the STMicroelectronics Multi-Function eXpander.
>> +
>> + This driver provides common support for accessing the device,
>> + additional drivers must be enabled in order to use the functionality
>> + of the device.
>> +
>> +
>> menu "Multimedia Capabilities Port drivers"
>> depends on ARCH_SA1100
>>
>> diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
>> index 5856a94..282323b 100644
>> --- a/drivers/mfd/Makefile
>> +++ b/drivers/mfd/Makefile
>> @@ -240,4 +240,4 @@ obj-$(CONFIG_MFD_MXS_LRADC) += mxs-lradc.o
>> obj-$(CONFIG_MFD_SC27XX_PMIC) += sprd-sc27xx-spi.o
>> obj-$(CONFIG_RAVE_SP_CORE) += rave-sp.o
>> obj-$(CONFIG_MFD_ROHM_BD718XX) += rohm-bd718x7.o
>> -
>> +obj-$(CONFIG_MFD_STMFX) += stmfx.o
>> diff --git a/drivers/mfd/stmfx.c b/drivers/mfd/stmfx.c
>> new file mode 100644
>> index 0000000..cfd4fca
>> --- /dev/null
>> +++ b/drivers/mfd/stmfx.c
>> @@ -0,0 +1,626 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +/*
>> + * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
>> + *
>> + * Copyright (C) 2018 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>
>> +
>> +/* General */
>> +#define STMFX_REG_CHIP_ID 0x00 /* R */
>> +#define STMFX_REG_FW_VERSION_MSB 0x01 /* R */
>> +#define STMFX_REG_FW_VERSION_LSB 0x02 /* R */
>> +#define STMFX_REG_SYS_CTRL 0x40 /* RW */
>> +/* IRQ output management */
>> +#define STMFX_REG_IRQ_OUT_PIN 0x41 /* RW */
>> +#define STMFX_REG_IRQ_SRC_EN 0x42 /* RW */
>> +#define STMFX_REG_IRQ_PENDING 0x08 /* R */
>> +#define STMFX_REG_IRQ_ACK 0x44 /* RW */
>> +/* GPIO management */
>> +#define STMFX_REG_IRQ_GPI_PENDING1 0x0C /* R */
>> +#define STMFX_REG_IRQ_GPI_PENDING2 0x0D /* R */
>> +#define STMFX_REG_IRQ_GPI_PENDING3 0x0E /* R */
>> +#define STMFX_REG_GPIO_STATE1 0x10 /* R */
>> +#define STMFX_REG_GPIO_STATE2 0x11 /* R */
>> +#define STMFX_REG_GPIO_STATE3 0x12 /* R */
>> +#define STMFX_REG_IRQ_GPI_SRC1 0x48 /* RW */
>> +#define STMFX_REG_IRQ_GPI_SRC2 0x49 /* RW */
>> +#define STMFX_REG_IRQ_GPI_SRC3 0x4A /* RW */
>> +#define STMFX_REG_GPO_SET1 0x6C /* RW */
>> +#define STMFX_REG_GPO_SET2 0x6D /* RW */
>> +#define STMFX_REG_GPO_SET3 0x6E /* RW */
>> +#define STMFX_REG_GPO_CLR1 0x70 /* RW */
>> +#define STMFX_REG_GPO_CLR2 0x71 /* RW */
>> +#define STMFX_REG_GPO_CLR3 0x72 /* RW */
>> +
>> +#define STMFX_REG_MAX 0xB0
>> +
>> +/* MFX boot time is around 10ms, so after reset, we have to wait this delay */
>> +#define STMFX_BOOT_TIME_MS 10
>> +
>> +/* STMFX_REG_CHIP_ID bitfields */
>> +#define STMFX_REG_CHIP_ID_MASK GENMASK(7, 0)
>> +
>> +/* STMFX_REG_SYS_CTRL bitfields */
>> +#define STMFX_REG_SYS_CTRL_GPIO_EN BIT(0)
>> +#define STMFX_REG_SYS_CTRL_TS_EN BIT(1)
>> +#define STMFX_REG_SYS_CTRL_IDD_EN BIT(2)
>> +#define STMFX_REG_SYS_CTRL_ALTGPIO_EN BIT(3)
>> +#define STMFX_REG_SYS_CTRL_SWRST BIT(7)
>> +
>> +/* STMFX_REG_IRQ_OUT_PIN bitfields */
>> +#define STMFX_REG_IRQ_OUT_PIN_TYPE BIT(0) /* 0-OD 1-PP */
>> +#define STMFX_REG_IRQ_OUT_PIN_POL BIT(1) /* 0-active LOW 1-active HIGH */
>> +
>> +/* STMFX_REG_IRQ_(SRC_EN/PENDING/ACK) bit shift */
>> +enum stmfx_irqs {
>> + STMFX_REG_IRQ_SRC_EN_GPIO = 0,
>> + STMFX_REG_IRQ_SRC_EN_IDD,
>> + STMFX_REG_IRQ_SRC_EN_ERROR,
>> + STMFX_REG_IRQ_SRC_EN_TS_DET,
>> + STMFX_REG_IRQ_SRC_EN_TS_NE,
>> + STMFX_REG_IRQ_SRC_EN_TS_TH,
>> + STMFX_REG_IRQ_SRC_EN_TS_FULL,
>> + STMFX_REG_IRQ_SRC_EN_TS_OVF,
>> + STMFX_REG_IRQ_SRC_MAX,
>> +};
>
> I'd prefer from here up to the includes to be placed into the header.
>

OK.

>> +/**
>> + * struct stmfx_ddata - STMFX MFD private structure
>
> You can drop '_ddata' from here (read next comment).
>
>> + * @stmfx: state holder with device for logs and register map
>
> I don't understand why this requires an additional struct.
>
>> + * @vdd: STMFX power supply
>> + * @irq_domain: IRQ domain
>> + * @lock: IRQ bus lock
>> + * @irq_src: cache of IRQ_SRC_EN register for bus_lock
>> + * @bkp_sysctrl: backup of SYS_CTRL register for suspend/resume
>> + * @bkp_irqoutpin: backup of IRQ_OUT_PIN register for suspend/resume
>> + */
>> +struct stmfx_ddata {
>> + struct stmfx *stmfx;
>> + struct regulator *vdd;
>> + struct irq_domain *irq_domain;
>> + struct mutex lock; /* IRQ bus lock */
>> + u8 irq_src;
>> +#ifdef CONFIG_PM
>> + u8 bkp_sysctrl;
>> + u8 bkp_irqoutpin;
>> +#endif
>
> I haven't seen this before.
>
> Why is this necessary for *this* device and no others?
>

Not necessary in fact. Private structure was here to reflect the mfd
core specific members because I thought it was useless for his children
to have access to these struct members.

>> +};
>> +
>> +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_ddata *ddata = irq_data_get_irq_chip_data(data);
>> +
>> + mutex_lock(&ddata->lock);
>> +}
>> +
>> +static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
>> +{
>> + struct stmfx_ddata *ddata = irq_data_get_irq_chip_data(data);
>> +
>> + regmap_write(ddata->stmfx->map, STMFX_REG_IRQ_SRC_EN, ddata->irq_src);
>> +
>> + mutex_unlock(&ddata->lock);
>> +}
>> +
>> +static void stmfx_irq_mask(struct irq_data *data)
>> +{
>> + struct stmfx_ddata *ddata = irq_data_get_irq_chip_data(data);
>> +
>> + ddata->irq_src &= ~BIT(data->hwirq % 8);
>> +}
>> +
>> +static void stmfx_irq_unmask(struct irq_data *data)
>> +{
>> + struct stmfx_ddata *ddata = irq_data_get_irq_chip_data(data);
>> +
>> + ddata->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_ddata *ddata = data;
>> + unsigned long n, pending;
>> + u32 ack;
>> + int ret;
>> +
>> + ret = regmap_read(ddata->stmfx->map, STMFX_REG_IRQ_PENDING,
>> + (u32 *)&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(ddata->stmfx->map, STMFX_REG_IRQ_ACK, ack);
>> + if (ret)
>> + return IRQ_NONE;
>> + }
>> +
>> + for_each_set_bit(n, &pending, STMFX_REG_IRQ_SRC_MAX)
>> + handle_nested_irq(irq_find_mapping(ddata->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 stmfx_ddata *ddata)
>> +{
>> + int hwirq;
>> +
>> + for (hwirq = 0; hwirq < STMFX_REG_IRQ_SRC_MAX; hwirq++)
>> + irq_dispose_mapping(irq_find_mapping(ddata->irq_domain, hwirq));
>
> '\n' here please.
>
>> + irq_domain_remove(ddata->irq_domain);
>> +}
>> +
>> +static int stmfx_irq_init(struct stmfx_ddata *ddata, int irq)
>> +{
>> + struct device *dev = ddata->stmfx->dev;
>
> Better to pass either 'dev' or 'pdev' around and extrapolate using the
> dev_get_drvdata() helpers, rather than the other way around.
>

I agree. I can pass i2c client and extrapolate using the
i2c_get_clientdata helper, here and in _irq_exit, _chip_init,
_chip_exit, to homogenize.

>> + u32 irqoutpin = 0, irqtrigger;
>> + int ret;
>> +
>> + ddata->irq_domain = irq_domain_add_simple(dev->of_node,
>> + STMFX_REG_IRQ_SRC_MAX, 0,
>> + &stmfx_irq_ops, ddata);
>> + if (!ddata->irq_domain) {
>> + dev_err(dev, "failed to create irq domain\n");
>
> s/irq/IRQ/
>
> I also prefer capital letters to start sentences, but it's not
> critical here.
>

OK, I will fix all typos.

>> + return -EINVAL;
>> + }
>> +
>> + if (!of_property_read_bool(dev->of_node, "drive-open-drain"))
>> + irqoutpin |= STMFX_REG_IRQ_OUT_PIN_TYPE;
>> +
>> + irqtrigger = irq_get_trigger_type(irq);
>> + if ((irqtrigger & IRQ_TYPE_EDGE_RISING) ||
>> + (irqtrigger & IRQ_TYPE_LEVEL_HIGH))
>> + irqoutpin |= STMFX_REG_IRQ_OUT_PIN_POL;
>> +
>> + ret = regmap_write(ddata->stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin);
>> + if (ret)
>> + return ret;
>> +
>> + ret = devm_request_threaded_irq(dev, irq, NULL, stmfx_irq_handler,
>> + irqtrigger | IRQF_ONESHOT,
>> + "stmfx", ddata);
>> + if (ret)
>> + stmfx_irq_exit(ddata);
>> +
>> + return ret;
>> +}
>> +
>> +static int stmfx_chip_reset(struct stmfx_ddata *ddata)
>> +{
>> + int ret;
>> +
>> + ret = regmap_write(ddata->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 stmfx_ddata *ddata, struct i2c_client *client)
>
> No need to provide both ddata and client, you can extrapolate the
> former from the latter.
>
>> +{
>> + u32 id;
>> + u8 version[2];
>> + int ret;
>> +
>> + ddata->vdd = devm_regulator_get_optional(&client->dev, "vdd");
>> + if (IS_ERR(ddata->vdd)) {
>> + ret = PTR_ERR(ddata->vdd);
>> + if (ret != -ENODEV) {
>> + if (ret != -EPROBE_DEFER)
>> + dev_err(&client->dev,
>> + "no vdd regulator found:%d\n", ret);
>
> s/vdd/VDD/?
>
>> + return ret;
>> + }
>> + }
>> +
>> + if (!IS_ERR(ddata->vdd)) {
>
> Why not just 'else'?
>
>> + ret = regulator_enable(ddata->vdd);
>> + if (ret) {
>> + dev_err(&client->dev, "vdd enable failed: %d\n", ret);
>
> s/vdd/VDD/?
>
>> + return ret;
>> + }
>> + }
>> +
>> + ret = regmap_read(ddata->stmfx->map, STMFX_REG_CHIP_ID, &id);
>> + if (ret) {
>> + dev_err(&client->dev, "error reading chip id: %d\n", ret);
>
> s/id/ID/
>
>> + 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(ddata->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]);
>> +
>> + return stmfx_chip_reset(ddata);
>> +
>> +err:
>> + if (!IS_ERR(ddata->vdd))
>> + return regulator_disable(ddata->vdd);
>> +
>> + return ret;
>> +}
>> +
>> +static int stmfx_chip_exit(struct stmfx_ddata *ddata)
>> +{
>> + regmap_write(ddata->stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
>> + regmap_write(ddata->stmfx->map, STMFX_REG_SYS_CTRL, 0);
>> +
>> + if (!IS_ERR(ddata->vdd))
>> + return regulator_disable(ddata->vdd);
>> +
>> + return 0;
>> +}
>> +
>> +static const struct resource stmfx_pinctrl_resources[] = {
>> + DEFINE_RES_IRQ(STMFX_REG_IRQ_SRC_EN_GPIO),
>> +};
>> +
>> +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),
>> + }
>> +};
>
> What other devices make up this MFD?
>

I can add two other cells for TouchScreen feature with TouchScreen
interrupts, and IDD feature with IDD and Error interrupt (used by IDD
module to raise default/error encountered during IDD measurement).

>> +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 int stmfx_probe(struct i2c_client *client,
>> + const struct i2c_device_id *id)
>> +{
>> + struct device *dev = &client->dev;
>> + struct stmfx_ddata *ddata;
>> + int i, ret;
>> +
>> + ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
>> + if (!ddata)
>> + return -ENOMEM;
>
> '\n' here please.
>
>> + /* State holder */
>> + ddata->stmfx = devm_kzalloc(dev, sizeof(*ddata->stmfx), GFP_KERNEL);
>> + if (!ddata->stmfx)
>> + return -ENOMEM;
>> +
>> + i2c_set_clientdata(client, ddata);
>> +
>> + ddata->stmfx->dev = dev;
>> +
>> + ddata->stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
>
> Just put this straight into the parent struct and do away with the
> extra complication.
>
>> + if (IS_ERR(ddata->stmfx->map)) {
>> + ret = PTR_ERR(ddata->stmfx->map);
>> + dev_err(dev, "failed to allocate register map: %d\n", ret);
>> + return ret;
>> + }
>> +
>> + mutex_init(&ddata->lock);
>> +
>> + ret = stmfx_chip_init(ddata, 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(ddata, client->irq);
>> + if (ret)
>> + goto err_chip_exit;
>> +
>> + for (i = 0; i < ARRAY_SIZE(stmfx_cells); i++) {
>> + stmfx_cells[i].platform_data = ddata->stmfx;
>> + stmfx_cells[i].pdata_size = sizeof(struct stmfx);
>> + }
>> +
>> + ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
>> + stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
>> + 0, ddata->irq_domain);
>> + if (ret)
>> + goto err_irq_exit;
>> +
>> + return 0;
>> +
>> +err_irq_exit:
>> + stmfx_irq_exit(ddata);
>> +err_chip_exit:
>> + stmfx_chip_exit(ddata);
>> +
>> + return ret;
>> +}
>> +
>> +static int stmfx_remove(struct i2c_client *client)
>> +{
>> + struct stmfx_ddata *ddata = i2c_get_clientdata(client);
>> +
>> + stmfx_irq_exit(ddata);
>> +
>> + return stmfx_chip_exit(ddata);
>> +}
>> +
>> +#ifdef CONFIG_PM_SLEEP
>> +static int stmfx_backup_regs(struct stmfx_ddata *ddata)
>> +{
>> + int ret;
>> +
>> + ret = regmap_raw_read(ddata->stmfx->map, STMFX_REG_SYS_CTRL,
>> + &ddata->bkp_sysctrl, sizeof(ddata->bkp_sysctrl));
>> + if (ret)
>> + return ret;
>> + ret = regmap_raw_read(ddata->stmfx->map, STMFX_REG_IRQ_OUT_PIN,
>> + &ddata->bkp_irqoutpin,
>> + sizeof(ddata->bkp_irqoutpin));
>> + if (ret)
>> + return ret;
>> +
>> + return 0;
>> +}
>> +
>> +static int stmfx_restore_regs(struct stmfx_ddata *ddata)
>> +{
>> + int ret;
>> +
>> + ret = regmap_raw_write(ddata->stmfx->map, STMFX_REG_SYS_CTRL,
>> + &ddata->bkp_sysctrl, sizeof(ddata->bkp_sysctrl));
>> + if (ret)
>> + return ret;
>> + ret = regmap_raw_write(ddata->stmfx->map, STMFX_REG_IRQ_OUT_PIN,
>> + &ddata->bkp_irqoutpin,
>> + sizeof(ddata->bkp_irqoutpin));
>> + if (ret)
>> + return ret;
>> + ret = regmap_raw_write(ddata->stmfx->map, STMFX_REG_IRQ_SRC_EN,
>> + &ddata->irq_src, sizeof(ddata->irq_src));
>> + if (ret)
>> + return ret;
>> +
>> + return 0;
>> +}
>> +
>> +static int stmfx_suspend(struct device *dev)
>> +{
>> + struct stmfx_ddata *ddata = dev_get_drvdata(dev);
>> + int ret;
>> +
>> + ret = stmfx_backup_regs(ddata);
>> + if (ret) {
>> + dev_err(ddata->stmfx->dev, "registers backup failure\n");
>> + return ret;
>> + }
>> +
>> + if (!IS_ERR(ddata->vdd)) {
>> + ret = regulator_disable(ddata->vdd);
>> + if (ret)
>> + return ret;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int stmfx_resume(struct device *dev)
>> +{
>> + struct stmfx_ddata *ddata = dev_get_drvdata(dev);
>> + int ret;
>> +
>> + if (!IS_ERR(ddata->vdd)) {
>> + ret = regulator_enable(ddata->vdd);
>> + if (ret) {
>> + dev_err(ddata->stmfx->dev,
>> + "vdd enable failed: %d\n", ret);
>> + return ret;
>> + }
>> + }
>> +
>> + ret = stmfx_restore_regs(ddata);
>> + if (ret) {
>> + dev_err(ddata->stmfx->dev, "registers restoration failure\n");
>> + return ret;
>> + }
>> +
>> + 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 = of_match_ptr(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");
>> diff --git a/include/linux/mfd/stmfx.h b/include/linux/mfd/stmfx.h
>> new file mode 100644
>> index 0000000..35c3d42
>> --- /dev/null
>> +++ b/include/linux/mfd/stmfx.h
>> @@ -0,0 +1,27 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +/*
>> + * Copyright (C) 2018 STMicroelectronics
>> + * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
>> + */
>> +
>> +#ifndef MFD_STMFX_H
>> +#define MFX_STMFX_H
>> +
>> +#include <linux/regmap.h>
>> +
>> +enum stmfx_functions {
>> + STMFX_FUNC_GPIO = BIT(0), /* GPIO[15:0] */
>> + STMFX_FUNC_ALTGPIO_LOW = BIT(1), /* aGPIO[3:0] */
>> + STMFX_FUNC_ALTGPIO_HIGH = BIT(2), /* aGPIO[7:4] */
>> + STMFX_FUNC_TS = BIT(3),
>> + STMFX_FUNC_IDD = BIT(4),
>> +};
>> +
>> +struct stmfx {
>> + struct device *dev;
>> + struct regmap *map;
>> +};
>> +
>> +int stmfx_function_enable(struct stmfx *stmfx, u32 func);
>> +int stmfx_function_disable(struct stmfx *stmfx, u32 func);
>> +#endif
>

V4 is coming, based on your comments. Thanks for the review.

Regards,
Amelie
\
 
 \ /
  Last update: 2019-02-27 10:33    [W:0.076 / U:8.452 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site