* [PATCH V1 0/3] da7280: haptic driver submission @ 2018-08-16 2:02 ` Roy Im 0 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: Roy Im <roy.im.opensource@diasemi.com> This patch adds support for the Dialog DA7280 Haptic driver IC. In this patch set the following is provided: [PATCH V1 1/3] MAINTAINERS file update for DA7280 [PATCH V1 2/3] DA7280 DT Binding [PATCH V1 3/3] DA7280 Driver This patch applies against linux-next and v4.18 Thank you, Roy Im, Dialog Semiconductor Ltd. Roy Im (3): MAINTAINERS: da7280 updates to the Dialog Semiconductor search terms Documentation: devicetree: input: new binding for da7280 Input: new da7280 haptic driver .../devicetree/bindings/input/dlg,da7280.txt | 91 ++ MAINTAINERS | 2 + drivers/input/misc/Kconfig | 12 + drivers/input/misc/Makefile | 1 + drivers/input/misc/da7280.c | 1452 ++++++++++++++++++++ drivers/input/misc/da7280.h | 412 ++++++ 6 files changed, 1970 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/dlg,da7280.txt create mode 100644 drivers/input/misc/da7280.c create mode 100644 drivers/input/misc/da7280.h -- end-of-patch for PATCH V1 ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH V1 0/3] da7280: haptic driver submission @ 2018-08-16 2:02 ` Roy Im 0 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: Roy Im <roy.im.opensource@diasemi.com> This patch adds support for the Dialog DA7280 Haptic driver IC. In this patch set the following is provided: [PATCH V1 1/3] MAINTAINERS file update for DA7280 [PATCH V1 2/3] DA7280 DT Binding [PATCH V1 3/3] DA7280 Driver This patch applies against linux-next and v4.18 Thank you, Roy Im, Dialog Semiconductor Ltd. Roy Im (3): MAINTAINERS: da7280 updates to the Dialog Semiconductor search terms Documentation: devicetree: input: new binding for da7280 Input: new da7280 haptic driver .../devicetree/bindings/input/dlg,da7280.txt | 91 ++ MAINTAINERS | 2 + drivers/input/misc/Kconfig | 12 + drivers/input/misc/Makefile | 1 + drivers/input/misc/da7280.c | 1452 ++++++++++++++++++++ drivers/input/misc/da7280.h | 412 ++++++ 6 files changed, 1970 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/dlg,da7280.txt create mode 100644 drivers/input/misc/da7280.c create mode 100644 drivers/input/misc/da7280.h -- end-of-patch for PATCH V1 ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH V1 2/3] Documentation: devicetree: input: new binding for da7280 2018-08-16 2:02 ` Roy Im @ 2018-08-16 2:02 ` Roy Im -1 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel from: Roy Im <roy.im.opensource@diasemi.com> Add device tree binding information for DA7280 haptic driver. Example bindings for DA7280 are added. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- .../devicetree/bindings/input/dlg,da7280.txt | 91 ++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/dlg,da7280.txt diff --git a/Documentation/devicetree/bindings/input/dlg,da7280.txt b/Documentation/devicetree/bindings/input/dlg,da7280.txt new file mode 100644 index 0000000..759bcfe --- /dev/null +++ b/Documentation/devicetree/bindings/input/dlg,da7280.txt @@ -0,0 +1,91 @@ +Dialog Semiconductor DA7280 Haptics bindings + +Required properties: +- compatible: Should be "dlg,da7280". +- reg: Specifies the I2C slave address. + +- interrupt-parent : Specifies the phandle of the interrupt controller to + which the IRQs from DA7280 are delivered to. +- interrupts: IRQ line info for DA7280. + (See Documentation/devicetree/bindings/interrupt-controller/ + interrupts.txt for further information relating to interrupt properties) +- dlg,vib-mode: + "LRA-MODE" - Linear Resonance Actuator mode. + "ERM-BAR" - Bar type Eccentric Rotating Mass mode. + "ERM-COIN" - Coin type Eccentric Rotating Mass mode. +- dlg,play-mode: choose one in below five modes. + "DRO-MODE" - Direct register override mode. + "PWM-MODE" - PWM data source mode. + In this case, user is able to set duty to 0 ~ 0xffff(0% ~ 100%) + "RTWM-MODE" - Register triggered waveform memory mode. + In this case, when enable this mode the pattern assigned + to the PS_SEQ_ID will be played as much times as PS_SEQ_LOOP. + "ETWM-MODE" - Edge triggered waveform memory mode. + In this case, external GPI(N) control are required to enable/disable + and it needs to keep device enabled by sending magnitude (X > 0) + the pattern assigned to the GPI(N)_SEQUENCE_ID below. + For more details, please see the datasheet. +- dlg,nom-microvolt: Nominal actuator voltage rating. +- dlg,abs-max-microvolt: Absolute actuator maximum voltage rating. +- dlg,imax-microamp: Actuator max current rating. +- dlg,impd-micro-ohms: the impedance of the actuator in micro ohm, + as read from its datasheet. + +Optional properties: +- pwms : phandle to the physical PWM(Pulse Width Modulation) device. + PWM properties should be named "pwms". And number of cell is different + for each pwm device. + (See Documentation/devicetree/bindings/pwm/pwm.txt + for further information relating to pwm properties) +- dlg,ps-seq-id: the PS_SEQ_ID(pattern ID in waveform memory inside chip) + to play back when RTWM-MODE is enabled. +- dlg,ps-seq-loop: the PS_SEQ_LOOP, Number of times the pre-stored sequence + pointed to by PS_SEQ_ID or GPI(N)_SEQUENCE_ID is repeated. +- dlg,gpiN-seq-id: the GPI(N)_SEQUENCE_ID, pattern to play + when gpi0 is triggered, 'N' must be 0~2. +- dlg,gpiN-mode: the pattern mode which can select either + "Single-pattern" or "Multi-pattern", 'N' must be 0~2. +- dlg,gpiN-polarity: gpiN polarity which can be chosen among "Rising-edge", + "Falling-edge" and "Both-edge", 'N' must be 0~2. + Haptic will work by this edge option in case of ETWM-MODE. + +- dlg,resonant-freq-hz: use in case of LRA-MODE, default 205Hz. + the freq range: 50Hz ~ 300Hz. + It will be set to 205Hz if the value is out of range. +- dlg,bemf-sens-enable: Enable for internal loop computations. +- dlg,freq-track-enable: Enable for resonant frequency tracking. +- dlg,acc-enable: Enable for active acceleration. +- dlg,rapid-stop-enable: Enable for rapid stop. +- dlg,amp-pid-enable: Enable for the amplitude PID. +- dlg,mem-array: use in case that memory registers should be updated, + Please fill the whole buffers(100 bytes) to avoid any error in driver. + For example, + dlg,mem-array = < + 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A + ... + 0x71 0x72 0x73 0x74 0x75 0x76 0x77 0x78 0x79 0x7A + 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 + 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 + >; + +For further information, see device datasheet. + +====== + +Example: + + haptics: da7280-haptics@4A { + compatible = "dlg,da7280"; + reg = <0x4A>; + interrupt-parent = <&gpio6>; + interrupts = <11 IRQ_TYPE_LEVEL_LOW>; + dlg,vib-mode = "LRA-MODE"; + dlg,play-mode = "DRO-MODE"; + dlg,nom-microvolt = <2000000>; + dlg,abs-max-microvolt = <2000000>; + dlg,imax-microamp = <170000>; + dlg,resonant-freq-hz = <180>; + dlg,impd-micro-ohms = <10500000>; + dlg,freq-track-enable; + dlg,rapid-stop-enable; + }; -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH V1 2/3] Documentation: devicetree: input: new binding for da7280 @ 2018-08-16 2:02 ` Roy Im 0 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel from: Roy Im <roy.im.opensource@diasemi.com> Add device tree binding information for DA7280 haptic driver. Example bindings for DA7280 are added. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- .../devicetree/bindings/input/dlg,da7280.txt | 91 ++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/dlg,da7280.txt diff --git a/Documentation/devicetree/bindings/input/dlg,da7280.txt b/Documentation/devicetree/bindings/input/dlg,da7280.txt new file mode 100644 index 0000000..759bcfe --- /dev/null +++ b/Documentation/devicetree/bindings/input/dlg,da7280.txt @@ -0,0 +1,91 @@ +Dialog Semiconductor DA7280 Haptics bindings + +Required properties: +- compatible: Should be "dlg,da7280". +- reg: Specifies the I2C slave address. + +- interrupt-parent : Specifies the phandle of the interrupt controller to + which the IRQs from DA7280 are delivered to. +- interrupts: IRQ line info for DA7280. + (See Documentation/devicetree/bindings/interrupt-controller/ + interrupts.txt for further information relating to interrupt properties) +- dlg,vib-mode: + "LRA-MODE" - Linear Resonance Actuator mode. + "ERM-BAR" - Bar type Eccentric Rotating Mass mode. + "ERM-COIN" - Coin type Eccentric Rotating Mass mode. +- dlg,play-mode: choose one in below five modes. + "DRO-MODE" - Direct register override mode. + "PWM-MODE" - PWM data source mode. + In this case, user is able to set duty to 0 ~ 0xffff(0% ~ 100%) + "RTWM-MODE" - Register triggered waveform memory mode. + In this case, when enable this mode the pattern assigned + to the PS_SEQ_ID will be played as much times as PS_SEQ_LOOP. + "ETWM-MODE" - Edge triggered waveform memory mode. + In this case, external GPI(N) control are required to enable/disable + and it needs to keep device enabled by sending magnitude (X > 0) + the pattern assigned to the GPI(N)_SEQUENCE_ID below. + For more details, please see the datasheet. +- dlg,nom-microvolt: Nominal actuator voltage rating. +- dlg,abs-max-microvolt: Absolute actuator maximum voltage rating. +- dlg,imax-microamp: Actuator max current rating. +- dlg,impd-micro-ohms: the impedance of the actuator in micro ohm, + as read from its datasheet. + +Optional properties: +- pwms : phandle to the physical PWM(Pulse Width Modulation) device. + PWM properties should be named "pwms". And number of cell is different + for each pwm device. + (See Documentation/devicetree/bindings/pwm/pwm.txt + for further information relating to pwm properties) +- dlg,ps-seq-id: the PS_SEQ_ID(pattern ID in waveform memory inside chip) + to play back when RTWM-MODE is enabled. +- dlg,ps-seq-loop: the PS_SEQ_LOOP, Number of times the pre-stored sequence + pointed to by PS_SEQ_ID or GPI(N)_SEQUENCE_ID is repeated. +- dlg,gpiN-seq-id: the GPI(N)_SEQUENCE_ID, pattern to play + when gpi0 is triggered, 'N' must be 0~2. +- dlg,gpiN-mode: the pattern mode which can select either + "Single-pattern" or "Multi-pattern", 'N' must be 0~2. +- dlg,gpiN-polarity: gpiN polarity which can be chosen among "Rising-edge", + "Falling-edge" and "Both-edge", 'N' must be 0~2. + Haptic will work by this edge option in case of ETWM-MODE. + +- dlg,resonant-freq-hz: use in case of LRA-MODE, default 205Hz. + the freq range: 50Hz ~ 300Hz. + It will be set to 205Hz if the value is out of range. +- dlg,bemf-sens-enable: Enable for internal loop computations. +- dlg,freq-track-enable: Enable for resonant frequency tracking. +- dlg,acc-enable: Enable for active acceleration. +- dlg,rapid-stop-enable: Enable for rapid stop. +- dlg,amp-pid-enable: Enable for the amplitude PID. +- dlg,mem-array: use in case that memory registers should be updated, + Please fill the whole buffers(100 bytes) to avoid any error in driver. + For example, + dlg,mem-array = < + 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A + ... + 0x71 0x72 0x73 0x74 0x75 0x76 0x77 0x78 0x79 0x7A + 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 + 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 + >; + +For further information, see device datasheet. + +====== + +Example: + + haptics: da7280-haptics@4A { + compatible = "dlg,da7280"; + reg = <0x4A>; + interrupt-parent = <&gpio6>; + interrupts = <11 IRQ_TYPE_LEVEL_LOW>; + dlg,vib-mode = "LRA-MODE"; + dlg,play-mode = "DRO-MODE"; + dlg,nom-microvolt = <2000000>; + dlg,abs-max-microvolt = <2000000>; + dlg,imax-microamp = <170000>; + dlg,resonant-freq-hz = <180>; + dlg,impd-micro-ohms = <10500000>; + dlg,freq-track-enable; + dlg,rapid-stop-enable; + }; -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH V1 3/3] Input: new da7280 haptic driver 2018-08-16 2:02 ` Roy Im @ 2018-08-16 2:02 ` Roy Im -1 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel from: Roy Im <roy.im.opensource@diasemi.com> Adds support for the Dialog DA7280 LRA/ERM Haptic Driver with multiple mode and integrated waveform memory and wideband support. It communicates via an I2C bus to the device. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- drivers/input/misc/Kconfig | 12 + drivers/input/misc/Makefile | 1 + drivers/input/misc/da7280.c | 1452 +++++++++++++++++++++++++++++++++++++++++++ drivers/input/misc/da7280.h | 412 ++++++++++++ 4 files changed, 1877 insertions(+) create mode 100644 drivers/input/misc/da7280.c create mode 100644 drivers/input/misc/da7280.h diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index ca59a2b..6e0de69 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -851,4 +851,16 @@ config INPUT_SC27XX_VIBRA To compile this driver as a module, choose M here. The module will be called sc27xx_vibra. +config INPUT_DA7280_HAPTICS + tristate "Dialog Semiconductor DA7280 haptics support" + depends on (INPUT && I2C && SYSFS) || PWM + select INPUT_FF_MEMLESS + select REGMAP_I2C + help + Say Y to enable support for the haptics controller on + Dialog DA7280 chip. + + To compile this driver as a module, choose M here: the + module will be called da7280-haptic. + endif diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 9d0f9d1..d941348 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -25,6 +25,7 @@ obj-$(CONFIG_INPUT_CMA3000) += cma3000_d0x.o obj-$(CONFIG_INPUT_CMA3000_I2C) += cma3000_d0x_i2c.o obj-$(CONFIG_INPUT_COBALT_BTNS) += cobalt_btns.o obj-$(CONFIG_INPUT_CPCAP_PWRBUTTON) += cpcap-pwrbutton.o +obj-$(CONFIG_INPUT_DA7280_HAPTICS) += da7280.o obj-$(CONFIG_INPUT_DA9052_ONKEY) += da9052_onkey.o obj-$(CONFIG_INPUT_DA9055_ONKEY) += da9055_onkey.o obj-$(CONFIG_INPUT_DA9063_ONKEY) += da9063_onkey.o diff --git a/drivers/input/misc/da7280.c b/drivers/input/misc/da7280.c new file mode 100644 index 0000000..8827711 --- /dev/null +++ b/drivers/input/misc/da7280.c @@ -0,0 +1,1452 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * DA7280 Haptic device driver + * + * Copyright (c) 2018 Dialog Semiconductor. + * Author: Roy Im <Roy.Im.Opensource@diasemi.com> + */ + +#include <linux/err.h> +#include <linux/i2c.h> +#include <linux/input.h> +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/pwm.h> +#include <linux/regmap.h> +#include <linux/workqueue.h> +#include "da7280.h" + +/* uV unit for voltage rate */ +#define DA7280_VOLTAGE_RATE_MAX 6000000 +#define DA7280_VOLTAGE_RATE_STEP 23400 +#define DA7280_NOMMAX_DFT 0x6B +#define DA7280_ABSMAX_DFT 0x78 + +#define DA7280_IMPD_MAX 0xFFFFFFFF +#define DA7280_IMPD_DEFAULT 22000000 + +#define DA7280_IMAX_DEFAULT 0x0E +/* uA unit step and limit for IMAX*/ +#define DA7280_IMAX_STEP 7200 +#define DA7280_IMAX_LIMIT 252000 + +#define DA7280_RESONT_FREQH_DFT 0x39 +#define DA7280_RESONT_FREQL_DFT 0x32 +#define DA7280_MIN_RESONAT_FREQ_HZ 50 +#define DA7280_MAX_RESONAT_FREQ_HZ 300 +#define DA7280_MIN_PWM_FREQ_KHZ 10 +#define DA7280_MAX_PWM_FREQ_KHZ 250 + +#define DA7280_SEQ_ID_MAX 15 +#define DA7280_SEQ_LOOP_MAX 15 +#define DA7280_GPI1_SEQ_ID_DEFT 0x0 + +#define DA7280_SNP_MEM_SIZE 100 +#define DA7280_SNP_MEM_MAX DA7280_SNP_MEM_99 + +#define DA7280_IRQ_FLAGS (IRQF_TRIGGER_LOW | IRQF_ONESHOT) +#define IRQ_NUM 3 + +#define DA7280_SKIP_INIT 0x100 + +enum da7280_haptic_dev_t { + DA7280_LRA = 0, + DA7280_ERM_BAR = 1, + DA7280_ERM_COIN = 2, + DA7280_DEV_MAX, +}; + +enum da7280_op_mode { + DA7280_INACTIVE = 0, + DA7280_DRO_MODE = 1, + DA7280_PWM_MODE = 2, + DA7280_RTWM_MODE = 3, + DA7280_ETWM_MODE = 4, + DA7280_OPMODE_MAX, +}; + +struct da7280_gpi_ctl { + u8 seq_id; + u8 mode; + u8 polarity; +}; + +struct da7280_haptic { + struct regmap *regmap; + struct input_dev *input_dev; + struct device *dev; + struct i2c_client *client; + struct pwm_device *pwm_dev; + bool legacy; + int pwm_id; + struct work_struct work; + + bool suspend_state; + unsigned int magnitude; + + u8 dev_type; + u8 op_mode; + u16 nommax; + u16 absmax; + u32 imax; + u32 impd; + u32 resonant_freq_h; + u32 resonant_freq_l; + u8 bemf_sense_en; + u8 freq_track_en; + u8 acc_en; + u8 rapid_stop_en; + u8 amp_pid_en; + u8 ps_seq_id; + u8 ps_seq_loop; + struct da7280_gpi_ctl gpi_ctl[3]; + bool mem_update; + u8 snp_mem[DA7280_SNP_MEM_SIZE]; + const struct attribute_group **attr_group; +}; + +static bool da7280_volatile_register(struct device *dev, unsigned int reg) +{ + switch (reg) { + case DA7280_IRQ_EVENT1: + case DA7280_IRQ_EVENT_WARNING_DIAG: + case DA7280_IRQ_EVENT_SEQ_DIAG: + case DA7280_IRQ_STATUS1: + case DA7280_TOP_CTL1: + return 1; + default: + return 0; + } +} + +static const struct regmap_config da7280_haptic_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = DA7280_SNP_MEM_MAX, + .volatile_reg = da7280_volatile_register, +}; + +static int da7280_haptic_mem_update(struct da7280_haptic *haptics) +{ + int ret; + unsigned int val; + + /* It is recommended to update the patterns + * during haptic is not working in order to avoid conflict + */ + ret = regmap_read(haptics->regmap, DA7280_IRQ_STATUS1, &val); + if (ret) + return ret; + if (val & DA7280_STA_WARNING_MASK) { + dev_warn(haptics->dev, + "Warning! Please check HAPTIC status.\n"); + return -EBUSY; + } + + /* Patterns are not updated if the lock bit is enabled */ + val = 0; + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL2, &val); + if (ret) + return ret; + if (~val & DA7280_WAV_MEM_LOCK_MASK) { + dev_warn(haptics->dev, + "Please unlock the bit first\n"); + return -EACCES; + } + + /* Set to Inactive mode to make sure safety */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, + 0); + if (ret) + return ret; + + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val); + if (ret) + return ret; + + return regmap_bulk_write(haptics->regmap, val, + haptics->snp_mem, DA7280_SNP_MEM_MAX - val + 1); +} + +static int da7280_haptic_set_pwm(struct da7280_haptic *haptics) +{ + struct pwm_args pargs; + u64 period_mag_multi; + unsigned int pwm_duty; + int ret; + + pwm_get_args(haptics->pwm_dev, &pargs); + period_mag_multi = + (u64)(pargs.period * haptics->magnitude); + if (haptics->acc_en) + pwm_duty = + (unsigned int)(period_mag_multi >> 16); + else + pwm_duty = + (unsigned int)((period_mag_multi >> 16) + + pargs.period) / 2; + + ret = pwm_config(haptics->pwm_dev, + pwm_duty, pargs.period); + if (ret) { + dev_err(haptics->dev, + "failed to configure pwm : %d\n", ret); + return ret; + } + + ret = pwm_enable(haptics->pwm_dev); + if (ret) { + pwm_disable(haptics->pwm_dev); + dev_err(haptics->dev, + "failed to enable haptics pwm device : %d\n", ret); + } + + return ret; +} + +static void da7280_haptic_enable(struct da7280_haptic *haptics) +{ + int ret = 0; + + switch (haptics->op_mode) { + case DA7280_DRO_MODE: + /* the valid range check when acc_en is enabled */ + if (haptics->acc_en && haptics->magnitude > 0x7F) + haptics->magnitude = 0x7F; + else if (haptics->magnitude > 0xFF) + haptics->magnitude = 0xFF; + + /* Set driver level + * as a % of ACTUATOR_NOMMAX(nommax) + */ + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, + haptics->magnitude); + if (ret) { + dev_err(haptics->dev, + "i2c err for driving level set : %d\n", + ret); + return; + } + break; + case DA7280_PWM_MODE: + if (da7280_haptic_set_pwm(haptics)) + return; + break; + case DA7280_RTWM_MODE: + /* PS_SEQ_ID will be played + * as many times as the PS_SEQ_LOOP + */ + case DA7280_ETWM_MODE: + /* Now users are able to control the GPI(N) + * assigned to GPI_0, GPI1 and GPI2 accordingly + * please see the datasheet for details. + * GPI(N)_SEQUENCE_ID will be played + * as many times as the PS_SEQ_LOOP + */ + break; + default: + dev_err(haptics->dev, + "Invalid Mode(%d)\n", haptics->op_mode); + return; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, + haptics->op_mode); + if (ret) { + dev_err(haptics->dev, + "i2c err for op_mode setting : %d\n", ret); + return; + } + + if (haptics->op_mode == DA7280_PWM_MODE || + haptics->op_mode == DA7280_RTWM_MODE) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_SEQ_START_MASK, + DA7280_SEQ_START_MASK); + if (ret) + dev_err(haptics->dev, + "i2c err for sequence triggering : %d\n", ret); + } +} + +static void da7280_haptic_disable(struct da7280_haptic *haptics) +{ + int ret; + + /* Set to Inactive mode */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for op_mode off : %d\n", ret); + return; + } + + switch (haptics->op_mode) { + case DA7280_RTWM_MODE: + case DA7280_ETWM_MODE: + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_SEQ_START_MASK, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for RTWM or ETWM mode off : %d\n", + ret); + return; + } + break; + case DA7280_DRO_MODE: + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for DRO mode off : %d\n", + ret); + return; + } + break; + case DA7280_PWM_MODE: + pwm_disable(haptics->pwm_dev); + break; + default: + dev_err(haptics->dev, + "Invalid Mode(%d)\n", haptics->op_mode); + break; + } +} + +static void da7280_haptic_work(struct work_struct *work) +{ + struct da7280_haptic *haptics = + container_of(work, struct da7280_haptic, work); + + if (haptics->magnitude) + da7280_haptic_enable(haptics); + else + da7280_haptic_disable(haptics); +} + +static int da7280_haptic_play(struct input_dev *dev, void *data, + struct ff_effect *effect) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + + if (effect->u.rumble.strong_magnitude > 0) + haptics->magnitude = effect->u.rumble.strong_magnitude; + else if (effect->u.rumble.weak_magnitude > 0) + haptics->magnitude = effect->u.rumble.weak_magnitude; + else + haptics->magnitude = 0; + + schedule_work(&haptics->work); + + return 0; +} + +static int da7280_haptic_open(struct input_dev *dev) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + int ret; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + dev_err(haptics->dev, + "Failed to open haptic, i2c error : %d\n", ret); + + return ret; +} + +static void da7280_haptic_close(struct input_dev *dev) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + int ret; + + cancel_work_sync(&haptics->work); + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) + goto error_i2c; + + if (haptics->op_mode == DA7280_DRO_MODE) { + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, 0); + + if (ret) + goto error_i2c; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, 0); + if (ret) + goto error_i2c; + + return; + +error_i2c: + dev_err(haptics->dev, "DA7280-haptic i2c error : %d\n", ret); +} + +static u8 da7280_haptic_of_mode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "LRA-MODE")) + return DA7280_LRA; + else if (!strcmp(str, "ERM-BAR")) + return DA7280_ERM_BAR; + else if (!strcmp(str, "ERM-COIN")) + return DA7280_ERM_COIN; + + dev_warn(dev, "Invalid string - set to default\n"); + return DA7280_LRA; +} + +static u8 da7280_haptic_of_opmode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "DRO-MODE")) + return DA7280_DRO_MODE; + else if (!strcmp(str, "PWM-MODE")) + return DA7280_PWM_MODE; + else if (!strcmp(str, "RTWM-MODE")) + return DA7280_RTWM_MODE; + else if (!strcmp(str, "ETWM-MODE")) + return DA7280_ETWM_MODE; + + dev_warn(dev, "Invalid string - set to default\n"); + return DA7280_DRO_MODE; +} + +static u8 da7280_haptic_of_gpi_mode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "Single-pattern")) + return 0; + else if (!strcmp(str, "Multi-pattern")) + return 1; + + dev_warn(dev, "Invalid string - set to default\n"); + return 0; +} + +static u8 da7280_haptic_of_gpi_pol_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "Rising-edge")) + return 0; + else if (!strcmp(str, "Falling-edge")) + return 1; + else if (!strcmp(str, "Both-edge")) + return 2; + + dev_warn(dev, "Invalid string - set to default\n"); + return 0; +} + +static u8 da7280_haptic_of_volt_rating_set(u32 val) +{ + u32 voltage; + + voltage = val / DA7280_VOLTAGE_RATE_STEP + 1; + + if (voltage > 0xFF) + return 0xFF; + return (u8)voltage; +} + +static void da7280_of_to_pdata(struct device *dev, + struct da7280_haptic *haptics) +{ + struct device_node *np = dev->of_node; + char dt_gpi_str1[] = "dlg,gpi0-seq-id"; + char dt_gpi_str2[] = "dlg,gpi0-mode"; + char dt_gpi_str3[] = "dlg,gpi0-polarity"; + unsigned int mem[DA7280_SNP_MEM_SIZE]; + const char *of_str; + u32 of_val32; + int i; + + if (!of_property_read_string(np, "dlg,vib-mode", &of_str)) + haptics->dev_type = + da7280_haptic_of_mode_str(dev, of_str); + else /* if no property, then use the mode inside chip */ + haptics->dev_type = DA7280_DEV_MAX; + + if (!of_property_read_string(np, "dlg,play-mode", &of_str)) + haptics->op_mode = + da7280_haptic_of_opmode_str(dev, of_str); + else /* Set to DRO mode as a default mode */ + haptics->op_mode = DA7280_DRO_MODE; + + if (of_property_read_u32(np, "dlg,nom-microvolt", &of_val32) >= 0) + if (of_val32 < DA7280_VOLTAGE_RATE_MAX) + haptics->nommax = + da7280_haptic_of_volt_rating_set(of_val32); + else + haptics->nommax = DA7280_SKIP_INIT; + else /* if no property, then use the value inside chip */ + haptics->nommax = DA7280_SKIP_INIT; + + if (of_property_read_u32(np, "dlg,abs-max-microvolt", &of_val32) >= 0) + if (of_val32 < DA7280_VOLTAGE_RATE_MAX) + haptics->absmax = + da7280_haptic_of_volt_rating_set(of_val32); + else + haptics->absmax = DA7280_SKIP_INIT; + else + haptics->absmax = DA7280_SKIP_INIT; + + if (of_property_read_u32(np, "dlg,imax-microamp", &of_val32) >= 0) + if (of_val32 < DA7280_IMAX_LIMIT) + haptics->imax = (of_val32 - 28600) + / DA7280_IMAX_STEP + 1; + else + haptics->imax = DA7280_IMAX_DEFAULT; + else + haptics->imax = DA7280_IMAX_DEFAULT; + + if (of_property_read_u32(np, "dlg,impd-micro-ohms", &of_val32) >= 0) + if (of_val32 <= DA7280_IMPD_MAX) + haptics->impd = of_val32; + else + haptics->impd = DA7280_IMPD_DEFAULT; + else + haptics->impd = DA7280_IMPD_DEFAULT; + + if (of_property_read_u32(np, "dlg,resonant-freq-hz", &of_val32) >= 0) { + if (of_val32 < DA7280_MAX_RESONAT_FREQ_HZ && + of_val32 > DA7280_MIN_RESONAT_FREQ_HZ) { + haptics->resonant_freq_h = + ((1000000000 / (of_val32 * 1333)) >> 7) & 0xFF; + haptics->resonant_freq_l = + (1000000000 / (of_val32 * 1333)) & 0x7F; + } else { + haptics->resonant_freq_h = + DA7280_RESONT_FREQH_DFT; + haptics->resonant_freq_l = + DA7280_RESONT_FREQL_DFT; + } + } else { + haptics->resonant_freq_h = DA7280_SKIP_INIT; + haptics->resonant_freq_l = DA7280_SKIP_INIT; + } + + if (of_property_read_u32(np, "dlg,ps-seq-id", &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_ID_MAX) + haptics->ps_seq_id = of_val32; + else + haptics->ps_seq_id = 0; + else /* if no property, set to zero as a default do nothing */ + haptics->ps_seq_id = 0; + + if (of_property_read_u32(np, "dlg,ps-seq-loop", &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_LOOP_MAX) + haptics->ps_seq_loop = of_val32; + else + haptics->ps_seq_loop = 0; + else /* if no property, then do nothing */ + haptics->ps_seq_loop = 0; + + /* GPI0~2 Control */ + for (i = 0; i < 3; i++) { + dt_gpi_str1[7] = '0' + i; + if (of_property_read_u32(np, dt_gpi_str1, &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_ID_MAX) + haptics->gpi_ctl[i].seq_id = of_val32; + else + haptics->gpi_ctl[i].seq_id = + DA7280_GPI1_SEQ_ID_DEFT + i; + else /* if no property, then do nothing */ + haptics->gpi_ctl[i].seq_id = + DA7280_GPI1_SEQ_ID_DEFT + i; + + dt_gpi_str2[7] = '0' + i; + if (!of_property_read_string(np, dt_gpi_str2, &of_str)) + haptics->gpi_ctl[i].mode = + da7280_haptic_of_gpi_mode_str(dev, of_str); + else + haptics->gpi_ctl[i].mode = 0; + + dt_gpi_str3[7] = '0' + i; + if (!of_property_read_string(np, dt_gpi_str3, &of_str)) + haptics->gpi_ctl[i].polarity = + da7280_haptic_of_gpi_pol_str(dev, of_str); + else + haptics->gpi_ctl[i].polarity = 0; + } + + haptics->bemf_sense_en = + of_property_read_bool(np, "dlg,bemf-sens-enable"); + haptics->freq_track_en = + of_property_read_bool(np, "dlg,freq-track-enable"); + haptics->acc_en = + of_property_read_bool(np, "dlg,acc-enable"); + haptics->rapid_stop_en = + of_property_read_bool(np, "dlg,rapid-stop-enable"); + haptics->amp_pid_en = + of_property_read_bool(np, "dlg,amp-pid-enable"); + + if (of_property_read_u32_array(np, "dlg,mem-array", + &mem[0], DA7280_SNP_MEM_SIZE) >= 0) { + haptics->mem_update = 1; + for (i = 0; i < DA7280_SNP_MEM_SIZE; i++) { + if (mem[i] > 0xff) + haptics->snp_mem[i] = 0x0; + else + haptics->snp_mem[i] = (u8)mem[i]; + } + } else { + haptics->mem_update = 0; + } +} + +static irqreturn_t da7280_irq_handler(int irq, void *data) +{ + struct da7280_haptic *haptics = data; + u8 events[IRQ_NUM]; + int ret; + + /* Check what events have happened */ + ret = regmap_bulk_read(haptics->regmap, + DA7280_IRQ_EVENT1, + events, IRQ_NUM); + if (ret) + goto error_i2c; + + /* Empty check due to shared interrupt */ + if ((events[0] | events[1] | events[2]) == 0x00) + return IRQ_HANDLED; + + if (events[0] & DA7280_E_SEQ_FAULT_MASK) { + /* Stop first if Haptic is working + * Otherwise, the fault may happen continually + * even though the bit is cleared. + */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) + goto error_i2c; + } + + /* Clear events */ + ret = regmap_write(haptics->regmap, + DA7280_IRQ_EVENT1, events[0]); + if (ret) + goto error_i2c; + + return IRQ_HANDLED; + +error_i2c: + dev_err(haptics->dev, "da7280 i2c error : %d\n", ret); + return IRQ_NONE; +} + +static int da7280_init(struct da7280_haptic *haptics) +{ + int ret, i; + unsigned int val = 0; + u32 v2i_factor; + u8 mask = 0; + + /* If device type is DA7280_DEV_MAX, + * then skip to initialze and use default value inside chip. + */ + if (haptics->dev_type == DA7280_DEV_MAX) { + ret = regmap_read(haptics->regmap, DA7280_TOP_CFG1, &val); + if (ret) + goto error_i2c; + if (val & DA7280_ACTUATOR_TYPE_MASK) + haptics->dev_type = DA7280_ERM_COIN; + else + haptics->dev_type = DA7280_LRA; + } + + /* Apply user settings */ + if (haptics->dev_type == DA7280_LRA) { + if (haptics->resonant_freq_l != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, + DA7280_FRQ_LRA_PER_H, + haptics->resonant_freq_h); + if (ret) + goto error_i2c; + ret = regmap_write(haptics->regmap, + DA7280_FRQ_LRA_PER_L, + haptics->resonant_freq_l); + if (ret) + goto error_i2c; + } + } else if (haptics->dev_type == DA7280_ERM_COIN) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_INT_CFG1, + DA7280_BEMF_FAULT_LIM_MASK, 0); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CFG4, + DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | + DA7280_V2I_FACTOR_FREEZE_MASK, + DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | + DA7280_V2I_FACTOR_FREEZE_MASK); + if (ret) + goto error_i2c; + + haptics->acc_en = 0; + haptics->rapid_stop_en = 0; + haptics->amp_pid_en = 0; + } + + /* Should be set to 0 only + * in custom waveform and wideband operation + */ + if (haptics->op_mode >= DA7280_RTWM_MODE) + haptics->bemf_sense_en = 0; + + mask = DA7280_ACTUATOR_TYPE_MASK | + DA7280_BEMF_SENSE_EN_MASK | + DA7280_FREQ_TRACK_EN_MASK | + DA7280_ACCELERATION_EN_MASK | + DA7280_RAPID_STOP_EN_MASK | + DA7280_AMP_PID_EN_MASK; + + val = (haptics->dev_type ? 1 : 0) + << DA7280_ACTUATOR_TYPE_SHIFT | + (haptics->bemf_sense_en ? 1 : 0) + << DA7280_BEMF_SENSE_EN_SHIFT | + (haptics->freq_track_en ? 1 : 0) + << DA7280_FREQ_TRACK_EN_SHIFT | + (haptics->acc_en ? 1 : 0) + << DA7280_ACCELERATION_EN_SHIFT | + (haptics->rapid_stop_en ? 1 : 0) + << DA7280_RAPID_STOP_EN_SHIFT | + (haptics->amp_pid_en ? 1 : 0) + << DA7280_AMP_PID_EN_SHIFT; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CFG1, mask, val); + if (ret) + goto error_i2c; + + if (haptics->nommax != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, + DA7280_ACTUATOR1, + haptics->nommax); + if (ret) + goto error_i2c; + } + + if (haptics->absmax != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, DA7280_ACTUATOR2, + haptics->absmax); + if (ret) + goto error_i2c; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_ACTUATOR3, + DA7280_IMAX_MASK, + haptics->imax); + if (ret) + goto error_i2c; + + v2i_factor = + haptics->impd * (haptics->imax + 4) / 1610400; + ret = regmap_write(haptics->regmap, + DA7280_CALIB_V2I_L, + v2i_factor); + if (ret) + goto error_i2c; + ret = regmap_write(haptics->regmap, DA7280_CALIB_V2I_H, + v2i_factor >> 8); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + goto error_i2c; + + if (haptics->mem_update) { + ret = da7280_haptic_mem_update(haptics); + if (ret) + goto error_i2c; + } + + /* Set PS_SEQ_ID and PS_SEQ_LOOP */ + val = haptics->ps_seq_id << DA7280_PS_SEQ_ID_SHIFT | + haptics->ps_seq_loop << DA7280_PS_SEQ_LOOP_SHIFT; + ret = regmap_write(haptics->regmap, + DA7280_SEQ_CTL2, val); + if (ret) + goto error_i2c; + + /* GPI(N) CTL */ + for (i = 0; i < 3; i++) { + val = haptics->gpi_ctl[i].seq_id + << DA7280_GPI0_SEQUENCE_ID_SHIFT | + haptics->gpi_ctl[i].mode + << DA7280_GPI0_MODE_SHIFT | + haptics->gpi_ctl[i].polarity + << DA7280_GPI0_POLARITY_SHIFT; + ret = regmap_write(haptics->regmap, + DA7280_GPI_0_CTL + i, val); + if (ret) + goto error_i2c; + } + + /* Clear Interrupts */ + ret = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, 0xff); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_IRQ_MASK1, + DA7280_SEQ_FAULT_M_MASK + | DA7280_SEQ_DONE_M_MASK, 0); + if (ret) + goto error_i2c; + + haptics->suspend_state = 0; + return 0; + +error_i2c: + dev_err(haptics->dev, "haptic init - I2C error : %d\n", ret); + return ret; +} + +/* Valid format for ps_seq_id + * echo X > ps_seq_id + * ex) echo 2 > /sys/class/..../ps_seq_id + * 0 <= X <= 15. + */ +static ssize_t ps_seq_id_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + long val = 0xff; + int ret; + + if (kstrtol(&buf[0], 0, &val) < 0) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_SEQ_CTL2, + DA7280_PS_SEQ_ID_MASK, + (val & 0xf) >> DA7280_PS_SEQ_ID_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->ps_seq_id = val & 0xf; + + return count; + +err: + dev_err(dev, "Invalid input\n"); + return count; +} + +static ssize_t ps_seq_id_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val; + + ret = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + val = (val & DA7280_PS_SEQ_ID_MASK) + >> DA7280_PS_SEQ_ID_SHIFT; + + return sprintf(buf, "ps_seq_id is %d\n", val); +} + +/* Valid format for ps_seq_loop + * echo X > ps_seq_loop + * ex) echo 2 > /sys/class/..../ps_seq_loop + * 0 <= X <= 15. + */ +static ssize_t ps_seq_loop_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + long val = 0xff; + int ret; + + if (kstrtol(&buf[0], 0, &val) < 0) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_SEQ_CTL2, + DA7280_PS_SEQ_LOOP_MASK, + (val & 0xF) << DA7280_PS_SEQ_LOOP_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->ps_seq_loop = (val & 0xF); + + return count; +err: + dev_err(dev, "Invalid input value!\n"); + return count; +} + +static ssize_t ps_seq_loop_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val; + + ret = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + val = (val & DA7280_PS_SEQ_LOOP_MASK) + >> DA7280_PS_SEQ_LOOP_SHIFT; + + return sprintf(buf, "ps_seq_loop is %d\n", val); +} + +/* Valid format for GPIx_SEQUENCE_ID + * echo X Y > gpi_seq_id + * ex) echo 2 15 > /sys/class/..../gpi_seq_id + * 0 <= X < 3, 0<= Y <= 15. + */ +static ssize_t gpi_seq_id_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_num = 0xff; + long seq_id = 0xff; + int ret; + + if (count < 4) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + else + goto err; + + if (buf[1] != ' ') + goto err; + + if (kstrtol(&buf[2], 0, &seq_id) < 0) + goto err; + + if (gpi_num > 2 || seq_id > 0xf) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_SEQUENCE_ID_MASK, + seq_id << DA7280_GPI0_SEQUENCE_ID_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].seq_id = seq_id; + + return count; + +err: + dev_err(dev, "Invalid format or values!\n"); + return count; +} + +static ssize_t gpi_seq_id_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + haptics->gpi_ctl[i].seq_id = + (val & DA7280_GPI0_SEQUENCE_ID_MASK) + >> DA7280_GPI0_SEQUENCE_ID_SHIFT; + val = 0; + } + + return sprintf(buf, + "Seq ID\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].seq_id, + haptics->gpi_ctl[1].seq_id, + haptics->gpi_ctl[2].seq_id); +} + +/* Valid format for GPIx_MODE + * echo X Y > gpi_mode + * ex) echo 2 1 > /sys/class/..../gpi_mode + * 0 <= X < 3, 0<= Y <= 1. + */ +static ssize_t gpi_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_num = 0xff, gpi_mode = 0xff; + int ret; + + if (count < 3) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + if (buf[2] >= '0') + gpi_mode = buf[2] - '0'; + + if (gpi_num > 2 || gpi_mode > 1) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_MODE_MASK, + gpi_mode << DA7280_GPI0_MODE_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].mode = gpi_mode; + + return count; + +err: + dev_err(dev, "Invalid format!\n"); + return count; +} + +static ssize_t gpi_mode_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + haptics->gpi_ctl[i].mode = + (val & DA7280_GPI0_MODE_MASK) + >> DA7280_GPI0_MODE_SHIFT; + val = 0; + } + + return sprintf(buf, "Mode\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].mode, + haptics->gpi_ctl[1].mode, + haptics->gpi_ctl[2].mode); +} + +/* Valid format for GPIx_MODE + * echo X Y > gpi_pol + * ex) echo 2 1 > /sys/class/..../gpi_pol + * 0 <= X < 3, 0<= Y <= 2. + */ +static ssize_t gpi_pol_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_pol = 0xff, gpi_num = 0xff; + int ret; + + if (count < 3) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + if (buf[2] >= '0') + gpi_pol = buf[2] - '0'; + + if (gpi_num > 2 || gpi_pol > 2) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_POLARITY_MASK, + gpi_pol << DA7280_GPI0_POLARITY_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].polarity = gpi_pol; + + return count; + +err: + dev_err(dev, "Invalid format or input values!\n"); + return count; +} + +static ssize_t gpi_pol_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) + return ret; + haptics->gpi_ctl[i].polarity = + (val & DA7280_GPI0_POLARITY_MASK) + >> DA7280_GPI0_POLARITY_SHIFT; + val = 0; + } + + return sprintf(buf, "Polarity\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].polarity, + haptics->gpi_ctl[1].polarity, + haptics->gpi_ctl[2].polarity); +} + +#define MAX_PTN_REGS DA7280_SNP_MEM_SIZE +#define MAX_USER_INPUT_LEN (5 * DA7280_SNP_MEM_SIZE) +struct parse_data_t { + int len; + u8 val[MAX_PTN_REGS]; +}; + +static int da7280_parse_args(struct device *dev, + char *cmd, struct parse_data_t *ptn) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + char *tok; /* used to separate tokens */ + const char ct[] = " \t"; /* space or tab delimits the tokens */ + int tok_count = 0; /* total number of tokens parsed */ + int i = 0, val; + + ptn->len = 0; + + /* parse the input string */ + while ((tok = strsep(&cmd, ct)) != NULL) { + /* this is a value to be written to the register */ + if (kstrtouint(tok, 0, &val) < 0) { + dev_err(haptics->dev, + "failed to read from %s\n", tok); + break; + } + + if (i < MAX_PTN_REGS) { + ptn->val[i] = val; + i++; + } + tok_count++; + } + + /* decide whether it is a read or write operation based on the + * value of tok_count and count_flag. + * tok_count = 0: no inputs, invalid case. + * tok_count = 1: write one value. + * tok_count > 1: write multiple values/patterns. + */ + switch (tok_count) { + case 0: + return -EINVAL; + case 1: + ptn->len = 1; + break; + default: + ptn->len = i; + } + return 0; +} + +static ssize_t +patterns_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + struct parse_data_t mem; + char cmd[MAX_USER_INPUT_LEN]; + unsigned int val; + int ret; + + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val); + if (ret) + return ret; + + if (count > MAX_USER_INPUT_LEN) + memcpy(cmd, buf, MAX_USER_INPUT_LEN); + else + memcpy(cmd, buf, count); + /* chop of '\n' introduced by echo at the end of the input */ + if (cmd[count - 1] == '\n') + cmd[count - 1] = '\0'; + + if (da7280_parse_args(dev, cmd, &mem) < 0) + return -EINVAL; + + memcpy(haptics->snp_mem, mem.val, mem.len); + + ret = da7280_haptic_mem_update(haptics); + if (ret) + return ret; + + return count; +} + +static DEVICE_ATTR_RW(ps_seq_id); +static DEVICE_ATTR_RW(ps_seq_loop); +static DEVICE_ATTR_RW(gpi_seq_id); +static DEVICE_ATTR_RW(gpi_mode); +static DEVICE_ATTR_RW(gpi_pol); +static DEVICE_ATTR_WO(patterns); +static struct attribute *da7280_sysfs_attr[] = { + &dev_attr_ps_seq_id.attr, + &dev_attr_ps_seq_loop.attr, + &dev_attr_gpi_seq_id.attr, + &dev_attr_gpi_mode.attr, + &dev_attr_gpi_pol.attr, + &dev_attr_patterns.attr, + NULL, +}; + +static const struct attribute_group da7280_attr_group = { + .attrs = da7280_sysfs_attr, +}; + +static const struct attribute_group *da7280_attr_groups[] = { + &da7280_attr_group, + NULL, +}; + +static int da7280_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct device *dev = &client->dev; + struct da7280_haptic *haptics; + unsigned int period2freq; + int ret; + + haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL); + if (!haptics) + return -ENOMEM; + haptics->dev = dev; + + if (!client->irq) { + dev_err(dev, "No IRQ configured\n"); + return -EINVAL; + } + + /* Handle DT data if provided */ + if (client->dev.of_node) + da7280_of_to_pdata(&client->dev, haptics); + + if (haptics->op_mode == DA7280_PWM_MODE) { + /* Get pwm and regulatot for haptics device */ + haptics->pwm_dev = devm_pwm_get(&client->dev, NULL); + if (IS_ERR(haptics->pwm_dev)) { + dev_err(dev, "failed to get PWM device\n"); + return PTR_ERR(haptics->pwm_dev); + } + + /* + * FIXME: pwm_apply_args() should be removed when switching to + * the atomic PWM API. + */ + pwm_apply_args(haptics->pwm_dev); + + /* Check PWM Period, it must be in 10k ~ 250kHz */ + period2freq = 1000000 / pwm_get_period(haptics->pwm_dev); + if (period2freq < DA7280_MIN_PWM_FREQ_KHZ || + period2freq > DA7280_MAX_PWM_FREQ_KHZ) { + dev_err(dev, "Not supported PWM frequency(%d)\n", + period2freq); + return -EINVAL; + } + } + + INIT_WORK(&haptics->work, da7280_haptic_work); + haptics->client = client; + i2c_set_clientdata(client, haptics); + + haptics->regmap = + devm_regmap_init_i2c(client, &da7280_haptic_regmap_config); + if (IS_ERR(haptics->regmap)) { + ret = PTR_ERR(haptics->regmap); + dev_err(dev, "Failed to allocate register map : %d\n", + ret); + return ret; + } + + ret = devm_request_threaded_irq(dev, client->irq, NULL, + da7280_irq_handler, + DA7280_IRQ_FLAGS, + "da7280-haptics", haptics); + if (ret != 0) { + dev_err(dev, + "Failed to request IRQ : %d\n", client->irq); + return ret; + } + + ret = da7280_init(haptics); + if (ret) { + dev_err(dev, "failed to initialize device\n"); + return ret; + } + + /* Initialize input device for haptic device */ + haptics->input_dev = devm_input_allocate_device(dev); + if (!haptics->input_dev) { + dev_err(dev, "failed to allocate input device\n"); + return -ENOMEM; + } + + haptics->input_dev->name = "da7280-haptic"; + haptics->input_dev->dev.parent = client->dev.parent; + haptics->input_dev->open = da7280_haptic_open; + haptics->input_dev->close = da7280_haptic_close; + input_set_drvdata(haptics->input_dev, haptics); + input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE); + + ret = input_ff_create_memless(haptics->input_dev, NULL, + da7280_haptic_play); + if (ret) { + dev_err(dev, "failed to create force-feedback\n"); + return ret; + } + +#ifdef CONFIG_SYSFS + haptics->input_dev->dev.groups = da7280_attr_groups; +#endif + + ret = input_register_device(haptics->input_dev); + if (ret) + dev_err(dev, "failed to register input device\n"); + + return ret; +} + +static int __maybe_unused da7280_suspend(struct device *dev) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + + mutex_lock(&haptics->input_dev->mutex); + if (haptics->suspend_state == 0) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, 0); + if (ret) + dev_err(haptics->dev, + "I2C error : %d\n", ret); + else + haptics->suspend_state = 1; + } + mutex_unlock(&haptics->input_dev->mutex); + return ret; +} + +static int __maybe_unused da7280_resume(struct device *dev) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + + mutex_lock(&haptics->input_dev->mutex); + if (haptics->suspend_state) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + dev_err(haptics->dev, + "i2c error : %d\n", ret); + else + haptics->suspend_state = 0; + } + mutex_unlock(&haptics->input_dev->mutex); + return ret; +} + +static const struct of_device_id da7280_of_match[] = { + { .compatible = "dlg,da7280", }, + { } +}; +MODULE_DEVICE_TABLE(of, da7280_of_match); + +static const struct i2c_device_id da7280_i2c_id[] = { + { "da7280", }, + { } +}; +MODULE_DEVICE_TABLE(i2c, da7280_i2c_id); + +static SIMPLE_DEV_PM_OPS(da7280_pm_ops, + da7280_suspend, da7280_resume); + +static struct i2c_driver da7280_driver = { + .driver = { + .name = "da7280", + .of_match_table = of_match_ptr(da7280_of_match), + .pm = &da7280_pm_ops, + }, + .probe = da7280_probe, + .id_table = da7280_i2c_id, +}; +module_i2c_driver(da7280_driver); + +MODULE_DESCRIPTION("DA7280 haptics driver"); +MODULE_AUTHOR("Roy Im <Roy.Im.Opensource@diasemi.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/input/misc/da7280.h b/drivers/input/misc/da7280.h new file mode 100644 index 0000000..d9310b6 --- /dev/null +++ b/drivers/input/misc/da7280.h @@ -0,0 +1,412 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * DA7280 Haptic device driver registers + * + * Copyright (c) 2017 Dialog Semiconductor. + * Author: Roy Im <Roy.Im.Opensource@diasemi.com> + */ + +#ifndef _DA7280_REG_DEFS_H +#define _DA7280_REG_DEFS_H + +#include <linux/bitops.h> + +/* Registers */ + +#define DA7280_CHIP_REV 0x00 +#define DA7280_IRQ_EVENT1 0x03 +#define DA7280_IRQ_EVENT_WARNING_DIAG 0x04 +#define DA7280_IRQ_EVENT_SEQ_DIAG 0x05 +#define DA7280_IRQ_STATUS1 0x06 +#define DA7280_IRQ_MASK1 0x07 +#define DA7280_CIF_I2C1 0x08 +#define DA7280_FRQ_LRA_PER_H 0x0A +#define DA7280_FRQ_LRA_PER_L 0x0B +#define DA7280_ACTUATOR1 0x0C +#define DA7280_ACTUATOR2 0x0D +#define DA7280_ACTUATOR3 0x0E +#define DA7280_CALIB_V2I_H 0x0F +#define DA7280_CALIB_V2I_L 0x10 +#define DA7280_CALIB_IMP_H 0x11 +#define DA7280_CALIB_IMP_L 0x12 +#define DA7280_TOP_CFG1 0x13 +#define DA7280_TOP_CFG2 0x14 +#define DA7280_TOP_CFG3 0x15 +#define DA7280_TOP_CFG4 0x16 +#define DA7280_TOP_INT_CFG1 0x17 +#define DA7280_TOP_INT_CFG6_H 0x1C +#define DA7280_TOP_INT_CFG6_L 0x1D +#define DA7280_TOP_INT_CFG7_H 0x1E +#define DA7280_TOP_INT_CFG7_L 0x1F +#define DA7280_TOP_INT_CFG8 0x20 +#define DA7280_TOP_CTL1 0x22 +#define DA7280_TOP_CTL2 0x23 +#define DA7280_SEQ_CTL1 0x24 +#define DA7280_SWG_C1 0x25 +#define DA7280_SWG_C2 0x26 +#define DA7280_SWG_C3 0x27 +#define DA7280_SEQ_CTL2 0x28 +#define DA7280_GPI_0_CTL 0x29 +#define DA7280_GPI_1_CTL 0x2A +#define DA7280_GPI_2_CTL 0x2B +#define DA7280_MEM_CTL1 0x2C +#define DA7280_MEM_CTL2 0x2D +#define DA7280_ADC_DATA_H1 0x2E +#define DA7280_ADC_DATA_L1 0x2F +#define DA7280_POLARITY 0x43 +#define DA7280_LRA_AVR_H 0x44 +#define DA7280_LRA_AVR_L 0x45 +#define DA7280_FRQ_LRA_PER_ACT_H 0x46 +#define DA7280_FRQ_LRA_PER_ACT_L 0x47 +#define DA7280_FRQ_PHASE_H 0x48 +#define DA7280_FRQ_PHASE_L 0x49 +#define DA7280_FRQ_CTL 0x4C +#define DA7280_TRIM3 0x5F +#define DA7280_TRIM4 0x60 +#define DA7280_TRIM6 0x62 +#define DA7280_TOP_CFG5 0x6E +#define DA7280_IRQ_EVENT_ACTUATOR_FAULT 0x81 +#define DA7280_IRQ_STATUS2 0x82 +#define DA7280_IRQ_MASK2 0x83 +#define DA7280_SNP_MEM_0 0x84 +#define DA7280_SNP_MEM_99 0xE7 + +/* DA7280_CHIP_REV (Address 0x00) */ +#define DA7280_CHIP_REV_MAJOR_SHIFT 0 +#define DA7280_CHIP_REV_MAJOR_MASK (15 << 0) +#define DA7280_CHIP_REV_MINOR_SHIFT 4 +#define DA7280_CHIP_REV_MINOR_MASK (15 << 4) + +/* DA7280_IRQ_EVENT1 (Address 0x03) */ +#define DA7280_E_SEQ_CONTINUE_SHIFT 0 +#define DA7280_E_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_E_UVLO_SHIFT 1 +#define DA7280_E_UVLO_MASK BIT(1) +#define DA7280_E_SEQ_DONE_SHIFT 2 +#define DA7280_E_SEQ_DONE_MASK BIT(2) +#define DA7280_E_OVERTEMP_CRIT_SHIFT 3 +#define DA7280_E_OVERTEMP_CRIT_MASK BIT(3) +#define DA7280_E_SEQ_FAULT_SHIFT 4 +#define DA7280_E_SEQ_FAULT_MASK BIT(4) +#define DA7280_E_WARNING_SHIFT 5 +#define DA7280_E_WARNING_MASK BIT(5) +#define DA7280_E_ACTUATOR_FAULT_SHIFT 6 +#define DA7280_E_ACTUATOR_FAULT_MASK BIT(6) +#define DA7280_E_OC_FAULT_SHIFT 7 +#define DA7280_E_OC_FAULT_MASK BIT(7) + +/* DA7280_IRQ_EVENT_WARNING_DIAG (Address 0x04) */ +#define DA7280_E_OVERTEMP_WARN_SHIFT 3 +#define DA7280_E_OVERTEMP_WARN_MASK BIT(3) +#define DA7280_E_MEM_TYPE_SHIFT 4 +#define DA7280_E_MEM_TYPE_MASK BIT(4) +#define DA7280_E_LIM_DRIVE_ACC_SHIFT 6 +#define DA7280_E_LIM_DRIVE_ACC_MASK BIT(6) +#define DA7280_E_LIM_DRIVE_SHIFT 7 +#define DA7280_E_LIM_DRIVE_MASK BIT(7) + +/* DA7280_IRQ_EVENT_PAT_DIAG (Address 0x05) */ +#define DA7280_E_PWM_FAULT_SHIFT 5 +#define DA7280_E_PWM_FAULT_MASK BIT(5) +#define DA7280_E_MEM_FAULT_SHIFT 6 +#define DA7280_E_MEM_FAULT_MASK BIT(6) +#define DA7280_E_SEQ_ID_FAULT_SHIFT 7 +#define DA7280_E_SEQ_ID_FAULT_MASK BIT(7) + +/* DA7280_IRQ_STATUS1 (Address 0x06) */ +#define DA7280_STA_SEQ_CONTINUE_SHIFT 0 +#define DA7280_STA_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_STA_UVLO_VBAT_OK_SHIFT 1 +#define DA7280_STA_UVLO_VBAT_OK_MASK BIT(1) +#define DA7280_STA_SEQ_DONE_SHIFT 2 +#define DA7280_STA_SEQ_DONE_MASK BIT(2) +#define DA7280_STA_OVERTEMP_CRIT_SHIFT 3 +#define DA7280_STA_OVERTEMP_CRIT_MASK BIT(3) +#define DA7280_STA_SEQ_FAULT_SHIFT 4 +#define DA7280_STA_SEQ_FAULT_MASK BIT(4) +#define DA7280_STA_WARNING_SHIFT 5 +#define DA7280_STA_WARNING_MASK BIT(5) +#define DA7280_STA_ACTUATOR_SHIFT 6 +#define DA7280_STA_ACTUATOR_MASK BIT(6) +#define DA7280_STA_OC_SHIFT 7 +#define DA7280_STA_OC_MASK BIT(7) + +/* DA7280_IRQ_MASK1 (Address 0x07) */ +#define DA7280_SEQ_CONTINUE_M_SHIFT 0 +#define DA7280_SEQ_CONTINUE_M_MASK BIT(0) +#define DA7280_E_UVLO_M_SHIFT 1 +#define DA7280_E_UVLO_M_MASK BIT(1) +#define DA7280_SEQ_DONE_M_SHIFT 2 +#define DA7280_SEQ_DONE_M_MASK BIT(2) +#define DA7280_OVERTEMP_CRIT_M_SHIFT 3 +#define DA7280_OVERTEMP_CRIT_M_MASK BIT(3) +#define DA7280_SEQ_FAULT_M_SHIFT 4 +#define DA7280_SEQ_FAULT_M_MASK BIT(4) +#define DA7280_WARNING_M_SHIFT 5 +#define DA7280_WARNING_M_MASK BIT(5) +#define DA7280_ACTUATOR_M_SHIFT 6 +#define DA7280_ACTUATOR_M_MASK BIT(6) +#define DA7280_OC_M_SHIFT 7 +#define DA7280_OC_M_MASK BIT(7) + +/* DA7280_CIF_I2C1 (Address 0x08) */ +#define DA7280_I2C_TO_ENABLE_SHIFT 6 +#define DA7280_I2C_TO_ENABLE_MASK BIT(6) +#define DA7280_I2C_WR_MODE_SHIFT 7 +#define DA7280_I2C_WR_MODE_MASK BIT(7) + +/* DA7280_FRQ_LRA_PER_H (Address 0x0a) */ +#define DA7280_LRA_PER_H_SHIFT 0 +#define DA7280_LRA_PER_H_MASK (255 << 0) + +/* DA7280_FRQ_LRA_PER_L (Address 0x0b) */ +#define DA7280_LRA_PER_L_SHIFT 0 +#define DA7280_LRA_PER_L_MASK (127 << 0) + +/* DA7280_ACTUATOR1 (Address 0x0c) */ +#define DA7280_ACTUATOR_NOMMAX_SHIFT 0 +#define DA7280_ACTUATOR_NOMMAX_MASK (255 << 0) + +/* DA7280_ACTUATOR2 (Address 0x0d) */ +#define DA7280_ACTUATOR_ABSMAX_SHIFT 0 +#define DA7280_ACTUATOR_ABSMAX_MASK (255 << 0) + +/* DA7280_ACTUATOR3 (Address 0x0e) */ +#define DA7280_IMAX_SHIFT 0 +#define DA7280_IMAX_MASK (31 << 0) + +/* DA7280_CALIB_V2I_H (Address 0x0f) */ +#define DA7280_V2I_FACTOR_H_SHIFT 0 +#define DA7280_V2I_FACTOR_H_MASK (255 << 0) + +/* DA7280_CALIB_V2I_L (Address 0x10) */ +#define DA7280_V2I_FACTOR_L_SHIFT 0 +#define DA7280_V2I_FACTOR_L_MASK (255 << 0) + +/* DA7280_CALIB_IMP_H (Address 0x11) */ +#define DA7280_IMPEDANCE_H_SHIFT 0 +#define DA7280_IMPEDANCE_H_MASK (255 << 0) + +/* DA7280_CALIB_IMP_L (Address 0x12) */ +#define DA7280_IMPEDANCE_L_SHIFT 0 +#define DA7280_IMPEDANCE_L_MASK (3 << 0) + +/* DA7280_TOP_CFG1 (Address 0x13) */ +#define DA7280_AMP_PID_EN_SHIFT 0 +#define DA7280_AMP_PID_EN_MASK BIT(0) +#define DA7280_RAPID_STOP_EN_SHIFT 1 +#define DA7280_RAPID_STOP_EN_MASK BIT(1) +#define DA7280_ACCELERATION_EN_SHIFT 2 +#define DA7280_ACCELERATION_EN_MASK BIT(2) +#define DA7280_FREQ_TRACK_EN_SHIFT 3 +#define DA7280_FREQ_TRACK_EN_MASK BIT(3) +#define DA7280_BEMF_SENSE_EN_SHIFT 4 +#define DA7280_BEMF_SENSE_EN_MASK BIT(4) +#define DA7280_ACTUATOR_TYPE_SHIFT 5 +#define DA7280_ACTUATOR_TYPE_MASK BIT(5) +#define DA7280_EMBEDDED_MODE_SHIFT 7 +#define DA7280_EMBEDDED_MODE_MASK BIT(7) + +/* DA7280_TOP_CFG2 (Address 0x14) */ +#define DA7280_FULL_BRAKE_THR_SHIFT 0 +#define DA7280_FULL_BRAKE_THR_MASK (15 << 0) +#define DA7280_MEM_DATA_SIGNED_SHIFT 4 +#define DA7280_MEM_DATA_SIGNED_MASK BIT(4) + +/* DA7280_TOP_CFG3 (Address 0x15) */ +#define DA7280_VDD_MARGIN_SHIFT 0 +#define DA7280_VDD_MARGIN_MASK (15 << 0) + +/* DA7280_TOP_CFG4 (Address 0x16) */ +#define DA7280_TST_CALIB_IMPEDANCE_DIS_SHIFT 6 +#define DA7280_TST_CALIB_IMPEDANCE_DIS_MASK BIT(6) +#define DA7280_V2I_FACTOR_FREEZE_SHIFT 7 +#define DA7280_V2I_FACTOR_FREEZE_MASK BIT(7) + +/* DA7280_TOP_INT_CFG1 (Address 0x17) */ +#define DA7280_BEMF_FAULT_LIM_SHIFT 0 +#define DA7280_BEMF_FAULT_LIM_MASK (3 << 0) +#define DA7280_FRQ_LOCKED_LIM_SHIFT 2 +#define DA7280_FRQ_LOCKED_LIM_MASK (63 << 2) + +/* DA7280_TOP_INT_CFG6_H (Address 0x1c) */ +#define DA7280_FRQ_PID_KP_H_SHIFT 0 +#define DA7280_FRQ_PID_KP_H_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG6_L (Address 0x1d) */ +#define DA7280_FRQ_PID_KP_L_SHIFT 0 +#define DA7280_FRQ_PID_KP_L_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG7_H (Address 0x1e) */ +#define DA7280_FRQ_PID_KI_H_SHIFT 0 +#define DA7280_FRQ_PID_KI_H_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG7_L (Address 0x1f) */ +#define DA7280_FRQ_PID_KI_L_SHIFT 0 +#define DA7280_FRQ_PID_KI_L_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG8 (Address 0x20) */ +#define DA7280_TST_FRQ_TRACK_BEMF_LIM_SHIFT 0 +#define DA7280_TST_FRQ_TRACK_BEMF_LIM_MASK (15 << 0) +#define DA7280_TST_AMP_RAPID_STOP_LIM_SHIFT 4 +#define DA7280_TST_AMP_RAPID_STOP_LIM_MASK (7 << 4) + +/* DA7280_TOP_CTL1 (Address 0x22) */ +#define DA7280_OPERATION_MODE_SHIFT 0 +#define DA7280_OPERATION_MODE_MASK (7 << 0) +#define DA7280_STANDBY_EN_SHIFT 3 +#define DA7280_STANDBY_EN_MASK BIT(3) +#define DA7280_SEQ_START_SHIFT 4 +#define DA7280_SEQ_START_MASK BIT(4) + +/* DA7280_TOP_CTL2 (Address 0x23) */ +#define DA7280_OVERRIDE_VAL_SHIFT 0 +#define DA7280_OVERRIDE_VAL_MASK (255 << 0) + +/* DA7280_SEQ_CTL1 (Address 0x24) */ +#define DA7280_SEQ_CONTINUE_SHIFT 0 +#define DA7280_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_WAVEGEN_MODE_SHIFT 1 +#define DA7280_WAVEGEN_MODE_MASK BIT(1) +#define DA7280_FREQ_WAVEFORM_TIMEBASE_SHIFT 2 +#define DA7280_FREQ_WAVEFORM_TIMEBASE_MASK BIT(2) + +/* DA7280_SWG_C1 (Address 0x25) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF1_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF1_MASK (255 << 0) + +/* DA7280_SWG_C2 (Address 0x26) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF2_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF2_MASK (255 << 0) + +/* DA7280_SWG_C3 (Address 0x27) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF3_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF3_MASK (255 << 0) + +/* DA7280_SEQ_CTL2 (Address 0x28) */ +#define DA7280_PS_SEQ_ID_SHIFT 0 +#define DA7280_PS_SEQ_ID_MASK (15 << 0) +#define DA7280_PS_SEQ_LOOP_SHIFT 4 +#define DA7280_PS_SEQ_LOOP_MASK (15 << 4) + +/* DA7280_GPIO_0_CTL (Address 0x29) */ +#define DA7280_GPI0_POLARITY_SHIFT 0 +#define DA7280_GPI0_POLARITY_MASK (3 << 0) +#define DA7280_GPI0_MODE_SHIFT 2 +#define DA7280_GPI0_MODE_MASK BIT(2) +#define DA7280_GPI0_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI0_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_GPIO_1_CTL (Address 0x2a) */ +#define DA7280_GPI1_POLARITY_SHIFT 0 +#define DA7280_GPI1_POLARITY_MASK (3 << 0) +#define DA7280_GPI1_MODE_SHIFT 2 +#define DA7280_GPI1_MODE_MASK BIT(2) +#define DA7280_GPI1_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI1_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_GPIO_2_CTL (Address 0x2b) */ +#define DA7280_GPI2_POLARITY_SHIFT 0 +#define DA7280_GPI2_POLARITY_MASK (3 << 0) +#define DA7280_GPI2_MODE_SHIFT 2 +#define DA7280_GPI2_MODE_MASK BIT(2) +#define DA7280_GPI2_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI2_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_MEM_CTL1 (Address 0x2c) */ +#define DA7280_WAV_MEM_BASE_ADDR_SHIFT 0 +#define DA7280_WAV_MEM_BASE_ADDR_MASK (255 << 0) + +/* DA7280_MEM_CTL2 (Address 0x2d) */ +#define DA7280_WAV_MEM_LOCK_SHIFT 7 +#define DA7280_WAV_MEM_LOCK_MASK BIT(7) + +/* DA7280_ADC_DATA_H1 (Address 0x2e) */ +#define DA7280_ADC_VDD_H_SHIFT 0 +#define DA7280_ADC_VDD_H_MASK (255 << 0) + +/* DA7280_ADC_DATA_L1 (Address 0x2f) */ +#define DA7280_ADC_VDD_L_SHIFT 0 +#define DA7280_ADC_VDD_L_MASK (127 << 0) + +/* DA7280_POLARITY (Address 0x43) */ +#define DA7280_POLARITY_SHIFT 0 +#define DA7280_POLARITY_MASK BIT(0) + +/* DA7280_LRA_AVR_H (Address 0x44) */ +#define DA7280_LRA_PER_AVERAGE_H_SHIFT 0 +#define DA7280_LRA_PER_AVERAGE_H_MASK (255 << 0) + +/* DA7280_LRA_AVR_L (Address 0x45) */ +#define DA7280_LRA_PER_AVERAGE_L_SHIFT 0 +#define DA7280_LRA_PER_AVERAGE_L_MASK (127 << 0) + +/* DA7280_FRQ_LRA_PER_ACT_H (Address 0x46) */ +#define DA7280_LRA_PER_ACTUAL_H_SHIFT 0 +#define DA7280_LRA_PER_ACTUAL_H_MASK (255 << 0) + +/* DA7280_FRQ_LRA_PER_ACT_L (Address 0x47) */ +#define DA7280_LRA_PER_ACTUAL_L_SHIFT 0 +#define DA7280_LRA_PER_ACTUAL_L_MASK (127 << 0) + +/* DA7280_FRQ_PHASE_H (Address 0x48) */ +#define DA7280_PHASE_DELAY_H_SHIFT 0 +#define DA7280_PHASE_DELAY_H_MASK (255 << 0) + +/* DA7280_FRQ_PHASE_L (Address 0x49) */ +#define DA7280_DELAY_SHIFT_L_SHIFT 0 +#define DA7280_DELAY_SHIFT_L_MASK (7 << 0) +#define DA7280_DELAY_SHIFT_FREEZE_SHIFT 7 +#define DA7280_DELAY_SHIFT_FREEZE_MASK BIT(7) + +/* DA7280_FRQ_CTL (Address 0x4c) */ +#define DA7280_FREQ_TRACKING_FORCE_ON_SHIFT 0 +#define DA7280_FREQ_TRACKING_FORCE_ON_MASK BIT(0) +#define DA7280_FREQ_TRACKING_AUTO_ADJ_SHIFT 1 +#define DA7280_FREQ_TRACKING_AUTO_ADJ_MASK BIT(1) + +/* DA7280_TRIM3 (Address 0x5f) */ +#define DA7280_REF_UVLO_THRES_SHIFT 3 +#define DA7280_REF_UVLO_THRES_MASK (3 << 3) +#define DA7280_LOOP_FILT_LOW_BW_SHIFT 5 +#define DA7280_LOOP_FILT_LOW_BW_MASK BIT(5) +#define DA7280_LOOP_IDAC_DOUBLE_RANGE_SHIFT 6 +#define DA7280_LOOP_IDAC_DOUBLE_RANGE_MASK BIT(6) + +/* DA7280_TRIM4 (Address 0x60) */ +#define DA7280_LOOP_FILT_RES_TRIM_SHIFT 0 +#define DA7280_LOOP_FILT_RES_TRIM_MASK (3 << 0) +#define DA7280_LOOP_FILT_CAP_TRIM_SHIFT 2 +#define DA7280_LOOP_FILT_CAP_TRIM_MASK (3 << 2) + +/* DA7280_TRIM6 (Address 0x62) */ +#define DA7280_HBRIDGE_ERC_HS_TRIM_SHIFT 0 +#define DA7280_HBRIDGE_ERC_HS_TRIM_MASK (3 << 0) +#define DA7280_HBRIDGE_ERC_LS_TRIM_SHIFT 2 +#define DA7280_HBRIDGE_ERC_LS_TRIM_MASK (3 << 2) + +/* DA7280_TOP_CFG5 (Address 0x6e) */ +#define DA7280_V2I_FACTOR_OFFSET_EN_SHIFT 0 +#define DA7280_V2I_FACTOR_OFFSET_EN_MASK BIT(0) +#define DA7280_FRQ_PAUSE_ON_POLARITY_CHANGE_SHIFT 1 +#define DA7280_FRQ_PAUSE_ON_POLARITY_CHANGE_MASK BIT(1) +#define DA7280_DELAY_BYPASS_SHIFT 2 +#define DA7280_DELAY_BYPASS_MASK BIT(2) + +/* DA7280_IRQ_EVENT_ACTUATOR_FAULT (Address 0x81) */ +#define DA7280_ADC_SAT_FAULT_SHIFT 2 +#define DA7280_ADC_SAT_FAULT_MASK BIT(2) + +/* DA7280_IRQ_STATUS2 (Address 0x82) */ +#define DA7280_STA_ADC_SAT_SHIFT 7 +#define DA7280_STA_ADC_SAT_MASK BIT(7) + +/* DA7280_IRQ_MASK2 (Address 0x83) */ +#define DA7280_ADC_SAT_M_SHIFT 7 +#define DA7280_ADC_SAT_M_MASK BIT(7) + +/* DA7280_SNP_MEM_XX (Address 0x84 ~ 0xe7) */ +#define DA7280_SNP_MEM_SHIFT 0 +#define DA7280_SNP_MEM_MASK (255 << 0) + +#endif -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH V1 3/3] Input: new da7280 haptic driver @ 2018-08-16 2:02 ` Roy Im 0 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel from: Roy Im <roy.im.opensource@diasemi.com> Adds support for the Dialog DA7280 LRA/ERM Haptic Driver with multiple mode and integrated waveform memory and wideband support. It communicates via an I2C bus to the device. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- drivers/input/misc/Kconfig | 12 + drivers/input/misc/Makefile | 1 + drivers/input/misc/da7280.c | 1452 +++++++++++++++++++++++++++++++++++++++++++ drivers/input/misc/da7280.h | 412 ++++++++++++ 4 files changed, 1877 insertions(+) create mode 100644 drivers/input/misc/da7280.c create mode 100644 drivers/input/misc/da7280.h diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index ca59a2b..6e0de69 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -851,4 +851,16 @@ config INPUT_SC27XX_VIBRA To compile this driver as a module, choose M here. The module will be called sc27xx_vibra. +config INPUT_DA7280_HAPTICS + tristate "Dialog Semiconductor DA7280 haptics support" + depends on (INPUT && I2C && SYSFS) || PWM + select INPUT_FF_MEMLESS + select REGMAP_I2C + help + Say Y to enable support for the haptics controller on + Dialog DA7280 chip. + + To compile this driver as a module, choose M here: the + module will be called da7280-haptic. + endif diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 9d0f9d1..d941348 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -25,6 +25,7 @@ obj-$(CONFIG_INPUT_CMA3000) += cma3000_d0x.o obj-$(CONFIG_INPUT_CMA3000_I2C) += cma3000_d0x_i2c.o obj-$(CONFIG_INPUT_COBALT_BTNS) += cobalt_btns.o obj-$(CONFIG_INPUT_CPCAP_PWRBUTTON) += cpcap-pwrbutton.o +obj-$(CONFIG_INPUT_DA7280_HAPTICS) += da7280.o obj-$(CONFIG_INPUT_DA9052_ONKEY) += da9052_onkey.o obj-$(CONFIG_INPUT_DA9055_ONKEY) += da9055_onkey.o obj-$(CONFIG_INPUT_DA9063_ONKEY) += da9063_onkey.o diff --git a/drivers/input/misc/da7280.c b/drivers/input/misc/da7280.c new file mode 100644 index 0000000..8827711 --- /dev/null +++ b/drivers/input/misc/da7280.c @@ -0,0 +1,1452 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * DA7280 Haptic device driver + * + * Copyright (c) 2018 Dialog Semiconductor. + * Author: Roy Im <Roy.Im.Opensource@diasemi.com> + */ + +#include <linux/err.h> +#include <linux/i2c.h> +#include <linux/input.h> +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/pwm.h> +#include <linux/regmap.h> +#include <linux/workqueue.h> +#include "da7280.h" + +/* uV unit for voltage rate */ +#define DA7280_VOLTAGE_RATE_MAX 6000000 +#define DA7280_VOLTAGE_RATE_STEP 23400 +#define DA7280_NOMMAX_DFT 0x6B +#define DA7280_ABSMAX_DFT 0x78 + +#define DA7280_IMPD_MAX 0xFFFFFFFF +#define DA7280_IMPD_DEFAULT 22000000 + +#define DA7280_IMAX_DEFAULT 0x0E +/* uA unit step and limit for IMAX*/ +#define DA7280_IMAX_STEP 7200 +#define DA7280_IMAX_LIMIT 252000 + +#define DA7280_RESONT_FREQH_DFT 0x39 +#define DA7280_RESONT_FREQL_DFT 0x32 +#define DA7280_MIN_RESONAT_FREQ_HZ 50 +#define DA7280_MAX_RESONAT_FREQ_HZ 300 +#define DA7280_MIN_PWM_FREQ_KHZ 10 +#define DA7280_MAX_PWM_FREQ_KHZ 250 + +#define DA7280_SEQ_ID_MAX 15 +#define DA7280_SEQ_LOOP_MAX 15 +#define DA7280_GPI1_SEQ_ID_DEFT 0x0 + +#define DA7280_SNP_MEM_SIZE 100 +#define DA7280_SNP_MEM_MAX DA7280_SNP_MEM_99 + +#define DA7280_IRQ_FLAGS (IRQF_TRIGGER_LOW | IRQF_ONESHOT) +#define IRQ_NUM 3 + +#define DA7280_SKIP_INIT 0x100 + +enum da7280_haptic_dev_t { + DA7280_LRA = 0, + DA7280_ERM_BAR = 1, + DA7280_ERM_COIN = 2, + DA7280_DEV_MAX, +}; + +enum da7280_op_mode { + DA7280_INACTIVE = 0, + DA7280_DRO_MODE = 1, + DA7280_PWM_MODE = 2, + DA7280_RTWM_MODE = 3, + DA7280_ETWM_MODE = 4, + DA7280_OPMODE_MAX, +}; + +struct da7280_gpi_ctl { + u8 seq_id; + u8 mode; + u8 polarity; +}; + +struct da7280_haptic { + struct regmap *regmap; + struct input_dev *input_dev; + struct device *dev; + struct i2c_client *client; + struct pwm_device *pwm_dev; + bool legacy; + int pwm_id; + struct work_struct work; + + bool suspend_state; + unsigned int magnitude; + + u8 dev_type; + u8 op_mode; + u16 nommax; + u16 absmax; + u32 imax; + u32 impd; + u32 resonant_freq_h; + u32 resonant_freq_l; + u8 bemf_sense_en; + u8 freq_track_en; + u8 acc_en; + u8 rapid_stop_en; + u8 amp_pid_en; + u8 ps_seq_id; + u8 ps_seq_loop; + struct da7280_gpi_ctl gpi_ctl[3]; + bool mem_update; + u8 snp_mem[DA7280_SNP_MEM_SIZE]; + const struct attribute_group **attr_group; +}; + +static bool da7280_volatile_register(struct device *dev, unsigned int reg) +{ + switch (reg) { + case DA7280_IRQ_EVENT1: + case DA7280_IRQ_EVENT_WARNING_DIAG: + case DA7280_IRQ_EVENT_SEQ_DIAG: + case DA7280_IRQ_STATUS1: + case DA7280_TOP_CTL1: + return 1; + default: + return 0; + } +} + +static const struct regmap_config da7280_haptic_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = DA7280_SNP_MEM_MAX, + .volatile_reg = da7280_volatile_register, +}; + +static int da7280_haptic_mem_update(struct da7280_haptic *haptics) +{ + int ret; + unsigned int val; + + /* It is recommended to update the patterns + * during haptic is not working in order to avoid conflict + */ + ret = regmap_read(haptics->regmap, DA7280_IRQ_STATUS1, &val); + if (ret) + return ret; + if (val & DA7280_STA_WARNING_MASK) { + dev_warn(haptics->dev, + "Warning! Please check HAPTIC status.\n"); + return -EBUSY; + } + + /* Patterns are not updated if the lock bit is enabled */ + val = 0; + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL2, &val); + if (ret) + return ret; + if (~val & DA7280_WAV_MEM_LOCK_MASK) { + dev_warn(haptics->dev, + "Please unlock the bit first\n"); + return -EACCES; + } + + /* Set to Inactive mode to make sure safety */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, + 0); + if (ret) + return ret; + + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val); + if (ret) + return ret; + + return regmap_bulk_write(haptics->regmap, val, + haptics->snp_mem, DA7280_SNP_MEM_MAX - val + 1); +} + +static int da7280_haptic_set_pwm(struct da7280_haptic *haptics) +{ + struct pwm_args pargs; + u64 period_mag_multi; + unsigned int pwm_duty; + int ret; + + pwm_get_args(haptics->pwm_dev, &pargs); + period_mag_multi = + (u64)(pargs.period * haptics->magnitude); + if (haptics->acc_en) + pwm_duty = + (unsigned int)(period_mag_multi >> 16); + else + pwm_duty = + (unsigned int)((period_mag_multi >> 16) + + pargs.period) / 2; + + ret = pwm_config(haptics->pwm_dev, + pwm_duty, pargs.period); + if (ret) { + dev_err(haptics->dev, + "failed to configure pwm : %d\n", ret); + return ret; + } + + ret = pwm_enable(haptics->pwm_dev); + if (ret) { + pwm_disable(haptics->pwm_dev); + dev_err(haptics->dev, + "failed to enable haptics pwm device : %d\n", ret); + } + + return ret; +} + +static void da7280_haptic_enable(struct da7280_haptic *haptics) +{ + int ret = 0; + + switch (haptics->op_mode) { + case DA7280_DRO_MODE: + /* the valid range check when acc_en is enabled */ + if (haptics->acc_en && haptics->magnitude > 0x7F) + haptics->magnitude = 0x7F; + else if (haptics->magnitude > 0xFF) + haptics->magnitude = 0xFF; + + /* Set driver level + * as a % of ACTUATOR_NOMMAX(nommax) + */ + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, + haptics->magnitude); + if (ret) { + dev_err(haptics->dev, + "i2c err for driving level set : %d\n", + ret); + return; + } + break; + case DA7280_PWM_MODE: + if (da7280_haptic_set_pwm(haptics)) + return; + break; + case DA7280_RTWM_MODE: + /* PS_SEQ_ID will be played + * as many times as the PS_SEQ_LOOP + */ + case DA7280_ETWM_MODE: + /* Now users are able to control the GPI(N) + * assigned to GPI_0, GPI1 and GPI2 accordingly + * please see the datasheet for details. + * GPI(N)_SEQUENCE_ID will be played + * as many times as the PS_SEQ_LOOP + */ + break; + default: + dev_err(haptics->dev, + "Invalid Mode(%d)\n", haptics->op_mode); + return; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, + haptics->op_mode); + if (ret) { + dev_err(haptics->dev, + "i2c err for op_mode setting : %d\n", ret); + return; + } + + if (haptics->op_mode == DA7280_PWM_MODE || + haptics->op_mode == DA7280_RTWM_MODE) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_SEQ_START_MASK, + DA7280_SEQ_START_MASK); + if (ret) + dev_err(haptics->dev, + "i2c err for sequence triggering : %d\n", ret); + } +} + +static void da7280_haptic_disable(struct da7280_haptic *haptics) +{ + int ret; + + /* Set to Inactive mode */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for op_mode off : %d\n", ret); + return; + } + + switch (haptics->op_mode) { + case DA7280_RTWM_MODE: + case DA7280_ETWM_MODE: + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_SEQ_START_MASK, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for RTWM or ETWM mode off : %d\n", + ret); + return; + } + break; + case DA7280_DRO_MODE: + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, 0); + if (ret) { + dev_err(haptics->dev, + "i2c err for DRO mode off : %d\n", + ret); + return; + } + break; + case DA7280_PWM_MODE: + pwm_disable(haptics->pwm_dev); + break; + default: + dev_err(haptics->dev, + "Invalid Mode(%d)\n", haptics->op_mode); + break; + } +} + +static void da7280_haptic_work(struct work_struct *work) +{ + struct da7280_haptic *haptics = + container_of(work, struct da7280_haptic, work); + + if (haptics->magnitude) + da7280_haptic_enable(haptics); + else + da7280_haptic_disable(haptics); +} + +static int da7280_haptic_play(struct input_dev *dev, void *data, + struct ff_effect *effect) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + + if (effect->u.rumble.strong_magnitude > 0) + haptics->magnitude = effect->u.rumble.strong_magnitude; + else if (effect->u.rumble.weak_magnitude > 0) + haptics->magnitude = effect->u.rumble.weak_magnitude; + else + haptics->magnitude = 0; + + schedule_work(&haptics->work); + + return 0; +} + +static int da7280_haptic_open(struct input_dev *dev) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + int ret; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + dev_err(haptics->dev, + "Failed to open haptic, i2c error : %d\n", ret); + + return ret; +} + +static void da7280_haptic_close(struct input_dev *dev) +{ + struct da7280_haptic *haptics = input_get_drvdata(dev); + int ret; + + cancel_work_sync(&haptics->work); + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) + goto error_i2c; + + if (haptics->op_mode == DA7280_DRO_MODE) { + ret = regmap_write(haptics->regmap, + DA7280_TOP_CTL2, 0); + + if (ret) + goto error_i2c; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, 0); + if (ret) + goto error_i2c; + + return; + +error_i2c: + dev_err(haptics->dev, "DA7280-haptic i2c error : %d\n", ret); +} + +static u8 da7280_haptic_of_mode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "LRA-MODE")) + return DA7280_LRA; + else if (!strcmp(str, "ERM-BAR")) + return DA7280_ERM_BAR; + else if (!strcmp(str, "ERM-COIN")) + return DA7280_ERM_COIN; + + dev_warn(dev, "Invalid string - set to default\n"); + return DA7280_LRA; +} + +static u8 da7280_haptic_of_opmode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "DRO-MODE")) + return DA7280_DRO_MODE; + else if (!strcmp(str, "PWM-MODE")) + return DA7280_PWM_MODE; + else if (!strcmp(str, "RTWM-MODE")) + return DA7280_RTWM_MODE; + else if (!strcmp(str, "ETWM-MODE")) + return DA7280_ETWM_MODE; + + dev_warn(dev, "Invalid string - set to default\n"); + return DA7280_DRO_MODE; +} + +static u8 da7280_haptic_of_gpi_mode_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "Single-pattern")) + return 0; + else if (!strcmp(str, "Multi-pattern")) + return 1; + + dev_warn(dev, "Invalid string - set to default\n"); + return 0; +} + +static u8 da7280_haptic_of_gpi_pol_str(struct device *dev, + const char *str) +{ + if (!strcmp(str, "Rising-edge")) + return 0; + else if (!strcmp(str, "Falling-edge")) + return 1; + else if (!strcmp(str, "Both-edge")) + return 2; + + dev_warn(dev, "Invalid string - set to default\n"); + return 0; +} + +static u8 da7280_haptic_of_volt_rating_set(u32 val) +{ + u32 voltage; + + voltage = val / DA7280_VOLTAGE_RATE_STEP + 1; + + if (voltage > 0xFF) + return 0xFF; + return (u8)voltage; +} + +static void da7280_of_to_pdata(struct device *dev, + struct da7280_haptic *haptics) +{ + struct device_node *np = dev->of_node; + char dt_gpi_str1[] = "dlg,gpi0-seq-id"; + char dt_gpi_str2[] = "dlg,gpi0-mode"; + char dt_gpi_str3[] = "dlg,gpi0-polarity"; + unsigned int mem[DA7280_SNP_MEM_SIZE]; + const char *of_str; + u32 of_val32; + int i; + + if (!of_property_read_string(np, "dlg,vib-mode", &of_str)) + haptics->dev_type = + da7280_haptic_of_mode_str(dev, of_str); + else /* if no property, then use the mode inside chip */ + haptics->dev_type = DA7280_DEV_MAX; + + if (!of_property_read_string(np, "dlg,play-mode", &of_str)) + haptics->op_mode = + da7280_haptic_of_opmode_str(dev, of_str); + else /* Set to DRO mode as a default mode */ + haptics->op_mode = DA7280_DRO_MODE; + + if (of_property_read_u32(np, "dlg,nom-microvolt", &of_val32) >= 0) + if (of_val32 < DA7280_VOLTAGE_RATE_MAX) + haptics->nommax = + da7280_haptic_of_volt_rating_set(of_val32); + else + haptics->nommax = DA7280_SKIP_INIT; + else /* if no property, then use the value inside chip */ + haptics->nommax = DA7280_SKIP_INIT; + + if (of_property_read_u32(np, "dlg,abs-max-microvolt", &of_val32) >= 0) + if (of_val32 < DA7280_VOLTAGE_RATE_MAX) + haptics->absmax = + da7280_haptic_of_volt_rating_set(of_val32); + else + haptics->absmax = DA7280_SKIP_INIT; + else + haptics->absmax = DA7280_SKIP_INIT; + + if (of_property_read_u32(np, "dlg,imax-microamp", &of_val32) >= 0) + if (of_val32 < DA7280_IMAX_LIMIT) + haptics->imax = (of_val32 - 28600) + / DA7280_IMAX_STEP + 1; + else + haptics->imax = DA7280_IMAX_DEFAULT; + else + haptics->imax = DA7280_IMAX_DEFAULT; + + if (of_property_read_u32(np, "dlg,impd-micro-ohms", &of_val32) >= 0) + if (of_val32 <= DA7280_IMPD_MAX) + haptics->impd = of_val32; + else + haptics->impd = DA7280_IMPD_DEFAULT; + else + haptics->impd = DA7280_IMPD_DEFAULT; + + if (of_property_read_u32(np, "dlg,resonant-freq-hz", &of_val32) >= 0) { + if (of_val32 < DA7280_MAX_RESONAT_FREQ_HZ && + of_val32 > DA7280_MIN_RESONAT_FREQ_HZ) { + haptics->resonant_freq_h = + ((1000000000 / (of_val32 * 1333)) >> 7) & 0xFF; + haptics->resonant_freq_l = + (1000000000 / (of_val32 * 1333)) & 0x7F; + } else { + haptics->resonant_freq_h = + DA7280_RESONT_FREQH_DFT; + haptics->resonant_freq_l = + DA7280_RESONT_FREQL_DFT; + } + } else { + haptics->resonant_freq_h = DA7280_SKIP_INIT; + haptics->resonant_freq_l = DA7280_SKIP_INIT; + } + + if (of_property_read_u32(np, "dlg,ps-seq-id", &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_ID_MAX) + haptics->ps_seq_id = of_val32; + else + haptics->ps_seq_id = 0; + else /* if no property, set to zero as a default do nothing */ + haptics->ps_seq_id = 0; + + if (of_property_read_u32(np, "dlg,ps-seq-loop", &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_LOOP_MAX) + haptics->ps_seq_loop = of_val32; + else + haptics->ps_seq_loop = 0; + else /* if no property, then do nothing */ + haptics->ps_seq_loop = 0; + + /* GPI0~2 Control */ + for (i = 0; i < 3; i++) { + dt_gpi_str1[7] = '0' + i; + if (of_property_read_u32(np, dt_gpi_str1, &of_val32) >= 0) + if (of_val32 <= DA7280_SEQ_ID_MAX) + haptics->gpi_ctl[i].seq_id = of_val32; + else + haptics->gpi_ctl[i].seq_id = + DA7280_GPI1_SEQ_ID_DEFT + i; + else /* if no property, then do nothing */ + haptics->gpi_ctl[i].seq_id = + DA7280_GPI1_SEQ_ID_DEFT + i; + + dt_gpi_str2[7] = '0' + i; + if (!of_property_read_string(np, dt_gpi_str2, &of_str)) + haptics->gpi_ctl[i].mode = + da7280_haptic_of_gpi_mode_str(dev, of_str); + else + haptics->gpi_ctl[i].mode = 0; + + dt_gpi_str3[7] = '0' + i; + if (!of_property_read_string(np, dt_gpi_str3, &of_str)) + haptics->gpi_ctl[i].polarity = + da7280_haptic_of_gpi_pol_str(dev, of_str); + else + haptics->gpi_ctl[i].polarity = 0; + } + + haptics->bemf_sense_en = + of_property_read_bool(np, "dlg,bemf-sens-enable"); + haptics->freq_track_en = + of_property_read_bool(np, "dlg,freq-track-enable"); + haptics->acc_en = + of_property_read_bool(np, "dlg,acc-enable"); + haptics->rapid_stop_en = + of_property_read_bool(np, "dlg,rapid-stop-enable"); + haptics->amp_pid_en = + of_property_read_bool(np, "dlg,amp-pid-enable"); + + if (of_property_read_u32_array(np, "dlg,mem-array", + &mem[0], DA7280_SNP_MEM_SIZE) >= 0) { + haptics->mem_update = 1; + for (i = 0; i < DA7280_SNP_MEM_SIZE; i++) { + if (mem[i] > 0xff) + haptics->snp_mem[i] = 0x0; + else + haptics->snp_mem[i] = (u8)mem[i]; + } + } else { + haptics->mem_update = 0; + } +} + +static irqreturn_t da7280_irq_handler(int irq, void *data) +{ + struct da7280_haptic *haptics = data; + u8 events[IRQ_NUM]; + int ret; + + /* Check what events have happened */ + ret = regmap_bulk_read(haptics->regmap, + DA7280_IRQ_EVENT1, + events, IRQ_NUM); + if (ret) + goto error_i2c; + + /* Empty check due to shared interrupt */ + if ((events[0] | events[1] | events[2]) == 0x00) + return IRQ_HANDLED; + + if (events[0] & DA7280_E_SEQ_FAULT_MASK) { + /* Stop first if Haptic is working + * Otherwise, the fault may happen continually + * even though the bit is cleared. + */ + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_OPERATION_MODE_MASK, 0); + if (ret) + goto error_i2c; + } + + /* Clear events */ + ret = regmap_write(haptics->regmap, + DA7280_IRQ_EVENT1, events[0]); + if (ret) + goto error_i2c; + + return IRQ_HANDLED; + +error_i2c: + dev_err(haptics->dev, "da7280 i2c error : %d\n", ret); + return IRQ_NONE; +} + +static int da7280_init(struct da7280_haptic *haptics) +{ + int ret, i; + unsigned int val = 0; + u32 v2i_factor; + u8 mask = 0; + + /* If device type is DA7280_DEV_MAX, + * then skip to initialze and use default value inside chip. + */ + if (haptics->dev_type == DA7280_DEV_MAX) { + ret = regmap_read(haptics->regmap, DA7280_TOP_CFG1, &val); + if (ret) + goto error_i2c; + if (val & DA7280_ACTUATOR_TYPE_MASK) + haptics->dev_type = DA7280_ERM_COIN; + else + haptics->dev_type = DA7280_LRA; + } + + /* Apply user settings */ + if (haptics->dev_type == DA7280_LRA) { + if (haptics->resonant_freq_l != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, + DA7280_FRQ_LRA_PER_H, + haptics->resonant_freq_h); + if (ret) + goto error_i2c; + ret = regmap_write(haptics->regmap, + DA7280_FRQ_LRA_PER_L, + haptics->resonant_freq_l); + if (ret) + goto error_i2c; + } + } else if (haptics->dev_type == DA7280_ERM_COIN) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_INT_CFG1, + DA7280_BEMF_FAULT_LIM_MASK, 0); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CFG4, + DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | + DA7280_V2I_FACTOR_FREEZE_MASK, + DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | + DA7280_V2I_FACTOR_FREEZE_MASK); + if (ret) + goto error_i2c; + + haptics->acc_en = 0; + haptics->rapid_stop_en = 0; + haptics->amp_pid_en = 0; + } + + /* Should be set to 0 only + * in custom waveform and wideband operation + */ + if (haptics->op_mode >= DA7280_RTWM_MODE) + haptics->bemf_sense_en = 0; + + mask = DA7280_ACTUATOR_TYPE_MASK | + DA7280_BEMF_SENSE_EN_MASK | + DA7280_FREQ_TRACK_EN_MASK | + DA7280_ACCELERATION_EN_MASK | + DA7280_RAPID_STOP_EN_MASK | + DA7280_AMP_PID_EN_MASK; + + val = (haptics->dev_type ? 1 : 0) + << DA7280_ACTUATOR_TYPE_SHIFT | + (haptics->bemf_sense_en ? 1 : 0) + << DA7280_BEMF_SENSE_EN_SHIFT | + (haptics->freq_track_en ? 1 : 0) + << DA7280_FREQ_TRACK_EN_SHIFT | + (haptics->acc_en ? 1 : 0) + << DA7280_ACCELERATION_EN_SHIFT | + (haptics->rapid_stop_en ? 1 : 0) + << DA7280_RAPID_STOP_EN_SHIFT | + (haptics->amp_pid_en ? 1 : 0) + << DA7280_AMP_PID_EN_SHIFT; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CFG1, mask, val); + if (ret) + goto error_i2c; + + if (haptics->nommax != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, + DA7280_ACTUATOR1, + haptics->nommax); + if (ret) + goto error_i2c; + } + + if (haptics->absmax != DA7280_SKIP_INIT) { + ret = regmap_write(haptics->regmap, DA7280_ACTUATOR2, + haptics->absmax); + if (ret) + goto error_i2c; + } + + ret = regmap_update_bits(haptics->regmap, + DA7280_ACTUATOR3, + DA7280_IMAX_MASK, + haptics->imax); + if (ret) + goto error_i2c; + + v2i_factor = + haptics->impd * (haptics->imax + 4) / 1610400; + ret = regmap_write(haptics->regmap, + DA7280_CALIB_V2I_L, + v2i_factor); + if (ret) + goto error_i2c; + ret = regmap_write(haptics->regmap, DA7280_CALIB_V2I_H, + v2i_factor >> 8); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + goto error_i2c; + + if (haptics->mem_update) { + ret = da7280_haptic_mem_update(haptics); + if (ret) + goto error_i2c; + } + + /* Set PS_SEQ_ID and PS_SEQ_LOOP */ + val = haptics->ps_seq_id << DA7280_PS_SEQ_ID_SHIFT | + haptics->ps_seq_loop << DA7280_PS_SEQ_LOOP_SHIFT; + ret = regmap_write(haptics->regmap, + DA7280_SEQ_CTL2, val); + if (ret) + goto error_i2c; + + /* GPI(N) CTL */ + for (i = 0; i < 3; i++) { + val = haptics->gpi_ctl[i].seq_id + << DA7280_GPI0_SEQUENCE_ID_SHIFT | + haptics->gpi_ctl[i].mode + << DA7280_GPI0_MODE_SHIFT | + haptics->gpi_ctl[i].polarity + << DA7280_GPI0_POLARITY_SHIFT; + ret = regmap_write(haptics->regmap, + DA7280_GPI_0_CTL + i, val); + if (ret) + goto error_i2c; + } + + /* Clear Interrupts */ + ret = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, 0xff); + if (ret) + goto error_i2c; + + ret = regmap_update_bits(haptics->regmap, + DA7280_IRQ_MASK1, + DA7280_SEQ_FAULT_M_MASK + | DA7280_SEQ_DONE_M_MASK, 0); + if (ret) + goto error_i2c; + + haptics->suspend_state = 0; + return 0; + +error_i2c: + dev_err(haptics->dev, "haptic init - I2C error : %d\n", ret); + return ret; +} + +/* Valid format for ps_seq_id + * echo X > ps_seq_id + * ex) echo 2 > /sys/class/..../ps_seq_id + * 0 <= X <= 15. + */ +static ssize_t ps_seq_id_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + long val = 0xff; + int ret; + + if (kstrtol(&buf[0], 0, &val) < 0) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_SEQ_CTL2, + DA7280_PS_SEQ_ID_MASK, + (val & 0xf) >> DA7280_PS_SEQ_ID_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->ps_seq_id = val & 0xf; + + return count; + +err: + dev_err(dev, "Invalid input\n"); + return count; +} + +static ssize_t ps_seq_id_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val; + + ret = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + val = (val & DA7280_PS_SEQ_ID_MASK) + >> DA7280_PS_SEQ_ID_SHIFT; + + return sprintf(buf, "ps_seq_id is %d\n", val); +} + +/* Valid format for ps_seq_loop + * echo X > ps_seq_loop + * ex) echo 2 > /sys/class/..../ps_seq_loop + * 0 <= X <= 15. + */ +static ssize_t ps_seq_loop_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + long val = 0xff; + int ret; + + if (kstrtol(&buf[0], 0, &val) < 0) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_SEQ_CTL2, + DA7280_PS_SEQ_LOOP_MASK, + (val & 0xF) << DA7280_PS_SEQ_LOOP_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->ps_seq_loop = (val & 0xF); + + return count; +err: + dev_err(dev, "Invalid input value!\n"); + return count; +} + +static ssize_t ps_seq_loop_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val; + + ret = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + val = (val & DA7280_PS_SEQ_LOOP_MASK) + >> DA7280_PS_SEQ_LOOP_SHIFT; + + return sprintf(buf, "ps_seq_loop is %d\n", val); +} + +/* Valid format for GPIx_SEQUENCE_ID + * echo X Y > gpi_seq_id + * ex) echo 2 15 > /sys/class/..../gpi_seq_id + * 0 <= X < 3, 0<= Y <= 15. + */ +static ssize_t gpi_seq_id_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_num = 0xff; + long seq_id = 0xff; + int ret; + + if (count < 4) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + else + goto err; + + if (buf[1] != ' ') + goto err; + + if (kstrtol(&buf[2], 0, &seq_id) < 0) + goto err; + + if (gpi_num > 2 || seq_id > 0xf) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_SEQUENCE_ID_MASK, + seq_id << DA7280_GPI0_SEQUENCE_ID_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].seq_id = seq_id; + + return count; + +err: + dev_err(dev, "Invalid format or values!\n"); + return count; +} + +static ssize_t gpi_seq_id_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + haptics->gpi_ctl[i].seq_id = + (val & DA7280_GPI0_SEQUENCE_ID_MASK) + >> DA7280_GPI0_SEQUENCE_ID_SHIFT; + val = 0; + } + + return sprintf(buf, + "Seq ID\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].seq_id, + haptics->gpi_ctl[1].seq_id, + haptics->gpi_ctl[2].seq_id); +} + +/* Valid format for GPIx_MODE + * echo X Y > gpi_mode + * ex) echo 2 1 > /sys/class/..../gpi_mode + * 0 <= X < 3, 0<= Y <= 1. + */ +static ssize_t gpi_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_num = 0xff, gpi_mode = 0xff; + int ret; + + if (count < 3) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + if (buf[2] >= '0') + gpi_mode = buf[2] - '0'; + + if (gpi_num > 2 || gpi_mode > 1) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_MODE_MASK, + gpi_mode << DA7280_GPI0_MODE_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].mode = gpi_mode; + + return count; + +err: + dev_err(dev, "Invalid format!\n"); + return count; +} + +static ssize_t gpi_mode_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) { + dev_err(haptics->dev, + "failed to read register : %d\n", ret); + return ret; + } + haptics->gpi_ctl[i].mode = + (val & DA7280_GPI0_MODE_MASK) + >> DA7280_GPI0_MODE_SHIFT; + val = 0; + } + + return sprintf(buf, "Mode\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].mode, + haptics->gpi_ctl[1].mode, + haptics->gpi_ctl[2].mode); +} + +/* Valid format for GPIx_MODE + * echo X Y > gpi_pol + * ex) echo 2 1 > /sys/class/..../gpi_pol + * 0 <= X < 3, 0<= Y <= 2. + */ +static ssize_t gpi_pol_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + u8 gpi_pol = 0xff, gpi_num = 0xff; + int ret; + + if (count < 3) + goto err; + + if (buf[0] >= '0') + gpi_num = buf[0] - '0'; + if (buf[2] >= '0') + gpi_pol = buf[2] - '0'; + + if (gpi_num > 2 || gpi_pol > 2) + goto err; + + ret = regmap_update_bits(haptics->regmap, + DA7280_GPI_0_CTL + gpi_num, + DA7280_GPI0_POLARITY_MASK, + gpi_pol << DA7280_GPI0_POLARITY_SHIFT); + if (ret) { + dev_err(haptics->dev, + "failed to update register : %d\n", ret); + return ret; + } + + haptics->gpi_ctl[gpi_num].polarity = gpi_pol; + + return count; + +err: + dev_err(dev, "Invalid format or input values!\n"); + return count; +} + +static ssize_t gpi_pol_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + unsigned int val, i; + + for (i = 0; i < 3; i++) { + ret = regmap_read(haptics->regmap, + DA7280_GPI_0_CTL + i, &val); + if (ret) + return ret; + haptics->gpi_ctl[i].polarity = + (val & DA7280_GPI0_POLARITY_MASK) + >> DA7280_GPI0_POLARITY_SHIFT; + val = 0; + } + + return sprintf(buf, "Polarity\nGPI0 : %d\nGPI1 : %d\nGPI2 : %d\n", + haptics->gpi_ctl[0].polarity, + haptics->gpi_ctl[1].polarity, + haptics->gpi_ctl[2].polarity); +} + +#define MAX_PTN_REGS DA7280_SNP_MEM_SIZE +#define MAX_USER_INPUT_LEN (5 * DA7280_SNP_MEM_SIZE) +struct parse_data_t { + int len; + u8 val[MAX_PTN_REGS]; +}; + +static int da7280_parse_args(struct device *dev, + char *cmd, struct parse_data_t *ptn) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + char *tok; /* used to separate tokens */ + const char ct[] = " \t"; /* space or tab delimits the tokens */ + int tok_count = 0; /* total number of tokens parsed */ + int i = 0, val; + + ptn->len = 0; + + /* parse the input string */ + while ((tok = strsep(&cmd, ct)) != NULL) { + /* this is a value to be written to the register */ + if (kstrtouint(tok, 0, &val) < 0) { + dev_err(haptics->dev, + "failed to read from %s\n", tok); + break; + } + + if (i < MAX_PTN_REGS) { + ptn->val[i] = val; + i++; + } + tok_count++; + } + + /* decide whether it is a read or write operation based on the + * value of tok_count and count_flag. + * tok_count = 0: no inputs, invalid case. + * tok_count = 1: write one value. + * tok_count > 1: write multiple values/patterns. + */ + switch (tok_count) { + case 0: + return -EINVAL; + case 1: + ptn->len = 1; + break; + default: + ptn->len = i; + } + return 0; +} + +static ssize_t +patterns_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + struct parse_data_t mem; + char cmd[MAX_USER_INPUT_LEN]; + unsigned int val; + int ret; + + ret = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val); + if (ret) + return ret; + + if (count > MAX_USER_INPUT_LEN) + memcpy(cmd, buf, MAX_USER_INPUT_LEN); + else + memcpy(cmd, buf, count); + /* chop of '\n' introduced by echo at the end of the input */ + if (cmd[count - 1] == '\n') + cmd[count - 1] = '\0'; + + if (da7280_parse_args(dev, cmd, &mem) < 0) + return -EINVAL; + + memcpy(haptics->snp_mem, mem.val, mem.len); + + ret = da7280_haptic_mem_update(haptics); + if (ret) + return ret; + + return count; +} + +static DEVICE_ATTR_RW(ps_seq_id); +static DEVICE_ATTR_RW(ps_seq_loop); +static DEVICE_ATTR_RW(gpi_seq_id); +static DEVICE_ATTR_RW(gpi_mode); +static DEVICE_ATTR_RW(gpi_pol); +static DEVICE_ATTR_WO(patterns); +static struct attribute *da7280_sysfs_attr[] = { + &dev_attr_ps_seq_id.attr, + &dev_attr_ps_seq_loop.attr, + &dev_attr_gpi_seq_id.attr, + &dev_attr_gpi_mode.attr, + &dev_attr_gpi_pol.attr, + &dev_attr_patterns.attr, + NULL, +}; + +static const struct attribute_group da7280_attr_group = { + .attrs = da7280_sysfs_attr, +}; + +static const struct attribute_group *da7280_attr_groups[] = { + &da7280_attr_group, + NULL, +}; + +static int da7280_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct device *dev = &client->dev; + struct da7280_haptic *haptics; + unsigned int period2freq; + int ret; + + haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL); + if (!haptics) + return -ENOMEM; + haptics->dev = dev; + + if (!client->irq) { + dev_err(dev, "No IRQ configured\n"); + return -EINVAL; + } + + /* Handle DT data if provided */ + if (client->dev.of_node) + da7280_of_to_pdata(&client->dev, haptics); + + if (haptics->op_mode == DA7280_PWM_MODE) { + /* Get pwm and regulatot for haptics device */ + haptics->pwm_dev = devm_pwm_get(&client->dev, NULL); + if (IS_ERR(haptics->pwm_dev)) { + dev_err(dev, "failed to get PWM device\n"); + return PTR_ERR(haptics->pwm_dev); + } + + /* + * FIXME: pwm_apply_args() should be removed when switching to + * the atomic PWM API. + */ + pwm_apply_args(haptics->pwm_dev); + + /* Check PWM Period, it must be in 10k ~ 250kHz */ + period2freq = 1000000 / pwm_get_period(haptics->pwm_dev); + if (period2freq < DA7280_MIN_PWM_FREQ_KHZ || + period2freq > DA7280_MAX_PWM_FREQ_KHZ) { + dev_err(dev, "Not supported PWM frequency(%d)\n", + period2freq); + return -EINVAL; + } + } + + INIT_WORK(&haptics->work, da7280_haptic_work); + haptics->client = client; + i2c_set_clientdata(client, haptics); + + haptics->regmap = + devm_regmap_init_i2c(client, &da7280_haptic_regmap_config); + if (IS_ERR(haptics->regmap)) { + ret = PTR_ERR(haptics->regmap); + dev_err(dev, "Failed to allocate register map : %d\n", + ret); + return ret; + } + + ret = devm_request_threaded_irq(dev, client->irq, NULL, + da7280_irq_handler, + DA7280_IRQ_FLAGS, + "da7280-haptics", haptics); + if (ret != 0) { + dev_err(dev, + "Failed to request IRQ : %d\n", client->irq); + return ret; + } + + ret = da7280_init(haptics); + if (ret) { + dev_err(dev, "failed to initialize device\n"); + return ret; + } + + /* Initialize input device for haptic device */ + haptics->input_dev = devm_input_allocate_device(dev); + if (!haptics->input_dev) { + dev_err(dev, "failed to allocate input device\n"); + return -ENOMEM; + } + + haptics->input_dev->name = "da7280-haptic"; + haptics->input_dev->dev.parent = client->dev.parent; + haptics->input_dev->open = da7280_haptic_open; + haptics->input_dev->close = da7280_haptic_close; + input_set_drvdata(haptics->input_dev, haptics); + input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE); + + ret = input_ff_create_memless(haptics->input_dev, NULL, + da7280_haptic_play); + if (ret) { + dev_err(dev, "failed to create force-feedback\n"); + return ret; + } + +#ifdef CONFIG_SYSFS + haptics->input_dev->dev.groups = da7280_attr_groups; +#endif + + ret = input_register_device(haptics->input_dev); + if (ret) + dev_err(dev, "failed to register input device\n"); + + return ret; +} + +static int __maybe_unused da7280_suspend(struct device *dev) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + + mutex_lock(&haptics->input_dev->mutex); + if (haptics->suspend_state == 0) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, 0); + if (ret) + dev_err(haptics->dev, + "I2C error : %d\n", ret); + else + haptics->suspend_state = 1; + } + mutex_unlock(&haptics->input_dev->mutex); + return ret; +} + +static int __maybe_unused da7280_resume(struct device *dev) +{ + struct da7280_haptic *haptics = dev_get_drvdata(dev); + int ret = 0; + + mutex_lock(&haptics->input_dev->mutex); + if (haptics->suspend_state) { + ret = regmap_update_bits(haptics->regmap, + DA7280_TOP_CTL1, + DA7280_STANDBY_EN_MASK, + DA7280_STANDBY_EN_MASK); + if (ret) + dev_err(haptics->dev, + "i2c error : %d\n", ret); + else + haptics->suspend_state = 0; + } + mutex_unlock(&haptics->input_dev->mutex); + return ret; +} + +static const struct of_device_id da7280_of_match[] = { + { .compatible = "dlg,da7280", }, + { } +}; +MODULE_DEVICE_TABLE(of, da7280_of_match); + +static const struct i2c_device_id da7280_i2c_id[] = { + { "da7280", }, + { } +}; +MODULE_DEVICE_TABLE(i2c, da7280_i2c_id); + +static SIMPLE_DEV_PM_OPS(da7280_pm_ops, + da7280_suspend, da7280_resume); + +static struct i2c_driver da7280_driver = { + .driver = { + .name = "da7280", + .of_match_table = of_match_ptr(da7280_of_match), + .pm = &da7280_pm_ops, + }, + .probe = da7280_probe, + .id_table = da7280_i2c_id, +}; +module_i2c_driver(da7280_driver); + +MODULE_DESCRIPTION("DA7280 haptics driver"); +MODULE_AUTHOR("Roy Im <Roy.Im.Opensource@diasemi.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/input/misc/da7280.h b/drivers/input/misc/da7280.h new file mode 100644 index 0000000..d9310b6 --- /dev/null +++ b/drivers/input/misc/da7280.h @@ -0,0 +1,412 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * DA7280 Haptic device driver registers + * + * Copyright (c) 2017 Dialog Semiconductor. + * Author: Roy Im <Roy.Im.Opensource@diasemi.com> + */ + +#ifndef _DA7280_REG_DEFS_H +#define _DA7280_REG_DEFS_H + +#include <linux/bitops.h> + +/* Registers */ + +#define DA7280_CHIP_REV 0x00 +#define DA7280_IRQ_EVENT1 0x03 +#define DA7280_IRQ_EVENT_WARNING_DIAG 0x04 +#define DA7280_IRQ_EVENT_SEQ_DIAG 0x05 +#define DA7280_IRQ_STATUS1 0x06 +#define DA7280_IRQ_MASK1 0x07 +#define DA7280_CIF_I2C1 0x08 +#define DA7280_FRQ_LRA_PER_H 0x0A +#define DA7280_FRQ_LRA_PER_L 0x0B +#define DA7280_ACTUATOR1 0x0C +#define DA7280_ACTUATOR2 0x0D +#define DA7280_ACTUATOR3 0x0E +#define DA7280_CALIB_V2I_H 0x0F +#define DA7280_CALIB_V2I_L 0x10 +#define DA7280_CALIB_IMP_H 0x11 +#define DA7280_CALIB_IMP_L 0x12 +#define DA7280_TOP_CFG1 0x13 +#define DA7280_TOP_CFG2 0x14 +#define DA7280_TOP_CFG3 0x15 +#define DA7280_TOP_CFG4 0x16 +#define DA7280_TOP_INT_CFG1 0x17 +#define DA7280_TOP_INT_CFG6_H 0x1C +#define DA7280_TOP_INT_CFG6_L 0x1D +#define DA7280_TOP_INT_CFG7_H 0x1E +#define DA7280_TOP_INT_CFG7_L 0x1F +#define DA7280_TOP_INT_CFG8 0x20 +#define DA7280_TOP_CTL1 0x22 +#define DA7280_TOP_CTL2 0x23 +#define DA7280_SEQ_CTL1 0x24 +#define DA7280_SWG_C1 0x25 +#define DA7280_SWG_C2 0x26 +#define DA7280_SWG_C3 0x27 +#define DA7280_SEQ_CTL2 0x28 +#define DA7280_GPI_0_CTL 0x29 +#define DA7280_GPI_1_CTL 0x2A +#define DA7280_GPI_2_CTL 0x2B +#define DA7280_MEM_CTL1 0x2C +#define DA7280_MEM_CTL2 0x2D +#define DA7280_ADC_DATA_H1 0x2E +#define DA7280_ADC_DATA_L1 0x2F +#define DA7280_POLARITY 0x43 +#define DA7280_LRA_AVR_H 0x44 +#define DA7280_LRA_AVR_L 0x45 +#define DA7280_FRQ_LRA_PER_ACT_H 0x46 +#define DA7280_FRQ_LRA_PER_ACT_L 0x47 +#define DA7280_FRQ_PHASE_H 0x48 +#define DA7280_FRQ_PHASE_L 0x49 +#define DA7280_FRQ_CTL 0x4C +#define DA7280_TRIM3 0x5F +#define DA7280_TRIM4 0x60 +#define DA7280_TRIM6 0x62 +#define DA7280_TOP_CFG5 0x6E +#define DA7280_IRQ_EVENT_ACTUATOR_FAULT 0x81 +#define DA7280_IRQ_STATUS2 0x82 +#define DA7280_IRQ_MASK2 0x83 +#define DA7280_SNP_MEM_0 0x84 +#define DA7280_SNP_MEM_99 0xE7 + +/* DA7280_CHIP_REV (Address 0x00) */ +#define DA7280_CHIP_REV_MAJOR_SHIFT 0 +#define DA7280_CHIP_REV_MAJOR_MASK (15 << 0) +#define DA7280_CHIP_REV_MINOR_SHIFT 4 +#define DA7280_CHIP_REV_MINOR_MASK (15 << 4) + +/* DA7280_IRQ_EVENT1 (Address 0x03) */ +#define DA7280_E_SEQ_CONTINUE_SHIFT 0 +#define DA7280_E_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_E_UVLO_SHIFT 1 +#define DA7280_E_UVLO_MASK BIT(1) +#define DA7280_E_SEQ_DONE_SHIFT 2 +#define DA7280_E_SEQ_DONE_MASK BIT(2) +#define DA7280_E_OVERTEMP_CRIT_SHIFT 3 +#define DA7280_E_OVERTEMP_CRIT_MASK BIT(3) +#define DA7280_E_SEQ_FAULT_SHIFT 4 +#define DA7280_E_SEQ_FAULT_MASK BIT(4) +#define DA7280_E_WARNING_SHIFT 5 +#define DA7280_E_WARNING_MASK BIT(5) +#define DA7280_E_ACTUATOR_FAULT_SHIFT 6 +#define DA7280_E_ACTUATOR_FAULT_MASK BIT(6) +#define DA7280_E_OC_FAULT_SHIFT 7 +#define DA7280_E_OC_FAULT_MASK BIT(7) + +/* DA7280_IRQ_EVENT_WARNING_DIAG (Address 0x04) */ +#define DA7280_E_OVERTEMP_WARN_SHIFT 3 +#define DA7280_E_OVERTEMP_WARN_MASK BIT(3) +#define DA7280_E_MEM_TYPE_SHIFT 4 +#define DA7280_E_MEM_TYPE_MASK BIT(4) +#define DA7280_E_LIM_DRIVE_ACC_SHIFT 6 +#define DA7280_E_LIM_DRIVE_ACC_MASK BIT(6) +#define DA7280_E_LIM_DRIVE_SHIFT 7 +#define DA7280_E_LIM_DRIVE_MASK BIT(7) + +/* DA7280_IRQ_EVENT_PAT_DIAG (Address 0x05) */ +#define DA7280_E_PWM_FAULT_SHIFT 5 +#define DA7280_E_PWM_FAULT_MASK BIT(5) +#define DA7280_E_MEM_FAULT_SHIFT 6 +#define DA7280_E_MEM_FAULT_MASK BIT(6) +#define DA7280_E_SEQ_ID_FAULT_SHIFT 7 +#define DA7280_E_SEQ_ID_FAULT_MASK BIT(7) + +/* DA7280_IRQ_STATUS1 (Address 0x06) */ +#define DA7280_STA_SEQ_CONTINUE_SHIFT 0 +#define DA7280_STA_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_STA_UVLO_VBAT_OK_SHIFT 1 +#define DA7280_STA_UVLO_VBAT_OK_MASK BIT(1) +#define DA7280_STA_SEQ_DONE_SHIFT 2 +#define DA7280_STA_SEQ_DONE_MASK BIT(2) +#define DA7280_STA_OVERTEMP_CRIT_SHIFT 3 +#define DA7280_STA_OVERTEMP_CRIT_MASK BIT(3) +#define DA7280_STA_SEQ_FAULT_SHIFT 4 +#define DA7280_STA_SEQ_FAULT_MASK BIT(4) +#define DA7280_STA_WARNING_SHIFT 5 +#define DA7280_STA_WARNING_MASK BIT(5) +#define DA7280_STA_ACTUATOR_SHIFT 6 +#define DA7280_STA_ACTUATOR_MASK BIT(6) +#define DA7280_STA_OC_SHIFT 7 +#define DA7280_STA_OC_MASK BIT(7) + +/* DA7280_IRQ_MASK1 (Address 0x07) */ +#define DA7280_SEQ_CONTINUE_M_SHIFT 0 +#define DA7280_SEQ_CONTINUE_M_MASK BIT(0) +#define DA7280_E_UVLO_M_SHIFT 1 +#define DA7280_E_UVLO_M_MASK BIT(1) +#define DA7280_SEQ_DONE_M_SHIFT 2 +#define DA7280_SEQ_DONE_M_MASK BIT(2) +#define DA7280_OVERTEMP_CRIT_M_SHIFT 3 +#define DA7280_OVERTEMP_CRIT_M_MASK BIT(3) +#define DA7280_SEQ_FAULT_M_SHIFT 4 +#define DA7280_SEQ_FAULT_M_MASK BIT(4) +#define DA7280_WARNING_M_SHIFT 5 +#define DA7280_WARNING_M_MASK BIT(5) +#define DA7280_ACTUATOR_M_SHIFT 6 +#define DA7280_ACTUATOR_M_MASK BIT(6) +#define DA7280_OC_M_SHIFT 7 +#define DA7280_OC_M_MASK BIT(7) + +/* DA7280_CIF_I2C1 (Address 0x08) */ +#define DA7280_I2C_TO_ENABLE_SHIFT 6 +#define DA7280_I2C_TO_ENABLE_MASK BIT(6) +#define DA7280_I2C_WR_MODE_SHIFT 7 +#define DA7280_I2C_WR_MODE_MASK BIT(7) + +/* DA7280_FRQ_LRA_PER_H (Address 0x0a) */ +#define DA7280_LRA_PER_H_SHIFT 0 +#define DA7280_LRA_PER_H_MASK (255 << 0) + +/* DA7280_FRQ_LRA_PER_L (Address 0x0b) */ +#define DA7280_LRA_PER_L_SHIFT 0 +#define DA7280_LRA_PER_L_MASK (127 << 0) + +/* DA7280_ACTUATOR1 (Address 0x0c) */ +#define DA7280_ACTUATOR_NOMMAX_SHIFT 0 +#define DA7280_ACTUATOR_NOMMAX_MASK (255 << 0) + +/* DA7280_ACTUATOR2 (Address 0x0d) */ +#define DA7280_ACTUATOR_ABSMAX_SHIFT 0 +#define DA7280_ACTUATOR_ABSMAX_MASK (255 << 0) + +/* DA7280_ACTUATOR3 (Address 0x0e) */ +#define DA7280_IMAX_SHIFT 0 +#define DA7280_IMAX_MASK (31 << 0) + +/* DA7280_CALIB_V2I_H (Address 0x0f) */ +#define DA7280_V2I_FACTOR_H_SHIFT 0 +#define DA7280_V2I_FACTOR_H_MASK (255 << 0) + +/* DA7280_CALIB_V2I_L (Address 0x10) */ +#define DA7280_V2I_FACTOR_L_SHIFT 0 +#define DA7280_V2I_FACTOR_L_MASK (255 << 0) + +/* DA7280_CALIB_IMP_H (Address 0x11) */ +#define DA7280_IMPEDANCE_H_SHIFT 0 +#define DA7280_IMPEDANCE_H_MASK (255 << 0) + +/* DA7280_CALIB_IMP_L (Address 0x12) */ +#define DA7280_IMPEDANCE_L_SHIFT 0 +#define DA7280_IMPEDANCE_L_MASK (3 << 0) + +/* DA7280_TOP_CFG1 (Address 0x13) */ +#define DA7280_AMP_PID_EN_SHIFT 0 +#define DA7280_AMP_PID_EN_MASK BIT(0) +#define DA7280_RAPID_STOP_EN_SHIFT 1 +#define DA7280_RAPID_STOP_EN_MASK BIT(1) +#define DA7280_ACCELERATION_EN_SHIFT 2 +#define DA7280_ACCELERATION_EN_MASK BIT(2) +#define DA7280_FREQ_TRACK_EN_SHIFT 3 +#define DA7280_FREQ_TRACK_EN_MASK BIT(3) +#define DA7280_BEMF_SENSE_EN_SHIFT 4 +#define DA7280_BEMF_SENSE_EN_MASK BIT(4) +#define DA7280_ACTUATOR_TYPE_SHIFT 5 +#define DA7280_ACTUATOR_TYPE_MASK BIT(5) +#define DA7280_EMBEDDED_MODE_SHIFT 7 +#define DA7280_EMBEDDED_MODE_MASK BIT(7) + +/* DA7280_TOP_CFG2 (Address 0x14) */ +#define DA7280_FULL_BRAKE_THR_SHIFT 0 +#define DA7280_FULL_BRAKE_THR_MASK (15 << 0) +#define DA7280_MEM_DATA_SIGNED_SHIFT 4 +#define DA7280_MEM_DATA_SIGNED_MASK BIT(4) + +/* DA7280_TOP_CFG3 (Address 0x15) */ +#define DA7280_VDD_MARGIN_SHIFT 0 +#define DA7280_VDD_MARGIN_MASK (15 << 0) + +/* DA7280_TOP_CFG4 (Address 0x16) */ +#define DA7280_TST_CALIB_IMPEDANCE_DIS_SHIFT 6 +#define DA7280_TST_CALIB_IMPEDANCE_DIS_MASK BIT(6) +#define DA7280_V2I_FACTOR_FREEZE_SHIFT 7 +#define DA7280_V2I_FACTOR_FREEZE_MASK BIT(7) + +/* DA7280_TOP_INT_CFG1 (Address 0x17) */ +#define DA7280_BEMF_FAULT_LIM_SHIFT 0 +#define DA7280_BEMF_FAULT_LIM_MASK (3 << 0) +#define DA7280_FRQ_LOCKED_LIM_SHIFT 2 +#define DA7280_FRQ_LOCKED_LIM_MASK (63 << 2) + +/* DA7280_TOP_INT_CFG6_H (Address 0x1c) */ +#define DA7280_FRQ_PID_KP_H_SHIFT 0 +#define DA7280_FRQ_PID_KP_H_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG6_L (Address 0x1d) */ +#define DA7280_FRQ_PID_KP_L_SHIFT 0 +#define DA7280_FRQ_PID_KP_L_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG7_H (Address 0x1e) */ +#define DA7280_FRQ_PID_KI_H_SHIFT 0 +#define DA7280_FRQ_PID_KI_H_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG7_L (Address 0x1f) */ +#define DA7280_FRQ_PID_KI_L_SHIFT 0 +#define DA7280_FRQ_PID_KI_L_MASK (255 << 0) + +/* DA7280_TOP_INT_CFG8 (Address 0x20) */ +#define DA7280_TST_FRQ_TRACK_BEMF_LIM_SHIFT 0 +#define DA7280_TST_FRQ_TRACK_BEMF_LIM_MASK (15 << 0) +#define DA7280_TST_AMP_RAPID_STOP_LIM_SHIFT 4 +#define DA7280_TST_AMP_RAPID_STOP_LIM_MASK (7 << 4) + +/* DA7280_TOP_CTL1 (Address 0x22) */ +#define DA7280_OPERATION_MODE_SHIFT 0 +#define DA7280_OPERATION_MODE_MASK (7 << 0) +#define DA7280_STANDBY_EN_SHIFT 3 +#define DA7280_STANDBY_EN_MASK BIT(3) +#define DA7280_SEQ_START_SHIFT 4 +#define DA7280_SEQ_START_MASK BIT(4) + +/* DA7280_TOP_CTL2 (Address 0x23) */ +#define DA7280_OVERRIDE_VAL_SHIFT 0 +#define DA7280_OVERRIDE_VAL_MASK (255 << 0) + +/* DA7280_SEQ_CTL1 (Address 0x24) */ +#define DA7280_SEQ_CONTINUE_SHIFT 0 +#define DA7280_SEQ_CONTINUE_MASK BIT(0) +#define DA7280_WAVEGEN_MODE_SHIFT 1 +#define DA7280_WAVEGEN_MODE_MASK BIT(1) +#define DA7280_FREQ_WAVEFORM_TIMEBASE_SHIFT 2 +#define DA7280_FREQ_WAVEFORM_TIMEBASE_MASK BIT(2) + +/* DA7280_SWG_C1 (Address 0x25) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF1_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF1_MASK (255 << 0) + +/* DA7280_SWG_C2 (Address 0x26) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF2_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF2_MASK (255 << 0) + +/* DA7280_SWG_C3 (Address 0x27) */ +#define DA7280_CUSTOM_WAVE_GEN_COEFF3_SHIFT 0 +#define DA7280_CUSTOM_WAVE_GEN_COEFF3_MASK (255 << 0) + +/* DA7280_SEQ_CTL2 (Address 0x28) */ +#define DA7280_PS_SEQ_ID_SHIFT 0 +#define DA7280_PS_SEQ_ID_MASK (15 << 0) +#define DA7280_PS_SEQ_LOOP_SHIFT 4 +#define DA7280_PS_SEQ_LOOP_MASK (15 << 4) + +/* DA7280_GPIO_0_CTL (Address 0x29) */ +#define DA7280_GPI0_POLARITY_SHIFT 0 +#define DA7280_GPI0_POLARITY_MASK (3 << 0) +#define DA7280_GPI0_MODE_SHIFT 2 +#define DA7280_GPI0_MODE_MASK BIT(2) +#define DA7280_GPI0_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI0_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_GPIO_1_CTL (Address 0x2a) */ +#define DA7280_GPI1_POLARITY_SHIFT 0 +#define DA7280_GPI1_POLARITY_MASK (3 << 0) +#define DA7280_GPI1_MODE_SHIFT 2 +#define DA7280_GPI1_MODE_MASK BIT(2) +#define DA7280_GPI1_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI1_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_GPIO_2_CTL (Address 0x2b) */ +#define DA7280_GPI2_POLARITY_SHIFT 0 +#define DA7280_GPI2_POLARITY_MASK (3 << 0) +#define DA7280_GPI2_MODE_SHIFT 2 +#define DA7280_GPI2_MODE_MASK BIT(2) +#define DA7280_GPI2_SEQUENCE_ID_SHIFT 3 +#define DA7280_GPI2_SEQUENCE_ID_MASK (15 << 3) + +/* DA7280_MEM_CTL1 (Address 0x2c) */ +#define DA7280_WAV_MEM_BASE_ADDR_SHIFT 0 +#define DA7280_WAV_MEM_BASE_ADDR_MASK (255 << 0) + +/* DA7280_MEM_CTL2 (Address 0x2d) */ +#define DA7280_WAV_MEM_LOCK_SHIFT 7 +#define DA7280_WAV_MEM_LOCK_MASK BIT(7) + +/* DA7280_ADC_DATA_H1 (Address 0x2e) */ +#define DA7280_ADC_VDD_H_SHIFT 0 +#define DA7280_ADC_VDD_H_MASK (255 << 0) + +/* DA7280_ADC_DATA_L1 (Address 0x2f) */ +#define DA7280_ADC_VDD_L_SHIFT 0 +#define DA7280_ADC_VDD_L_MASK (127 << 0) + +/* DA7280_POLARITY (Address 0x43) */ +#define DA7280_POLARITY_SHIFT 0 +#define DA7280_POLARITY_MASK BIT(0) + +/* DA7280_LRA_AVR_H (Address 0x44) */ +#define DA7280_LRA_PER_AVERAGE_H_SHIFT 0 +#define DA7280_LRA_PER_AVERAGE_H_MASK (255 << 0) + +/* DA7280_LRA_AVR_L (Address 0x45) */ +#define DA7280_LRA_PER_AVERAGE_L_SHIFT 0 +#define DA7280_LRA_PER_AVERAGE_L_MASK (127 << 0) + +/* DA7280_FRQ_LRA_PER_ACT_H (Address 0x46) */ +#define DA7280_LRA_PER_ACTUAL_H_SHIFT 0 +#define DA7280_LRA_PER_ACTUAL_H_MASK (255 << 0) + +/* DA7280_FRQ_LRA_PER_ACT_L (Address 0x47) */ +#define DA7280_LRA_PER_ACTUAL_L_SHIFT 0 +#define DA7280_LRA_PER_ACTUAL_L_MASK (127 << 0) + +/* DA7280_FRQ_PHASE_H (Address 0x48) */ +#define DA7280_PHASE_DELAY_H_SHIFT 0 +#define DA7280_PHASE_DELAY_H_MASK (255 << 0) + +/* DA7280_FRQ_PHASE_L (Address 0x49) */ +#define DA7280_DELAY_SHIFT_L_SHIFT 0 +#define DA7280_DELAY_SHIFT_L_MASK (7 << 0) +#define DA7280_DELAY_SHIFT_FREEZE_SHIFT 7 +#define DA7280_DELAY_SHIFT_FREEZE_MASK BIT(7) + +/* DA7280_FRQ_CTL (Address 0x4c) */ +#define DA7280_FREQ_TRACKING_FORCE_ON_SHIFT 0 +#define DA7280_FREQ_TRACKING_FORCE_ON_MASK BIT(0) +#define DA7280_FREQ_TRACKING_AUTO_ADJ_SHIFT 1 +#define DA7280_FREQ_TRACKING_AUTO_ADJ_MASK BIT(1) + +/* DA7280_TRIM3 (Address 0x5f) */ +#define DA7280_REF_UVLO_THRES_SHIFT 3 +#define DA7280_REF_UVLO_THRES_MASK (3 << 3) +#define DA7280_LOOP_FILT_LOW_BW_SHIFT 5 +#define DA7280_LOOP_FILT_LOW_BW_MASK BIT(5) +#define DA7280_LOOP_IDAC_DOUBLE_RANGE_SHIFT 6 +#define DA7280_LOOP_IDAC_DOUBLE_RANGE_MASK BIT(6) + +/* DA7280_TRIM4 (Address 0x60) */ +#define DA7280_LOOP_FILT_RES_TRIM_SHIFT 0 +#define DA7280_LOOP_FILT_RES_TRIM_MASK (3 << 0) +#define DA7280_LOOP_FILT_CAP_TRIM_SHIFT 2 +#define DA7280_LOOP_FILT_CAP_TRIM_MASK (3 << 2) + +/* DA7280_TRIM6 (Address 0x62) */ +#define DA7280_HBRIDGE_ERC_HS_TRIM_SHIFT 0 +#define DA7280_HBRIDGE_ERC_HS_TRIM_MASK (3 << 0) +#define DA7280_HBRIDGE_ERC_LS_TRIM_SHIFT 2 +#define DA7280_HBRIDGE_ERC_LS_TRIM_MASK (3 << 2) + +/* DA7280_TOP_CFG5 (Address 0x6e) */ +#define DA7280_V2I_FACTOR_OFFSET_EN_SHIFT 0 +#define DA7280_V2I_FACTOR_OFFSET_EN_MASK BIT(0) +#define DA7280_FRQ_PAUSE_ON_POLARITY_CHANGE_SHIFT 1 +#define DA7280_FRQ_PAUSE_ON_POLARITY_CHANGE_MASK BIT(1) +#define DA7280_DELAY_BYPASS_SHIFT 2 +#define DA7280_DELAY_BYPASS_MASK BIT(2) + +/* DA7280_IRQ_EVENT_ACTUATOR_FAULT (Address 0x81) */ +#define DA7280_ADC_SAT_FAULT_SHIFT 2 +#define DA7280_ADC_SAT_FAULT_MASK BIT(2) + +/* DA7280_IRQ_STATUS2 (Address 0x82) */ +#define DA7280_STA_ADC_SAT_SHIFT 7 +#define DA7280_STA_ADC_SAT_MASK BIT(7) + +/* DA7280_IRQ_MASK2 (Address 0x83) */ +#define DA7280_ADC_SAT_M_SHIFT 7 +#define DA7280_ADC_SAT_M_MASK BIT(7) + +/* DA7280_SNP_MEM_XX (Address 0x84 ~ 0xe7) */ +#define DA7280_SNP_MEM_SHIFT 0 +#define DA7280_SNP_MEM_MASK (255 << 0) + +#endif -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* Re: [PATCH V1 3/3] Input: new da7280 haptic driver 2018-08-16 2:02 ` Roy Im (?) @ 2018-08-16 6:46 ` kbuild test robot -1 siblings, 0 replies; 13+ messages in thread From: kbuild test robot @ 2018-08-16 6:46 UTC (permalink / raw) To: Roy Im Cc: kbuild-all, Dmitry Torokhov, Rob Herring, Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel Hi Roy, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on input/next] [also build test WARNING on v4.18 next-20180815] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Roy-Im/da7280-haptic-driver-submission/20180816-133626 base: https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next coccinelle warnings: (new ones prefixed by >>) >> drivers/input/misc/da7280.c:116:9-10: WARNING: return of 0/1 in function 'da7280_volatile_register' with return type bool -- >> drivers/input/misc/da7280.c:1335:7-32: ERROR: Threaded IRQ with no primary handler requested without IRQF_ONESHOT Please review and possibly fold the followup patch. --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH] Input: fix irqf_oneshot.cocci warnings 2018-08-16 2:02 ` Roy Im (?) (?) @ 2018-08-16 6:46 ` kbuild test robot -1 siblings, 0 replies; 13+ messages in thread From: kbuild test robot @ 2018-08-16 6:46 UTC (permalink / raw) To: Roy Im Cc: kbuild-all, Dmitry Torokhov, Rob Herring, Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: kbuild test robot <fengguang.wu@intel.com> drivers/input/misc/da7280.c:1335:7-32: ERROR: Threaded IRQ with no primary handler requested without IRQF_ONESHOT Since commit 1c6c69525b40 ("genirq: Reject bogus threaded irq requests") threaded IRQs without a primary handler need to be requested with IRQF_ONESHOT, otherwise the request will fail. So pass the IRQF_ONESHOT flag in this case. Generated by: scripts/coccinelle/misc/irqf_oneshot.cocci Fixes: a067f5d53e35 ("Input: new da7280 haptic driver") CC: Roy Im <roy.im.opensource@diasemi.com> Signed-off-by: kbuild test robot <fengguang.wu@intel.com> --- Please take the patch only if it's a positive warning. Thanks! da7280.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) --- a/drivers/input/misc/da7280.c +++ b/drivers/input/misc/da7280.c @@ -1334,7 +1334,7 @@ static int da7280_probe(struct i2c_clien ret = devm_request_threaded_irq(dev, client->irq, NULL, da7280_irq_handler, - DA7280_IRQ_FLAGS, + DA7280_IRQ_FLAGS | IRQF_ONESHOT, "da7280-haptics", haptics); if (ret != 0) { dev_err(dev, ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH] Input: fix boolreturn.cocci warnings 2018-08-16 2:02 ` Roy Im ` (2 preceding siblings ...) (?) @ 2018-08-16 6:46 ` kbuild test robot -1 siblings, 0 replies; 13+ messages in thread From: kbuild test robot @ 2018-08-16 6:46 UTC (permalink / raw) To: Roy Im Cc: kbuild-all, Dmitry Torokhov, Rob Herring, Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: kbuild test robot <fengguang.wu@intel.com> drivers/input/misc/da7280.c:116:9-10: WARNING: return of 0/1 in function 'da7280_volatile_register' with return type bool Return statements in functions returning bool should use true/false instead of 1/0. Generated by: scripts/coccinelle/misc/boolreturn.cocci Fixes: a067f5d53e35 ("Input: new da7280 haptic driver") CC: Roy Im <roy.im.opensource@diasemi.com> Signed-off-by: kbuild test robot <fengguang.wu@intel.com> --- da7280.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) --- a/drivers/input/misc/da7280.c +++ b/drivers/input/misc/da7280.c @@ -113,9 +113,9 @@ static bool da7280_volatile_register(str case DA7280_IRQ_EVENT_SEQ_DIAG: case DA7280_IRQ_STATUS1: case DA7280_TOP_CTL1: - return 1; + return true; default: - return 0; + return false; } } ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH V1 1/3] MAINTAINERS: da7280 updates to the Dialog Semiconductor search terms 2018-08-16 2:02 ` Roy Im @ 2018-08-16 2:02 ` Roy Im -1 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: Roy Im <roy.im.opensource@diasemi.com> This patch adds the da7280 bindings doc and driver to the Dialog Semiconductor support list. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 544cac8..720f9fe 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4221,6 +4221,7 @@ S: Supported F: Documentation/hwmon/da90?? F: Documentation/devicetree/bindings/mfd/da90*.txt F: Documentation/devicetree/bindings/input/da90??-onkey.txt +F: Documentation/devicetree/bindings/input/dlg,da72??.txt F: Documentation/devicetree/bindings/thermal/da90??-thermal.txt F: Documentation/devicetree/bindings/regulator/da92*.txt F: Documentation/devicetree/bindings/watchdog/da90??-wdt.txt @@ -4229,6 +4230,7 @@ F: drivers/gpio/gpio-da90??.c F: drivers/hwmon/da90??-hwmon.c F: drivers/iio/adc/da91??-*.c F: drivers/input/misc/da90??_onkey.c +F: drivers/input/misc/da72??.[ch] F: drivers/input/touchscreen/da9052_tsi.c F: drivers/leds/leds-da90??.c F: drivers/mfd/da903x.c -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* [PATCH V1 1/3] MAINTAINERS: da7280 updates to the Dialog Semiconductor search terms @ 2018-08-16 2:02 ` Roy Im 0 siblings, 0 replies; 13+ messages in thread From: Roy Im @ 2018-08-16 2:02 UTC (permalink / raw) To: Dmitry Torokhov, Rob Herring Cc: Mark Rutland, Support Opensource, devicetree, linux-input, linux-kernel From: Roy Im <roy.im.opensource@diasemi.com> This patch adds the da7280 bindings doc and driver to the Dialog Semiconductor support list. Signed-off-by: Roy Im <roy.im.opensource@diasemi.com> --- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 544cac8..720f9fe 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4221,6 +4221,7 @@ S: Supported F: Documentation/hwmon/da90?? F: Documentation/devicetree/bindings/mfd/da90*.txt F: Documentation/devicetree/bindings/input/da90??-onkey.txt +F: Documentation/devicetree/bindings/input/dlg,da72??.txt F: Documentation/devicetree/bindings/thermal/da90??-thermal.txt F: Documentation/devicetree/bindings/regulator/da92*.txt F: Documentation/devicetree/bindings/watchdog/da90??-wdt.txt @@ -4229,6 +4230,7 @@ F: drivers/gpio/gpio-da90??.c F: drivers/hwmon/da90??-hwmon.c F: drivers/iio/adc/da91??-*.c F: drivers/input/misc/da90??_onkey.c +F: drivers/input/misc/da72??.[ch] F: drivers/input/touchscreen/da9052_tsi.c F: drivers/leds/leds-da90??.c F: drivers/mfd/da903x.c -- end-of-patch for PATCH V1 ^ permalink raw reply related [flat|nested] 13+ messages in thread
* Re: [PATCH v3 2/2] Input: add support for Azoteq IQS7222A/B/C
@ 2022-04-05 10:56 kernel test robot
2022-04-05 10:54 ` [PATCH] Input: fix irqf_oneshot.cocci warnings kernel test robot
0 siblings, 1 reply; 13+ messages in thread
From: kernel test robot @ 2022-04-05 10:56 UTC (permalink / raw)
To: kbuild
[-- Attachment #1: Type: text/plain, Size: 1661 bytes --]
CC: kbuild-all(a)lists.01.org
BCC: lkp(a)intel.com
In-Reply-To: <20220403221659.865997-3-jeff@labundy.com>
References: <20220403221659.865997-3-jeff@labundy.com>
TO: Jeff LaBundy <jeff@labundy.com>
TO: dmitry.torokhov(a)gmail.com
TO: robh+dt(a)kernel.org
CC: linux-input(a)vger.kernel.org
CC: devicetree(a)vger.kernel.org
CC: Jeff LaBundy <jeff@labundy.com>
Hi Jeff,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on dtor-input/next]
[also build test WARNING on robh/for-next hid/for-next v5.18-rc1 next-20220405]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/intel-lab-lkp/linux/commits/Jeff-LaBundy/Add-support-for-Azoteq-IQS7222A-B-C/20220404-061950
base: https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
:::::: branch date: 2 days ago
:::::: commit date: 2 days ago
config: ia64-randconfig-c003-20220405 (https://download.01.org/0day-ci/archive/20220405/202204051838.6Uj66mbG-lkp(a)intel.com/config)
compiler: ia64-linux-gcc (GCC) 11.2.0
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
Reported-by: Julia Lawall <julia.lawall@lip6.fr>
cocci warnings: (new ones prefixed by >>)
>> drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ)
Please review and possibly fold the followup patch.
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH] Input: fix irqf_oneshot.cocci warnings 2022-04-05 10:56 [PATCH v3 2/2] Input: add support for Azoteq IQS7222A/B/C kernel test robot @ 2022-04-05 10:54 ` kernel test robot 0 siblings, 0 replies; 13+ messages in thread From: kernel test robot @ 2022-04-05 10:54 UTC (permalink / raw) To: kbuild [-- Attachment #1: Type: text/plain, Size: 1862 bytes --] CC: kbuild-all(a)lists.01.org BCC: lkp(a)intel.com In-Reply-To: <20220403221659.865997-3-jeff@labundy.com> References: <20220403221659.865997-3-jeff@labundy.com> TO: Jeff LaBundy <jeff@labundy.com> TO: dmitry.torokhov(a)gmail.com TO: robh+dt(a)kernel.org CC: linux-input(a)vger.kernel.org CC: devicetree(a)vger.kernel.org CC: Jeff LaBundy <jeff@labundy.com> From: kernel test robot <lkp@intel.com> drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ) Since commit 1c6c69525b40 ("genirq: Reject bogus threaded irq requests") threaded IRQs without a primary handler need to be requested with IRQF_ONESHOT, otherwise the request will fail. So pass the IRQF_ONESHOT flag in this case. Generated by: scripts/coccinelle/misc/irqf_oneshot.cocci CC: Jeff LaBundy <jeff@labundy.com> Reported-by: kernel test robot <lkp@intel.com> Signed-off-by: kernel test robot <lkp@intel.com> --- url: https://github.com/intel-lab-lkp/linux/commits/Jeff-LaBundy/Add-support-for-Azoteq-IQS7222A-B-C/20220404-061950 base: https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next :::::: branch date: 2 days ago :::::: commit date: 2 days ago Please take the patch only if it's a positive warning. Thanks! drivers/input/misc/iqs7222.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) --- a/drivers/input/misc/iqs7222.c +++ b/drivers/input/misc/iqs7222.c @@ -2416,7 +2416,8 @@ static int iqs7222_probe(struct i2c_clie irq_flags |= IRQF_ONESHOT; error = devm_request_threaded_irq(&client->dev, irq, NULL, iqs7222_irq, - irq_flags, client->name, iqs7222); + irq_flags | IRQF_ONESHOT, + client->name, iqs7222); if (error) dev_err(&client->dev, "Failed to request IRQ: %d\n", error); ^ permalink raw reply [flat|nested] 13+ messages in thread
* [linux-next:master 2115/14198] drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ)
@ 2022-05-28 7:52 kernel test robot
2022-05-28 7:48 ` [PATCH] Input: fix irqf_oneshot.cocci warnings kernel test robot
0 siblings, 1 reply; 13+ messages in thread
From: kernel test robot @ 2022-05-28 7:52 UTC (permalink / raw)
To: kbuild
[-- Attachment #1: Type: text/plain, Size: 1134 bytes --]
CC: kbuild-all(a)lists.01.org
BCC: lkp(a)intel.com
CC: Linux Memory Management List <linux-mm@kvack.org>
TO: Jeff LaBundy <jeff@labundy.com>
CC: Dmitry Torokhov <dmitry.torokhov@gmail.com>
tree: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master
head: d3fde8ff50ab265749704bd7fbcf70d35235421f
commit: e505edaedcb9e7d16eefddc62d2189afaea0febc [2115/14198] Input: add support for Azoteq IQS7222A/B/C
:::::: branch date: 25 hours ago
:::::: commit date: 7 weeks ago
config: mips-allyesconfig (https://download.01.org/0day-ci/archive/20220528/202205281555.7oEwEjIQ-lkp(a)intel.com/config)
compiler: mips-linux-gcc (GCC) 11.3.0
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp@intel.com>
Reported-by: Julia Lawall <julia.lawall@lip6.fr>
cocci warnings: (new ones prefixed by >>)
>> drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ)
Please review and possibly fold the followup patch.
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] 13+ messages in thread* [PATCH] Input: fix irqf_oneshot.cocci warnings 2022-05-28 7:52 [linux-next:master 2115/14198] drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ) kernel test robot @ 2022-05-28 7:48 ` kernel test robot 0 siblings, 0 replies; 13+ messages in thread From: kernel test robot @ 2022-05-28 7:48 UTC (permalink / raw) To: kbuild [-- Attachment #1: Type: text/plain, Size: 1804 bytes --] CC: kbuild-all(a)lists.01.org BCC: lkp(a)intel.com CC: Linux Memory Management List <linux-mm@kvack.org> TO: Jeff LaBundy <jeff@labundy.com> CC: Dmitry Torokhov <dmitry.torokhov@gmail.com> CC: linux-input(a)vger.kernel.org CC: linux-kernel(a)vger.kernel.org From: kernel test robot <lkp@intel.com> drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ) Since commit 1c6c69525b40 ("genirq: Reject bogus threaded irq requests") threaded IRQs without a primary handler need to be requested with IRQF_ONESHOT, otherwise the request will fail. So pass the IRQF_ONESHOT flag in this case. Generated by: scripts/coccinelle/misc/irqf_oneshot.cocci CC: Jeff LaBundy <jeff@labundy.com> Reported-by: kernel test robot <lkp@intel.com> Signed-off-by: kernel test robot <lkp@intel.com> --- tree: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master head: d3fde8ff50ab265749704bd7fbcf70d35235421f commit: e505edaedcb9e7d16eefddc62d2189afaea0febc [2115/14198] Input: add support for Azoteq IQS7222A/B/C :::::: branch date: 25 hours ago :::::: commit date: 7 weeks ago Please take the patch only if it's a positive warning. Thanks! drivers/input/misc/iqs7222.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) --- a/drivers/input/misc/iqs7222.c +++ b/drivers/input/misc/iqs7222.c @@ -2416,7 +2416,8 @@ static int iqs7222_probe(struct i2c_clie irq_flags |= IRQF_ONESHOT; error = devm_request_threaded_irq(&client->dev, irq, NULL, iqs7222_irq, - irq_flags, client->name, iqs7222); + irq_flags | IRQF_ONESHOT, + client->name, iqs7222); if (error) dev_err(&client->dev, "Failed to request IRQ: %d\n", error); ^ permalink raw reply [flat|nested] 13+ messages in thread
end of thread, other threads:[~2022-05-28 7:48 UTC | newest] Thread overview: 13+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2018-08-16 2:02 [PATCH V1 0/3] da7280: haptic driver submission Roy Im 2018-08-16 2:02 ` Roy Im 2018-08-16 2:02 ` [PATCH V1 2/3] Documentation: devicetree: input: new binding for da7280 Roy Im 2018-08-16 2:02 ` Roy Im 2018-08-16 2:02 ` [PATCH V1 3/3] Input: new da7280 haptic driver Roy Im 2018-08-16 2:02 ` Roy Im 2018-08-16 6:46 ` kbuild test robot 2018-08-16 6:46 ` [PATCH] Input: fix irqf_oneshot.cocci warnings kbuild test robot 2018-08-16 6:46 ` [PATCH] Input: fix boolreturn.cocci warnings kbuild test robot 2018-08-16 2:02 ` [PATCH V1 1/3] MAINTAINERS: da7280 updates to the Dialog Semiconductor search terms Roy Im 2018-08-16 2:02 ` Roy Im -- strict thread matches above, loose matches on Subject: below -- 2022-04-05 10:56 [PATCH v3 2/2] Input: add support for Azoteq IQS7222A/B/C kernel test robot 2022-04-05 10:54 ` [PATCH] Input: fix irqf_oneshot.cocci warnings kernel test robot 2022-05-28 7:52 [linux-next:master 2115/14198] drivers/input/misc/iqs7222.c:2418:9-34: WARNING: Threaded IRQ with no primary handler requested without IRQF_ONESHOT (unless it is nested IRQ) kernel test robot 2022-05-28 7:48 ` [PATCH] Input: fix irqf_oneshot.cocci warnings kernel test robot
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.