/** * 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; }
static ssize_t ft6x06_ftsgetprojectcode_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t num_read_chars = 0; char projectcode[50]; struct i2c_client *client = container_of(dev, struct i2c_client, dev); tp_log_info("%s %d\n",__func__,__LINE__); memset(projectcode, 0, sizeof(projectcode)); mutex_lock(&g_device_mutex); if(ft6x06_read_project_code(client, projectcode) < 0) { tp_log_debug("%s %d num_read_chars = %d\n",__func__,__LINE__,num_read_chars); num_read_chars = snprintf(buf, PAGE_SIZE, "get projcet code fail!\n"); tp_log_debug("%s %d num_read_chars = %d\n",__func__,__LINE__,num_read_chars); } else { tp_log_debug("%s %d num_read_chars = %d\n",__func__,__LINE__,num_read_chars); num_read_chars = snprintf(buf, PAGE_SIZE, "projcet code = %s\n", projectcode); tp_log_debug("%s %d num_read_chars = %d\n",__func__,__LINE__,num_read_chars); } mutex_unlock(&g_device_mutex); return num_read_chars; }
/* 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 : 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; }
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; }
static int cyttsp4_proximity_release(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev); tp_log_debug("%s\n", __func__); if (pd->input_device_registered) { /* Disable proximity sensing */ mutex_lock(&pd->sysfs_lock); if (pd->enable_count) _cyttsp4_proximity_disable(pd, true); mutex_unlock(&pd->sysfs_lock); device_remove_file(dev, &dev_attr_enable); input_unregister_device(pd->input); } else { input_free_device(pd->input); cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_STARTUP, cyttsp4_setup_input_attention, 0); } pm_runtime_suspend(dev); pm_runtime_disable(dev); dev_set_drvdata(dev, NULL); kfree(pd); return 0; }
/***************************************************************** Parameters : void Return : Description : set irq_handle flag, esd work will read ic *****************************************************************/ void synaptics_dsx_esd_resume(void) { int resume_count = atomic_read(&synaptics_dsx_esd.irq_status); atomic_set(&(synaptics_dsx_esd.irq_status), resume_count + 1); tp_log_debug("%s %d:synaptics esd check resume, count = %d\n", __func__, __LINE__, resume_count + 1); }
/***************************************************************** 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 int cyttsp4_debug_startup_attention(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_debug_data *dd = dev_get_drvdata(dev); tp_log_debug( "%s\n", __func__); dd->monitor.mntr_status = CY_MNTR_DISABLED; return 0; }
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_debug_cat_attention(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_debug_data *dd = dev_get_drvdata(dev); struct cyttsp4_sysinfo *si = dd->si; u8 cat_masked_cmd; tp_log_debug( "%s\n", __func__); /* Check for CaT command executed */ cat_masked_cmd = si->xy_mode[CY_REG_CAT_CMD] & CY_CMD_MASK; if (cat_masked_cmd == CY_CMD_CAT_START_SENSOR_DATA_MODE) { tp_log_debug( "%s: Sensor data mode enabled\n", __func__); dd->monitor.mntr_status = CY_MNTR_ENABLED; } else if (cat_masked_cmd == CY_CMD_CAT_STOP_SENSOR_DATA_MODE) { tp_log_debug( "%s: Sensor data mode disabled\n", __func__); dd->monitor.mntr_status = CY_MNTR_DISABLED; } return 0; }
static int cyttsp4_proximity_attention(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev); int rc = 0; tp_log_debug("%s\n", __func__); mutex_lock(&pd->report_lock); if (!pd->is_suspended) { /* core handles handshake */ rc = cyttsp4_xy_worker(pd); } else { tp_log_debug("%s: Ignoring report while suspended\n", __func__); } mutex_unlock(&pd->report_lock); if (rc < 0) tp_log_err("%s: xy_worker error r=%d\n", __func__, rc); return rc; }
static int cyttsp4_proximity_resume(struct device *dev) { struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev); tp_log_debug("%s\n", __func__); mutex_lock(&pd->report_lock); pd->is_suspended = false; mutex_unlock(&pd->report_lock); return 0; }
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; }
/** * tp_get_touch_screen_obj - it is a common function,tp can call it to creat /sys/touch_screen file node * * @no input value * * This function is tp call it to creat /sys/touch_screen file node. * * The kobject of touch_screen_kobject_ts will be returned,notice it is static. */ struct kobject* tp_get_touch_screen_obj(void) { if( NULL == touch_screen_kobject_ts ) { touch_screen_kobject_ts = kobject_create_and_add("touch_screen", NULL); if (!touch_screen_kobject_ts) { tp_log_err("%s: create touch_screen kobjetct error!\n", __func__); return NULL; } else { tp_log_debug("%s: create sys/touch_screen successful!\n", __func__); } } else { tp_log_debug("%s: sys/touch_screen already exist!\n", __func__); } return touch_screen_kobject_ts; }
int cyttsp4_detect(struct cyttsp4_core_platform_data *pdata, struct device *dev, cyttsp4_platform_read read) { int retry = 3; int rc; char buf[1]; while (retry--) { /* Perform reset, wait for 100 ms and perform read */ tp_log_debug( "%s: Performing a reset\n", __func__); pdata->xres(pdata, dev); msleep(100); rc = read(dev, 0, buf, 1); if (!rc) return 0; tp_log_debug( "%s: Read unsuccessful, try=%d\n", __func__, 3 - retry); } return rc; }
static int cyttsp4_startup_attention(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev); tp_log_debug("%s\n", __func__); mutex_lock(&pd->report_lock); cyttsp4_report_proximity(pd, false); mutex_unlock(&pd->report_lock); return 0; }
/** * tp_get_virtual_key_obj - it is a common function,tp can call it to creat virtual_key file node in /sys/ * * @no input value * * This function is tp call it to creat virtual_key file node in /sys/ * * The kobject of virtual_key_kobject_ts will be returned */ struct kobject* tp_get_virtual_key_obj(char *name) { if( NULL == virtual_key_kobject_ts ) { virtual_key_kobject_ts = kobject_create_and_add(name, NULL); if (!virtual_key_kobject_ts) { tp_log_err("%s: create virtual_key kobjetct error!\n", __func__); return NULL; } else { tp_log_debug("%s: create virtual_key successful!\n", __func__); } } else { tp_log_debug("%s: virtual_key already exist!\n", __func__); } return virtual_key_kobject_ts; }
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; }
int cyttsp4_xres(struct cyttsp4_core_platform_data *pdata, struct device *dev) { int rst_gpio = pdata->rst_gpio; int rc = 0; gpio_set_value(rst_gpio, 1); msleep(20); gpio_set_value(rst_gpio, 0); msleep(40); gpio_set_value(rst_gpio, 1); msleep(20); tp_log_debug( "%s: RESET CYTTSP gpio=%d r=%d\n", __func__, pdata->rst_gpio, rc); 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_setup_input_attention(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_proximity_data *pd = dev_get_drvdata(dev); int rc; tp_log_debug("%s\n", __func__); pd->si = cyttsp4_request_sysinfo(ttsp); if (!pd->si) return -EINVAL; rc = cyttsp4_setup_input_device_and_sysfs(ttsp); cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_STARTUP, cyttsp4_setup_input_attention, 0); return rc; }
/* *ft6x06_i2c_Read-read data and write data by i2c *@client: handle of i2c *@writebuf: Data that will be written to the slave *@writelen: How many bytes to write *@readbuf: Where to store data read from slave *@readlen: How many bytes to read * *Returns negative errno, else the number of messages executed * * */ int ft6x06_i2c_Read(struct i2c_client *client, char *writebuf, int writelen, char *readbuf, int readlen) { int ret; tp_log_debug("in ft6x06_i2c_Read\n"); if (writelen > 0) { struct i2c_msg msgs[] = { { .addr = client->addr, .flags = 0, .len = writelen, .buf = writebuf, }, { .addr = client->addr, .flags = I2C_M_RD, .len = readlen, .buf = readbuf, }, };
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; }
static int ft6x06_read_project_code(struct i2c_client * client, char * pProjectCode) { u8 reg_val[2] = {0}; u32 i = 0; u32 j=0; u32 temp; u8 packet_buf[4]; u8 auc_i2c_write_buf[10]; int i_ret; u8 is_5336_new_bootloader = 0; int rc =0; for (i = 0; i < FTS_UPGRADE_LOOP; i++) { /*********Step 1:Reset CTPM *****/ /*write 0xaa to register 0xbc*/ ft6x06_write_reg(client, 0xbc, FT_UPGRADE_AA); msleep(FT6X06_UPGRADE_AA_DELAY); /*write 0x55 to register 0xbc*/ ft6x06_write_reg(client, 0xbc, FT_UPGRADE_55); msleep(FT6X06_UPGRADE_55_DELAY+20); /*********Step 2:Enter upgrade mode *****/ auc_i2c_write_buf[0] = FT_UPGRADE_55; auc_i2c_write_buf[1] = FT_UPGRADE_AA; do{ j++; i_ret = ft6x06_i2c_Write(client, auc_i2c_write_buf, 2); msleep(5); }while(i_ret <= 0 && j<5); /*********Step 3:check READ-ID***********************/ msleep(FT6X06_UPGRADE_READID_DELAY); auc_i2c_write_buf[0] = 0x90; auc_i2c_write_buf[1] = auc_i2c_write_buf[2] = auc_i2c_write_buf[3] = 0x00; rc = ft6x06_i2c_Read(client, auc_i2c_write_buf, 4, reg_val, 2); if(rc < 0) tp_log_err("error:%s,line=%d,rc=%d\n", __func__, __LINE__,rc); if (reg_val[0] == FT6X06_UPGRADE_ID_1 && reg_val[1] == FT6X06_UPGRADE_ID_2) { tp_log_debug("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]); break; } else { tp_log_err("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]); continue; } } if (i >= FTS_UPGRADE_LOOP) { return -EIO; } auc_i2c_write_buf[0] = 0xcd; rc = ft6x06_i2c_Read(client, auc_i2c_write_buf, 1, reg_val, 1); if(rc < 0) tp_log_err("error:%s,line=%d,rc=%d\n", __func__, __LINE__,rc); if (reg_val[0] > 4) is_5336_new_bootloader = 1; tp_log_debug("bootloader version:%d\n", reg_val[0]); /*read project code*/ packet_buf[0] = 0x03; packet_buf[1] = 0x00; for (j=0;j<33;j++) { if (is_5336_new_bootloader) temp = 0x07d0 + j; else temp = 0x7820 + j; packet_buf[2] = (u8)(temp>>8); packet_buf[3] = (u8)temp; rc = ft6x06_i2c_Read(client, packet_buf, sizeof(packet_buf), pProjectCode+j, 1); if(rc < 0) tp_log_err("error:%s,line=%d,rc=%d\n", __func__, __LINE__,rc); if (*(pProjectCode+j) == '\0') break; tp_log_debug("j = %d\n",j); } //if(strcmp(pProjectCode,"FTS0000P000") == 0) tp_log_debug("project code = %s \n", pProjectCode); #if 1 /*********reset the new FW***********************/ tp_log_debug("%s %d\n",__func__,__LINE__); auc_i2c_write_buf[0] = 0x07; ft6x06_i2c_Write(client, auc_i2c_write_buf, 1); msleep(300); /*make sure CTP startup normally*/ tp_log_debug("%s %d\n",__func__,__LINE__); #endif return 0; }
static int cyttsp4_proximity_probe(struct cyttsp4_device *ttsp) { struct cyttsp4_proximity_data *pd; struct device *dev = &ttsp->dev; struct cyttsp4_proximity_platform_data *pdata = dev_get_platdata(dev); int rc = 0; tp_log_info("%s\n", __func__); tp_log_debug("%s: debug on\n", __func__); tp_log_debug("%s: verbose debug on\n", __func__); if (pdata == NULL) { tp_log_err("%s: Missing platform data\n", __func__); rc = -ENODEV; goto error_no_pdata; } pd = kzalloc(sizeof(*pd), GFP_KERNEL); if (pd == NULL) { tp_log_err("%s: Error, kzalloc\n", __func__); rc = -ENOMEM; goto error_alloc_data_failed; } mutex_init(&pd->report_lock); mutex_init(&pd->sysfs_lock); pd->ttsp = ttsp; pd->pdata = pdata; dev_set_drvdata(dev, pd); /* Create the input device and register it. */ tp_log_debug("%s: Create the input device and register it\n", __func__); pd->input = input_allocate_device(); if (pd->input == NULL) { tp_log_err("%s: Error, failed to allocate input device\n", __func__); rc = -ENOSYS; goto error_alloc_failed; } pd->input->name = ttsp->name; scnprintf(pd->phys, sizeof(pd->phys) - 1, "%s", dev_name(dev)); pd->input->phys = pd->phys; pd->input->dev.parent = &pd->ttsp->dev; input_set_drvdata(pd->input, pd); pm_runtime_enable(dev); /* get sysinfo */ pd->si = cyttsp4_request_sysinfo(ttsp); if (pd->si) { rc = cyttsp4_setup_input_device_and_sysfs(ttsp); if (rc) goto error_init_input; } else { tp_log_err("%s: Fail get sysinfo pointer from core \n", __func__); cyttsp4_subscribe_attention(ttsp, CY_ATTEN_STARTUP, cyttsp4_setup_input_attention, 0); } tp_log_debug("%s: ok\n", __func__); return 0; error_init_input: pm_runtime_suspend(dev); pm_runtime_disable(dev); input_free_device(pd->input); error_alloc_failed: dev_set_drvdata(dev, NULL); kfree(pd); error_alloc_data_failed: error_no_pdata: tp_log_err("%s failed.\n", __func__); return rc; }
ssize_t cyttsp5_dsm_record_basic_err_info(struct device *dev) { ssize_t size = 0; ssize_t total_size = 0; struct cyttsp5_core_data *cd = dev_get_drvdata(dev); /* power status,include mode, is enable, voltage */ if((cd->cpdata->power_config->vbus_type == CY_POWER_PMU)&&(cd->cpdata->power_config->vbus_reg)) { tp_log_debug("%s: record power!\n", __func__); size = dsm_client_record(tp_cyp_dclient, "[vbus power] mode:%d, enable:%d, vol:%d\n", regulator_get_mode(cd->cpdata->power_config->vbus_reg), regulator_is_enabled(cd->cpdata->power_config->vbus_reg), regulator_get_voltage(cd->cpdata->power_config->vbus_reg)); total_size += size; tp_log_err("[vbus power] mode:%d, enable:%d, vol:%d\n", regulator_get_mode(cd->cpdata->power_config->vbus_reg), regulator_is_enabled(cd->cpdata->power_config->vbus_reg), regulator_get_voltage(cd->cpdata->power_config->vbus_reg)); } if((cd->cpdata->power_config->vdd_type == CY_POWER_PMU)&&(cd->cpdata->power_config->vdd_reg)) { tp_log_debug("%s: record power!\n", __func__); size = dsm_client_record(tp_cyp_dclient, "[vdd power] mode:%d, enable:%d, vol:%d\n", regulator_get_mode(cd->cpdata->power_config->vdd_reg), regulator_is_enabled(cd->cpdata->power_config->vdd_reg), regulator_get_voltage(cd->cpdata->power_config->vdd_reg)); total_size += size; tp_log_err("[vdd power] mode:%d, enable:%d, vol:%d\n", regulator_get_mode(cd->cpdata->power_config->vdd_reg), regulator_is_enabled(cd->cpdata->power_config->vdd_reg), regulator_get_voltage(cd->cpdata->power_config->vdd_reg)); } if (cd->cpdata->power_config->vdd_type == CY_POWER_GPIO) { tp_log_debug("%s: record power!\n", __func__); size = dsm_client_record(tp_cyp_dclient, "[vdd power] mode:%d, enable:%d\n", cd->cpdata->power_config->vdd_type, gpio_get_value(cd->cpdata->power_config->vdd_en_gpio)); total_size += size; tp_log_err("[vdd power] mode:%d, enable:%d\n", cd->cpdata->power_config->vdd_type, gpio_get_value(cd->cpdata->power_config->vdd_en_gpio)); } if (cd->cpdata->power_config->vbus_type == CY_POWER_GPIO) { tp_log_debug("%s: record power!\n", __func__); size = dsm_client_record(tp_cyp_dclient, "[vdd power] mode:%d, enable:%d\n", cd->cpdata->power_config->vdd_type, gpio_get_value(cd->cpdata->power_config->vbus_en_gpio)); total_size += size; tp_log_err("[vdd power] mode:%d, enable:%d\n", cd->cpdata->power_config->vdd_type, gpio_get_value(cd->cpdata->power_config->vbus_en_gpio)); } /* record irq and reset gpio status */ tp_log_debug("%s: record irq and reset gpio!\n", __func__); size = dsm_client_record(tp_cyp_dclient, "[irq gpio] num:%d, irq gpio status:%d\n" "[reset gpio] num:%d, reset gpio status:%d\n", g_tp_dsm_info.irq_gpio, gpio_get_value(g_tp_dsm_info.irq_gpio), g_tp_dsm_info.rst_gpio, gpio_get_value(g_tp_dsm_info.rst_gpio)); total_size += size; tp_log_err("[irq gpio] num:%d, irq gpio status:%d\n" "[reset gpio] num:%d, reset gpio status:%d\n", g_tp_dsm_info.irq_gpio, gpio_get_value(g_tp_dsm_info.irq_gpio), g_tp_dsm_info.rst_gpio, gpio_get_value(g_tp_dsm_info.rst_gpio)); return total_size; }
/* read xy_data for all touches for debug */ static int cyttsp4_xy_worker(struct cyttsp4_debug_data *dd) { struct device *dev = &dd->ttsp->dev; struct cyttsp4_sysinfo *si = dd->si; u8 tt_stat = si->xy_mode[si->si_ofs.tt_stat_ofs]; u8 num_cur_rec = GET_NUM_TOUCH_RECORDS(tt_stat); uint32_t formated_output; int rc; mutex_lock(&dd->sysfs_lock); dd->interrupt_count++; formated_output = dd->formated_output; mutex_unlock(&dd->sysfs_lock); /* Read command parameters */ rc = cyttsp4_read(dd->ttsp, CY_MODE_OPERATIONAL, si->si_ofs.cmd_ofs + 1, &si->xy_mode[si->si_ofs.cmd_ofs + 1], si->si_ofs.rep_ofs - si->si_ofs.cmd_ofs - 1); if (rc < 0) { tp_log_err( "%s: read fail on command parameter regs r=%d\n", __func__, rc); } if (si->si_ofs.num_btns > 0) { /* read button diff data */ rc = cyttsp4_read(dd->ttsp, CY_MODE_OPERATIONAL, /* replace with btn_diff_ofs when that field * becomes supported in the firmware */ si->si_ofs.tt_stat_ofs + 1 + si->si_ofs.max_tchs * si->si_ofs.tch_rec_size, si->btn_rec_data, si->si_ofs.num_btns * si->si_ofs.btn_rec_size); if (rc < 0) { tp_log_err( "%s: read fail on button regs r=%d\n", __func__, rc); } } /* Interrupt */ #if 0//huawei 0701 tp_log_info("Interrupt(%u)\n", dd->interrupt_count); #endif //huawei 0701 if (formated_output) cyttsp4_debug_formated(dev, dd->pr_buf, si, num_cur_rec); else /* print data for TTHE */ cyttsp4_pr_buf_op_mode(dev, dd->pr_buf, si, num_cur_rec); if (dd->monitor.mntr_status == CY_MNTR_ENABLED) { int offset = (si->si_ofs.max_tchs * si->si_ofs.tch_rec_size) + (si->si_ofs.num_btns * si->si_ofs.btn_rec_size) + (si->si_ofs.tt_stat_ofs + 1); rc = cyttsp4_read(dd->ttsp, CY_MODE_OPERATIONAL, offset, &(dd->monitor.sensor_data[0]), 150); if (rc < 0) tp_log_err( "%s: read fail on sensor monitor regs r=%d\n", __func__, rc); /* print data for the sensor monitor */ cyttsp4_debug_print(dev, dd->pr_buf, dd->monitor.sensor_data, 150, "cyttsp4_sensor_monitor"); } #if 0//huawei 0701 tp_log_info("\n"); #endif //huawei 0701 tp_log_debug( "%s: done\n", __func__); return 0; }
static int cyttsp4_debug_probe(struct cyttsp4_device *ttsp) { struct device *dev = &ttsp->dev; struct cyttsp4_debug_data *dd; struct cyttsp4_debug_platform_data *pdata = dev_get_platdata(dev); int rc; tp_log_info( "%s: startup\n", __func__); tp_log_debug( "%s: debug on\n", __func__); tp_log_debug( "%s: verbose debug on\n", __func__); /* get context and debug print buffers */ dd = kzalloc(sizeof(*dd), GFP_KERNEL); if (dd == NULL) { tp_log_err( "%s: Error, kzalloc\n", __func__); rc = -ENOMEM; goto cyttsp4_debug_probe_alloc_failed; } rc = device_create_file(dev, &dev_attr_int_count); if (rc) { tp_log_err( "%s: Error, could not create int_count\n", __func__); goto cyttsp4_debug_probe_create_int_count_failed; } rc = device_create_file(dev, &dev_attr_formated_output); if (rc) { tp_log_err( "%s: Error, could not create formated_output\n", __func__); goto cyttsp4_debug_probe_create_formated_failed; } mutex_init(&dd->sysfs_lock); dd->ttsp = ttsp; dd->pdata = pdata; dev_set_drvdata(dev, dd); pm_runtime_enable(dev); dd->si = cyttsp4_request_sysinfo(ttsp); if (dd->si == NULL) { tp_log_err( "%s: Fail get sysinfo pointer from core\n", __func__); rc = -ENODEV; goto cyttsp4_debug_probe_sysinfo_failed; } rc = cyttsp4_subscribe_attention(ttsp, CY_ATTEN_IRQ, cyttsp4_debug_op_attention, CY_MODE_OPERATIONAL); if (rc < 0) { tp_log_err( "%s: Error, could not subscribe Operating mode attention cb\n", __func__); goto cyttsp4_debug_probe_subscribe_op_failed; } rc = cyttsp4_subscribe_attention(ttsp, CY_ATTEN_IRQ, cyttsp4_debug_cat_attention, CY_MODE_CAT); if (rc < 0) { tp_log_err( "%s: Error, could not subscribe CaT mode attention cb\n", __func__); goto cyttsp4_debug_probe_subscribe_cat_failed; } rc = cyttsp4_subscribe_attention(ttsp, CY_ATTEN_STARTUP, cyttsp4_debug_startup_attention, 0); if (rc < 0) { tp_log_err( "%s: Error, could not subscribe startup attention cb\n", __func__); goto cyttsp4_debug_probe_subscribe_startup_failed; } return 0; cyttsp4_debug_probe_subscribe_startup_failed: cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_IRQ, cyttsp4_debug_cat_attention, CY_MODE_CAT); cyttsp4_debug_probe_subscribe_cat_failed: cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_IRQ, cyttsp4_debug_op_attention, CY_MODE_OPERATIONAL); cyttsp4_debug_probe_subscribe_op_failed: cyttsp4_debug_probe_sysinfo_failed: pm_runtime_suspend(dev); pm_runtime_disable(dev); dev_set_drvdata(dev, NULL); device_remove_file(dev, &dev_attr_formated_output); cyttsp4_debug_probe_create_formated_failed: device_remove_file(dev, &dev_attr_int_count); cyttsp4_debug_probe_create_int_count_failed: kfree(dd); cyttsp4_debug_probe_alloc_failed: tp_log_err( "%s failed.\n", __func__); return rc; }