--- v20
+++ v12
@@ -2,32 +2,9 @@
multiple mode and integrated waveform memory and wideband support.
It communicates via an I2C bus to the device.
-Reviewed-by: Jes Sorensen <Jes.Sorensen@gmail.com>.
-
Signed-off-by: Roy Im <roy.im.opensource@diasemi.com>
---
-v20:
- - Simplified the code with dev_err_probe().
- - Removed some work queues.
-v19:
- - Corrected some errors and replaced some code to proper one.
- - Improved work queues and removed sysfs attributes
- - Added changes for gpix id in upload effect.
-v18:
- - Corrected comments in Kconfig
- - Updated to preferred style for multi line comments in c file.
-v17:
- - fixed an issue.
-v16:
- - Corrected some code and updated description in Kconfig.
-v15:
- - Removed some defines and updated some comments.
-v14:
- - Updated pwm related code, alignments and comments.
-v13:
- - Updated some conditions in pwm function and alignments.
-v12: No changes.
v11:
- Updated the pwm related code, comments and typo.
v10:
@@ -50,35 +27,36 @@
v2: Fixed kbuild error/warning
- drivers/input/misc/Kconfig | 12 +
+ drivers/input/misc/Kconfig | 13 +
drivers/input/misc/Makefile | 1 +
- drivers/input/misc/da7280.c | 1375 +++++++++++++++++++++++++++++++++++++++++++
- 3 files changed, 1388 insertions(+)
+ drivers/input/misc/da7280.c | 1898 +++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 1912 insertions(+)
create mode 100644 drivers/input/misc/da7280.c
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
-index 362e8a0..d38b466 100644
+index 7e2e658..e2bf442 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
-@@ -869,4 +869,16 @@ config INPUT_STPMIC1_ONKEY
+@@ -879,4 +879,17 @@ config INPUT_STPMIC1_ONKEY
To compile this driver as a module, choose M here: the
module will be called stpmic1_onkey.
+config INPUT_DA7280_HAPTICS
+ tristate "Dialog Semiconductor DA7280 haptics support"
+ depends on INPUT && I2C
++ select INPUT_FF_MEMLESS
+ select REGMAP_I2C
+ help
+ Say Y to enable support for the Dialog DA7280 haptics driver.
-+ The haptics can be controlled by PWM or GPIO
-+ with I2C communication.
++ The haptics can be controlled by i2c communication,
++ or by PWM input, or by GPI.
+
+ To compile this driver as a module, choose M here: the
+ module will be called da7280.
+
endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
-index a48e5f2..9cfd6ab 100644
+index 8fd187f..71dc381 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_INPUT_CMA3000) += cma3000_d0x.o
@@ -91,10 +69,10 @@
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..21d4d37
+index 0000000..2dd76d2
--- /dev/null
+++ b/drivers/input/misc/da7280.c
-@@ -0,0 +1,1375 @@
+@@ -0,0 +1,1898 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * DA7280 Haptic device driver
@@ -113,7 +91,6 @@
+#include <linux/workqueue.h>
+#include <linux/uaccess.h>
+#include <linux/bitops.h>
-+#include <linux/bitfield.h>
+
+/* Registers */
+#define DA7280_IRQ_EVENT1 0x03
@@ -147,91 +124,137 @@
+/* Register field */
+
+/* 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_ACTUATOR3 (Address 0x0e) */
-+#define DA7280_IMAX_MASK GENMASK(4, 0)
++#define DA7280_IMAX_MASK (31 << 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)
+
+/* DA7280_TOP_CFG2 (Address 0x14) */
-+#define DA7280_FULL_BRAKE_THR_MASK GENMASK(3, 0)
++#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_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_MASK GENMASK(1, 0)
++#define DA7280_BEMF_FAULT_LIM_SHIFT 0
++#define DA7280_BEMF_FAULT_LIM_MASK (3 << 0)
+
+/* DA7280_TOP_CTL1 (Address 0x22) */
-+#define DA7280_OPERATION_MODE_MASK GENMASK(2, 0)
++#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_SEQ_CTL2 (Address 0x28) */
-+#define DA7280_PS_SEQ_ID_MASK GENMASK(3, 0)
-+#define DA7280_PS_SEQ_LOOP_MASK GENMASK(7, 4)
++#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_MASK GENMASK(1, 0)
-+#define DA7280_GPI0_MODE_MASK BIT(2)
-+#define DA7280_GPI0_SEQUENCE_ID_MASK GENMASK(6, 3)
++#define DA7280_GPI0_POLARITY_SHIFT 0
++#define DA7280_GPI0_MODE_SHIFT 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_MASK GENMASK(1, 0)
-+#define DA7280_GPI1_MODE_MASK BIT(2)
-+#define DA7280_GPI1_SEQUENCE_ID_MASK GENMASK(6, 3)
++#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_MASK GENMASK(1, 0)
-+#define DA7280_GPI2_MODE_MASK BIT(2)
-+#define DA7280_GPI2_SEQUENCE_ID_MASK GENMASK(6, 3)
++#define DA7280_GPI2_SEQUENCE_ID_SHIFT 3
++#define DA7280_GPI2_SEQUENCE_ID_MASK (15 << 3)
+
+/* DA7280_MEM_CTL2 (Address 0x2d) */
+#define DA7280_WAV_MEM_LOCK_MASK BIT(7)
@@ -260,11 +283,12 @@
+#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_GPI_SEQ_ID_DFT 0
-+#define DA7280_GPI_SEQ_ID_MAX 2
++#define DA7280_GPI_SEQ_ID_DFT 0x0
+
+#define DA7280_SNP_MEM_SIZE 100
+#define DA7280_SNP_MEM_MAX DA7280_SNP_MEM_99
@@ -303,15 +327,9 @@
+#define DA7280_FF_CONSTANT_MODE DA7280_DRO_MODE
+
+enum da7280_custom_effect_param {
-+ DA7280_CUSTOM_SEQ_ID_IDX = 0,
-+ DA7280_CUSTOM_SEQ_LOOP_IDX = 1,
-+ DA7280_CUSTOM_DATA_LEN = 2,
-+};
-+
-+enum da7280_custom_gpi_effect_param {
-+ DA7280_CUSTOM_GPI_SEQ_ID_IDX = 0,
-+ DA7280_CUSTOM_GPI_NUM_IDX = 2,
-+ DA7280_CUSTOM_GP_DATA_LEN = 3,
++ DA7280_CUSTOM_DATA_SEQ_ID_IDX = 0,
++ DA7280_CUSTOM_DATA_SEQ_LOOP_IDX = 1,
++ DA7280_CUSTOM_DATA_LEN = 2,
+};
+
+struct da7280_gpi_ctl {
@@ -328,9 +346,13 @@
+ struct pwm_device *pwm_dev;
+
+ bool legacy;
-+ struct work_struct work;
++ struct delayed_work work_duration;
++ struct work_struct work_playback;
++ struct work_struct work_setgain;
+ int val;
+ u16 gain;
++ u16 new_gain;
++
+ s16 level;
+
+ u8 dev_type;
@@ -354,6 +376,7 @@
+ bool mem_update;
+ u8 snp_mem[DA7280_SNP_MEM_SIZE];
+ u8 enabled;
++ int length_ms;
+};
+
+static bool da7280_volatile_register(struct device *dev, unsigned int reg)
@@ -379,10 +402,12 @@
+
+static int da7280_haptic_mem_update(struct da7280_haptic *haptics)
+{
++ int error;
+ unsigned int val;
-+ int error;
-+
-+ /* The patterns should be updated when haptic is not working */
++
++ /* It is recommended to update the patterns
++ * during haptic is not working in order to avoid conflict
++ */
+ error = regmap_read(haptics->regmap, DA7280_IRQ_STATUS1, &val);
+ if (error)
+ return error;
@@ -425,20 +450,19 @@
+ u64 period_mag_multi;
+ int error;
+
-+ if (!haptics->gain && enabled) {
++ if (!haptics->gain) {
+ dev_err(haptics->dev,
-+ "Please set the proper gain first\n");
++ "Please set the gain first for the pwm mode\n");
+ return -EINVAL;
+ }
+
+ pwm_get_state(haptics->pwm_dev, &state);
+ state.enabled = enabled;
+ if (enabled) {
-+ period_mag_multi = (u64)state.period * haptics->gain;
++ period_mag_multi = state.period * haptics->gain;
+ period_mag_multi >>= MAX_MAGNITUDE_SHIFT;
+
-+ /*
-+ * The interpretation of duty cycle depends on the acc_en,
++ /* The interpretation of duty cycle depends on the acc_en,
+ * it should be between 50% and 100% for acc_en = 0.
+ * See datasheet 'PWM mode' section.
+ */
@@ -452,7 +476,8 @@
+
+ error = pwm_apply_state(haptics->pwm_dev, &state);
+ if (error)
-+ dev_err(haptics->dev, "Failed to apply pwm state: %pe\n",
++ dev_err(haptics->dev,
++ "failed to apply pwm state: %pE\n",
+ ERR_PTR(error));
+
+ return error;
@@ -473,14 +498,16 @@
+ else if (haptics->level > 0xFF)
+ haptics->level = 0xFF;
+
-+ /* Set level as a % of ACTUATOR_NOMMAX(nommax) */
++ /* Set driver level
++ * as a % of ACTUATOR_NOMMAX(nommax)
++ */
+ error = regmap_write(haptics->regmap,
+ DA7280_TOP_CTL2,
+ haptics->level);
+ if (error) {
+ dev_err(haptics->dev,
-+ "i2c err (%d) for driving level (%d)\n",
-+ error, haptics->level);
++ "i2c err %pE for driving level (%d)\n",
++ ERR_PTR(error), haptics->level);
+ return;
+ }
+ break;
@@ -489,13 +516,11 @@
+ return;
+ break;
+ case DA7280_RTWM_MODE:
-+ /*
-+ * The pattern will be played by
++ /* The pattern will be played by
+ * the PS_SEQ_ID and the PS_SEQ_LOOP
+ */
+ case DA7280_ETWM_MODE:
-+ /*
-+ * The pattern will be played by
++ /* The pattern will be played by
+ * the GPI[N] state, GPI(N)_SEQUENCE_ID
+ * and the PS_SEQ_LOOP.
+ * please see the datasheet for the details.
@@ -513,7 +538,8 @@
+ haptics->op_mode);
+ if (error) {
+ dev_err(haptics->dev,
-+ "op_mode i2c err: %d\n", error);
++ "i2c err for op_mode setting : %pE\n",
++ ERR_PTR(error));
+ return;
+ }
+
@@ -525,13 +551,16 @@
+ DA7280_SEQ_START_MASK);
+ if (error) {
+ dev_err(haptics->dev,
-+ "i2c err for sequence triggering: %d\n",
-+ error);
++ "i2c err for sequence triggering : %pE\n",
++ ERR_PTR(error));
+ return;
+ }
+ }
+
+ haptics->enabled = true;
++ if (haptics->length_ms && haptics->op_mode <= DA7280_PWM_MODE)
++ schedule_delayed_work(&haptics->work_duration,
++ msecs_to_jiffies(haptics->length_ms));
+}
+
+static void da7280_haptic_disable(struct da7280_haptic *haptics)
@@ -547,7 +576,7 @@
+ DA7280_OPERATION_MODE_MASK, 0);
+ if (error) {
+ dev_err(haptics->dev,
-+ "i2c err for op_mode off: %d\n", error);
++ "i2c err for op_mode off : %pE\n", ERR_PTR(error));
+ return;
+ }
+
@@ -557,8 +586,8 @@
+ DA7280_TOP_CTL2, 0);
+ if (error) {
+ dev_err(haptics->dev,
-+ "i2c err for DRO mode off: %d\n",
-+ error);
++ "i2c err for DRO mode off : %pE\n",
++ ERR_PTR(error));
+ return;
+ }
+ break;
@@ -573,24 +602,32 @@
+ DA7280_SEQ_START_MASK, 0);
+ if (error) {
+ dev_err(haptics->dev,
-+ "i2c err for RTWM or ETWM mode off: %d\n",
-+ error);
++ "i2c err for RTWM or ETWM mode off: %pE\n",
++ ERR_PTR(error));
+ return;
+ }
+ break;
+ default:
+ dev_err(haptics->dev,
-+ "Invalid op mode(%d)\n", haptics->op_mode);
++ "Invalid Mode(%d)\n", haptics->op_mode);
+ return;
+ }
+
+ haptics->enabled = false;
+}
+
-+static void da7280_haptic_work(struct work_struct *work)
++static void da7280_haptic_work_duration(struct work_struct *work)
+{
+ struct da7280_haptic *haptics =
-+ container_of(work, struct da7280_haptic, work);
++ container_of(work, struct da7280_haptic, work_duration.work);
++
++ da7280_haptic_disable(haptics);
++}
++
++static void da7280_haptic_work_playback(struct work_struct *work)
++{
++ struct da7280_haptic *haptics =
++ container_of(work, struct da7280_haptic, work_playback);
+ int val = haptics->val;
+
+ if (!!val)
@@ -599,24 +636,78 @@
+ da7280_haptic_disable(haptics);
+}
+
++static void da7280_haptic_work_setgain(struct work_struct *work)
++{
++ struct da7280_haptic *haptics =
++ container_of(work, struct da7280_haptic, work_setgain);
++ u16 gain = haptics->new_gain;
++ int error = 0;
++
++ if (gain == 0)
++ return;
++
++ /* DRO and PWM modes support set_gain feature
++ */
++ switch (haptics->op_mode) {
++ case DA7280_DRO_MODE:
++ if (haptics->acc_en == 1) {
++ haptics->level = (u8)(gain * 0x7F / 0x7fff);
++ } else if (haptics->acc_en == 0) {
++ haptics->level = (u8)(gain * 0xFF / 0x7fff);
++
++ if (gain <= 0x3FFF)
++ haptics->level = haptics->level + 0x80;
++ else if (gain > 0x3FFF)
++ haptics->level = haptics->level - 0x80;
++ } else {
++ dev_err(haptics->dev, "Invalid acc_en %d.\n",
++ haptics->acc_en);
++ }
++
++ /* Set driver level
++ * as a % of ACTUATOR_NOMMAX(nommax)
++ */
++ error = regmap_write(haptics->regmap,
++ DA7280_TOP_CTL2,
++ haptics->level);
++ if (error) {
++ dev_err(haptics->dev,
++ "i2c err for driving level set: %pE\n",
++ ERR_PTR(error));
++ return;
++ }
++ break;
++ case DA7280_PWM_MODE:
++ haptics->gain = gain;
++ if (haptics->enabled) {
++ if (da7280_haptic_set_pwm(haptics, true))
++ return;
++ }
++ break;
++ default:
++ dev_err(haptics->dev,
++ "Invalid Mode(%d). Change to DRM (Constant) mode.\n",
++ haptics->op_mode);
++ break;
++ }
++}
++
+static int da7280_haptics_upload_effect(struct input_dev *dev,
+ struct ff_effect *effect,
+ struct ff_effect *old)
+{
+ struct da7280_haptic *haptics = input_get_drvdata(dev);
++ int error;
++ int tmp, i;
++ unsigned int val;
+ s16 data[DA7280_SNP_MEM_SIZE] = {0,};
-+ unsigned int val;
-+ int tmp, i, num;
-+ int error;
-+
-+ /* The effect should be uploaded when haptic is not working */
-+ if (haptics->enabled)
-+ return -EBUSY;
+
+ switch (effect->type) {
+ /* DRO/PWM modes support this type */
+ case FF_CONSTANT:
+ haptics->op_mode = haptics->const_op_mode;
++ /* effect->replay.length should be ms base */
++ haptics->length_ms = effect->replay.length;
+ if (haptics->op_mode == DA7280_DRO_MODE) {
+ tmp = effect->u.constant.level * 254;
+ haptics->level = tmp / 0x7FFF;
@@ -637,16 +728,12 @@
+
+ /*
+ * Load the data and check the length.
-+ * the data will be patterns in this case: 4 < X <= 100,
++ * the data will be patterns in this case: 3 < X <= 100,
+ * and will be saved into the waveform memory inside DA728x.
-+ * If X = 2, the data will be PS_SEQ_ID and PS_SEQ_LOOP.
-+ * If X = 3, the 1st data will be GPIX_SEQUENCE_ID .
++ * If X = 2, the data will be PS_SEQ_ID and PS_SEQ_LOOP .
+ */
+ if (effect->u.periodic.custom_len == DA7280_CUSTOM_DATA_LEN)
-+ goto set_seq_id_loop;
-+
-+ if (effect->u.periodic.custom_len == DA7280_CUSTOM_GP_DATA_LEN)
-+ goto set_gpix_seq_id;
++ goto set_id_loop;
+
+ if (effect->u.periodic.custom_len < DA7280_CUSTOM_DATA_LEN ||
+ effect->u.periodic.custom_len > DA7280_SNP_MEM_SIZE) {
@@ -657,14 +744,15 @@
+ if (copy_from_user(data, effect->u.periodic.custom_data,
+ sizeof(s16) *
+ effect->u.periodic.custom_len)) {
-+ dev_err(haptics->dev, "Custom data load error\n");
++ dev_err(haptics->dev,
++ "custom data load error\n");
+ return -EFAULT;
+ }
+
+ memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE);
+
+ for (i = 0; i < effect->u.periodic.custom_len; i++) {
-+ if (data[i] <= 0xff && data[i] >= 0) {
++ if (data[i] <= 0xff) {
+ haptics->snp_mem[i] = (u8)data[i];
+ } else {
+ dev_err(haptics->dev,
@@ -676,78 +764,40 @@
+ error = da7280_haptic_mem_update(haptics);
+ if (error) {
+ dev_err(haptics->dev,
-+ "Custom date update error: %d\n", error);
++ "mem update error: %pE\n",
++ ERR_PTR(error));
+ return error;
+ }
+ break;
+
-+set_seq_id_loop:
++set_id_loop:
+ if (copy_from_user(data, effect->u.periodic.custom_data,
+ sizeof(s16) * DA7280_CUSTOM_DATA_LEN)) {
+ dev_err(haptics->dev,
-+ "Custom id/loop load error\n");
++ "custom id/loop load error\n");
+ return -EFAULT;
+ }
+
-+ if (data[DA7280_CUSTOM_SEQ_ID_IDX] < 0 ||
-+ data[DA7280_CUSTOM_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX ||
-+ data[DA7280_CUSTOM_SEQ_LOOP_IDX] < 0 ||
-+ data[DA7280_CUSTOM_SEQ_LOOP_IDX] > DA7280_SEQ_LOOP_MAX) {
-+ dev_err(haptics->dev, "Invalid custom id or loop\n");
-+ return -EINVAL;
-+ }
+ haptics->ps_seq_id =
-+ data[DA7280_CUSTOM_SEQ_ID_IDX] & 0x0f;
++ data[DA7280_CUSTOM_DATA_SEQ_ID_IDX] <=
++ DA7280_SEQ_ID_MAX ?
++ data[DA7280_CUSTOM_DATA_SEQ_ID_IDX] : 0;
++
+ haptics->ps_seq_loop =
-+ data[DA7280_CUSTOM_SEQ_LOOP_IDX] & 0x0f;
++ data[DA7280_CUSTOM_DATA_SEQ_LOOP_IDX] <=
++ DA7280_SEQ_LOOP_MAX ?
++ data[DA7280_CUSTOM_DATA_SEQ_LOOP_IDX] : 0;
++
+ haptics->op_mode = haptics->periodic_op_mode;
+
-+ val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) |
-+ FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK,
-+ haptics->ps_seq_loop);
++ val = haptics->ps_seq_id << DA7280_PS_SEQ_ID_SHIFT |
++ haptics->ps_seq_loop << DA7280_PS_SEQ_LOOP_SHIFT;
+ error = regmap_write(haptics->regmap,
+ DA7280_SEQ_CTL2, val);
+ if (error) {
+ dev_err(haptics->dev,
-+ "Upload effect, custom i2c err: %d\n",
-+ error);
-+ return error;
-+ }
-+ break;
-+
-+set_gpix_seq_id:
-+ if (copy_from_user(data, effect->u.periodic.custom_data,
-+ sizeof(s16) * DA7280_CUSTOM_GP_DATA_LEN)) {
-+ dev_err(haptics->dev,
-+ "Custom GPI id load error\n");
-+ return -EFAULT;
-+ }
-+
-+ if (data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] < 0 ||
-+ data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX ||
-+ data[DA7280_CUSTOM_GPI_NUM_IDX] < 0 ||
-+ data[DA7280_CUSTOM_GPI_NUM_IDX] > DA7280_GPI_SEQ_ID_MAX) {
-+ dev_err(haptics->dev,
-+ "Invalid custom GPI id/loop\n");
-+ return -EINVAL;
-+ }
-+
-+ num = data[DA7280_CUSTOM_GPI_NUM_IDX] & 0x0f;
-+ haptics->gpi_ctl[num].seq_id =
-+ data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] & 0x0f;
-+
-+ haptics->op_mode = haptics->periodic_op_mode;
-+
-+ val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK,
-+ haptics->gpi_ctl[num].seq_id);
-+ error = regmap_update_bits(haptics->regmap,
-+ DA7280_GPI_0_CTL + num,
-+ DA7280_GPI0_SEQUENCE_ID_MASK,
-+ val);
-+ if (error) {
-+ dev_err(haptics->dev,
-+ "Upload effect, custom GPI i2c err: %d\n",
-+ error);
++ "i2c err for driving level set: %pE\n",
++ ERR_PTR(error));
+ return error;
+ }
+ break;
@@ -768,14 +818,26 @@
+
+ if (!haptics->op_mode) {
+ dev_warn(haptics->dev,
-+ "No effects have been uploaded\n");
-+ return -EINVAL;
++ "Any effects are not uploaded yet\n");
++ return -EPERM;
+ }
+
+ haptics->val = val;
-+ schedule_work(&haptics->work);
++ schedule_work(&haptics->work_playback);
+
+ return 0;
++}
++
++static void da7280_haptics_set_gain(struct input_dev *dev, u16 gain)
++{
++ struct da7280_haptic *haptics = input_get_drvdata(dev);
++
++ if (gain > 0x7fff)
++ gain = 0x7fff;
++
++ haptics->new_gain = gain;
++
++ schedule_work(&haptics->work_setgain);
+}
+
+static int da7280_haptic_open(struct input_dev *dev)
@@ -789,8 +851,8 @@
+ DA7280_STANDBY_EN_MASK);
+ if (error)
+ dev_err(haptics->dev,
-+ "Failed to open da7280, i2c err: %d\n",
-+ error);
++ "Failed to open haptic, i2c error : %pE\n",
++ ERR_PTR(error));
+
+ return error;
+}
@@ -800,7 +862,9 @@
+ struct da7280_haptic *haptics = input_get_drvdata(dev);
+ int error;
+
-+ cancel_work_sync(&haptics->work);
++ cancel_delayed_work_sync(&haptics->work_duration);
++ cancel_work_sync(&haptics->work_playback);
++ cancel_work_sync(&haptics->work_setgain);
+
+ error = regmap_update_bits(haptics->regmap,
+ DA7280_TOP_CTL1,
@@ -825,8 +889,8 @@
+ return;
+
+error_i2c:
-+ dev_err(haptics->dev,
-+ "Failed to close da7280, i2c err: %d\n", error);
++ dev_err(haptics->dev, "DA7280-haptic i2c error : %pE\n",
++ ERR_PTR(error));
+}
+
+static u8 da7280_haptic_of_mode_str(struct device *dev,
@@ -839,7 +903,7 @@
+ else if (!strcmp(str, "ERM-coin"))
+ return DA7280_ERM_COIN;
+
-+ dev_warn(dev, "Invalid string - set to LRA\n");
++ dev_warn(dev, "Invalid string - set to default\n");
+ return DA7280_LRA;
+}
+
@@ -851,7 +915,7 @@
+ else if (!strcmp(str, "Multi-pattern"))
+ return 1;
+
-+ dev_warn(dev, "Invalid string - set to Single-pattern\n");
++ dev_warn(dev, "Invalid string - set to default\n");
+ return 0;
+}
+
@@ -865,7 +929,7 @@
+ else if (!strcmp(str, "Both-edge"))
+ return 2;
+
-+ dev_warn(dev, "Invalid string - set to Rising-edge\n");
++ dev_warn(dev, "Invalid string - set to default\n");
+ return 0;
+}
+
@@ -883,10 +947,10 @@
+static void da7280_parse_properties(struct device *dev,
+ struct da7280_haptic *haptics)
+{
-+ unsigned int i, mem[DA7280_SNP_MEM_SIZE];
+ char gpi_str1[] = "dlg,gpi0-seq-id";
+ char gpi_str2[] = "dlg,gpi0-mode";
+ char gpi_str3[] = "dlg,gpi0-polarity";
++ unsigned int i, mem[DA7280_SNP_MEM_SIZE];
+ const char *str;
+ u32 val;
+
@@ -984,7 +1048,7 @@
+ haptics->ps_seq_loop = 0;
+
+ /* GPI0~2 Control */
-+ for (i = 0; i <= DA7280_GPI_SEQ_ID_MAX; i++) {
++ for (i = 0; i < 3; i++) {
+ gpi_str1[7] = '0' + i;
+ if (device_property_read_u32 (dev, gpi_str1, &val) >= 0)
+ if (val <= DA7280_SEQ_ID_MAX)
@@ -1063,8 +1127,7 @@
+ goto error_i2c;
+
+ if (events[0] & DA7280_E_SEQ_FAULT_MASK) {
-+ /*
-+ * Stop first if Haptic is working
++ /* Stop first if Haptic is working
+ * Otherwise, the fault may happen continually
+ * even though the bit is cleared.
+ */
@@ -1100,19 +1163,18 @@
+ return IRQ_HANDLED;
+
+error_i2c:
-+ dev_err(dev, "da7280 irq, i2c err: %d\n", error);
++ dev_err(dev, "da7280 i2c error : %pE\n", ERR_PTR(error));
+ return IRQ_NONE;
+}
+
+static int da7280_init(struct da7280_haptic *haptics)
+{
++ int error, i;
+ unsigned int val = 0;
+ u32 v2i_factor;
-+ int error, i;
+ u8 mask = 0;
+
-+ /*
-+ * If device type is DA7280_DEV_MAX,
++ /* If device type is DA7280_DEV_MAX,
+ * then just use default value inside chip.
+ */
+ if (haptics->dev_type == DA7280_DEV_MAX) {
@@ -1167,18 +1229,19 @@
+ DA7280_ACCELERATION_EN_MASK |
+ DA7280_RAPID_STOP_EN_MASK |
+ DA7280_AMP_PID_EN_MASK;
-+ val = FIELD_PREP(DA7280_ACTUATOR_TYPE_MASK,
-+ (haptics->dev_type ? 1 : 0)) |
-+ FIELD_PREP(DA7280_BEMF_SENSE_EN_MASK,
-+ (haptics->bemf_sense_en ? 1 : 0)) |
-+ FIELD_PREP(DA7280_FREQ_TRACK_EN_MASK,
-+ (haptics->freq_track_en ? 1 : 0)) |
-+ FIELD_PREP(DA7280_ACCELERATION_EN_MASK,
-+ (haptics->acc_en ? 1 : 0)) |
-+ FIELD_PREP(DA7280_RAPID_STOP_EN_MASK,
-+ (haptics->rapid_stop_en ? 1 : 0)) |
-+ FIELD_PREP(DA7280_AMP_PID_EN_MASK,
-+ (haptics->amp_pid_en ? 1 : 0));
++
++ 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;
+
+ error = regmap_update_bits(haptics->regmap,
+ DA7280_TOP_CFG1, mask, val);
@@ -1250,8 +1313,8 @@
+ }
+
+ /* Set PS_SEQ_ID and PS_SEQ_LOOP */
-+ val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) |
-+ FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK, haptics->ps_seq_loop);
++ val = haptics->ps_seq_id << DA7280_PS_SEQ_ID_SHIFT |
++ haptics->ps_seq_loop << DA7280_PS_SEQ_LOOP_SHIFT;
+ error = regmap_write(haptics->regmap,
+ DA7280_SEQ_CTL2, val);
+ if (error)
@@ -1259,12 +1322,12 @@
+
+ /* GPI(N) CTL */
+ for (i = 0; i < 3; i++) {
-+ val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK,
-+ haptics->gpi_ctl[i].seq_id) |
-+ FIELD_PREP(DA7280_GPI0_MODE_MASK,
-+ haptics->gpi_ctl[i].mode) |
-+ FIELD_PREP(DA7280_GPI0_POLARITY_MASK,
-+ haptics->gpi_ctl[i].polarity);
++ 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;
+ error = regmap_write(haptics->regmap,
+ DA7280_GPI_0_CTL + i, val);
+ if (error)
@@ -1296,9 +1359,419 @@
+
+error_i2c:
+ dev_err(haptics->dev,
-+ "da7280 init, i2c err: %d\n", error);
++ "haptic init - I2C error : %pE\n", ERR_PTR(error));
+ return error;
+}
++
++/* 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 error;
++
++ if (haptics->enabled)
++ return -EBUSY;
++
++ if (kstrtol(&buf[0], 0, &val) < 0)
++ goto err;
++
++ error = regmap_update_bits(haptics->regmap,
++ DA7280_SEQ_CTL2,
++ DA7280_PS_SEQ_ID_MASK,
++ (val & 0xf) >> DA7280_PS_SEQ_ID_SHIFT);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to update register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ 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 error;
++ unsigned int val;
++
++ error = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to read register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++ 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 error;
++
++ if (haptics->enabled)
++ return -EBUSY;
++
++ if (kstrtol(&buf[0], 0, &val) < 0)
++ goto err;
++
++ error = regmap_update_bits(haptics->regmap,
++ DA7280_SEQ_CTL2,
++ DA7280_PS_SEQ_LOOP_MASK,
++ (val & 0xF) << DA7280_PS_SEQ_LOOP_SHIFT);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to update register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ 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 error;
++ unsigned int val;
++
++ error = regmap_read(haptics->regmap, DA7280_SEQ_CTL2, &val);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to read register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++ 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 > ./gpi_seq_id0
++ * Range of X: 0 <= X <= 15
++ * ex)
++ * echo 1 > /sys/class/..../gpi_seq_id0
++ * echo 2 > /sys/class/..../gpi_seq_id1
++ * echo 3 > /sys/class/..../gpi_seq_id2
++ */
++static ssize_t gpi_seq_id0_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 error;
++
++ if (haptics->enabled)
++ return -EBUSY;
++
++ if (kstrtol(&buf[0], 0, &val) < 0)
++ goto err;
++
++ error = regmap_update_bits(haptics->regmap,
++ DA7280_GPI_0_CTL,
++ DA7280_GPI0_SEQUENCE_ID_MASK,
++ (val & 0xf)
++ << DA7280_GPI0_SEQUENCE_ID_SHIFT);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to update register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ haptics->gpi_ctl[0].seq_id = val & 0xf;
++
++ return count;
++
++err:
++ dev_err(dev, "Invalid input\n");
++ return count;
++}
++
++static ssize_t gpi_seq_id0_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct da7280_haptic *haptics = dev_get_drvdata(dev);
++ int error;
++ unsigned int val;
++
++ error = regmap_read(haptics->regmap, DA7280_GPI_0_CTL, &val);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to read register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++ val = (val & DA7280_GPI0_SEQUENCE_ID_MASK)
++ >> DA7280_GPI0_SEQUENCE_ID_SHIFT;
++
++ return sprintf(buf, "gpi_seq_id0 is %d\n", val);
++}
++
++static ssize_t gpi_seq_id1_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 error;
++
++ if (haptics->enabled)
++ return -EBUSY;
++
++ if (kstrtol(&buf[0], 0, &val) < 0)
++ goto err;
++
++ error = regmap_update_bits(haptics->regmap,
++ DA7280_GPI_1_CTL,
++ DA7280_GPI1_SEQUENCE_ID_MASK,
++ (val & 0xf)
++ << DA7280_GPI1_SEQUENCE_ID_SHIFT);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to update register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ haptics->gpi_ctl[1].seq_id = val & 0xf;
++
++ return count;
++
++err:
++ dev_err(dev, "Invalid input\n");
++ return count;
++}
++
++static ssize_t gpi_seq_id1_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct da7280_haptic *haptics = dev_get_drvdata(dev);
++ int error;
++ unsigned int val;
++
++ error = regmap_read(haptics->regmap, DA7280_GPI_1_CTL, &val);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to read register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++ val = (val & DA7280_GPI1_SEQUENCE_ID_MASK)
++ >> DA7280_GPI1_SEQUENCE_ID_SHIFT;
++
++ return sprintf(buf, "gpi_seq_id1 is %d\n", val);
++}
++
++static ssize_t gpi_seq_id2_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 error;
++
++ if (haptics->enabled)
++ return -EBUSY;
++
++ if (kstrtol(&buf[0], 0, &val) < 0)
++ goto err;
++
++ error = regmap_update_bits(haptics->regmap,
++ DA7280_GPI_2_CTL,
++ DA7280_GPI2_SEQUENCE_ID_MASK,
++ (val & 0xf)
++ << DA7280_GPI2_SEQUENCE_ID_SHIFT);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to update register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ haptics->gpi_ctl[2].seq_id = val & 0xf;
++
++ return count;
++
++err:
++ dev_err(dev, "Invalid input\n");
++ return count;
++}
++
++static ssize_t gpi_seq_id2_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct da7280_haptic *haptics = dev_get_drvdata(dev);
++ int error;
++ unsigned int val;
++
++ error = regmap_read(haptics->regmap, DA7280_GPI_2_CTL, &val);
++ if (error) {
++ dev_err(haptics->dev,
++ "failed to read register : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++ val = (val & DA7280_GPI2_SEQUENCE_ID_MASK)
++ >> DA7280_GPI2_SEQUENCE_ID_SHIFT;
++
++ return sprintf(buf, "gpi_seq_id2 is %d\n", val);
++}
++
++#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 */
++ static 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 error;
++
++ error = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val);
++ if (error)
++ return error;
++
++ 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;
++
++ memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE);
++ memcpy(haptics->snp_mem, mem.val, mem.len);
++
++ error = da7280_haptic_mem_update(haptics);
++ if (error)
++ return error;
++
++ return count;
++}
++
++static DEVICE_ATTR_RW(ps_seq_id);
++static DEVICE_ATTR_RW(ps_seq_loop);
++static DEVICE_ATTR_RW(gpi_seq_id0);
++static DEVICE_ATTR_RW(gpi_seq_id1);
++static DEVICE_ATTR_RW(gpi_seq_id2);
++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_id0.attr,
++ &dev_attr_gpi_seq_id1.attr,
++ &dev_attr_gpi_seq_id2.attr,
++ &dev_attr_patterns.attr,
++ NULL,
++};
++
++static const struct attribute_group da7280_attr_group = {
++ .attrs = da7280_sysfs_attr,
++};
+
+static int da7280_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
@@ -1306,8 +1779,9 @@
+ struct device *dev = &client->dev;
+ struct da7280_haptic *haptics;
+ struct input_dev *input_dev;
++ struct ff_device *ff;
+ struct pwm_state state;
-+ struct ff_device *ff;
++ unsigned int period2freq;
+ int error;
+
+ haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL);
@@ -1315,55 +1789,72 @@
+ return -ENOMEM;
+ haptics->dev = dev;
+
-+ if (!client->irq)
-+ dev_err_probe(dev, -EINVAL, "No IRQ configured\n");
++ if (!client->irq) {
++ dev_err(dev, "No IRQ configured\n");
++ return -EINVAL;
++ }
+
+ da7280_parse_properties(dev, haptics);
+
+ if (haptics->const_op_mode == DA7280_PWM_MODE) {
+ haptics->pwm_dev = devm_pwm_get(dev, NULL);
-+ if (IS_ERR(haptics->pwm_dev))
-+ return dev_err_probe(dev, PTR_ERR(haptics->pwm_dev),
-+ "Unable to request PWM\n");
++ if (IS_ERR(haptics->pwm_dev)) {
++ error = PTR_ERR(haptics->pwm_dev);
++ if (error != -EPROBE_DEFER)
++ dev_err(dev, "unable to request PWM: %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
+
+ /* Sync up PWM state and ensure it is off. */
+ pwm_init_state(haptics->pwm_dev, &state);
+ state.enabled = false;
+ error = pwm_apply_state(haptics->pwm_dev, &state);
-+ if (error)
-+ return dev_err_probe(dev, error,
-+ "Failed to apply PWM state\n");
-+
-+ /*
-+ * Check PWM period, PWM freq = 1000000 / state.period.
-+ * The valid PWM freq range: 10k ~ 250kHz.
-+ */
-+ if (state.period > 100000 || state.period < 4000)
-+ return dev_err_probe(dev, -EINVAL,
-+ "Unsupported PWM period\n");
-+ }
-+
-+ INIT_WORK(&haptics->work, da7280_haptic_work);
++ if (error) {
++ dev_err(dev,
++ "failed to apply initial PWM state: %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
++ /* Check PWM Period, it must be in 10k ~ 250kHz */
++ period2freq = 1000000 / state.period;
++ 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_DELAYED_WORK(&haptics->work_duration, da7280_haptic_work_duration);
++ INIT_WORK(&haptics->work_playback, da7280_haptic_work_playback);
++ INIT_WORK(&haptics->work_setgain, da7280_haptic_work_setgain);
+
+ haptics->client = client;
+ i2c_set_clientdata(client, haptics);
+
+ haptics->regmap =
+ devm_regmap_init_i2c(client, &da7280_haptic_regmap_config);
-+ if (IS_ERR(haptics->regmap))
-+ return dev_err_probe(dev, PTR_ERR(haptics->regmap),
-+ "Failed to allocate register map\n");
++ if (IS_ERR(haptics->regmap)) {
++ error = PTR_ERR(haptics->regmap);
++ dev_err(dev, "Failed to allocate register map : %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
+
+ error = da7280_init(haptics);
-+ if (error)
-+ return dev_err_probe(dev, error,
-+ "Failed to initialize device\n");
++ if (error) {
++ dev_err(dev, "failed to initialize device\n");
++ return error;
++ }
+
+ /* Initialize input device for haptic device */
+ input_dev = devm_input_allocate_device(dev);
-+ if (!input_dev)
-+ return dev_err_probe(dev, -ENOMEM,
-+ "Failed to allocate input device\n");
++ if (!input_dev) {
++ dev_err(dev, "failed to allocate input device\n");
++ return -ENOMEM;
++ }
+
+ input_dev->name = "da7280-haptic";
+ input_dev->dev.parent = client->dev.parent;
@@ -1377,28 +1868,39 @@
+ input_set_capability(haptics->input_dev, EV_FF, FF_CONSTANT);
+ input_set_capability(haptics->input_dev, EV_FF, FF_GAIN);
+
-+ error = input_ff_create(haptics->input_dev,
-+ DA7280_FF_EFFECT_COUNT_MAX);
-+ if (error)
-+ return dev_err_probe(dev, error,
-+ "Create FF input device failed");
++ error = input_ff_create(haptics->input_dev, DA7280_FF_EFFECT_COUNT_MAX);
++ if (error) {
++ dev_err(dev, "create FF input device failed: %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
+
+ ff = input_dev->ff;
+ ff->upload = da7280_haptics_upload_effect;
+ ff->playback = da7280_haptics_playback;
++ ff->set_gain = da7280_haptics_set_gain;
+
+ error = input_register_device(input_dev);
-+ if (error)
-+ return dev_err_probe(dev, error,
-+ "Failed to register input device\n");
++ if (error) {
++ dev_err(dev, "failed to register input device\n");
++ return error;
++ }
++
++ error = devm_device_add_group(dev, &da7280_attr_group);
++ if (error) {
++ dev_err(dev, "Failed to create sysfs attributes: %pE\n",
++ ERR_PTR(error));
++ return error;
++ }
++
+ error = devm_request_threaded_irq(dev, client->irq, NULL,
+ da7280_irq_handler,
+ IRQF_ONESHOT,
+ "da7280-haptics", haptics);
+ if (error)
-+ return dev_err_probe(dev, error,
-+ "Failed to request IRQ\n");
-+ return 0;
++ dev_err(dev, "Failed to request IRQ : %d\n", client->irq);
++
++ return error;
+}
+
+static int __maybe_unused da7280_suspend(struct device *dev)
@@ -1408,15 +1910,14 @@
+
+ mutex_lock(&haptics->input_dev->mutex);
+
-+ if (haptics->enabled)
-+ da7280_haptic_disable(haptics);
++ da7280_haptic_disable(haptics);
+
+ error = regmap_update_bits(haptics->regmap,
+ DA7280_TOP_CTL1,
+ DA7280_STANDBY_EN_MASK, 0);
+ if (error)
+ dev_err(haptics->dev,
-+ "da7280, suspend i2c err: %d\n", error);
++ "I2C error : %pE\n", ERR_PTR(error));
+
+ mutex_unlock(&haptics->input_dev->mutex);
+ return error;
@@ -1435,7 +1936,7 @@
+ DA7280_STANDBY_EN_MASK);
+ if (error)
+ dev_err(haptics->dev,
-+ "da7280, resume i2c err: %d\n", error);
++ "i2c error : %pE\n", ERR_PTR(error));
+
+ mutex_unlock(&haptics->input_dev->mutex);
+ return error;
@@ -1457,13 +1958,13 @@
+ da7280_suspend, da7280_resume);
+
+static struct i2c_driver da7280_driver = {
-+ .driver = {
-+ .name = "da7280",
++ .driver = {
++ .name = "da7280",
+ .of_match_table = of_match_ptr(da7280_of_match),
-+ .pm = &da7280_pm_ops,
++ .pm = &da7280_pm_ops,
+ },
-+ .probe = da7280_probe,
-+ .id_table = da7280_i2c_id,
++ .probe = da7280_probe,
++ .id_table = da7280_i2c_id,
+};
+module_i2c_driver(da7280_driver);
+
@@ -1471,5 +1972,5 @@
+MODULE_AUTHOR("Roy Im <Roy.Im.Opensource@diasemi.com>");
+MODULE_LICENSE("GPL");
--
-end-of-patch for PATCH v20
+end-of-patch for PATCH V12