/*****************************************************************
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;
}
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;
}
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;
}
static void __exit cyttsp4_debug_exit(void)
{
int i;
cyttsp4_unregister_driver(&cyttsp4_debug_driver);
for (i = 0; i < num_core_ids; i++) {
cyttsp4_unregister_device(cyttsp4_debug_infos[i].name,
cyttsp4_debug_infos[i].core_id);
tp_log_info("%s: Unregistering debug device for core_id: %s\n",
__func__, cyttsp4_debug_infos[i].core_id);
}
tp_log_info("%s: module exit\n", __func__);
}
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;
}
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;
}
/*
* This function provide output of combined xy_mode and xy_data.
* Required by TTHE.
*/
static void cyttsp4_pr_buf_op_mode(struct device *dev, u8 *pr_buf,
struct cyttsp4_sysinfo *si, u8 cur_touch)
{
int i, k;
const char fmt[] = "%02X ";
int max = (CY_MAX_PRBUF_SIZE - 1) - sizeof(CY_PR_TRUNCATED);
int total_size = si->si_ofs.mode_size
+ (cur_touch * si->si_ofs.tch_rec_size);
u8 num_btns = si->si_ofs.num_btns;
pr_buf[0] = 0;
for (i = k = 0; i < si->si_ofs.mode_size && i < max; i++, k += 3)
scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, fmt, si->xy_mode[i]);
for (i = 0; i < (cur_touch * si->si_ofs.tch_rec_size) && i < max;
i++, k += 3)
scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, fmt, si->xy_data[i]);
if (num_btns) {
/* print btn diff data for TTHE */
scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, "%s", "=");
k++;
for (i = 0; i < (num_btns * si->si_ofs.btn_rec_size) && i < max;
i++, k += 3)
scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, fmt,
si->btn_rec_data[i]);
total_size += num_btns * si->si_ofs.btn_rec_size + 1;
}
#if 0//hauwei 0701
tp_log_info("%s=%s%s\n", "cyttsp4_OpModeData", pr_buf,
total_size <= max ? "" : CY_PR_TRUNCATED);
#endif//huawei 0701
}
static int __init cyttsp4_proximity_init(void)
{
int rc = 0;
rc = cyttsp4_register_driver(&cyttsp4_proximity_driver);
tp_log_info("%s: Cypress TTSP MT v4 Proximity (Built %s), rc=%d\n",
__func__, CY_DRIVER_DATE, rc);
return rc;
}
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;
}
static int __init cyttsp4_mt_init(void)
{
int rc;
cyttsp4_mt_driver.driver.owner = THIS_MODULE;
rc = cyttsp4_register_driver(&cyttsp4_mt_driver);
tp_log_info("%s: Cypress TTSP MTA v4 multi-touch (Built %s), rc=%d\n",
__func__, CY_DRIVER_DATE, rc);
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;
}
static void cyttsp4_debug_formated(struct device *dev, u8 *pr_buf,
struct cyttsp4_sysinfo *si, u8 num_cur_rec)
{
u8 mode_size = si->si_ofs.mode_size;
u8 rep_len = si->xy_mode[si->si_ofs.rep_ofs];
u8 tch_rec_size = si->si_ofs.tch_rec_size;
u8 num_btns = si->si_ofs.num_btns;
u8 num_btn_regs = (num_btns + CY_NUM_BTN_PER_REG - 1)
/ CY_NUM_BTN_PER_REG;
u8 num_btn_tch;
u8 data_name[] = "touch[99]";
int max_print_length = 18;
int i;
/* xy_mode */
cyttsp4_debug_print(dev, pr_buf, si->xy_mode, mode_size, "xy_mode");
/* xy_data */
if (rep_len > max_print_length) {
tp_log_info("xy_data[0..%d]:\n", rep_len);
for (i = 0; i < rep_len - max_print_length;
i += max_print_length) {
cyttsp4_debug_print(dev, pr_buf, si->xy_data + i,
max_print_length, " ");
}
if (rep_len - i)
cyttsp4_debug_print(dev, pr_buf, si->xy_data + i,
rep_len - i, " ");
} else {
cyttsp4_debug_print(dev, pr_buf, si->xy_data,
rep_len - si->si_ofs.rep_hdr_size, "xy_data");
}
/* touches */
for (i = 0; i < num_cur_rec; i++) {
scnprintf(data_name, sizeof(data_name) - 1, "touch[%u]", i);
cyttsp4_debug_print(dev, pr_buf,
si->xy_data + (i * tch_rec_size),
tch_rec_size, data_name);
}
/* buttons */
if (num_btns) {
num_btn_tch = 0;
for (i = 0; i < num_btn_regs; i++) {
if (si->xy_mode[si->si_ofs.rep_ofs + 2 + i]) {
num_btn_tch++;
break;
}
}
if (num_btn_tch)
cyttsp4_debug_print(dev, pr_buf,
&si->xy_mode[si->si_ofs.rep_ofs + 2],
num_btn_regs, "button");
}
}
/*create sysfs for debug*/
int ft6x06_create_sysfs(struct i2c_client *client)
{
int err;
tp_log_info(" in ft6x06_create_sysfs\n");
err = sysfs_create_group(&client->dev.kobj, &ft6x06_attribute_group);
if (0 != err) {
dev_err(&client->dev,
"%s() - ERROR: sysfs_create_group() failed.\n",
__func__);
sysfs_remove_group(&client->dev.kobj, &ft6x06_attribute_group);
return -EIO;
} else {
mutex_init(&g_device_mutex);
pr_info("ft6x06:%s() - sysfs_create_group() succeeded.\n",
__func__);
}
tp_log_info(" out ft6x06_create_sysfs\n");
return err;
}
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 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;
}
int cyttsp5_xres(struct cyttsp5_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_info("%s: RESET CYTTSP gpio=%d r=%d\n", __func__, pdata->rst_gpio, rc);
return rc;
}
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;
}
/*****************************************************************
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 void cyttsp4_debug_print(struct device *dev, u8 *pr_buf, u8 *sptr,
int size, const char *data_name)
{
int i, j;
int elem_size = sizeof("XX ") - 1;
int max = (CY_MAX_PRBUF_SIZE - 1) / elem_size;
int limit = size < max ? size : max;
if (limit < 0)
limit = 0;
pr_buf[0] = 0;
for (i = j = 0; i < limit; i++, j += elem_size)
scnprintf(pr_buf + j, CY_MAX_PRBUF_SIZE - j, "%02X ", sptr[i]);
tp_log_info("%s[0..%d]=%s%s\n", data_name, size ? size - 1 : 0, pr_buf,
size <= max ? "" : CY_PR_TRUNCATED);
}
/*
*ft6x06_tp_dump - called when force dump dsm err
*/
int ft6x06_tp_dump (int type, void *buff, int size)
{
int used_size = 0;
struct dsm_client * dsm_client = tp_dclient;
if(NULL == dsm_client)
{
tp_log_err("%s %d: dsm_client is NULL!\n", __func__, __LINE__);
return used_size;
}
/* save tp basice infomation */
used_size = ft6x06_dsm_record_basic_info(g_ft6x06_ts, dsm_client);
if( used_size > 0 )
{
tp_log_info("%s %d: force dump tp error! \n",__func__, __LINE__);
snprintf( buff, dsm_client->used_size, dsm_client->dump_buff );
}
return dsm_client->used_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;
}
/*
************************************************************************
*InputParms:
***pd - a pointer to hw_tp_power_data where power configs saved
*return: number of power configs parsed
************************************************************************
*/
int hw_tp_power_parse_config(struct hw_tp_power_data * pd)
{
int ret = 0;
int i = 0;
u32 value;
struct hw_tp_power_node * pn = NULL;
struct device_node * tnp = NULL;
char pname[MAX_PNODE_NAME_LEN] = {0};
struct device_node * np = pd->np;
pd->pw_cnt = 0;
pn = kzalloc(sizeof(*pn),GFP_KERNEL);
if(!pn){
tp_log_err("%s#%d: kzalloc of power_node failed!\n",__func__,__LINE__);
goto hw_tp_parse_confg_exit;
}
memset(pn, 0, sizeof(*pn));
pd->pnode_list = pn;
for_each_child_of_node(np,tnp) {
snprintf(pname,sizeof(pname),tnp->name);
/* alloc memory for a new power node*/
if(i != 0) {
pn->next = kzalloc(sizeof(*pn),GFP_KERNEL);
if(!pn->next) {
tp_log_err("%s#%d: kzalloc of pn->next fail!\n",__func__,__LINE__);
ret = -ENOMEM;
goto hw_tp_parse_confg_exit;
}
memset(pn->next,0,sizeof(*pn));
pn = pn->next;
}
i++;
pn->np = tnp;
/* read power name */
ret = of_property_read_string(tnp, "power-name",&pn->power_name);
if(ret) {
tp_log_warning("%s#%d: %s -> power-name empty!\n",
__func__,__LINE__,pname);
pn->power_name = NULL;
} else {
tp_log_info("%s#%d: %s -> power_name = %s\n",
__func__,__LINE__,pname,pn->power_name);
}
/* read power type */
ret = of_property_read_u32(tnp,"power-type",&value);
if(ret){
tp_log_err("%s#%d: read power-type from %s fai!ret = %d\n",
__func__,__LINE__,pname, ret);
pn->power_type = NONE_SUPPLY;
} else {
pn->power_type = (u32)value;
tp_log_info("%s#%d: %s -> power_type = %d\n",
__func__,__LINE__,pname, pn->power_type);
}
/* read power gpio */
if (of_find_property(tnp, "power-gpio", NULL)) {
pn->power_gpio = of_get_named_gpio_flags(tnp, "power-gpio",0, NULL);
tp_log_info("%s#%d: %s -> power_gpio = %d\n",
__func__,__LINE__,pname, pn->power_gpio);
} else {
tp_log_warning("%s#%d: read power-gpio from %s fail!ret = %d\n",
__func__,__LINE__,pname, ret);
pn->power_gpio = 0;
}
/* read power-voltage */
ret = of_property_read_u32(tnp,"power-volt",&value);
if(ret){
tp_log_warning("%s#%d: read power-volt from %s fail!ret = %d\n",
__func__,__LINE__,pname, ret);
pn->power_volt = 0;
} else {
pn->power_volt= (u32)value;
tp_log_info("%s#%d: %s -> power_volt = %d\n",
__func__,__LINE__,pname, pn->power_volt);
}
/* read delay-time of power-node */
ret = of_property_read_u32(tnp,"power-dlay",&value);
if(ret){
tp_log_warning("%s#%d: read power-dlay from %s fail!ret = %d\n",
__func__,__LINE__,pname, ret);
pn->power_dlay = 0;
} else {
pn->power_dlay= (u32)value;
tp_log_info("%s#%d: %s -> power_dlay = %d\n",
__func__,__LINE__,pname, pn->power_dlay);
}
}
static void __exit cyttsp4_proximity_exit(void)
{
cyttsp4_unregister_driver(&cyttsp4_proximity_driver);
tp_log_info("%s: module exit\n", __func__);
}
/*****************************************************************
Parameters : client
i2c_id
Return :
Description : call cyttsp5_probe in cyttsp5_core.c
*****************************************************************/
static int cyttsp5_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *i2c_id)
{
struct device *dev = &client->dev;
#ifdef CONFIG_TOUCHSCREEN_CYPRESS_CYTTSP5_DEVICETREE_SUPPORT
const struct of_device_id *match = NULL;
#endif
int rc = 0;
if(already_has_tp_driver_running()) {
tp_log_warning("%s: Another tp driver is running!\n",__func__);
return 0;
}
tp_log_warning("%s %d:Probe start\n", __func__, __LINE__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
tp_log_err("%s %d:I2C functionality not Supported.\n", __func__, __LINE__);
return -EIO;
}
/* if support device tree, get pdata from device tree */
#ifdef CONFIG_TOUCHSCREEN_CYPRESS_CYTTSP5_DEVICETREE_SUPPORT
match = of_match_device(of_match_ptr(cyttsp5_i2c_of_match), dev);
if (match) {
rc = cyttsp5_devtree_create_and_get_pdata(dev);
if (rc < 0) {
tp_log_err("%s %d:device tree create and get pdata fail, rc = %d.\n",
__func__, __LINE__, rc);
return rc;
}
} else {
tp_log_err("%s %d:No device mathced.\n", __func__, __LINE__);
return -ENODEV;
}
#endif
#ifdef CONFIG_HUAWEI_DSM
tp_cyp_dclient = dsm_register_client(&dsm_cyp_tp);
if (!tp_cyp_dclient)
tp_log_err("%s: dsm register client failed\n", __func__);
#endif/*CONFIG_HUAWEI_DSM*/
rc = cyttsp5_probe(&cyttsp5_i2c_bus_ops, &client->dev, client->irq,
CY_I2C_DATA_SIZE);
#ifdef CONFIG_TOUCHSCREEN_CYPRESS_CYTTSP5_DEVICETREE_SUPPORT
if (rc && match) {
cyttsp5_devtree_clean_pdata(dev);
#ifdef CONFIG_HUAWEI_DSM
if (tp_cyp_dclient) {
dsm_unregister_client(tp_cyp_dclient, &dsm_cyp_tp);
tp_cyp_dclient = NULL;
}
#endif/*CONFIG_HUAWEI_DSM*/
tp_log_err("%s %d:cyttsp5 probe fail.\n", __func__, __LINE__);
return rc;
}
#endif
set_tp_driver_running();
tp_log_info("%s %d:cyttsp5 probe success.\n", __func__, __LINE__);
return rc;
}
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;
}
/*
************************************************************************
*InputParms:
***pd - a pointer to hw_tp_power_data where power configs saved
*return: number of power configs initialized successful
************************************************************************
*/
int hw_tp_power_init_config(struct hw_tp_power_data * pd)
{
int ret = 0;
struct device_node * np = NULL;
struct hw_tp_power_node * pn = NULL;
struct device * dev = NULL;
if(!pd) {
tp_log_err("%s#%d: pd is NULL!\n",__func__,__LINE__);
ret = -EINVAL;
goto hw_tp_power_init_config_exit;
}
np = pd->np;
pn = pd->pnode_list;
dev = pd->dev;
if(!np || !pn || !dev) {
ret = -EINVAL;
tp_log_err("%s#%d: pn=%p, pn=%p, dev=%p\n",
__func__,__LINE__,np,pn,dev);
goto hw_tp_power_init_config_exit;
}
while(pn) {
tp_log_info("%s#%d: init config of %s\n",
__func__,__LINE__,pn->power_name);
switch(pn->power_type) {
case GPIO_H_SUPPLY:
case GPIO_L_SUPPLY:
ret = gpio_request(pn->power_gpio,dev_name(dev));
if(ret) {
tp_log_err("%s#%d: %s -> request gpio fail!\n",
__func__,__LINE__,pn->power_name);
goto hw_tp_power_init_config_exit;
}
pn->is_initialized = true;
break;
case PMU_SUPPLY:
//pn->preg = hw_tp_power_get_regulator(dev,np,pn->power_name);
tp_log_info("testing##: %s\n",pn->np->name);
pn->preg = hw_tp_power_get_regulator(dev,pn->np,pn->power_name);
ret = IS_ERR(pn->preg);
if(ret) {
tp_log_err("%s#%d: %s -> get preg fail!\n",
__func__,__LINE__,pn->power_name);
goto hw_tp_power_init_config_exit;
}
ret = regulator_set_voltage(pn->preg,pn->power_volt,pn->power_volt);
if(ret) {
tp_log_err("%s#%d: %s -> get preg fail!\n",
__func__,__LINE__,pn->power_name);
goto hw_tp_power_init_config_exit;
}
pn->is_initialized = true;
default:
tp_log_warning("%s#%d:%s -> invalid type: %d\n",
__func__,__LINE__,pn->power_name,pn->power_type);
break;
}
pn = pn->next;
}
pd->pw_ready = true;
hw_tp_power_init_config_exit:
tp_log_info("%s#%d: power configs init done!,ret=%d\n",__func__,__LINE__,ret);
return ret;
}
/* 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;
}
