Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * DA7280 Haptic device driver
0004  *
0005  * Copyright (c) 2020 Dialog Semiconductor.
0006  * Author: Roy Im <Roy.Im.Opensource@diasemi.com>
0007  */
0008 
0009 #include <linux/bitfield.h>
0010 #include <linux/bitops.h>
0011 #include <linux/err.h>
0012 #include <linux/i2c.h>
0013 #include <linux/input.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/module.h>
0016 #include <linux/pwm.h>
0017 #include <linux/regmap.h>
0018 #include <linux/workqueue.h>
0019 #include <linux/uaccess.h>
0020 
0021 /* Registers */
0022 #define DA7280_IRQ_EVENT1           0x03
0023 #define DA7280_IRQ_EVENT_WARNING_DIAG       0x04
0024 #define DA7280_IRQ_EVENT_SEQ_DIAG       0x05
0025 #define DA7280_IRQ_STATUS1          0x06
0026 #define DA7280_IRQ_MASK1            0x07
0027 #define DA7280_FRQ_LRA_PER_H            0x0A
0028 #define DA7280_FRQ_LRA_PER_L            0x0B
0029 #define DA7280_ACTUATOR1            0x0C
0030 #define DA7280_ACTUATOR2            0x0D
0031 #define DA7280_ACTUATOR3            0x0E
0032 #define DA7280_CALIB_V2I_H          0x0F
0033 #define DA7280_CALIB_V2I_L          0x10
0034 #define DA7280_TOP_CFG1             0x13
0035 #define DA7280_TOP_CFG2             0x14
0036 #define DA7280_TOP_CFG4             0x16
0037 #define DA7280_TOP_INT_CFG1         0x17
0038 #define DA7280_TOP_CTL1             0x22
0039 #define DA7280_TOP_CTL2             0x23
0040 #define DA7280_SEQ_CTL2             0x28
0041 #define DA7280_GPI_0_CTL            0x29
0042 #define DA7280_GPI_1_CTL            0x2A
0043 #define DA7280_GPI_2_CTL            0x2B
0044 #define DA7280_MEM_CTL1             0x2C
0045 #define DA7280_MEM_CTL2             0x2D
0046 #define DA7280_TOP_CFG5             0x6E
0047 #define DA7280_IRQ_MASK2            0x83
0048 #define DA7280_SNP_MEM_99           0xE7
0049 
0050 /* Register field */
0051 
0052 /* DA7280_IRQ_EVENT1 (Address 0x03) */
0053 #define DA7280_E_SEQ_CONTINUE_MASK      BIT(0)
0054 #define DA7280_E_UVLO_MASK          BIT(1)
0055 #define DA7280_E_SEQ_DONE_MASK          BIT(2)
0056 #define DA7280_E_OVERTEMP_CRIT_MASK     BIT(3)
0057 #define DA7280_E_SEQ_FAULT_MASK         BIT(4)
0058 #define DA7280_E_WARNING_MASK           BIT(5)
0059 #define DA7280_E_ACTUATOR_FAULT_MASK        BIT(6)
0060 #define DA7280_E_OC_FAULT_MASK          BIT(7)
0061 
0062 /* DA7280_IRQ_EVENT_WARNING_DIAG (Address 0x04) */
0063 #define DA7280_E_OVERTEMP_WARN_MASK             BIT(3)
0064 #define DA7280_E_MEM_TYPE_MASK                  BIT(4)
0065 #define DA7280_E_LIM_DRIVE_ACC_MASK             BIT(6)
0066 #define DA7280_E_LIM_DRIVE_MASK                 BIT(7)
0067 
0068 /* DA7280_IRQ_EVENT_PAT_DIAG (Address 0x05) */
0069 #define DA7280_E_PWM_FAULT_MASK         BIT(5)
0070 #define DA7280_E_MEM_FAULT_MASK         BIT(6)
0071 #define DA7280_E_SEQ_ID_FAULT_MASK      BIT(7)
0072 
0073 /* DA7280_IRQ_STATUS1 (Address 0x06) */
0074 #define DA7280_STA_SEQ_CONTINUE_MASK        BIT(0)
0075 #define DA7280_STA_UVLO_VBAT_OK_MASK        BIT(1)
0076 #define DA7280_STA_SEQ_DONE_MASK        BIT(2)
0077 #define DA7280_STA_OVERTEMP_CRIT_MASK       BIT(3)
0078 #define DA7280_STA_SEQ_FAULT_MASK       BIT(4)
0079 #define DA7280_STA_WARNING_MASK         BIT(5)
0080 #define DA7280_STA_ACTUATOR_MASK        BIT(6)
0081 #define DA7280_STA_OC_MASK          BIT(7)
0082 
0083 /* DA7280_IRQ_MASK1 (Address 0x07) */
0084 #define DA7280_SEQ_CONTINUE_M_MASK      BIT(0)
0085 #define DA7280_E_UVLO_M_MASK            BIT(1)
0086 #define DA7280_SEQ_DONE_M_MASK          BIT(2)
0087 #define DA7280_OVERTEMP_CRIT_M_MASK     BIT(3)
0088 #define DA7280_SEQ_FAULT_M_MASK         BIT(4)
0089 #define DA7280_WARNING_M_MASK           BIT(5)
0090 #define DA7280_ACTUATOR_M_MASK          BIT(6)
0091 #define DA7280_OC_M_MASK            BIT(7)
0092 
0093 /* DA7280_ACTUATOR3 (Address 0x0e) */
0094 #define DA7280_IMAX_MASK            GENMASK(4, 0)
0095 
0096 /* DA7280_TOP_CFG1 (Address 0x13) */
0097 #define DA7280_AMP_PID_EN_MASK          BIT(0)
0098 #define DA7280_RAPID_STOP_EN_MASK       BIT(1)
0099 #define DA7280_ACCELERATION_EN_MASK     BIT(2)
0100 #define DA7280_FREQ_TRACK_EN_MASK       BIT(3)
0101 #define DA7280_BEMF_SENSE_EN_MASK       BIT(4)
0102 #define DA7280_ACTUATOR_TYPE_MASK       BIT(5)
0103 
0104 /* DA7280_TOP_CFG2 (Address 0x14) */
0105 #define DA7280_FULL_BRAKE_THR_MASK      GENMASK(3, 0)
0106 #define DA7280_MEM_DATA_SIGNED_MASK     BIT(4)
0107 
0108 /* DA7280_TOP_CFG4 (Address 0x16) */
0109 #define DA7280_TST_CALIB_IMPEDANCE_DIS_MASK BIT(6)
0110 #define DA7280_V2I_FACTOR_FREEZE_MASK       BIT(7)
0111 
0112 /* DA7280_TOP_INT_CFG1 (Address 0x17) */
0113 #define DA7280_BEMF_FAULT_LIM_MASK      GENMASK(1, 0)
0114 
0115 /* DA7280_TOP_CTL1 (Address 0x22) */
0116 #define DA7280_OPERATION_MODE_MASK      GENMASK(2, 0)
0117 #define DA7280_STANDBY_EN_MASK          BIT(3)
0118 #define DA7280_SEQ_START_MASK           BIT(4)
0119 
0120 /* DA7280_SEQ_CTL2 (Address 0x28) */
0121 #define DA7280_PS_SEQ_ID_MASK           GENMASK(3, 0)
0122 #define DA7280_PS_SEQ_LOOP_MASK         GENMASK(7, 4)
0123 
0124 /* DA7280_GPIO_0_CTL (Address 0x29) */
0125 #define DA7280_GPI0_POLARITY_MASK       GENMASK(1, 0)
0126 #define DA7280_GPI0_MODE_MASK           BIT(2)
0127 #define DA7280_GPI0_SEQUENCE_ID_MASK        GENMASK(6, 3)
0128 
0129 /* DA7280_GPIO_1_CTL (Address 0x2a) */
0130 #define DA7280_GPI1_POLARITY_MASK       GENMASK(1, 0)
0131 #define DA7280_GPI1_MODE_MASK           BIT(2)
0132 #define DA7280_GPI1_SEQUENCE_ID_MASK        GENMASK(6, 3)
0133 
0134 /* DA7280_GPIO_2_CTL (Address 0x2b) */
0135 #define DA7280_GPI2_POLARITY_MASK       GENMASK(1, 0)
0136 #define DA7280_GPI2_MODE_MASK           BIT(2)
0137 #define DA7280_GPI2_SEQUENCE_ID_MASK        GENMASK(6, 3)
0138 
0139 /* DA7280_MEM_CTL2 (Address 0x2d) */
0140 #define DA7280_WAV_MEM_LOCK_MASK        BIT(7)
0141 
0142 /* DA7280_TOP_CFG5 (Address 0x6e) */
0143 #define DA7280_V2I_FACTOR_OFFSET_EN_MASK    BIT(0)
0144 
0145 /* DA7280_IRQ_MASK2 (Address 0x83) */
0146 #define DA7280_ADC_SAT_M_MASK           BIT(7)
0147 
0148 /* Controls */
0149 
0150 #define DA7280_VOLTAGE_RATE_MAX         6000000
0151 #define DA7280_VOLTAGE_RATE_STEP        23400
0152 #define DA7280_NOMMAX_DFT           0x6B
0153 #define DA7280_ABSMAX_DFT           0x78
0154 
0155 #define DA7280_IMPD_MAX             1500000000
0156 #define DA7280_IMPD_DEFAULT         22000000
0157 
0158 #define DA7280_IMAX_DEFAULT         0x0E
0159 #define DA7280_IMAX_STEP            7200
0160 #define DA7280_IMAX_LIMIT           252000
0161 
0162 #define DA7280_RESONT_FREQH_DFT         0x39
0163 #define DA7280_RESONT_FREQL_DFT         0x32
0164 #define DA7280_MIN_RESONAT_FREQ_HZ      50
0165 #define DA7280_MAX_RESONAT_FREQ_HZ      300
0166 
0167 #define DA7280_SEQ_ID_MAX           15
0168 #define DA7280_SEQ_LOOP_MAX         15
0169 #define DA7280_GPI_SEQ_ID_DFT           0
0170 #define DA7280_GPI_SEQ_ID_MAX           2
0171 
0172 #define DA7280_SNP_MEM_SIZE         100
0173 #define DA7280_SNP_MEM_MAX          DA7280_SNP_MEM_99
0174 
0175 #define DA7280_IRQ_NUM              3
0176 
0177 #define DA7280_SKIP_INIT            0x100
0178 
0179 #define DA7280_FF_EFFECT_COUNT_MAX      15
0180 
0181 /* Maximum gain is 0x7fff for PWM mode */
0182 #define DA7280_MAX_MAGNITUDE_SHIFT      15
0183 
0184 enum da7280_haptic_dev_t {
0185     DA7280_LRA  = 0,
0186     DA7280_ERM_BAR  = 1,
0187     DA7280_ERM_COIN = 2,
0188     DA7280_DEV_MAX,
0189 };
0190 
0191 enum da7280_op_mode {
0192     DA7280_INACTIVE     = 0,
0193     DA7280_DRO_MODE     = 1,
0194     DA7280_PWM_MODE     = 2,
0195     DA7280_RTWM_MODE    = 3,
0196     DA7280_ETWM_MODE    = 4,
0197     DA7280_OPMODE_MAX,
0198 };
0199 
0200 #define DA7280_FF_CONSTANT_DRO          1
0201 #define DA7280_FF_PERIODIC_PWM          2
0202 #define DA7280_FF_PERIODIC_RTWM         1
0203 #define DA7280_FF_PERIODIC_ETWM         2
0204 
0205 #define DA7280_FF_PERIODIC_MODE         DA7280_RTWM_MODE
0206 #define DA7280_FF_CONSTANT_MODE         DA7280_DRO_MODE
0207 
0208 enum da7280_custom_effect_param {
0209     DA7280_CUSTOM_SEQ_ID_IDX    = 0,
0210     DA7280_CUSTOM_SEQ_LOOP_IDX  = 1,
0211     DA7280_CUSTOM_DATA_LEN      = 2,
0212 };
0213 
0214 enum da7280_custom_gpi_effect_param {
0215     DA7280_CUSTOM_GPI_SEQ_ID_IDX    = 0,
0216     DA7280_CUSTOM_GPI_NUM_IDX   = 2,
0217     DA7280_CUSTOM_GP_DATA_LEN   = 3,
0218 };
0219 
0220 struct da7280_gpi_ctl {
0221     u8 seq_id;
0222     u8 mode;
0223     u8 polarity;
0224 };
0225 
0226 struct da7280_haptic {
0227     struct regmap *regmap;
0228     struct input_dev *input_dev;
0229     struct device *dev;
0230     struct i2c_client *client;
0231     struct pwm_device *pwm_dev;
0232 
0233     bool legacy;
0234     struct work_struct work;
0235     int val;
0236     u16 gain;
0237     s16 level;
0238 
0239     u8 dev_type;
0240     u8 op_mode;
0241     u8 const_op_mode;
0242     u8 periodic_op_mode;
0243     u16 nommax;
0244     u16 absmax;
0245     u32 imax;
0246     u32 impd;
0247     u32 resonant_freq_h;
0248     u32 resonant_freq_l;
0249     bool bemf_sense_en;
0250     bool freq_track_en;
0251     bool acc_en;
0252     bool rapid_stop_en;
0253     bool amp_pid_en;
0254     u8 ps_seq_id;
0255     u8 ps_seq_loop;
0256     struct da7280_gpi_ctl gpi_ctl[3];
0257     bool mem_update;
0258     u8 snp_mem[DA7280_SNP_MEM_SIZE];
0259     bool active;
0260     bool suspended;
0261 };
0262 
0263 static bool da7280_volatile_register(struct device *dev, unsigned int reg)
0264 {
0265     switch (reg) {
0266     case DA7280_IRQ_EVENT1:
0267     case DA7280_IRQ_EVENT_WARNING_DIAG:
0268     case DA7280_IRQ_EVENT_SEQ_DIAG:
0269     case DA7280_IRQ_STATUS1:
0270     case DA7280_TOP_CTL1:
0271         return true;
0272     default:
0273         return false;
0274     }
0275 }
0276 
0277 static const struct regmap_config da7280_haptic_regmap_config = {
0278     .reg_bits = 8,
0279     .val_bits = 8,
0280     .max_register = DA7280_SNP_MEM_MAX,
0281     .volatile_reg = da7280_volatile_register,
0282 };
0283 
0284 static int da7280_haptic_mem_update(struct da7280_haptic *haptics)
0285 {
0286     unsigned int val;
0287     int error;
0288 
0289     /* The patterns should be updated when haptic is not working */
0290     error = regmap_read(haptics->regmap, DA7280_IRQ_STATUS1, &val);
0291     if (error)
0292         return error;
0293     if (val & DA7280_STA_WARNING_MASK) {
0294         dev_warn(haptics->dev,
0295              "Warning! Please check HAPTIC status.\n");
0296         return -EBUSY;
0297     }
0298 
0299     /* Patterns are not updated if the lock bit is enabled */
0300     val = 0;
0301     error = regmap_read(haptics->regmap, DA7280_MEM_CTL2, &val);
0302     if (error)
0303         return error;
0304     if (~val & DA7280_WAV_MEM_LOCK_MASK) {
0305         dev_warn(haptics->dev, "Please unlock the bit first\n");
0306         return -EACCES;
0307     }
0308 
0309     /* Set to Inactive mode to make sure safety */
0310     error = regmap_update_bits(haptics->regmap,
0311                    DA7280_TOP_CTL1,
0312                    DA7280_OPERATION_MODE_MASK,
0313                    0);
0314     if (error)
0315         return error;
0316 
0317     error = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val);
0318     if (error)
0319         return error;
0320 
0321     return regmap_bulk_write(haptics->regmap, val, haptics->snp_mem,
0322                  DA7280_SNP_MEM_MAX - val + 1);
0323 }
0324 
0325 static int da7280_haptic_set_pwm(struct da7280_haptic *haptics, bool enabled)
0326 {
0327     struct pwm_state state;
0328     u64 period_mag_multi;
0329     int error;
0330 
0331     if (!haptics->gain && enabled) {
0332         dev_err(haptics->dev, "Unable to enable pwm with 0 gain\n");
0333         return -EINVAL;
0334     }
0335 
0336     pwm_get_state(haptics->pwm_dev, &state);
0337     state.enabled = enabled;
0338     if (enabled) {
0339         period_mag_multi = (u64)state.period * haptics->gain;
0340         period_mag_multi >>= DA7280_MAX_MAGNITUDE_SHIFT;
0341 
0342         /*
0343          * The interpretation of duty cycle depends on the acc_en,
0344          * it should be between 50% and 100% for acc_en = 0.
0345          * See datasheet 'PWM mode' section.
0346          */
0347         if (!haptics->acc_en) {
0348             period_mag_multi += state.period;
0349             period_mag_multi /= 2;
0350         }
0351 
0352         state.duty_cycle = period_mag_multi;
0353     }
0354 
0355     error = pwm_apply_state(haptics->pwm_dev, &state);
0356     if (error)
0357         dev_err(haptics->dev, "Failed to apply pwm state: %d\n", error);
0358 
0359     return error;
0360 }
0361 
0362 static void da7280_haptic_activate(struct da7280_haptic *haptics)
0363 {
0364     int error;
0365 
0366     if (haptics->active)
0367         return;
0368 
0369     switch (haptics->op_mode) {
0370     case DA7280_DRO_MODE:
0371         /* the valid range check when acc_en is enabled */
0372         if (haptics->acc_en && haptics->level > 0x7F)
0373             haptics->level = 0x7F;
0374         else if (haptics->level > 0xFF)
0375             haptics->level = 0xFF;
0376 
0377         /* Set level as a % of ACTUATOR_NOMMAX (nommax) */
0378         error = regmap_write(haptics->regmap, DA7280_TOP_CTL2,
0379                      haptics->level);
0380         if (error) {
0381             dev_err(haptics->dev,
0382                 "Failed to set level to %d: %d\n",
0383                 haptics->level, error);
0384             return;
0385         }
0386         break;
0387 
0388     case DA7280_PWM_MODE:
0389         if (da7280_haptic_set_pwm(haptics, true))
0390             return;
0391         break;
0392 
0393     case DA7280_RTWM_MODE:
0394         /*
0395          * The pattern will be played by the PS_SEQ_ID and the
0396          * PS_SEQ_LOOP
0397          */
0398         break;
0399 
0400     case DA7280_ETWM_MODE:
0401         /*
0402          * The pattern will be played by the GPI[N] state,
0403          * GPI(N)_SEQUENCE_ID and the PS_SEQ_LOOP. See the
0404          * datasheet for the details.
0405          */
0406         break;
0407 
0408     default:
0409         dev_err(haptics->dev, "Invalid op mode %d\n", haptics->op_mode);
0410         return;
0411     }
0412 
0413     error = regmap_update_bits(haptics->regmap,
0414                    DA7280_TOP_CTL1,
0415                    DA7280_OPERATION_MODE_MASK,
0416                    haptics->op_mode);
0417     if (error) {
0418         dev_err(haptics->dev,
0419             "Failed to set operation mode: %d", error);
0420         return;
0421     }
0422 
0423     if (haptics->op_mode == DA7280_PWM_MODE ||
0424         haptics->op_mode == DA7280_RTWM_MODE) {
0425         error = regmap_update_bits(haptics->regmap,
0426                        DA7280_TOP_CTL1,
0427                        DA7280_SEQ_START_MASK,
0428                        DA7280_SEQ_START_MASK);
0429         if (error) {
0430             dev_err(haptics->dev,
0431                 "Failed to start sequence: %d\n", error);
0432             return;
0433         }
0434     }
0435 
0436     haptics->active = true;
0437 }
0438 
0439 static void da7280_haptic_deactivate(struct da7280_haptic *haptics)
0440 {
0441     int error;
0442 
0443     if (!haptics->active)
0444         return;
0445 
0446     /* Set to Inactive mode */
0447     error = regmap_update_bits(haptics->regmap,
0448                    DA7280_TOP_CTL1,
0449                    DA7280_OPERATION_MODE_MASK, 0);
0450     if (error) {
0451         dev_err(haptics->dev,
0452             "Failed to clear operation mode: %d", error);
0453         return;
0454     }
0455 
0456     switch (haptics->op_mode) {
0457     case DA7280_DRO_MODE:
0458         error = regmap_write(haptics->regmap,
0459                      DA7280_TOP_CTL2, 0);
0460         if (error) {
0461             dev_err(haptics->dev,
0462                 "Failed to disable DRO mode: %d\n", error);
0463             return;
0464         }
0465         break;
0466 
0467     case DA7280_PWM_MODE:
0468         if (da7280_haptic_set_pwm(haptics, false))
0469             return;
0470         break;
0471 
0472     case DA7280_RTWM_MODE:
0473     case DA7280_ETWM_MODE:
0474         error = regmap_update_bits(haptics->regmap,
0475                        DA7280_TOP_CTL1,
0476                        DA7280_SEQ_START_MASK, 0);
0477         if (error) {
0478             dev_err(haptics->dev,
0479                 "Failed to disable RTWM/ETWM mode: %d\n",
0480                 error);
0481             return;
0482         }
0483         break;
0484 
0485     default:
0486         dev_err(haptics->dev, "Invalid op mode %d\n", haptics->op_mode);
0487         return;
0488     }
0489 
0490     haptics->active = false;
0491 }
0492 
0493 static void da7280_haptic_work(struct work_struct *work)
0494 {
0495     struct da7280_haptic *haptics =
0496         container_of(work, struct da7280_haptic, work);
0497     int val = haptics->val;
0498 
0499     if (val)
0500         da7280_haptic_activate(haptics);
0501     else
0502         da7280_haptic_deactivate(haptics);
0503 }
0504 
0505 static int da7280_haptics_upload_effect(struct input_dev *dev,
0506                     struct ff_effect *effect,
0507                     struct ff_effect *old)
0508 {
0509     struct da7280_haptic *haptics = input_get_drvdata(dev);
0510     s16 data[DA7280_SNP_MEM_SIZE] = { 0 };
0511     unsigned int val;
0512     int tmp, i, num;
0513     int error;
0514 
0515     /* The effect should be uploaded when haptic is not working */
0516     if (haptics->active)
0517         return -EBUSY;
0518 
0519     switch (effect->type) {
0520     /* DRO/PWM modes support this type */
0521     case FF_CONSTANT:
0522         haptics->op_mode = haptics->const_op_mode;
0523         if (haptics->op_mode == DA7280_DRO_MODE) {
0524             tmp = effect->u.constant.level * 254;
0525             haptics->level = tmp / 0x7FFF;
0526             break;
0527         }
0528 
0529         haptics->gain = effect->u.constant.level <= 0 ?
0530                     0 : effect->u.constant.level;
0531         break;
0532 
0533     /* RTWM/ETWM modes support this type */
0534     case FF_PERIODIC:
0535         if (effect->u.periodic.waveform != FF_CUSTOM) {
0536             dev_err(haptics->dev,
0537                 "Device can only accept FF_CUSTOM waveform\n");
0538             return -EINVAL;
0539         }
0540 
0541         /*
0542          * Load the data and check the length.
0543          * the data will be patterns in this case: 4 < X <= 100,
0544          * and will be saved into the waveform memory inside DA728x.
0545          * If X = 2, the data will be PS_SEQ_ID and PS_SEQ_LOOP.
0546          * If X = 3, the 1st data will be GPIX_SEQUENCE_ID .
0547          */
0548         if (effect->u.periodic.custom_len == DA7280_CUSTOM_DATA_LEN)
0549             goto set_seq_id_loop;
0550 
0551         if (effect->u.periodic.custom_len == DA7280_CUSTOM_GP_DATA_LEN)
0552             goto set_gpix_seq_id;
0553 
0554         if (effect->u.periodic.custom_len < DA7280_CUSTOM_DATA_LEN ||
0555             effect->u.periodic.custom_len > DA7280_SNP_MEM_SIZE) {
0556             dev_err(haptics->dev, "Invalid waveform data size\n");
0557             return -EINVAL;
0558         }
0559 
0560         if (copy_from_user(data, effect->u.periodic.custom_data,
0561                    sizeof(s16) *
0562                    effect->u.periodic.custom_len))
0563             return -EFAULT;
0564 
0565         memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE);
0566 
0567         for (i = 0; i < effect->u.periodic.custom_len; i++) {
0568             if (data[i] < 0 || data[i] > 0xff) {
0569                 dev_err(haptics->dev,
0570                     "Invalid waveform data %d at offset %d\n",
0571                     data[i], i);
0572                 return -EINVAL;
0573             }
0574             haptics->snp_mem[i] = (u8)data[i];
0575         }
0576 
0577         error = da7280_haptic_mem_update(haptics);
0578         if (error) {
0579             dev_err(haptics->dev,
0580                 "Failed to upload waveform: %d\n", error);
0581             return error;
0582         }
0583         break;
0584 
0585 set_seq_id_loop:
0586         if (copy_from_user(data, effect->u.periodic.custom_data,
0587                    sizeof(s16) * DA7280_CUSTOM_DATA_LEN))
0588             return -EFAULT;
0589 
0590         if (data[DA7280_CUSTOM_SEQ_ID_IDX] < 0 ||
0591             data[DA7280_CUSTOM_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX ||
0592             data[DA7280_CUSTOM_SEQ_LOOP_IDX] < 0 ||
0593             data[DA7280_CUSTOM_SEQ_LOOP_IDX] > DA7280_SEQ_LOOP_MAX) {
0594             dev_err(haptics->dev,
0595                 "Invalid custom id (%d) or loop (%d)\n",
0596                 data[DA7280_CUSTOM_SEQ_ID_IDX],
0597                 data[DA7280_CUSTOM_SEQ_LOOP_IDX]);
0598             return -EINVAL;
0599         }
0600 
0601         haptics->ps_seq_id = data[DA7280_CUSTOM_SEQ_ID_IDX] & 0x0f;
0602         haptics->ps_seq_loop = data[DA7280_CUSTOM_SEQ_LOOP_IDX] & 0x0f;
0603         haptics->op_mode = haptics->periodic_op_mode;
0604 
0605         val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) |
0606             FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK,
0607                    haptics->ps_seq_loop);
0608         error = regmap_write(haptics->regmap, DA7280_SEQ_CTL2, val);
0609         if (error) {
0610             dev_err(haptics->dev,
0611                 "Failed to update PS sequence: %d\n", error);
0612             return error;
0613         }
0614         break;
0615 
0616 set_gpix_seq_id:
0617         if (copy_from_user(data, effect->u.periodic.custom_data,
0618                    sizeof(s16) * DA7280_CUSTOM_GP_DATA_LEN))
0619             return -EFAULT;
0620 
0621         if (data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] < 0 ||
0622             data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] > DA7280_SEQ_ID_MAX ||
0623             data[DA7280_CUSTOM_GPI_NUM_IDX] < 0 ||
0624             data[DA7280_CUSTOM_GPI_NUM_IDX] > DA7280_GPI_SEQ_ID_MAX) {
0625             dev_err(haptics->dev,
0626                 "Invalid custom GPI id (%d) or num (%d)\n",
0627                 data[DA7280_CUSTOM_GPI_SEQ_ID_IDX],
0628                 data[DA7280_CUSTOM_GPI_NUM_IDX]);
0629             return -EINVAL;
0630         }
0631 
0632         num = data[DA7280_CUSTOM_GPI_NUM_IDX] & 0x0f;
0633         haptics->gpi_ctl[num].seq_id =
0634             data[DA7280_CUSTOM_GPI_SEQ_ID_IDX] & 0x0f;
0635         haptics->op_mode = haptics->periodic_op_mode;
0636 
0637         val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK,
0638                  haptics->gpi_ctl[num].seq_id);
0639         error = regmap_update_bits(haptics->regmap,
0640                        DA7280_GPI_0_CTL + num,
0641                        DA7280_GPI0_SEQUENCE_ID_MASK,
0642                        val);
0643         if (error) {
0644             dev_err(haptics->dev,
0645                 "Failed to update GPI sequence: %d\n", error);
0646             return error;
0647         }
0648         break;
0649 
0650     default:
0651         dev_err(haptics->dev, "Unsupported effect type: %d\n",
0652             effect->type);
0653         return -EINVAL;
0654     }
0655 
0656     return 0;
0657 }
0658 
0659 static int da7280_haptics_playback(struct input_dev *dev,
0660                    int effect_id, int val)
0661 {
0662     struct da7280_haptic *haptics = input_get_drvdata(dev);
0663 
0664     if (!haptics->op_mode) {
0665         dev_warn(haptics->dev, "No effects have been uploaded\n");
0666         return -EINVAL;
0667     }
0668 
0669     if (likely(!haptics->suspended)) {
0670         haptics->val = val;
0671         schedule_work(&haptics->work);
0672     }
0673 
0674     return 0;
0675 }
0676 
0677 static int da7280_haptic_start(struct da7280_haptic *haptics)
0678 {
0679     int error;
0680 
0681     error = regmap_update_bits(haptics->regmap,
0682                    DA7280_TOP_CTL1,
0683                    DA7280_STANDBY_EN_MASK,
0684                    DA7280_STANDBY_EN_MASK);
0685     if (error) {
0686         dev_err(haptics->dev, "Unable to enable device: %d\n", error);
0687         return error;
0688     }
0689 
0690     return 0;
0691 }
0692 
0693 static void da7280_haptic_stop(struct da7280_haptic *haptics)
0694 {
0695     int error;
0696 
0697     cancel_work_sync(&haptics->work);
0698 
0699 
0700     da7280_haptic_deactivate(haptics);
0701 
0702     error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1,
0703                    DA7280_STANDBY_EN_MASK, 0);
0704     if (error)
0705         dev_err(haptics->dev, "Failed to disable device: %d\n", error);
0706 }
0707 
0708 static int da7280_haptic_open(struct input_dev *dev)
0709 {
0710     struct da7280_haptic *haptics = input_get_drvdata(dev);
0711 
0712     return da7280_haptic_start(haptics);
0713 }
0714 
0715 static void da7280_haptic_close(struct input_dev *dev)
0716 {
0717     struct da7280_haptic *haptics = input_get_drvdata(dev);
0718 
0719     da7280_haptic_stop(haptics);
0720 }
0721 
0722 static u8 da7280_haptic_of_mode_str(struct device *dev,
0723                     const char *str)
0724 {
0725     if (!strcmp(str, "LRA")) {
0726         return DA7280_LRA;
0727     } else if (!strcmp(str, "ERM-bar")) {
0728         return DA7280_ERM_BAR;
0729     } else if (!strcmp(str, "ERM-coin")) {
0730         return DA7280_ERM_COIN;
0731     } else {
0732         dev_warn(dev, "Invalid string - set to LRA\n");
0733         return DA7280_LRA;
0734     }
0735 }
0736 
0737 static u8 da7280_haptic_of_gpi_mode_str(struct device *dev,
0738                     const char *str)
0739 {
0740     if (!strcmp(str, "Single-pattern")) {
0741         return 0;
0742     } else if (!strcmp(str, "Multi-pattern")) {
0743         return 1;
0744     } else {
0745         dev_warn(dev, "Invalid string - set to Single-pattern\n");
0746         return 0;
0747     }
0748 }
0749 
0750 static u8 da7280_haptic_of_gpi_pol_str(struct device *dev,
0751                        const char *str)
0752 {
0753     if (!strcmp(str, "Rising-edge")) {
0754         return 0;
0755     } else if (!strcmp(str, "Falling-edge")) {
0756         return 1;
0757     } else if (!strcmp(str, "Both-edge")) {
0758         return 2;
0759     } else {
0760         dev_warn(dev, "Invalid string - set to Rising-edge\n");
0761         return 0;
0762     }
0763 }
0764 
0765 static u8 da7280_haptic_of_volt_rating_set(u32 val)
0766 {
0767     u32 voltage = val / DA7280_VOLTAGE_RATE_STEP + 1;
0768 
0769     return min_t(u32, voltage, 0xff);
0770 }
0771 
0772 static void da7280_parse_properties(struct device *dev,
0773                     struct da7280_haptic *haptics)
0774 {
0775     unsigned int i, mem[DA7280_SNP_MEM_SIZE];
0776     char gpi_str1[] = "dlg,gpi0-seq-id";
0777     char gpi_str2[] = "dlg,gpi0-mode";
0778     char gpi_str3[] = "dlg,gpi0-polarity";
0779     const char *str;
0780     u32 val;
0781     int error;
0782 
0783     /*
0784      * If there is no property, then use the mode programmed into the chip.
0785      */
0786     haptics->dev_type = DA7280_DEV_MAX;
0787     error = device_property_read_string(dev, "dlg,actuator-type", &str);
0788     if (!error)
0789         haptics->dev_type = da7280_haptic_of_mode_str(dev, str);
0790 
0791     haptics->const_op_mode = DA7280_DRO_MODE;
0792     error = device_property_read_u32(dev, "dlg,const-op-mode", &val);
0793     if (!error && val == DA7280_FF_PERIODIC_PWM)
0794         haptics->const_op_mode = DA7280_PWM_MODE;
0795 
0796     haptics->periodic_op_mode = DA7280_RTWM_MODE;
0797     error = device_property_read_u32(dev, "dlg,periodic-op-mode", &val);
0798     if (!error && val == DA7280_FF_PERIODIC_ETWM)
0799         haptics->periodic_op_mode = DA7280_ETWM_MODE;
0800 
0801     haptics->nommax = DA7280_SKIP_INIT;
0802     error = device_property_read_u32(dev, "dlg,nom-microvolt", &val);
0803     if (!error && val < DA7280_VOLTAGE_RATE_MAX)
0804         haptics->nommax = da7280_haptic_of_volt_rating_set(val);
0805 
0806     haptics->absmax = DA7280_SKIP_INIT;
0807     error = device_property_read_u32(dev, "dlg,abs-max-microvolt", &val);
0808     if (!error && val < DA7280_VOLTAGE_RATE_MAX)
0809         haptics->absmax = da7280_haptic_of_volt_rating_set(val);
0810 
0811     haptics->imax = DA7280_IMAX_DEFAULT;
0812     error = device_property_read_u32(dev, "dlg,imax-microamp", &val);
0813     if (!error && val < DA7280_IMAX_LIMIT)
0814         haptics->imax = (val - 28600) / DA7280_IMAX_STEP + 1;
0815 
0816     haptics->impd = DA7280_IMPD_DEFAULT;
0817     error = device_property_read_u32(dev, "dlg,impd-micro-ohms", &val);
0818     if (!error && val <= DA7280_IMPD_MAX)
0819         haptics->impd = val;
0820 
0821     haptics->resonant_freq_h = DA7280_SKIP_INIT;
0822     haptics->resonant_freq_l = DA7280_SKIP_INIT;
0823     error = device_property_read_u32(dev, "dlg,resonant-freq-hz", &val);
0824     if (!error) {
0825         if (val < DA7280_MAX_RESONAT_FREQ_HZ &&
0826             val > DA7280_MIN_RESONAT_FREQ_HZ) {
0827             haptics->resonant_freq_h =
0828                 ((1000000000 / (val * 1333)) >> 7) & 0xFF;
0829             haptics->resonant_freq_l =
0830                 (1000000000 / (val * 1333)) & 0x7F;
0831         } else {
0832             haptics->resonant_freq_h = DA7280_RESONT_FREQH_DFT;
0833             haptics->resonant_freq_l = DA7280_RESONT_FREQL_DFT;
0834         }
0835     }
0836 
0837     /* If no property, set to zero as default is to do nothing. */
0838     haptics->ps_seq_id = 0;
0839     error = device_property_read_u32(dev, "dlg,ps-seq-id", &val);
0840     if (!error && val <= DA7280_SEQ_ID_MAX)
0841         haptics->ps_seq_id = val;
0842 
0843     haptics->ps_seq_loop = 0;
0844     error = device_property_read_u32(dev, "dlg,ps-seq-loop", &val);
0845     if (!error && val <= DA7280_SEQ_LOOP_MAX)
0846         haptics->ps_seq_loop = val;
0847 
0848     /* GPI0~2 Control */
0849     for (i = 0; i <= DA7280_GPI_SEQ_ID_MAX; i++) {
0850         gpi_str1[7] = '0' + i;
0851         haptics->gpi_ctl[i].seq_id = DA7280_GPI_SEQ_ID_DFT + i;
0852         error = device_property_read_u32 (dev, gpi_str1, &val);
0853         if (!error && val <= DA7280_SEQ_ID_MAX)
0854             haptics->gpi_ctl[i].seq_id = val;
0855 
0856         gpi_str2[7] = '0' + i;
0857         haptics->gpi_ctl[i].mode = 0;
0858         error = device_property_read_string(dev, gpi_str2, &str);
0859         if (!error)
0860             haptics->gpi_ctl[i].mode =
0861                 da7280_haptic_of_gpi_mode_str(dev, str);
0862 
0863         gpi_str3[7] = '0' + i;
0864         haptics->gpi_ctl[i].polarity = 0;
0865         error = device_property_read_string(dev, gpi_str3, &str);
0866         if (!error)
0867             haptics->gpi_ctl[i].polarity =
0868                 da7280_haptic_of_gpi_pol_str(dev, str);
0869     }
0870 
0871     haptics->bemf_sense_en =
0872         device_property_read_bool(dev, "dlg,bemf-sens-enable");
0873     haptics->freq_track_en =
0874         device_property_read_bool(dev, "dlg,freq-track-enable");
0875     haptics->acc_en =
0876         device_property_read_bool(dev, "dlg,acc-enable");
0877     haptics->rapid_stop_en =
0878         device_property_read_bool(dev, "dlg,rapid-stop-enable");
0879     haptics->amp_pid_en =
0880         device_property_read_bool(dev, "dlg,amp-pid-enable");
0881 
0882     haptics->mem_update = false;
0883     error = device_property_read_u32_array(dev, "dlg,mem-array",
0884                            &mem[0], DA7280_SNP_MEM_SIZE);
0885     if (!error) {
0886         haptics->mem_update = true;
0887         memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE);
0888         for (i = 0; i < DA7280_SNP_MEM_SIZE; i++) {
0889             if (mem[i] <= 0xff) {
0890                 haptics->snp_mem[i] = (u8)mem[i];
0891             } else {
0892                 dev_err(haptics->dev,
0893                     "Invalid data in mem-array at %d: %x\n",
0894                     i, mem[i]);
0895                 haptics->mem_update = false;
0896                 break;
0897             }
0898         }
0899     }
0900 }
0901 
0902 static irqreturn_t da7280_irq_handler(int irq, void *data)
0903 {
0904     struct da7280_haptic *haptics = data;
0905     struct device *dev = haptics->dev;
0906     u8 events[DA7280_IRQ_NUM];
0907     int error;
0908 
0909     /* Check what events have happened */
0910     error = regmap_bulk_read(haptics->regmap, DA7280_IRQ_EVENT1,
0911                  events, sizeof(events));
0912     if (error) {
0913         dev_err(dev, "failed to read interrupt data: %d\n", error);
0914         goto out;
0915     }
0916 
0917     /* Clear events */
0918     error = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, events[0]);
0919     if (error) {
0920         dev_err(dev, "failed to clear interrupts: %d\n", error);
0921         goto out;
0922     }
0923 
0924     if (events[0] & DA7280_E_SEQ_FAULT_MASK) {
0925         /*
0926          * Stop first if haptic is active, otherwise, the fault may
0927          * happen continually even though the bit is cleared.
0928          */
0929         error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1,
0930                        DA7280_OPERATION_MODE_MASK, 0);
0931         if (error)
0932             dev_err(dev, "failed to clear op mode on fault: %d\n",
0933                 error);
0934     }
0935 
0936     if (events[0] & DA7280_E_SEQ_DONE_MASK)
0937         haptics->active = false;
0938 
0939     if (events[0] & DA7280_E_WARNING_MASK) {
0940         if (events[1] & DA7280_E_LIM_DRIVE_MASK ||
0941             events[1] & DA7280_E_LIM_DRIVE_ACC_MASK)
0942             dev_warn(dev, "Please reduce the driver level\n");
0943         if (events[1] & DA7280_E_MEM_TYPE_MASK)
0944             dev_warn(dev, "Please check the mem data format\n");
0945         if (events[1] & DA7280_E_OVERTEMP_WARN_MASK)
0946             dev_warn(dev, "Over-temperature warning\n");
0947     }
0948 
0949     if (events[0] & DA7280_E_SEQ_FAULT_MASK) {
0950         if (events[2] & DA7280_E_SEQ_ID_FAULT_MASK)
0951             dev_info(dev, "Please reload PS_SEQ_ID & mem data\n");
0952         if (events[2] & DA7280_E_MEM_FAULT_MASK)
0953             dev_info(dev, "Please reload the mem data\n");
0954         if (events[2] & DA7280_E_PWM_FAULT_MASK)
0955             dev_info(dev, "Please restart PWM interface\n");
0956     }
0957 
0958 out:
0959     return IRQ_HANDLED;
0960 }
0961 
0962 static int da7280_init(struct da7280_haptic *haptics)
0963 {
0964     unsigned int val = 0;
0965     u32 v2i_factor;
0966     int error, i;
0967     u8 mask = 0;
0968 
0969     /*
0970      * If device type is DA7280_DEV_MAX then simply use currently
0971      * programmed mode.
0972      */
0973     if (haptics->dev_type == DA7280_DEV_MAX) {
0974         error = regmap_read(haptics->regmap, DA7280_TOP_CFG1, &val);
0975         if (error)
0976             goto out_err;
0977 
0978         haptics->dev_type = val & DA7280_ACTUATOR_TYPE_MASK ?
0979                     DA7280_ERM_COIN : DA7280_LRA;
0980     }
0981 
0982     /* Apply user settings */
0983     if (haptics->dev_type == DA7280_LRA &&
0984         haptics->resonant_freq_l != DA7280_SKIP_INIT) {
0985         error = regmap_write(haptics->regmap, DA7280_FRQ_LRA_PER_H,
0986                      haptics->resonant_freq_h);
0987         if (error)
0988             goto out_err;
0989         error = regmap_write(haptics->regmap, DA7280_FRQ_LRA_PER_L,
0990                      haptics->resonant_freq_l);
0991         if (error)
0992             goto out_err;
0993     } else if (haptics->dev_type == DA7280_ERM_COIN) {
0994         error = regmap_update_bits(haptics->regmap, DA7280_TOP_INT_CFG1,
0995                        DA7280_BEMF_FAULT_LIM_MASK, 0);
0996         if (error)
0997             goto out_err;
0998 
0999         mask = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK |
1000             DA7280_V2I_FACTOR_FREEZE_MASK;
1001         val = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK |
1002             DA7280_V2I_FACTOR_FREEZE_MASK;
1003         error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG4,
1004                        mask, val);
1005         if (error)
1006             goto out_err;
1007 
1008         haptics->acc_en = false;
1009         haptics->rapid_stop_en = false;
1010         haptics->amp_pid_en = false;
1011     }
1012 
1013     mask = DA7280_ACTUATOR_TYPE_MASK |
1014             DA7280_BEMF_SENSE_EN_MASK |
1015             DA7280_FREQ_TRACK_EN_MASK |
1016             DA7280_ACCELERATION_EN_MASK |
1017             DA7280_RAPID_STOP_EN_MASK |
1018             DA7280_AMP_PID_EN_MASK;
1019     val = FIELD_PREP(DA7280_ACTUATOR_TYPE_MASK,
1020              (haptics->dev_type ? 1 : 0)) |
1021         FIELD_PREP(DA7280_BEMF_SENSE_EN_MASK,
1022                (haptics->bemf_sense_en ? 1 : 0)) |
1023         FIELD_PREP(DA7280_FREQ_TRACK_EN_MASK,
1024                (haptics->freq_track_en ? 1 : 0)) |
1025         FIELD_PREP(DA7280_ACCELERATION_EN_MASK,
1026                (haptics->acc_en ? 1 : 0)) |
1027         FIELD_PREP(DA7280_RAPID_STOP_EN_MASK,
1028                (haptics->rapid_stop_en ? 1 : 0)) |
1029         FIELD_PREP(DA7280_AMP_PID_EN_MASK,
1030                (haptics->amp_pid_en ? 1 : 0));
1031 
1032     error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG1, mask, val);
1033     if (error)
1034         goto out_err;
1035 
1036     error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG5,
1037                    DA7280_V2I_FACTOR_OFFSET_EN_MASK,
1038                    haptics->acc_en ?
1039                     DA7280_V2I_FACTOR_OFFSET_EN_MASK : 0);
1040     if (error)
1041         goto out_err;
1042 
1043     error = regmap_update_bits(haptics->regmap,
1044                    DA7280_TOP_CFG2,
1045                    DA7280_MEM_DATA_SIGNED_MASK,
1046                    haptics->acc_en ?
1047                     0 : DA7280_MEM_DATA_SIGNED_MASK);
1048     if (error)
1049         goto out_err;
1050 
1051     if (haptics->nommax != DA7280_SKIP_INIT) {
1052         error = regmap_write(haptics->regmap, DA7280_ACTUATOR1,
1053                      haptics->nommax);
1054         if (error)
1055             goto out_err;
1056     }
1057 
1058     if (haptics->absmax != DA7280_SKIP_INIT) {
1059         error = regmap_write(haptics->regmap, DA7280_ACTUATOR2,
1060                      haptics->absmax);
1061         if (error)
1062             goto out_err;
1063     }
1064 
1065     error = regmap_update_bits(haptics->regmap, DA7280_ACTUATOR3,
1066                    DA7280_IMAX_MASK, haptics->imax);
1067     if (error)
1068         goto out_err;
1069 
1070     v2i_factor = haptics->impd * (haptics->imax + 4) / 1610400;
1071     error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_L,
1072                  v2i_factor & 0xff);
1073     if (error)
1074         goto out_err;
1075     error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_H,
1076                  v2i_factor >> 8);
1077     if (error)
1078         goto out_err;
1079 
1080     error = regmap_update_bits(haptics->regmap,
1081                    DA7280_TOP_CTL1,
1082                    DA7280_STANDBY_EN_MASK,
1083                    DA7280_STANDBY_EN_MASK);
1084     if (error)
1085         goto out_err;
1086 
1087     if (haptics->mem_update) {
1088         error = da7280_haptic_mem_update(haptics);
1089         if (error)
1090             goto out_err;
1091     }
1092 
1093     /* Set  PS_SEQ_ID and PS_SEQ_LOOP */
1094     val = FIELD_PREP(DA7280_PS_SEQ_ID_MASK, haptics->ps_seq_id) |
1095         FIELD_PREP(DA7280_PS_SEQ_LOOP_MASK, haptics->ps_seq_loop);
1096     error = regmap_write(haptics->regmap, DA7280_SEQ_CTL2, val);
1097     if (error)
1098         goto out_err;
1099 
1100     /* GPI(N) CTL */
1101     for (i = 0; i < 3; i++) {
1102         val = FIELD_PREP(DA7280_GPI0_SEQUENCE_ID_MASK,
1103                  haptics->gpi_ctl[i].seq_id) |
1104             FIELD_PREP(DA7280_GPI0_MODE_MASK,
1105                    haptics->gpi_ctl[i].mode) |
1106             FIELD_PREP(DA7280_GPI0_POLARITY_MASK,
1107                    haptics->gpi_ctl[i].polarity);
1108         error = regmap_write(haptics->regmap,
1109                      DA7280_GPI_0_CTL + i, val);
1110         if (error)
1111             goto out_err;
1112     }
1113 
1114     /* Mask ADC_SAT_M bit as default */
1115     error = regmap_update_bits(haptics->regmap,
1116                    DA7280_IRQ_MASK2,
1117                    DA7280_ADC_SAT_M_MASK,
1118                    DA7280_ADC_SAT_M_MASK);
1119     if (error)
1120         goto out_err;
1121 
1122     /* Clear Interrupts */
1123     error = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, 0xff);
1124     if (error)
1125         goto out_err;
1126 
1127     error = regmap_update_bits(haptics->regmap,
1128                    DA7280_IRQ_MASK1,
1129                    DA7280_SEQ_FAULT_M_MASK |
1130                     DA7280_SEQ_DONE_M_MASK,
1131                    0);
1132     if (error)
1133         goto out_err;
1134 
1135     haptics->active = false;
1136     return 0;
1137 
1138 out_err:
1139     dev_err(haptics->dev, "chip initialization error: %d\n", error);
1140     return error;
1141 }
1142 
1143 static int da7280_probe(struct i2c_client *client,
1144             const struct i2c_device_id *id)
1145 {
1146     struct device *dev = &client->dev;
1147     struct da7280_haptic *haptics;
1148     struct input_dev *input_dev;
1149     struct pwm_state state;
1150     struct ff_device *ff;
1151     int error;
1152 
1153     if (!client->irq) {
1154         dev_err(dev, "No IRQ configured\n");
1155         return -EINVAL;
1156     }
1157 
1158     haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL);
1159     if (!haptics)
1160         return -ENOMEM;
1161 
1162     haptics->dev = dev;
1163 
1164     da7280_parse_properties(dev, haptics);
1165 
1166     if (haptics->const_op_mode == DA7280_PWM_MODE) {
1167         haptics->pwm_dev = devm_pwm_get(dev, NULL);
1168         error = PTR_ERR_OR_ZERO(haptics->pwm_dev);
1169         if (error) {
1170             if (error != -EPROBE_DEFER)
1171                 dev_err(dev, "Unable to request PWM: %d\n",
1172                     error);
1173             return error;
1174         }
1175 
1176         /* Sync up PWM state and ensure it is off. */
1177         pwm_init_state(haptics->pwm_dev, &state);
1178         state.enabled = false;
1179         error = pwm_apply_state(haptics->pwm_dev, &state);
1180         if (error) {
1181             dev_err(dev, "Failed to apply PWM state: %d\n", error);
1182             return error;
1183         }
1184 
1185         /*
1186          * Check PWM period, PWM freq = 1000000 / state.period.
1187          * The valid PWM freq range: 10k ~ 250kHz.
1188          */
1189         if (state.period > 100000 || state.period < 4000) {
1190             dev_err(dev, "Unsupported PWM period: %lld\n",
1191                 state.period);
1192             return -EINVAL;
1193         }
1194     }
1195 
1196     INIT_WORK(&haptics->work, da7280_haptic_work);
1197 
1198     haptics->client = client;
1199     i2c_set_clientdata(client, haptics);
1200 
1201     haptics->regmap = devm_regmap_init_i2c(client,
1202                            &da7280_haptic_regmap_config);
1203     error = PTR_ERR_OR_ZERO(haptics->regmap);
1204     if (error) {
1205         dev_err(dev, "Failed to allocate register map: %d\n", error);
1206         return error;
1207     }
1208 
1209     error = da7280_init(haptics);
1210     if (error) {
1211         dev_err(dev, "Failed to initialize device: %d\n", error);
1212         return error;
1213     }
1214 
1215     /* Initialize input device for haptic device */
1216     input_dev = devm_input_allocate_device(dev);
1217     if (!input_dev) {
1218         dev_err(dev, "Failed to allocate input device\n");
1219         return -ENOMEM;
1220     }
1221 
1222     input_dev->name = "da7280-haptic";
1223     input_dev->dev.parent = client->dev.parent;
1224     input_dev->open = da7280_haptic_open;
1225     input_dev->close = da7280_haptic_close;
1226     input_set_drvdata(input_dev, haptics);
1227     haptics->input_dev = input_dev;
1228 
1229     input_set_capability(haptics->input_dev, EV_FF, FF_PERIODIC);
1230     input_set_capability(haptics->input_dev, EV_FF, FF_CUSTOM);
1231     input_set_capability(haptics->input_dev, EV_FF, FF_CONSTANT);
1232     input_set_capability(haptics->input_dev, EV_FF, FF_GAIN);
1233 
1234     error = input_ff_create(haptics->input_dev,
1235                 DA7280_FF_EFFECT_COUNT_MAX);
1236     if (error) {
1237         dev_err(dev, "Failed to create FF input device: %d\n", error);
1238         return error;
1239     }
1240 
1241     ff = input_dev->ff;
1242     ff->upload = da7280_haptics_upload_effect;
1243     ff->playback = da7280_haptics_playback;
1244 
1245     error = input_register_device(input_dev);
1246     if (error) {
1247         dev_err(dev, "Failed to register input device: %d\n", error);
1248         return error;
1249     }
1250 
1251     error = devm_request_threaded_irq(dev, client->irq,
1252                       NULL, da7280_irq_handler,
1253                       IRQF_ONESHOT,
1254                       "da7280-haptics", haptics);
1255     if (error) {
1256         dev_err(dev, "Failed to request IRQ %d: %d\n",
1257             client->irq, error);
1258         return error;
1259     }
1260 
1261     return 0;
1262 }
1263 
1264 static int __maybe_unused da7280_suspend(struct device *dev)
1265 {
1266     struct da7280_haptic *haptics = dev_get_drvdata(dev);
1267 
1268     mutex_lock(&haptics->input_dev->mutex);
1269 
1270     /*
1271      * Make sure no new requests will be submitted while device is
1272      * suspended.
1273      */
1274     spin_lock_irq(&haptics->input_dev->event_lock);
1275     haptics->suspended = true;
1276     spin_unlock_irq(&haptics->input_dev->event_lock);
1277 
1278     da7280_haptic_stop(haptics);
1279 
1280     mutex_unlock(&haptics->input_dev->mutex);
1281 
1282     return 0;
1283 }
1284 
1285 static int __maybe_unused da7280_resume(struct device *dev)
1286 {
1287     struct da7280_haptic *haptics = dev_get_drvdata(dev);
1288     int retval;
1289 
1290     mutex_lock(&haptics->input_dev->mutex);
1291 
1292     retval = da7280_haptic_start(haptics);
1293     if (!retval) {
1294         spin_lock_irq(&haptics->input_dev->event_lock);
1295         haptics->suspended = false;
1296         spin_unlock_irq(&haptics->input_dev->event_lock);
1297     }
1298 
1299     mutex_unlock(&haptics->input_dev->mutex);
1300     return retval;
1301 }
1302 
1303 #ifdef CONFIG_OF
1304 static const struct of_device_id da7280_of_match[] = {
1305     { .compatible = "dlg,da7280", },
1306     { }
1307 };
1308 MODULE_DEVICE_TABLE(of, da7280_of_match);
1309 #endif
1310 
1311 static const struct i2c_device_id da7280_i2c_id[] = {
1312     { "da7280", },
1313     { }
1314 };
1315 MODULE_DEVICE_TABLE(i2c, da7280_i2c_id);
1316 
1317 static SIMPLE_DEV_PM_OPS(da7280_pm_ops, da7280_suspend, da7280_resume);
1318 
1319 static struct i2c_driver da7280_driver = {
1320     .driver = {
1321         .name = "da7280",
1322         .of_match_table = of_match_ptr(da7280_of_match),
1323         .pm = &da7280_pm_ops,
1324     },
1325     .probe = da7280_probe,
1326     .id_table = da7280_i2c_id,
1327 };
1328 module_i2c_driver(da7280_driver);
1329 
1330 MODULE_DESCRIPTION("DA7280 haptics driver");
1331 MODULE_AUTHOR("Roy Im <Roy.Im.Opensource@diasemi.com>");
1332 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!