/* * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sx9320_reg_multi3.h" #if defined(CONFIG_MUIC_NOTIFIER) #include #include #ifdef CONFIG_CCIC_NOTIFIER #include #endif #endif #if defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER) #include #endif #define VENDOR_NAME "SEMTECH" #define MODEL_NAME "SX9320_MULTI3" #define MODULE_NAME "grip_sensor_multi3" #define I2C_M_WR 0 /* for i2c Write */ #define I2c_M_RD 1 /* for i2c Read */ #define IDLE 0 #define ACTIVE 1 #define SX9320_MULTI3_MODE_SLEEP 0 #define SX9320_MULTI3_MODE_NORMAL 1 #define MAIN_SENSOR 1 #define REF_SENSOR 2 #define DIFF_READ_NUM 10 #define GRIP_LOG_TIME 15 /* 30 sec */ #define PHX_STATUS_REG SX9320_MULTI3_STAT0_PROXSTAT_PH0_FLAG /* CS0, CS1, CS2, CS3 */ #define TOTAL_BOTTON_COUNT 1 #define ENABLE_CSX ((1 << MAIN_SENSOR) | (1 << REF_SENSOR)) #define IRQ_PROCESS_CONDITION (SX9320_MULTI3_IRQSTAT_TOUCH_FLAG \ | SX9320_MULTI3_IRQSTAT_RELEASE_FLAG) #define NONE_ENABLE -1 #define IDLE_STATE 0 #define TOUCH_STATE 1 #define BODY_STATE 2 #define HALLIC1_PATH "/sys/class/sec/sec_key/hall_detect" struct sx9320_multi3_p { struct i2c_client *client; struct input_dev *input; struct device *factory_device; struct delayed_work init_work; struct delayed_work irq_work; struct delayed_work debug_work; struct wake_lock grip_wake_lock; struct mutex read_mutex; #if defined(CONFIG_MUIC_NOTIFIER) struct notifier_block cpuidle_muic_nb; #endif #if defined(CONFIG_CCIC_NOTIFIER) struct notifier_block cpuidle_ccic_nb; #endif bool skip_data; bool check_usb; u8 normal_th; u8 normal_th_buf; u8 phen; u8 gain; u8 again; int again_ch; u8 scan_period; u8 range; u8 sampling_freq; u8 resolution; u8 rawfilt; u8 hyst; u8 avgposfilt; u8 avgnegfilt; u8 avgthresh; u8 debouncer; u8 afeph0; u8 afeph1; u8 afeph2; u8 afeph3; int irq; int gpio_nirq; int state; int debug_count; int diff_avg; int diff_cnt; int init_done; int irq_count; int abnormal_mode; s32 capmain; s32 useful; s32 useful_avg; s16 avg; s32 diff; s32 max_diff; s32 max_normal_diff; u16 offset; u16 freq; int ch1_state; int ch2_state; atomic_t enable; unsigned char hall_ic1[6]; unsigned char hall_ic2[6]; }; static int sx9320_multi3_check_hallic_state(char *file_path, unsigned char hall_ic_status[]) { int iRet = 0; mm_segment_t old_fs; struct file *filep; u8 hall_sysfs[5]; old_fs = get_fs(); set_fs(KERNEL_DS); filep = filp_open(file_path, O_RDONLY, 0666); if (IS_ERR(filep)) { iRet = PTR_ERR(filep); set_fs(old_fs); goto exit; } iRet = filep->f_op->read(filep, hall_sysfs, sizeof(hall_sysfs), &filep->f_pos); if (iRet != sizeof(hall_sysfs)) iRet = -EIO; else strncpy(hall_ic_status, hall_sysfs, sizeof(hall_sysfs)); filp_close(filep, current->files); set_fs(old_fs); exit: return iRet; } static int sx9320_multi3_get_nirq_state(struct sx9320_multi3_p *data) { return gpio_get_value_cansleep(data->gpio_nirq); } static int sx9320_multi3_i2c_write(struct sx9320_multi3_p *data, u8 reg_addr, u8 buf) { int ret; struct i2c_msg msg; unsigned char w_buf[2]; w_buf[0] = reg_addr; w_buf[1] = buf; msg.addr = data->client->addr; msg.flags = I2C_M_WR; msg.len = 2; msg.buf = (char *)w_buf; ret = i2c_transfer(data->client->adapter, &msg, 1); if (ret < 0) pr_err("[SX9320_MULTI3]: %s - i2c write error %d\n", __func__, ret); return ret; } static int sx9320_multi3_i2c_read(struct sx9320_multi3_p *data, u8 reg_addr, u8 *buf) { int ret; struct i2c_msg msg[2]; msg[0].addr = data->client->addr; msg[0].flags = I2C_M_WR; msg[0].len = 1; msg[0].buf = ®_addr; msg[1].addr = data->client->addr; msg[1].flags = I2C_M_RD; msg[1].len = 1; msg[1].buf = buf; ret = i2c_transfer(data->client->adapter, msg, 2); if (ret < 0) pr_err("[SX9320_MULTI3]: %s - i2c read error %d\n", __func__, ret); return ret; } static void sx9320_multi3_get_again(struct sx9320_multi3_p *data) { switch (data->again) { case 0x06: data->again_ch = 1247; break; case 0x08: data->again_ch = 1000; break; case 0x0B: data->again_ch = 768; break; case 0x0F: data->again_ch = 552; break; default: data->again_ch = 1000; } } static u8 sx9320_multi3_read_irqstate(struct sx9320_multi3_p *data) { u8 val = 0; if (sx9320_multi3_i2c_read(data, SX9320_MULTI3_IRQSTAT_REG, &val) >= 0) return val; return 0; } static void sx9320_multi3_initialize_register(struct sx9320_multi3_p *data) { int idx; for (idx = 0; idx < (int)(sizeof(setup_reg) >> 1); idx++) sx9320_multi3_i2c_write(data, setup_reg[idx].reg, setup_reg[idx].val); if (data->phen < 2) sx9320_multi3_i2c_write(data, SX9320_MULTI3_PROXCTRL6_REG, data->normal_th); else sx9320_multi3_i2c_write(data, SX9320_MULTI3_PROXCTRL7_REG, data->normal_th); data->init_done = ON; } static void sx9320_multi3_initialize_chip(struct sx9320_multi3_p *data) { int cnt = 0; while ((sx9320_multi3_get_nirq_state(data) == 0) && (cnt++ < 10)) { sx9320_multi3_read_irqstate(data); msleep(20); } if (cnt >= 10) pr_err("[SX9320_MULTI3]: %s - s/w reset fail(%d)\n", __func__, cnt); sx9320_multi3_initialize_register(data); } static int sx9320_multi3_set_offset_calibration(struct sx9320_multi3_p *data) { int ret = 0; ret = sx9320_multi3_i2c_write(data, SX9320_MULTI3_STAT2_REG, 0x0F); return ret; } static void sx9320_multi3_send_event(struct sx9320_multi3_p *data, u8 state) { if (state == ACTIVE) { data->state = ACTIVE; pr_info("[SX9320_MULTI3]: %s - button touched\n", __func__); } else { data->state = IDLE; pr_info("[SX9320_MULTI3]: %s - button released\n", __func__); } if (data->skip_data == true) { pr_info("[SX9320_MULTI3]: %s - skip grip event\n", __func__); return; } if (state == ACTIVE) input_report_rel(data->input, REL_MISC, 1); else input_report_rel(data->input, REL_MISC, 2); input_sync(data->input); } static void sx9320_multi3_display_data_reg(struct sx9320_multi3_p *data) { u8 val = 0; int idx; sx9320_multi3_i2c_write(data, SX9320_MULTI3_REGSENSORSELECT, (u8)data->phen); for (idx = 0; idx < (int)(sizeof(setup_reg) >> 1); idx++) { sx9320_multi3_i2c_read(data, setup_reg[idx].reg, &val); pr_info("[SX9320_MULTI3]: %s - Read Reg: 0x%x Value: 0x%x\n\n", __func__, setup_reg[idx].reg, val); } } static void sx9320_multi3_get_data(struct sx9320_multi3_p *data) { u8 ms_byte = 0; u8 ls_byte = 0; s16 avg = 0; u16 offset = 0; s32 capMain = 0, useful = 0, range = 0; s32 gain, again; mutex_lock(&data->read_mutex); sx9320_multi3_i2c_write(data, SX9320_MULTI3_REGSENSORSELECT, (u8)data->phen); /* useful read */ sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGUSEMSB, &ms_byte); sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGUSELSB, &ls_byte); useful = (s32)ms_byte; useful = (useful << 8) | ((s32)ls_byte); if (useful > 32767) useful -= 65536; /* offset read */ sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGOFFSETMSB, &ms_byte); sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGOFFSETLSB, &ls_byte); offset = (u16)ms_byte; offset = (offset << 8) | ((u16)ls_byte); /* capMain calculate */ ms_byte = (u8)((offset >> 7) & 0x7F); ls_byte = (u8)((offset) & 0x7F); gain = 1 << (data->gain - 1); again = data->again_ch; /* range small(00) : 1.325 Large(01) : 2.65 */ if (data->range == 1) range = SX9320_MULTI3_LARGE_RANGE_VALUE; else range = SX9320_MULTI3_SMALL_RANGE_VALUE; capMain = (((s32)ms_byte * 21234) + ((s32)ls_byte * 496)) + ((useful * range) / ((gain * again * 65536) / 1000)); /* avg read */ sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGAVGMSB, &ms_byte); sx9320_multi3_i2c_read(data, SX9320_MULTI3_REGAVGLSB, &ls_byte); avg = (u16)ms_byte; avg = (avg << 8) | ((u16)ls_byte); data->useful = useful; data->offset = offset; data->capmain = capMain; data->avg = avg; data->diff = useful - avg; mutex_unlock(&data->read_mutex); pr_info("[SX9320_MULTI3]: %s - Capmain: %d, Useful: %d, avg: %d, diff: %d, Offset: %u\n", __func__, data->capmain, data->useful, data->avg, data->diff, data->offset); } static int sx9320_multi3_set_mode(struct sx9320_multi3_p *data, unsigned char mode) { int ret = -EINVAL; /* sx9320_multi3 enables the each PHASES(PHEN reg) instead of CSX */ if (mode == SX9320_MULTI3_MODE_SLEEP) { ret = sx9320_multi3_i2c_write(data, SX9320_MULTI3_GNRLCTRL1_REG, setup_reg[2].val); } else if (mode == SX9320_MULTI3_MODE_NORMAL) { ret = sx9320_multi3_i2c_write(data, SX9320_MULTI3_GNRLCTRL1_REG, setup_reg[2].val | (1 << data->phen)); msleep(20); sx9320_multi3_set_offset_calibration(data); msleep(400); } pr_info("[SX9320_MULTI3]: %s - change the mode : %u\n", __func__, mode); return ret; } static void sx9320_multi3_read_ch_interrupt(struct sx9320_multi3_p *data, u8 status) { if (status & (PHX_STATUS_REG << data->phen)) data->ch1_state = TOUCH_STATE; else data->ch1_state = IDLE_STATE; pr_info("[SX9320_MULTI3]: %s - ch1:%d, ch2:%d\n", __func__, data->ch1_state, data->ch2_state); } static void sx9320_multi3_check_status(struct sx9320_multi3_p *data, int enable) { /* this function has to be modified if chs are over 2 for SAR */ u8 status = 0; sx9320_multi3_i2c_read(data, SX9320_MULTI3_STAT0_REG, &status); if (data->skip_data == true) { input_report_rel(data->input, REL_MISC, 2); input_sync(data->input); } else if (status & (PHX_STATUS_REG << data->phen)) { sx9320_multi3_send_event(data, ACTIVE); } else { sx9320_multi3_send_event(data, IDLE); } } static void sx9320_multi3_set_enable(struct sx9320_multi3_p *data, int enable) { u8 status = 0; pr_info("[SX9320_MULTI3]: %s\n", __func__); if (enable == ON) { pr_info("[SX9320_MULTI3]: %s - enable(status : 0x%x)\n", __func__, status); data->diff_avg = 0; data->diff_cnt = 0; data->useful_avg = 0; sx9320_multi3_get_data(data); sx9320_multi3_check_status(data, enable); msleep(20); /* * make sure no interrupts are pending since enabling irq * will only work on next falling edge */ sx9320_multi3_read_irqstate(data); /* * enable interrupt */ sx9320_multi3_i2c_write(data, SX9320_MULTI3_IRQ_ENABLE_REG, 0x70); enable_irq(data->irq); enable_irq_wake(data->irq); } else { pr_info("[SX9320_MULTI3]: %s - disable\n", __func__); /* * disable interrupt */ sx9320_multi3_i2c_write(data, SX9320_MULTI3_IRQ_ENABLE_REG, 0x00); disable_irq(data->irq); disable_irq_wake(data->irq); } } static void sx9320_multi3_set_debug_work(struct sx9320_multi3_p *data, u8 enable, unsigned int time_ms) { if (enable == ON) { data->debug_count = 0; schedule_delayed_work_on(1, &data->debug_work, msecs_to_jiffies(time_ms)); } else { cancel_delayed_work_sync(&data->debug_work); } } static ssize_t sx9320_multi3_get_offset_calibration_show(struct device *dev, struct device_attribute *attr, char *buf) { u8 val = 0; struct sx9320_multi3_p *data = dev_get_drvdata(dev); sx9320_multi3_i2c_read(data, SX9320_MULTI3_IRQSTAT_REG, &val); return snprintf(buf, PAGE_SIZE, "%d\n", val); } static ssize_t sx9320_multi3_set_offset_calibration_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long val; struct sx9320_multi3_p *data = dev_get_drvdata(dev); if (kstrtoul(buf, 10, &val)) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return -EINVAL; } if (val) sx9320_multi3_set_offset_calibration(data); return count; } static ssize_t sx9320_multi3_register_write_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int regist = 0, val = 0; struct sx9320_multi3_p *data = dev_get_drvdata(dev); if (sscanf(buf, "%3d,%3d", ®ist, &val) != 2) { pr_err("[SX9320_MULTI3]: %s - The number of data are wrong\n", __func__); return -EINVAL; } sx9320_multi3_i2c_write(data, (unsigned char)regist, (unsigned char)val); pr_info("[SX9320_MULTI3]: %s - Register(0x%2x) data(0x%2x)\n", __func__, regist, val); return count; } static ssize_t sx9320_multi3_register_read_show(struct device *dev, struct device_attribute *attr, char *buf) { u8 val = 0; int offset = 0, idx = 0; struct sx9320_multi3_p *data = dev_get_drvdata(dev); for (idx = 0; idx < (int)(sizeof(setup_reg) >> 1); idx++) { sx9320_multi3_i2c_read(data, setup_reg[idx].reg, &val); pr_info("[SX9320_MULTI3]: %s - Read Reg: 0x%x Value: 0x%x\n\n", __func__, setup_reg[idx].reg, val); offset += snprintf(buf + offset, PAGE_SIZE - offset, "Reg: 0x%x Value: 0x%x\n", setup_reg[idx].reg, val); } return offset; } static ssize_t sx9320_multi3_read_data_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); sx9320_multi3_display_data_reg(data); return snprintf(buf, PAGE_SIZE, "%d\n", 0); } static ssize_t sx9320_multi3_sw_reset_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); pr_info("[SX9320_MULTI3]: %s\n", __func__); sx9320_multi3_set_offset_calibration(data); msleep(400); sx9320_multi3_get_data(data); return snprintf(buf, PAGE_SIZE, "%d\n", 0); } static ssize_t sx9320_multi3_freq_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long val; struct sx9320_multi3_p *data = dev_get_drvdata(dev); if (kstrtoul(buf, 10, &val)) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return count; } data->freq = (u16)val; val = ((val << 3) | (setup_reg[4].val & 0x07)) & 0xff; sx9320_multi3_i2c_write(data, SX9320_MULTI3_AFECTRL4_REG, (u8)val); pr_info("[SX9320_MULTI3]: %s - Freq : 0x%x\n", __func__, data->freq); return count; } static ssize_t sx9320_multi3_freq_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); pr_info("[SX9320_MULTI3]: %s - Freq : 0x%x\n", __func__, data->freq); return snprintf(buf, PAGE_SIZE, "%u\n", data->freq); } static ssize_t sx9320_multi3_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%s\n", VENDOR_NAME); } static ssize_t sx9320_multi3_name_show(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%s\n", MODEL_NAME); } static ssize_t sx9320_multi3_touch_mode_show(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "1\n"); } static ssize_t sx9320_multi3_raw_data_show(struct device *dev, struct device_attribute *attr, char *buf) { static int sum_diff; struct sx9320_multi3_p *data = dev_get_drvdata(dev); sx9320_multi3_get_data(data); if (data->diff_cnt == 0) sum_diff = data->diff; else sum_diff += data->diff; if (++data->diff_cnt >= DIFF_READ_NUM) { data->diff_avg = sum_diff / DIFF_READ_NUM; data->useful_avg = sum_diff / DIFF_READ_NUM; data->diff_cnt = 0; } return snprintf(buf, PAGE_SIZE, "%d,%d,%u,%d,%d\n", data->capmain, data->useful, data->offset, data->diff, data->avg); } static ssize_t sx9320_multi3_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { /* It's for init touch */ return snprintf(buf, PAGE_SIZE, "0\n"); } static ssize_t sx9320_multi3_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return count; } static ssize_t sx9320_multi3_normal_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); u16 thresh_temp = 0, hysteresis = 0; thresh_temp = data->normal_th; thresh_temp = thresh_temp * thresh_temp / 2; /* AdvCtrl13 */ hysteresis = (setup_reg[33].val >> 2) & 0x3; switch (hysteresis) { case 0x01: /* 6% */ hysteresis = thresh_temp >> 4; break; case 0x02: /* 12% */ hysteresis = thresh_temp >> 3; break; case 0x03: /* 25% */ hysteresis = thresh_temp >> 2; break; default: /* None */ break; } return snprintf(buf, PAGE_SIZE, "%d,%d\n", thresh_temp + hysteresis, thresh_temp - hysteresis); } static ssize_t sx9320_multi3_normal_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long val; struct sx9320_multi3_p *data = dev_get_drvdata(dev); /* It's for normal touch */ if (kstrtoul(buf, 10, &val)) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return count; } sx9320_multi3_i2c_write(data, SX9320_MULTI3_PROXCTRL7_REG, val); pr_info("[SX9320_MULTI3]: %s - normal threshold %lu\n", __func__, val); data->normal_th_buf = data->normal_th = (u8)(val); return count; } static ssize_t sx9320_multi3_onoff_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", !data->skip_data); } static ssize_t sx9320_multi3_onoff_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { u8 val; int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); ret = kstrtou8(buf, 2, &val); if (ret) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return count; } if (val == 0) { data->skip_data = true; if (atomic_read(&data->enable) == ON) { data->state = IDLE; input_report_rel(data->input, REL_MISC, 2); input_sync(data->input); } } else { data->skip_data = false; } pr_info("[SX9320_MULTI3]: %s -%u\n", __func__, val); return count; } static ssize_t sx9320_multi3_calibration_show(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "2,0,0\n"); } static ssize_t sx9320_multi3_calibration_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return count; } static ssize_t sx9320_multi3_gain_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); switch (data->gain) { case 0x01: ret = snprintf(buf, PAGE_SIZE, "x1\n"); break; case 0x02: ret = snprintf(buf, PAGE_SIZE, "x2\n"); break; case 0x03: ret = snprintf(buf, PAGE_SIZE, "x4\n"); break; case 0x04: ret = snprintf(buf, PAGE_SIZE, "x8\n"); break; default: ret = snprintf(buf, PAGE_SIZE, "Reserved\n"); break; } return ret; } static ssize_t sx9320_multi3_range_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); switch (data->range) { case 0x00: ret = snprintf(buf, PAGE_SIZE, "Small\n"); break; case 0x01: ret = snprintf(buf, PAGE_SIZE, "Large\n"); break; default: ret = snprintf(buf, PAGE_SIZE, "Small\n"); break; } return ret; } static ssize_t sx9320_multi3_diff_avg_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", data->diff_avg); } static ssize_t sx9320_multi3_useful_avg_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", data->useful_avg); } static ssize_t sx9320_multi3_ch_state_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); if (data->skip_data == true) { ret = snprintf(buf, PAGE_SIZE, "%d,%d\n", NONE_ENABLE, NONE_ENABLE); } else if (atomic_read(&data->enable) == ON) { ret = snprintf(buf, PAGE_SIZE, "%d,%d\n", data->ch1_state, data->ch2_state); } else { ret = snprintf(buf, PAGE_SIZE, "%d,%d\n", NONE_ENABLE, NONE_ENABLE); } return ret; } static ssize_t sx9320_multi3_body_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); u16 thresh_temp = 0, hysteresis = 0; u16 thresh_table[8] = {0, 300, 600, 900, 1200, 1500, 1800, 30000}; thresh_temp = (data->normal_th) & 0x07; thresh_temp = thresh_table[thresh_temp]; /* CTRL10 */ hysteresis = (setup_reg[16].val >> 4) & 0x3; switch (hysteresis) { case 0x01: /* 6% */ hysteresis = thresh_temp >> 4; break; case 0x02: /* 12% */ hysteresis = thresh_temp >> 3; break; case 0x03: /* 25% */ hysteresis = thresh_temp >> 2; break; default: /* None */ break; } return snprintf(buf, PAGE_SIZE, "%d,%d\n", thresh_temp + hysteresis, thresh_temp - hysteresis); } static ssize_t sx9320_multi3_body_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long val; struct sx9320_multi3_p *data = dev_get_drvdata(dev); if (kstrtoul(buf, 10, &val)) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return count; } data->normal_th &= 0xf8; data->normal_th |= val; pr_info("[SX9320_MULTI3]: %s - body threshold %lu\n", __func__, val); data->normal_th_buf = data->normal_th = (u8)(val); return count; } static ssize_t sx9320_multi3_grip_flush_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int ret = 0; u8 handle = 0; ret = kstrtou8(buf, 10, &handle); if (ret < 0) { pr_err("%s - kstrtou8 failed.(%d)\n", __func__, ret); return count; } pr_info("[SX9320_MULTI3]: %s - handle = %d\n", __func__, handle); input_report_rel(data->input, REL_MAX, handle); input_sync(data->input); return count; } static ssize_t sx9320_multi3_avgnegfilt_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int avgnegfilt = data->avgnegfilt; if (avgnegfilt == 7) return snprintf(buf, PAGE_SIZE, "1\n"); else if (avgnegfilt > 0 && data->avgnegfilt < 7) return snprintf(buf, PAGE_SIZE, "1-1/%d\n", 1 << avgnegfilt); else if (avgnegfilt == 0) return snprintf(buf, PAGE_SIZE, "0\n"); return snprintf(buf, PAGE_SIZE, "not set\n"); } static ssize_t sx9320_multi3_avgposfilt_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); switch (data->avgposfilt) { case 0x00: return snprintf(buf, PAGE_SIZE, "0\n"); case 0x01: return snprintf(buf, PAGE_SIZE, "1-1/16\n"); case 0x02: return snprintf(buf, PAGE_SIZE, "1-1/64\n"); case 0x03: return snprintf(buf, PAGE_SIZE, "1-1/128\n"); case 0x04: return snprintf(buf, PAGE_SIZE, "1-1/256\n"); case 0x05: return snprintf(buf, PAGE_SIZE, "1-1/512\n"); case 0x06: return snprintf(buf, PAGE_SIZE, "1-1/1024\n"); case 0x07: return snprintf(buf, PAGE_SIZE, "1\n"); default: break; } return snprintf(buf, PAGE_SIZE, "not set\n"); } static ssize_t sx9320_multi3_avgthresh_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", 512 * data->avgthresh); } static ssize_t sx9320_multi3_rawfilt_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int rawfilt = data->rawfilt; if (rawfilt > 0 && rawfilt < 8) return snprintf(buf, PAGE_SIZE, "1-1/%d\n", 1 << rawfilt); else if (rawfilt == 0) return snprintf(buf, PAGE_SIZE, "0\n"); return snprintf(buf, PAGE_SIZE, "not set\n"); } static ssize_t sx9320_multi3_sampling_freq_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int sampling_freq = data->sampling_freq; const char *table[32] = { "250", "200", "166.67", "142.86", "125", "111.11", "100", "90.91", "83.33", "76.92", "71.43", "66.67", "62.50", "58.82", "55.56", "52.63", "50", "45.45", "41.67", "38.46", "35.71", "31.25", "27.78", "25", "20.83", "17.86", "13.89", "11.36", "8.33", "6.58", "5.43", "4.63"}; if (sampling_freq < 0 || sampling_freq > 31) return snprintf(buf, PAGE_SIZE, "not set\n"); return snprintf(buf, PAGE_SIZE, "%skHz\n", table[sampling_freq]); } static ssize_t sx9320_multi3_scan_period_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int scan_period = data->scan_period; const char *table[30] = { "Min", "2ms", "4ms", "6ms", "8ms", "10ms", "14ms", "18ms", "22ms", "26ms", "30ms", "34ms", "38ms", "42ms", "46ms", "50ms", "56ms", "62ms", "68ms", "74ms", "80ms", "90ms", "100ms", "200ms", "300ms", "400ms", "600ms", "800ms", "1s", "2s"}; if (scan_period < 0 || scan_period > 29) return snprintf(buf, PAGE_SIZE, "not set\n"); return snprintf(buf, PAGE_SIZE, "%s\n", table[scan_period]); } static ssize_t sx9320_multi3_again_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); switch (data->again_ch) { case 1247: return snprintf(buf, PAGE_SIZE, "x1.247\n"); case 1000: return snprintf(buf, PAGE_SIZE, "x1\n"); case 768: return snprintf(buf, PAGE_SIZE, "x0.768\n"); case 552: return snprintf(buf, PAGE_SIZE, "x0.552\n"); default: return snprintf(buf, PAGE_SIZE, "not set\n"); } } static ssize_t sx9320_multi3_phase_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", data->phen); } static ssize_t sx9320_multi3_hysteresis_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); const char *table[4] = {"None", "+/-6%", "+/-12%", "+/-25%"}; int hyst = data->hyst; if (hyst < 0 || hyst > 3) return snprintf(buf, PAGE_SIZE, "not set\n"); return snprintf(buf, PAGE_SIZE, "%s\n", table[hyst]); } static ssize_t sx9320_multi3_irq_count_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int result = 0; s32 max_diff_val = 0; if (data->irq_count) { result = -1; max_diff_val = data->max_diff; } else { max_diff_val = data->max_normal_diff; } pr_info("[SX9320_MULTI3]: %s - called\n", __func__); return snprintf(buf, PAGE_SIZE, "%d,%d,%d\n", result, data->irq_count, max_diff_val); } static ssize_t sx9320_multi3_irq_count_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); u8 onoff; int ret; ret = kstrtou8(buf, 10, &onoff); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s - kstrtou8 failed.(%d)\n", __func__, ret); return count; } mutex_lock(&data->read_mutex); if (onoff == 0) { data->abnormal_mode = OFF; } else if (onoff == 1) { data->abnormal_mode = ON; data->irq_count = 0; data->max_diff = 0; data->max_normal_diff = 0; } else { pr_err("[SX9320_MULTI3]: %s - unknown value %d\n", __func__, onoff); } mutex_unlock(&data->read_mutex); pr_info("[SX9320_MULTI3]: %s - %d\n", __func__, onoff); return count; } static DEVICE_ATTR(menual_calibrate, 0664, sx9320_multi3_get_offset_calibration_show, sx9320_multi3_set_offset_calibration_store); static DEVICE_ATTR(register_write, 0220, NULL, sx9320_multi3_register_write_store); static DEVICE_ATTR(register_read, 0444, sx9320_multi3_register_read_show, NULL); static DEVICE_ATTR(readback, 0444, sx9320_multi3_read_data_show, NULL); static DEVICE_ATTR(reset, 0444, sx9320_multi3_sw_reset_show, NULL); static DEVICE_ATTR(name, 0444, sx9320_multi3_name_show, NULL); static DEVICE_ATTR(vendor, 0444, sx9320_multi3_vendor_show, NULL); static DEVICE_ATTR(mode, 0444, sx9320_multi3_touch_mode_show, NULL); static DEVICE_ATTR(raw_data, 0444, sx9320_multi3_raw_data_show, NULL); static DEVICE_ATTR(diff_avg, 0444, sx9320_multi3_diff_avg_show, NULL); static DEVICE_ATTR(useful_avg, 0444, sx9320_multi3_useful_avg_show, NULL); static DEVICE_ATTR(calibration, 0664, sx9320_multi3_calibration_show, sx9320_multi3_calibration_store); static DEVICE_ATTR(onoff, 0664, sx9320_multi3_onoff_show, sx9320_multi3_onoff_store); static DEVICE_ATTR(threshold, 0664, sx9320_multi3_threshold_show, sx9320_multi3_threshold_store); static DEVICE_ATTR(normal_threshold, 0664, sx9320_multi3_normal_threshold_show, sx9320_multi3_normal_threshold_store); static DEVICE_ATTR(freq, 0664, sx9320_multi3_freq_show, sx9320_multi3_freq_store); static DEVICE_ATTR(ch_state, 0444, sx9320_multi3_ch_state_show, NULL); static DEVICE_ATTR(body_threshold, 0664, sx9320_multi3_body_threshold_show, sx9320_multi3_body_threshold_store); static DEVICE_ATTR(avg_negfilt, 0444, sx9320_multi3_avgnegfilt_show, NULL); static DEVICE_ATTR(avg_posfilt, 0444, sx9320_multi3_avgposfilt_show, NULL); static DEVICE_ATTR(avg_thresh, 0444, sx9320_multi3_avgthresh_show, NULL); static DEVICE_ATTR(rawfilt, 0444, sx9320_multi3_rawfilt_show, NULL); static DEVICE_ATTR(sampling_freq, 0444, sx9320_multi3_sampling_freq_show, NULL); static DEVICE_ATTR(scan_period, 0444, sx9320_multi3_scan_period_show, NULL); static DEVICE_ATTR(gain, 0444, sx9320_multi3_gain_show, NULL); static DEVICE_ATTR(range, 0444, sx9320_multi3_range_show, NULL); static DEVICE_ATTR(analog_gain, 0444, sx9320_multi3_again_show, NULL); static DEVICE_ATTR(phase, 0444, sx9320_multi3_phase_show, NULL); static DEVICE_ATTR(hysteresis, 0444, sx9320_multi3_hysteresis_show, NULL); static DEVICE_ATTR(irq_count, 0664, sx9320_multi3_irq_count_show, sx9320_multi3_irq_count_store); static DEVICE_ATTR(grip_flush, 0220, NULL, sx9320_multi3_grip_flush_store); static struct device_attribute *sensor_attrs[] = { &dev_attr_menual_calibrate, &dev_attr_register_write, &dev_attr_register_read, &dev_attr_readback, &dev_attr_reset, &dev_attr_name, &dev_attr_vendor, &dev_attr_mode, &dev_attr_diff_avg, &dev_attr_useful_avg, &dev_attr_raw_data, &dev_attr_threshold, &dev_attr_normal_threshold, &dev_attr_onoff, &dev_attr_calibration, &dev_attr_freq, &dev_attr_ch_state, &dev_attr_body_threshold, &dev_attr_grip_flush, &dev_attr_avg_negfilt, &dev_attr_avg_posfilt, &dev_attr_avg_thresh, &dev_attr_rawfilt, &dev_attr_sampling_freq, &dev_attr_scan_period, &dev_attr_gain, &dev_attr_range, &dev_attr_analog_gain, &dev_attr_phase, &dev_attr_hysteresis, &dev_attr_irq_count, NULL, }; static ssize_t sx9320_multi3_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { u8 enable; int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); int pre_enable = atomic_read(&data->enable); ret = kstrtou8(buf, 2, &enable); if (ret) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return ret; } pr_info("[SX9320_MULTI3]: %s - new_value = %u old_value = %d\n", __func__, enable, pre_enable); if (pre_enable == enable) return size; atomic_set(&data->enable, enable); sx9320_multi3_set_enable(data, enable); return size; } static ssize_t sx9320_multi3_enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&data->enable)); } static ssize_t sx9320_multi3_flush_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { u8 enable; int ret; struct sx9320_multi3_p *data = dev_get_drvdata(dev); ret = kstrtou8(buf, 2, &enable); if (ret) { pr_err("[SX9320_MULTI3]: %s - Invalid Argument\n", __func__); return count; } if (enable == 1) { input_report_rel(data->input, REL_MAX, 1); input_sync(data->input); } return count; } static DEVICE_ATTR(enable, 0664, sx9320_multi3_enable_show, sx9320_multi3_enable_store); static DEVICE_ATTR(flush, 0220, NULL, sx9320_multi3_flush_store); static struct attribute *sx9320_multi3_attributes[] = { &dev_attr_enable.attr, &dev_attr_flush.attr, NULL }; static struct attribute_group sx9320_multi3_attribute_group = { .attrs = sx9320_multi3_attributes }; static void sx9320_multi3_touch_process(struct sx9320_multi3_p *data, u8 flag) { u8 status = 0; sx9320_multi3_i2c_read(data, SX9320_MULTI3_STAT0_REG, &status); pr_info("[SX9320_MULTI3]: %s - (status: 0x%x)\n", __func__, status); sx9320_multi3_get_data(data); if (data->abnormal_mode) { if (status) { if (data->max_diff < data->diff) data->max_diff = data->diff; data->irq_count++; } } sx9320_multi3_read_ch_interrupt(data, status); if (data->state == IDLE) { if (status & (PHX_STATUS_REG << data->phen)) sx9320_multi3_send_event(data, ACTIVE); else pr_info("[SX9320_MULTI3]: %s - already released\n", __func__); } else { if (!(status & (PHX_STATUS_REG << data->phen))) sx9320_multi3_send_event(data, IDLE); else pr_info("[SX9320_MULTI3]: %s - still touched\n", __func__); } } static void sx9320_multi3_process_interrupt(struct sx9320_multi3_p *data) { u8 flag = 0; /* since we are not in an interrupt don't need to disable irq. */ flag = sx9320_multi3_read_irqstate(data); if (flag & IRQ_PROCESS_CONDITION) sx9320_multi3_touch_process(data, flag); else pr_info("[SX9320_MULTI3]: %s interrupt generated but skip\n", __func__); } static void sx9320_multi3_init_work_func(struct work_struct *work) { struct sx9320_multi3_p *data = container_of((struct delayed_work *)work, struct sx9320_multi3_p, init_work); sx9320_multi3_initialize_chip(data); /* set the threshold at init. register depends on phase */ if (data->phen < 2) sx9320_multi3_i2c_write(data, SX9320_MULTI3_PROXCTRL6_REG, data->normal_th); else sx9320_multi3_i2c_write(data, SX9320_MULTI3_PROXCTRL7_REG, data->normal_th); sx9320_multi3_set_mode(data, SX9320_MULTI3_MODE_NORMAL); /* * make sure no interrupts are pending since enabling irq * will only work on next falling edge */ sx9320_multi3_read_irqstate(data); } static void sx9320_multi3_irq_work_func(struct work_struct *work) { struct sx9320_multi3_p *data = container_of((struct delayed_work *)work, struct sx9320_multi3_p, irq_work); if (sx9320_multi3_get_nirq_state(data) == 0) sx9320_multi3_process_interrupt(data); else pr_err("[SX9320_MULTI3]: %s - nirq read high %d\n", __func__, sx9320_multi3_get_nirq_state(data)); } static void sx9320_multi3_debug_work_func(struct work_struct *work) { struct sx9320_multi3_p *data = container_of((struct delayed_work *)work, struct sx9320_multi3_p, debug_work); static int hall_flag = 1; sx9320_multi3_check_hallic_state(HALLIC1_PATH, data->hall_ic1); /* Hall IC closed : offset cal (once) */ if (strcmp(data->hall_ic1, "CLOSE") == 0) { if (hall_flag) { pr_info("[SX9320_MULTI3]: %s - hall IC1 is closed\n", __func__); sx9320_multi3_set_offset_calibration(data); hall_flag = 0; } } else hall_flag = 1; if (atomic_read(&data->enable) == ON) { if (data->abnormal_mode) { sx9320_multi3_get_data(data); if (data->max_normal_diff < data->diff) data->max_normal_diff = data->diff; } else { if (data->debug_count >= GRIP_LOG_TIME) { sx9320_multi3_get_data(data); data->debug_count = 0; } else { data->debug_count++; } } } schedule_delayed_work_on(1, &data->debug_work, msecs_to_jiffies(2000)); } static irqreturn_t sx9320_multi3_interrupt_thread(int irq, void *pdata) { struct sx9320_multi3_p *data = pdata; if (sx9320_multi3_get_nirq_state(data) == 1) { pr_err("[SX9320_MULTI3]: %s - nirq read high\n", __func__); } else { wake_lock_timeout(&data->grip_wake_lock, 3 * HZ); schedule_delayed_work(&data->irq_work, msecs_to_jiffies(100)); } return IRQ_HANDLED; } static int sx9320_multi3_init_input(struct sx9320_multi3_p *data) { int ret = 0; /* Create the input device */ data->input = input_allocate_device(); if (!data->input) return -ENOMEM; data->input->name = MODULE_NAME; data->input->id.bustype = BUS_I2C; input_set_capability(data->input, EV_REL, REL_MISC); input_set_capability(data->input, EV_REL, REL_MAX); input_set_drvdata(data->input, data); ret = input_register_device(data->input); if (ret < 0) { input_free_device(data->input); return ret; } ret = sensors_create_symlink(data->input); if (ret < 0) { input_unregister_device(data->input); return ret; } ret = sysfs_create_group(&data->input->dev.kobj, &sx9320_multi3_attribute_group); if (ret < 0) { sensors_remove_symlink(data->input); input_unregister_device(data->input); return ret; } return 0; } static int sx9320_multi3_setup_pin(struct sx9320_multi3_p *data) { int ret; ret = gpio_request(data->gpio_nirq, "SX9320_MULTI3_nIRQ"); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s - gpio %d request failed (%d)\n", __func__, data->gpio_nirq, ret); return ret; } ret = gpio_direction_input(data->gpio_nirq); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s - failed to set gpio %d(%d)\n", __func__, data->gpio_nirq, ret); gpio_free(data->gpio_nirq); return ret; } return 0; } static void sx9320_multi3_set_specific_register(int regi_num, int end, int start, u8 val) { u16 clear_bit = 0x00; unsigned char temp_val; temp_val = setup_reg[regi_num].val; clear_bit = ~((1 << (end + 1)) - (1 << start)); temp_val = (temp_val & clear_bit) | (val << start); setup_reg[regi_num].val = temp_val; } static void sx9320_multi3_initialize_variable(struct sx9320_multi3_p *data) { data->state = IDLE; data->skip_data = false; data->check_usb = false; data->debug_count = 0; data->normal_th_buf = data->normal_th; data->ch1_state = IDLE; data->init_done = OFF; atomic_set(&data->enable, OFF); /* sampling freq, rawfilt, gain, hyst are depends on phase */ if (data->phen < 2) { /* regi_num, end bit, start bit, val */ sx9320_multi3_set_specific_register(5, 7, 3, data->sampling_freq); sx9320_multi3_set_specific_register(5, 2, 0, data->resolution); sx9320_multi3_set_specific_register(12, 2, 0, data->rawfilt); sx9320_multi3_set_specific_register(12, 5, 3, data->gain); } else { sx9320_multi3_set_specific_register(7, 7, 3, data->sampling_freq); sx9320_multi3_set_specific_register(7, 2, 0, data->resolution); sx9320_multi3_set_specific_register(13, 2, 0, data->rawfilt); sx9320_multi3_set_specific_register(13, 5, 3, data->gain); } sx9320_multi3_set_specific_register(0, 4, 0, data->scan_period); sx9320_multi3_set_specific_register(43, 3, 0, data->again); sx9320_multi3_set_specific_register(14, 5, 0, data->avgthresh); sx9320_multi3_set_specific_register(16, 2, 0, data->avgposfilt); sx9320_multi3_set_specific_register(16, 5, 3, data->avgnegfilt); sx9320_multi3_set_specific_register(17, 3, 2, data->debouncer); sx9320_multi3_set_specific_register(17, 5, 4, data->hyst); sx9320_multi3_set_specific_register(8, 5, 0, data->afeph0); sx9320_multi3_set_specific_register(9, 5, 0, data->afeph1); sx9320_multi3_set_specific_register(10, 5, 0, data->afeph2); sx9320_multi3_set_specific_register(11, 5, 0, data->afeph3); sx9320_multi3_get_again(data); } static int sx9320_multi3_read_setupreg(struct device_node *dnode, char *str, u8 *val) { u32 temp_val; int ret; ret = of_property_read_u32(dnode, str, &temp_val); if (!ret) *val = (u8)temp_val; else pr_err("[SX9320_MULTI3]: %s - %s: prop read err 0x%2x (%d)\n", __func__, str, temp_val, ret); return ret; } static int sx9320_multi3_parse_dt(struct sx9320_multi3_p *data, struct device *dev) { struct device_node *node = dev->of_node; enum of_gpio_flags flags; if (node == NULL) return -ENODEV; data->gpio_nirq = of_get_named_gpio_flags(node, "sx9320_multi3,nirq-gpio", 0, &flags); if (data->gpio_nirq < 0) { pr_err("[SX9320_MULTI3]: %s - get gpio_nirq error\n", __func__); return -ENODEV; } sx9320_multi3_read_setupreg(node, SX9320_MULTI3_PHEN, &data->phen); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_GAIN, &data->gain); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AGAIN, &data->again); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_SCANPERIOD, &data->scan_period); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_RANGE, &data->range); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_SAMPLING_FREQ, &data->sampling_freq); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_RESOLUTION, &data->resolution); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_RAWFILT, &data->rawfilt); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_HYST, &data->hyst); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AVGPOSFILT, &data->avgposfilt); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AVGNEGFILT, &data->avgnegfilt); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AVGTHRESH, &data->avgthresh); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_DEBOUNCER, &data->debouncer); sx9320_multi3_read_setupreg(node, SX9320_MULTI3_NORMALTHD, &data->normal_th); if (sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AFEPH0, &data->afeph0)) data->afeph0 = setup_reg[8].val; if (sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AFEPH1, &data->afeph1)) data->afeph1 = setup_reg[9].val; if (sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AFEPH2, &data->afeph2)) data->afeph2 = setup_reg[10].val; if (sx9320_multi3_read_setupreg(node, SX9320_MULTI3_AFEPH3, &data->afeph3)) data->afeph3 = setup_reg[11].val; pr_info("[SX9320_MULTI3]: afeph0:%x, afeph1:%x, afeph2:%x, afeph3:%x\n", data->afeph0, data->afeph1, data->afeph2, data->afeph3); return 0; } #if defined(CONFIG_CCIC_NOTIFIER) && defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER) static int sx9320_multi3_ccic_handle_notification(struct notifier_block *nb, unsigned long action, void *data) { CC_NOTI_USB_STATUS_TYPEDEF usb_status = *(CC_NOTI_USB_STATUS_TYPEDEF *)data; struct sx9320_multi3_p *pdata = container_of(nb, struct sx9320_multi3_p, cpuidle_ccic_nb); static int pre_attach; if (pre_attach == usb_status.attach) return 0; /* * USB_STATUS_NOTIFY_DETACH = 0, * USB_STATUS_NOTIFY_ATTACH_DFP = 1, // Host * USB_STATUS_NOTIFY_ATTACH_UFP = 2, // Device * USB_STATUS_NOTIFY_ATTACH_DRP = 3, // Dual role */ if (pdata->init_done == ON) { switch (usb_status.drp) { case USB_STATUS_NOTIFY_ATTACH_UFP: case USB_STATUS_NOTIFY_ATTACH_DFP: case USB_STATUS_NOTIFY_DETACH: pr_info("[SX9320_MULTI3]: %s - drp = %d attat = %d\n", __func__, usb_status.drp, usb_status.attach); sx9320_multi3_set_offset_calibration(pdata); break; default: pr_info("[SX9320_MULTI3]: %s - DRP type : %d\n", __func__, usb_status.drp); break; } } pre_attach = usb_status.attach; return 0; } #elif defined(CONFIG_MUIC_NOTIFIER) static int sx9320_multi3_cpuidle_muic_notifier(struct notifier_block *nb, unsigned long action, void *data) { struct sx9320_multi3_p *grip_data; muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data; grip_data = container_of(nb, struct sx9320_multi3_p, cpuidle_muic_nb); switch (attached_dev) { case ATTACHED_DEV_OTG_MUIC: case ATTACHED_DEV_USB_MUIC: case ATTACHED_DEV_TA_MUIC: case ATTACHED_DEV_AFC_CHARGER_PREPARE_MUIC: case ATTACHED_DEV_AFC_CHARGER_9V_MUIC: if (action == MUIC_NOTIFY_CMD_ATTACH) pr_info("[SX9320_MULTI3]: %s - TA/USB insert\n", __func__); else if (action == MUIC_NOTIFY_CMD_DETACH) pr_info("[SX9320_MULTI3]: %s - TA/USB remove\n", __func__); if (grip_data->init_done == ON) sx9320_multi3_set_offset_calibration(grip_data); else pr_info("[SX9320_MULTI3]: %s - not initialized\n", __func__); break; default: break; } pr_info("[SX9320_MULTI3]: %s dev=%d, action=%lu\n", __func__, attached_dev, action); return NOTIFY_DONE; } #endif static int sx9320_multi3_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct sx9320_multi3_p *data = NULL; pr_info("[SX9320_MULTI3]: %s - Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[SX9320_MULTI3]: %s - i2c_check_functionality error\n", __func__); goto exit; } /* create memory for main struct */ data = kzalloc(sizeof(struct sx9320_multi3_p), GFP_KERNEL); i2c_set_clientdata(client, data); data->client = client; data->factory_device = &client->dev; ret = sx9320_multi3_init_input(data); if (ret < 0) goto exit_input_init; wake_lock_init(&data->grip_wake_lock, WAKE_LOCK_SUSPEND, "grip_wake_lock"); mutex_init(&data->read_mutex); ret = sx9320_multi3_parse_dt(data, &client->dev); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s - of_node error\n", __func__); ret = -ENODEV; goto exit_of_node; } ret = sx9320_multi3_setup_pin(data); if (ret) { pr_err("[SX9320_MULTI3]: %s - could not setup pin\n", __func__); goto exit_setup_pin; } /* read chip id */ ret = sx9320_multi3_i2c_write(data, SX9320_MULTI3_SOFTRESET_REG, SX9320_MULTI3_SOFTRESET); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s - reset failed%d\n", __func__, ret); goto exit_chip_reset; } sx9320_multi3_initialize_variable(data); INIT_DELAYED_WORK(&data->init_work, sx9320_multi3_init_work_func); INIT_DELAYED_WORK(&data->irq_work, sx9320_multi3_irq_work_func); INIT_DELAYED_WORK(&data->debug_work, sx9320_multi3_debug_work_func); data->irq = gpio_to_irq(data->gpio_nirq); ret = request_threaded_irq(data->irq, NULL, sx9320_multi3_interrupt_thread, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "sx9320_multi3_irq", data); if (ret < 0) { pr_err("[SX9320_MULTI3]: %s failed to set request irq %d(%d)\n", __func__, data->irq, ret); goto exit_request_threaded_irq; } disable_irq(data->irq); ret = sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME); if (ret) { pr_err("[SX9320_MULTI3] %s - cound not register sensor(%d).\n", __func__, ret); goto grip_sensor_register_failed; } schedule_delayed_work(&data->init_work, msecs_to_jiffies(300)); sx9320_multi3_set_debug_work(data, ON, 20000); #if defined(CONFIG_CCIC_NOTIFIER) && defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER) manager_notifier_register(&data->cpuidle_ccic_nb, sx9320_multi3_ccic_handle_notification, MANAGER_NOTIFY_CCIC_SENSORHUB); #elif defined(CONFIG_MUIC_NOTIFIER) muic_notifier_register(&data->cpuidle_muic_nb, sx9320_multi3_cpuidle_muic_notifier, MUIC_NOTIFY_DEV_CPUIDLE); #endif pr_info("[SX9320_MULTI3]: %s - Probe done!\n", __func__); return 0; grip_sensor_register_failed: free_irq(data->irq, data); exit_request_threaded_irq: exit_chip_reset: gpio_free(data->gpio_nirq); exit_setup_pin: exit_of_node: mutex_destroy(&data->read_mutex); wake_lock_destroy(&data->grip_wake_lock); sysfs_remove_group(&data->input->dev.kobj, &sx9320_multi3_attribute_group); sensors_remove_symlink(data->input); input_unregister_device(data->input); exit_input_init: kfree(data); exit: pr_err("[SX9320_MULTI3]: %s - Probe fail!\n", __func__); return ret; } static int sx9320_multi3_remove(struct i2c_client *client) { struct sx9320_multi3_p *data = (struct sx9320_multi3_p *)i2c_get_clientdata(client); if (atomic_read(&data->enable) == ON) sx9320_multi3_set_enable(data, OFF); sx9320_multi3_set_mode(data, SX9320_MULTI3_MODE_SLEEP); cancel_delayed_work_sync(&data->init_work); cancel_delayed_work_sync(&data->irq_work); cancel_delayed_work_sync(&data->debug_work); free_irq(data->irq, data); gpio_free(data->gpio_nirq); wake_lock_destroy(&data->grip_wake_lock); sensors_unregister(data->factory_device, sensor_attrs); sensors_remove_symlink(data->input); sysfs_remove_group(&data->input->dev.kobj, &sx9320_multi3_attribute_group); input_unregister_device(data->input); mutex_destroy(&data->read_mutex); kfree(data); return 0; } static int sx9320_multi3_suspend(struct device *dev) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); int cnt = 0; pr_info("[SX9320_MULTI3]: %s\n", __func__); /* before go to sleep, make the interrupt pin as high*/ while ((sx9320_multi3_get_nirq_state(data) == 0) && (cnt++ < 3)) { sx9320_multi3_read_irqstate(data); msleep(20); } if (cnt >= 3) pr_err("[SX9320_MULTI3]: %s - s/w reset fail(%d)\n", __func__, cnt); sx9320_multi3_set_debug_work(data, OFF, 1000); return 0; } static int sx9320_multi3_resume(struct device *dev) { struct sx9320_multi3_p *data = dev_get_drvdata(dev); pr_info("[SX9320_MULTI3]: %s\n", __func__); sx9320_multi3_set_debug_work(data, ON, 1000); return 0; } static void sx9320_multi3_shutdown(struct i2c_client *client) { struct sx9320_multi3_p *data = i2c_get_clientdata(client); pr_info("[SX9320_MULTI3]: %s\n", __func__); sx9320_multi3_set_debug_work(data, OFF, 1000); if (atomic_read(&data->enable) == ON) sx9320_multi3_set_enable(data, OFF); sx9320_multi3_set_mode(data, SX9320_MULTI3_MODE_SLEEP); } static const struct of_device_id grip2_match_table[] = { { .compatible = "sx9320_multi3",}, {}, }; static const struct i2c_device_id sx9320_multi3_id[] = { { "sx9320_multi3", 0 }, { } }; static const struct dev_pm_ops sx9320_multi3_pm_ops = { .suspend = sx9320_multi3_suspend, .resume = sx9320_multi3_resume, }; static struct i2c_driver grip2_driver = { .driver = { .name = MODEL_NAME, .owner = THIS_MODULE, .of_match_table = grip2_match_table, .pm = &sx9320_multi3_pm_ops }, .probe = sx9320_multi3_probe, .remove = sx9320_multi3_remove, .shutdown = sx9320_multi3_shutdown, .id_table = sx9320_multi3_id, }; static int __init grip2_init(void) { return i2c_add_driver(&grip2_driver); } static void __exit grip2_exit(void) { i2c_del_driver(&grip2_driver); } module_init(grip2_init); module_exit(grip2_exit); MODULE_DESCRIPTION("Semtech Corp. SX9320 Capacitive Touch Controller Driver"); MODULE_AUTHOR("Samsung Electronics"); MODULE_LICENSE("GPL");