Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329// SPDX-License-Identifier: GPL-2.0+/* * DA7280 Haptic device driver * * Copyright (c) 2020 Dialog Semiconductor. * Author: Roy Im <Roy.Im.Opensource@diasemi.com> */
#include <linux/bitfield.h>#include <linux/bitops.h>#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 <linux/uaccess.h>
/* Registers */#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_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_TOP_CFG1 0x13#define DA7280_TOP_CFG2 0x14#define DA7280_TOP_CFG4 0x16#define DA7280_TOP_INT_CFG1 0x17#define DA7280_TOP_CTL1 0x22#define DA7280_TOP_CTL2 0x23#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_TOP_CFG5 0x6E#define DA7280_IRQ_MASK2 0x83#define DA7280_SNP_MEM_99 0xE7
/* Register field */
/* DA7280_IRQ_EVENT1 (Address 0x03) */#define DA7280_E_SEQ_CONTINUE_MASK BIT(0)#define DA7280_E_UVLO_MASK BIT(1)#define DA7280_E_SEQ_DONE_MASK BIT(2)#define DA7280_E_OVERTEMP_CRIT_MASK BIT(3)#define DA7280_E_SEQ_FAULT_MASK BIT(4)#define DA7280_E_WARNING_MASK BIT(5)#define DA7280_E_ACTUATOR_FAULT_MASK BIT(6)#define DA7280_E_OC_FAULT_MASK BIT(7)
/* DA7280_IRQ_EVENT_WARNING_DIAG (Address 0x04) */#define DA7280_E_OVERTEMP_WARN_MASK BIT(3)#define DA7280_E_MEM_TYPE_MASK BIT(4)#define DA7280_E_LIM_DRIVE_ACC_MASK BIT(6)#define DA7280_E_LIM_DRIVE_MASK BIT(7)
/* DA7280_IRQ_EVENT_PAT_DIAG (Address 0x05) */#define DA7280_E_PWM_FAULT_MASK BIT(5)#define DA7280_E_MEM_FAULT_MASK BIT(6)#define DA7280_E_SEQ_ID_FAULT_MASK BIT(7)
/* DA7280_IRQ_STATUS1 (Address 0x06) */#define DA7280_STA_SEQ_CONTINUE_MASK BIT(0)#define DA7280_STA_UVLO_VBAT_OK_MASK BIT(1)#define DA7280_STA_SEQ_DONE_MASK BIT(2)#define DA7280_STA_OVERTEMP_CRIT_MASK BIT(3)#define DA7280_STA_SEQ_FAULT_MASK BIT(4)#define DA7280_STA_WARNING_MASK BIT(5)#define DA7280_STA_ACTUATOR_MASK BIT(6)#define DA7280_STA_OC_MASK BIT(7)
/* DA7280_IRQ_MASK1 (Address 0x07) */#define DA7280_SEQ_CONTINUE_M_MASK BIT(0)#define DA7280_E_UVLO_M_MASK BIT(1)#define DA7280_SEQ_DONE_M_MASK BIT(2)#define DA7280_OVERTEMP_CRIT_M_MASK BIT(3)#define DA7280_SEQ_FAULT_M_MASK BIT(4)#define DA7280_WARNING_M_MASK BIT(5)#define DA7280_ACTUATOR_M_MASK BIT(6)#define DA7280_OC_M_MASK BIT(7)
/* DA7280_ACTUATOR3 (Address 0x0e) */#define DA7280_IMAX_MASK GENMASK(4, 0)
/* DA7280_TOP_CFG1 (Address 0x13) */#define DA7280_AMP_PID_EN_MASK BIT(0)#define DA7280_RAPID_STOP_EN_MASK BIT(1)#define DA7280_ACCELERATION_EN_MASK BIT(2)#define DA7280_FREQ_TRACK_EN_MASK BIT(3)#define DA7280_BEMF_SENSE_EN_MASK BIT(4)#define DA7280_ACTUATOR_TYPE_MASK BIT(5)
/* DA7280_TOP_CFG2 (Address 0x14) */#define DA7280_FULL_BRAKE_THR_MASK GENMASK(3, 0)#define DA7280_MEM_DATA_SIGNED_MASK BIT(4)
/* DA7280_TOP_CFG4 (Address 0x16) */#define DA7280_TST_CALIB_IMPEDANCE_DIS_MASK BIT(6)#define DA7280_V2I_FACTOR_FREEZE_MASK BIT(7)
/* DA7280_TOP_INT_CFG1 (Address 0x17) */#define DA7280_BEMF_FAULT_LIM_MASK GENMASK(1, 0)
/* DA7280_TOP_CTL1 (Address 0x22) */#define DA7280_OPERATION_MODE_MASK GENMASK(2, 0)#define DA7280_STANDBY_EN_MASK BIT(3)#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)
/* 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)
/* 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)
/* 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)
/* DA7280_MEM_CTL2 (Address 0x2d) */#define DA7280_WAV_MEM_LOCK_MASK BIT(7)
/* DA7280_TOP_CFG5 (Address 0x6e) */#define DA7280_V2I_FACTOR_OFFSET_EN_MASK BIT(0)
/* DA7280_IRQ_MASK2 (Address 0x83) */#define DA7280_ADC_SAT_M_MASK BIT(7)
/* Controls */
#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 1500000000#define DA7280_IMPD_DEFAULT 22000000
#define DA7280_IMAX_DEFAULT 0x0E#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_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_SNP_MEM_SIZE 100#define DA7280_SNP_MEM_MAX DA7280_SNP_MEM_99
#define DA7280_IRQ_NUM 3
#define DA7280_SKIP_INIT 0x100
#define DA7280_FF_EFFECT_COUNT_MAX 15
/* Maximum gain is 0x7fff for PWM mode */#define DA7280_MAX_MAGNITUDE_SHIFT 15
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,};
#define DA7280_FF_CONSTANT_DRO 1#define DA7280_FF_PERIODIC_PWM 2#define DA7280_FF_PERIODIC_RTWM 1#define DA7280_FF_PERIODIC_ETWM 2
#define DA7280_FF_PERIODIC_MODE DA7280_RTWM_MODE#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,};
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;
struct work_struct work; int val; u16 gain; s16 level;
u8 dev_type; u8 op_mode; u8 const_op_mode; u8 periodic_op_mode; u16 nommax; u16 absmax; u32 imax; u32 impd; u32 resonant_freq_h; u32 resonant_freq_l; bool bemf_sense_en; bool freq_track_en; bool acc_en; bool rapid_stop_en; bool 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]; bool active; bool suspended;};
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 true; default: return false; }}
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){ unsigned int val; int error;
/* The patterns should be updated when haptic is not working */ error = regmap_read(haptics->regmap, DA7280_IRQ_STATUS1, &val); if (error) return error; 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; error = regmap_read(haptics->regmap, DA7280_MEM_CTL2, &val); if (error) return error; 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 */ error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_OPERATION_MODE_MASK, 0); if (error) return error;
error = regmap_read(haptics->regmap, DA7280_MEM_CTL1, &val); if (error) return error;
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, bool enabled){ struct pwm_state state; u64 period_mag_multi; int error;
if (!haptics->gain && enabled) { dev_err(haptics->dev, "Unable to enable pwm with 0 gain\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 >>= DA7280_MAX_MAGNITUDE_SHIFT;
/* * 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. */ if (!haptics->acc_en) { period_mag_multi += state.period; period_mag_multi /= 2; }
state.duty_cycle = period_mag_multi; }
error = pwm_apply_might_sleep(haptics->pwm_dev, &state); if (error) dev_err(haptics->dev, "Failed to apply pwm state: %d\n", error);
return error;}
static void da7280_haptic_activate(struct da7280_haptic *haptics){ int error;
if (haptics->active) return;
switch (haptics->op_mode) { case DA7280_DRO_MODE: /* the valid range check when acc_en is enabled */ if (haptics->acc_en && haptics->level > 0x7F) haptics->level = 0x7F; else if (haptics->level > 0xFF) haptics->level = 0xFF;
/* Set level as a % of ACTUATOR_NOMMAX (nommax) */ error = regmap_write(haptics->regmap, DA7280_TOP_CTL2, haptics->level); if (error) { dev_err(haptics->dev, "Failed to set level to %d: %d\n", haptics->level, error); return; } break;
case DA7280_PWM_MODE: if (da7280_haptic_set_pwm(haptics, true)) return; break;
case DA7280_RTWM_MODE: /* * The pattern will be played by the PS_SEQ_ID and the * PS_SEQ_LOOP */ break;
case DA7280_ETWM_MODE: /* * The pattern will be played by the GPI[N] state, * GPI(N)_SEQUENCE_ID and the PS_SEQ_LOOP. See the * datasheet for the details. */ break;
default: dev_err(haptics->dev, "Invalid op mode %d\n", haptics->op_mode); return; }
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_OPERATION_MODE_MASK, haptics->op_mode); if (error) { dev_err(haptics->dev, "Failed to set operation mode: %d", error); return; }
if (haptics->op_mode == DA7280_PWM_MODE || haptics->op_mode == DA7280_RTWM_MODE) { error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_SEQ_START_MASK, DA7280_SEQ_START_MASK); if (error) { dev_err(haptics->dev, "Failed to start sequence: %d\n", error); return; } }
haptics->active = true;}
static void da7280_haptic_deactivate(struct da7280_haptic *haptics){ int error;
if (!haptics->active) return;
/* Set to Inactive mode */ error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_OPERATION_MODE_MASK, 0); if (error) { dev_err(haptics->dev, "Failed to clear operation mode: %d", error); return; }
switch (haptics->op_mode) { case DA7280_DRO_MODE: error = regmap_write(haptics->regmap, DA7280_TOP_CTL2, 0); if (error) { dev_err(haptics->dev, "Failed to disable DRO mode: %d\n", error); return; } break;
case DA7280_PWM_MODE: if (da7280_haptic_set_pwm(haptics, false)) return; break;
case DA7280_RTWM_MODE: case DA7280_ETWM_MODE: error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_SEQ_START_MASK, 0); if (error) { dev_err(haptics->dev, "Failed to disable RTWM/ETWM mode: %d\n", error); return; } break;
default: dev_err(haptics->dev, "Invalid op mode %d\n", haptics->op_mode); return; }
haptics->active = false;}
static void da7280_haptic_work(struct work_struct *work){ struct da7280_haptic *haptics = container_of(work, struct da7280_haptic, work); int val = haptics->val;
if (val) da7280_haptic_activate(haptics); else da7280_haptic_deactivate(haptics);}
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); 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->active) return -EBUSY;
switch (effect->type) { /* DRO/PWM modes support this type */ case FF_CONSTANT: haptics->op_mode = haptics->const_op_mode; if (haptics->op_mode == DA7280_DRO_MODE) { tmp = effect->u.constant.level * 254; haptics->level = tmp / 0x7FFF; break; }
haptics->gain = effect->u.constant.level <= 0 ? 0 : effect->u.constant.level; break;
/* RTWM/ETWM modes support this type */ case FF_PERIODIC: if (effect->u.periodic.waveform != FF_CUSTOM) { dev_err(haptics->dev, "Device can only accept FF_CUSTOM waveform\n"); return -EINVAL; }
/* * Load the data and check the length. * the data will be patterns in this case: 4 < 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 (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;
if (effect->u.periodic.custom_len < DA7280_CUSTOM_DATA_LEN || effect->u.periodic.custom_len > DA7280_SNP_MEM_SIZE) { dev_err(haptics->dev, "Invalid waveform data size\n"); return -EINVAL; }
if (copy_from_user(data, effect->u.periodic.custom_data, sizeof(s16) * effect->u.periodic.custom_len)) return -EFAULT;
memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE);
for (i = 0; i < effect->u.periodic.custom_len; i++) { if (data[i] < 0 || data[i] > 0xff) { dev_err(haptics->dev, "Invalid waveform data %d at offset %d\n", data[i], i); return -EINVAL; } haptics->snp_mem[i] = (u8)data[i]; }
error = da7280_haptic_mem_update(haptics); if (error) { dev_err(haptics->dev, "Failed to upload waveform: %d\n", error); return error; } break;
set_seq_id_loop: if (copy_from_user(data, effect->u.periodic.custom_data, sizeof(s16) * DA7280_CUSTOM_DATA_LEN)) 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 (%d) or loop (%d)\n", data[DA7280_CUSTOM_SEQ_ID_IDX], data[DA7280_CUSTOM_SEQ_LOOP_IDX]); return -EINVAL; }
haptics->ps_seq_id = data[DA7280_CUSTOM_SEQ_ID_IDX] & 0x0f; haptics->ps_seq_loop = data[DA7280_CUSTOM_SEQ_LOOP_IDX] & 0x0f; 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); error = regmap_write(haptics->regmap, DA7280_SEQ_CTL2, val); if (error) { dev_err(haptics->dev, "Failed to update PS sequence: %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)) 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 (%d) or num (%d)\n", data[DA7280_CUSTOM_GPI_SEQ_ID_IDX], data[DA7280_CUSTOM_GPI_NUM_IDX]); 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, "Failed to update GPI sequence: %d\n", error); return error; } break;
default: dev_err(haptics->dev, "Unsupported effect type: %d\n", effect->type); return -EINVAL; }
return 0;}
static int da7280_haptics_playback(struct input_dev *dev, int effect_id, int val){ struct da7280_haptic *haptics = input_get_drvdata(dev);
if (!haptics->op_mode) { dev_warn(haptics->dev, "No effects have been uploaded\n"); return -EINVAL; }
if (likely(!haptics->suspended)) { haptics->val = val; schedule_work(&haptics->work); }
return 0;}
static int da7280_haptic_start(struct da7280_haptic *haptics){ int error;
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_STANDBY_EN_MASK, DA7280_STANDBY_EN_MASK); if (error) { dev_err(haptics->dev, "Unable to enable device: %d\n", error); return error; }
return 0;}
static void da7280_haptic_stop(struct da7280_haptic *haptics){ int error;
cancel_work_sync(&haptics->work);
da7280_haptic_deactivate(haptics);
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_STANDBY_EN_MASK, 0); if (error) dev_err(haptics->dev, "Failed to disable device: %d\n", error);}
static int da7280_haptic_open(struct input_dev *dev){ struct da7280_haptic *haptics = input_get_drvdata(dev);
return da7280_haptic_start(haptics);}
static void da7280_haptic_close(struct input_dev *dev){ struct da7280_haptic *haptics = input_get_drvdata(dev);
da7280_haptic_stop(haptics);}
static u8 da7280_haptic_of_mode_str(struct device *dev, const char *str){ if (!strcmp(str, "LRA")) { return DA7280_LRA; } else if (!strcmp(str, "ERM-bar")) { return DA7280_ERM_BAR; } else if (!strcmp(str, "ERM-coin")) { return DA7280_ERM_COIN; } else { dev_warn(dev, "Invalid string - set to LRA\n"); return DA7280_LRA; }}
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; } else { dev_warn(dev, "Invalid string - set to Single-pattern\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; } else { dev_warn(dev, "Invalid string - set to Rising-edge\n"); return 0; }}
static u8 da7280_haptic_of_volt_rating_set(u32 val){ u32 voltage = val / DA7280_VOLTAGE_RATE_STEP + 1;
return min_t(u32, voltage, 0xff);}
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"; const char *str; u32 val; int error;
/* * If there is no property, then use the mode programmed into the chip. */ haptics->dev_type = DA7280_DEV_MAX; error = device_property_read_string(dev, "dlg,actuator-type", &str); if (!error) haptics->dev_type = da7280_haptic_of_mode_str(dev, str);
haptics->const_op_mode = DA7280_DRO_MODE; error = device_property_read_u32(dev, "dlg,const-op-mode", &val); if (!error && val == DA7280_FF_PERIODIC_PWM) haptics->const_op_mode = DA7280_PWM_MODE;
haptics->periodic_op_mode = DA7280_RTWM_MODE; error = device_property_read_u32(dev, "dlg,periodic-op-mode", &val); if (!error && val == DA7280_FF_PERIODIC_ETWM) haptics->periodic_op_mode = DA7280_ETWM_MODE;
haptics->nommax = DA7280_SKIP_INIT; error = device_property_read_u32(dev, "dlg,nom-microvolt", &val); if (!error && val < DA7280_VOLTAGE_RATE_MAX) haptics->nommax = da7280_haptic_of_volt_rating_set(val);
haptics->absmax = DA7280_SKIP_INIT; error = device_property_read_u32(dev, "dlg,abs-max-microvolt", &val); if (!error && val < DA7280_VOLTAGE_RATE_MAX) haptics->absmax = da7280_haptic_of_volt_rating_set(val);
haptics->imax = DA7280_IMAX_DEFAULT; error = device_property_read_u32(dev, "dlg,imax-microamp", &val); if (!error && val < DA7280_IMAX_LIMIT) haptics->imax = (val - 28600) / DA7280_IMAX_STEP + 1;
haptics->impd = DA7280_IMPD_DEFAULT; error = device_property_read_u32(dev, "dlg,impd-micro-ohms", &val); if (!error && val <= DA7280_IMPD_MAX) haptics->impd = val;
haptics->resonant_freq_h = DA7280_SKIP_INIT; haptics->resonant_freq_l = DA7280_SKIP_INIT; error = device_property_read_u32(dev, "dlg,resonant-freq-hz", &val); if (!error) { if (val < DA7280_MAX_RESONAT_FREQ_HZ && val > DA7280_MIN_RESONAT_FREQ_HZ) { haptics->resonant_freq_h = ((1000000000 / (val * 1333)) >> 7) & 0xFF; haptics->resonant_freq_l = (1000000000 / (val * 1333)) & 0x7F; } else { haptics->resonant_freq_h = DA7280_RESONT_FREQH_DFT; haptics->resonant_freq_l = DA7280_RESONT_FREQL_DFT; } }
/* If no property, set to zero as default is to do nothing. */ haptics->ps_seq_id = 0; error = device_property_read_u32(dev, "dlg,ps-seq-id", &val); if (!error && val <= DA7280_SEQ_ID_MAX) haptics->ps_seq_id = val;
haptics->ps_seq_loop = 0; error = device_property_read_u32(dev, "dlg,ps-seq-loop", &val); if (!error && val <= DA7280_SEQ_LOOP_MAX) haptics->ps_seq_loop = val;
/* GPI0~2 Control */ for (i = 0; i <= DA7280_GPI_SEQ_ID_MAX; i++) { gpi_str1[7] = '0' + i; haptics->gpi_ctl[i].seq_id = DA7280_GPI_SEQ_ID_DFT + i; error = device_property_read_u32 (dev, gpi_str1, &val); if (!error && val <= DA7280_SEQ_ID_MAX) haptics->gpi_ctl[i].seq_id = val;
gpi_str2[7] = '0' + i; haptics->gpi_ctl[i].mode = 0; error = device_property_read_string(dev, gpi_str2, &str); if (!error) haptics->gpi_ctl[i].mode = da7280_haptic_of_gpi_mode_str(dev, str);
gpi_str3[7] = '0' + i; haptics->gpi_ctl[i].polarity = 0; error = device_property_read_string(dev, gpi_str3, &str); if (!error) haptics->gpi_ctl[i].polarity = da7280_haptic_of_gpi_pol_str(dev, str); }
haptics->bemf_sense_en = device_property_read_bool(dev, "dlg,bemf-sens-enable"); haptics->freq_track_en = device_property_read_bool(dev, "dlg,freq-track-enable"); haptics->acc_en = device_property_read_bool(dev, "dlg,acc-enable"); haptics->rapid_stop_en = device_property_read_bool(dev, "dlg,rapid-stop-enable"); haptics->amp_pid_en = device_property_read_bool(dev, "dlg,amp-pid-enable");
haptics->mem_update = false; error = device_property_read_u32_array(dev, "dlg,mem-array", &mem[0], DA7280_SNP_MEM_SIZE); if (!error) { haptics->mem_update = true; memset(haptics->snp_mem, 0, DA7280_SNP_MEM_SIZE); for (i = 0; i < DA7280_SNP_MEM_SIZE; i++) { if (mem[i] <= 0xff) { haptics->snp_mem[i] = (u8)mem[i]; } else { dev_err(haptics->dev, "Invalid data in mem-array at %d: %x\n", i, mem[i]); haptics->mem_update = false; break; } } }}
static irqreturn_t da7280_irq_handler(int irq, void *data){ struct da7280_haptic *haptics = data; struct device *dev = haptics->dev; u8 events[DA7280_IRQ_NUM]; int error;
/* Check what events have happened */ error = regmap_bulk_read(haptics->regmap, DA7280_IRQ_EVENT1, events, sizeof(events)); if (error) { dev_err(dev, "failed to read interrupt data: %d\n", error); goto out; }
/* Clear events */ error = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, events[0]); if (error) { dev_err(dev, "failed to clear interrupts: %d\n", error); goto out; }
if (events[0] & DA7280_E_SEQ_FAULT_MASK) { /* * Stop first if haptic is active, otherwise, the fault may * happen continually even though the bit is cleared. */ error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_OPERATION_MODE_MASK, 0); if (error) dev_err(dev, "failed to clear op mode on fault: %d\n", error); }
if (events[0] & DA7280_E_SEQ_DONE_MASK) haptics->active = false;
if (events[0] & DA7280_E_WARNING_MASK) { if (events[1] & DA7280_E_LIM_DRIVE_MASK || events[1] & DA7280_E_LIM_DRIVE_ACC_MASK) dev_warn(dev, "Please reduce the driver level\n"); if (events[1] & DA7280_E_MEM_TYPE_MASK) dev_warn(dev, "Please check the mem data format\n"); if (events[1] & DA7280_E_OVERTEMP_WARN_MASK) dev_warn(dev, "Over-temperature warning\n"); }
if (events[0] & DA7280_E_SEQ_FAULT_MASK) { if (events[2] & DA7280_E_SEQ_ID_FAULT_MASK) dev_info(dev, "Please reload PS_SEQ_ID & mem data\n"); if (events[2] & DA7280_E_MEM_FAULT_MASK) dev_info(dev, "Please reload the mem data\n"); if (events[2] & DA7280_E_PWM_FAULT_MASK) dev_info(dev, "Please restart PWM interface\n"); }
out: return IRQ_HANDLED;}
static int da7280_init(struct da7280_haptic *haptics){ unsigned int val = 0; u32 v2i_factor; int error, i; u8 mask = 0;
/* * If device type is DA7280_DEV_MAX then simply use currently * programmed mode. */ if (haptics->dev_type == DA7280_DEV_MAX) { error = regmap_read(haptics->regmap, DA7280_TOP_CFG1, &val); if (error) goto out_err;
haptics->dev_type = val & DA7280_ACTUATOR_TYPE_MASK ? DA7280_ERM_COIN : DA7280_LRA; }
/* Apply user settings */ if (haptics->dev_type == DA7280_LRA && haptics->resonant_freq_l != DA7280_SKIP_INIT) { error = regmap_write(haptics->regmap, DA7280_FRQ_LRA_PER_H, haptics->resonant_freq_h); if (error) goto out_err; error = regmap_write(haptics->regmap, DA7280_FRQ_LRA_PER_L, haptics->resonant_freq_l); if (error) goto out_err; } else if (haptics->dev_type == DA7280_ERM_COIN) { error = regmap_update_bits(haptics->regmap, DA7280_TOP_INT_CFG1, DA7280_BEMF_FAULT_LIM_MASK, 0); if (error) goto out_err;
mask = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | DA7280_V2I_FACTOR_FREEZE_MASK; val = DA7280_TST_CALIB_IMPEDANCE_DIS_MASK | DA7280_V2I_FACTOR_FREEZE_MASK; error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG4, mask, val); if (error) goto out_err;
haptics->acc_en = false; haptics->rapid_stop_en = false; haptics->amp_pid_en = false; }
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 = 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));
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG1, mask, val); if (error) goto out_err;
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG5, DA7280_V2I_FACTOR_OFFSET_EN_MASK, haptics->acc_en ? DA7280_V2I_FACTOR_OFFSET_EN_MASK : 0); if (error) goto out_err;
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CFG2, DA7280_MEM_DATA_SIGNED_MASK, haptics->acc_en ? 0 : DA7280_MEM_DATA_SIGNED_MASK); if (error) goto out_err;
if (haptics->nommax != DA7280_SKIP_INIT) { error = regmap_write(haptics->regmap, DA7280_ACTUATOR1, haptics->nommax); if (error) goto out_err; }
if (haptics->absmax != DA7280_SKIP_INIT) { error = regmap_write(haptics->regmap, DA7280_ACTUATOR2, haptics->absmax); if (error) goto out_err; }
error = regmap_update_bits(haptics->regmap, DA7280_ACTUATOR3, DA7280_IMAX_MASK, haptics->imax); if (error) goto out_err;
v2i_factor = haptics->impd * (haptics->imax + 4) / 1610400; error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_L, v2i_factor & 0xff); if (error) goto out_err; error = regmap_write(haptics->regmap, DA7280_CALIB_V2I_H, v2i_factor >> 8); if (error) goto out_err;
error = regmap_update_bits(haptics->regmap, DA7280_TOP_CTL1, DA7280_STANDBY_EN_MASK, DA7280_STANDBY_EN_MASK); if (error) goto out_err;
if (haptics->mem_update) { error = da7280_haptic_mem_update(haptics); if (error) goto out_err; }
/* 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); error = regmap_write(haptics->regmap, DA7280_SEQ_CTL2, val); if (error) goto out_err;
/* 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); error = regmap_write(haptics->regmap, DA7280_GPI_0_CTL + i, val); if (error) goto out_err; }
/* Mask ADC_SAT_M bit as default */ error = regmap_update_bits(haptics->regmap, DA7280_IRQ_MASK2, DA7280_ADC_SAT_M_MASK, DA7280_ADC_SAT_M_MASK); if (error) goto out_err;
/* Clear Interrupts */ error = regmap_write(haptics->regmap, DA7280_IRQ_EVENT1, 0xff); if (error) goto out_err;
error = regmap_update_bits(haptics->regmap, DA7280_IRQ_MASK1, DA7280_SEQ_FAULT_M_MASK | DA7280_SEQ_DONE_M_MASK, 0); if (error) goto out_err;
haptics->active = false; return 0;
out_err: dev_err(haptics->dev, "chip initialization error: %d\n", error); return error;}
static int da7280_probe(struct i2c_client *client){ struct device *dev = &client->dev; struct da7280_haptic *haptics; struct input_dev *input_dev; struct pwm_state state; struct ff_device *ff; int error;
if (!client->irq) { dev_err(dev, "No IRQ configured\n"); return -EINVAL; }
haptics = devm_kzalloc(dev, sizeof(*haptics), GFP_KERNEL); if (!haptics) return -ENOMEM;
haptics->dev = dev;
da7280_parse_properties(dev, haptics);
if (haptics->const_op_mode == DA7280_PWM_MODE) { haptics->pwm_dev = devm_pwm_get(dev, NULL); error = PTR_ERR_OR_ZERO(haptics->pwm_dev); if (error) { if (error != -EPROBE_DEFER) dev_err(dev, "Unable to request PWM: %d\n", 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_might_sleep(haptics->pwm_dev, &state); if (error) { dev_err(dev, "Failed to apply PWM state: %d\n", error); return error; }
/* * Check PWM period, PWM freq = 1000000 / state.period. * The valid PWM freq range: 10k ~ 250kHz. */ if (state.period > 100000 || state.period < 4000) { dev_err(dev, "Unsupported PWM period: %lld\n", state.period); 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); error = PTR_ERR_OR_ZERO(haptics->regmap); if (error) { dev_err(dev, "Failed to allocate register map: %d\n", error); return error; }
error = da7280_init(haptics); if (error) { dev_err(dev, "Failed to initialize device: %d\n", error); return error; }
/* Initialize input device for haptic device */ input_dev = devm_input_allocate_device(dev); 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; input_dev->open = da7280_haptic_open; input_dev->close = da7280_haptic_close; input_set_drvdata(input_dev, haptics); haptics->input_dev = input_dev;
input_set_capability(haptics->input_dev, EV_FF, FF_PERIODIC); input_set_capability(haptics->input_dev, EV_FF, FF_CUSTOM); 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) { dev_err(dev, "Failed to create FF input device: %d\n", error); return error; }
ff = input_dev->ff; ff->upload = da7280_haptics_upload_effect; ff->playback = da7280_haptics_playback;
error = input_register_device(input_dev); if (error) { dev_err(dev, "Failed to register input device: %d\n", error); return error; }
error = devm_request_threaded_irq(dev, client->irq, NULL, da7280_irq_handler, IRQF_ONESHOT, "da7280-haptics", haptics); if (error) { dev_err(dev, "Failed to request IRQ %d: %d\n", client->irq, error); return error; }
return 0;}
static int da7280_suspend(struct device *dev){ struct da7280_haptic *haptics = dev_get_drvdata(dev);
guard(mutex)(&haptics->input_dev->mutex);
/* * Make sure no new requests will be submitted while device is * suspended. */ scoped_guard(spinlock_irq, &haptics->input_dev->event_lock) { haptics->suspended = true; }
da7280_haptic_stop(haptics);
return 0;}
static int da7280_resume(struct device *dev){ struct da7280_haptic *haptics = dev_get_drvdata(dev); int error;
guard(mutex)(&haptics->input_dev->mutex);
error = da7280_haptic_start(haptics); if (error) return error;
scoped_guard(spinlock_irq, &haptics->input_dev->event_lock) { haptics->suspended = false; }
return 0;}
#ifdef CONFIG_OFstatic const struct of_device_id da7280_of_match[] = { { .compatible = "dlg,da7280", }, { }};MODULE_DEVICE_TABLE(of, da7280_of_match);#endif
static const struct i2c_device_id da7280_i2c_id[] = { { .name = "da7280" }, { }};MODULE_DEVICE_TABLE(i2c, da7280_i2c_id);
static DEFINE_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 = pm_sleep_ptr(&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");