1939 lines
50 KiB
C
Executable File
1939 lines
50 KiB
C
Executable File
/*
|
|
* Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/input.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/wakelock.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#include <linux/power_supply.h>
|
|
#include <linux/vmalloc.h>
|
|
#if defined(CONFIG_MUIC_NOTIFIER)
|
|
#include <linux/muic/muic.h>
|
|
#include <linux/muic/muic_notifier.h>
|
|
#endif
|
|
#if defined(CONFIG_CCIC_NOTIFIER) || defined(CONFIG_PDIC_NOTIFIER)
|
|
#include <linux/usb/typec/pdic_notifier.h>
|
|
#endif
|
|
#if defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
|
|
#include <linux/usb/typec/usb_typec_manager_notifier.h>
|
|
#endif
|
|
|
|
#include "isg5320a_reg.h"
|
|
|
|
#define CHIP_ID 0x32
|
|
#define DEVICE_NAME "ISG5320A"
|
|
#define VENDOR_NAME "IMAGIS"
|
|
#define MODULE_NAME "grip_sensor"
|
|
|
|
#define ISG5320A_MODE_SLEEP 0
|
|
#define ISG5320A_MODE_NORMAL 1
|
|
#define ISG5320A_DIFF_AVR_CNT 10
|
|
#define ISG5320A_DISPLAY_TIME 30
|
|
#define ISG5320A_TAG "[ISG5320A]"
|
|
|
|
#if IS_ENABLED(CONFIG_HALL_NEW_NODE)
|
|
#define HALLIC_PATH "/sys/class/sec/hall_ic/hall_detect"
|
|
#define HALLIC_CERT_PATH "/sys/class/sec/hall_ic/certify_hall_detect"
|
|
#else
|
|
#define HALLIC_PATH "/sys/class/sec/sec_key/hall_detect"
|
|
#define HALLIC_CERT_PATH "/sys/class/sec/sec_key/certify_hall_detect"
|
|
#endif
|
|
|
|
#define ISG5320A_INIT_DELAYEDWORK
|
|
#define GRIP_LOG_TIME 40 /* 20 sec */
|
|
|
|
#pragma pack(1)
|
|
typedef struct {
|
|
char cmd;
|
|
u8 addr;
|
|
u8 val;
|
|
} direct_info;
|
|
#pragma pack()
|
|
|
|
struct isg5320a_data {
|
|
struct i2c_client *client;
|
|
struct input_dev *input_dev;
|
|
struct device *dev;
|
|
struct delayed_work debug_work;
|
|
struct delayed_work cal_work;
|
|
struct work_struct force_cal_work;
|
|
#ifdef ISG5320A_INIT_DELAYEDWORK
|
|
struct delayed_work init_work;
|
|
#endif
|
|
struct wake_lock grip_wake_lock;
|
|
struct mutex lock;
|
|
#ifdef CONFIG_MUIC_NOTIFIER
|
|
struct notifier_block cpuidle_muic_nb;
|
|
#endif
|
|
#if defined(CONFIG_CCIC_NOTIFIER) || defined(CONFIG_PDIC_NOTIFIER)
|
|
struct notifier_block cpuidle_ccic_nb;
|
|
#endif
|
|
int gpio_int;
|
|
|
|
int enable;
|
|
int state;
|
|
|
|
bool skip_data;
|
|
int initialized;
|
|
|
|
u16 normal_th;
|
|
|
|
u32 cdc;
|
|
u32 base;
|
|
s32 diff;
|
|
s32 max_diff;
|
|
s32 max_normal_diff;
|
|
|
|
int diff_cnt;
|
|
int diff_sum;
|
|
int diff_avg;
|
|
int cdc_sum;
|
|
int cdc_avg;
|
|
|
|
u32 debug_cdc[3];
|
|
s32 debug_diff[3];
|
|
u32 debug_base[2];
|
|
|
|
int irq_count;
|
|
int abnormal_mode;
|
|
|
|
u16 fine_coarse;
|
|
u32 cfcal_th;
|
|
bool bfcal_chk_ready;
|
|
bool bfcal_chk_start;
|
|
u32 bfcal_chk_count;
|
|
u32 bfcal_chk_cdc;
|
|
s32 bfcal_chk_diff;
|
|
|
|
int debug_cnt;
|
|
|
|
u8 intr_debug_addr;
|
|
int intr_debug_size;
|
|
direct_info direct;
|
|
|
|
int hall_flag;
|
|
int hall_cert_flag;
|
|
int hallic_detect;
|
|
int hallic_cert_detect;
|
|
unsigned char hall_ic[6];
|
|
};
|
|
|
|
static int check_hallic_state(char *file_path, unsigned char hall_ic_status[])
|
|
{
|
|
int ret = 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)) {
|
|
ret = PTR_ERR(filep);
|
|
set_fs(old_fs);
|
|
goto exit;
|
|
}
|
|
|
|
ret = vfs_read(filep, hall_sysfs, sizeof(hall_sysfs),
|
|
&filep->f_pos);
|
|
|
|
if (ret != sizeof(hall_sysfs))
|
|
ret = -EIO;
|
|
else
|
|
strncpy(hall_ic_status, hall_sysfs, sizeof(hall_sysfs));
|
|
|
|
filp_close(filep, current->files);
|
|
set_fs(old_fs);
|
|
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
static int isg5320a_i2c_write(struct isg5320a_data *data, u8 cmd, u8 *val,
|
|
int len)
|
|
{
|
|
int ret;
|
|
u8 buf[sizeof(cmd) + len];
|
|
struct i2c_msg msg;
|
|
|
|
buf[0] = cmd;
|
|
memcpy(buf + sizeof(cmd), val, len);
|
|
|
|
msg.addr = data->client->addr;
|
|
msg.flags = 0; /*I2C_M_WR*/
|
|
msg.len = sizeof(cmd) + len;
|
|
msg.buf = buf;
|
|
|
|
ret = i2c_transfer(data->client->adapter, &msg, 1);
|
|
if (ret < 0)
|
|
pr_err("%s %s: i2c_transfer failed(%d)\n", ISG5320A_TAG, __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int isg5320a_i2c_write_one(struct isg5320a_data *data, u8 cmd, u8 val)
|
|
{
|
|
int ret;
|
|
u8 buf[2];
|
|
struct i2c_msg msg;
|
|
|
|
buf[0] = cmd;
|
|
buf[1] = val;
|
|
|
|
msg.addr = data->client->addr;
|
|
msg.flags = 0; /*I2C_M_WR*/
|
|
msg.len = 2;
|
|
msg.buf = buf;
|
|
|
|
ret = i2c_transfer(data->client->adapter, &msg, 1);
|
|
if (ret < 0)
|
|
pr_err("%s %s: i2c_transfer failed(%d)\n", ISG5320A_TAG, __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int isg5320a_i2c_read(struct isg5320a_data *data, u8 cmd, u8 *val,
|
|
int len)
|
|
{
|
|
int ret;
|
|
struct i2c_msg msgs[2] = {
|
|
{
|
|
.addr = data->client->addr,
|
|
.flags = 0,
|
|
.len = sizeof(cmd),
|
|
.buf = &cmd,
|
|
},
|
|
{
|
|
.addr = data->client->addr,
|
|
.flags = I2C_M_RD,
|
|
.len = len,
|
|
.buf = val,
|
|
},
|
|
};
|
|
|
|
ret = i2c_transfer(data->client->adapter, msgs, 2);
|
|
if (ret < 0)
|
|
pr_err("%s %s: i2c_transfer failed(%d)\n", ISG5320A_TAG, __func__, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int isg5320a_reset(struct isg5320a_data *data)
|
|
{
|
|
int ret = 0;
|
|
int cnt = 0;
|
|
u8 val;
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
if (data->initialized == OFF)
|
|
usleep_range(5000, 5100);
|
|
|
|
ret = isg5320a_i2c_read(data, ISG5320A_IRQSRC_REG, &val, 1);
|
|
if (ret < 0)
|
|
pr_err("%s irq to high failed(%d)\n", ISG5320A_TAG, ret);
|
|
|
|
while (gpio_get_value_cansleep(data->gpio_int) == 0 && cnt++ < 10)
|
|
usleep_range(5000, 5100);
|
|
|
|
if (cnt >= 10)
|
|
pr_err("%s wait irq to high failed\n", ISG5320A_TAG);
|
|
|
|
ret = isg5320a_i2c_write_one(data, ISG5320A_PROTECT_REG,
|
|
ISG5320A_PRT_VALUE);
|
|
if (ret < 0)
|
|
pr_err("%s unlock protect failed(%d)\n", ISG5320A_TAG, ret);
|
|
|
|
ret = isg5320a_i2c_write_one(data, ISG5320A_SOFTRESET_REG,
|
|
ISG5320A_RST_VALUE);
|
|
if (ret < 0)
|
|
pr_err("%s soft reset failed(%d)\n", ISG5320A_TAG, ret);
|
|
|
|
usleep_range(1000, 1100);
|
|
|
|
cnt = 0;
|
|
while (gpio_get_value_cansleep(data->gpio_int) != 0 && cnt++ < 10)
|
|
usleep_range(5000, 5100);
|
|
|
|
if (cnt >= 10) {
|
|
pr_err("%s wait soft reset failed\n", ISG5320A_TAG);
|
|
return -EIO;
|
|
} else {
|
|
pr_info("%s wait cnt:%d\n", ISG5320A_TAG, cnt);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void isg5320a_force_calibration(struct isg5320a_data *data,
|
|
bool only_bfcal)
|
|
|
|
{
|
|
mutex_lock(&data->lock);
|
|
|
|
pr_info("%s %s(%d)\n", ISG5320A_TAG, __func__, only_bfcal ? 1 : 0);
|
|
|
|
if (!only_bfcal) {
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL1_REG,
|
|
ISG5320A_SCAN_STOP);
|
|
|
|
isg5320a_i2c_write_one(data, ISG5320A_BS_ON_WD_REG, ISG5320A_BS_WD_OFF);
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL2_REG,
|
|
ISG5320A_SCAN2_CLEAR);
|
|
msleep(100);
|
|
isg5320a_i2c_write_one(data, ISG5320A_OSCCON_REG, ISG5320A_OSC_NOMAL);
|
|
|
|
isg5320a_i2c_write_one(data, ISG5320A_BS_ON_WD_REG, ISG5320A_BS_WD_ON);
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL2_REG,
|
|
ISG5320A_SCAN2_RESET);
|
|
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL1_REG,
|
|
ISG5320A_CFCAL_START);
|
|
msleep(300);
|
|
}
|
|
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL2_REG, ISG5320A_BFCAL_START);
|
|
|
|
msleep(100);
|
|
|
|
mutex_unlock(&data->lock);
|
|
}
|
|
|
|
static inline unsigned char str2int(unsigned char c)
|
|
{
|
|
if (c >= '0' && c <= '9')
|
|
return c - '0';
|
|
|
|
if (c >= 'A' && c <= 'F')
|
|
return c - 'A' + 10;
|
|
|
|
if (c >= 'a' && c <= 'f')
|
|
return c - 'a' + 10;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int isg5320a_setup_reg(struct isg5320a_data *data)
|
|
{
|
|
int ret;
|
|
int i;
|
|
long file_size = 0;
|
|
uint8_t *file_data;
|
|
struct file *fp = NULL;
|
|
loff_t pos;
|
|
mm_segment_t old_fs = { 0 };
|
|
u8 addr = 0;
|
|
u8 val = 0;
|
|
|
|
old_fs = get_fs();
|
|
set_fs(get_ds());
|
|
|
|
fp = filp_open("/sdcard/isg5320a.reg", O_RDONLY, 0);
|
|
if (IS_ERR(fp)) {
|
|
pr_err("%s %s - file not exist:%ld\n", ISG5320A_TAG, __func__,
|
|
PTR_ERR(fp));
|
|
set_fs(old_fs);
|
|
return -1;
|
|
}
|
|
|
|
file_size = fp->f_path.dentry->d_inode->i_size;
|
|
pr_info("%s %s - size of the file : %ld(bytes)\n", ISG5320A_TAG,
|
|
__func__, file_size);
|
|
file_data = vzalloc(file_size);
|
|
pos = 0;
|
|
ret = vfs_read(fp, (char __user *)file_data, file_size, &pos);
|
|
if (ret != file_size) {
|
|
pr_err("%s %s - failed to read file (ret = %d)\n", ISG5320A_TAG,
|
|
__func__, ret);
|
|
vfree(file_data);
|
|
filp_close(fp, current->files);
|
|
return -1;
|
|
}
|
|
|
|
filp_close(fp, current->files);
|
|
set_fs(old_fs);
|
|
|
|
for (i = 0; i < file_size; i++) {
|
|
if (file_data[i] == 'W') {
|
|
if ((i + 6) >= file_size)
|
|
break;
|
|
addr = (u8)((str2int(file_data[i + 2]) * 16) +
|
|
str2int(file_data[i + 3]));
|
|
val = (u8)((str2int(file_data[i + 5]) * 16) +
|
|
str2int(file_data[i + 6]));
|
|
isg5320a_i2c_write_one(data, addr, val);
|
|
pr_info("%s W %02X %02X\n", ISG5320A_TAG, addr, val);
|
|
isg5320a_i2c_read(data, addr, &val, 1);
|
|
pr_info("%s %02X %02X\n", ISG5320A_TAG, addr, val);
|
|
} else if (file_data[i] == 'R') {
|
|
if ((i + 3) >= file_size)
|
|
break;
|
|
addr = (u8)((str2int(file_data[i + 2]) * 16) +
|
|
str2int(file_data[i + 3]));
|
|
isg5320a_i2c_read(data, addr, &val, 1);
|
|
pr_info("%s R %02X %02X\n", ISG5320A_TAG, addr, val);
|
|
}
|
|
}
|
|
|
|
vfree(file_data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void isg5320a_get_raw_data(struct isg5320a_data *data, bool log_print)
|
|
{
|
|
int ret = 0;
|
|
u8 buf[4];
|
|
u16 cpbuf;
|
|
u32 temp;
|
|
|
|
mutex_lock(&data->lock);
|
|
ret = isg5320a_i2c_read(data, ISG5320A_CDC16_T_H_REG, buf, sizeof(buf));
|
|
|
|
if (ret < 0) {
|
|
pr_info("%s fail to get data\n", ISG5320A_TAG);
|
|
} else {
|
|
temp = ((u32)buf[0] << 8) | (u32)buf[1];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->cdc = temp;
|
|
|
|
temp = ((u32)buf[2] << 8) | (u32)buf[3];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->base = temp;
|
|
data->diff = (s32)data->cdc - (s32)data->base;
|
|
}
|
|
|
|
ret = isg5320a_i2c_read(data, ISG5320A_COARSE_OUT_B_REG, (u8 *)&cpbuf, 2);
|
|
if (ret < 0)
|
|
pr_info("%s fail to get capMain\n", ISG5320A_TAG);
|
|
else
|
|
data->fine_coarse = cpbuf;
|
|
|
|
mutex_unlock(&data->lock);
|
|
|
|
if (log_print) {
|
|
pr_info("%s capMain: %d%02d, cdc: %d, baseline:%d, diff:%d, skip_data:%d\n",
|
|
ISG5320A_TAG, (data->fine_coarse & 0xFF),
|
|
((data->fine_coarse >> 8) & 0x3F), data->cdc, data->base,
|
|
data->diff, data->skip_data);
|
|
} else {
|
|
if (data->debug_cnt >= GRIP_LOG_TIME) {
|
|
pr_info("%s capMain: %d%02d, cdc: %d, baseline:%d, diff:%d, skip_data:%d\n",
|
|
ISG5320A_TAG, (data->fine_coarse & 0xFF),
|
|
((data->fine_coarse >> 8) & 0x3F), data->cdc, data->base,
|
|
data->diff, data->skip_data);
|
|
data->debug_cnt = 0;
|
|
} else {
|
|
data->debug_cnt++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void force_far_grip(struct isg5320a_data *data)
|
|
{
|
|
if (data->state == CLOSE) {
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
if (data->skip_data == true)
|
|
return;
|
|
|
|
input_report_rel(data->input_dev, REL_MISC, 2);
|
|
input_sync(data->input_dev);
|
|
data->state = FAR;
|
|
}
|
|
}
|
|
|
|
static void report_event_data(struct isg5320a_data *data, u8 intr_msg)
|
|
{
|
|
int state;
|
|
|
|
if (data->skip_data == true) {
|
|
pr_info("%s - skip grip event\n", ISG5320A_TAG);
|
|
return;
|
|
}
|
|
|
|
state = (intr_msg & (1 << ISG5320A_PROX_STATE)) ? CLOSE : FAR;
|
|
|
|
if (data->abnormal_mode) {
|
|
if (state == CLOSE) {
|
|
if (data->max_diff < data->diff)
|
|
data->max_diff = data->diff;
|
|
data->irq_count++;
|
|
}
|
|
}
|
|
|
|
if (state == CLOSE) {
|
|
if (data->state == FAR) {
|
|
pr_info("%s CLOSE\n", ISG5320A_TAG);
|
|
data->state = CLOSE;
|
|
data->bfcal_chk_start = true;
|
|
data->bfcal_chk_ready = false;
|
|
data->bfcal_chk_count = 0;
|
|
} else {
|
|
pr_info("%s still CLOSE\n", ISG5320A_TAG);
|
|
}
|
|
} else {
|
|
if (data->state == CLOSE) {
|
|
pr_info("%s FAR\n", ISG5320A_TAG);
|
|
data->state = FAR;
|
|
data->bfcal_chk_start = false;
|
|
data->bfcal_chk_ready = false;
|
|
data->bfcal_chk_count = 0;
|
|
} else {
|
|
pr_info("%s already FAR\n", ISG5320A_TAG);
|
|
}
|
|
}
|
|
|
|
if (data->state == CLOSE)
|
|
input_report_rel(data->input_dev, REL_MISC, 1);
|
|
else
|
|
input_report_rel(data->input_dev, REL_MISC, 2);
|
|
|
|
input_sync(data->input_dev);
|
|
}
|
|
|
|
static irqreturn_t isg5320a_irq_thread(int irq, void *ptr)
|
|
{
|
|
int ret;
|
|
int i;
|
|
u8 intr_msg = 0;
|
|
u8 *buf8;
|
|
struct isg5320a_data *data = (struct isg5320a_data *)ptr;
|
|
|
|
if (data->initialized == OFF)
|
|
return IRQ_HANDLED;
|
|
|
|
wake_lock(&data->grip_wake_lock);
|
|
|
|
isg5320a_get_raw_data(data, true);
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_IRQSRC_REG, &intr_msg, 1);
|
|
|
|
if (data->intr_debug_size > 0) {
|
|
buf8 = kzalloc(data->intr_debug_size, GFP_KERNEL);
|
|
if (buf8) {
|
|
pr_info("%s Intr_debug1 (0x%02X)\n", ISG5320A_TAG,
|
|
data->intr_debug_addr);
|
|
isg5320a_i2c_read(data, data->intr_debug_addr, buf8,
|
|
data->intr_debug_size);
|
|
for (i = 0; i < data->intr_debug_size; i++)
|
|
pr_info("%s \t%02X\n", ISG5320A_TAG, buf8[i]);
|
|
kfree(buf8);
|
|
}
|
|
}
|
|
|
|
ret = isg5320a_i2c_read(data, ISG5320A_IRQSTS_REG, &intr_msg, 1);
|
|
if (ret < 0) {
|
|
pr_err("%s fail to read state(%d)\n", ISG5320A_TAG, ret);
|
|
goto irq_end;
|
|
}
|
|
|
|
pr_info("%s intr msg: 0x%02X\n", ISG5320A_TAG, intr_msg);
|
|
|
|
report_event_data(data, intr_msg);
|
|
|
|
irq_end:
|
|
wake_unlock(&data->grip_wake_lock);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void isg5320a_initialize(struct isg5320a_data *data)
|
|
{
|
|
int ret;
|
|
int i;
|
|
u8 val;
|
|
u8 buf[2];
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
force_far_grip(data);
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_IRQSRC_REG, &val, 1);
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL1_REG, ISG5320A_SCAN_STOP);
|
|
msleep(30);
|
|
|
|
ret = isg5320a_setup_reg(data);
|
|
if (ret < 0) {
|
|
for (i = 0; i < (sizeof(setup_reg) >> 1); i++) {
|
|
isg5320a_i2c_write_one(data, setup_reg[i].addr, setup_reg[i].val);
|
|
pr_info("%s W %02X %02X\n", ISG5320A_TAG, setup_reg[i].addr,
|
|
setup_reg[i].val);
|
|
isg5320a_i2c_read(data, setup_reg[i].addr, &val, 1);
|
|
pr_info("%s %02X %02X\n", ISG5320A_TAG, setup_reg[i].addr, val);
|
|
}
|
|
}
|
|
|
|
if (data->normal_th > 0) {
|
|
buf[0] = (data->normal_th >> 8) & 0xFF;
|
|
buf[1] = data->normal_th & 0xFF;
|
|
|
|
isg5320a_i2c_write(data, ISG5320A_B_PROXCTL3_REG, buf, 2);
|
|
}
|
|
ret = isg5320a_i2c_read(data, ISG5320A_DIGITAL_ACC_REG, &val, 1);
|
|
if (ret < 0)
|
|
pr_err("%s fail to read DIGITAL ACC(%d)\n", ISG5320A_TAG, ret);
|
|
else
|
|
data->cfcal_th = ISG5320A_RESET_CONDITION * val / 8;
|
|
|
|
data->initialized = ON;
|
|
}
|
|
|
|
static void isg5320a_set_debug_work(struct isg5320a_data *data, bool enable,
|
|
unsigned int delay_ms)
|
|
{
|
|
if (enable == ON) {
|
|
data->debug_cnt = 0;
|
|
schedule_delayed_work(&data->debug_work, msecs_to_jiffies(delay_ms));
|
|
schedule_delayed_work(&data->cal_work, msecs_to_jiffies(delay_ms));
|
|
} else {
|
|
cancel_delayed_work_sync(&data->debug_work);
|
|
cancel_delayed_work_sync(&data->cal_work);
|
|
}
|
|
}
|
|
|
|
static void isg5320a_set_enable(struct isg5320a_data *data, int enable)
|
|
{
|
|
u8 state;
|
|
int ret = 0;
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
if (data->enable == enable) {
|
|
pr_info("%s - already enabled\n", ISG5320A_TAG);
|
|
return;
|
|
}
|
|
|
|
if (enable == ON) {
|
|
pr_info("%s %s - enable\n", ISG5320A_TAG, __func__);
|
|
|
|
data->diff_avg = 0;
|
|
data->diff_cnt = 0;
|
|
data->cdc_avg = 0;
|
|
|
|
ret = isg5320a_i2c_read(data, ISG5320A_IRQSTS_REG, &state, 1);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
isg5320a_get_raw_data(data, true);
|
|
|
|
if (data->skip_data == true) {
|
|
input_report_rel(data->input_dev, REL_MISC, 2);
|
|
} else if (state & (1 << ISG5320A_PROX_STATE)) {
|
|
data->state = CLOSE;
|
|
input_report_rel(data->input_dev, REL_MISC, 1);
|
|
} else {
|
|
data->state = FAR;
|
|
input_report_rel(data->input_dev, REL_MISC, 2);
|
|
}
|
|
input_sync(data->input_dev);
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_IRQSRC_REG, &state, 1);
|
|
isg5320a_i2c_write_one(data, ISG5320A_IRQFUNC_REG, ISG5320A_IRQ_ENABLE);
|
|
|
|
enable_irq(data->client->irq);
|
|
enable_irq_wake(data->client->irq);
|
|
} else {
|
|
pr_info("%s %s - disable\n", ISG5320A_TAG, __func__);
|
|
|
|
isg5320a_i2c_write_one(data, ISG5320A_IRQFUNC_REG, ISG5320A_IRQ_DISABLE);
|
|
|
|
disable_irq(data->client->irq);
|
|
disable_irq_wake(data->client->irq);
|
|
}
|
|
|
|
data->enable = enable;
|
|
}
|
|
|
|
static int isg5320a_set_mode(struct isg5320a_data *data, unsigned char mode)
|
|
{
|
|
int ret = -EINVAL;
|
|
u8 state;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_IRQSRC_REG, &state, 1);
|
|
|
|
if (mode == ISG5320A_MODE_SLEEP) {
|
|
isg5320a_i2c_write_one(data, ISG5320A_SCANCTRL1_REG,
|
|
ISG5320A_SCAN_STOP);
|
|
isg5320a_i2c_write_one(data, ISG5320A_OSCCON_REG, ISG5320A_OSC_SLEEP);
|
|
isg5320a_i2c_write_one(data, ISG5320A_BS_ON_WD_REG, ISG5320A_BS_WD_OFF);
|
|
} else if (mode == ISG5320A_MODE_NORMAL) {
|
|
isg5320a_i2c_write_one(data, ISG5320A_BS_ON_WD_REG, ISG5320A_BS_WD_ON);
|
|
isg5320a_force_calibration(data, false);
|
|
}
|
|
|
|
pr_info("%s %s - change the mode : %u\n", ISG5320A_TAG, __func__, mode);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t isg5320a_name_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
pr_info("%s %s%s\n", ISG5320A_TAG, __func__, DEVICE_NAME);
|
|
|
|
return sprintf(buf, "%s\n", DEVICE_NAME);
|
|
}
|
|
|
|
static ssize_t isg5320a_vendor_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
pr_info("%s %s%s\n", ISG5320A_TAG, __func__, VENDOR_NAME);
|
|
|
|
return sprintf(buf, "%s\n", VENDOR_NAME);
|
|
}
|
|
|
|
static ssize_t isg5320a_mode_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "1\n");
|
|
}
|
|
|
|
static ssize_t isg5320a_acal_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "2,0,0\n");
|
|
}
|
|
|
|
static ssize_t isg5320a_manual_acal_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
|
|
|
|
return sprintf(buf, "OK\n");
|
|
}
|
|
|
|
static ssize_t isg5320a_onoff_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
u8 val;
|
|
int ret;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
ret = kstrtou8(buf, 2, &val);
|
|
if (ret) {
|
|
pr_err("%s invalid argument\n", ISG5320A_TAG);
|
|
return ret;
|
|
}
|
|
|
|
if (val == 0) {
|
|
data->skip_data = true;
|
|
if (data->enable == ON) {
|
|
data->state = FAR;
|
|
input_report_rel(data->input_dev, REL_MISC, 2);
|
|
input_sync(data->input_dev);
|
|
}
|
|
} else {
|
|
data->skip_data = false;
|
|
}
|
|
|
|
pr_info("%s %d\n", ISG5320A_TAG, (int)val);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t isg5320a_onoff_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
return sprintf(buf, "%u\n", !data->skip_data);
|
|
}
|
|
|
|
static ssize_t isg5320a_sw_reset_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
isg5320a_force_calibration(data, true);
|
|
msleep(300);
|
|
isg5320a_get_raw_data(data, true);
|
|
|
|
return sprintf(buf, "%d\n", 0);
|
|
}
|
|
|
|
static ssize_t isg5320a_normal_threshold_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
int val = 0;
|
|
u8 buf8[2];
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
sscanf(buf, "%d", &val);
|
|
|
|
if (val < 0) {
|
|
pr_err("%s invalid argument\n", ISG5320A_TAG);
|
|
return size;
|
|
}
|
|
|
|
pr_info("%s change threshold(%d->%d)\n", ISG5320A_TAG, data->normal_th,
|
|
val);
|
|
|
|
data->normal_th = val;
|
|
|
|
buf8[0] = (data->normal_th >> 8) & 0xFF;
|
|
buf8[1] = data->normal_th & 0xFF;
|
|
|
|
isg5320a_i2c_write(data, ISG5320A_B_PROXCTL3_REG, buf8, 2);
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t isg5320a_normal_threshold_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
u32 threshold = 0;
|
|
u32 close_hyst = 0;
|
|
u32 far_hyst = 0;
|
|
u8 buf8[6];
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_B_PROXCTL3_REG, buf8, sizeof(buf8));
|
|
|
|
threshold = ((u32)buf8[0] << 8) | (u32)buf8[1];
|
|
close_hyst = ((u32)buf8[2] << 8) | (u32)buf8[3];
|
|
far_hyst = ((u32)buf8[4] << 8) | (u32)buf8[5];
|
|
|
|
return sprintf(buf, "%d,%d\n", threshold + close_hyst,
|
|
threshold - far_hyst);
|
|
}
|
|
|
|
|
|
static ssize_t isg5320a_raw_data_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
isg5320a_get_raw_data(data, true);
|
|
if (data->diff_cnt == 0) {
|
|
data->diff_sum = data->diff;
|
|
data->cdc_sum = data->cdc;
|
|
} else {
|
|
data->diff_sum += data->diff;
|
|
data->cdc_sum += data->cdc;
|
|
}
|
|
|
|
if (++data->diff_cnt >= ISG5320A_DIFF_AVR_CNT) {
|
|
data->diff_avg = data->diff_sum / ISG5320A_DIFF_AVR_CNT;
|
|
data->cdc_avg = data->cdc_sum / ISG5320A_DIFF_AVR_CNT;
|
|
data->diff_cnt = 0;
|
|
}
|
|
|
|
return sprintf(buf, "%d%02d,%d,%d,%d,%d\n", (data->fine_coarse & 0xFF),
|
|
((data->fine_coarse >> 8) & 0x3F), data->cdc,
|
|
data->fine_coarse, data->diff, data->base);
|
|
}
|
|
|
|
static ssize_t isg5320a_debug_raw_data_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int ret = 0;
|
|
u8 buff[10];
|
|
u16 temp;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
mutex_lock(&data->lock);
|
|
ret = isg5320a_i2c_read(data, ISG5320A_CDC16_A_H_REG, buff, sizeof(buff));
|
|
mutex_unlock(&data->lock);
|
|
if (ret < 0) {
|
|
pr_info("%s fail to get data\n", ISG5320A_TAG);
|
|
} else {
|
|
temp = ((u32)buff[0] << 8) | (u32)buff[1];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->debug_cdc[0] = temp;
|
|
|
|
temp = ((u32)buff[2] << 8) | (u32)buff[3];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->debug_base[0] = temp;
|
|
data->debug_diff[0] =
|
|
(s32)data->debug_cdc[0] - (s32)data->debug_base[0];
|
|
|
|
temp = ((u32)buff[6] << 8) | (u32)buff[7];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->debug_cdc[1] = temp;
|
|
|
|
temp = ((u32)buff[8] << 8) | (u32)buff[9];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->debug_base[1] = temp;
|
|
data->debug_diff[1] =
|
|
(s32)data->debug_cdc[1] - (s32)data->debug_base[1];
|
|
|
|
temp = ((u32)buff[4] << 8) | (u32)buff[5];
|
|
if ((temp != 0) && (temp != 0xFFFF))
|
|
data->debug_cdc[2] = temp;
|
|
data->debug_diff[2] =
|
|
(s32)data->debug_cdc[2] - (s32)data->debug_base[1];
|
|
}
|
|
|
|
return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d\n", data->debug_cdc[0],
|
|
data->debug_diff[0], data->debug_base[0], data->debug_cdc[1],
|
|
data->debug_diff[1], data->debug_base[1], data->debug_cdc[2],
|
|
data->debug_diff[2], data->debug_base[1]);
|
|
}
|
|
|
|
static ssize_t isg5320a_debug_data_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
return sprintf(buf, "%d,%d,%d\n", data->cdc, data->base, data->diff);
|
|
}
|
|
|
|
static ssize_t isg5320a_diff_avg_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
return sprintf(buf, "%d\n", data->diff_avg);
|
|
}
|
|
|
|
static ssize_t isg5320a_cdc_avg_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", data->cdc_avg);
|
|
}
|
|
|
|
static ssize_t isg5320a_ch_state_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int count;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
if (data->skip_data == true)
|
|
count = snprintf(buf, PAGE_SIZE, "%d,%d\n", NONE_ENABLE, NONE_ENABLE);
|
|
else if (data->enable == ON)
|
|
count = snprintf(buf, PAGE_SIZE, "%d,%d\n", data->state, NONE_ENABLE);
|
|
else
|
|
count = snprintf(buf, PAGE_SIZE, "%d,%d\n", NONE_ENABLE, NONE_ENABLE);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t isg5320a_hysteresis_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
u32 far_hyst = 0;
|
|
u8 buf8[6];
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_B_PROXCTL3_REG, buf8, sizeof(buf8));
|
|
|
|
far_hyst = ((u32)buf8[4] << 8) | (u32)buf8[5];
|
|
|
|
return sprintf(buf, "%d\n", far_hyst);
|
|
}
|
|
|
|
static ssize_t isg5320a_reg_update_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int enable_backup;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
enable_backup = data->enable;
|
|
|
|
isg5320a_reset(data);
|
|
if (enable_backup)
|
|
isg5320a_set_enable(data, OFF);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_SLEEP);
|
|
isg5320a_initialize(data);
|
|
if (enable_backup)
|
|
isg5320a_set_enable(data, ON);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_NORMAL);
|
|
|
|
return sprintf(buf, "OK\n");
|
|
}
|
|
|
|
#define DIRECT_CMD_WRITE 'w'
|
|
#define DIRECT_CMD_READ 'r'
|
|
#define DIRECT_BUF_COUNT 16
|
|
static ssize_t isg5320a_direct_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
int ret = -EPERM;
|
|
u32 tmp1, tmp2;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
direct_info *direct = (direct_info *)&data->direct;
|
|
|
|
sscanf(buf, "%c %x %x", &direct->cmd, &tmp1, &tmp2);
|
|
|
|
direct->addr = tmp1;
|
|
direct->val = tmp2;
|
|
|
|
pr_info("%s direct cmd: %c, addr: %x, val: %x\n", ISG5320A_TAG, direct->cmd,
|
|
direct->addr, direct->val);
|
|
|
|
if ((direct->cmd != DIRECT_CMD_WRITE) && (direct->cmd != DIRECT_CMD_READ)) {
|
|
pr_err("%s direct cmd is not correct!\n", ISG5320A_TAG);
|
|
return size;
|
|
}
|
|
|
|
if (direct->cmd == DIRECT_CMD_WRITE) {
|
|
ret = isg5320a_i2c_write_one(data, direct->addr, direct->val);
|
|
if (ret < 0)
|
|
pr_err("%s direct write fail\n", ISG5320A_TAG);
|
|
else
|
|
pr_info("%s direct write addr: %x, val: %x\n", ISG5320A_TAG,
|
|
direct->addr, direct->val);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t isg5320a_direct_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int i, count = 0;
|
|
int ret = 0;
|
|
int len;
|
|
u8 addr;
|
|
const int msg_len = 256;
|
|
char msg[msg_len];
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
direct_info *direct = (direct_info *)&data->direct;
|
|
u8 buf8[DIRECT_BUF_COUNT] = {0,};
|
|
int max_len = DIRECT_BUF_COUNT;
|
|
|
|
if (direct->cmd != DIRECT_CMD_READ)
|
|
return sprintf(buf, "ex) echo r addr len size(display) > direct\n");
|
|
|
|
len = direct->val;
|
|
addr = direct->addr;
|
|
|
|
while (len > 0) {
|
|
if (len < max_len)
|
|
max_len = len;
|
|
|
|
ret = isg5320a_i2c_read(data, addr, buf8, max_len);
|
|
if (ret < 0) {
|
|
count = sprintf(buf, "i2c read fail\n");
|
|
break;
|
|
}
|
|
addr += max_len;
|
|
|
|
for (i = 0; i < max_len; i++) {
|
|
count += snprintf(msg, msg_len, "0x%02X ", buf8[i]);
|
|
strncat(buf, msg, msg_len);
|
|
}
|
|
count += snprintf(msg, msg_len, "\n");
|
|
strncat(buf, msg, msg_len);
|
|
|
|
len -= max_len;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t isg5320a_intr_debug_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
u32 tmp1;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
sscanf(buf, "%x %d", &tmp1, &data->intr_debug_size);
|
|
|
|
data->intr_debug_addr = tmp1;
|
|
|
|
pr_info("%s intr debug addr: 0x%x, count: %d\n", ISG5320A_TAG,
|
|
data->intr_debug_addr, data->intr_debug_size);
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t isg5320a_intr_debug_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
pr_info("%s intr debug addr: 0x%x, count: %d\n", ISG5320A_TAG,
|
|
data->intr_debug_addr, data->intr_debug_size);
|
|
|
|
return sprintf(buf, "intr debug addr: 0x%x, count: %d\n",
|
|
data->intr_debug_addr, data->intr_debug_size);
|
|
}
|
|
|
|
static ssize_t isg5320a_cp_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int ret;
|
|
u16 buff;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
ret = isg5320a_i2c_read(data, ISG5320A_COARSE_B_REG, (u8 *)&buff, 2);
|
|
if (ret < 0) {
|
|
pr_info("%s fail to get cp\n", ISG5320A_TAG);
|
|
} else {
|
|
data->fine_coarse = buff;
|
|
pr_info("%s coarse B:%04X\n", ISG5320A_TAG, data->fine_coarse);
|
|
}
|
|
|
|
return sprintf(buf, "%d%02d,0\n", (data->fine_coarse & 0xFF),
|
|
(data->fine_coarse >> 8) & 0x3F);
|
|
}
|
|
|
|
#define SCAN_INT 0x12
|
|
#define FAR_CLOSE_INT 0x0C
|
|
static ssize_t isg5320a_scan_int_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int ret;
|
|
u8 irq_con = SCAN_INT;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
ret = isg5320a_i2c_write(data, ISG5320A_IRQCON_REG, &irq_con, 1);
|
|
if (ret < 0) {
|
|
pr_err("%s fail to set scan done int\n", ISG5320A_TAG);
|
|
return sprintf(buf, "FAIL\n");
|
|
} else {
|
|
pr_info("%s set scan done int\n", ISG5320A_TAG);
|
|
return sprintf(buf, "OK\n");
|
|
}
|
|
}
|
|
|
|
static ssize_t isg5320a_far_close_int_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int ret;
|
|
u8 irq_con = FAR_CLOSE_INT;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
ret = isg5320a_i2c_write(data, ISG5320A_IRQCON_REG, &irq_con, 1);
|
|
if (ret < 0) {
|
|
pr_err("%s fail to set normal int\n", ISG5320A_TAG);
|
|
return sprintf(buf, "FAIL\n");
|
|
} else {
|
|
pr_info("%s set normal int\n", ISG5320A_TAG);
|
|
return sprintf(buf, "OK\n");
|
|
}
|
|
}
|
|
|
|
static ssize_t isg5320a_toggle_enable_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int enable;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
enable = (data->enable == OFF) ? ON : OFF;
|
|
isg5320a_set_enable(data, (int)enable);
|
|
|
|
return sprintf(buf, "%d\n", data->enable);
|
|
}
|
|
|
|
static ssize_t isg5320a_enable_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
int ret;
|
|
u8 enable;
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
int pre_enable = data->enable;
|
|
|
|
ret = kstrtou8(buf, 2, &enable);
|
|
if (ret) {
|
|
pr_err("%s invalid argument\n", ISG5320A_TAG);
|
|
return size;
|
|
}
|
|
|
|
pr_info("%s new_value=%d old_value=%d\n", ISG5320A_TAG, (int)enable,
|
|
pre_enable);
|
|
|
|
if (pre_enable == enable)
|
|
return size;
|
|
|
|
isg5320a_set_enable(data, (int)enable);
|
|
|
|
return size;
|
|
}
|
|
|
|
static ssize_t isg5320a_enable_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
return sprintf(buf, "%d\n", data->enable);
|
|
}
|
|
|
|
static ssize_t isg5320a_sampling_freq_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
int sampling_freq;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_NUM_OF_CLK, &buff, 1);
|
|
sampling_freq = (int)(4000 / ((int)buff + 1));
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%dkHz\n", sampling_freq);
|
|
}
|
|
|
|
static ssize_t isg5320a_isum_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
const char *table[16] = {
|
|
"0", "0", "0", "0", "0", "0", "0", "0", "0",
|
|
"20", "24", "28", "32", "40", "48", "64"};
|
|
u8 buff = 0;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_CHB_LSUM_TYPE_REG, &buff, 1);
|
|
buff = (buff & 0xf0) >> 4;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", table[buff]);
|
|
}
|
|
|
|
static ssize_t isg5320a_scan_period_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff[2];
|
|
int scan_period;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_WUTDATA_REG, (u8 *)&buff, sizeof(buff));
|
|
|
|
scan_period = (int)(((u16)buff[1] & 0xff) | (((u16)buff[0] & 0x3f) << 8));
|
|
if (!scan_period)
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", scan_period);
|
|
|
|
scan_period = (int)(4000 / scan_period);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", scan_period);
|
|
}
|
|
|
|
static ssize_t isg5320a_again_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
u8 temp1, temp2;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_ANALOG_GAIN, &buff, 1);
|
|
temp1 = (buff & 0x38) >> 3;
|
|
temp2 = (buff & 0x07);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d/%d\n", (int)temp2 + 1, (int)temp1 + 1);
|
|
}
|
|
|
|
static ssize_t isg5320a_cdc_up_coef_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
int coef;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_CHB_CDC_UP_COEF_REG, &buff, 1);
|
|
coef = (int)buff;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%x, %d\n", buff, coef);
|
|
}
|
|
|
|
static ssize_t isg5320a_cdc_down_coef_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
int coef;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_CHB_CDC_DN_COEF_REG, &buff, 1);
|
|
coef = (int)buff;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%x, %d\n", buff, coef);
|
|
}
|
|
|
|
static ssize_t isg5320a_temp_enable_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_TEMPERATURE_ENABLE_REG, &buff, 1);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", ((buff & 0x40) >> 6));
|
|
}
|
|
|
|
|
|
static ssize_t isg5320a_cml_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
u8 buff;
|
|
|
|
isg5320a_i2c_read(data, ISG5320A_CML_BIAS_REG, &buff, 1);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", (buff & 0x07));
|
|
}
|
|
|
|
static ssize_t isg5320a_irq_count_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
int ret = 0;
|
|
s16 max_diff_val = 0;
|
|
|
|
if (data->irq_count) {
|
|
ret = -1;
|
|
max_diff_val = data->max_diff;
|
|
} else {
|
|
max_diff_val = data->max_normal_diff;
|
|
}
|
|
|
|
pr_info("%s %s - called\n", ISG5320A_TAG, __func__);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d,%d,%d\n", ret, data->irq_count,
|
|
max_diff_val);
|
|
}
|
|
|
|
static ssize_t isg5320a_irq_count_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
u8 onoff;
|
|
int ret;
|
|
|
|
ret = kstrtou8(buf, 10, &onoff);
|
|
if (ret < 0) {
|
|
pr_err("%s invalid argument\n", ISG5320A_TAG);
|
|
return count;
|
|
}
|
|
|
|
mutex_lock(&data->lock);
|
|
|
|
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("%s invalid value %d\n", ISG5320A_TAG, onoff);
|
|
}
|
|
|
|
mutex_unlock(&data->lock);
|
|
|
|
pr_info("%s %s - %d\n", ISG5320A_TAG, __func__, onoff);
|
|
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR(name, 0444, isg5320a_name_show, NULL);
|
|
static DEVICE_ATTR(vendor, 0444, isg5320a_vendor_show, NULL);
|
|
static DEVICE_ATTR(mode, 0444, isg5320a_mode_show, NULL);
|
|
static DEVICE_ATTR(manual_acal, 0444, isg5320a_manual_acal_show, NULL);
|
|
static DEVICE_ATTR(calibration, 0444, isg5320a_acal_show, NULL);
|
|
static DEVICE_ATTR(onoff, 0664, isg5320a_onoff_show, isg5320a_onoff_store);
|
|
static DEVICE_ATTR(reset, 0444, isg5320a_sw_reset_show, NULL);
|
|
static DEVICE_ATTR(normal_threshold, 0664, isg5320a_normal_threshold_show,
|
|
isg5320a_normal_threshold_store);
|
|
static DEVICE_ATTR(raw_data, 0444, isg5320a_raw_data_show, NULL);
|
|
static DEVICE_ATTR(debug_raw_data, 0444, isg5320a_debug_raw_data_show, NULL);
|
|
static DEVICE_ATTR(debug_data, 0444, isg5320a_debug_data_show, NULL);
|
|
static DEVICE_ATTR(diff_avg, 0444, isg5320a_diff_avg_show, NULL);
|
|
static DEVICE_ATTR(cdc_avg, 0444, isg5320a_cdc_avg_show, NULL);
|
|
static DEVICE_ATTR(useful_avg, 0444, isg5320a_cdc_avg_show, NULL);
|
|
static DEVICE_ATTR(ch_state, 0444, isg5320a_ch_state_show, NULL);
|
|
static DEVICE_ATTR(hysteresis, 0444, isg5320a_hysteresis_show, NULL);
|
|
static DEVICE_ATTR(reg_update, 0444, isg5320a_reg_update_show, NULL);
|
|
static DEVICE_ATTR(direct, 0664, isg5320a_direct_show, isg5320a_direct_store);
|
|
static DEVICE_ATTR(intr_debug, 0664, isg5320a_intr_debug_show, isg5320a_intr_debug_store);
|
|
static DEVICE_ATTR(cp, 0444, isg5320a_cp_show, NULL);
|
|
static DEVICE_ATTR(scan_int, 0444, isg5320a_scan_int_show, NULL);
|
|
static DEVICE_ATTR(far_close_int, 0444, isg5320a_far_close_int_show, NULL);
|
|
static DEVICE_ATTR(toggle_enable, 0444, isg5320a_toggle_enable_show, NULL);
|
|
static DEVICE_ATTR(sampling_freq, 0444, isg5320a_sampling_freq_show, NULL);
|
|
static DEVICE_ATTR(isum, 0444, isg5320a_isum_show, NULL);
|
|
static DEVICE_ATTR(scan_period, 0444, isg5320a_scan_period_show, NULL);
|
|
static DEVICE_ATTR(analog_gain, 0444, isg5320a_again_show, NULL);
|
|
static DEVICE_ATTR(cdc_up, 0444, isg5320a_cdc_down_coef_show, NULL);
|
|
static DEVICE_ATTR(cdc_down, 0444, isg5320a_cdc_up_coef_show, NULL);
|
|
static DEVICE_ATTR(temp_enable, 0444, isg5320a_temp_enable_show, NULL);
|
|
static DEVICE_ATTR(cml, 0444, isg5320a_cml_show, NULL);
|
|
static DEVICE_ATTR(irq_count, 0664, isg5320a_irq_count_show,
|
|
isg5320a_irq_count_store);
|
|
|
|
static struct device_attribute *sensor_attrs[] = {
|
|
&dev_attr_name,
|
|
&dev_attr_vendor,
|
|
&dev_attr_mode,
|
|
&dev_attr_manual_acal,
|
|
&dev_attr_calibration,
|
|
&dev_attr_onoff,
|
|
&dev_attr_reset,
|
|
&dev_attr_normal_threshold,
|
|
&dev_attr_raw_data,
|
|
&dev_attr_debug_raw_data,
|
|
&dev_attr_debug_data,
|
|
&dev_attr_diff_avg,
|
|
&dev_attr_useful_avg,
|
|
&dev_attr_cdc_avg,
|
|
&dev_attr_ch_state,
|
|
&dev_attr_hysteresis,
|
|
&dev_attr_reg_update,
|
|
&dev_attr_direct,
|
|
&dev_attr_intr_debug,
|
|
&dev_attr_cp,
|
|
&dev_attr_scan_int,
|
|
&dev_attr_far_close_int,
|
|
&dev_attr_toggle_enable,
|
|
&dev_attr_sampling_freq,
|
|
&dev_attr_isum,
|
|
&dev_attr_scan_period,
|
|
&dev_attr_analog_gain,
|
|
&dev_attr_cdc_up,
|
|
&dev_attr_cdc_down,
|
|
&dev_attr_temp_enable,
|
|
&dev_attr_cml,
|
|
&dev_attr_irq_count,
|
|
NULL,
|
|
};
|
|
|
|
static DEVICE_ATTR(enable, 0664, isg5320a_enable_show, isg5320a_enable_store);
|
|
|
|
static struct attribute *isg5320a_attributes[] = {
|
|
&dev_attr_enable.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group isg5320a_attribute_group = {
|
|
.attrs = isg5320a_attributes,
|
|
};
|
|
|
|
#ifdef ISG5320A_INIT_DELAYEDWORK
|
|
static void init_work_func(struct work_struct *work)
|
|
{
|
|
struct delayed_work *delayed_work = to_delayed_work(work);
|
|
struct isg5320a_data *data = container_of(delayed_work,
|
|
struct isg5320a_data, init_work);
|
|
|
|
isg5320a_initialize(data);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_NORMAL);
|
|
isg5320a_set_debug_work(data, ON, 2000);
|
|
}
|
|
#endif
|
|
|
|
static void cal_work_func(struct work_struct *work)
|
|
{
|
|
|
|
struct delayed_work *delayed_work = to_delayed_work(work);
|
|
struct isg5320a_data *data = container_of(delayed_work,
|
|
struct isg5320a_data, cal_work);
|
|
bool force_cal = false;
|
|
|
|
isg5320a_get_raw_data(data, false);
|
|
// check cfcal
|
|
if (data->cdc < data->cfcal_th) {
|
|
pr_info("%s cdc : %d, cfcal_th %d\n", ISG5320A_TAG, data->cdc,
|
|
data->cfcal_th);
|
|
isg5320a_force_calibration(data, false);
|
|
force_cal = true;
|
|
}
|
|
|
|
// check bfcal
|
|
if (data->bfcal_chk_start) {
|
|
data->bfcal_chk_count++;
|
|
if (data->bfcal_chk_count == ISG5320A_BFCAL_CHK_RDY_TIME) {
|
|
data->bfcal_chk_ready = true;
|
|
data->bfcal_chk_cdc = data->cdc;
|
|
data->bfcal_chk_diff =
|
|
data->diff / ISG5320A_BFCAL_CHK_DIFF_RATIO;
|
|
} else if (data->bfcal_chk_count > ISG5320A_BFCAL_CHK_RDY_TIME) {
|
|
if (((data->bfcal_chk_count - ISG5320A_BFCAL_CHK_RDY_TIME) %
|
|
ISG5320A_BFCAL_CHK_CYCLE_TIME) == 0) {
|
|
if (((s32)data->bfcal_chk_cdc - (s32)data->cdc) >=
|
|
data->bfcal_chk_diff) {
|
|
isg5320a_force_calibration(data, true);
|
|
force_cal = true;
|
|
data->bfcal_chk_start = false;
|
|
data->bfcal_chk_ready = false;
|
|
data->bfcal_chk_count = 0;
|
|
} else {
|
|
data->bfcal_chk_cdc = data->cdc;
|
|
data->bfcal_chk_diff =
|
|
data->diff / ISG5320A_BFCAL_CHK_DIFF_RATIO;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (force_cal)
|
|
schedule_delayed_work(&data->cal_work, msecs_to_jiffies(1000));
|
|
else
|
|
schedule_delayed_work(&data->cal_work, msecs_to_jiffies(500));
|
|
}
|
|
|
|
static void force_cal_work_func(struct work_struct *work)
|
|
{
|
|
struct isg5320a_data *data = container_of(work,
|
|
struct isg5320a_data, force_cal_work);
|
|
isg5320a_force_calibration(data, true);
|
|
}
|
|
|
|
static void debug_work_func(struct work_struct *work)
|
|
{
|
|
int ret;
|
|
struct delayed_work *delayed_work = to_delayed_work(work);
|
|
struct isg5320a_data *data = container_of(delayed_work,
|
|
struct isg5320a_data, debug_work);
|
|
|
|
if (data->hallic_detect) {
|
|
ret = check_hallic_state(HALLIC_PATH, data->hall_ic);
|
|
if (ret < 0)
|
|
pr_err("%s hallic detect fail = %d\n", ISG5320A_TAG, ret);
|
|
|
|
if (strcmp(data->hall_ic, "CLOSE") == 0) {
|
|
if (data->hall_flag) {
|
|
pr_info("%s hall IC is closed\n", ISG5320A_TAG);
|
|
isg5320a_force_calibration(data, true);
|
|
data->hall_flag = 0;
|
|
}
|
|
} else {
|
|
data->hall_flag = 1;
|
|
}
|
|
}
|
|
|
|
if (data->hallic_cert_detect) {
|
|
ret = check_hallic_state(HALLIC_CERT_PATH, data->hall_ic);
|
|
if (ret < 0)
|
|
pr_err("%s Cert hall IC detect fail = %d\n", ISG5320A_TAG, ret);
|
|
|
|
if (strcmp(data->hall_ic, "CLOSE") == 0) {
|
|
if (data->hall_cert_flag) {
|
|
pr_info("%s Cert hall IC is closed\n", ISG5320A_TAG);
|
|
isg5320a_force_calibration(data, true);
|
|
data->hall_cert_flag = 0;
|
|
}
|
|
} else {
|
|
data->hall_cert_flag = 1;
|
|
}
|
|
}
|
|
|
|
if (data->enable == ON) {
|
|
if (data->abnormal_mode) {
|
|
isg5320a_get_raw_data(data, true);
|
|
if (data->max_normal_diff < data->diff)
|
|
data->max_normal_diff = data->diff;
|
|
}
|
|
}
|
|
|
|
schedule_delayed_work(&data->debug_work, msecs_to_jiffies(2000));
|
|
}
|
|
|
|
#if (defined(CONFIG_CCIC_NOTIFIER) || defined(CONFIG_PDIC_NOTIFIER)) && defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
|
|
static int isg5320a_ccic_handle_notification(struct notifier_block *nb,
|
|
unsigned long action, void *data)
|
|
{
|
|
#if defined(CONFIG_PDIC_NOTIFIER)
|
|
PD_NOTI_USB_STATUS_TYPEDEF usb_status = *(PD_NOTI_USB_STATUS_TYPEDEF *)data;
|
|
#else
|
|
CC_NOTI_USB_STATUS_TYPEDEF usb_status = *(CC_NOTI_USB_STATUS_TYPEDEF *)data;
|
|
#endif
|
|
struct isg5320a_data *pdata = container_of(nb, struct isg5320a_data,
|
|
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->initialized == ON) {
|
|
switch (usb_status.drp) {
|
|
case USB_STATUS_NOTIFY_ATTACH_UFP:
|
|
case USB_STATUS_NOTIFY_ATTACH_DFP:
|
|
case USB_STATUS_NOTIFY_DETACH:
|
|
pr_info("%s - drp = %d attat = %d\n", ISG5320A_TAG, usb_status.drp,
|
|
usb_status.attach);
|
|
schedule_work(&pdata->force_cal_work);
|
|
break;
|
|
default:
|
|
pr_info("%s - DRP type : %d\n", ISG5320A_TAG, usb_status.drp);
|
|
break;
|
|
}
|
|
}
|
|
|
|
pre_attach = usb_status.attach;
|
|
|
|
return 0;
|
|
}
|
|
#elif defined(CONFIG_MUIC_NOTIFIER)
|
|
static int isg5320a_cpuidle_muic_notifier(struct notifier_block *nb,
|
|
unsigned long action, void *muic_data)
|
|
{
|
|
|
|
muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)muic_data;
|
|
|
|
struct isg5320a_data *data = container_of(nb, struct isg5320a_data,
|
|
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("%s TA/USB is inserted\n", ISG5320A_TAG);
|
|
else if (action == MUIC_NOTIFY_CMD_DETACH)
|
|
pr_info("%s TA/USB is removed\n", ISG5320A_TAG);
|
|
|
|
if (data->initialized == ON)
|
|
schedule_work(&pdata->force_cal_work);
|
|
else
|
|
pr_info("%s not initialized\n", ISG5320A_TAG);
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
pr_info("%s dev=%d, action=%lu\n", ISG5320A_TAG, attached_dev, action);
|
|
|
|
return NOTIFY_DONE;
|
|
}
|
|
#endif
|
|
|
|
static int isg5320a_parse_dt(struct isg5320a_data *data, struct device *dev)
|
|
{
|
|
struct device_node *node = dev->of_node;
|
|
enum of_gpio_flags flags;
|
|
int ret;
|
|
|
|
data->gpio_int = of_get_named_gpio_flags(node, "isg5320a,irq-gpio", 0,
|
|
&flags);
|
|
if (data->gpio_int < 0) {
|
|
pr_err("%s get gpio_int error\n", ISG5320A_TAG);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_info("%s gpio_int:%d\n", ISG5320A_TAG, data->gpio_int);
|
|
|
|
ret = of_property_read_u32(node, "isg5320a,hallic_detect",
|
|
&data->hallic_detect);
|
|
if (ret < 0)
|
|
data->hallic_detect = 0;
|
|
ret = of_property_read_u32(node, "isg5320a,hallic_cert_detect",
|
|
&data->hallic_cert_detect);
|
|
if (ret < 0)
|
|
data->hallic_cert_detect = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int isg5320a_gpio_init(struct isg5320a_data *data)
|
|
{
|
|
int ret = 0;
|
|
|
|
ret = gpio_request(data->gpio_int, "isg5320a_irq");
|
|
if (ret < 0) {
|
|
pr_err("%s gpio %d request failed\n", ISG5320A_TAG, data->gpio_int);
|
|
return ret;
|
|
}
|
|
|
|
ret = gpio_direction_input(data->gpio_int);
|
|
if (ret < 0) {
|
|
pr_err("%s failed to set gpio %d(%d)\n", ISG5320A_TAG, data->gpio_int,
|
|
ret);
|
|
gpio_free(data->gpio_int);
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int isg5320a_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
int ret = -ENODEV;
|
|
struct isg5320a_data *data;
|
|
struct input_dev *input_dev;
|
|
|
|
pr_info("%s ### %s probe ###\n", ISG5320A_TAG, DEVICE_NAME);
|
|
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
|
pr_err("%s i2c_check_functionality error\n", ISG5320A_TAG);
|
|
goto err;
|
|
}
|
|
|
|
data = kzalloc(sizeof(struct isg5320a_data), GFP_KERNEL);
|
|
if (!data) {
|
|
pr_err("%s failed to allocate memory\n", ISG5320A_TAG);
|
|
goto err_kzalloc;
|
|
}
|
|
|
|
ret = isg5320a_parse_dt(data, &client->dev);
|
|
if (ret) {
|
|
pr_err("%s failed to parse dt\n", ISG5320A_TAG);
|
|
goto err_parse_dt;
|
|
}
|
|
|
|
ret = isg5320a_gpio_init(data);
|
|
if (ret) {
|
|
pr_err("%s failed to init sys\n", ISG5320A_TAG);
|
|
goto err_gpio_init;
|
|
}
|
|
|
|
data->client = client;
|
|
i2c_set_clientdata(client, data);
|
|
|
|
input_dev = input_allocate_device();
|
|
if (!input_dev) {
|
|
pr_err("%s input_allocate_device failed\n", ISG5320A_TAG);
|
|
goto err_input_alloc;
|
|
}
|
|
|
|
data->dev = &client->dev;
|
|
data->input_dev = input_dev;
|
|
|
|
input_dev->name = MODULE_NAME;
|
|
input_dev->id.bustype = BUS_I2C;
|
|
|
|
input_set_capability(input_dev, EV_REL, REL_MISC);
|
|
input_set_capability(input_dev, EV_REL, REL_MAX);
|
|
input_set_drvdata(input_dev, data);
|
|
|
|
ret = isg5320a_reset(data);
|
|
if (ret < 0) {
|
|
pr_err("%s IMAGIS reset failed\n", ISG5320A_TAG);
|
|
goto err_soft_reset;
|
|
}
|
|
|
|
data->skip_data = false;
|
|
data->state = FAR;
|
|
data->enable = OFF;
|
|
data->initialized = OFF;
|
|
data->debug_cnt = 0;
|
|
data->normal_th = 0;
|
|
data->fine_coarse = 0;
|
|
data->cfcal_th = ISG5320A_RESET_CONDITION;
|
|
data->bfcal_chk_ready = false;
|
|
data->bfcal_chk_start = false;
|
|
data->bfcal_chk_count = 0;
|
|
data->hall_flag = 1;
|
|
data->hall_cert_flag = 1;
|
|
data->debug_cdc[0] = 0;
|
|
data->debug_cdc[1] = 0;
|
|
data->debug_cdc[2] = 0;
|
|
data->debug_base[0] = 0;
|
|
data->debug_base[1] = 0;
|
|
data->debug_diff[0] = 0;
|
|
data->debug_diff[1] = 0;
|
|
|
|
client->irq = gpio_to_irq(data->gpio_int);
|
|
ret = request_threaded_irq(client->irq, NULL, isg5320a_irq_thread,
|
|
IRQF_TRIGGER_FALLING | IRQF_ONESHOT, DEVICE_NAME, data);
|
|
if (ret < 0) {
|
|
pr_err("%s failed to register interrupt\n", ISG5320A_TAG);
|
|
goto err_irq;
|
|
}
|
|
disable_irq(client->irq);
|
|
mutex_init(&data->lock);
|
|
|
|
ret = input_register_device(input_dev);
|
|
if (ret) {
|
|
input_free_device(input_dev);
|
|
pr_err("%s failed to register input dev (%d)\n", ISG5320A_TAG, ret);
|
|
goto err_register_input_dev;
|
|
}
|
|
|
|
ret = sensors_create_symlink(input_dev);
|
|
if (ret < 0) {
|
|
pr_err("%s failed to create symlink (%d)\n", ISG5320A_TAG, ret);
|
|
goto err_create_symlink;
|
|
}
|
|
|
|
ret = sysfs_create_group(&input_dev->dev.kobj, &isg5320a_attribute_group);
|
|
if (ret < 0) {
|
|
pr_err("%s failed to create sysfs group (%d)\n", ISG5320A_TAG, ret);
|
|
goto err_sysfs_create_group;
|
|
}
|
|
|
|
ret = sensors_register(data->dev, data, sensor_attrs, MODULE_NAME);
|
|
if (ret) {
|
|
pr_err("%s could not register sensor(%d).\n", ISG5320A_TAG, ret);
|
|
goto err_sensor_register;
|
|
}
|
|
|
|
wake_lock_init(&data->grip_wake_lock, WAKE_LOCK_SUSPEND, "grip_wake_lock");
|
|
INIT_DELAYED_WORK(&data->debug_work, debug_work_func);
|
|
INIT_DELAYED_WORK(&data->cal_work, cal_work_func);
|
|
INIT_WORK(&data->force_cal_work, force_cal_work_func);
|
|
#ifdef ISG5320A_INIT_DELAYEDWORK
|
|
INIT_DELAYED_WORK(&data->init_work, init_work_func);
|
|
schedule_delayed_work(&data->init_work, msecs_to_jiffies(300));
|
|
#else
|
|
isg5320a_initialize(data);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_NORMAL);
|
|
isg5320a_set_debug_work(data, ON, 2000);
|
|
#endif
|
|
|
|
#if defined(CONFIG_PDIC_NOTIFIER) && defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
|
|
manager_notifier_register(&data->cpuidle_ccic_nb,
|
|
isg5320a_ccic_handle_notification,
|
|
MANAGER_NOTIFY_PDIC_SENSORHUB);
|
|
#elif defined(CONFIG_CCIC_NOTIFIER) && defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
|
|
manager_notifier_register(&data->cpuidle_ccic_nb,
|
|
isg5320a_ccic_handle_notification,
|
|
MANAGER_NOTIFY_CCIC_SENSORHUB);
|
|
#elif defined(CONFIG_MUIC_NOTIFIER)
|
|
muic_notifier_register(&data->cpuidle_muic_nb,
|
|
isg5320a_cpuidle_muic_notifier, MUIC_NOTIFY_DEV_CPUIDLE);
|
|
#endif
|
|
|
|
pr_info("%s ### IMAGIS probe done ###\n", ISG5320A_TAG);
|
|
|
|
return 0;
|
|
|
|
err_sensor_register:
|
|
sysfs_remove_group(&input_dev->dev.kobj, &isg5320a_attribute_group);
|
|
err_sysfs_create_group:
|
|
sensors_remove_symlink(input_dev);
|
|
err_create_symlink:
|
|
input_unregister_device(input_dev);
|
|
err_register_input_dev:
|
|
mutex_destroy(&data->lock);
|
|
free_irq(client->irq, data);
|
|
err_irq:
|
|
err_soft_reset:
|
|
err_input_alloc:
|
|
gpio_free(data->gpio_int);
|
|
err_gpio_init:
|
|
err_parse_dt:
|
|
kfree(data);
|
|
err_kzalloc:
|
|
err:
|
|
pr_info("%s ### IMAGIS probe failed ###\n", ISG5320A_TAG);
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
static int isg5320a_remove(struct i2c_client *client)
|
|
{
|
|
struct isg5320a_data *data = i2c_get_clientdata(client);
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
isg5320a_set_debug_work(data, OFF, 0);
|
|
if (data->enable == ON)
|
|
isg5320a_set_enable(data, OFF);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_SLEEP);
|
|
|
|
free_irq(client->irq, data);
|
|
gpio_free(data->gpio_int);
|
|
|
|
wake_lock_destroy(&data->grip_wake_lock);
|
|
sensors_unregister(data->dev, sensor_attrs);
|
|
sensors_remove_symlink(data->input_dev);
|
|
sysfs_remove_group(&data->input_dev->dev.kobj, &isg5320a_attribute_group);
|
|
input_unregister_device(data->input_dev);
|
|
mutex_destroy(&data->lock);
|
|
|
|
kfree(data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int isg5320a_suspend(struct device *dev)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
isg5320a_set_debug_work(data, OFF, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int isg5320a_resume(struct device *dev)
|
|
{
|
|
struct isg5320a_data *data = dev_get_drvdata(dev);
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
isg5320a_set_debug_work(data, ON, 1000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void isg5320a_shutdown(struct i2c_client *client)
|
|
{
|
|
struct isg5320a_data *data = i2c_get_clientdata(client);
|
|
|
|
pr_info("%s %s\n", ISG5320A_TAG, __func__);
|
|
|
|
cancel_work_sync(&data->force_cal_work);
|
|
isg5320a_set_debug_work(data, OFF, 0);
|
|
if (data->enable == ON)
|
|
isg5320a_set_enable(data, OFF);
|
|
isg5320a_set_mode(data, ISG5320A_MODE_SLEEP);
|
|
}
|
|
|
|
static const struct of_device_id isg5320a_match_table[] = {
|
|
{ .compatible = "isg5320a", },
|
|
{ },
|
|
};
|
|
|
|
static struct i2c_device_id isg5320a_id_table[] = {
|
|
{ DEVICE_NAME, 0 },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, isg5320a_id_table);
|
|
|
|
static const struct dev_pm_ops isg5320a_pm_ops = {
|
|
.suspend = isg5320a_suspend,
|
|
.resume = isg5320a_resume,
|
|
};
|
|
|
|
static struct i2c_driver isg5320a_driver = {
|
|
.driver = {
|
|
.name = DEVICE_NAME,
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = isg5320a_match_table,
|
|
.pm = &isg5320a_pm_ops,
|
|
},
|
|
.id_table = isg5320a_id_table,
|
|
.probe = isg5320a_probe,
|
|
.remove = isg5320a_remove,
|
|
.shutdown = isg5320a_shutdown,
|
|
};
|
|
|
|
static int __init isg5320a_init(void)
|
|
{
|
|
return i2c_add_driver(&isg5320a_driver);
|
|
}
|
|
|
|
static void __exit isg5320a_exit(void)
|
|
{
|
|
i2c_del_driver(&isg5320a_driver);
|
|
}
|
|
|
|
module_init(isg5320a_init);
|
|
module_exit(isg5320a_exit);
|
|
|
|
MODULE_DESCRIPTION("Imagis Grip Sensor driver");
|
|
MODULE_LICENSE("GPL");
|