static int cyttsp4_wakeup(struct cyttsp4_core_platform_data *pdata,
struct device *dev, atomic_t *ignore_irq)
{
int irq_gpio = pdata->irq_gpio;
int rc = 0;
if (ignore_irq)
atomic_set(ignore_irq, 1);
rc = gpio_direction_output(irq_gpio, 0);
if (rc < 0) {
if (ignore_irq)
atomic_set(ignore_irq, 0);
tp_log_err(
"%s: Fail set output gpio=%d\n",
__func__, irq_gpio);
} else {
udelay(2000);
rc = gpio_direction_input(irq_gpio);
if (ignore_irq)
atomic_set(ignore_irq, 0);
if (rc < 0) {
tp_log_err(
"%s: Fail set input gpio=%d\n",
__func__, irq_gpio);
}
}
tp_log_info(
"%s: WAKEUP CYTTSP gpio=%d r=%d\n", __func__,
irq_gpio, rc);
return rc;
}
/**
* tp_get_glove_func_obj - it is a common function,tp can call it to creat glove_func file node in /sys/touch_screen/
*
* @no input value
*
* This function is tp call it to creat glove_func file node in /sys/touch_screen/.
*
* The kobject of touch_glove_func_ts will be returned,notice it is static.
*/
struct kobject* tp_get_glove_func_obj(void)
{
struct kobject *properties_kobj;
properties_kobj = tp_get_touch_screen_obj();
if( NULL == properties_kobj )
{
tp_log_err("%s: Error, get kobj failed!\n", __func__);
return NULL;
}
if( NULL == touch_glove_func_ts )
{
touch_glove_func_ts = kobject_create_and_add("glove_func", properties_kobj);
if (!touch_glove_func_ts)
{
tp_log_err("%s: create glove_func kobjetct error!\n", __func__);
return NULL;
}
else
{
tp_log_debug("%s: create sys/touch_screen/glove_func successful!\n", __func__);
}
}
else
{
tp_log_debug("%s: sys/touch_screen/glove_func already exist!\n", __func__);
}
return touch_glove_func_ts;
}
/*****************************************************************
Parameters : rmi4_data
read
write
Return : ok:0, error:-1
Description : init ESD parameter
*****************************************************************/
int synaptics_dsx_esd_init(struct synaptics_rmi4_data *rmi4_data,
synaptics_read read, synaptics_write write)
{
if (NULL == rmi4_data || NULL == read || NULL == write)
{
tp_log_err("%s %d:input parameter is NULL\n", __func__, __LINE__);
return -1;
}
tp_log_debug("%s %d:synaptics esd init\n", __func__, __LINE__);
g_rmi4_data = rmi4_data;
synaptics_esd_read = read;
INIT_DELAYED_WORK(&synaptics_dsx_esd.esd_work, synaptics_esd_work);
synaptics_dsx_esd.esd_work_queue =
create_singlethread_workqueue("synaptics_esd_workqueue");
if (!synaptics_dsx_esd.esd_work_queue)
{
tp_log_err("%s %d:synaptics esd workqueue alloc failed\n", __func__, __LINE__);
return -1;
}
/* set esd check thread state */
atomic_set(&(synaptics_dsx_esd.esd_check_status), ESD_CHECK_STOPED);
atomic_set(&(synaptics_dsx_esd.irq_status), 0);
return 0;
}
void ft6x06_report_dsm_erro(struct ft6x06_ts_data * ft6x06_data, struct dsm_client * dsm_client,
int type, int err_num)
{
if(!dsm_client)
{
tp_log_err("%s %d: dsm_client is null!\n", __func__, __LINE__);
return;
}
if(dsm_client_ocuppy(dsm_client))
{
tp_log_err("%s %d: dsm buffer is busy!\n", __func__, __LINE__);
return;
}
switch(type)
{
case DSM_TP_I2C_RW_ERROR_NO:
dsm_client_record(dsm_client,"%s %d: i2c_trans_erro, rc = %d\n", __func__,__LINE__, err_num);
break;
case DSM_TP_FW_ERROR_NO:
dsm_client_record(dsm_client,"%s %d: firmware upgrade erro!\n", __func__,__LINE__);
break;
default:
break;
}
ft6x06_dsm_record_basic_info(ft6x06_data, dsm_client);
dsm_client_notify(dsm_client, type);
return;
}
/*****************************************************************
Parameters:
dev: consumer device of the power
Return: zero if succeed, otherwise a negtive value
Description : parse config from dev and init configs
*****************************************************************/
int hw_tp_power_init(struct device * dev){
int ret = 0;
struct hw_tp_power_data * pd = NULL;
if(!dev || !dev->of_node){
tp_log_err("%s#%d: dev or dev->of_node is NULL!\n",__func__,__LINE__);
return -EINVAL;
}
/* get global power data throw this func */
pd = hw_tp_get_power_data();
if (!pd) {
tp_log_err("%s#%d: get pwdata fail!\n",__func__,__LINE__);
return -ENOMEM;
} else if (pd->pw_ready){
tp_log_warning("%s#%d: power already init, so release first...\n",
__func__,__LINE__);
hw_tp_power_release();
}
/* get hw_tp_power as a root node */
pd->np = of_find_node_by_name(dev->of_node,"huawei-tp-power");
if(!pd->np){
tp_log_err("%s#%d: get hw_tp_power node failed!\n",__func__,__LINE__);
ret = -ENODEV;
goto hw_tp_power_init_exit;
}
pd->dev = dev;
/* parse power configs from dts */
ret = hw_tp_power_parse_config(pd);
if(ret) {
tp_log_info("%s#%d: %d power configs found!\n",__func__,__LINE__,ret);
} else {
tp_log_warning("%s#%d: no power configs found!\n",__func__,__LINE__);
ret = -EINVAL;
goto hw_tp_power_init_exit;
}
/* init power configs: request gpio, get regulaor and set ....*/
ret = hw_tp_power_init_config(pd);
if(ret) {
tp_log_warning("%s#%d: power configs init fail, ret=%d\n",
__func__,__LINE__,ret);
ret = -EAGAIN;
goto hw_tp_power_init_exit;
} else {
tp_log_info("%s#%d: power config init success!\n",__func__,__LINE__);
}
//hw_tp_power_off();
tp_log_info("%s#%d: power init success!\n",__func__,__LINE__);
return 0;
hw_tp_power_init_exit:
tp_log_info("%s#%d: power init fail!\n",__func__,__LINE__);
hw_tp_power_release();
return ret;
}
/* read xy_data for all current touches */
static int cyttsp4_xy_worker(struct cyttsp4_proximity_data *pd)
{
struct device *dev = &pd->ttsp->dev;
struct cyttsp4_sysinfo *si = pd->si;
u8 num_cur_rec;
u8 rep_len;
u8 rep_stat;
u8 tt_stat;
int rc = 0;
/*
* Get event data from cyttsp4 device.
* The event data includes all data
* for all active touches.
* Event data also includes button data
*/
rep_len = si->xy_mode[si->si_ofs.rep_ofs];
rep_stat = si->xy_mode[si->si_ofs.rep_ofs + 1];
tt_stat = si->xy_mode[si->si_ofs.tt_stat_ofs];
num_cur_rec = GET_NUM_TOUCH_RECORDS(tt_stat);
if (rep_len == 0 && num_cur_rec > 0) {
tp_log_err("%s: report length error rep_len=%d num_rec=%d\n",
__func__, rep_len, num_cur_rec);
goto cyttsp4_xy_worker_exit;
}
/* check any error conditions */
if (IS_BAD_PKT(rep_stat)) {
tp_log_debug("%s: Invalid buffer detected\n", __func__);
rc = 0;
goto cyttsp4_xy_worker_exit;
}
if (IS_LARGE_AREA(tt_stat))
tp_log_debug("%s: Large area detected\n", __func__);
if (num_cur_rec > si->si_ofs.max_tchs) {
tp_log_err("%s: %s (n=%d c=%d)\n", __func__,
"too many tch; set to max tch",
num_cur_rec, si->si_ofs.max_tchs);
num_cur_rec = si->si_ofs.max_tchs;
}
/* extract xy_data for all currently reported touches */
tp_log_debug("%s: extract data num_cur_rec=%d\n", __func__,
num_cur_rec);
if (num_cur_rec)
cyttsp4_get_proximity_touch(pd, num_cur_rec);
else
cyttsp4_report_proximity(pd, false);
tp_log_debug("%s: done\n", __func__);
rc = 0;
cyttsp4_xy_worker_exit:
return rc;
}
/*****************************************************************
Parameters : dev
buf
max
Return : success return 0, fail return error number
Description : i2c read function
*****************************************************************/
static int cyttsp5_i2c_read_default_nosize(struct device *dev, u8 *buf, u32 max)
{
struct i2c_client *client = to_i2c_client(dev);
struct i2c_msg msgs[2];
u8 msg_count = 1;
int rc;
u32 size;
if (!buf) {
tp_log_err("%s %d:input parameter error.\n", __func__, __LINE__);
return -EINVAL;
}
msgs[0].addr = client->addr;
msgs[0].flags = (client->flags & I2C_M_TEN) | I2C_M_RD;
msgs[0].len = 2;
msgs[0].buf = buf;
rc = i2c_transfer(client->adapter, msgs, msg_count);
if (rc < 0 || rc != msg_count) {
tp_log_err("%s %d:I2C transfer error, rc = %d, msg_count = %d\n",
__func__, __LINE__, rc, msg_count);
return (rc < 0) ? rc : -EIO;
}
size = get_unaligned_le16(&buf[0]);
if (!size || size == 2) {
tp_log_info("%s %d:get_unaligned_le16, size = %d\n", __func__,
__LINE__, size);
return 0;
}
if (size > max) {
tp_log_err("%s %d:ERROR, size = %d, max = %d\n", __func__,
__LINE__, size, max);
return -EINVAL;
}
rc = i2c_master_recv(client, buf, size);
#ifdef CONFIG_HUAWEI_DSM
if ((rc < 0) || (rc != size)) {
g_tp_dsm_info.constraints_I2C_status = rc;
cyttsp5_tp_report_dsm_err(dev, DSM_TP_I2C_RW_ERROR_NO, g_tp_dsm_info.constraints_I2C_status);
}
#endif/*CONFIG_HUAWEI_DSM*/
if (rc < 0) {
tp_log_err("%s %d:I2C read error, rc = %d\n", __func__,
__LINE__, rc);
return rc;
} else if (rc != size) {
tp_log_err("%s %d:I2C read error, rc = %d, size = %d\n",
__func__, __LINE__, rc, size);
return -EIO;
}
return 0;
}
int cyttsp4_init(struct cyttsp4_core_platform_data *pdata,
int on, struct device *dev)
{
int rst_gpio = pdata->rst_gpio;
int irq_gpio = pdata->irq_gpio;
int rc = 0;
if (on)
{
rc = gpio_request(rst_gpio, "cyttsp4");
if (rc < 0)
{
gpio_free(rst_gpio);
rc = gpio_request(rst_gpio, "cyttsp4");
}
if (rc < 0)
{
tp_log_err(
"%s: Fail request gpio=%d\n", __func__,
rst_gpio);
}
else
{
rc = gpio_direction_output(rst_gpio, 1);
if (rc < 0)
{
tp_log_err("%s: Fail set output gpio=%d\n",
__func__, rst_gpio);
gpio_free(rst_gpio);
}
else
{
/* set irq gpio as no pull */
rc = gpio_tlmm_config(GPIO_CFG(irq_gpio,0,GPIO_CFG_INPUT,
GPIO_CFG_PULL_UP,GPIO_CFG_8MA),GPIO_CFG_ENABLE);
if( rc < 0 )
{
tp_log_err("%s: Fail set gpio=%d as no pull\n", __func__, irq_gpio);
}
rc = gpio_direction_input(irq_gpio);
}
}
}
else
{
gpio_free(rst_gpio);
gpio_free(irq_gpio);
}
tp_log_info(
"%s: INIT CYTTSP RST gpio=%d and IRQ gpio=%d r=%d\n",
__func__, rst_gpio, irq_gpio, rc);
return rc;
}
static ssize_t ft6x06_tprwreg_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct i2c_client *client = container_of(dev, struct i2c_client, dev);
ssize_t num_read_chars = 0;
int retval;
long unsigned int wmreg = 0;
u8 regaddr = 0xff, regvalue = 0xff;
u8 valbuf[5] = {0};
memset(valbuf, 0, sizeof(valbuf));
mutex_lock(&g_device_mutex);
num_read_chars = count - 1;
if (num_read_chars != 2) {
if (num_read_chars != 4) {
tp_log_info("please input 2 or 4 character\n");
goto error_return;
}
}
memcpy(valbuf, buf, num_read_chars);
retval = strict_strtoul(valbuf, 16, &wmreg);
if (0 != retval) {
tp_log_err("%s() - ERROR: Could not convert the "\
"given input to a number." \
"The given input was: \"%s\"\n",
__func__, buf);
goto error_return;
}
if (2 == num_read_chars) {
/*read register*/
regaddr = wmreg;
if (ft6x06_read_reg(client, regaddr, ®value) < 0)
tp_log_err("Could not read the register(0x%02x)\n", regaddr);
else
tp_log_info("the register(0x%02x) is 0x%02x\n", regaddr, regvalue);
} else {
regaddr = wmreg >> 8;
regvalue = wmreg;
if (ft6x06_write_reg(client, regaddr, regvalue) < 0)
tp_log_err("Could not write the register(0x%02x)\n", regaddr);
else
tp_log_info("Write 0x%02x into register(0x%02x) successful\n", regvalue, regaddr);
}
error_return:
mutex_unlock(&g_device_mutex);
return count;
}
static int __init cyttsp4_debug_init(void)
{
int rc = 0;
int i, j;
/* Check for invalid or duplicate core_ids */
for (i = 0; i < num_core_ids; i++) {
if (!strlen(core_ids[i])) {
tp_log_err("%s: core_id %d is empty\n",
__func__, i+1);
return -EINVAL;
}
for (j = i+1; j < num_core_ids; j++)
if (!strcmp(core_ids[i], core_ids[j])) {
tp_log_err("%s: core_ids %d and %d are same\n",
__func__, i+1, j+1);
return -EINVAL;
}
}
for (i = 0; i < num_core_ids; i++) {
cyttsp4_debug_infos[i].name = cyttsp4_debug_name;
cyttsp4_debug_infos[i].core_id = core_ids[i];
cyttsp4_debug_infos[i].platform_data =
&_cyttsp4_debug_platform_data;
tp_log_debug("%s: Registering debug device for core_id: %s\n",
__func__, cyttsp4_debug_infos[i].core_id);
rc = cyttsp4_register_device(&cyttsp4_debug_infos[i]);
if (rc < 0) {
tp_log_err("%s: Error, failed registering device\n",
__func__);
goto fail_unregister_devices;
}
}
rc = cyttsp4_register_driver(&cyttsp4_debug_driver);
if (rc) {
tp_log_err("%s: Error, failed registering driver\n", __func__);
goto fail_unregister_devices;
}
tp_log_info("%s: Cypress TTSP Debug (Built %s) rc=%d\n",
__func__, CY_DRIVER_DATE, rc);
return 0;
fail_unregister_devices:
for (i--; i >= 0; i--) {
cyttsp4_unregister_device(cyttsp4_debug_infos[i].name,
cyttsp4_debug_infos[i].core_id);
tp_log_info("%s: Unregistering device access device for core_id: %s\n",
__func__, cyttsp4_debug_infos[i].core_id);
}
return rc;
}
static int cyttsp4_setup_input_device_and_sysfs(struct cyttsp4_device *ttsp)
{
struct device *dev = &ttsp->dev;
struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev);
int signal = CY_IGNORE_VALUE;
int min, max;
int i;
int rc;
rc = device_create_file(dev, &dev_attr_enable);
if (rc) {
tp_log_err("%s: Error, could not create enable\n", __func__);
goto exit;
}
tp_log_debug("%s: Initialize event signals\n", __func__);
__set_bit(EV_ABS, pd->input->evbit);
for (i = 0; i < (pd->pdata->frmwrk->size / CY_NUM_ABS_SET); i++) {
signal = pd->pdata->frmwrk->abs
[(i * CY_NUM_ABS_SET) + CY_SIGNAL_OST];
if (signal != CY_IGNORE_VALUE) {
min = pd->pdata->frmwrk->abs
[(i * CY_NUM_ABS_SET) + CY_MIN_OST];
max = pd->pdata->frmwrk->abs
[(i * CY_NUM_ABS_SET) + CY_MAX_OST];
input_set_abs_params(pd->input, signal, min, max,
pd->pdata->frmwrk->abs
[(i * CY_NUM_ABS_SET) +
CY_FUZZ_OST],
pd->pdata->frmwrk->
abs[(i * CY_NUM_ABS_SET) +
CY_FLAT_OST]);
}
}
rc = input_register_device(pd->input);
if (rc) {
tp_log_err("%s: Error, failed register input device r=%d\n",
__func__, rc);
goto unregister_enable;
}
pd->input_device_registered = true;
return rc;
unregister_enable:
device_remove_file(dev, &dev_attr_enable);
exit:
return rc;
}
void hw_tp_power_off(void) {
int ret = 0;
struct hw_tp_power_data * pd = NULL;
struct hw_tp_power_node * pn =NULL;
pd = hw_tp_get_power_data();
if(!pd) {
tp_log_err("%s#%d: get power data fail!\n",__func__,__LINE__);
return;
}
tp_log_info("%s#%d: tp_power_count=%d, tp_power_ready=%d\n",
__func__,__LINE__,pwdata->pw_cnt,pwdata->pw_ready);
pn = pd->pnode_list;
while(pn) {
if (pn->is_initialized) {
tp_log_info("%s#%d: begin to power off %s\n",
__func__,__LINE__,pn->power_name);
switch (pn->power_type) {
case GPIO_H_SUPPLY:
gpio_set_value(pn->power_gpio,0);
break;
case GPIO_L_SUPPLY:
gpio_set_value(pn->power_gpio,1);
break;
case PMU_SUPPLY:
ret = regulator_disable(pn->preg);
if(ret) {
tp_log_err("%s#%d: disable of %s fail!\n",
__func__,__LINE__,pn->power_name);
}
break;
default:
tp_log_warning("%s#%d: invalid type: %s-%d\n",
__func__,__LINE__,pn->power_name,pn->power_type);
break;
}
if(pn->power_dlay) {
mdelay(pn->power_dlay);
}
} else {
tp_log_err("%s#%d: %s is not initialized!\n",
__func__,__LINE__,pn->power_name);
}
pn = pn->next;
}
tp_log_info("%s#%d: power_on done!\n",__func__,__LINE__);
return;
}
void hw_tp_power_get_info(char * buf, ssize_t len) {
struct hw_tp_power_data * pd = NULL;
struct hw_tp_power_node * pn =NULL;
char str_tmp[MAX_POWER_TMP_STR_LEN] = {0};
ssize_t size = 0;
pd = hw_tp_get_power_data();
if(!pd) {
tp_log_err("%s#%d: get power data fail!\n",__func__,__LINE__);
return;
}
pn = pd->pnode_list;
while(pn) {
snprintf(str_tmp,sizeof(str_tmp),
"power-name=%s; power-type=%d; power-gpio=%d; power-volt=%d; "
"gpio-value=%d; is-initialized = %d; ",
pn->power_name, pn->power_type, pn->power_gpio, pn->power_volt,
gpio_get_value(pn->power_gpio), pn->is_initialized);
strncat(buf,str_tmp, len-size);
size += strlen(str_tmp);
if(pn->preg) {
snprintf(str_tmp,sizeof(str_tmp),
"power-reg-enable=%d; power-reg-value=%d\n",
regulator_get_voltage(pn->preg), pn->power_volt);
strncat(buf,str_tmp, len-size);
size += strlen(str_tmp);
} else {
strncat(buf,"\n",1);
size++;
}
pn = pn->next;
}
}
int nvt_flash_read(struct file *file, char __user *buff, size_t count, loff_t *offp)
{
struct i2c_msg msgs[2];
char *str;
int ret = -1;
int retries = 0;
file->private_data = (uint8_t *)kmalloc(64, GFP_KERNEL);
str = file->private_data;
if(copy_from_user(str, buff, count)){
return -EFAULT;
}
msgs[0].flags = !I2C_M_RD;
msgs[0].addr = str[0];
msgs[0].len = 1;
msgs[0].buf = &str[2];
msgs[1].flags = I2C_M_RD;
msgs[1].addr = str[0];
msgs[1].len = str[1]-1;
msgs[1].buf = &str[3];
while(retries < 20)
{
ret = i2c_transfer(ts->client->adapter, msgs, 2);
if(ret == 2){
break;
}else{
tp_log_err("%s line%d: read error %d\n",__func__,__LINE__, retries);
}
retries++;
}
ret=copy_to_user(buff, str, count);
return ret;
}
static int cyttsp4_debug_release(struct cyttsp4_device *ttsp)
{
struct device *dev = &ttsp->dev;
struct cyttsp4_debug_data *dd = dev_get_drvdata(dev);
int rc = 0;
tp_log_debug( "%s\n", __func__);
if (dev_get_drvdata(&ttsp->core->dev) == NULL) {
tp_log_err( "%s: Unable to un-subscribe attention\n",
__func__);
goto cyttsp4_debug_release_exit;
}
/* Unsubscribe from attentions */
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_IRQ,
cyttsp4_debug_op_attention, CY_MODE_OPERATIONAL);
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_IRQ,
cyttsp4_debug_cat_attention, CY_MODE_CAT);
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_STARTUP,
cyttsp4_debug_startup_attention, 0);
cyttsp4_debug_release_exit:
pm_runtime_suspend(dev);
pm_runtime_disable(dev);
device_remove_file(dev, &dev_attr_int_count);
dev_set_drvdata(dev, NULL);
kfree(dd);
return rc;
}
/*****************************************************************
Parameters : work
Return :
Description : check if is running
*****************************************************************/
static void synaptics_esd_work(struct work_struct *work)
{
int i = 0;
int ret = 0;
unsigned char data = 0x00;
tp_log_debug("%s %d:synaptics esd check is working\n", __func__, __LINE__);
/* if irq is be handled, cancle esd check */
ret = atomic_read(&(synaptics_dsx_esd.irq_status));
if (ret != 0)
{
tp_log_err("%s %d:synaptics ic is handle irq, count = %d.\n",
__func__, __LINE__, ret);
goto exit;
}
/* read 3 times, if success, ic is working, if all 3 times read
fail, ic is dead */
for (i = 0; i < SYNAPTICS_ESD_RETRY_TIMES; i++)
{
ret = synaptics_esd_read(g_rmi4_data, SYNAPTICS_STATUS_REG,
&data, sizeof(data));
if (ret > 0)
{
break;
}
}
if (ret <= 0 && i == SYNAPTICS_ESD_RETRY_TIMES)
{
tp_log_err("%s %d:synaptics ic is dead\n", __func__, __LINE__);
#ifdef CONFIG_HUAWEI_DSM
synp_tp_report_dsm_err(DSM_TP_ESD_ERROR_NO, ret);
#endif/*CONFIG_HUAWEI_DSM*/
synaptics_dsx_hardware_reset(g_rmi4_data);
}
else
{
tp_log_info("%s %d:synaptics ic is working\n", __func__, __LINE__);
}
exit:
tp_log_debug("%s %d:synaptics data = %d\n", __func__, __LINE__, data);
queue_delayed_work(synaptics_dsx_esd.esd_work_queue, &synaptics_dsx_esd.esd_work, msecs_to_jiffies(SYNAPTICS_ESD_CHECK_TIME));
}
static int _cyttsp4_proximity_enable(struct cyttsp4_proximity_data *pd)
{
struct cyttsp4_device *ttsp = pd->ttsp;
struct device *dev = &ttsp->dev;
int rc = 0;
tp_log_debug("%s\n", __func__);
/* We use pm_runtime_get_sync to activate
* the core device until it is disabled back
*/
pm_runtime_get_sync(dev);
rc = cyttsp4_request_exclusive(ttsp,
CY_PROXIMITY_REQUEST_EXCLUSIVE_TIMEOUT);
if (rc < 0) {
tp_log_err("%s: Error on request exclusive r=%d\n",
__func__, rc);
goto exit;
}
rc = cyttsp4_request_enable_scan_type(ttsp, CY_ST_PROXIMITY);
if (rc < 0) {
tp_log_err
("%s: Error on request enable proximity scantype r=%d\n",
__func__, rc);
goto exit_release;
}
tp_log_debug("%s: setup subscriptions\n", __func__);
/* set up touch call back */
cyttsp4_subscribe_attention(ttsp, CY_ATTEN_IRQ,
cyttsp4_proximity_attention,
CY_MODE_OPERATIONAL);
/* set up startup call back */
cyttsp4_subscribe_attention(ttsp, CY_ATTEN_STARTUP,
cyttsp4_startup_attention, 0);
exit_release:
cyttsp4_release_exclusive(ttsp);
exit:
return rc;
}
static ssize_t cyttsp4_proximity_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, u32 size)
{
struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev);
unsigned long value;
int rc;
rc = kstrtoul(buf, 10, &value);
if (rc < 0 || (value != 0 && value != 1)) {
tp_log_err("%s: Invalid value\n", __func__);
return -EINVAL;
}
mutex_lock(&pd->sysfs_lock);
if (value) {
if (pd->enable_count++) {
tp_log_debug("%s: '%s' already enabled\n", __func__,
pd->ttsp->name);
} else {
rc = _cyttsp4_proximity_enable(pd);
if (rc)
pd->enable_count--;
}
} else {
if (--pd->enable_count) {
if (pd->enable_count < 0) {
tp_log_err("%s: '%s' unbalanced disable\n",
__func__, pd->ttsp->name);
pd->enable_count = 0;
}
} else {
rc = _cyttsp4_proximity_disable(pd, false);
if (rc)
pd->enable_count++;
}
}
mutex_unlock(&pd->sysfs_lock);
if (rc)
return rc;
return size;
}
static int _cyttsp4_proximity_disable(struct cyttsp4_proximity_data *pd,
bool force)
{
struct cyttsp4_device *ttsp = pd->ttsp;
struct device *dev = &ttsp->dev;
int rc = 0;
tp_log_debug("%s\n", __func__);
rc = cyttsp4_request_exclusive(ttsp,
CY_PROXIMITY_REQUEST_EXCLUSIVE_TIMEOUT);
if (rc < 0) {
tp_log_err("%s: Error on request exclusive r=%d\n",
__func__, rc);
goto exit;
}
rc = cyttsp4_request_disable_scan_type(ttsp, CY_ST_PROXIMITY);
if (rc < 0) {
tp_log_err("%s: Error on request disable proximity scan r=%d\n",
__func__, rc);
goto exit_release;
}
exit_release:
cyttsp4_release_exclusive(ttsp);
exit:
if (!rc || force) {
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_IRQ,
cyttsp4_proximity_attention,
CY_MODE_OPERATIONAL);
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_STARTUP,
cyttsp4_startup_attention, 0);
pm_runtime_put(dev);
}
return rc;
}
/*****************************************************************
Parameters : dev
write_len
write_buf
read_buf
Return :
Description :
*****************************************************************/
static int cyttsp5_i2c_write_read_specific(struct device *dev, u8 write_len,
u8 *write_buf, u8 *read_buf)
{
struct i2c_client *client = to_i2c_client(dev);
struct i2c_msg msgs[2];
u8 msg_count = 1;
int rc;
if (!write_buf || !write_len) {
tp_log_err("%s %d:input parameter error.\n", __func__, __LINE__);
return -EINVAL;
}
msgs[0].addr = client->addr;
msgs[0].flags = client->flags & I2C_M_TEN;
msgs[0].len = write_len;
msgs[0].buf = write_buf;
rc = i2c_transfer(client->adapter, msgs, msg_count);
if (rc < 0 || rc != msg_count) {
#ifdef CONFIG_HUAWEI_DSM
g_tp_dsm_info.constraints_I2C_status = rc;
cyttsp5_tp_report_dsm_err(dev, DSM_TP_I2C_RW_ERROR_NO, g_tp_dsm_info.constraints_I2C_status);
#endif/*CONFIG_HUAWEI_DSM*/
tp_log_err("%s %d:I2C transfer error, rc = %d\n", __func__, __LINE__, rc);
return (rc < 0) ? rc : -EIO;
}
rc = 0;
if (read_buf) {
rc = cyttsp5_i2c_read_default_nosize(dev, read_buf,
CY_I2C_DATA_SIZE);
if (rc) {
tp_log_err("%s %d:I2C read error, rc = %d\n", __func__, __LINE__, rc);
}
}
return rc;
}
static int __init cyttsp5_i2c_init(void)
{
int rc = i2c_add_driver(&cyttsp5_i2c_driver);
if (rc) {
tp_log_err("%s %d: Cypress v5 I2C Driver add fail, rc = %d.\n",
__func__, __LINE__, rc);
} else {
tp_log_info("%s %d: Cypress TTSP v5 I2C Driver add success.\n",
__func__, __LINE__, rc);
}
return rc;
}
size_t ft6x06_dsm_record_basic_info(struct ft6x06_ts_data * ft6x06_data, struct dsm_client * dsm_client)
{
ssize_t size = 0;
ssize_t total_size = 0;
if(!ft6x06_data)
{
tp_log_err("%s %d: ft6x06_data is null!\n", __func__, __LINE__);
return -1;
}
if(!dsm_client)
{
tp_log_err("%s %d: dsm_client is null!\n", __func__, __LINE__);
return -1;
}
/* power status: mode, enable, voltage*/
size = dsm_client_record(dsm_client,
"[vbus power] mode:%d, enable:%d, vol:%d\n"
"[vdd power] mode:%d, enable:%d, vol:%d\n",
regulator_get_mode(vbus_focaltech),
regulator_is_enabled(vbus_focaltech),
regulator_get_voltage(vbus_focaltech),
regulator_get_mode(vdd_focaltech),
regulator_is_enabled(vdd_focaltech),
regulator_get_voltage(vdd_focaltech));
total_size += size;
/* gpio status: irq, reset*/
size =dsm_client_record(dsm_client,
"[irq gpio] num:%d, irq gpio status:%d\n"
"[reset gpio] num:%d, reset gpio status:%d\n",
ft6x06_data->pdata->irq, gpio_get_value(ft6x06_data->pdata->reset),
ft6x06_data->pdata->reset, gpio_get_value(ft6x06_data->pdata->reset));
total_size += size;
return total_size;
}
/*****************************************************************
Parameters : void
Return :
Description : suspend esd check
*****************************************************************/
int synaptics_dsx_esd_stop(void)
{
int ret = 0;
tp_log_err("%s %d:stop synaptics esd check\n", __func__, __LINE__);
if (ESD_CHECK_START == atomic_read(&synaptics_dsx_esd.esd_check_status))
{
ret = cancel_delayed_work(&synaptics_dsx_esd.esd_work);
if (!ret) {
tp_log_err("%s %d:stop synaptics esd fail.\n", __func__, __LINE__);
return -1;
}
flush_delayed_work(&synaptics_dsx_esd.esd_work);
atomic_set(&(synaptics_dsx_esd.esd_check_status), ESD_CHECK_STOPED);
}
else
{
tp_log_err("%s %d:synaptics esd check is not running\n", __func__, __LINE__);
}
return ret;
}
int cyttsp5_init(struct cyttsp5_core_platform_data *pdata,
int on, struct device *dev)
{
int rst_gpio = pdata->rst_gpio;
int irq_gpio = pdata->irq_gpio;
int rc = 0;
if (NULL == pdata || NULL == dev) {
tp_log_err("%s %d:input parameter missing\n", __func__, __LINE__);
return -EINVAL;
}
#ifdef CONFIG_HUAWEI_DSM
g_tp_dsm_info.rst_gpio = rst_gpio;
g_tp_dsm_info.irq_gpio = irq_gpio;
#endif/*CONFIG_HUAWEI_DSM*/
if (on) {
rc = gpio_request(rst_gpio, "ts_reset");
if (rc < 0) {
tp_log_err("%s %d:gpio_request fail, gpio = %d,rc = %d\n",
__func__, __LINE__, rst_gpio, rc);
gpio_free(rst_gpio);
rc = gpio_request(rst_gpio, "ts_reset");
}
if (rc < 0) {
tp_log_err("%s: Fail request gpio=%d\n", __func__, rst_gpio);
} else {
rc = gpio_direction_output(rst_gpio, 1);
if (rc < 0) {
tp_log_err("%s: Fail set output gpio=%d\n", __func__, rst_gpio);
gpio_free(rst_gpio);
} else {
rc = gpio_request(irq_gpio, "ts_irq");
if (rc < 0) {
tp_log_err("%s %d:gpio_request fail, gpio = %d,rc = %d\n",
__func__, __LINE__, irq_gpio, rc);
gpio_free(irq_gpio);
rc = gpio_request(irq_gpio, "ts_irq");
}
if (rc < 0) {
tp_log_err("%s: Fail request gpio=%d\n", __func__, irq_gpio);
gpio_free(rst_gpio);
} else {
gpio_direction_input(irq_gpio);
}
}
}
} else {
gpio_free(rst_gpio);
gpio_free(irq_gpio);
}
tp_log_info("%s: INIT CYTTSP RST gpio=%d and IRQ gpio=%d r=%d\n",
__func__, rst_gpio, irq_gpio, rc);
return rc;
}
/* i2c error infomation: err number, register infomation */
ssize_t cyttsp5_dsm_record_i2c_err_info( int err_numb )
{
ssize_t size = 0;
ssize_t total_size = 0;
tp_log_err("%s: entry!\n", __func__);
/* err number */
size = dsm_client_record(tp_cyp_dclient, "i2c err number:%d\n", err_numb );
total_size += size;
return total_size;
}
/*****************************************************************
Parameters : void
Return : success return work number,fail return 0;
Description :
*****************************************************************/
int synaptics_dsx_esd_start(void)
{
int ret = 0;
tp_log_info("%s %d:start synaptics esd check\n", __func__, __LINE__);
if (ESD_CHECK_STOPED == atomic_read(&synaptics_dsx_esd.esd_check_status))
{
ret = queue_delayed_work(synaptics_dsx_esd.esd_work_queue, &synaptics_dsx_esd.esd_work, msecs_to_jiffies(SYNAPTICS_ESD_CHECK_TIME));
if (!ret) {
tp_log_err("%s %d:queue_delayed_work fail\n", __func__, __LINE__);
return ret;
}
atomic_set(&(synaptics_dsx_esd.esd_check_status), ESD_CHECK_START);
}
else
{
tp_log_err("%s %d:synaptics esd check is not ready\n", __func__, __LINE__);
ret = 0;
}
return ret;
}
/* tp report err according to err type */
int cyttsp5_tp_report_dsm_err(struct device *dev, int type, int err_numb)
{
tp_log_err("%s: entry! type:%d\n", __func__, type);
if( NULL == tp_cyp_dclient ) {
tp_log_err("%s: there is not tp_dclient!\n", __func__);
return -1;
}
/* try to get permission to use the buffer */
if(dsm_client_ocuppy(tp_cyp_dclient)) {
/* buffer is busy */
tp_log_err("%s: buffer is busy!\n", __func__);
return -1;
}
/* tp report err according to err type */
switch(type) {
case DSM_TP_I2C_RW_ERROR_NO:
/* report tp basic infomation */
cyttsp5_dsm_record_basic_err_info(dev);
/* report i2c infomation */
cyttsp5_dsm_record_i2c_err_info(err_numb);
break;
case DSM_TP_FW_ERROR_NO:
/* report tp basic infomation */
cyttsp5_dsm_record_basic_err_info(dev);
/* report fw infomation */
cyttsp5_dsm_record_fw_err_info(err_numb);
break;
default:
break;
}
dsm_client_notify(tp_cyp_dclient, type);
return 0;
}
static int cyttsp4_debug_op_attention(struct cyttsp4_device *ttsp)
{
struct device *dev = &ttsp->dev;
struct cyttsp4_debug_data *dd = dev_get_drvdata(dev);
int rc = 0;
tp_log_debug( "%s\n", __func__);
/* core handles handshake */
rc = cyttsp4_xy_worker(dd);
if (rc < 0)
tp_log_err( "%s: xy_worker error r=%d\n", __func__, rc);
return rc;
}
static ssize_t cyttsp4_formated_output_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct cyttsp4_debug_data *dd = dev_get_drvdata(dev);
unsigned long value;
int rc;
rc = kstrtoul(buf, 10, &value);
if (rc < 0) {
tp_log_err( "%s: Invalid value\n", __func__);
return size;
}
/* Expecting only 0 or 1 */
if (value != 0 && value != 1) {
tp_log_err( "%s: Invalid value %lu\n", __func__, value);
return size;
}
mutex_lock(&dd->sysfs_lock);
dd->formated_output = value;
mutex_unlock(&dd->sysfs_lock);
return size;
}
int nvt_proc_flash_init(void)
{
int ret=0;
static struct proc_dir_entry *nvt_proc_entry;
nvt_proc_entry = proc_create(DEVICE_NAME, 0644, NULL, &nvt_flash_fops);
if(nvt_proc_entry == NULL){
tp_log_err("%s line%d: proc_create entry failed!\n", __func__,__LINE__);
ret = -ENOMEM;
return ret ;
}else{
tp_log_info("%s line%d: proc_create entry succeed.\n",__func__,__LINE__);
}
return 0;
}
