// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. * Copyright (c) 2021-2024, Qualcomm Innovation Center, Inc. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define CREATE_TRACE_POINTS #include #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE #include #include #define RICHTAP_NAME "qcom_haptic" #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE /* status register definitions in HAPTICS_CFG module */ #define HAP_CFG_REVISION1_REG 0x00 #define HAP_CFG_V1 0x1 #define HAP_CFG_V2 0x2 #define HAP_CFG_V3 0x3 #define HAP_CFG_V4 0x4 #define HAP_CFG_STATUS_DATA_MSB_REG 0x09 /* STATUS_DATA_MSB definitions while MOD_STATUS_SEL is 0 */ #define AUTO_RES_CAL_DONE_BIT BIT(5) #define CAL_TLRA_CL_STS_MSB_MASK GENMASK(4, 0) /* STATUS_DATA_MSB definition while MOD_STATUS_SEL is 3 */ #define LAST_GOOD_TLRA_CL_MSB_MASK GENMASK(4, 0) /* STATUS_DATA_MSB definition while MOD_STATUS_SEL is 4 */ #define TLRA_CL_ERR_MSB_MASK GENMASK(4, 0) /* STATUS_DATA_MSB when MOD_STATUS_SEL is 5 and MOD_STATUS_XT.SEL is 1 */ #define FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V2 GENMASK(1, 0) #define FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V3 GENMASK(2, 0) #define FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V4 GENMASK(3, 0) #define FIFO_EMPTY_FLAG_BIT BIT(6) #define FIFO_FULL_FLAG_BIT BIT(5) #define HAP_CFG_STATUS_DATA_LSB_REG 0x0A /* STATUS_DATA_LSB definition while MOD_STATUS_SEL is 0 */ #define CAL_TLRA_CL_STS_LSB_MASK GENMASK(7, 0) /* STATUS_DATA_LSB when MOD_STATUS_SEL is 5 and MOD_STATUS_XT.SEL is 1 */ #define FIFO_REAL_TIME_FILL_STATUS_LSB_MASK GENMASK(7, 0) /* STATUS_DATA_LSB when MOD_STATUS_SEL is 5 and MOD_STATUS_XT.SEL is 0 */ #define HAP_DRV_PATTERN_SRC_STATUS_MASK GENMASK(2, 0) #define HAP_CFG_FAULT_STATUS_REG 0x0C #define SC_FLAG_BIT BIT(2) #define AUTO_RES_ERROR_BIT BIT(1) #define HPRW_RDY_FAULT_BIT BIT(0) /* Only for HAP525_HV */ #define HAP_CFG_HPWR_INTF_REG 0x0B #define HPWR_INTF_STATUS_MASK GENMASK(1, 0) #define HPWR_DISABLED 0 #define HPWR_READY 3 #define HAP_CFG_REAL_TIME_LRA_IMPEDANCE_REG 0x0E #define LRA_IMPEDANCE_MOHMS_LSB 250 #define HAP_CFG_INT_RT_STS_REG 0x10 #define FIFO_EMPTY_BIT BIT(1) /* config register definitions in HAPTICS_CFG module */ #define HAP_CFG_EN_CTL_REG 0x46 #define HAPTICS_EN_BIT BIT(7) #define HAP_CFG_DRV_CTRL_REG 0x47 #define PSTG_DLY_MASK GENMASK(7, 6) #define DRV_SLEW_RATE_MASK GENMASK(2, 0) #define HAP_CFG_VMAX_REG 0x48 #define VMAX_HV_STEP_MV 50 #define VMAX_MV_STEP_MV 32 #define MAX_VMAX_MV 11000 #define MAX_HV_VMAX_MV 10000 #define MAX_MV_VMAX_MV 6000 #define CLAMPED_VMAX_MV 5000 #define DEFAULT_VMAX_MV 5000 #define HAP_CFG_DRV_WF_SEL_REG 0x49 #define DRV_WF_FMT_BIT BIT(4) #define DRV_WF_SEL_MASK GENMASK(1, 0) #define HAP_CFG_AUTO_SHUTDOWN_CFG_REG 0x4A #define HAP_CFG_TRIG_PRIORITY_REG 0x4B #define SWR_IGNORE_BIT BIT(4) #define HAP_CFG_SPMI_PLAY_REG 0x4C #define PLAY_EN_BIT BIT(7) #define PATX_MEM_SEL_MASK GENMASK(5, 4) /* This is only for HAP525_HV */ #define BRAKE_EN_BIT BIT(3) #define PAT_SRC_MASK GENMASK(2, 0) #define HAP_CFG_EXT_TRIG_REG 0x4D #define HAP_CFG_SWR_ACCESS_REG 0x4E #define SWR_PAT_CFG_EN_BIT BIT(7) #define SWR_PAT_INPUT_EN_BIT BIT(6) #define SWR_PAT_RES_N_BIT BIT(5) #define HAP_CFG_BRAKE_MODE_CFG_REG 0x50 #define BRAKE_MODE_MASK GENMASK(7, 6) #define BRAKE_MODE_SHIFT 6 #define BRAKE_SINE_GAIN_MASK GENMASK(3, 2) #define BRAKE_SINE_GAIN_SHIFT 2 #define BRAKE_WF_SEL_MASK GENMASK(1, 0) #define HAP_CFG_CL_BRAKE_CFG_REG 0x51 #define HAP_CFG_CL_BRAKE_CAL_PARAM_REG 0x52 #define HAP_CFG_CL_BRAKE_RSET_REG 0x53 #define HAP_CFG_PWM_CFG_REG 0x5A #define HAP_CFG_TLRA_OL_HIGH_REG 0x5C #define TLRA_OL_MSB_MASK GENMASK(3, 0) #define HAP_CFG_TLRA_OL_LOW_REG 0x5D #define TLRA_OL_LSB_MASK GENMASK(7, 0) #define TLRA_STEP_US 5 #define TLRA_MAX_US 20475 #define HAP_CFG_RC_CLK_CAL_COUNT_MSB_REG 0x5E #define RC_CLK_CAL_COUNT_MSB_MASK GENMASK(1, 0) #define HAP_CFG_RC_CLK_CAL_COUNT_LSB_REG 0x5F #define RC_CLK_CAL_COUNT_LSB_MASK GENMASK(7, 0) #define HAP_CFG_DRV_DUTY_CFG_REG 0x60 #define ADT_DRV_DUTY_EN_BIT BIT(7) #define ADT_BRK_DUTY_EN_BIT BIT(6) #define DRV_DUTY_MASK GENMASK(5, 3) #define DRV_DUTY_62P5_PCT 2 #define DRV_DUTY_SHIFT 3 #define BRK_DUTY_MASK GENMASK(2, 0) #define BRK_DUTY_75_PCT 6 #define HAP_CFG_ADT_DRV_DUTY_CFG_REG 0x61 #define HAP_CFG_ZX_WIND_CFG_REG 0x62 #define HAP_CFG_AUTORES_CFG_REG 0x63 #define AUTORES_EN_BIT BIT(7) #define AUTORES_EN_DLY_MASK GENMASK(5, 2) #define AUTORES_EN_DLY(cycles) ((cycles) * 2) #define AUTORES_EN_DLY_6_CYCLES AUTORES_EN_DLY(6) #define AUTORES_EN_DLY_7_CYCLES AUTORES_EN_DLY(7) #define AUTORES_EN_DLY_SHIFT 2 #define AUTORES_ERR_WINDOW_MASK GENMASK(1, 0) #define AUTORES_ERR_WINDOW_12P5_PERCENT 0x0 #define AUTORES_ERR_WINDOW_25_PERCENT 0x1 #define AUTORES_ERR_WINDOW_50_PERCENT 0x2 #define AUTORES_ERR_WINDOW_100_PERCENT 0x3 #define HAP_CFG_AUTORES_ERR_RECOVERY_REG 0x64 #define EN_HW_RECOVERY_BIT BIT(1) #define SW_ERR_DRV_FREQ_BIT BIT(0) #define HAP_CFG_ISC_CFG_REG 0x65 #define ILIM_CC_EN_BIT BIT(7) #define ILIM_CC_EN_BIT_VAL 1 /* Following bits are only for HAP525_HV */ #define EN_SC_DET_P_HAP525_HV_BIT BIT(6) #define EN_SC_DET_N_HAP525_HV_BIT BIT(5) #define EN_IMP_DET_HAP525_HV_BIT BIT(4) #define ILIM_PULSE_DENSITY_MASK GENMASK(3, 2) #define ILIM_DENSITY_8_OVER_64_CYCLES 0 #define HAP_CFG_FAULT_CLR_REG 0x66 #define SC_CLR_BIT BIT(2) #define AUTO_RES_ERR_CLR_BIT BIT(1) #define HPWR_RDY_FAULT_CLR_BIT BIT(0) #define HAP_CFG_VMAX_HDRM_REG 0x67 #define VMAX_HDRM_MASK GENMASK(6, 0) #define VMAX_HDRM_STEP_MV 50 #define VMAX_HDRM_MAX_MV 6350 #define HAP_CFG_VSET_CFG_REG 0x68 #define FORCE_VSET_ACK_BIT BIT(1) /* This is only for HAP525_HV */ #define FORCE_VREG_RDY_BIT BIT(0) #define HAP_CFG_MOD_STATUS_SEL_REG 0x70 #define HAP_CFG_MOD_STATUS_XT_REG 0x71 #define HAP_CFG_CAL_EN_REG 0x72 #define CAL_RC_CLK_MASK GENMASK(3, 2) #define CAL_RC_CLK_SHIFT 2 #define CAL_RC_CLK_DISABLED_VAL 0 #define CAL_RC_CLK_AUTO_VAL 1 #define CAL_RC_CLK_MANUAL_VAL 2 /* For HAP520_MV and HAP525_HV */ #define HAP_CFG_ISC_CFG2_REG 0x77 #define EN_SC_DET_P_HAP520_MV_BIT BIT(6) #define EN_SC_DET_N_HAP520_MV_BIT BIT(5) #define ISC_THRESH_HAP520_MV_MASK GENMASK(2, 0) #define ISC_THRESH_HAP520_MV_140MA 0x01 #define ISC_THRESH_HAP525_HV_MASK GENMASK(4, 0) #define ISC_THRESH_HAP525_HV_125MA 0x11 #define ISC_THRESH_HAP525_HV_250MA 0x12 /* These registers are only applicable for HAP520_MV */ #define HAP_CFG_HW_CONFIG_REG 0x0D #define HV_HAP_DRIVER_BIT BIT(1) #define HAP_CFG_HPWR_INTF_CTL_REG 0x80 #define INTF_CTL_MASK GENMASK(1, 0) #define INTF_CTL_BOB 1 #define INTF_CTL_BHARGER 2 #define HAP_CFG_VHPWR_REG 0x84 #define VHPWR_STEP_MV 32 /* Only for HAP525_HV */ #define HAP_CFG_RT_LRA_IMPD_MEAS_CFG_REG 0xA4 #define LRA_IMPEDANCE_MEAS_EN_BIT BIT(7) #define LRA_IMPEDANCE_MEAS_CURRENT_SEL_BIT BIT(0) #define CURRENT_SEL_VAL_125MA 0 #define CURRENT_SEL_VAL_250MA 1 /* version register definitions for HAPTICS_PATTERN module */ #define HAP_PTN_REVISION2_REG 0x01 #define HAP_PTN_V1 0x1 #define HAP_PTN_V2 0x2 #define HAP_PTN_V3 0x3 #define HAP_PTN_V4 0x4 /* status register definition for HAPTICS_PATTERN module */ #define HAP_PTN_FIFO_READY_STS_REG 0x08 #define FIFO_READY_BIT BIT(0) #define HAP_PTN_NUM_PAT_REG 0x09 /* config register definition for HAPTICS_PATTERN module */ #define HAP_PTN_FIFO_DIN_0_REG 0x20 #define HAP_PTN_FIFO_DIN_NUM 4 #define HAP_PTN_FIFO_PLAY_RATE_REG 0x24 #define PAT_MEM_PLAY_RATE_MASK GENMASK(7, 4) #define FIFO_PLAY_RATE_MASK GENMASK(3, 0) #define HAP_PTN_AUTORES_CAL_CFG_REG 0x28 #define AUTORES_CAL_TRIG_BIT BIT(7) #define AUTORES_CAL_TIMER_4_HALF_CYCLES 4 #define AUTORES_CAL_TIMER_6_HALF_CYCLES 6 #define HAP_PTN_FIFO_EMPTY_CFG_REG 0x2A #define EMPTY_THRESH_MASK GENMASK(3, 0) #define HAP_PTN_FIFO_THRESH_LSB 40 #define HAP_PTN_FIFO_DEPTH_CFG_REG 0x2B #define HAP_PTN_FIFO_DIN_1B_REG 0x2C #define HAP_PTN_DIRECT_PLAY_REG 0x26 #define DIRECT_PLAY_MAX_AMPLITUDE 0xFF #define HAP_PTN_AUTORES_CAL_CFG_REG 0x28 #define HAP_PTN_PTRN1_TLRA_MSB_REG 0x30 #define HAP_PTN_PTRN1_TLRA_LSB_REG 0x31 #define HAP_PTN_PTRN2_TLRA_MSB_REG 0x32 #define HAP_PTN_PTRN2_TLRA_LSB_REG 0x33 #define HAP_PTN_PTRN1_CFG_REG 0x34 #define PTRN_FLRA2X_SHIFT 7 #define PTRN_SAMPLE_PER_MASK GENMASK(2, 0) #define PTRN_AMP_MSB_MASK BIT(0) #define PTRN_AMP_LSB_MASK GENMASK(7, 0) #define HAP_PTN_PTRN2_CFG_REG 0x50 #define HAP_PTN_BRAKE_AMP_REG 0x70 /* HAPTICS_PATTERN registers only present in HAP525_HV */ #define HAP_PTN_MEM_OP_ACCESS_REG 0x2D #define MEM_PAT_ACCESS_BIT BIT(7) #define MEM_PAT_RW_SEL_MASK GENMASK(5, 4) #define MEM_FLUSH_RELOAD_BIT BIT(0) #define HAP_PTN_MMAP_FIFO_REG 0xA0 #define MMAP_FIFO_EXIST_BIT BIT(7) #define MMAP_FIFO_LEN_MASK GENMASK(3, 0) #define MMAP_FIFO_LEN_PER_LSB 128 #define HAP_PTN_MMAP_PAT1_REG 0xA1 #define MMAP_PAT_LEN_PER_LSB 32 #define MMAP_PAT1_LEN_MASK GENMASK(6, 0) #define MMAP_PAT2_LEN_MASK GENMASK(5, 0) #define MMAP_PAT3_PAT4_LEN_MASK GENMASK(4, 0) /* register in HBOOST module */ #define HAP_BOOST_REVISION1 0x00 #define HAP_BOOST_REVISION2 0x01 #define HAP_BOOST_V0P0 0x0000 #define HAP_BOOST_V0P1 0x0001 #define HAP_BOOST_V0P2 0x0002 #define HAP_BOOST_STATUS4_REG 0x0B #define BOOST_DTEST1_STATUS_BIT BIT(0) #define HAP_BOOST_HW_CTRL_FOLLOW_REG 0x41 #define FOLLOW_HW_EN_BIT BIT(7) #define FOLLOW_HW_CCM_BIT BIT(6) #define FOLLOW_HW_VSET_BIT BIT(5) #define HAP_BOOST_VREG_EN_REG 0x46 #define VREG_EN_BIT BIT(7) #define HAP_BOOST_CLAMP_REG 0x70 #define CLAMP_5V_BIT BIT(0) /* haptics SDAM registers offset definition */ #define HAP_STATUS_DATA_MSB_SDAM_OFFSET 0x46 #define HAP_LRA_NOMINAL_OHM_SDAM_OFFSET 0x75 #define HAP_LRA_DETECTED_OHM_SDAM_OFFSET 0x76 /* constant parameters */ #define SAMPLES_PER_PATTERN 8 #define BRAKE_SAMPLE_COUNT 8 #define DEFAULT_ERM_PLAY_RATE_US 5000 #define MAX_EFFECT_COUNT 64 #define FIFO_READY_TIMEOUT_MS 1000 #define CHAR_PER_PATTERN_S 48 #define CHAR_PER_SAMPLE 8 #define CHAR_MSG_HEADER 16 #define CHAR_BRAKE_MODE 24 #define HW_BRAKE_MAX_CYCLES 16 #define F_LRA_VARIATION_HZ 5 #define NON_HBOOST_MAX_VMAX_MV 4000 /* below definitions are only for HAP525_HV */ #define MMAP_NUM_BYTES 2048 #define MMAP_FIFO_MIN_SIZE 640 #define FIFO_PRGM_INIT_SIZE 320 #define is_between(val, min, max) \ (((min) <= (max)) && ((min) <= (val)) && ((val) <= (max))) /* * rc_clk_cal_count default value if caliration failed and dts not set * this value get from haptics_get_closeloop_lra_period() */ #define LRA_F0_CAL_COUNT 0x244 enum hap_status_sel { CAL_TLRA_CL_STS = 0x00, T_WIND_STS, T_WIND_STS_PREV, LAST_GOOD_TLRA_CL_STS, TLRA_CL_ERR_STS, HAP_DRV_STS, RNAT_RCAL_INT, BRAKE_CAL_SCALAR = 0x07, CLAMPED_DUTY_CYCLE_STS = 0x8003, FIFO_REAL_TIME_STS = 0x8005, }; enum drv_sig_shape { WF_SQUARE, WF_SINE, WF_NO_MODULATION, WF_RESERVED, }; enum brake_mode { OL_BRAKE, CL_BRAKE, PREDICT_BRAKE, AUTO_BRAKE, }; enum brake_sine_gain { BRAKE_SINE_GAIN_X1, BRAKE_SINE_GAIN_X2, BRAKE_SINE_GAIN_X4, BRAKE_SINE_GAIN_X8, }; enum pat_mem_sel { PAT1_MEM, PAT2_MEM, PAT3_MEM, PAT4_MEM, PAT_MEM_MAX, }; enum pattern_src { FIFO, DIRECT_PLAY, PATTERN1, PATTERN2, SWR, PATTERN_MEM, SRC_RESERVED, }; enum s_period { T_LRA = 0, T_LRA_DIV_2, T_LRA_DIV_4, T_LRA_DIV_8, T_LRA_X_2, T_LRA_X_4, T_LRA_X_8, T_RESERVED, /* F_xKHZ definitions are for FIFO only */ F_8KHZ, F_16KHZ, F_24KHZ, F_32KHZ, F_44P1KHZ, F_48KHZ, F_RESERVED, }; enum custom_effect_param { CUSTOM_DATA_EFFECT_IDX, CUSTOM_DATA_TIMEOUT_SEC_IDX, CUSTOM_DATA_TIMEOUT_MSEC_IDX, CUSTOM_DATA_LEN, }; /* * HW type of the haptics module, the type value follows the * revision value of the HAPTICS_CFG/HAPTICS_PATTERN modules */ enum haptics_hw_type { HAP520 = 0x2, /* PM8350B */ HAP520_MV = 0x3, /* PM5100 */ HAP525_HV = 0x4, /* PMIC for kalama */ }; enum wa_flags { TOGGLE_CAL_RC_CLK = BIT(0), SW_CTRL_HBST = BIT(1), SLEEP_CLK_32K_SCALE = BIT(2), TOGGLE_EN_TO_FLUSH_FIFO = BIT(3), RECOVER_SWR_SLAVE = BIT(4), TOGGLE_MODULE_EN = BIT(5), }; static const char * const src_str[] = { "FIFO", "DIRECT_PLAY", "PATTERN1", "PATTERN2", "SWR", "reserved", }; static const char * const brake_str[] = { "open-loop-brake", "close-loop-brake", "predictive-brake", "auto-brake", }; static const char * const period_str[] = { "T_LRA", "T_LRA_DIV_2", "T_LRA_DIV_4", "T_LRA_DIV_8", "T_LRA_X_2", "T_LRA_X_4", "T_LRA_X_8", "reserved_1", "F_8KHZ", "F_16HKZ", "F_24KHZ", "F_32KHZ", "F_44P1KHZ", "F_48KHZ", "reserved_2", }; struct pattern_s { u16 amplitude; enum s_period period; bool f_lra_x2; }; struct pattern_cfg { struct pattern_s samples[SAMPLES_PER_PATTERN]; u32 play_rate_us; u32 play_length_us; bool preload; }; struct fifo_cfg { u8 *samples; u32 num_s; enum s_period period_per_s; u32 play_length_us; bool preload; }; struct brake_cfg { u8 samples[BRAKE_SAMPLE_COUNT]; enum brake_mode mode; enum drv_sig_shape brake_wf; enum brake_sine_gain sine_gain; u32 play_length_us; bool disabled; }; struct haptics_effect { struct pattern_cfg *pattern; struct fifo_cfg *fifo; struct brake_cfg *brake; u32 id; u32 vmax_mv; u32 t_lra_us; enum pattern_src src; enum pat_mem_sel pat_sel; bool auto_res_disable; }; struct mmap_partition { u32 max_size; u32 length; bool in_use; }; struct haptics_mmap { struct mmap_partition fifo_mmap; struct mmap_partition pat_sel_mmap[PAT_MEM_MAX]; enum s_period pat_play_rate; }; /** * struct fifo_play_status - Data used for recording the FIFO playing status * * @samples_written: The number of the samples that has been written into * FIFO memory. * @written_done: The flag to indicate if all of the FIFO samples has * been written to the FIFO memory. * @is_busy: The flag to indicate if it's in the middle of FIFO * playing. * @cancelled: The flag to indicate if FIFO playing is cancelled due * to a stopping command arrived in the middle of playing. */ struct fifo_play_status { u32 samples_written; atomic_t written_done; atomic_t is_busy; atomic_t cancelled; }; struct haptics_play_info { struct haptics_effect *effect; struct brake_cfg *brake; struct fifo_play_status fifo_status; struct mutex lock; atomic_t gain; u32 vmax_mv; u32 length_us; enum pattern_src pattern_src; bool in_calibration; }; struct haptics_hw_config { struct brake_cfg brake; u32 vmax_mv; u32 vmax_mv_debug; u32 t_lra_us; u32 cl_t_lra_us; u32 lra_min_mohms; u32 lra_max_mohms; u32 lra_open_mohms; u32 lra_measured_mohms; u32 preload_effect; u32 fifo_empty_thresh; u16 rc_clk_cal_count; enum drv_sig_shape drv_wf; bool is_erm; bool measure_lra_impedance; bool sw_cmd_freq_det; }; struct custom_fifo_data { u32 idx; u32 length; u32 play_rate_hz; u8 *data; }; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE enum { RICHTAP_UNKNOWN = -1, RICHTAP_AW_8697 = 0x05, RICHTAP_PMIC_8350BH = 0x06, }; enum { MMAP_BUF_DATA_VALID = 0x55, MMAP_BUF_DATA_FINISHED = 0xAA, MMAP_BUF_DATA_INVALID = 0xFF, }; #define RICHTAP_IOCTL_GROUP 0x52 #define RICHTAP_GET_HWINFO _IO(RICHTAP_IOCTL_GROUP, 0x03) #define RICHTAP_SET_FREQ _IO(RICHTAP_IOCTL_GROUP, 0x04) #define RICHTAP_SETTING_GAIN _IO(RICHTAP_IOCTL_GROUP, 0x05) #define RICHTAP_OFF_MODE _IO(RICHTAP_IOCTL_GROUP, 0x06) #define RICHTAP_TIMEOUT_MODE _IO(RICHTAP_IOCTL_GROUP, 0x07) #define RICHTAP_RAM_MODE _IO(RICHTAP_IOCTL_GROUP, 0x08) #define RICHTAP_RTP_MODE _IO(RICHTAP_IOCTL_GROUP, 0x09) #define RICHTAP_STREAM_MODE _IO(RICHTAP_IOCTL_GROUP, 0x0A) #define RICHTAP_UPDATE_RAM _IO(RICHTAP_IOCTL_GROUP, 0x10) #define RICHTAP_GET_F0 _IO(RICHTAP_IOCTL_GROUP, 0x11) #define RICHTAP_STOP_MODE _IO(RICHTAP_IOCTL_GROUP, 0x12) #define RICHTAP_F0_UPDATE _IO(RICHTAP_IOCTL_GROUP, 0x13) #define RICHTAP_MMAP_BUF_SIZE 1000 #define RICHTAP_MMAP_PAGE_ORDER 2 #define RICHTAP_MMAP_BUF_SUM 16 #pragma pack(4) struct mmap_buf_format { uint8_t status; uint8_t bit; int16_t length; uint32_t reserve; struct mmap_buf_format *kernel_next; struct mmap_buf_format *user_next; uint8_t data[RICHTAP_MMAP_BUF_SIZE]; }; #pragma pack() #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE struct haptics_chip { struct device *dev; struct regmap *regmap; struct input_dev *input_dev; struct haptics_hw_config config; struct haptics_effect *effects; struct haptics_effect *primitives; struct haptics_effect *custom_effect; struct haptics_play_info play; struct haptics_mmap mmap; struct dentry *debugfs_dir; struct delayed_work stop_work; struct regulator_dev *swr_slave_rdev; struct nvmem_cell *cl_brake_nvmem; struct nvmem_device *hap_cfg_nvmem; struct device_node *pbs_node; struct class hap_class; struct regulator *hpwr_vreg; struct hrtimer hbst_off_timer; struct notifier_block hboost_nb; struct mutex vmax_lock; struct work_struct set_gain_work; int fifo_empty_irq; u32 hpwr_voltage_mv; u32 effects_count; u32 primitives_count; u32 cfg_addr_base; u32 ptn_addr_base; u32 hbst_addr_base; u32 clamped_vmax_mv; u32 wa_flags; u32 primitive_duration; u8 cfg_rev1; u8 cfg_revision; u8 ptn_revision; u8 hpwr_intf_ctl; u16 hbst_revision; u16 max_vmax_mv; enum haptics_hw_type hw_type; bool fifo_empty_irq_en; bool swr_slave_enabled; bool clamp_at_5v; bool hpwr_vreg_enabled; bool is_hv_haptics; bool hboost_enabled; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE uint8_t *rtp_ptr; struct mmap_buf_format *start_buf; struct mmap_buf_format *current_buf; struct work_struct richtap_stream_work; struct work_struct richtap_erase_work; int16_t pos; atomic_t richtap_mode; bool erase_working; uint32_t lower_mv; #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE }; struct haptics_reg_info { u8 addr; u8 val; }; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE struct haptics_chip *g_richtap_ptr; #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE static inline int get_max_fifo_samples(struct haptics_chip *chip) { int val = 0; switch (chip->hw_type) { case HAP520: val = 640; break; case HAP520_MV: val = 1024; break; case HAP525_HV: val = chip->mmap.fifo_mmap.length ? chip->mmap.fifo_mmap.length : MMAP_FIFO_MIN_SIZE; break; default: pr_err("Invalid HW type\n"); break; } return val; } static int get_fifo_empty_threshold(struct haptics_chip *chip) { int val = 0; switch (chip->hw_type) { case HAP520: val = 280; break; case HAP520_MV: case HAP525_HV: val = 288; break; default: pr_err("Invalid HW type\n"); break; } return val; } static int get_fifo_threshold_per_bit(struct haptics_chip *chip) { int val = -EINVAL; switch (chip->hw_type) { case HAP520: val = 40; break; case HAP520_MV: case HAP525_HV: val = 32; break; default: pr_err("Invalid HW type\n"); break; } return val; } static bool is_haptics_external_powered(struct haptics_chip *chip) { /* SW based explicit vote */ if (chip->hpwr_vreg) return true; /* Implicit voting by HW */ if (chip->hw_type == HAP520_MV) return true; /* Powered by HBOOST */ return false; } static int haptics_read(struct haptics_chip *chip, u16 base, u8 offset, u8 *val, u32 length) { int rc = 0; u16 addr = base + offset; rc = regmap_bulk_read(chip->regmap, addr, val, length); if (rc < 0) dev_err(chip->dev, "read addr %#x failed, rc=%d\n", addr, rc); return rc; } static int haptics_write(struct haptics_chip *chip, u16 base, u8 offset, u8 *val, u32 length) { int rc = 0; u16 addr = base + offset; rc = regmap_bulk_write(chip->regmap, addr, val, length); if (rc < 0) dev_err(chip->dev, "write addr %#x failed, rc=%d\n", addr, rc); return rc; } static int haptics_masked_write(struct haptics_chip *chip, u16 base, u8 offset, u8 mask, u8 val) { int rc = 0; u16 addr = base + offset; regmap_update_bits(chip->regmap, addr, mask, val); if (rc < 0) dev_err(chip->dev, "update addr %#x failed, rc=%d\n", addr, rc); return rc; } static void __dump_effects(struct haptics_chip *chip, struct haptics_effect *effects, int effects_count) { struct haptics_effect *effect; struct pattern_s *sample; char *str; u32 size, pos; int i, j; for (i = 0; i < effects_count; i++) { effect = &effects[i]; if (!effect) return; dev_dbg(chip->dev, "effect %d\n", effect->id); dev_dbg(chip->dev, "vmax_mv = %d\n", effect->vmax_mv); if (effect->pattern) { for (j = 0; j < SAMPLES_PER_PATTERN; j++) { sample = &effect->pattern->samples[j]; dev_dbg(chip->dev, "pattern = %d, period = %s, f_lra_x2 = %d\n", sample->amplitude, period_str[sample->period], sample->f_lra_x2); } dev_dbg(chip->dev, "pattern play_rate_us = %d\n", effect->pattern->play_rate_us); dev_dbg(chip->dev, "pattern play_length_us = %d\n", effect->pattern->play_length_us); dev_dbg(chip->dev, "pattern preload = %d\n", effect->pattern->preload); } if (effect->fifo) { size = effect->fifo->num_s * CHAR_PER_SAMPLE + CHAR_MSG_HEADER; str = kzalloc(size, GFP_KERNEL); if (str == NULL) return; pos = 0; pos += scnprintf(str, size, "%s", "FIFO data: "); for (j = 0; j < effect->fifo->num_s; j++) pos += scnprintf(str + pos, size - pos, "%d ", (s8)effect->fifo->samples[j]); dev_dbg(chip->dev, "%s\n", str); kfree(str); dev_dbg(chip->dev, "FIFO data preload: %d, play rate: %s, play length: %uus\n", effect->fifo->preload, period_str[effect->fifo->period_per_s], effect->fifo->play_length_us); } if (effect->brake && !effect->brake->disabled) { size = BRAKE_SAMPLE_COUNT * CHAR_PER_SAMPLE + CHAR_MSG_HEADER; str = kzalloc(size, GFP_KERNEL); if (str == NULL) return; pos = 0; pos += scnprintf(str, size, "%s", "brake pattern: "); for (j = 0; j < BRAKE_SAMPLE_COUNT; j++) pos += scnprintf(str + pos, size - pos, "%#x ", effect->brake->samples[j]); dev_dbg(chip->dev, "%s\n", str); kfree(str); dev_dbg(chip->dev, "brake mode: %s\n", brake_str[effect->brake->mode]); dev_dbg(chip->dev, "brake play length: %dus\n", effect->brake->play_length_us); } dev_dbg(chip->dev, "pattern src: %s\n", src_str[effect->src]); dev_dbg(chip->dev, "auto resonance %s\n", effect->auto_res_disable ? "disabled" : "enabled"); } } static void verify_brake_samples(struct brake_cfg *brake) { int i; if (brake->mode == PREDICT_BRAKE || brake->mode == AUTO_BRAKE) return; for (i = BRAKE_SAMPLE_COUNT - 1; i > 0; i--) { if (brake->samples[i] != 0) { brake->disabled = false; return; } } brake->disabled = true; } static int get_pattern_play_length_us(struct pattern_cfg *pattern) { int i = SAMPLES_PER_PATTERN - 1, j; u32 us_per_sample, total_length_us = 0; if (!pattern) return -EINVAL; for (; i >= 0; i--) if (pattern->samples[i].amplitude != 0) break; for (j = 0; j < i; j++) { us_per_sample = pattern->play_rate_us; switch (pattern->samples[j].period) { case T_LRA: break; case T_LRA_DIV_2: us_per_sample /= 2; break; case T_LRA_DIV_4: us_per_sample /= 4; break; case T_LRA_DIV_8: us_per_sample /= 8; break; case T_LRA_X_2: us_per_sample *= 2; break; case T_LRA_X_4: us_per_sample *= 4; break; case T_LRA_X_8: us_per_sample *= 8; break; default: return -EINVAL; } if (pattern->samples[j].f_lra_x2) us_per_sample /= 2; total_length_us += us_per_sample; } return total_length_us; } static int get_fifo_play_length_us(struct fifo_cfg *fifo, u32 t_lra_us) { u32 length_us; int i; if (!fifo) return -EINVAL; for (i = fifo->num_s - 1; i > 0; i--) if (fifo->samples[i] != 0) break; length_us = (i + 1) * t_lra_us; switch (fifo->period_per_s) { case T_LRA: break; case T_LRA_DIV_2: length_us /= 2; break; case T_LRA_DIV_4: length_us /= 4; break; case T_LRA_DIV_8: length_us /= 8; break; case T_LRA_X_2: length_us *= 2; break; case T_LRA_X_4: length_us *= 4; break; case T_LRA_X_8: length_us *= 8; break; case F_8KHZ: length_us = 1000 * fifo->num_s / 8; break; case F_16KHZ: length_us = 1000 * fifo->num_s / 16; break; case F_24KHZ: length_us = 1000 * fifo->num_s / 24; break; case F_32KHZ: length_us = 1000 * fifo->num_s / 32; break; case F_44P1KHZ: length_us = 10000 * fifo->num_s / 441; break; case F_48KHZ: length_us = 1000 * fifo->num_s / 48; break; default: length_us = -EINVAL; break; } return length_us; } static int get_brake_play_length_us(struct brake_cfg *brake, u32 t_lra_us) { int i = BRAKE_SAMPLE_COUNT - 1; if (!brake || brake->disabled) return 0; if (brake->mode == PREDICT_BRAKE || brake->mode == AUTO_BRAKE) return HW_BRAKE_MAX_CYCLES * t_lra_us / 2; for (; i >= 0; i--) if (brake->samples[i] != 0) break; return t_lra_us * (i + 1) / 2; } static int haptics_get_status_data(struct haptics_chip *chip, enum hap_status_sel sel, u8 data[]) { int rc; u8 mod_sel_val[2]; const char *hap_status_name[BRAKE_CAL_SCALAR + 1] = { "CAL_TLRA_CL_STS", "T_WIND_STS", "T_WIND_STS_PREV", "LAST_GOOD_TLRA_CL_STS", "TLRA_CL_ERR_STS", "HAP_DRV_STS", "RNAT_RCAL_INT", "BRAKE_CAL_SCALAR", }; const char *name = NULL; mod_sel_val[0] = sel & 0xff; mod_sel_val[1] = (sel >> 8) & 0xff; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_MOD_STATUS_XT_REG, &mod_sel_val[1], 1); if (rc < 0) return rc; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_MOD_STATUS_SEL_REG, mod_sel_val, 1); if (rc < 0) return rc; rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_STATUS_DATA_MSB_REG, data, 2); if (rc < 0) return rc; if (sel <= BRAKE_CAL_SCALAR) name = hap_status_name[sel]; else if (sel == CLAMPED_DUTY_CYCLE_STS) name = "CLAMPED_DUTY_CYCLE_STS"; else if (sel == FIFO_REAL_TIME_STS) name = "FIFO_REAL_TIME_STS"; dev_info(chip->dev, "Get status data[%s] = (%#x, %#x)\n", name, data[0], data[1]); trace_qcom_haptics_status(name, data[0], data[1]); return 0; } #define AUTO_CAL_CLK_SCALE_DEN 1000 #define AUTO_CAL_CLK_SCALE_NUM 1024 static int haptics_adjust_lra_period(struct haptics_chip *chip, u32 *t_lra_us) { int rc; u8 val; if (chip->wa_flags & SLEEP_CLK_32K_SCALE) { rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, &val, 1); if (rc < 0) return rc; if ((val & CAL_RC_CLK_MASK) == (CAL_RC_CLK_AUTO_VAL << CAL_RC_CLK_SHIFT)) *t_lra_us = div_u64((u64)(*t_lra_us) * AUTO_CAL_CLK_SCALE_NUM, AUTO_CAL_CLK_SCALE_DEN); } return 0; } /* constant definitions for calculating TLRA */ #define TLRA_AUTO_RES_ERR_NO_CAL_STEP_PSEC 1667000 #define TLRA_AUTO_RES_NO_CAL_STEP_PSEC 3333000 #define TLRA_AUTO_RES_ERR_AUTO_CAL_STEP_PSEC \ ((chip->wa_flags & SLEEP_CLK_32K_SCALE) ? 1627700 : 1666667) #define TLRA_AUTO_RES_AUTO_CAL_STEP_PSEC \ ((chip->wa_flags & SLEEP_CLK_32K_SCALE) ? 813850 : 833333) #define SLEEP_CLK_CAL_DIVIDER \ ((chip->wa_flags & SLEEP_CLK_32K_SCALE) ? 600 : 586) static int haptics_get_closeloop_lra_period( struct haptics_chip *chip, bool in_boot) { struct haptics_hw_config *config = &chip->config; u16 cal_tlra_cl_sts, tlra_cl_err_sts, tlra_ol, last_good_tlra_cl_sts; u8 val[2], rc_clk_cal; bool auto_res_done; u64 tmp; int rc; /* read RC_CLK_CAL enabling mode */ rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, val, 1); if (rc < 0) return rc; rc_clk_cal = ((val[0] & CAL_RC_CLK_MASK) >> CAL_RC_CLK_SHIFT); /* read auto resonance calibration result */ if (in_boot && ((chip->hw_type == HAP520) || (chip->hw_type == HAP520_MV))) { if (chip->hap_cfg_nvmem == NULL) { dev_dbg(chip->dev, "nvmem device for hap_cfg is not defined\n"); return -EINVAL; } rc = nvmem_device_read(chip->hap_cfg_nvmem, HAP_STATUS_DATA_MSB_SDAM_OFFSET, 2, val); if (rc < 0) { dev_err(chip->dev, "read SDAM %#x failed, rc=%d\n", HAP_STATUS_DATA_MSB_SDAM_OFFSET, rc); return rc; } dev_info(chip->dev, "read calibration result from SDAM 0x%x, 0x%x\n", val[0], val[1]); } else { rc = haptics_get_status_data(chip, CAL_TLRA_CL_STS, val); if (rc < 0) return rc; } auto_res_done = !!(val[0] & AUTO_RES_CAL_DONE_BIT); cal_tlra_cl_sts = ((val[0] & CAL_TLRA_CL_STS_MSB_MASK) << 8) | val[1]; /* read auto resonance calibration error status */ rc = haptics_get_status_data(chip, TLRA_CL_ERR_STS, val); if (rc < 0) return rc; tlra_cl_err_sts = ((val[0] & TLRA_CL_ERR_MSB_MASK) << 8) | val[1]; dev_dbg(chip->dev, "rc_clk_cal = %u, auto_res_done = %d\n", rc_clk_cal, auto_res_done); if (rc_clk_cal == CAL_RC_CLK_DISABLED_VAL && !auto_res_done) { /* TLRA_CL_ERR(us) = TLRA_CL_ERR_STS * 1.667 us */ tmp = tlra_cl_err_sts * TLRA_AUTO_RES_ERR_NO_CAL_STEP_PSEC; dev_dbg(chip->dev, "tlra_cl_err_sts = %#x\n", tlra_cl_err_sts); config->cl_t_lra_us = div_u64(tmp, 1000000); } else if (rc_clk_cal == CAL_RC_CLK_DISABLED_VAL && auto_res_done) { /* * CAL_TLRA_CL_STS_NO_CAL = CAL_TLRA_CL_STS * TLRA_AUTO_RES(us) = CAL_TLRA_CL_STS_NO_CAL * 3.333 us */ tmp = cal_tlra_cl_sts * TLRA_AUTO_RES_NO_CAL_STEP_PSEC; dev_dbg(chip->dev, "cal_tlra_cl_sts = %#x\n", cal_tlra_cl_sts); config->cl_t_lra_us = div_u64(tmp, 1000000); } else if (rc_clk_cal == CAL_RC_CLK_AUTO_VAL && !auto_res_done) { /* * CAL_TLRA_OL = CAL_TLRA_CL_STS; * TLRA_CL_ERR(us) = TLRA_CL_ERR_STS * * (TLRA_OL / CAL_TLRA_OL) * TLRA_AUTO_RES_ERR_AUTO_CAL_STEP_US */ /* read the TLRA_OL setting */ rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_TLRA_OL_HIGH_REG, val, 2); if (rc < 0) return rc; tlra_ol = (val[0] & TLRA_OL_MSB_MASK) << 8 | val[1]; dev_dbg(chip->dev, "tlra_ol = %#x, tlra_cl_err_sts = %#x, cal_tlra_cl_sts = %#x\n", tlra_ol, tlra_cl_err_sts, cal_tlra_cl_sts); tmp = tlra_cl_err_sts * tlra_ol; tmp *= TLRA_AUTO_RES_ERR_AUTO_CAL_STEP_PSEC; tmp = div_u64(tmp, cal_tlra_cl_sts); config->cl_t_lra_us = div_u64(tmp, 1000000); /* calculate RC_CLK_CAL_COUNT */ if (!config->t_lra_us || !config->cl_t_lra_us) return -EINVAL; /* * RC_CLK_CAL_COUNT = SLEEP_CLK_CAL_DIVIDER * (CAL_TLRA_OL / TLRA_OL) * * (SLEEP_CLK_CAL_DIVIDER / 586) * (CL_T_TLRA_US / OL_T_LRA_US) */ tmp = SLEEP_CLK_CAL_DIVIDER * SLEEP_CLK_CAL_DIVIDER; tmp *= cal_tlra_cl_sts * config->cl_t_lra_us; tmp = div_u64(tmp, tlra_ol); tmp = div_u64(tmp, 586); config->rc_clk_cal_count = div_u64(tmp, config->t_lra_us); } else if (rc_clk_cal == CAL_RC_CLK_AUTO_VAL && auto_res_done) { /* * CAL_TLRA_CL_STS_W_CAL = CAL_TLRA_CL_STS; * TLRA_AUTO_RES(us) = LAST_GOOD_TLRA_CL_STS * * TLRA_AUTO_RES_AUTO_CAL_STEP_US * * (LAST_GOOD_TLRA_CL_STS / CAL_TLRA_CL_STS_AUTO_CAL) */ /* read LAST_GOOD_TLRA_CL_STS */ rc = haptics_get_status_data(chip, LAST_GOOD_TLRA_CL_STS, val); if (rc < 0) return rc; last_good_tlra_cl_sts = ((val[0] & LAST_GOOD_TLRA_CL_MSB_MASK) << 8) | val[1]; dev_dbg(chip->dev, "last_good_tlra_cl_sts = %#x, cal_tlra_cl_sts = %#x\n", last_good_tlra_cl_sts, cal_tlra_cl_sts); tmp = last_good_tlra_cl_sts * last_good_tlra_cl_sts; tmp *= TLRA_AUTO_RES_AUTO_CAL_STEP_PSEC; tmp = div_u64(tmp, cal_tlra_cl_sts); config->cl_t_lra_us = div_u64(tmp, 1000000); /* calculate RC_CLK_CAL_COUNT */ if (!config->t_lra_us || !config->cl_t_lra_us) return -EINVAL; /* * RC_CLK_CAL_COUNT = * SLEEP_CLK_CAL_DIVIDER * (CAL_TLRA_CL_STS_AUTO_CAL / LAST_GOOD_TLRA_CL_STS) * * (SLEEP_CLK_CAL_DIVIDER / 293) * (CL_T_TLRA_US / OL_T_LRA_US) */ tmp = SLEEP_CLK_CAL_DIVIDER * SLEEP_CLK_CAL_DIVIDER; tmp *= cal_tlra_cl_sts * config->cl_t_lra_us; tmp = div_u64(tmp, last_good_tlra_cl_sts); tmp = div_u64(tmp, 293); config->rc_clk_cal_count = div_u64(tmp, config->t_lra_us); } else { dev_err(chip->dev, "Can't get close-loop LRA period in rc_clk_cal mode %u\n", rc_clk_cal); return -EINVAL; } dev_info(chip->dev, "OL_TLRA %u us, CL_TLRA %u us, RC_CLK_CAL_COUNT %#x\n", chip->config.t_lra_us, chip->config.cl_t_lra_us, chip->config.rc_clk_cal_count); return 0; } static int haptics_module_enable(struct haptics_chip *chip, bool enable) { u8 val; int rc; val = enable ? HAPTICS_EN_BIT : 0; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_EN_CTL_REG, &val, 1); if (rc < 0) return rc; dev_dbg(chip->dev, "haptics module %s\n", enable ? "enabled" : "disabled"); return 0; } static int haptics_toggle_module_enable(struct haptics_chip *chip) { int rc; /* * Updating HAPTICS_EN would vote hBoost enable status. Add 100us * delay before updating HAPTICS_EN for hBoost to have enough time * to handle its power transition. */ usleep_range(100, 101); rc = haptics_module_enable(chip, false); if (rc < 0) return rc; usleep_range(100, 101); return haptics_module_enable(chip, true); } #define VMAX_SETTLE_COUNT 10 static int haptics_check_hpwr_status(struct haptics_chip *chip) { int i, rc = 0; u8 val; if (chip->hw_type != HAP525_HV) return 0; for (i = 0; i < VMAX_SETTLE_COUNT; i++) { rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_HPWR_INTF_REG, &val, 1); if (rc < 0) break; val &= HPWR_INTF_STATUS_MASK; if ((val == HPWR_DISABLED) || (val == HPWR_READY)) break; usleep_range(1000, 1001); } if (!rc && i == VMAX_SETTLE_COUNT) { haptics_toggle_module_enable(chip); dev_err(chip->dev, "set Vmax failed, toggle HAPTICS_EN to restore HW status\n"); rc = -EBUSY; } return rc; } static int haptics_set_vmax_mv(struct haptics_chip *chip, u32 vmax_mv) { int rc = 0; u8 val, vmax_step; mutex_lock(&chip->vmax_lock); if (vmax_mv > chip->max_vmax_mv) { dev_dbg(chip->dev, "vmax (%d) exceed the max value: %d\n", vmax_mv, chip->max_vmax_mv); vmax_mv = chip->max_vmax_mv; } if (vmax_mv > chip->clamped_vmax_mv) vmax_mv = chip->clamped_vmax_mv; if (chip->clamp_at_5v && (vmax_mv > CLAMPED_VMAX_MV)) vmax_mv = CLAMPED_VMAX_MV; vmax_step = (chip->is_hv_haptics) ? VMAX_HV_STEP_MV : VMAX_MV_STEP_MV; val = vmax_mv / vmax_step; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_VMAX_REG, &val, 1); if (rc < 0) { dev_err(chip->dev, "config VMAX failed, rc=%d\n", rc); mutex_unlock(&chip->vmax_lock); return rc; } dev_info(chip->dev, "Set Vmax to %u mV\n", vmax_mv); rc = haptics_check_hpwr_status(chip); if (rc < 0) dev_err(chip->dev, "check hpwr_status failed, rc=%d\n", rc); mutex_unlock(&chip->vmax_lock); return rc; } static int haptics_set_vmax_headroom_mv(struct haptics_chip *chip, u32 hdrm_mv) { int rc = 0; u8 val; if (hdrm_mv > VMAX_HDRM_MAX_MV) { dev_err(chip->dev, "headroom (%d) exceed the max value: %d\n", hdrm_mv, VMAX_HDRM_MAX_MV); return -EINVAL; } val = hdrm_mv / VMAX_HDRM_STEP_MV; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_VMAX_HDRM_REG, &val, 1); if (rc < 0) dev_err(chip->dev, "config VMAX_HDRM failed, rc=%d\n", rc); return rc; } static int haptics_get_vmax_headroom_mv(struct haptics_chip *chip, u32 *hdrm_mv) { int rc; u8 val; rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_VMAX_HDRM_REG, &val, 1); if (rc < 0) { dev_err(chip->dev, "Get Vmax HDRM failed, rc=%d\n", rc); return rc; } *hdrm_mv = (val & VMAX_HDRM_MASK) * VMAX_HDRM_STEP_MV; return 0; } static int haptics_enable_autores(struct haptics_chip *chip, bool en) { int rc; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_AUTORES_CFG_REG, AUTORES_EN_BIT, en ? AUTORES_EN_BIT : 0); if (rc < 0) dev_err(chip->dev, "%s auto resonance failed, rc=%d\n", en ? "enable" : "disable", rc); return rc; } static int haptics_set_direct_play(struct haptics_chip *chip, u8 amplitude) { int rc; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_DIRECT_PLAY_REG, &litude, 1); if (rc < 0) dev_err(chip->dev, "config DIRECT_PLAY failed, rc=%d\n", rc); return rc; } static bool is_boost_vreg_enabled_in_open_loop(struct haptics_chip *chip) { int rc; u8 val; if (is_haptics_external_powered(chip)) return false; rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_VREG_EN_REG, &val, 1); if (rc < 0) return false; chip->hboost_enabled = (val & VREG_EN_BIT); rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_HW_CTRL_FOLLOW_REG, &val, 1); if (rc < 0) return false; if (!(val & FOLLOW_HW_EN_BIT) && chip->hboost_enabled) { dev_dbg(chip->dev, "HBoost is enabled in open loop condition\n"); return true; } return false; } #define PBS_ARG_REG 0x42 #define HAP_VREG_ON_VAL 0x1 #define HAP_VREG_OFF_VAL 0x2 #define PBS_TRIG_SET_REG 0xE5 #define PBS_TRIG_SET_VAL 0x1 static int haptics_boost_vreg_enable(struct haptics_chip *chip, bool en) { int rc; u8 val; if (is_haptics_external_powered(chip)) return 0; if (!(chip->wa_flags & SW_CTRL_HBST)) return 0; if (chip->hap_cfg_nvmem == NULL) { dev_dbg(chip->dev, "nvmem device for hap_cfg is not defined\n"); return 0; } if (is_boost_vreg_enabled_in_open_loop(chip)) { dev_dbg(chip->dev, "Ignore %s hBoost while it's enabled in open-loop mode\n", en ? "enabling" : "disabling"); return 0; } if (chip->hboost_enabled == en) return 0; val = en ? HAP_VREG_ON_VAL : HAP_VREG_OFF_VAL; rc = nvmem_device_write(chip->hap_cfg_nvmem, PBS_ARG_REG, 1, &val); if (rc < 0) { dev_err(chip->dev, "write SDAM %#x failed, rc=%d\n", PBS_ARG_REG, rc); return rc; } val = PBS_TRIG_SET_VAL; rc = nvmem_device_write(chip->hap_cfg_nvmem, PBS_TRIG_SET_REG, 1, &val); if (rc < 0) { dev_err(chip->dev, "Write SDAM %#x failed, rc=%d\n", PBS_TRIG_SET_REG, rc); return rc; } chip->hboost_enabled = en; return 0; } static bool is_swr_play_enabled(struct haptics_chip *chip) { int rc; u8 val[2]; rc = haptics_get_status_data(chip, HAP_DRV_STS, val); if (rc < 0) return false; if ((val[1] & HAP_DRV_PATTERN_SRC_STATUS_MASK) == SWR) return true; return false; } #define HBOOST_WAIT_READY_COUNT 100 #define HBOOST_WAIT_READY_INTERVAL_US 200 static int haptics_wait_hboost_ready(struct haptics_chip *chip) { int i, rc; u8 val; if (is_haptics_external_powered(chip)) return 0; if (!(chip->wa_flags & SW_CTRL_HBST)) return 0; if ((hrtimer_get_remaining(&chip->hbst_off_timer) > 0) || hrtimer_active(&chip->hbst_off_timer)) { hrtimer_cancel(&chip->hbst_off_timer); dev_dbg(chip->dev, "hboost is still on, ignore\n"); return 0; } /* * Wait ~20ms until hBoost is ready, otherwise * bail out and return -EBUSY */ for (i = 0; i < HBOOST_WAIT_READY_COUNT; i++) { /* HBoost is always ready when working in open loop mode */ if (is_boost_vreg_enabled_in_open_loop(chip)) return 0; /* * If there is already a SWR play in the background, then HBoost * will be kept as on hence no need to wait its ready. */ mutex_lock(&chip->play.lock); if (is_swr_play_enabled(chip)) { dev_dbg(chip->dev, "Ignore waiting hBoost when SWR play is in progress\n"); mutex_unlock(&chip->play.lock); return 0; } mutex_unlock(&chip->play.lock); /* Check if HBoost is in standby (disabled) state */ rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_VREG_EN_REG, &val, 1); if (!rc && !(val & VREG_EN_BIT)) { rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_STATUS4_REG, &val, 1); if (!rc && !(val & BOOST_DTEST1_STATUS_BIT)) return 0; } dev_dbg(chip->dev, "hBoost is busy, wait %d\n", i); usleep_range(HBOOST_WAIT_READY_INTERVAL_US, HBOOST_WAIT_READY_INTERVAL_US + 1); } if (i == HBOOST_WAIT_READY_COUNT) { dev_err(chip->dev, "hboost is not ready for haptics play\n"); return -EBUSY; } return 0; } static int haptics_enable_hpwr_vreg(struct haptics_chip *chip, bool en) { int rc; if (chip->hpwr_vreg == NULL || chip->hpwr_vreg_enabled == en) return 0; if (en) { rc = regulator_set_voltage(chip->hpwr_vreg, chip->hpwr_voltage_mv * 1000, INT_MAX); if (rc < 0) { dev_err(chip->dev, "Set hpwr voltage failed, rc=%d\n", rc); return rc; } rc = regulator_enable(chip->hpwr_vreg); if (rc < 0) { dev_err(chip->dev, "Enable hpwr failed, rc=%d\n", rc); regulator_set_voltage(chip->hpwr_vreg, 0, INT_MAX); return rc; } } else { rc = regulator_disable(chip->hpwr_vreg); if (rc < 0) { dev_err(chip->dev, "Disable hpwr failed, rc=%d\n", rc); return rc; } rc = regulator_set_voltage(chip->hpwr_vreg, 0, INT_MAX); if (rc < 0) { dev_err(chip->dev, "Set hpwr voltage failed, rc=%d\n", rc); return rc; } } dev_dbg(chip->dev, "%s hpwr vreg\n", en ? "enabled" : "disabled"); chip->hpwr_vreg_enabled = en; return 0; } static int haptics_force_vreg_ready(struct haptics_chip *chip, bool ready) { u8 mask; mask = FORCE_VREG_RDY_BIT; if (chip->hw_type == HAP525_HV) mask |= FORCE_VSET_ACK_BIT; return haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_VSET_CFG_REG, mask, ready ? mask : 0); } static int haptics_open_loop_drive_config(struct haptics_chip *chip, bool en) { int rc = 0; u8 val; if ((is_boost_vreg_enabled_in_open_loop(chip) || chip->hboost_enabled || is_haptics_external_powered(chip)) && en) { /* * Only set force-VREG-ready here if hBoost is not used by charger firmware. * In the case of charger firmware enabling hBoost, force-VREG-ready will be * set/reset based on the VMAX_CLAMP notification. */ if (chip->clamped_vmax_mv == MAX_HV_VMAX_MV) { rc = haptics_force_vreg_ready(chip, true); if (rc < 0) return rc; } /* Toggle RC_CLK_CAL_EN if it's in auto mode */ rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, &val, 1); if (rc < 0) return rc; if ((chip->wa_flags & TOGGLE_CAL_RC_CLK) && ((val & CAL_RC_CLK_MASK) == CAL_RC_CLK_AUTO_VAL << CAL_RC_CLK_SHIFT)) { val = CAL_RC_CLK_DISABLED_VAL << CAL_RC_CLK_SHIFT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val); if (rc < 0) return rc; val = CAL_RC_CLK_AUTO_VAL << CAL_RC_CLK_SHIFT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val); if (rc < 0) return rc; dev_dbg(chip->dev, "Toggle CAL_EN in open-loop-VREG playing\n"); } #ifndef CONFIG_RICHTAP_FOR_PMIC_ENABLE } else if (!is_haptics_external_powered(chip) && (chip->clamped_vmax_mv == MAX_HV_VMAX_MV)) { /* * Reset force-VREG-ready only when hBoost is not * used by charger firmware. */ rc = haptics_force_vreg_ready(chip, false); if (rc < 0) return rc; } #else } else { val = en ? FORCE_VREG_RDY_BIT : 0; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_VSET_CFG_REG, FORCE_VREG_RDY_BIT, val); if (rc < 0) return rc; } #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE return 0; } static int haptics_clear_fault(struct haptics_chip *chip) { u8 val; val = SC_CLR_BIT | AUTO_RES_ERR_CLR_BIT | HPWR_RDY_FAULT_CLR_BIT; return haptics_write(chip, chip->cfg_addr_base, HAP_CFG_FAULT_CLR_REG, &val, 1); } static int haptics_wait_brake_complete(struct haptics_chip *chip) { struct haptics_play_info *play = &chip->play; u32 brake_length_us, t_lra_us, timeout, delay_us; int rc; u8 val; if (chip->hw_type != HAP525_HV) return 0; t_lra_us = (chip->config.cl_t_lra_us) ? chip->config.cl_t_lra_us : chip->config.t_lra_us; brake_length_us = get_brake_play_length_us(play->brake, t_lra_us); /* add a cycle to give some margin for brake sychronization */ brake_length_us += t_lra_us; delay_us = t_lra_us / 2; timeout = brake_length_us / delay_us + 1; dev_dbg(chip->dev, "wait %d us for brake pattern to complete\n", brake_length_us); /* poll HPWR_DISABLED to guarantee the brake pattern has been played completely */ do { usleep_range(delay_us, delay_us + 1); rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_HPWR_INTF_REG, &val, 1); if (rc < 0) { dev_err(chip->dev, "read HPWR_INTF failed, rc=%d\n", rc); return rc; } if ((val & HPWR_INTF_STATUS_MASK) == HPWR_DISABLED) { dev_dbg(chip->dev, "stopped play completely"); break; } dev_dbg(chip->dev, "polling HPWR_INTF timeout %d, value = %d\n", timeout, val); } while (--timeout); if (timeout == 0) { dev_warn(chip->dev, "poll HPWR_DISABLED failed after stopped play\n"); return haptics_toggle_module_enable(chip); } return 0; } #define BOOST_VREG_OFF_DELAY_SECONDS 2 static int haptics_enable_play(struct haptics_chip *chip, bool en) { struct haptics_play_info *play = &chip->play; int rc; u8 val; if (en) { rc = haptics_clear_fault(chip); if (rc < 0) return rc; } rc = haptics_open_loop_drive_config(chip, en); if (rc < 0) return rc; val = play->pattern_src; if (chip->hw_type == HAP525_HV && play->pattern_src == PATTERN_MEM) val |= FIELD_PREP(PATX_MEM_SEL_MASK, play->effect->pat_sel); if (play->brake && !play->brake->disabled) val |= BRAKE_EN_BIT; if (en) val |= PLAY_EN_BIT; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_SPMI_PLAY_REG, &val, 1); if (rc < 0) { dev_err(chip->dev, "Write SPMI_PLAY failed, rc=%d\n", rc); return rc; } if (!en) haptics_wait_brake_complete(chip); if (chip->wa_flags & SW_CTRL_HBST) { if (en) { rc = haptics_boost_vreg_enable(chip, true); if (rc < 0) { dev_err(chip->dev, "Keep boost vreg on failed, rc=%d\n", rc); return rc; } } else { hrtimer_start(&chip->hbst_off_timer, ktime_set(BOOST_VREG_OFF_DELAY_SECONDS, 0), HRTIMER_MODE_REL); } } if ((chip->wa_flags & TOGGLE_MODULE_EN) && !en) rc = haptics_toggle_module_enable(chip); trace_qcom_haptics_play(en); return rc; } static int haptics_set_brake(struct haptics_chip *chip, struct brake_cfg *brake) { int rc = 0; u8 zero_samples[BRAKE_SAMPLE_COUNT] = {0}, val; if (brake->disabled) return 0; val = brake->mode << BRAKE_MODE_SHIFT | brake->sine_gain << BRAKE_SINE_GAIN_SHIFT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_BRAKE_MODE_CFG_REG, BRAKE_MODE_MASK | BRAKE_SINE_GAIN_MASK, val); if (rc < 0) { dev_err(chip->dev, "set brake CFG failed, rc=%d\n", rc); return rc; } rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_BRAKE_AMP_REG, (brake->mode == OL_BRAKE || brake->mode == CL_BRAKE) ? brake->samples : zero_samples, BRAKE_SAMPLE_COUNT); if (rc < 0) { dev_err(chip->dev, "set brake pattern failed, rc=%d\n", rc); return rc; } return 0; } static int haptics_set_pattern(struct haptics_chip *chip, struct pattern_cfg *pattern, enum pattern_src src) { struct pattern_s *sample; u8 values[SAMPLES_PER_PATTERN * 3] = { 0 }; u8 ptn_tlra_addr, ptn_cfg_addr; int i, rc, tmp; u32 play_rate_us; if (src != PATTERN1 && src != PATTERN2) { dev_err(chip->dev, "no pattern src specified!\n"); return -EINVAL; } ptn_tlra_addr = HAP_PTN_PTRN1_TLRA_MSB_REG; ptn_cfg_addr = HAP_PTN_PTRN1_CFG_REG; if (src == PATTERN2) { ptn_tlra_addr = HAP_PTN_PTRN2_TLRA_MSB_REG; ptn_cfg_addr = HAP_PTN_PTRN2_CFG_REG; } /* Adjust T_LRA before programming it into HW */ play_rate_us = pattern->play_rate_us; rc = haptics_adjust_lra_period(chip, &play_rate_us); if (rc < 0) return rc; /* Configure T_LRA for this pattern */ tmp = play_rate_us / TLRA_STEP_US; values[0] = (tmp >> 8) & TLRA_OL_MSB_MASK; values[1] = tmp & TLRA_OL_LSB_MASK; rc = haptics_write(chip, chip->ptn_addr_base, ptn_tlra_addr, values, 2); if (rc < 0) { dev_err(chip->dev, "update pattern TLRA failed, rc=%d\n", rc); return rc; } /* Configure pattern registers */ for (i = 0; i < SAMPLES_PER_PATTERN; i++) { sample = &pattern->samples[i]; values[i * 3] = sample->f_lra_x2 << PTRN_FLRA2X_SHIFT; values[i * 3] |= sample->period & PTRN_SAMPLE_PER_MASK; values[i * 3 + 1] = (sample->amplitude >> 8) & PTRN_AMP_MSB_MASK; values[i * 3 + 2] = sample->amplitude & PTRN_AMP_LSB_MASK; } rc = haptics_write(chip, chip->ptn_addr_base, ptn_cfg_addr, values, SAMPLES_PER_PATTERN * 3); if (rc < 0) { dev_err(chip->dev, "write pattern data failed, rc=%d\n", rc); return rc; } return 0; } static int haptics_update_memory_data(struct haptics_chip *chip, u8 *data, u32 length) { int rc, count, i; u32 left; u8 tmp[HAP_PTN_FIFO_DIN_NUM] = {0}; if (!length) return 0; count = length / HAP_PTN_FIFO_DIN_NUM; for (i = 0; i < count; i++) { rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_DIN_0_REG, data, HAP_PTN_FIFO_DIN_NUM); if (rc < 0) { dev_err(chip->dev, "bulk write FIFO_DIN failed, rc=%d\n", rc); return rc; } data += HAP_PTN_FIFO_DIN_NUM; } left = length % HAP_PTN_FIFO_DIN_NUM; if (left) { /* * In HAP520 module, when 1-byte FIFO write clashes * with the HW FIFO read operation, the HW will only read * 1 valid byte in every 4 bytes FIFO samples. So avoid * this by keeping the samples 4-byte aligned and always * use 4-byte write for HAP520 module. */ if (chip->hw_type == HAP520) { memcpy(tmp, data, left); rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_DIN_0_REG, tmp, HAP_PTN_FIFO_DIN_NUM); if (rc < 0) dev_err(chip->dev, "write FIFO_DIN failed, rc=%d\n", rc); return rc; } for (i = 0; i < left; i++) { rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_DIN_1B_REG, (data + i), 1); if (rc < 0) { dev_err(chip->dev, "write FIFO_DIN_1B failed, rc=%d\n", rc); return rc; } } } return 0; } static int haptics_update_fifo_samples(struct haptics_chip *chip, u8 *samples, u32 length, bool refill) { int rc; u8 val; if (!samples) { dev_err(chip->dev, "no data available to update FIFO\n"); return -EINVAL; } if (chip->hw_type == HAP525_HV && !refill) { val = MEM_FLUSH_RELOAD_BIT; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MEM_OP_ACCESS_REG, &val, 1); if (rc < 0) return rc; val = 0; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MEM_OP_ACCESS_REG, &val, 1); if (rc < 0) return rc; } return haptics_update_memory_data(chip, samples, length); } static int haptics_update_pat_mem_samples(struct haptics_chip *chip, enum pat_mem_sel pat_sel, u8 *samples, u32 length) { int rc; u8 val; if (!samples) { dev_err(chip->dev, "no data available to update PAT_MEM\n"); return -EINVAL; } /* only HAP525_HV supports PATx_MEM pattern source */ if (chip->hw_type != HAP525_HV) { dev_dbg(chip->dev, "HW type %d doesn't support PATx_MEM pattern source\n", chip->hw_type); return 0; } val = FIELD_PREP(MEM_PAT_RW_SEL_MASK, pat_sel); val |= MEM_PAT_ACCESS_BIT | MEM_FLUSH_RELOAD_BIT; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MEM_OP_ACCESS_REG, &val, 1); if (rc < 0) return rc; val &= ~MEM_FLUSH_RELOAD_BIT; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MEM_OP_ACCESS_REG, &val, 1); if (rc < 0) return rc; rc = haptics_update_memory_data(chip, samples, length); rc |= haptics_masked_write(chip, chip->ptn_addr_base, HAP_PTN_MEM_OP_ACCESS_REG, MEM_PAT_ACCESS_BIT, 0); return rc; } static int haptics_get_fifo_fill_status(struct haptics_chip *chip, u32 *fill) { int rc; u8 val[2], fill_status_mask; u32 filled, available; bool empty = false, full = false; rc = haptics_get_status_data(chip, FIFO_REAL_TIME_STS, val); if (rc < 0) return rc; switch (chip->hw_type) { case HAP520: fill_status_mask = FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V2; break; case HAP520_MV: fill_status_mask = FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V3; break; case HAP525_HV: fill_status_mask = FIFO_REAL_TIME_FILL_STATUS_MSB_MASK_V4; break; default: dev_err(chip->dev, "HW type %d is not supported\n", chip->hw_type); return -EINVAL; } filled = ((val[0] & fill_status_mask) << 8) | val[1]; empty = !!(val[0] & FIFO_EMPTY_FLAG_BIT); full = !!(val[0] & FIFO_FULL_FLAG_BIT); available = get_max_fifo_samples(chip) - filled; dev_dbg(chip->dev, "filled=%u, available=%u, full=%d, empty=%d\n", filled, available, full, empty); trace_qcom_haptics_fifo_hw_status(filled, available, full, empty); *fill = filled; return 0; } static int haptics_get_available_fifo_memory(struct haptics_chip *chip) { int rc; u32 fill, available; rc = haptics_get_fifo_fill_status(chip, &fill); if (rc < 0) return rc; if (fill > get_max_fifo_samples(chip)) { dev_err(chip->dev, "Filled FIFO number %d exceed the max %d\n", fill, get_max_fifo_samples(chip)); return -EINVAL; } else if (fill == get_max_fifo_samples(chip)) { dev_err(chip->dev, "no FIFO space available\n"); return -EBUSY; } available = get_max_fifo_samples(chip) - fill; return available; } static int haptics_set_manual_rc_clk_cal(struct haptics_chip *chip) { int rc; u16 cal_count = chip->config.rc_clk_cal_count; u8 val[2]; if (cal_count == 0) { dev_dbg(chip->dev, "Ignore setting RC_CLK_CAL_COUNT\n"); return 0; } val[0] = (cal_count >> 8) & RC_CLK_CAL_COUNT_MSB_MASK; val[1] = cal_count & RC_CLK_CAL_COUNT_LSB_MASK; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_RC_CLK_CAL_COUNT_MSB_REG, val, 2); if (rc < 0) return rc; val[0] = CAL_RC_CLK_MANUAL_VAL << CAL_RC_CLK_SHIFT; return haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val[0]); } static int haptics_set_fifo_playrate(struct haptics_chip *chip, enum s_period period_per_s) { int rc; rc = haptics_masked_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_PLAY_RATE_REG, FIFO_PLAY_RATE_MASK, period_per_s); if (rc < 0) dev_err(chip->dev, "Set FIFO play rate failed, rc=%d\n", rc); return rc; } static int haptics_set_fifo_empty_threshold(struct haptics_chip *chip, u32 thresh) { u8 thresh_per_bit; int rc; rc = get_fifo_threshold_per_bit(chip); if (rc < 0) return rc; thresh_per_bit = rc; rc = haptics_masked_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_EMPTY_CFG_REG, EMPTY_THRESH_MASK, (thresh / thresh_per_bit)); if (rc < 0) dev_err(chip->dev, "Set FIFO empty threshold failed, rc=%d\n", rc); return rc; } static void haptics_fifo_empty_irq_config(struct haptics_chip *chip, bool enable) { if (!chip->fifo_empty_irq_en && enable) { enable_irq(chip->fifo_empty_irq); chip->fifo_empty_irq_en = true; } else if (chip->fifo_empty_irq_en && !enable) { disable_irq_nosync(chip->fifo_empty_irq); chip->fifo_empty_irq_en = false; } } static int haptics_set_fifo(struct haptics_chip *chip, struct fifo_cfg *fifo) { struct fifo_play_status *status = &chip->play.fifo_status; u32 num, fifo_thresh; int rc, available; if (atomic_read(&status->is_busy) == 1) { dev_err(chip->dev, "FIFO is busy\n"); return -EBUSY; } /* Configure FIFO play rate */ rc = haptics_set_fifo_playrate(chip, fifo->period_per_s); if (rc < 0) return rc; if (fifo->period_per_s >= F_8KHZ) { /* Set manual RC CLK CAL when playing FIFO */ rc = haptics_set_manual_rc_clk_cal(chip); if (rc < 0) return rc; } atomic_set(&status->written_done, 0); atomic_set(&status->cancelled, 0); status->samples_written = 0; /* * Write the 1st set of the data into FIFO if there are * more than MAX_FIFO_SAMPLES samples, the rest will be * written if any FIFO memory is available after playing. */ num = min_t(u32, fifo->num_s, get_max_fifo_samples(chip)); available = haptics_get_available_fifo_memory(chip); if (available < 0) return available; num = min_t(u32, available, num); num = min_t(u32, num, FIFO_PRGM_INIT_SIZE); /* Keep the FIFO programming 4-byte aligned if FIFO refilling is needed */ if ((num < fifo->num_s) && (num % HAP_PTN_FIFO_DIN_NUM)) num = round_down(num, HAP_PTN_FIFO_DIN_NUM); rc = haptics_update_fifo_samples(chip, fifo->samples, num, false); if (rc < 0) { dev_err(chip->dev, "write FIFO samples failed, rc=%d\n", rc); return rc; } atomic_set(&status->is_busy, 1); status->samples_written = num; trace_qcom_haptics_fifo_prgm_status(fifo->num_s, status->samples_written, num); if (num == fifo->num_s) { fifo_thresh = 0; atomic_set(&status->written_done, 1); } else { fifo_thresh = chip->config.fifo_empty_thresh; } /* * Set FIFO empty threshold here. FIFO empty IRQ will * be enabled after playing FIFO samples so that more * FIFO samples can be written (if available) when * FIFO empty IRQ is triggered. */ rc = haptics_set_fifo_empty_threshold(chip, fifo_thresh); if (rc < 0) return rc; haptics_fifo_empty_irq_config(chip, true); return 0; } static int haptics_load_constant_effect(struct haptics_chip *chip, u8 amplitude) { struct haptics_play_info *play = &chip->play; u32 hdrm_mv, vmax_mv = chip->config.vmax_mv; int rc = 0; mutex_lock(&chip->play.lock); if (chip->play.in_calibration) { dev_err(chip->dev, "calibration in progress, ignore playing constant effect\n"); rc = -EBUSY; goto unlock; } /* No effect data when playing constant waveform */ play->effect = NULL; /* Fix Vmax to (hpwr_vreg_mv - hdrm_mv) in non-HBOOST regulator case */ if (is_haptics_external_powered(chip)) { rc = haptics_get_vmax_headroom_mv(chip, &hdrm_mv); if (rc < 0) goto unlock; vmax_mv = chip->hpwr_voltage_mv - hdrm_mv; } /* configure VMAX in case it was changed in previous effect playing */ rc = haptics_set_vmax_mv(chip, vmax_mv); if (rc < 0) goto unlock; /* Config brake settings if it's necessary */ play->brake = &chip->config.brake; if (play->brake) { rc = haptics_set_brake(chip, play->brake); if (rc < 0) goto unlock; } rc = haptics_set_direct_play(chip, amplitude); if (rc < 0) goto unlock; /* Always enable LRA auto resonance for DIRECT_PLAY */ rc = haptics_enable_autores(chip, !chip->config.is_erm); if (rc < 0) goto unlock; play->pattern_src = DIRECT_PLAY; unlock: mutex_unlock(&chip->play.lock); return rc; } static int haptics_load_predefined_effect(struct haptics_chip *chip, struct haptics_effect *effect) { struct haptics_play_info *play = &chip->play; int rc; if (effect == NULL) return -EINVAL; play->effect = effect; /* Clamp VMAX for different vibration strength */ rc = haptics_set_vmax_mv(chip, play->vmax_mv); if (rc < 0) return rc; play->pattern_src = play->effect->src; if (play->pattern_src == DIRECT_PLAY || play->pattern_src == SWR) { dev_err(chip->dev, "pattern src %d can't be used for predefined effect\n", play->pattern_src); return -EINVAL; } if ((play->pattern_src == FIFO) && (chip->wa_flags & TOGGLE_EN_TO_FLUSH_FIFO)) { /* Toggle HAPTICS_EN for a clear start point of FIFO playing */ rc = haptics_toggle_module_enable(chip); if (rc < 0) return rc; } rc = haptics_enable_autores(chip, !play->effect->auto_res_disable); if (rc < 0) return rc; play->brake = play->effect->brake; /* Config brake settings if it's necessary */ if (play->brake) { rc = haptics_set_brake(chip, play->brake); if (rc < 0) return rc; } if (play->pattern_src == PATTERN1 || play->pattern_src == PATTERN2) { if (play->effect->pattern->preload) { dev_dbg(chip->dev, "Ignore preloaded effect: %d\n", play->effect->id); return 0; } rc = haptics_set_pattern(chip, play->effect->pattern, play->pattern_src); if (rc < 0) return rc; } if (play->pattern_src == FIFO) { rc = haptics_set_fifo(chip, play->effect->fifo); if (rc < 0) return rc; } /* * PATTERN_MEM sources (PATx_MEM) introduced in HAP525_HV haptics * module are used for preload effects. The pattern for the preload * effect should have been programmed during boot up and it will be * retained until device is powered off, so it doesn't need to be * programmed at runtime. */ if (chip->hw_type == HAP525_HV && play->pattern_src == PATTERN_MEM) { if (!play->effect->fifo->preload) { dev_err(chip->dev, "effect %d has PAT_MEM src but not preloaded\n", play->effect->id); return -EINVAL; } /* disable auto resonance for PATx_MEM mode */ rc = haptics_enable_autores(chip, false); if (rc < 0) return rc; dev_dbg(chip->dev, "Ignore loading data for preload FIFO effect: %d\n", play->effect->id); } return 0; } static int haptics_init_custom_effect(struct haptics_chip *chip) { chip->custom_effect = devm_kzalloc(chip->dev, sizeof(*chip->custom_effect), GFP_KERNEL); if (!chip->custom_effect) return -ENOMEM; chip->custom_effect->fifo = devm_kzalloc(chip->dev, sizeof(*chip->custom_effect->fifo), GFP_KERNEL); if (!chip->custom_effect->fifo) return -ENOMEM; /* custom effect will be played in FIFO mode without brake */ chip->custom_effect->pattern = NULL; chip->custom_effect->brake = NULL; chip->custom_effect->id = UINT_MAX; chip->custom_effect->vmax_mv = chip->config.vmax_mv; chip->custom_effect->t_lra_us = chip->config.t_lra_us; chip->custom_effect->src = FIFO; chip->custom_effect->auto_res_disable = true; return 0; } static int haptics_convert_sample_period(struct haptics_chip *chip, u32 play_rate_hz) { enum s_period period; u32 f_lra, f_lra_min, f_lra_max; if (chip->config.t_lra_us == 0) return -EINVAL; f_lra = USEC_PER_SEC / chip->config.t_lra_us; if (f_lra == 0 || f_lra < F_LRA_VARIATION_HZ) return -EINVAL; f_lra_min = f_lra - F_LRA_VARIATION_HZ; f_lra_max = f_lra + F_LRA_VARIATION_HZ; if (play_rate_hz == 8000) period = F_8KHZ; else if (play_rate_hz == 16000) period = F_16KHZ; else if (play_rate_hz == 24000) period = F_24KHZ; else if (play_rate_hz == 32000) period = F_32KHZ; else if (play_rate_hz == 44100) period = F_44P1KHZ; else if (play_rate_hz == 48000) period = F_48KHZ; else if (is_between(play_rate_hz, f_lra_min, f_lra_max)) period = T_LRA; else if (is_between(play_rate_hz / 2, f_lra_min, f_lra_max)) period = T_LRA_DIV_2; else if (is_between(play_rate_hz / 4, f_lra_min, f_lra_max)) period = T_LRA_DIV_4; else if (is_between(play_rate_hz / 8, f_lra_min, f_lra_max)) period = T_LRA_DIV_8; else if (is_between(play_rate_hz * 2, f_lra_min, f_lra_max)) period = T_LRA_X_2; else if (is_between(play_rate_hz * 4, f_lra_min, f_lra_max)) period = T_LRA_X_4; else if (is_between(play_rate_hz * 8, f_lra_min, f_lra_max)) period = T_LRA_X_8; else return -EINVAL; return period; } static int haptics_load_custom_effect(struct haptics_chip *chip, s16 __user *data, u32 length, s16 magnitude) { struct haptics_play_info *play = &chip->play; struct custom_fifo_data custom_data = {}; struct fifo_cfg *fifo; int rc; if (!chip->custom_effect || !chip->custom_effect->fifo) return -ENOMEM; fifo = chip->custom_effect->fifo; if (copy_from_user(&custom_data, data, sizeof(custom_data))) return -EFAULT; dev_dbg(chip->dev, "custom data length %d with play-rate %d Hz\n", custom_data.length, custom_data.play_rate_hz); rc = haptics_convert_sample_period(chip, custom_data.play_rate_hz); if (rc < 0) { dev_err(chip->dev, "Can't support play rate: %d Hz\n", custom_data.play_rate_hz); return rc; } mutex_lock(&chip->play.lock); fifo->period_per_s = rc; /* * Before allocating samples buffer, free the old sample * buffer first if it's not been freed. */ kvfree(fifo->samples); fifo->samples = kcalloc(custom_data.length, sizeof(u8), GFP_KERNEL); if (!fifo->samples) { fifo->samples = vmalloc(custom_data.length); if (!fifo->samples) { rc = -ENOMEM; goto unlock; } } if (copy_from_user(fifo->samples, (u8 __user *)custom_data.data, custom_data.length)) { rc = -EFAULT; goto cleanup; } dev_dbg(chip->dev, "Copy custom FIFO samples successfully\n"); fifo->num_s = custom_data.length; fifo->play_length_us = get_fifo_play_length_us(fifo, chip->custom_effect->t_lra_us); if (chip->play.in_calibration) { dev_err(chip->dev, "calibration in progress, ignore playing custom effect\n"); rc = -EBUSY; goto cleanup; } play->effect = chip->custom_effect; play->brake = NULL; play->vmax_mv = (magnitude * chip->custom_effect->vmax_mv) / 0x7fff; rc = haptics_set_vmax_mv(chip, play->vmax_mv); if (rc < 0) goto cleanup; /* Toggle HAPTICS_EN for a clear start point of FIFO playing */ if (chip->wa_flags & TOGGLE_EN_TO_FLUSH_FIFO) { rc = haptics_toggle_module_enable(chip); if (rc < 0) goto cleanup; } rc = haptics_enable_autores(chip, !play->effect->auto_res_disable); if (rc < 0) goto cleanup; play->pattern_src = FIFO; rc = haptics_set_fifo(chip, play->effect->fifo); if (rc < 0) goto cleanup; mutex_unlock(&chip->play.lock); return 0; cleanup: kvfree(fifo->samples); fifo->samples = NULL; unlock: mutex_unlock(&chip->play.lock); return rc; } static u32 get_play_length_effect_us(struct haptics_effect *effect) { u32 length_us = 0; if (effect->brake) length_us = effect->brake->play_length_us; if ((effect->src == PATTERN1 || effect->src == PATTERN2) && effect->pattern) length_us += effect->pattern->play_length_us; else if (effect->src == FIFO && effect->fifo) length_us += effect->fifo->play_length_us; return length_us; } static inline u32 get_play_length_us(struct haptics_play_info *play) { return get_play_length_effect_us(play->effect); } #define PRIMITIVE_EFFECT_ID_BIT BIT(15) #define PRIMITIVE_EFFECT_ID_MASK GENMASK(14, 0) static int haptics_load_periodic_effect(struct haptics_chip *chip, s16 __user *data, u32 length, s16 magnitude) { struct haptics_play_info *play = &chip->play; s16 custom_data[CUSTOM_DATA_LEN] = { 0 }; struct haptics_effect *effects = NULL; s16 custom_id = 0; int effects_count = 0; int rc, i; bool primitive; if (copy_from_user(custom_data, data, sizeof(custom_data))) return -EFAULT; primitive = !!(custom_data[CUSTOM_DATA_EFFECT_IDX] & PRIMITIVE_EFFECT_ID_BIT); if (primitive) { if (chip->primitives_count == 0) return -EINVAL; custom_id = custom_data[CUSTOM_DATA_EFFECT_IDX] & PRIMITIVE_EFFECT_ID_MASK; effects = chip->primitives; effects_count = chip->primitives_count; } else { if (chip->effects_count == 0) return -EINVAL; custom_id = custom_data[CUSTOM_DATA_EFFECT_IDX]; effects = chip->effects; effects_count = chip->effects_count; } for (i = 0; i < effects_count; i++) if (effects[i].id == custom_id) break; if (i == effects_count) { dev_err(chip->dev, "effect%d is not supported!\n", custom_data[CUSTOM_DATA_EFFECT_IDX]); return -EINVAL; } mutex_lock(&chip->play.lock); if (chip->play.in_calibration) { dev_err(chip->dev, "calibration in progress, ignore playing predefined effect\n"); rc = -EBUSY; goto unlock; } play->vmax_mv = (magnitude * effects[i].vmax_mv) / 0x7fff; dev_dbg(chip->dev, "upload %s effect %d, vmax=%d\n", primitive ? "primitive" : "predefined", effects[i].id, play->vmax_mv); rc = haptics_load_predefined_effect(chip, &effects[i]); if (rc < 0) { dev_err(chip->dev, "Play predefined effect%d failed, rc=%d\n", effects[i].id, rc); goto unlock; } mutex_unlock(&chip->play.lock); play->length_us = get_play_length_us(play); custom_data[CUSTOM_DATA_TIMEOUT_SEC_IDX] = play->length_us / USEC_PER_SEC; custom_data[CUSTOM_DATA_TIMEOUT_MSEC_IDX] = (play->length_us % USEC_PER_SEC) / USEC_PER_MSEC; if (copy_to_user(data, custom_data, length)) return -EFAULT; return 0; unlock: mutex_unlock(&chip->play.lock); return rc; } static u8 get_direct_play_max_amplitude(struct haptics_chip *chip) { u32 amplitude = DIRECT_PLAY_MAX_AMPLITUDE, hdrm_mv; int rc; if (is_haptics_external_powered(chip)) { rc = haptics_get_vmax_headroom_mv(chip, &hdrm_mv); if (rc < 0) return 0; amplitude *= chip->config.vmax_mv; amplitude /= (chip->hpwr_voltage_mv - hdrm_mv); if (amplitude > DIRECT_PLAY_MAX_AMPLITUDE) amplitude = DIRECT_PLAY_MAX_AMPLITUDE; } dev_dbg(chip->dev, "max amplitude for direct play: %#x\n", amplitude); return (u8)amplitude; } static int haptics_stop_fifo_play(struct haptics_chip *chip) { int rc; u8 val; if (atomic_read(&chip->play.fifo_status.is_busy) == 0) { dev_info(chip->dev, "FIFO playing is not in progress\n"); return 0; } rc = haptics_enable_play(chip, false); if (rc < 0) return rc; /* restore FIFO play rate back to T_LRA */ rc = haptics_set_fifo_playrate(chip, T_LRA); if (rc < 0) return rc; haptics_fifo_empty_irq_config(chip, false); kvfree(chip->custom_effect->fifo->samples); chip->custom_effect->fifo->samples = NULL; atomic_set(&chip->play.fifo_status.is_busy, 0); /* * All other playing modes would use AUTO mode RC * calibration except FIFO streaming mode, so restore * back to AUTO RC calibration after FIFO playing. */ val = CAL_RC_CLK_AUTO_VAL << CAL_RC_CLK_SHIFT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val); if (rc < 0) return rc; dev_info(chip->dev, "stopped FIFO playing successfully\n"); return 0; } static void haptics_stop_constant_effect_play(struct work_struct *work) { struct haptics_chip *chip = container_of(work, struct haptics_chip, stop_work.work); int rc = 0; rc = haptics_enable_play(chip, false); if (rc < 0) dev_err(chip->dev, "stop constant effect play failed\n"); rc = haptics_enable_hpwr_vreg(chip, false); if (rc < 0) dev_err(chip->dev, "disable hpwr_vreg failed\n"); } static int haptics_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old) { struct haptics_chip *chip = input_get_drvdata(dev); u32 length_ms, tmp; s16 level; u8 amplitude; int rc = 0; switch (effect->type) { case FF_CONSTANT: length_ms = effect->replay.length; level = effect->u.constant.level; tmp = get_direct_play_max_amplitude(chip); tmp *= level; amplitude = tmp / 0x7fff; dev_dbg(chip->dev, "upload constant effect, length = %dms, amplitude = %#x\n", length_ms, amplitude); schedule_delayed_work(&chip->stop_work, msecs_to_jiffies(length_ms)); haptics_load_constant_effect(chip, amplitude); if (rc < 0) { dev_err(chip->dev, "set direct play failed, rc=%d\n", rc); return rc; } break; case FF_PERIODIC: if (effect->u.periodic.waveform != FF_CUSTOM) { dev_err(chip->dev, "Only support custom waveforms\n"); return -EINVAL; } if (effect->u.periodic.custom_len == sizeof(struct custom_fifo_data)) { rc = haptics_load_custom_effect(chip, effect->u.periodic.custom_data, effect->u.periodic.custom_len, effect->u.periodic.magnitude); if (rc < 0) { dev_err(chip->dev, "Upload custom FIFO data failed, rc=%d\n", rc); return rc; } } else if (effect->u.periodic.custom_len == sizeof(s16) * CUSTOM_DATA_LEN) { rc = haptics_load_periodic_effect(chip, effect->u.periodic.custom_data, effect->u.periodic.custom_len, effect->u.periodic.magnitude); if (rc < 0) { dev_err(chip->dev, "Upload periodic effect failed, rc=%d\n", rc); return rc; } } break; default: dev_err(chip->dev, "%d effect is not supported\n", effect->type); return -EINVAL; } rc = haptics_enable_hpwr_vreg(chip, true); if (rc < 0) { dev_err(chip->dev, "enable hpwr_vreg failed, rc=%d\n", rc); return rc; } rc = haptics_wait_hboost_ready(chip); if (rc < 0 && chip->play.pattern_src == FIFO) { /* * Call haptics_stop_fifo_play(chip) explicitly if hBoost is * not ready for the FIFO play. This drops current FIFO play * but it restores the SW back to initial status so that the * following FIFO play requests can still be served. */ dev_dbg(chip->dev, "stop FIFO play explicitly to restore SW status\n"); mutex_lock(&chip->play.lock); haptics_stop_fifo_play(chip); mutex_unlock(&chip->play.lock); return rc; } return 0; } static int haptics_playback(struct input_dev *dev, int effect_id, int val) { struct haptics_chip *chip = input_get_drvdata(dev); dev_dbg(chip->dev, "playback val = %d\n", val); if (!!val) return haptics_enable_play(chip, true); return 0; } static int haptics_erase(struct input_dev *dev, int effect_id) { struct haptics_chip *chip = input_get_drvdata(dev); struct haptics_play_info *play = &chip->play; int rc; dev_dbg(chip->dev, "erase effect, really stop play\n"); mutex_lock(&play->lock); cancel_delayed_work_sync(&chip->stop_work); if ((play->pattern_src == FIFO) && atomic_read(&play->fifo_status.is_busy)) { if (atomic_read(&play->fifo_status.written_done) == 0) { dev_dbg(chip->dev, "cancelling FIFO playing\n"); atomic_set(&play->fifo_status.cancelled, 1); } rc = haptics_stop_fifo_play(chip); if (rc < 0) { dev_err(chip->dev, "stop FIFO playing failed, rc=%d\n", rc); mutex_unlock(&play->lock); return rc; } } else { rc = haptics_enable_play(chip, false); if (rc < 0) { dev_err(chip->dev, "stop play failed, rc=%d\n", rc); mutex_unlock(&play->lock); return rc; } } mutex_unlock(&play->lock); rc = haptics_enable_hpwr_vreg(chip, false); if (rc < 0) dev_err(chip->dev, "disable hpwr_vreg failed, rc=%d\n", rc); return rc; } static void haptics_set_gain_work(struct work_struct *work) { struct haptics_chip *chip = container_of(work, struct haptics_chip, set_gain_work); struct haptics_hw_config *config = &chip->config; struct haptics_play_info *play = &chip->play; u32 vmax_mv, amplitude; u16 gain; mutex_lock(&play->lock); gain = atomic_read(&play->gain); /* scale amplitude when playing in DIRECT_PLAY mode */ if (chip->play.pattern_src == DIRECT_PLAY) { amplitude = get_direct_play_max_amplitude(chip); amplitude *= gain; amplitude /= 0x7fff; dev_dbg(chip->dev, "Set amplitude: %#x\n", amplitude); haptics_set_direct_play(chip, (u8)amplitude); mutex_unlock(&play->lock); return; } /* scale Vmax when playing in other modes */ vmax_mv = config->vmax_mv; if (play->effect) vmax_mv = play->effect->vmax_mv; if (chip->clamp_at_5v && (vmax_mv > CLAMPED_VMAX_MV)) vmax_mv = CLAMPED_VMAX_MV; play->vmax_mv = ((u32)(gain * vmax_mv)) / 0x7fff; haptics_set_vmax_mv(chip, play->vmax_mv); mutex_unlock(&play->lock); } static void haptics_set_gain(struct input_dev *dev, u16 gain) { struct haptics_chip *chip = input_get_drvdata(dev); struct haptics_play_info *play = &chip->play; if (gain == 0) return; if (gain > 0x7fff) gain = 0x7fff; atomic_set(&play->gain, gain); schedule_work(&chip->set_gain_work); dev_dbg(chip->dev, "Set gain: %#x\n", gain); } static int haptics_store_cl_brake_settings(struct haptics_chip *chip) { int rc = 0; u8 val[2]; if (!chip->cl_brake_nvmem) return 0; rc = haptics_get_status_data(chip, RNAT_RCAL_INT, val); if (rc < 0) return rc; rc = nvmem_cell_write(chip->cl_brake_nvmem, &val[1], 1); if (rc < 0) dev_err(chip->dev, "store RNAT/RCAL to SDAM failed, rc=%d\n", rc); return rc; } static int haptics_config_openloop_lra_period(struct haptics_chip *chip, u32 t_lra_us) { u32 tmp; u8 val[2]; int rc; rc = haptics_adjust_lra_period(chip, &t_lra_us); if (rc < 0) return rc; tmp = t_lra_us / TLRA_STEP_US; val[0] = (tmp >> 8) & TLRA_OL_MSB_MASK; val[1] = tmp & TLRA_OL_LSB_MASK; return haptics_write(chip, chip->cfg_addr_base, HAP_CFG_TLRA_OL_HIGH_REG, val, 2); } static int haptics_config_preload_fifo_effect(struct haptics_chip *chip, struct haptics_effect *effect) { int rc; if (!effect->fifo->preload) { dev_err(chip->dev, "effect %d doesn't support preload\n", effect->id); return -EINVAL; } if (effect->src != PATTERN_MEM) { dev_err(chip->dev, "effect %d pattern_src is not PATTERN_MEM\n", effect->id); return -EINVAL; } rc = haptics_update_pat_mem_samples(chip, effect->pat_sel, effect->fifo->samples, effect->fifo->num_s); if (!rc) dev_dbg(chip->dev, "effect %d is preloaded in PAT_MEM %d\n", effect->id, effect->pat_sel); return rc; } static int haptics_mmap_config(struct haptics_chip *chip) { int rc, i, left; u8 val[4]; /* * Make the FIFO memory size 128-byte aligned, and append * the leftover memory bytes to PAT1_MEM. */ left = chip->mmap.fifo_mmap.length % MMAP_FIFO_LEN_PER_LSB; if (left) { chip->mmap.fifo_mmap.length -= left; chip->mmap.pat_sel_mmap[PAT1_MEM].length += left; } /* config MMAP_FIFO */ val[0] = chip->mmap.fifo_mmap.length / MMAP_FIFO_LEN_PER_LSB; if (val[0]-- == 0) { dev_err(chip->dev, "fifo length %d is less than %d\n", chip->mmap.fifo_mmap.length, MMAP_FIFO_LEN_PER_LSB); return -EINVAL; } val[0] &= MMAP_FIFO_LEN_MASK; val[0] |= MMAP_FIFO_EXIST_BIT; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MMAP_FIFO_REG, val, 1); if (rc < 0) return rc; /* config MMAP_PAT1/2/3/4 */ for (i = PAT1_MEM; i <= PAT4_MEM; i++) val[i] = min(chip->mmap.pat_sel_mmap[i].length, chip->mmap.pat_sel_mmap[i].max_size) / MMAP_PAT_LEN_PER_LSB; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_MMAP_PAT1_REG, val, 4); if (rc < 0) return rc; /* config PATx_PLAY_RATE */ rc = haptics_masked_write(chip, chip->ptn_addr_base, HAP_PTN_FIFO_PLAY_RATE_REG, PAT_MEM_PLAY_RATE_MASK, FIELD_PREP(PAT_MEM_PLAY_RATE_MASK, chip->mmap.pat_play_rate)); if (rc < 0) { dev_err(chip->dev, "Set pat_mem play rate failed, rc=%d\n", rc); return rc; } dev_dbg(chip->dev, "haptics memory map configured with FIFO: %d, PAT1:%d, PAT2: %d, PAT3: %d, PAT4: %d\n", chip->mmap.fifo_mmap.length, chip->mmap.pat_sel_mmap[PAT1_MEM].length, chip->mmap.pat_sel_mmap[PAT2_MEM].length, chip->mmap.pat_sel_mmap[PAT3_MEM].length, chip->mmap.pat_sel_mmap[PAT4_MEM].length); return 0; } static int haptics_mmap_preload_fifo_effect(struct haptics_chip *chip, struct haptics_effect *effect) { int i; u32 length, fifo_length; if (!effect->fifo->preload) { dev_err(chip->dev, "effect %d doesn't support preload\n", effect->id); return -EINVAL; } if (chip->mmap.pat_play_rate == F_RESERVED) { chip->mmap.pat_play_rate = effect->fifo->period_per_s; } else if (chip->mmap.pat_play_rate != effect->fifo->period_per_s) { dev_warn(chip->dev, "PATx_MEM sources only support one play rate\n"); goto mmap_failed; } length = effect->fifo->num_s; if (length % MMAP_PAT_LEN_PER_LSB) length = (length / MMAP_PAT_LEN_PER_LSB + 1) * MMAP_PAT_LEN_PER_LSB; fifo_length = chip->mmap.fifo_mmap.length - length; if (fifo_length < MMAP_FIFO_MIN_SIZE) { dev_warn(chip->dev, "not enough space for preload FIFO effect\n"); goto mmap_failed; } for (i = PAT4_MEM; i >= PAT1_MEM; i--) { if (!chip->mmap.pat_sel_mmap[i].in_use && (length <= chip->mmap.pat_sel_mmap[i].max_size)) break; } if (i < PAT1_MEM) { dev_warn(chip->dev, "no PAT_MEM source available\n"); effect->fifo->preload = false; goto mmap_failed; } /* update the mmap configuration */ chip->mmap.pat_sel_mmap[i].in_use = true; chip->mmap.pat_sel_mmap[i].length = length; chip->mmap.fifo_mmap.length = fifo_length; /* Update the effect pattern_src and pat_sel for the preload effect */ effect->src = PATTERN_MEM; effect->pat_sel = i; return 0; /* if mmap is failed then the effect couldn't be preloaded */ mmap_failed: effect->fifo->preload = false; return -ENOSPC; } static void haptics_mmap_init(struct haptics_chip *chip) { u32 max_pat_mem_size = MMAP_NUM_BYTES - MMAP_FIFO_MIN_SIZE; /* Assume that all memory space is used for FIFO mode by default */ chip->mmap.fifo_mmap.in_use = true; chip->mmap.fifo_mmap.length = MMAP_NUM_BYTES; chip->mmap.fifo_mmap.max_size = MMAP_NUM_BYTES; /* different PATx_MEM partition has different maximum size */ chip->mmap.pat_sel_mmap[PAT1_MEM].max_size = min(max_pat_mem_size, (u32)MMAP_PAT1_LEN_MASK * MMAP_PAT_LEN_PER_LSB); chip->mmap.pat_sel_mmap[PAT2_MEM].max_size = min(max_pat_mem_size, (u32)MMAP_PAT2_LEN_MASK * MMAP_PAT_LEN_PER_LSB); chip->mmap.pat_sel_mmap[PAT3_MEM].max_size = min(max_pat_mem_size, (u32)MMAP_PAT3_PAT4_LEN_MASK * MMAP_PAT_LEN_PER_LSB); chip->mmap.pat_sel_mmap[PAT4_MEM].max_size = min(max_pat_mem_size, (u32)MMAP_PAT3_PAT4_LEN_MASK * MMAP_PAT_LEN_PER_LSB); chip->mmap.pat_play_rate = F_RESERVED; } static int haptics_init_fifo_memory(struct haptics_chip *chip) { struct haptics_effect *effect; int rc, i; if (chip->hw_type != HAP525_HV) { dev_dbg(chip->dev, "HW type %d doesn't support mmap\n", chip->hw_type); return 0; } haptics_mmap_init(chip); for (i = 0; i < chip->effects_count; i++) { effect = &chip->effects[i]; if (!effect->fifo || !effect->fifo->preload) continue; rc = haptics_mmap_preload_fifo_effect(chip, effect); if (rc < 0 && rc != -ENOSPC) return rc; } rc = haptics_mmap_config(chip); if (rc < 0) return rc; for (i = 0; i < chip->effects_count; i++) { effect = &chip->effects[i]; if (!effect->fifo || !effect->fifo->preload) continue; rc = haptics_config_preload_fifo_effect(chip, effect); if (rc < 0) return rc; } return 0; } static int haptics_init_preload_pattern_effect(struct haptics_chip *chip) { struct haptics_hw_config *config = &chip->config; struct haptics_effect *effect; int i; if (config->preload_effect == -EINVAL) return 0; for (i = 0; i < chip->effects_count; i++) if (chip->effects[i].id == config->preload_effect) break; if (i == chip->effects_count) { dev_err(chip->dev, "preload effect %d is not found\n", config->preload_effect); return -EINVAL; } effect = &chip->effects[i]; return haptics_set_pattern(chip, effect->pattern, effect->src); } static int haptics_init_lra_period_config(struct haptics_chip *chip) { int rc = 0; u8 val; u32 t_lra_us; /* set AUTO_mode RC CLK calibration by default */ val = FIELD_PREP(CAL_RC_CLK_MASK, CAL_RC_CLK_AUTO_VAL); rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val); if (rc < 0) return rc; /* get calibrated close loop period */ t_lra_us = chip->config.t_lra_us; rc = haptics_get_closeloop_lra_period(chip, true); if (!rc && chip->config.cl_t_lra_us != 0) t_lra_us = chip->config.cl_t_lra_us; else dev_warn(chip->dev, "get closeloop LRA period failed, rc=%d\n", rc); /* Config T_LRA */ return haptics_config_openloop_lra_period(chip, t_lra_us); } static int haptics_init_hpwr_config(struct haptics_chip *chip) { int rc; u8 val; if ((chip->hw_type == HAP520_MV) && !chip->hpwr_vreg) { /* Indicates if HPWR is BOB or Bharger */ rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_HPWR_INTF_CTL_REG, &val, 1); if (rc < 0) return rc; chip->hpwr_intf_ctl = val & INTF_CTL_MASK; /* Read HPWR voltage to adjust the VMAX */ if (chip->hpwr_voltage_mv == 0 && chip->hpwr_intf_ctl == INTF_CTL_BOB) { rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_VHPWR_REG, &val, 1); if (rc < 0) return rc; chip->hpwr_voltage_mv = val * VHPWR_STEP_MV; } } /* Force VREG_RDY if non-HBoost is used for powering haptics */ if (is_haptics_external_powered(chip)) return haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_VSET_CFG_REG, FORCE_VREG_RDY_BIT, FORCE_VREG_RDY_BIT); return 0; } static int haptics_init_drive_config(struct haptics_chip *chip) { struct haptics_hw_config *config = &chip->config; int rc; u8 val; /* Config driver waveform shape and use 2's complement data format */ rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_DRV_WF_SEL_REG, DRV_WF_SEL_MASK | DRV_WF_FMT_BIT, config->drv_wf); if (rc < 0) return rc; /* Config brake mode and waveform shape */ val = FIELD_PREP(BRAKE_MODE_MASK, config->brake.mode); val |= FIELD_PREP(BRAKE_SINE_GAIN_MASK, config->brake.sine_gain); val |= FIELD_PREP(BRAKE_WF_SEL_MASK, config->brake.brake_wf); return haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_BRAKE_MODE_CFG_REG, BRAKE_MODE_MASK | BRAKE_SINE_GAIN_MASK | BRAKE_WF_SEL_MASK, val); } static int haptics_init_vmax_config(struct haptics_chip *chip) { int rc; u8 val; if (!is_haptics_external_powered(chip)) { rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_CLAMP_REG, &val, 1); if (rc < 0) return rc; chip->clamp_at_5v = val & CLAMP_5V_BIT; } chip->is_hv_haptics = true; chip->max_vmax_mv = MAX_VMAX_MV; if (chip->hw_type == HAP520_MV || chip->hw_type == HAP525_HV) { rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_HW_CONFIG_REG, &val, 1); if (rc < 0) return rc; chip->is_hv_haptics = val & HV_HAP_DRIVER_BIT; chip->max_vmax_mv = (chip->is_hv_haptics) ? MAX_HV_VMAX_MV : MAX_MV_VMAX_MV; } /* Set the initial clamped vmax value when hBoost is used by charger firmware */ chip->clamped_vmax_mv = MAX_HV_VMAX_MV; /* Config VMAX */ return haptics_set_vmax_mv(chip, chip->config.vmax_mv); } static int haptics_config_wa(struct haptics_chip *chip) { switch (chip->hw_type) { case HAP520: chip->wa_flags |= TOGGLE_CAL_RC_CLK | SW_CTRL_HBST | SLEEP_CLK_32K_SCALE | TOGGLE_EN_TO_FLUSH_FIFO | RECOVER_SWR_SLAVE; break; case HAP520_MV: chip->wa_flags |= SLEEP_CLK_32K_SCALE; if (!chip->cfg_rev1) chip->wa_flags |= TOGGLE_MODULE_EN; break; case HAP525_HV: if (chip->hbst_revision == HAP_BOOST_V0P1) chip->wa_flags |= SW_CTRL_HBST; break; default: dev_err(chip->dev, "HW type %d does not match\n", chip->hw_type); return -EINVAL; } return 0; } static int haptics_hw_init(struct haptics_chip *chip) { int rc; rc = haptics_config_wa(chip); if (rc < 0) return rc; rc = haptics_store_cl_brake_settings(chip); if (rc < 0) return rc; rc = haptics_init_vmax_config(chip); if (rc < 0) return rc; rc = haptics_init_drive_config(chip); if (rc < 0) return rc; rc = haptics_init_hpwr_config(chip); if (rc < 0) return rc; if (chip->config.is_erm) return 0; rc = haptics_init_lra_period_config(chip); if (rc < 0) return rc; rc = haptics_init_preload_pattern_effect(chip); if (rc < 0) return rc; return haptics_init_fifo_memory(chip); } static irqreturn_t fifo_empty_irq_handler(int irq, void *data) { struct haptics_chip *chip = data; struct fifo_cfg *fifo; struct fifo_play_status *status; u32 samples_left; u8 *samples, val; int rc, num; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE int16_t num_rt = 0, num_val = 0; int16_t pos = 0, retry = 3; u32 fill; #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_INT_RT_STS_REG, &val, 1); if (rc < 0) return IRQ_HANDLED; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE if (!(val & FIFO_EMPTY_BIT)) { haptics_get_fifo_fill_status(chip, &fill); if ((atomic_read(&chip->richtap_mode)) && (fill < 24)) schedule_work(&chip->richtap_erase_work); return IRQ_HANDLED; } #else if (!(val & FIFO_EMPTY_BIT)) return IRQ_HANDLED; #endif mutex_lock(&chip->play.lock); status = &chip->play.fifo_status; if (atomic_read(&status->written_done) == 1) { /* * Check the FIFO real time fill status before stopping * play to make sure that all FIFO samples can be played * successfully. If there are still samples left in FIFO * memory, defer the stop into erase() function. */ num = haptics_get_available_fifo_memory(chip); if (num != get_max_fifo_samples(chip)) { dev_info(chip->dev, "%d FIFO samples still in playing\n", get_max_fifo_samples(chip) - num); goto unlock; } #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE if (atomic_read(&chip->richtap_mode)) atomic_set(&chip->richtap_mode, false); #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE rc = haptics_stop_fifo_play(chip); if (rc < 0) goto unlock; dev_info(chip->dev, "FIFO playing is done\n"); } else { if (atomic_read(&status->cancelled) == 1) { dev_dbg(chip->dev, "FIFO programming got cancelled\n"); goto unlock; } #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE if (atomic_read(&chip->richtap_mode)) { num_rt = (int16_t)haptics_get_available_fifo_memory(chip); if (num_rt == get_max_fifo_samples(chip)) { dev_info(chip->dev, "aac richtap fifo stopped, wait next vibrator %d\n", num_rt); goto unlock; } if (num_rt < 0) { dev_err(chip->dev, "get fifo error, num_rt = %d\n", num_rt); schedule_work(&chip->richtap_erase_work); goto unlock; } num_rt -= (num_rt % HAP_PTN_FIFO_DIN_NUM); // qcom chip issue do { if (chip->current_buf->status == MMAP_BUF_DATA_VALID) { num_val = chip->current_buf->length - chip->pos; if (num_val < 0) { dev_err(chip->dev, "aac richtap length error, pos = %d, length = %d\n", chip->pos, chip->current_buf->length); schedule_work(&chip->richtap_erase_work); goto unlock; } if (num_rt >= num_val) { samples_left = (u32)num_val; memcpy(&chip->rtp_ptr[pos], &chip->current_buf->data[chip->pos], samples_left); pos += samples_left; num_rt -= samples_left; chip->current_buf->status = MMAP_BUF_DATA_INVALID; chip->current_buf->length = 0; chip->current_buf = chip->current_buf->kernel_next; chip->pos = 0; } else { memcpy(&chip->rtp_ptr[pos], &chip->current_buf->data[chip->pos], num_rt); chip->pos += num_rt; pos += num_rt; num_rt = 0; } } else if (chip->current_buf->status == MMAP_BUF_DATA_FINISHED) { break; } else { if (retry-- <= 0) { dev_err(chip->dev, "invalid data\n"); break; } else { usleep_range(1000, 1001); } } } while (num_rt > 0 && atomic_read(&chip->richtap_mode)); dev_info(chip->dev, "update fifo len %d\n", pos); if (pos != 0) { rc = haptics_update_fifo_samples(chip, chip->rtp_ptr, (u32)pos, true); if (rc < 0) { dev_err(chip->dev, "richtap Update FIFO fail, rc=%d\n", rc); schedule_work(&chip->richtap_erase_work); goto unlock; } } if (chip->current_buf->status != MMAP_BUF_DATA_VALID && chip->erase_working) { chip->erase_working = false; schedule_work(&chip->richtap_erase_work); dev_info(chip->dev, "richtap stream mode is done\n"); } goto unlock; } #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE if (!chip->play.effect) goto unlock; fifo = chip->play.effect->fifo; if (!fifo || !fifo->samples) { dev_err(chip->dev, "no FIFO samples available\n"); goto unlock; } samples_left = fifo->num_s - status->samples_written; num = haptics_get_available_fifo_memory(chip); if (num < 0) goto unlock; samples = fifo->samples + status->samples_written; /* * Always use 4-byte burst write in the middle of FIFO programming to * avoid HW padding zeros during 1-byte write which would cause the HW * stop driving for the unexpected padding zeros. */ if (num < samples_left) num = round_down(num, HAP_PTN_FIFO_DIN_NUM); else num = samples_left; rc = haptics_update_fifo_samples(chip, samples, num, true); if (rc < 0) { dev_err(chip->dev, "Update FIFO samples failed, rc=%d\n", rc); goto unlock; } status->samples_written += num; trace_qcom_haptics_fifo_prgm_status(fifo->num_s, status->samples_written, num); if (status->samples_written == fifo->num_s) { dev_dbg(chip->dev, "FIFO programming is done\n"); atomic_set(&chip->play.fifo_status.written_done, 1); haptics_set_fifo_empty_threshold(chip, 0); } } unlock: mutex_unlock(&chip->play.lock); return IRQ_HANDLED; } #ifdef CONFIG_DEBUG_FS static int vmax_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = effect->vmax_mv; return 0; } static int vmax_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; if (val > MAX_VMAX_MV) val = MAX_VMAX_MV; effect->vmax_mv = (u32) val; return 0; } DEFINE_DEBUGFS_ATTRIBUTE(vmax_debugfs_ops, vmax_dbgfs_read, vmax_dbgfs_write, "%llu\n"); static int auto_res_en_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = !effect->auto_res_disable; return 0; } static int auto_res_en_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; effect->auto_res_disable = !val; return 0; } DEFINE_DEBUGFS_ATTRIBUTE(auto_res_en_debugfs_ops, auto_res_en_dbgfs_read, auto_res_en_dbgfs_write, "%llu\n"); static ssize_t pattern_s_dbgfs_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; u32 pos = 0, size = CHAR_PER_PATTERN_S * SAMPLES_PER_PATTERN; char *str; int i = 0, rc; if (!effect->pattern) return 0; str = kzalloc(size, GFP_KERNEL); if (!str) return -ENOMEM; for (i = 0; i < SAMPLES_PER_PATTERN; i++) { pos += scnprintf(str + pos, size - pos, "0x%03x ", effect->pattern->samples[i].amplitude); pos += scnprintf(str + pos, size - pos, "%s(0x%02x) ", period_str[effect->pattern->samples[i].period], effect->pattern->samples[i].period); pos += scnprintf(str + pos, size - pos, "F_LRA_X2(%1d)\n", effect->pattern->samples[i].f_lra_x2); } rc = simple_read_from_buffer(buf, count, ppos, str, pos); kfree(str); return rc; } static ssize_t pattern_s_dbgfs_write(struct file *fp, const char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct pattern_s patterns[SAMPLES_PER_PATTERN] = {{0, 0, 0},}; char *str, *kbuf, *token; u32 val, tmp[3 * SAMPLES_PER_PATTERN] = {0}; int rc, i = 0, j = 0; if (count > CHAR_PER_PATTERN_S * SAMPLES_PER_PATTERN) return -EINVAL; kbuf = kzalloc(CHAR_PER_PATTERN_S * SAMPLES_PER_PATTERN + 1, GFP_KERNEL); if (!kbuf) return -ENOMEM; str = kbuf; rc = copy_from_user(str, buf, count); if (rc > 0) { rc = -EFAULT; goto exit; } str[count] = '\0'; *ppos += count; while ((token = strsep((char **)&str, " ")) != NULL) { rc = kstrtouint(token, 0, &val); if (rc < 0) { rc = -EINVAL; goto exit; } if (i >= ARRAY_SIZE(tmp)) { pr_err("too many patterns in input string\n"); rc = -EINVAL; goto exit; } tmp[i++] = val; } if (i % 3) pr_warn("Tuple should be having 3 elements, discarding tuple %d\n", i / 3); for (j = 0; j < i / 3; j++) { if (tmp[3 * j] > 0x1ff || tmp[3 * j + 1] > T_LRA_X_8 || tmp[3 * j + 2] > 1) { pr_err("allowed tuples: [amplitude(<= 0x1ff) period(<=6(T_LRA_X_8)) f_lra_x2(0,1)]\n"); rc = -EINVAL; goto exit; } patterns[j].amplitude = (u16)tmp[3 * j]; patterns[j].period = (enum s_period)tmp[3 * j + 1]; patterns[j].f_lra_x2 = !!tmp[3 * j + 2]; } memcpy(effect->pattern->samples, patterns, sizeof(effect->pattern->samples)); /* recalculate the play length */ effect->pattern->play_length_us = get_pattern_play_length_us(effect->pattern); if (effect->pattern->play_length_us == -EINVAL) { pr_err("get pattern play length failed\n"); rc = -EINVAL; goto exit; } rc = count; exit: kfree(kbuf); return rc; } static const struct file_operations pattern_s_dbgfs_ops = { .read = pattern_s_dbgfs_read, .write = pattern_s_dbgfs_write, .open = simple_open, }; static int pattern_play_rate_us_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = effect->pattern->play_rate_us; return 0; } static int pattern_play_rate_us_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; if (val > TLRA_MAX_US) val = TLRA_MAX_US; effect->pattern->play_rate_us = (u32)val; /* recalculate the play length */ effect->pattern->play_length_us = get_pattern_play_length_us(effect->pattern); if (effect->pattern->play_length_us == -EINVAL) { pr_err("get pattern play length failed\n"); return -EINVAL; } return 0; } DEFINE_DEBUGFS_ATTRIBUTE(pattern_play_rate_dbgfs_ops, pattern_play_rate_us_dbgfs_read, pattern_play_rate_us_dbgfs_write, "%llu\n"); static ssize_t fifo_s_dbgfs_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct fifo_cfg *fifo = effect->fifo; char *kbuf; int rc, i; u32 size, pos = 0; size = CHAR_PER_SAMPLE * fifo->num_s + 1; kbuf = kzalloc(size, GFP_KERNEL); if (!kbuf) return -ENOMEM; for (i = 0; i < fifo->num_s; i++) pos += scnprintf(kbuf + pos, size - pos, "%d ", (s8)fifo->samples[i]); pos += scnprintf(kbuf + pos, size - pos, "%s", "\n"); rc = simple_read_from_buffer(buf, count, ppos, kbuf, pos); kfree(kbuf); return rc; } static ssize_t fifo_s_dbgfs_write(struct file *fp, const char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct fifo_cfg *fifo = effect->fifo; char *str, *kbuf, *token; int rc, i = 0; int val; u8 *samples; kbuf = kzalloc(count + 1, GFP_KERNEL); if (!kbuf) return -ENOMEM; str = kbuf; rc = copy_from_user(str, buf, count); if (rc > 0) { rc = -EFAULT; goto exit; } str[count] = '\0'; *ppos += count; samples = kcalloc(fifo->num_s, sizeof(*samples), GFP_KERNEL); if (!samples) { rc = -ENOMEM; goto exit; } while ((token = strsep(&str, " ")) != NULL) { rc = kstrtoint(token, 0, &val); if (rc < 0) { rc = -EINVAL; goto exit2; } if (val > 0xff) val = 0xff; samples[i++] = (u8)val; /* only support fifo pattern no longer than before */ if (i >= fifo->num_s) break; } memcpy(fifo->samples, samples, fifo->num_s); fifo->play_length_us = get_fifo_play_length_us(fifo, effect->t_lra_us); if (fifo->play_length_us == -EINVAL) { pr_err("get fifo play length failed\n"); rc = -EINVAL; goto exit2; } rc = count; exit2: kfree(samples); exit: kfree(kbuf); return rc; } static const struct file_operations fifo_s_dbgfs_ops = { .read = fifo_s_dbgfs_read, .write = fifo_s_dbgfs_write, .owner = THIS_MODULE, .open = simple_open, }; static int fifo_period_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = effect->fifo->period_per_s; return 0; } static int fifo_period_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; struct fifo_cfg *fifo = effect->fifo; if (val > F_48KHZ) return -EINVAL; fifo->period_per_s = (enum s_period)val; fifo->play_length_us = get_fifo_play_length_us(fifo, effect->t_lra_us); if (fifo->play_length_us == -EINVAL) { pr_err("get fifo play length failed\n"); return -EINVAL; } return 0; } DEFINE_DEBUGFS_ATTRIBUTE(fifo_period_dbgfs_ops, fifo_period_dbgfs_read, fifo_period_dbgfs_write, "%llu\n"); static ssize_t brake_s_dbgfs_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct brake_cfg *brake = effect->brake; char *str; int rc, i; u32 size, pos = 0; size = CHAR_PER_SAMPLE * BRAKE_SAMPLE_COUNT + 1; str = kzalloc(size, GFP_KERNEL); if (!str) return -ENOMEM; for (i = 0; i < BRAKE_SAMPLE_COUNT; i++) pos += scnprintf(str + pos, size - pos, "0x%02x ", brake->samples[i]); pos += scnprintf(str + pos, size - pos, "%s", "\n"); rc = simple_read_from_buffer(buf, count, ppos, str, pos); kfree(str); return rc; } static ssize_t brake_s_dbgfs_write(struct file *fp, const char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct brake_cfg *brake = effect->brake; char *str, *kbuf, *token; int rc, i = 0; u32 val; u8 samples[BRAKE_SAMPLE_COUNT] = {0}; if (count > CHAR_PER_SAMPLE * BRAKE_SAMPLE_COUNT) return -EINVAL; kbuf = kzalloc(CHAR_PER_SAMPLE * BRAKE_SAMPLE_COUNT + 1, GFP_KERNEL); if (!kbuf) return -ENOMEM; str = kbuf; rc = copy_from_user(str, buf, count); if (rc > 0) { rc = -EFAULT; goto exit; } str[count] = '\0'; *ppos += count; while ((token = strsep((char **)&str, " ")) != NULL) { rc = kstrtouint(token, 0, &val); if (rc < 0) { rc = -EINVAL; goto exit; } if (val > 0xff) val = 0xff; samples[i++] = (u8)val; if (i >= BRAKE_SAMPLE_COUNT) break; } memcpy(brake->samples, samples, BRAKE_SAMPLE_COUNT); verify_brake_samples(brake); brake->play_length_us = get_brake_play_length_us(brake, effect->t_lra_us); rc = count; exit: kfree(kbuf); return rc; } static const struct file_operations brake_s_dbgfs_ops = { .read = brake_s_dbgfs_read, .write = brake_s_dbgfs_write, .open = simple_open, }; static ssize_t brake_mode_dbgfs_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct brake_cfg *brake = effect->brake; char str[CHAR_BRAKE_MODE] = {0}; u32 size; int rc; size = scnprintf(str, ARRAY_SIZE(str), "%s\n", brake_str[brake->mode]); rc = simple_read_from_buffer(buf, count, ppos, str, size); return rc; } static ssize_t brake_mode_dbgfs_write(struct file *fp, const char __user *buf, size_t count, loff_t *ppos) { struct haptics_effect *effect = fp->private_data; struct brake_cfg *brake = effect->brake; char *kbuf; int rc; kbuf = kzalloc(count + 1, GFP_KERNEL); if (!kbuf) return -ENOMEM; rc = copy_from_user(kbuf, buf, count); if (rc > 0) { rc = -EFAULT; goto exit; } kbuf[count] = '\0'; *ppos += count; rc = count; if (strcmp(kbuf, "open-loop") == 0) { brake->mode = OL_BRAKE; } else if (strcmp(kbuf, "close-loop") == 0) { brake->mode = CL_BRAKE; } else if (strcmp(kbuf, "predictive") == 0) { brake->mode = PREDICT_BRAKE; } else if (strcmp(kbuf, "auto") == 0) { brake->mode = AUTO_BRAKE; } else { pr_err("%s brake mode is not supported\n", kbuf); rc = -EINVAL; } exit: kfree(kbuf); return rc; } static const struct file_operations brake_mode_dbgfs_ops = { .read = brake_mode_dbgfs_read, .write = brake_mode_dbgfs_write, .open = simple_open, }; static int brake_en_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = !effect->brake->disabled; return 0; } static int brake_en_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; effect->brake->disabled = !val; return 0; } DEFINE_DEBUGFS_ATTRIBUTE(brake_en_dbgfs_ops, brake_en_dbgfs_read, brake_en_dbgfs_write, "%llu\n"); static int brake_sine_gain_dbgfs_read(void *data, u64 *val) { struct haptics_effect *effect = data; *val = effect->brake->sine_gain; return 0; } static int brake_sine_gain_dbgfs_write(void *data, u64 val) { struct haptics_effect *effect = data; if (val > BRAKE_SINE_GAIN_X8) return -EINVAL; effect->brake->sine_gain = val; return 0; } DEFINE_DEBUGFS_ATTRIBUTE(brake_sine_gain_dbgfs_ops, brake_sine_gain_dbgfs_read, brake_sine_gain_dbgfs_write, "%llu\n"); static int preload_effect_idx_dbgfs_read(void *data, u64 *val) { struct haptics_chip *chip = data; *val = chip->config.preload_effect; return 0; } static int preload_effect_idx_dbgfs_write(void *data, u64 val) { struct haptics_chip *chip = data; struct haptics_effect *new, *old; int rc, i; for (i = 0; i < chip->effects_count; i++) if (chip->effects[i].id == val) break; if (i == chip->effects_count) return -EINVAL; new = &chip->effects[i]; for (i = 0; i < chip->effects_count; i++) if (chip->effects[i].id == chip->config.preload_effect) break; old = &chip->effects[i]; chip->config.preload_effect = (u32)val; new->pattern->preload = true; new->src = PATTERN2; rc = haptics_set_pattern(chip, new->pattern, new->src); if (rc < 0) return rc; old->src = PATTERN1; old->pattern->preload = false; return 0; } DEFINE_DEBUGFS_ATTRIBUTE(preload_effect_idx_dbgfs_ops, preload_effect_idx_dbgfs_read, preload_effect_idx_dbgfs_write, "%llu\n"); static int haptics_add_effects_debugfs(struct haptics_effect *effect, struct dentry *dir) { struct dentry *file, *pattern_dir, *fifo_dir, *brake_dir; file = debugfs_create_file_unsafe("vmax_mv", 0644, dir, effect, &vmax_debugfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file_unsafe("lra_auto_res_en", 0644, dir, effect, &auto_res_en_debugfs_ops); if (IS_ERR(file)) return PTR_ERR(file); /* effect can have either pattern or FIFO */ if (effect->pattern) { pattern_dir = debugfs_create_dir("pattern", dir); if (IS_ERR(pattern_dir)) return PTR_ERR(pattern_dir); file = debugfs_create_file("samples", 0644, pattern_dir, effect, &pattern_s_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file_unsafe("play_rate_us", 0644, pattern_dir, effect, &pattern_play_rate_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); } else if (effect->fifo) { fifo_dir = debugfs_create_dir("fifo", dir); if (IS_ERR(fifo_dir)) return PTR_ERR(fifo_dir); file = debugfs_create_file("samples", 0644, fifo_dir, effect, &fifo_s_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file_unsafe("period", 0644, fifo_dir, effect, &fifo_period_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); } if (effect->brake) { brake_dir = debugfs_create_dir("brake", dir); if (IS_ERR(brake_dir)) return PTR_ERR(brake_dir); file = debugfs_create_file("samples", 0644, brake_dir, effect, &brake_s_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file("mode", 0644, brake_dir, effect, &brake_mode_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file_unsafe("enable", 0644, brake_dir, effect, &brake_en_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); file = debugfs_create_file_unsafe("sine_gain", 0644, brake_dir, effect, &brake_sine_gain_dbgfs_ops); if (IS_ERR(file)) return PTR_ERR(file); } return 0; } #define EFFECT_NAME_SIZE 15 static int haptics_add_debugfs(struct dentry *hap_dir, struct haptics_effect *effects, int count, char *effect_name) { struct dentry *effect_dir; char str[EFFECT_NAME_SIZE] = {0}; int rc = 0; int i = 0; for (; i < count; i++) { scnprintf(str, ARRAY_SIZE(str), "%s%d", effect_name, effects[i].id); effect_dir = debugfs_create_dir(str, hap_dir); if (IS_ERR(effect_dir)) { rc = PTR_ERR(effect_dir); pr_err("create %s debugfs directory failed, rc=%d\n", str, rc); return rc; } rc = haptics_add_effects_debugfs(&effects[i], effect_dir); if (rc < 0) { pr_err("create debugfs nodes for %s failed, rc=%d\n", str, rc); return rc; } } return rc; } static int haptics_create_debugfs(struct haptics_chip *chip) { struct dentry *hap_dir, *file; int rc = 0; hap_dir = debugfs_create_dir("haptics", NULL); if (IS_ERR(hap_dir)) { rc = PTR_ERR(hap_dir); dev_err(chip->dev, "create haptics debugfs directory failed, rc=%d\n", rc); return rc; } rc = haptics_add_debugfs(hap_dir, chip->effects, chip->effects_count, "effect"); if (rc < 0) goto exit; rc = haptics_add_debugfs(hap_dir, chip->primitives, chip->primitives_count, "primitive"); if (rc < 0) goto exit; file = debugfs_create_file_unsafe("preload_effect_idx", 0644, hap_dir, chip, &preload_effect_idx_dbgfs_ops); if (IS_ERR(file)) { rc = PTR_ERR(file); dev_err(chip->dev, "create preload_effect_idx debugfs failed, rc=%d\n", rc); goto exit; } debugfs_create_u32("fifo_empty_thresh", 0600, hap_dir, &chip->config.fifo_empty_thresh); chip->debugfs_dir = hap_dir; return 0; exit: debugfs_remove_recursive(hap_dir); return rc; } #endif static int haptics_parse_effect_pattern_data(struct haptics_chip *chip, struct device_node *node, struct haptics_effect *effect) { struct haptics_hw_config *config = &chip->config; u32 data[SAMPLES_PER_PATTERN * 3]; int rc, tmp, i; effect->t_lra_us = config->t_lra_us; tmp = of_property_count_elems_of_size(node, "qcom,wf-pattern-data", sizeof(u32)); if (tmp <= 0) { dev_dbg(chip->dev, "qcom,wf-pattern-data is not defined properly for effect %d\n", effect->id); return 0; } if (tmp > SAMPLES_PER_PATTERN * 3) { dev_err(chip->dev, "Pattern src can only play 8 samples at max\n"); return -EINVAL; } effect->pattern = devm_kzalloc(chip->dev, sizeof(*effect->pattern), GFP_KERNEL); if (!effect->pattern) return -ENOMEM; rc = of_property_read_u32_array(node, "qcom,wf-pattern-data", data, tmp); if (rc < 0) { dev_err(chip->dev, "Read wf-pattern-data failed, rc=%d\n", rc); return rc; } for (i = 0; i < tmp / 3; i++) { if (data[3 * i] > 0x1ff || data[3 * i + 1] > T_LRA_X_8 || data[3 * i + 2] > 1) { dev_err(chip->dev, "allowed tuples: [amplitude(<= 0x1ff) period(<=6(T_LRA_X_8)) f_lra_x2(0,1)]\n"); return -EINVAL; } effect->pattern->samples[i].amplitude = (u16)data[3 * i]; effect->pattern->samples[i].period = (enum s_period)data[3 * i + 1]; effect->pattern->samples[i].f_lra_x2 = (bool)data[3 * i + 2]; } effect->pattern->preload = of_property_read_bool(node, "qcom,wf-pattern-preload"); /* * Use PATTERN1 src by default, effect with preloaded * pattern will use PATTERN2 by default and only the * 1st preloaded pattern will be served. */ effect->src = PATTERN1; if (effect->pattern->preload) { if (config->preload_effect != -EINVAL) { dev_err(chip->dev, "effect %d has been defined as preloaded\n", config->preload_effect); effect->pattern->preload = false; } else { config->preload_effect = effect->id; effect->src = PATTERN2; } } if (config->is_erm) effect->pattern->play_rate_us = DEFAULT_ERM_PLAY_RATE_US; else effect->pattern->play_rate_us = config->t_lra_us; rc = of_property_read_u32(node, "qcom,wf-pattern-period-us", &tmp); if (rc < 0) dev_dbg(chip->dev, "Read qcom,wf-pattern-period-us failed, rc=%d\n", rc); else effect->pattern->play_rate_us = tmp; if (effect->pattern->play_rate_us > TLRA_MAX_US) { dev_err(chip->dev, "qcom,wf-pattern-period-us (%d) exceed the max value: %d\n", effect->pattern->play_rate_us, TLRA_MAX_US); return -EINVAL; } effect->pattern->play_length_us = get_pattern_play_length_us(effect->pattern); if (effect->pattern->play_length_us == -EINVAL) { dev_err(chip->dev, "get pattern play length failed\n"); return -EINVAL; } return 0; } static int haptics_parse_effect_fifo_data(struct haptics_chip *chip, struct device_node *node, struct haptics_effect *effect) { struct haptics_hw_config *config = &chip->config; int rc, tmp; if (effect->pattern) { dev_dbg(chip->dev, "ignore parsing FIFO effect when pattern effect is present\n"); return 0; } tmp = of_property_count_u8_elems(node, "qcom,wf-fifo-data"); if (tmp <= 0) { dev_dbg(chip->dev, "qcom,wf-fifo-data is not defined properly for effect %d\n", effect->id); return 0; } effect->fifo = devm_kzalloc(chip->dev, sizeof(*effect->fifo), GFP_KERNEL); if (!effect->fifo) return -ENOMEM; effect->fifo->samples = devm_kcalloc(chip->dev, tmp, sizeof(u8), GFP_KERNEL); if (!effect->fifo->samples) return -ENOMEM; rc = of_property_read_u8_array(node, "qcom,wf-fifo-data", effect->fifo->samples, tmp); if (rc < 0) { dev_err(chip->dev, "Read wf-fifo-data failed, rc=%d\n", rc); return rc; } effect->fifo->num_s = tmp; effect->fifo->period_per_s = T_LRA; rc = of_property_read_u32(node, "qcom,wf-fifo-period", &tmp); if (rc < 0) { dev_err(chip->dev, "Get qcom,wf-fifo-period failed, rc=%d\n", rc); return rc; } else if (tmp > F_48KHZ) { dev_err(chip->dev, "FIFO playing period %d is not supported\n", tmp); return -EINVAL; } effect->fifo->period_per_s = tmp; effect->fifo->play_length_us = get_fifo_play_length_us(effect->fifo, config->t_lra_us); if (effect->fifo->play_length_us == -EINVAL) { dev_err(chip->dev, "get fifo play length failed\n"); return -EINVAL; } effect->src = FIFO; effect->fifo->preload = of_property_read_bool(node, "qcom,wf-fifo-preload"); return 0; } static int haptics_parse_effect_brake_data(struct haptics_chip *chip, struct device_node *node, struct haptics_effect *effect) { struct haptics_hw_config *config = &chip->config; int rc, tmp; effect->brake = devm_kzalloc(chip->dev, sizeof(*effect->brake), GFP_KERNEL); if (!effect->brake) return -ENOMEM; memcpy(effect->brake, &config->brake, sizeof(*effect->brake)); of_property_read_u32(node, "qcom,wf-brake-mode", &effect->brake->mode); if (effect->brake->mode > AUTO_BRAKE) { dev_err(chip->dev, "can't support brake mode: %d\n", effect->brake->mode); return -EINVAL; } if (effect->brake->brake_wf == WF_SINE) { of_property_read_u32(node, "qcom,wf-brake-sine-gain", &effect->brake->sine_gain); if (effect->brake->sine_gain > BRAKE_SINE_GAIN_X8) { dev_err(chip->dev, "can't support brake sine gain: %d\n", effect->brake->sine_gain); return -EINVAL; } } effect->brake->disabled = of_property_read_bool(node, "qcom,wf-brake-disable"); tmp = of_property_count_u8_elems(node, "qcom,wf-brake-pattern"); if (tmp > BRAKE_SAMPLE_COUNT) { dev_err(chip->dev, "more than %d brake samples\n", BRAKE_SAMPLE_COUNT); return -EINVAL; } if (tmp > 0) { memset(effect->brake->samples, 0, sizeof(u8) * BRAKE_SAMPLE_COUNT); rc = of_property_read_u8_array(node, "qcom,wf-brake-pattern", effect->brake->samples, tmp); if (rc < 0) { dev_err(chip->dev, "Read wf-brake-pattern failed, rc=%d\n", rc); return rc; } verify_brake_samples(effect->brake); } else { if (effect->brake->mode == OL_BRAKE || effect->brake->mode == CL_BRAKE) effect->brake->disabled = true; } effect->brake->play_length_us = get_brake_play_length_us(effect->brake, config->t_lra_us); return 0; } static int haptics_parse_per_effect_dt(struct haptics_chip *chip, struct device_node *node, struct haptics_effect *effect) { struct haptics_hw_config *config = &chip->config; int rc, tmp; if (!effect) return -EINVAL; effect->vmax_mv = config->vmax_mv; rc = of_property_read_u32(node, "qcom,wf-vmax-mv", &tmp); if (rc < 0) dev_dbg(chip->dev, "read qcom,wf-vmax-mv failed, rc=%d\n", rc); else effect->vmax_mv = tmp; if (effect->vmax_mv > MAX_VMAX_MV) { dev_err(chip->dev, "qcom,wf-vmax-mv (%d) exceed the max value: %d\n", effect->vmax_mv, MAX_VMAX_MV); return -EINVAL; } rc = haptics_parse_effect_pattern_data(chip, node, effect); if (rc < 0) { dev_err(chip->dev, "parse effect PATTERN data failed, rc=%d\n", rc); return rc; } rc = haptics_parse_effect_fifo_data(chip, node, effect); if (rc < 0) { dev_err(chip->dev, "parse effect FIFO data failed, rc=%d\n", rc); return rc; } if (!effect->pattern && !effect->fifo) { dev_err(chip->dev, "no pattern specified for effect %d\n", effect->id); return -EINVAL; } rc = haptics_parse_effect_brake_data(chip, node, effect); if (rc < 0) { dev_err(chip->dev, "parse effect brake data failed, rc=%d\n", rc); return rc; } if (!config->is_erm) effect->auto_res_disable = of_property_read_bool(node, "qcom,wf-auto-res-disable"); return 0; } static int haptics_parse_primitives_dt(struct haptics_chip *chip) { struct device_node *node = chip->dev->of_node; struct device_node *child; int rc, i = 0, num = 0; for_each_available_child_of_node(node, child) { if (of_find_property(child, "qcom,primitive-id", NULL)) num++; } if (!num) return 0; chip->primitives = devm_kcalloc(chip->dev, num, sizeof(*chip->effects), GFP_KERNEL); if (!chip->primitives) return -ENOMEM; for_each_available_child_of_node(node, child) { if (!of_find_property(child, "qcom,primitive-id", NULL)) continue; rc = of_property_read_u32(child, "qcom,primitive-id", &(chip->primitives[i].id)); if (rc < 0) { dev_err(chip->dev, "Read qcom,primitive-id failed, rc=%d\n", rc); of_node_put(child); return rc; } rc = haptics_parse_per_effect_dt(chip, child, &chip->primitives[i]); if (rc < 0) { dev_err(chip->dev, "parse primitive %d failed, rc=%d\n", i, rc); of_node_put(child); return rc; } i++; } chip->primitives_count = i; dev_dbg(chip->dev, "Dump primitive effect settings as following\n"); __dump_effects(chip, chip->primitives, chip->primitives_count); return 0; } static int haptics_parse_effects_dt(struct haptics_chip *chip) { struct device_node *node = chip->dev->of_node; struct device_node *child; int rc, i = 0, num = 0; for_each_available_child_of_node(node, child) { if (of_find_property(child, "qcom,effect-id", NULL)) num++; } if (num == 0) return 0; chip->effects = devm_kcalloc(chip->dev, num, sizeof(*chip->effects), GFP_KERNEL); if (!chip->effects) return -ENOMEM; for_each_available_child_of_node(node, child) { if (!of_find_property(child, "qcom,effect-id", NULL)) continue; rc = of_property_read_u32(child, "qcom,effect-id", &(chip->effects[i].id)); if (rc < 0) { dev_err(chip->dev, "Read qcom,effect-id failed, rc=%d\n", rc); of_node_put(child); return rc; } rc = haptics_parse_per_effect_dt(chip, child, &chip->effects[i]); if (rc < 0) { dev_err(chip->dev, "parse effect %d failed, rc=%d\n", i, rc); of_node_put(child); return rc; } i++; } chip->effects_count = i; dev_dbg(chip->dev, "Dump predefined effect settings as following\n"); __dump_effects(chip, chip->effects, chip->effects_count); return 0; } static int haptics_parse_lra_dt(struct haptics_chip *chip) { struct haptics_hw_config *config = &chip->config; struct device_node *node = chip->dev->of_node; int rc; rc = of_property_read_u32(node, "qcom,lra-period-us", &config->t_lra_us); if (rc < 0) { dev_err(chip->dev, "Read T-LRA failed, rc=%d\n", rc); return rc; } if (config->t_lra_us > TLRA_MAX_US) { dev_err(chip->dev, "qcom,lra-period-us (%d) exceed the max value: %d\n", config->t_lra_us, TLRA_MAX_US); return -EINVAL; } config->drv_wf = WF_SINE; of_property_read_u32(node, "qcom,drv-sig-shape", &config->drv_wf); if (config->drv_wf >= WF_RESERVED) { dev_err(chip->dev, "Can't support drive shape: %d\n", config->drv_wf); return -EINVAL; } config->brake.brake_wf = WF_SINE; of_property_read_u32(node, "qcom,brake-sig-shape", &config->brake.brake_wf); if (config->brake.brake_wf >= WF_RESERVED) { dev_err(chip->dev, "Can't support brake shape: %d\n", config->brake.brake_wf); return -EINVAL; } if (config->brake.brake_wf == WF_SINE) { config->brake.sine_gain = BRAKE_SINE_GAIN_X1; of_property_read_u32(node, "qcom,brake-sine-gain", &config->brake.sine_gain); if (config->brake.sine_gain > BRAKE_SINE_GAIN_X8) { dev_err(chip->dev, "Can't support brake sine gain: %d\n", config->brake.sine_gain); return -EINVAL; } } if (chip->hw_type == HAP525_HV) config->measure_lra_impedance = of_property_read_bool(node, "qcom,rt-imp-detect"); config->sw_cmd_freq_det = of_property_read_bool(node, "qcom,sw-cmd-freq-detect"); return 0; } static int haptics_get_revision(struct haptics_chip *chip) { struct device_node *node = chip->dev->of_node; int rc; u8 val[2]; const __be32 *addr; rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_REVISION1_REG, val, 2); if (rc < 0) return rc; chip->cfg_rev1 = val[0]; chip->cfg_revision = val[1]; rc = haptics_read(chip, chip->ptn_addr_base, HAP_PTN_REVISION2_REG, val, 1); if (rc < 0) return rc; chip->ptn_revision = val[0]; if ((chip->cfg_revision == HAP_CFG_V2) && (chip->ptn_revision == HAP_PTN_V2)) { chip->hw_type = HAP520; } else if ((chip->cfg_revision == HAP_CFG_V3) && (chip->ptn_revision == HAP_PTN_V3)) { chip->hw_type = HAP520_MV; } else if ((chip->cfg_revision == HAP_CFG_V4) && (chip->ptn_revision == HAP_PTN_V4)) { chip->hw_type = HAP525_HV; } else { dev_err(chip->dev, "haptics revision is not supported\n"); return -EOPNOTSUPP; } if (is_haptics_external_powered(chip)) { dev_info(chip->dev, "haptics revision: HAP_CFG %#x, HAP_PTN %#x\n", chip->cfg_revision, chip->ptn_revision); } else { addr = of_get_address(node, 2, NULL, NULL); if (!addr) { dev_err(chip->dev, "Read HAPTICS_HBOOST address failed\n"); return -EINVAL; } chip->hbst_addr_base = be32_to_cpu(*addr); rc = haptics_read(chip, chip->hbst_addr_base, HAP_BOOST_REVISION1, val, 2); if (rc < 0) return rc; chip->hbst_revision = (val[1] << 8) | val[0]; dev_info(chip->dev, "haptics revision: HAP_CFG %#x, HAP_PTN %#x, HAP_HBST %#x\n", chip->cfg_revision, chip->ptn_revision, chip->hbst_revision); } return 0; } static int haptics_parse_hpwr_vreg_dt(struct haptics_chip *chip) { struct device_node *node = chip->dev->of_node; int rc; if (!of_find_property(node, "qcom,hpwr-supply", NULL)) return 0; chip->hpwr_vreg = devm_regulator_get(chip->dev, "qcom,hpwr"); if (IS_ERR(chip->hpwr_vreg)) { rc = PTR_ERR(chip->hpwr_vreg); if (rc != -EPROBE_DEFER) dev_err(chip->dev, "Failed to get qcom,hpwr-supply, rc=%d\n", rc); return rc; } rc = of_property_read_u32(node, "qcom,hpwr-voltage-mv", &chip->hpwr_voltage_mv); if (rc < 0) { dev_err(chip->dev, "Failed to read qcom,hpwr-voltage-mv, rc=%d\n", rc); return rc; } if (chip->hpwr_voltage_mv == 0 || chip->hpwr_voltage_mv > NON_HBOOST_MAX_VMAX_MV) return -EINVAL; return 0; } static int haptics_parse_dt(struct haptics_chip *chip) { struct haptics_hw_config *config = &chip->config; struct device_node *node = chip->dev->of_node; struct platform_device *pdev = to_platform_device(chip->dev); const __be32 *addr; int rc = 0, tmp; rc = haptics_parse_hpwr_vreg_dt(chip); if (rc < 0) return rc; if (of_find_property(node, "nvmem-cells", NULL)) { chip->cl_brake_nvmem = devm_nvmem_cell_get(chip->dev, "hap_cl_brake"); if (IS_ERR(chip->cl_brake_nvmem)) { rc = PTR_ERR(chip->cl_brake_nvmem); if (rc != -EPROBE_DEFER) dev_err(chip->dev, "Failed to get nvmem-cells, rc=%d\n", rc); return rc; } } if (of_find_property(node, "nvmem", NULL)) { chip->hap_cfg_nvmem = devm_nvmem_device_get(chip->dev, "hap_cfg_sdam"); if (IS_ERR(chip->hap_cfg_nvmem)) { rc = PTR_ERR(chip->hap_cfg_nvmem); if (rc != -EPROBE_DEFER) dev_err(chip->dev, "Failed to get hap_cfg nvmem device, rc=%d\n", rc); return rc; } } if (of_find_property(node, "qcom,pbs-client", NULL)) { chip->pbs_node = of_parse_phandle(node, "qcom,pbs-client", 0); if (!chip->pbs_node) { dev_err(chip->dev, "Failed to get PBS client\n"); return -ENODEV; } } addr = of_get_address(node, 0, NULL, NULL); if (!addr) { dev_err(chip->dev, "Read HAPTICS_CFG address failed\n"); rc = -EINVAL; goto free_pbs; } chip->cfg_addr_base = be32_to_cpu(*addr); addr = of_get_address(node, 1, NULL, NULL); if (!addr) { dev_err(chip->dev, "Read HAPTICS_PATTERN address failed\n"); rc = -EINVAL; goto free_pbs; } chip->ptn_addr_base = be32_to_cpu(*addr); rc = haptics_get_revision(chip); if (rc < 0) { dev_err(chip->dev, "Get revision failed, rc=%d\n", rc); goto free_pbs; } chip->fifo_empty_irq = platform_get_irq_byname(pdev, "fifo-empty"); if (!chip->fifo_empty_irq) { dev_err(chip->dev, "Get fifo-empty IRQ failed\n"); rc = -EINVAL; goto free_pbs; } config->vmax_mv = DEFAULT_VMAX_MV; of_property_read_u32(node, "qcom,vmax-mv", &config->vmax_mv); if (config->vmax_mv >= MAX_VMAX_MV) { dev_err(chip->dev, "qcom,vmax-mv (%d) exceed the max value: %d\n", config->vmax_mv, MAX_VMAX_MV); rc = -EINVAL; goto free_pbs; } config->vmax_mv_debug = 0; config->fifo_empty_thresh = get_fifo_empty_threshold(chip); of_property_read_u32(node, "qcom,fifo-empty-threshold", &config->fifo_empty_thresh); if (config->fifo_empty_thresh >= get_max_fifo_samples(chip)) { dev_err(chip->dev, "FIFO empty threshold (%d) should be less than %d\n", config->fifo_empty_thresh, get_max_fifo_samples(chip)); rc = -EINVAL; goto free_pbs; } config->brake.mode = AUTO_BRAKE; of_property_read_u32(node, "qcom,brake-mode", &config->brake.mode); if (config->brake.mode > AUTO_BRAKE) { dev_err(chip->dev, "Can't support brake mode: %d\n", config->brake.mode); rc = -EINVAL; goto free_pbs; } config->brake.disabled = of_property_read_bool(node, "qcom,brake-disable"); tmp = of_property_count_u8_elems(node, "qcom,brake-pattern"); if (tmp > BRAKE_SAMPLE_COUNT) { dev_err(chip->dev, "more than %d brake samples\n", BRAKE_SAMPLE_COUNT); rc = -EINVAL; goto free_pbs; } if (tmp > 0) { rc = of_property_read_u8_array(node, "qcom,brake-pattern", config->brake.samples, tmp); if (rc < 0) { dev_err(chip->dev, "Read brake-pattern failed, rc=%d\n", rc); goto free_pbs; } verify_brake_samples(&config->brake); } else { if (config->brake.mode == OL_BRAKE || config->brake.mode == CL_BRAKE) config->brake.disabled = true; } config->is_erm = of_property_read_bool(node, "qcom,use-erm"); if (config->is_erm) { config->drv_wf = WF_NO_MODULATION; config->brake.brake_wf = WF_NO_MODULATION; } else { rc = haptics_parse_lra_dt(chip); if (rc < 0) { dev_err(chip->dev, "Parse device-tree for LRA failed, rc=%d\n", rc); goto free_pbs; } } config->preload_effect = -EINVAL; rc = haptics_parse_effects_dt(chip); if (rc < 0) { dev_err(chip->dev, "Parse device-tree for effects failed, rc=%d\n", rc); goto free_pbs; } rc = haptics_parse_primitives_dt(chip); if (rc < 0) { dev_err(chip->dev, "Parse device-tree for primitives failed, rc=%d\n", rc); goto free_pbs; } return 0; free_pbs: if (chip->pbs_node) { of_node_put(chip->pbs_node); chip->pbs_node = NULL; } return rc; } static int swr_slave_reg_enable(struct regulator_dev *rdev) { struct haptics_chip *chip = rdev_get_drvdata(rdev); int rc; u8 mask = SWR_PAT_INPUT_EN_BIT | SWR_PAT_RES_N_BIT | SWR_PAT_CFG_EN_BIT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_SWR_ACCESS_REG, mask, mask); if (rc < 0) { dev_err(chip->dev, "Failed to enable SWR_PAT, rc=%d\n", rc); return rc; } if (!(chip->wa_flags & RECOVER_SWR_SLAVE)) goto done; /* * If haptics has already been in SWR mode when enabling the SWR * slave, it means that the haptics module was stuck in prevous * SWR play. Then toggle HAPTICS_EN to reset haptics module and * ignore SWR mode until next SWR slave enable request is coming. */ if (is_swr_play_enabled(chip)) { rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_TRIG_PRIORITY_REG, SWR_IGNORE_BIT, SWR_IGNORE_BIT); if (rc < 0) { dev_err(chip->dev, "Failed to enable SWR_IGNORE, rc=%d\n", rc); return rc; } rc = haptics_toggle_module_enable(chip); if (rc < 0) return rc; } else { rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_TRIG_PRIORITY_REG, SWR_IGNORE_BIT, 0); if (rc < 0) { dev_err(chip->dev, "Failed to disable SWR_IGNORE, rc=%d\n", rc); return rc; } } done: chip->swr_slave_enabled = true; return 0; } static int swr_slave_reg_disable(struct regulator_dev *rdev) { struct haptics_chip *chip = rdev_get_drvdata(rdev); int rc; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_SWR_ACCESS_REG, SWR_PAT_INPUT_EN_BIT | SWR_PAT_RES_N_BIT | SWR_PAT_CFG_EN_BIT, 0); if (rc < 0) { dev_err(chip->dev, "Failed to disable SWR_PAT, rc=%d\n", rc); return rc; } chip->swr_slave_enabled = false; return 0; } static int swr_slave_reg_is_enabled(struct regulator_dev *rdev) { struct haptics_chip *chip = rdev_get_drvdata(rdev); return chip->swr_slave_enabled; } static const struct regulator_ops swr_slave_reg_ops = { .enable = swr_slave_reg_enable, .disable = swr_slave_reg_disable, .is_enabled = swr_slave_reg_is_enabled, }; static struct regulator_desc swr_slave_reg_rdesc = { .owner = THIS_MODULE, .of_match = "qcom,hap-swr-slave-reg", .name = "hap-swr-slave-reg", .type = REGULATOR_VOLTAGE, .ops = &swr_slave_reg_ops, }; static int haptics_init_swr_slave_regulator(struct haptics_chip *chip) { struct regulator_config cfg = {}; u8 val, mask; int rc = 0; rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_SWR_ACCESS_REG, &val, 1); if (rc < 0) { dev_err(chip->dev, "Failed to read SWR_ACCESS, rc=%d\n", rc); return rc; } mask = SWR_PAT_INPUT_EN_BIT | SWR_PAT_RES_N_BIT | SWR_PAT_CFG_EN_BIT; val &= mask; chip->swr_slave_enabled = ((val == mask) ? true : false); cfg.dev = chip->dev; cfg.driver_data = chip; chip->swr_slave_rdev = devm_regulator_register(chip->dev, &swr_slave_reg_rdesc, &cfg); if (IS_ERR(chip->swr_slave_rdev)) { rc = PTR_ERR(chip->swr_slave_rdev); chip->swr_slave_rdev = NULL; if (rc != -EPROBE_DEFER) dev_err(chip->dev, "register swr-slave-reg regulator failed, rc=%d\n", rc); } return rc; } static int haptics_pbs_trigger_isc_config(struct haptics_chip *chip) { int rc; if (chip->pbs_node == NULL) { dev_err(chip->dev, "PBS device is not defined\n"); return -ENODEV; } rc = qpnp_pbs_trigger_single_event(chip->pbs_node); if (rc < 0) dev_err(chip->dev, "Trigger PBS to config ISC failed, rc=%d\n", rc); return rc; } #define MAX_SWEEP_STEPS 5 #define MIN_DUTY_MILLI_PCT 0 #define MAX_DUTY_MILLI_PCT 100000 #define LRA_CONFIG_REGS 3 static u32 get_lra_impedance_capable_max(struct haptics_chip *chip) { u32 mohms; u32 max_vmax_mv, min_isc_ma; switch (chip->hw_type) { case HAP520: min_isc_ma = 250; if (chip->clamp_at_5v) max_vmax_mv = 5000; else max_vmax_mv = 10000; break; case HAP520_MV: max_vmax_mv = 5000; min_isc_ma = 140; break; case HAP525_HV: if (chip->clamp_at_5v) { max_vmax_mv = 5000; min_isc_ma = 125; } else { max_vmax_mv = 10000; min_isc_ma = 250; } break; default: return 0; } mohms = (max_vmax_mv * 1000) / min_isc_ma; if (is_haptics_external_powered(chip)) mohms = (chip->hpwr_voltage_mv * 1000) / min_isc_ma; dev_dbg(chip->dev, "LRA impedance capable max: %u mohms\n", mohms); return mohms; } #define RT_IMPD_DET_VMAX_DEFAULT_MV 4500 static int haptics_measure_realtime_lra_impedance(struct haptics_chip *chip) { int rc; u8 val, current_sel; u32 vmax_mv, nominal_ohm, current_ma, vmax_margin_mv; struct pattern_cfg pattern = { .samples = { {0xff, T_LRA, false}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, }, .play_rate_us = chip->config.t_lra_us + 2000, /* drive off resonance of the LRA */ .play_length_us = chip->config.t_lra_us + 2000, /* drive it at least 1 cycle */ .preload = false, }; /* calculate Vmax according to nominal resistance */ vmax_mv = RT_IMPD_DET_VMAX_DEFAULT_MV; current_sel = chip->clamp_at_5v ? CURRENT_SEL_VAL_125MA : CURRENT_SEL_VAL_250MA; if (chip->hap_cfg_nvmem != NULL) { rc = nvmem_device_read(chip->hap_cfg_nvmem, HAP_LRA_NOMINAL_OHM_SDAM_OFFSET, 1, &val); if (rc > 0 && val) { nominal_ohm = val * LRA_IMPEDANCE_MOHMS_LSB / 1000; /* * use 250mA current_sel when nominal impedance is lower than 15 Ohms * and use 125mA detection when nominal impedance is higher than 40 Ohms */ if (nominal_ohm < 15) current_sel = CURRENT_SEL_VAL_250MA; else if (nominal_ohm > 40) current_sel = CURRENT_SEL_VAL_125MA; /* * give 8 Ohms margin (1000mV / 125mA, or 2000mV / 250mA) for wider * detectability */ if (current_sel == CURRENT_SEL_VAL_125MA) { current_ma = 125; vmax_margin_mv = 1000; } else { current_ma = 250; vmax_margin_mv = 2000; } vmax_mv = max(vmax_mv, nominal_ohm * current_ma + vmax_margin_mv); } } dev_dbg(chip->dev, "Set %u mV Vmax for impedance detection\n", vmax_mv); rc = haptics_set_vmax_mv(chip, vmax_mv); if (rc < 0) return rc; /* set current for imp_det comparator and enable it */ val = LRA_IMPEDANCE_MEAS_EN_BIT | current_sel; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_RT_LRA_IMPD_MEAS_CFG_REG, LRA_IMPEDANCE_MEAS_EN_BIT | LRA_IMPEDANCE_MEAS_CURRENT_SEL_BIT, val); if (rc < 0) return rc; /* disconnect imp_det comparator to avoid it impact SC behavior */ rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_ISC_CFG_REG, EN_IMP_DET_HAP525_HV_BIT, 0); if (rc < 0) goto restore; /* play 1 drive cycle using PATTERN1 source */ rc = haptics_set_pattern(chip, &pattern, PATTERN1); if (rc < 0) goto restore; chip->play.pattern_src = PATTERN1; rc = haptics_enable_play(chip, true); if (rc < 0) goto restore; usleep_range(pattern.play_length_us, pattern.play_length_us + 1); rc = haptics_enable_play(chip, false); if (rc < 0) goto restore; /* read the measured LRA impedance */ rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_REAL_TIME_LRA_IMPEDANCE_REG, &val, 1); if (rc < 0) goto restore; chip->config.lra_measured_mohms = val * LRA_IMPEDANCE_MOHMS_LSB; dev_dbg(chip->dev, "measured LRA impedance: %u mohm", chip->config.lra_measured_mohms); /* store the detected LRA impedance into SDAM for future usage */ if (chip->hap_cfg_nvmem != NULL) { rc = nvmem_device_write(chip->hap_cfg_nvmem, HAP_LRA_DETECTED_OHM_SDAM_OFFSET, 1, &val); if (rc < 0) dev_err(chip->dev, "write measured impedance value into SDAM failed, rc=%d\n", rc); } restore: if (rc < 0) dev_err(chip->dev, "measure LRA impedance failed, rc=%d\n", rc); return haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_RT_LRA_IMPD_MEAS_CFG_REG, LRA_IMPEDANCE_MEAS_EN_BIT, 0); } static int haptics_detect_lra_impedance(struct haptics_chip *chip) { int rc, i; struct haptics_reg_info lra_config[LRA_CONFIG_REGS] = { { HAP_CFG_DRV_WF_SEL_REG, 0x10 }, { HAP_CFG_VMAX_REG, 0xC8 }, { HAP_CFG_VMAX_HDRM_REG, 0x00 }, }; struct haptics_reg_info backup[LRA_CONFIG_REGS]; u8 val, cfg1, cfg2, reg1, reg2, mask1, mask2, val1, val2; u32 duty_milli_pct, low_milli_pct, high_milli_pct; u32 amplitude, lra_min_mohms, lra_max_mohms, capability_mohms; /* Backup default register values */ memcpy(backup, lra_config, sizeof(backup)); for (i = 0; i < LRA_CONFIG_REGS; i++) { rc = haptics_read(chip, chip->cfg_addr_base, backup[i].addr, &backup[i].val, 1); if (rc < 0) return rc; } if (chip->hw_type == HAP520) { /* Trigger PBS to config 250mA ISC setting */ rc = haptics_pbs_trigger_isc_config(chip); if (rc < 0) return rc; } else { /* Config ISC_CFG settings for LRA impedance_detection */ switch (chip->hw_type) { case HAP520_MV: reg1 = HAP_CFG_ISC_CFG_REG; mask1 = ILIM_CC_EN_BIT; val1 = !ILIM_CC_EN_BIT_VAL; reg2 = HAP_CFG_ISC_CFG2_REG; mask2 = EN_SC_DET_P_HAP520_MV_BIT | EN_SC_DET_N_HAP520_MV_BIT | ISC_THRESH_HAP520_MV_MASK; val2 = EN_SC_DET_P_HAP520_MV_BIT| EN_SC_DET_N_HAP520_MV_BIT| ISC_THRESH_HAP520_MV_140MA; break; case HAP525_HV: reg1 = HAP_CFG_ISC_CFG_REG; mask1 = EN_SC_DET_P_HAP525_HV_BIT | EN_SC_DET_N_HAP525_HV_BIT | EN_IMP_DET_HAP525_HV_BIT | ILIM_PULSE_DENSITY_MASK; val1 = EN_IMP_DET_HAP525_HV_BIT | FIELD_PREP(ILIM_PULSE_DENSITY_MASK, ILIM_DENSITY_8_OVER_64_CYCLES); reg2 = HAP_CFG_RT_LRA_IMPD_MEAS_CFG_REG; mask2 = LRA_IMPEDANCE_MEAS_EN_BIT | LRA_IMPEDANCE_MEAS_CURRENT_SEL_BIT; val2 = chip->clamp_at_5v ? CURRENT_SEL_VAL_125MA : CURRENT_SEL_VAL_250MA; val2 |= LRA_IMPEDANCE_MEAS_EN_BIT; break; default: dev_err(chip->dev, "unsupported HW type: %d\n", chip->hw_type); return -EOPNOTSUPP; } /* save ISC_CFG default settings */ rc = haptics_read(chip, chip->cfg_addr_base, reg1, &cfg1, 1); if (rc < 0) return rc; rc = haptics_read(chip, chip->cfg_addr_base, reg2, &cfg2, 1); if (rc < 0) return rc; /* update ISC_CFG settings for the detection */ rc = haptics_masked_write(chip, chip->cfg_addr_base, reg1, mask1, val1); if (rc < 0) return rc; rc = haptics_masked_write(chip, chip->cfg_addr_base, reg2, mask2, val2); if (rc < 0) goto restore; } /* Set square drive waveform, 10V Vmax, no HDRM */ for (i = 0; i < LRA_CONFIG_REGS; i++) { /* PM5100 has 6V Vmax so update the setting for it */ if (chip->hw_type == HAP520_MV && lra_config[i].addr == HAP_CFG_VMAX_REG) lra_config[i].val = 0x78; rc = haptics_write(chip, chip->cfg_addr_base, lra_config[i].addr, &lra_config[i].val, 1); if (rc < 0) goto restore; } rc = haptics_enable_hpwr_vreg(chip, true); if (rc < 0) goto restore; low_milli_pct = MIN_DUTY_MILLI_PCT; high_milli_pct = MAX_DUTY_MILLI_PCT; /* Sweep duty cycle using binary approach */ for (i = 0; i < MAX_SWEEP_STEPS; i++) { /* Set direct play amplitude */ duty_milli_pct = (low_milli_pct + high_milli_pct) / 2; amplitude = (duty_milli_pct * DIRECT_PLAY_MAX_AMPLITUDE) / 100000; rc = haptics_set_direct_play(chip, (u8)amplitude); if (rc < 0) goto restore; dev_dbg(chip->dev, "sweeping milli_pct %u, amplitude %#x\n", duty_milli_pct, amplitude); /* Enable play */ chip->play.pattern_src = DIRECT_PLAY; rc = haptics_enable_play(chip, true); if (rc < 0) goto restore; /* Play a cycle then read SC fault status */ usleep_range(chip->config.t_lra_us, chip->config.t_lra_us + 1000); rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_FAULT_STATUS_REG, &val, 1); if (rc < 0) goto restore; if (val & SC_FLAG_BIT) high_milli_pct = duty_milli_pct; else low_milli_pct = duty_milli_pct; /* Disable play */ rc = haptics_enable_play(chip, false); if (rc < 0) goto restore; /* Sleep 4ms */ usleep_range(4000, 5000); } capability_mohms = get_lra_impedance_capable_max(chip); lra_min_mohms = low_milli_pct * capability_mohms / 100000; lra_max_mohms = high_milli_pct * capability_mohms / 100000; if (lra_min_mohms == 0) dev_warn(chip->dev, "Short circuit detected!\n"); else if (lra_max_mohms >= capability_mohms) dev_warn(chip->dev, "Open circuit detected!\n"); else dev_dbg(chip->dev, "LRA impedance is between %u - %u mohms\n", lra_min_mohms, lra_max_mohms); chip->config.lra_min_mohms = lra_min_mohms; chip->config.lra_max_mohms = lra_max_mohms; chip->config.lra_open_mohms = capability_mohms; restore: /* Disable play in case it's not been disabled */ haptics_enable_play(chip, false); rc = haptics_enable_hpwr_vreg(chip, false); if (rc < 0) return rc; if (chip->hw_type == HAP520) { /* Trigger PBS to restore 1500mA ISC setting */ rc = haptics_pbs_trigger_isc_config(chip); if (rc < 0) return rc; } else { /* restore ISC_CFG settings to default */ rc = haptics_write(chip, chip->cfg_addr_base, reg1, &cfg1, 1); if (rc < 0) return rc; rc = haptics_write(chip, chip->cfg_addr_base, reg2, &cfg2, 1); if (rc < 0) return rc; } /* Restore driver waveform, Vmax, HDRM settings */ for (i = 0; i < LRA_CONFIG_REGS; i++) { rc = haptics_write(chip, chip->cfg_addr_base, backup[i].addr, &backup[i].val, 1); if (rc < 0) break; } return rc; } static int haptics_enable_autores_cal(struct haptics_chip *chip, bool enable) { u8 val = 0; int rc; if (enable) val = AUTORES_CAL_TRIG_BIT | AUTORES_CAL_TIMER_6_HALF_CYCLES; else val = AUTORES_CAL_TIMER_4_HALF_CYCLES; rc = haptics_write(chip, chip->ptn_addr_base, HAP_PTN_AUTORES_CAL_CFG_REG, &val, 1); return rc; } #define LRA_CALIBRATION_VMAX_HDRM_MV 500 static int haptics_detect_lra_frequency(struct haptics_chip *chip) { int rc; u8 autores_cfg, drv_duty_cfg, amplitude, mask, val = 0; u32 vmax_mv = chip->config.vmax_mv; rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_AUTORES_CFG_REG, &autores_cfg, 1); if (rc < 0) { dev_err(chip->dev, "Read AUTORES_CFG failed, rc=%d\n", rc); return rc; } rc = haptics_read(chip, chip->cfg_addr_base, HAP_CFG_DRV_DUTY_CFG_REG, &drv_duty_cfg, 1); if (rc < 0) { dev_err(chip->dev, "Read DRV_DUTY_CFG failed, rc=%d\n", rc); return rc; } if (!chip->config.sw_cmd_freq_det) val = AUTORES_EN_BIT; if (chip->hw_type >= HAP525_HV) val |= AUTORES_EN_DLY_7_CYCLES << AUTORES_EN_DLY_SHIFT | AUTORES_ERR_WINDOW_25_PERCENT; else val |= AUTORES_EN_DLY_6_CYCLES << AUTORES_EN_DLY_SHIFT | AUTORES_ERR_WINDOW_50_PERCENT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_AUTORES_CFG_REG, AUTORES_EN_BIT | AUTORES_EN_DLY_MASK | AUTORES_ERR_WINDOW_MASK, val); if (rc < 0) return rc; if (chip->hw_type == HAP525_HV) { mask = ADT_DRV_DUTY_EN_BIT | ADT_BRK_DUTY_EN_BIT | DRV_DUTY_MASK | BRK_DUTY_MASK; val = DRV_DUTY_62P5_PCT << DRV_DUTY_SHIFT | BRK_DUTY_75_PCT; } else { mask = ADT_DRV_DUTY_EN_BIT; val = 0; } rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_DRV_DUTY_CFG_REG, mask, val); if (rc < 0) goto restore; rc = haptics_config_openloop_lra_period(chip, chip->config.t_lra_us); if (rc < 0) goto restore; rc = haptics_set_vmax_headroom_mv(chip, LRA_CALIBRATION_VMAX_HDRM_MV); if (rc < 0) goto restore; /* Fix Vmax to (hpwr_vreg_mv - hdrm_mv) in non-HBOOST regulator case */ if (is_haptics_external_powered(chip)) vmax_mv = chip->hpwr_voltage_mv - LRA_CALIBRATION_VMAX_HDRM_MV; rc = haptics_set_vmax_mv(chip, vmax_mv); if (rc < 0) goto restore; amplitude = get_direct_play_max_amplitude(chip); rc = haptics_set_direct_play(chip, amplitude); if (rc < 0) goto restore; rc = haptics_enable_hpwr_vreg(chip, true); if (rc < 0) goto restore; chip->play.pattern_src = DIRECT_PLAY; rc = haptics_enable_play(chip, true); if (rc < 0) goto restore; if (chip->config.sw_cmd_freq_det) { msleep(60); /* Enable SW based auto resonance */ rc = haptics_enable_autores_cal(chip, true); if (rc < 0) goto restore; msleep(20); /* Get the 1st detected frequency */ rc = haptics_get_closeloop_lra_period(chip, false); if (rc < 0) goto restore; msleep(50); /* Reset SW based auto resonance */ rc = haptics_enable_autores_cal(chip, false); if (rc < 0) goto restore; rc = haptics_enable_autores_cal(chip, true); if (rc < 0) goto restore; msleep(20); /* Get the 2nd detected frequency */ rc = haptics_get_closeloop_lra_period(chip, false); if (rc < 0) goto restore; usleep_range(4000, 4001); } else { /* Wait for ~150ms to get the LRA calibration result */ msleep(150); rc = haptics_get_closeloop_lra_period(chip, false); if (rc < 0) goto restore; } rc = haptics_enable_play(chip, false); if (rc < 0) goto restore; if (chip->config.sw_cmd_freq_det) haptics_enable_autores_cal(chip, false); haptics_config_openloop_lra_period(chip, chip->config.cl_t_lra_us); restore: /* Disable play in case it's not been disabled */ haptics_enable_play(chip, false); rc = haptics_enable_hpwr_vreg(chip, false); if (rc < 0) return rc; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_AUTORES_CFG_REG, &autores_cfg, 1); if (rc < 0) return rc; rc = haptics_write(chip, chip->cfg_addr_base, HAP_CFG_DRV_DUTY_CFG_REG, &drv_duty_cfg, 1); return rc; } static int haptics_start_play(struct haptics_chip *chip, bool enable) { int rc; u8 amplitude; u32 vmax_mv = (chip->config.vmax_mv_debug == 0 ? chip->config.vmax_mv : chip->config.vmax_mv_debug); mutex_lock(&chip->play.lock); if (enable) { /* Stop other mode playing if there is any */ rc = haptics_enable_play(chip, false); if (rc < 0) { dev_err(chip->dev, "Stop playing failed, rc=%d\n", rc); goto unlock; } rc = haptics_set_vmax_mv(chip, vmax_mv); if (rc < 0) goto unlock; amplitude = get_direct_play_max_amplitude(chip); rc = haptics_set_direct_play(chip, amplitude); if (rc < 0) goto unlock; rc = haptics_enable_hpwr_vreg(chip, true); if (rc < 0) goto unlock; rc = haptics_wait_hboost_ready(chip); if (rc < 0) goto unlock; chip->play.pattern_src = DIRECT_PLAY; rc = haptics_enable_play(chip, true); if (rc < 0) goto unlock; mutex_unlock(&chip->play.lock); return rc; } unlock: /* Disable play in case it's not been disabled */ haptics_enable_play(chip, false); rc = haptics_enable_hpwr_vreg(chip, false); mutex_unlock(&chip->play.lock); return rc; } static int haptics_start_lra_calibrate(struct haptics_chip *chip) { int rc; mutex_lock(&chip->play.lock); /* * Ignore calibration if it's in FIFO playing to avoid * messing up the FIFO playing status */ if ((chip->play.pattern_src == FIFO) && atomic_read(&chip->play.fifo_status.is_busy)) { dev_err(chip->dev, "In FIFO playing, ignore calibration\n"); rc = -EBUSY; goto unlock; } /* Stop other mode playing if there is any */ rc = haptics_enable_play(chip, false); if (rc < 0) { dev_err(chip->dev, "Stop playing failed, rc=%d\n", rc); goto unlock; } chip->play.in_calibration = true; rc = haptics_detect_lra_frequency(chip); if (rc < 0) { dev_err(chip->dev, "Detect LRA frequency failed, rc=%d\n", rc); goto unlock; } /* Sleep at least 4ms to stabilize the LRA from frequency detection */ usleep_range(4000, 5000); if (chip->config.measure_lra_impedance) rc = haptics_measure_realtime_lra_impedance(chip); else rc = haptics_detect_lra_impedance(chip); if (rc < 0) { dev_err(chip->dev, "Detect LRA impedance failed, rc=%d\n", rc); goto unlock; } unlock: haptics_clear_fault(chip); chip->play.in_calibration = false; mutex_unlock(&chip->play.lock); return rc; } static ssize_t lra_calibration_store(struct class *c, struct class_attribute *attr, const char *buf, size_t count) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); bool val; int rc; if (kstrtobool(buf, &val)) return -EINVAL; if (val) { rc = haptics_start_lra_calibrate(chip); if (rc < 0) return rc; } return count; } static CLASS_ATTR_WO(lra_calibration); static ssize_t lra_frequency_hz_show(struct class *c, struct class_attribute *attr, char *buf) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); u32 cl_f_lra; if (chip->config.cl_t_lra_us == 0) return -EINVAL; cl_f_lra = USEC_PER_SEC / chip->config.cl_t_lra_us; return scnprintf(buf, PAGE_SIZE, "%d Hz\n", cl_f_lra); } static CLASS_ATTR_RO(lra_frequency_hz); static ssize_t lra_impedance_show(struct class *c, struct class_attribute *attr, char *buf) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); if (chip->config.measure_lra_impedance) return scnprintf(buf, PAGE_SIZE, "measured %u mohms\n", chip->config.lra_measured_mohms); if (chip->config.lra_min_mohms == 0 && chip->config.lra_max_mohms == 0) return -EINVAL; else if (chip->config.lra_min_mohms == 0) return scnprintf(buf, PAGE_SIZE, "%s\n", "Short circuit"); else if (chip->config.lra_max_mohms >= chip->config.lra_open_mohms) return scnprintf(buf, PAGE_SIZE, "%s\n", "Open circuit"); else return scnprintf(buf, PAGE_SIZE, "%u ~ %u mohms\n", chip->config.lra_min_mohms, chip->config.lra_max_mohms); } static CLASS_ATTR_RO(lra_impedance); static ssize_t enable_play_store(struct class *c, struct class_attribute *attr, const char *buf, size_t count) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); int val; int rc; if (kstrtoint(buf, 0, &val)) return -EINVAL; if (val) { rc = haptics_start_play(chip, true); if (rc < 0) return rc; } else { rc = haptics_start_play(chip, false); if (rc < 0) return rc; } return count; } static CLASS_ATTR_WO(enable_play); #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE static void richtap_clean_buf(struct haptics_chip *chip, int status) { struct mmap_buf_format *opbuf = chip->start_buf; int i; for (i = 0; i < RICHTAP_MMAP_BUF_SUM; i++) { opbuf->status = status; opbuf->length = 0; opbuf = opbuf->kernel_next; } } static int richtap_get_lra_frequency_hz(struct haptics_chip *chip, u32 *val) { if (chip->config.cl_t_lra_us == 0) return -EINVAL; *val = USEC_PER_SEC / chip->config.cl_t_lra_us; #ifdef raac_FEATURE_CHG_BASIC if (chip->cal_data_restore) { if (chip->cal_data.cl_t_lra_us != 0) *val = USEC_PER_SEC / chip->cal_data.cl_t_lra_us; else *val = 0; dev_err(chip->dev, "lra_frequency_hz read : %d\n", *val); } #endif return 0; } static int richtap_rc_clk_disable(struct haptics_chip *chip) { int rc; u8 val; /* * All other playing modes would use AUTO mode RC * calibration except FIFO streaming mode, so restore * back to AUTO RC calibration after FIFO playing. */ val = CAL_RC_CLK_DISABLED_VAL << CAL_RC_CLK_SHIFT; rc = haptics_masked_write(chip, chip->cfg_addr_base, HAP_CFG_CAL_EN_REG, CAL_RC_CLK_MASK, val); if (rc < 0) return rc; return 0; } static int richtap_set_fifo(struct haptics_chip *chip, struct fifo_cfg *fifo) { struct fifo_play_status *status = &chip->play.fifo_status; u32 num, fifo_thresh; int rc, available; if (atomic_read(&status->is_busy) == 1) { dev_err(chip->dev, "FIFO is busy\n"); return -EBUSY; } if (chip->ptn_revision == HAP_PTN_V1 && fifo->period_per_s > F_8KHZ && fifo->num_s > get_max_fifo_samples(chip)) { dev_err(chip->dev, "PM8350B v1 not play long pattern higher than 8 KHz play rate\n"); return -EINVAL; } /* Configure FIFO play rate */ rc = haptics_set_fifo_playrate(chip, fifo->period_per_s); if (rc < 0) return rc; if (fifo->period_per_s >= F_8KHZ) { /* Set manual RC CLK CAL when playing FIFO */ rc = haptics_set_manual_rc_clk_cal(chip); if (rc < 0) return rc; } atomic_set(&status->written_done, 0); atomic_set(&status->cancelled, 0); status->samples_written = 0; /* * Write the 1st set of the data into FIFO if there are * more than MAX_FIFO_SAMPLES samples, the rest will be * written if any FIFO memory is available after playing. */ num = min_t(u32, fifo->num_s, get_max_fifo_samples(chip)); available = haptics_get_available_fifo_memory(chip); if (available < 0) return available; num = min_t(u32, available, num); rc = haptics_update_fifo_samples(chip, fifo->samples, num, false); if (rc < 0) { dev_err(chip->dev, "write FIFO samples failed, rc=%d\n", rc); return rc; } dev_info(chip->dev, "aac Richtap set busy to 1\n"); atomic_set(&status->is_busy, 1); status->samples_written = num; fifo_thresh = 480; //480 * 40us /* * Set FIFO empty threshold here. FIFO empty IRQ will * be enabled after playing FIFO samples so that more * FIFO samples can be written (if available) when * FIFO empty IRQ is triggered. */ return haptics_set_fifo_empty_threshold(chip, fifo_thresh); } static void richtap_erase_work_proc(struct work_struct *work) { struct haptics_chip *chip = container_of(work, struct haptics_chip, richtap_erase_work); int rc; u8 count = 5; u32 fill; while (count--) { rc = haptics_get_fifo_fill_status(chip, &fill); if ((rc < 0) || (atomic_read(&chip->play.fifo_status.is_busy) == 0)) return; if (fill < 24) break; fill /= 24; //24k play_rate_hz fill *= 1000; usleep_range((fill + 25), (fill + 30)); dev_info(chip->dev, "aac fill time %d\n", fill); } mutex_lock(&chip->play.lock); richtap_clean_buf(chip, MMAP_BUF_DATA_FINISHED); atomic_set(&chip->play.fifo_status.written_done, 1); haptics_set_fifo_empty_threshold(chip, 0); haptics_stop_fifo_play(chip); atomic_set(&chip->richtap_mode, false); mutex_unlock(&chip->play.lock); } static int richtap_playback(struct haptics_chip *chip, bool on) { struct haptics_play_info *play = &chip->play; int rc; if (on) { rc = haptics_enable_play(chip, true); if (rc < 0) return rc; if (play->pattern_src == FIFO) haptics_fifo_empty_irq_config(chip, true); } else { if (play->pattern_src == FIFO && atomic_read(&play->fifo_status.is_busy)) { dev_dbg(chip->dev, "FIFO playing is not done yet, defer stopping in erase\n"); return 0; } rc = haptics_enable_play(chip, false); } return rc; } static int richtap_load_prebake(struct haptics_chip *chip, u8 *data, u32 length) { struct haptics_play_info *play = &chip->play; struct custom_fifo_data custom_data = {}; struct fifo_cfg *fifo; int rc; if (!chip->custom_effect || !chip->custom_effect->fifo) return -ENOMEM; fifo = chip->custom_effect->fifo; custom_data.length = length; custom_data.play_rate_hz = 24000; //24000; custom_data.data = data; dev_dbg(chip->dev, "aac RichTap data %d length\n", length); rc = haptics_convert_sample_period(chip, custom_data.play_rate_hz); if (rc < 0) { dev_err(chip->dev, "aac RichTap Can't support play rate: %d Hz\n", custom_data.play_rate_hz); return rc; } mutex_lock(&chip->play.lock); fifo->period_per_s = rc; fifo->num_s = length; /* * Before allocating samples buffer, free the old sample * buffer first if it's not been freed. */ kfree(fifo->samples); fifo->samples = kcalloc(custom_data.length, sizeof(u8), GFP_KERNEL); if (!fifo->samples) { rc = -ENOMEM; goto unlock; } memcpy(fifo->samples, custom_data.data, custom_data.length); play->effect = chip->custom_effect; play->brake = NULL; rc = haptics_set_vmax_mv(chip, play->vmax_mv); if (rc < 0) goto cleanup; /* Toggle HAPTICS_EN for a clear start point of FIFO playing */ if (chip->wa_flags & TOGGLE_EN_TO_FLUSH_FIFO) { rc = haptics_toggle_module_enable(chip); if (rc < 0) goto cleanup; } rc = haptics_enable_autores(chip, false); if (rc < 0) goto cleanup; play->pattern_src = FIFO; rc = richtap_set_fifo(chip, play->effect->fifo); if (rc < 0) goto cleanup; dev_info(chip->dev, "aac RichTap haptics_set_fifo success\n"); mutex_unlock(&chip->play.lock); return 0; cleanup: kfree(fifo->samples); fifo->samples = NULL; unlock: mutex_unlock(&chip->play.lock); return rc; } static void richtap_work_proc(struct work_struct *work) { struct haptics_chip *chip = container_of(work, struct haptics_chip, richtap_stream_work); uint32_t count = 100, tmp_len = 0, retry_count = 30; int ret; cancel_work_sync(&chip->richtap_erase_work); richtap_rc_clk_disable(chip); atomic_set(&chip->richtap_mode, true); chip->erase_working = true; while ((count--) && (chip->start_buf->status != MMAP_BUF_DATA_VALID)) usleep_range(1000, 1001); if ((chip->start_buf->length <= 0) || (chip->start_buf->status != MMAP_BUF_DATA_VALID)) { dev_err(chip->dev, "aac richtap first length invalid %d %d ", chip->start_buf->status, chip->start_buf->length); mutex_lock(&chip->play.lock); richtap_clean_buf(chip, MMAP_BUF_DATA_FINISHED); atomic_set(&chip->play.fifo_status.written_done, 1); haptics_set_fifo_empty_threshold(chip, 0); haptics_stop_fifo_play(chip); atomic_set(&chip->richtap_mode, false); mutex_unlock(&chip->play.lock); return; } chip->pos = 0; count = 0; chip->current_buf = chip->start_buf; do { if (chip->current_buf->status == MMAP_BUF_DATA_VALID) { if ((tmp_len + chip->current_buf->length) > get_max_fifo_samples(chip)) { memcpy(&chip->rtp_ptr[tmp_len], chip->current_buf->data, (get_max_fifo_samples(chip) - tmp_len)); chip->pos = get_max_fifo_samples(chip) - tmp_len; tmp_len = get_max_fifo_samples(chip); dev_err(chip->dev, "first full\n"); } else { memcpy(&chip->rtp_ptr[tmp_len], chip->current_buf->data, chip->current_buf->length); tmp_len += chip->current_buf->length; chip->current_buf->status = MMAP_BUF_DATA_INVALID; chip->current_buf->length = 0; chip->pos = 0; chip->current_buf = chip->current_buf->kernel_next; } } else if (chip->current_buf->status == MMAP_BUF_DATA_FINISHED) { break; } else { usleep_range(1000, 1001); dev_err(chip->dev, "wait for data\n"); } } while (tmp_len < get_max_fifo_samples(chip) && count++ < retry_count); dev_info(chip->dev, "tmp_len %d, retry %d, max_fifo %d\n", tmp_len, count, get_max_fifo_samples(chip)); ret = richtap_load_prebake(chip, chip->rtp_ptr, tmp_len); if (ret < 0) { dev_err(chip->dev, "aac RichTap Upload FIFO data fail\n", ret); return; } ret = haptics_enable_hpwr_vreg(chip, true); if (ret < 0) { dev_err(chip->dev, "aac RichTap enable hpwr_vreg fail, rc=%d\n", ret); return; } ret = haptics_wait_hboost_ready(chip); if (ret < 0) { schedule_work(&chip->richtap_erase_work); return; } ret = richtap_playback(chip, true); if (ret < 0) dev_err(chip->dev, "aac RichTap richtap_playback fail, rc=%d\n", ret); } /***************************************************** * * haptic fops * *****************************************************/ static int richtap_file_open(struct inode *inode, struct file *file) { if (!try_module_get(THIS_MODULE)) return -ENODEV; file->private_data = (void *)g_richtap_ptr; return 0; } static int richtap_file_release(struct inode *inode, struct file *file) { file->private_data = (void *)NULL; module_put(THIS_MODULE); return 0; } static long richtap_file_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct haptics_chip *chip = (struct haptics_chip *)file->private_data; uint32_t tmp; int ret = 0; dev_info(chip->dev, "%s: cmd=0x%x, arg=0x%lx\n", __func__, cmd, arg); switch (cmd) { case RICHTAP_GET_HWINFO: tmp = RICHTAP_AW_8697; if (copy_to_user((void __user *)arg, &tmp, sizeof(uint32_t))) return -EFAULT; break; case RICHTAP_RTP_MODE: if (copy_from_user(chip->rtp_ptr, (void __user *)arg, RICHTAP_MMAP_BUF_SIZE * RICHTAP_MMAP_BUF_SUM)) { ret = -EFAULT; break; } tmp = *((uint32_t *)chip->rtp_ptr); if (tmp > (RICHTAP_MMAP_BUF_SIZE * RICHTAP_MMAP_BUF_SUM - 4)) { dev_err(chip->dev, "aac RichTap rtp mode date len error %d\n", tmp); ret = -EINVAL; break; } mutex_lock(&chip->play.lock); haptics_stop_fifo_play(chip); atomic_set(&chip->play.fifo_status.written_done, 1); atomic_set(&chip->richtap_mode, false); mutex_unlock(&chip->play.lock); richtap_rc_clk_disable(chip); ret = richtap_load_prebake(chip, &chip->rtp_ptr[4], tmp); if (ret < 0) { dev_err(chip->dev, "aac RichTap Upload FIFO data fail\n", ret); break; } ret = haptics_enable_hpwr_vreg(chip, true); if (ret < 0) { dev_err(chip->dev, "aac RichTap en hpwr_vreg fail, rc=%d\n", ret); break; } ret = haptics_wait_hboost_ready(chip); if (ret < 0) { schedule_work(&chip->richtap_erase_work); break; } ret = richtap_playback(chip, true); if (ret < 0) dev_err(chip->dev, "aac RichTap en hpwr_vreg fail, rc=%d\n", ret); schedule_work(&chip->richtap_erase_work); break; case RICHTAP_OFF_MODE: break; case RICHTAP_GET_F0: ret = richtap_get_lra_frequency_hz(chip, &tmp); dev_info(chip->dev, "aac RichTap get f0 =%d\n", tmp); if (ret < 0) { dev_err(chip->dev, "aac RichTap get f0 error, ret=%d\n", ret); break; } if (copy_to_user((void __user *)arg, &tmp, sizeof(uint32_t))) ret = -EFAULT; break; case RICHTAP_SETTING_GAIN: if (arg > 0x80) arg = 0x80; tmp = chip->lower_mv; chip->play.vmax_mv = ((u32)(arg * tmp)) / 128; haptics_set_vmax_mv(chip, chip->play.vmax_mv); break; case RICHTAP_STREAM_MODE: cancel_work_sync(&chip->richtap_stream_work); mutex_lock(&chip->play.lock); haptics_stop_fifo_play(chip); mutex_unlock(&chip->play.lock); schedule_work(&chip->richtap_stream_work); richtap_clean_buf(chip, MMAP_BUF_DATA_INVALID); break; case RICHTAP_STOP_MODE: cancel_work_sync(&chip->richtap_stream_work); mutex_lock(&chip->play.lock); richtap_clean_buf(chip, MMAP_BUF_DATA_FINISHED); atomic_set(&chip->play.fifo_status.written_done, 1); haptics_set_fifo_empty_threshold(chip, 0); haptics_stop_fifo_play(chip); atomic_set(&chip->richtap_mode, false); mutex_unlock(&chip->play.lock); break; case RICHTAP_F0_UPDATE: break; default: dev_err(chip->dev, "%s, unknown cmd\n", __func__); break; } return ret; } static ssize_t richtap_file_read(struct file *filp, char *buff, size_t len, loff_t *offset) { return len; } static ssize_t richtap_file_write(struct file *filp, const char *buff, size_t len, loff_t *off) { return len; } static int richtap_file_mmap(struct file *filp, struct vm_area_struct *vma) { struct haptics_chip *chip = (struct haptics_chip *)filp->private_data; unsigned long phys; int ret = 0; //only accept PROT_READ, PROT_WRITE and MAP_SHARED from the API of mmap vm_flags_t vm_flags = calc_vm_prot_bits(PROT_READ|PROT_WRITE, 0) | calc_vm_flag_bits(filp, MAP_SHARED); vm_flags |= current->mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC | VM_SHARED | VM_MAYSHARE; if (vma && (pgprot_val(vma->vm_page_prot) != pgprot_val(vm_get_page_prot(vm_flags)))) return -EPERM; if (vma && ((vma->vm_end - vma->vm_start) != (PAGE_SIZE << RICHTAP_MMAP_PAGE_ORDER))) return -ENOMEM; phys = virt_to_phys(chip->start_buf); ret = remap_pfn_range(vma, vma->vm_start, (phys >> PAGE_SHIFT), (vma->vm_end - vma->vm_start), vma->vm_page_prot); if (ret) { dev_err(chip->dev, "Error mmap failed\n"); return ret; } return ret; } static const struct file_operations fops = { .owner = THIS_MODULE, .read = richtap_file_read, .write = richtap_file_write, .mmap = richtap_file_mmap, .unlocked_ioctl = richtap_file_unlocked_ioctl, .open = richtap_file_open, .release = richtap_file_release, }; static struct miscdevice richtap_misc = { .minor = MISC_DYNAMIC_MINOR, .name = RICHTAP_NAME, .fops = &fops, }; #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE static ssize_t primitive_duration_show(struct class *c, struct class_attribute *attr, char *buf) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); return scnprintf(buf, PAGE_SIZE, "%d\n", chip->primitive_duration); } static ssize_t primitive_duration_store(struct class *c, struct class_attribute *attr, const char *buf, size_t count) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); u16 primitive_id = 0; int i = 0; if (kstrtou16(buf, 0, &primitive_id)) return -EINVAL; for (i = 0; i < chip->primitives_count; i++) { if (chip->primitives[i].id == primitive_id) break; } if (i == chip->primitives_count) { pr_err("Primitive id specified is incorrect\n"); return -EINVAL; } chip->primitive_duration = get_play_length_effect_us(&chip->primitives[i]); return count; } static CLASS_ATTR_RW(primitive_duration); static ssize_t vmax_mv_debug_store(struct class *c, struct class_attribute *attr, const char *buf, size_t count) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); int val; if (kstrtoint(buf, 0, &val)) return -EINVAL; if (val >= 0) { dev_err(chip->dev, "change vmax_mv %d -> %d\n", chip->config.vmax_mv, val); chip->config.vmax_mv_debug = val; } else { chip->config.vmax_mv_debug = 0; } return count; } static ssize_t vmax_mv_debug_show(struct class *c, struct class_attribute *attr, char *buf) { struct haptics_chip *chip = container_of(c, struct haptics_chip, hap_class); return scnprintf(buf, PAGE_SIZE, "%d mv\n", chip->config.vmax_mv_debug); } static CLASS_ATTR_RW(vmax_mv_debug); static struct attribute *hap_class_attrs[] = { &class_attr_lra_calibration.attr, &class_attr_lra_frequency_hz.attr, &class_attr_lra_impedance.attr, &class_attr_primitive_duration.attr, &class_attr_enable_play.attr, &class_attr_vmax_mv_debug.attr, NULL, }; ATTRIBUTE_GROUPS(hap_class); static bool is_swr_supported(struct haptics_chip *chip) { /* HAP520_MV does not support soundwire */ if (chip->hw_type == HAP520_MV) return false; return true; } static enum hrtimer_restart haptics_disable_hbst_timer(struct hrtimer *timer) { struct haptics_chip *chip = container_of(timer, struct haptics_chip, hbst_off_timer); int rc; rc = haptics_boost_vreg_enable(chip, false); if (rc < 0) dev_err(chip->dev, "disable boost vreg failed, rc=%d\n", rc); else dev_dbg(chip->dev, "boost vreg is disabled\n"); return HRTIMER_NORESTART; } static int haptics_boost_notifier(struct notifier_block *nb, unsigned long event, void *val) { struct haptics_chip *chip = container_of(nb, struct haptics_chip, hboost_nb); u32 vmax_mv; int rc; switch (event) { case VMAX_CLAMP: vmax_mv = *(u32 *)val; if (vmax_mv > MAX_HV_VMAX_MV) { dev_err(chip->dev, "voted Vmax (%u mV) is higher than maximum (%u mV)\n", vmax_mv, MAX_HV_VMAX_MV); return -EINVAL; } chip->clamped_vmax_mv = vmax_mv; dev_dbg(chip->dev, "Vmax is clamped at %u mV to support hBoost concurrency\n", vmax_mv); rc = haptics_force_vreg_ready(chip, vmax_mv == MAX_HV_VMAX_MV ? false : true); if (rc < 0) return rc; break; default: break; } return 0; } static int haptics_probe(struct platform_device *pdev) { struct haptics_chip *chip; struct input_dev *input_dev; struct ff_device *ff_dev; int rc, count; u32 t_lra_us_min, t_lra_us_max, f0_cal_count; chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; input_dev = devm_input_allocate_device(&pdev->dev); if (!input_dev) return -ENOMEM; chip->dev = &pdev->dev; chip->regmap = dev_get_regmap(chip->dev->parent, NULL); if (!chip->regmap) { dev_err(chip->dev, "Get regmap failed\n"); return -ENXIO; } rc = haptics_parse_dt(chip); if (rc < 0) { dev_err(chip->dev, "Parse device-tree failed, rc = %d\n", rc); return rc; } rc = haptics_init_custom_effect(chip); if (rc < 0) { dev_err(chip->dev, "Init custom effect failed, rc=%d\n", rc); return rc; } mutex_init(&chip->vmax_lock); rc = haptics_hw_init(chip); if (rc < 0) { dev_err(chip->dev, "Initialize HW failed, rc = %d\n", rc); return rc; } if (is_swr_supported(chip)) { rc = haptics_init_swr_slave_regulator(chip); if (rc < 0) { dev_err(chip->dev, "Initialize swr slave regulator failed, rc = %d\n", rc); return rc; } } rc = devm_request_threaded_irq(chip->dev, chip->fifo_empty_irq, NULL, fifo_empty_irq_handler, IRQF_ONESHOT, "fifo-empty", chip); if (rc < 0) { dev_err(chip->dev, "request fifo-empty IRQ failed, rc=%d\n", rc); return rc; } mutex_init(&chip->play.lock); disable_irq_nosync(chip->fifo_empty_irq); chip->fifo_empty_irq_en = false; hrtimer_init(&chip->hbst_off_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); chip->hbst_off_timer.function = haptics_disable_hbst_timer; INIT_DELAYED_WORK(&chip->stop_work, haptics_stop_constant_effect_play); INIT_WORK(&chip->set_gain_work, haptics_set_gain_work); atomic_set(&chip->play.fifo_status.is_busy, 0); atomic_set(&chip->play.fifo_status.written_done, 0); atomic_set(&chip->play.fifo_status.cancelled, 0); input_dev->name = "qcom-hv-haptics"; input_set_drvdata(input_dev, chip); chip->input_dev = input_dev; input_set_capability(input_dev, EV_FF, FF_CONSTANT); input_set_capability(input_dev, EV_FF, FF_GAIN); if ((chip->effects_count != 0) || (chip->primitives_count != 0)) { input_set_capability(input_dev, EV_FF, FF_PERIODIC); input_set_capability(input_dev, EV_FF, FF_CUSTOM); } if (chip->effects_count + chip->primitives_count > MAX_EFFECT_COUNT) dev_err(chip->dev, "Effects count cannot be more than %d\n", MAX_EFFECT_COUNT); count = min_t(u32, chip->effects_count + chip->primitives_count + 1, MAX_EFFECT_COUNT); rc = input_ff_create(input_dev, count); if (rc < 0) { dev_err(chip->dev, "create input FF device failed, rc=%d\n", rc); return rc; } ff_dev = input_dev->ff; ff_dev->upload = haptics_upload_effect; ff_dev->playback = haptics_playback; ff_dev->erase = haptics_erase; ff_dev->set_gain = haptics_set_gain; rc = input_register_device(input_dev); if (rc < 0) { dev_err(chip->dev, "register input device failed, rc=%d\n", rc); goto destroy_ff; } dev_set_drvdata(chip->dev, chip); chip->hap_class.name = "qcom-haptics"; chip->hap_class.class_groups = hap_class_groups; rc = class_register(&chip->hap_class); if (rc < 0) { dev_err(chip->dev, "register hap_class failed, rc=%d\n", rc); goto destroy_ff; } chip->hboost_nb.notifier_call = haptics_boost_notifier; register_hboost_event_notifier(&chip->hboost_nb); #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE rc = of_property_read_u32(chip->dev->of_node, "moto,wf-vmax-mv", &chip->lower_mv); if (rc < 0) { dev_info(chip->dev, "No voltage config,use default value:9000mV\n"); chip->lower_mv = 9000; } chip->rtp_ptr = kmalloc(RICHTAP_MMAP_BUF_SIZE * RICHTAP_MMAP_BUF_SUM, GFP_KERNEL); if (chip->rtp_ptr == NULL) goto destroy_ff; chip->start_buf = (struct mmap_buf_format *)__get_free_pages(GFP_KERNEL, RICHTAP_MMAP_PAGE_ORDER); if (chip->start_buf == NULL) { dev_err(chip->dev, "Error __get_free_pages failed\n"); goto destroy_richtap; } SetPageReserved(virt_to_page(chip->start_buf)); { struct mmap_buf_format *temp; uint32_t i = 0; temp = chip->start_buf; for (i = 1; i < RICHTAP_MMAP_BUF_SUM; i++) { temp->kernel_next = (chip->start_buf + i); temp = temp->kernel_next; } temp->kernel_next = chip->start_buf; } INIT_WORK(&chip->richtap_stream_work, richtap_work_proc); INIT_WORK(&chip->richtap_erase_work, richtap_erase_work_proc); misc_register(&richtap_misc); atomic_set(&chip->richtap_mode, false); g_richtap_ptr = chip; #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE #ifdef CONFIG_DEBUG_FS rc = haptics_create_debugfs(chip); if (rc < 0) dev_err(chip->dev, "Creating debugfs failed, rc=%d\n", rc); #endif if (of_property_read_bool(chip->dev->of_node, "moto,cal_again")) { dev_err(chip->dev, "In XBL cal F0 is %d Hz\n", (USEC_PER_SEC / chip->config.cl_t_lra_us)); rc = of_property_read_u32(chip->dev->of_node, "moto,lra-period-us-min", &t_lra_us_min); if (rc < 0) { dev_err(chip->dev, "Read T-LRA-min failed, rc=%d\n", rc); goto continue_on; } rc = of_property_read_u32(chip->dev->of_node, "moto,lra-period-us-max", &t_lra_us_max); if (rc < 0) { dev_err(chip->dev, "Read T-LRA-max failed, rc=%d\n", rc); goto continue_on; } /* If calibration failed in XBL,will be calibrate again */ if (chip->config.cl_t_lra_us < t_lra_us_min || chip->config.cl_t_lra_us > t_lra_us_max) { dev_err(chip->dev, "The start up cal fail, cal again in kernel\n"); rc = haptics_start_lra_calibrate(chip); if (rc < 0) { dev_err(chip->dev, "Cal again failed in kernel\n"); goto continue_on; } dev_err(chip->dev, "Latest cal F0 is %d Hz\n", (USEC_PER_SEC / chip->config.cl_t_lra_us)); /* If cal failed in kernel, force set manual freq */ if (chip->config.cl_t_lra_us < t_lra_us_min || chip->config.cl_t_lra_us > t_lra_us_max) { rc = of_property_read_u32(chip->dev->of_node, "moto,lra-period-cal-count", &f0_cal_count); if (rc < 0) { dev_err(chip->dev, "Read cal-count failed, rc=%d\n", rc); f0_cal_count = LRA_F0_CAL_COUNT; } dev_err(chip->dev, "Failure of all cal, set manual freq to %dHz, f0_count to %d\n", USEC_PER_SEC / chip->config.t_lra_us, f0_cal_count); chip->config.cl_t_lra_us = chip->config.t_lra_us; chip->config.rc_clk_cal_count = f0_cal_count; rc = haptics_config_openloop_lra_period(chip, chip->config.cl_t_lra_us); if (rc < 0) dev_err(chip->dev, "Config manual freq failed, rc=%d\n", rc); rc = haptics_set_manual_rc_clk_cal(chip); if (rc < 0) dev_err(chip->dev, "Config manual cal count failed, rc=%d\n", rc); } } } continue_on: return 0; #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE destroy_richtap: kfree(chip->rtp_ptr); #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE destroy_ff: input_ff_destroy(chip->input_dev); return rc; } static int haptics_remove(struct platform_device *pdev) { struct haptics_chip *chip = dev_get_drvdata(&pdev->dev); if (chip->pbs_node) of_node_put(chip->pbs_node); unregister_hboost_event_notifier(&chip->hboost_nb); class_unregister(&chip->hap_class); #ifdef CONFIG_DEBUG_FS debugfs_remove_recursive(chip->debugfs_dir); #endif #ifdef CONFIG_RICHTAP_FOR_PMIC_ENABLE kfree(chip->rtp_ptr); free_pages((unsigned long)chip->start_buf, RICHTAP_MMAP_PAGE_ORDER); #endif //CONFIG_RICHTAP_FOR_PMIC_ENABLE input_unregister_device(chip->input_dev); dev_set_drvdata(chip->dev, NULL); return 0; } static void haptics_ds_suspend_config(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); if (chip->fifo_empty_irq > 0) devm_free_irq(dev, chip->fifo_empty_irq, chip); } static int haptics_ds_resume_config(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); int rc = 0; rc = haptics_hw_init(chip); if (rc < 0) { dev_err(chip->dev, "Initialize HW failed, rc = %d\n", rc); return rc; } if (chip->fifo_empty_irq > 0) { rc = devm_request_threaded_irq(chip->dev, chip->fifo_empty_irq, NULL, fifo_empty_irq_handler, IRQF_ONESHOT, "fifo-empty", chip); if (rc < 0) { dev_err(chip->dev, "request fifo-empty IRQ failed, rc=%d\n", rc); return rc; } disable_irq_nosync(chip->fifo_empty_irq); chip->fifo_empty_irq_en = false; } return rc; } #ifdef CONFIG_PM_SLEEP static int haptics_suspend_config(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); struct haptics_play_info *play = &chip->play; int rc; mutex_lock(&play->lock); if ((play->pattern_src == FIFO) && atomic_read(&play->fifo_status.is_busy)) { if (atomic_read(&play->fifo_status.written_done) == 0) { dev_dbg(chip->dev, "cancelling FIFO playing\n"); atomic_set(&play->fifo_status.cancelled, 1); } rc = haptics_stop_fifo_play(chip); if (rc < 0) { dev_err(chip->dev, "stop FIFO playing failed, rc=%d\n", rc); mutex_unlock(&play->lock); return rc; } } else { rc = haptics_enable_play(chip, false); if (rc < 0) { mutex_unlock(&play->lock); return rc; } } mutex_unlock(&play->lock); /* * Cancel the hBoost turning off timer and disable * hBoost if it's still enabled */ if (chip->wa_flags & SW_CTRL_HBST) { hrtimer_cancel(&chip->hbst_off_timer); haptics_boost_vreg_enable(chip, false); } rc = haptics_enable_hpwr_vreg(chip, false); if (rc < 0) return rc; return haptics_module_enable(chip, false); } static int haptics_suspend(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); int rc = 0; if (chip->cfg_revision == HAP_CFG_V1) return 0; rc = haptics_suspend_config(dev); if (rc < 0) return rc; #ifdef CONFIG_DEEPSLEEP if (pm_suspend_via_firmware()) haptics_ds_suspend_config(dev); #endif return 0; } static int haptics_resume(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); #ifdef CONFIG_DEEPSLEEP if (pm_suspend_via_firmware()) { int rc = 0; rc = haptics_ds_resume_config(dev); if (rc < 0) return rc; } #endif return haptics_module_enable(chip, true); } #endif static int haptics_freeze(struct device *dev) { int rc = 0; rc = haptics_suspend_config(dev); if (rc < 0) return rc; haptics_ds_suspend_config(dev); return 0; } static int haptics_restore(struct device *dev) { struct haptics_chip *chip = dev_get_drvdata(dev); int rc = 0; rc = haptics_ds_resume_config(dev); if (rc < 0) return rc; return haptics_module_enable(chip, true); } static void haptics_shutdown(struct platform_device *pdev) { struct haptics_chip *chip = platform_get_drvdata(pdev); haptics_suspend_config(chip->dev); haptics_ds_suspend_config(chip->dev); } static const struct dev_pm_ops haptics_pm_ops = { .suspend = haptics_suspend, .resume = haptics_resume, .freeze = haptics_freeze, .restore = haptics_restore, }; static const struct of_device_id haptics_match_table[] = { { .compatible = "qcom,hv-haptics", }, { .compatible = "qcom,pm8350b-haptics", }, { .compatible = "qcom,pm5100-haptics", }, {}, }; static struct platform_driver haptics_driver = { .driver = { .name = "qcom-hv-haptics", .of_match_table = haptics_match_table, .pm = &haptics_pm_ops, }, .probe = haptics_probe, .shutdown = haptics_shutdown, .remove = haptics_remove, }; module_platform_driver(haptics_driver); MODULE_DESCRIPTION("Qualcomm Technologies, Inc. High-Voltage Haptics driver"); MODULE_LICENSE("GPL v2");