1959 lines
46 KiB
C
1959 lines
46 KiB
C
/*
|
|
* Copyright (C) 2010 - 2018 Novatek, Inc.
|
|
*
|
|
* $Revision: 49359 $
|
|
* $Date: 2019-08-19 16:20:18 +0800 (週一, 19 八月 2019) $
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/input/mt.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/of_irq.h>
|
|
#include "tpd.h"
|
|
#if defined(CONFIG_FB)
|
|
#include <linux/notifier.h>
|
|
#include <linux/fb.h>
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
#include <linux/earlysuspend.h>
|
|
#endif
|
|
|
|
#include "nt36xxx.h"
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
#include <linux/jiffies.h>
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
static struct delayed_work nvt_esd_check_work;
|
|
static struct workqueue_struct *nvt_esd_check_wq;
|
|
static unsigned long irq_timer = 0;
|
|
uint8_t esd_check = false;
|
|
uint8_t esd_retry = 0;
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
#if NVT_TOUCH_EXT_PROC
|
|
extern int32_t nvt_extra_proc_init(void);
|
|
extern void nvt_extra_proc_deinit(void);
|
|
#endif
|
|
|
|
#if NVT_TOUCH_MP
|
|
extern int32_t nvt_mp_proc_init(void);
|
|
extern void nvt_mp_proc_deinit(void);
|
|
#endif
|
|
|
|
struct nvt_ts_data *ts;
|
|
int jran_gesture_fun_enable = 0;
|
|
extern char * mtkfb_find_lcm_driver(void);
|
|
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
static struct workqueue_struct *nvt_fwu_wq;
|
|
extern void Boot_Update_Firmware(struct work_struct *work);
|
|
#endif
|
|
|
|
uint32_t ENG_RST_ADDR = 0x7FFF80;
|
|
uint32_t SWRST_N8_ADDR = 0; //read from dtsi
|
|
uint32_t SPI_RD_FAST_ADDR = 0; //read from dtsi
|
|
|
|
#if TOUCH_KEY_NUM > 0
|
|
const uint16_t touch_key_array[TOUCH_KEY_NUM] = {
|
|
KEY_BACK,
|
|
KEY_HOME,
|
|
KEY_MENU
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_MTK_SPI
|
|
const struct mt_chip_conf spi_ctrdata = {
|
|
.setuptime = 25,
|
|
.holdtime = 25,
|
|
.high_time = 5, /* 10MHz (SPI_SPEED=100M / (high_time+low_time(10ns)))*/
|
|
.low_time = 5,
|
|
.cs_idletime = 2,
|
|
.ulthgh_thrsh = 0,
|
|
.cpol = 0,
|
|
.cpha = 0,
|
|
.rx_mlsb = 1,
|
|
.tx_mlsb = 1,
|
|
.tx_endian = 0,
|
|
.rx_endian = 0,
|
|
.com_mod = DMA_TRANSFER,
|
|
.pause = 0,
|
|
.finish_intr = 1,
|
|
.deassert = 0,
|
|
.ulthigh = 0,
|
|
.tckdly = 0,
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_SPI_MT65XX
|
|
const struct mtk_chip_config spi_ctrdata = {
|
|
.rx_mlsb = 1,
|
|
.tx_mlsb = 1,
|
|
//.cs_pol = 0,
|
|
.cs_setuptime = 50,
|
|
};
|
|
#endif
|
|
|
|
static uint8_t bTouchIsAwake = 0;
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen irq enable/disable function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
static void nvt_irq_enable(bool enable)
|
|
{
|
|
if (enable) {
|
|
if (!ts->irq_enabled) {
|
|
enable_irq(ts->client->irq);
|
|
ts->irq_enabled = true;
|
|
}
|
|
} else {
|
|
if (ts->irq_enabled) {
|
|
disable_irq(ts->client->irq);
|
|
ts->irq_enabled = false;
|
|
}
|
|
}
|
|
NVT_LOG("enable=%d", enable);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen spi read/write core function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed.
|
|
*******************************************************/
|
|
static inline int32_t spi_read_write(struct spi_device *client, uint8_t *buf, size_t len , NVT_SPI_RW rw)
|
|
{
|
|
struct spi_message m;
|
|
struct spi_transfer t = {
|
|
.len = len,
|
|
};
|
|
//memcpy(ts->xbuf, buf, len + DUMMY_BYTES);
|
|
memset(ts->xbuf, 0, len + DUMMY_BYTES);
|
|
memcpy(ts->xbuf, buf, len);
|
|
switch (rw) {
|
|
case NVTREAD:
|
|
t.tx_buf = ts->xbuf;
|
|
t.rx_buf = ts->rbuf;
|
|
t.len = (len + DUMMY_BYTES);
|
|
break;
|
|
|
|
case NVTWRITE:
|
|
t.tx_buf = ts->xbuf;
|
|
break;
|
|
}
|
|
|
|
spi_message_init(&m);
|
|
spi_message_add_tail(&t, &m);
|
|
return spi_sync(client, &m);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen spi read function.
|
|
|
|
return:
|
|
Executive outcomes. 2---succeed. -5---I/O error
|
|
*******************************************************/
|
|
int32_t CTP_SPI_READ(struct spi_device *client, uint8_t *buf, uint16_t len)
|
|
{
|
|
int32_t ret = -1;
|
|
int32_t retries = 0;
|
|
|
|
mutex_lock(&ts->xbuf_lock);
|
|
|
|
buf[0] = SPI_READ_MASK(buf[0]);
|
|
|
|
while (retries < 3) {
|
|
ret = spi_read_write(client, buf, len, NVTREAD);
|
|
if (ret == 0) break;
|
|
msleep(10);
|
|
retries++;
|
|
}
|
|
|
|
if (unlikely(retries == 3)) {
|
|
NVT_ERR("read error, ret=%d\n", ret);
|
|
ret = -EIO;
|
|
} else {
|
|
memcpy((buf+1), (ts->rbuf+2), (len-1));
|
|
}
|
|
|
|
mutex_unlock(&ts->xbuf_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen spi write function.
|
|
|
|
return:
|
|
Executive outcomes. 1---succeed. -5---I/O error
|
|
*******************************************************/
|
|
int32_t CTP_SPI_WRITE(struct spi_device *client, uint8_t *buf, uint16_t len)
|
|
{
|
|
int32_t ret = -1;
|
|
int32_t retries = 0;
|
|
|
|
mutex_lock(&ts->xbuf_lock);
|
|
|
|
buf[0] = SPI_WRITE_MASK(buf[0]);
|
|
|
|
while (retries < 3) {
|
|
ret = spi_read_write(client, buf, len, NVTWRITE);
|
|
if (ret == 0) break;
|
|
retries++;
|
|
}
|
|
|
|
if (unlikely(retries == 3)) {
|
|
NVT_ERR("error, ret=%d\n", ret);
|
|
ret = -EIO;
|
|
}
|
|
|
|
mutex_unlock(&ts->xbuf_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen set index/page/addr address.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -5---access fail.
|
|
*******************************************************/
|
|
int32_t nvt_set_page(uint32_t addr)
|
|
{
|
|
uint8_t buf[4] = {0};
|
|
|
|
buf[0] = 0xFF; //set index/page/addr command
|
|
buf[1] = (addr >> 15) & 0xFF;
|
|
buf[2] = (addr >> 7) & 0xFF;
|
|
|
|
return CTP_SPI_WRITE(ts->client, buf, 3);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen write data to specify address.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -5---access fail.
|
|
*******************************************************/
|
|
int32_t nvt_write_addr(uint32_t addr, uint8_t data)
|
|
{
|
|
int32_t ret = 0;
|
|
uint8_t buf[4] = {0};
|
|
|
|
//---set xdata index---
|
|
buf[0] = 0xFF; //set index/page/addr command
|
|
buf[1] = (addr >> 15) & 0xFF;
|
|
buf[2] = (addr >> 7) & 0xFF;
|
|
ret = CTP_SPI_WRITE(ts->client, buf, 3);
|
|
if (ret) {
|
|
NVT_ERR("set page 0x%06X failed, ret = %d\n", addr, ret);
|
|
return ret;
|
|
}
|
|
|
|
//---write data to index---
|
|
buf[0] = addr & (0x7F);
|
|
buf[1] = data;
|
|
ret = CTP_SPI_WRITE(ts->client, buf, 2);
|
|
if (ret) {
|
|
NVT_ERR("write data to 0x%06X failed, ret = %d\n", addr, ret);
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen enable hw bld crc function.
|
|
|
|
return:
|
|
N/A.
|
|
*******************************************************/
|
|
void nvt_bld_crc_enable(void)
|
|
{
|
|
uint8_t buf[4] = {0};
|
|
|
|
//---set xdata index to BLD_CRC_EN_ADDR---
|
|
nvt_set_page(ts->mmap->BLD_CRC_EN_ADDR);
|
|
|
|
//---read data from index---
|
|
buf[0] = ts->mmap->BLD_CRC_EN_ADDR & (0x7F);
|
|
buf[1] = 0xFF;
|
|
CTP_SPI_READ(ts->client, buf, 2);
|
|
|
|
//---write data to index---
|
|
buf[0] = ts->mmap->BLD_CRC_EN_ADDR & (0x7F);
|
|
buf[1] = buf[1] | (0x01 << 7);
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen clear status & enable fw crc function.
|
|
|
|
return:
|
|
N/A.
|
|
*******************************************************/
|
|
void nvt_fw_crc_enable(void)
|
|
{
|
|
uint8_t buf[4] = {0};
|
|
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR);
|
|
|
|
//---clear fw reset status---
|
|
buf[0] = EVENT_MAP_RESET_COMPLETE & (0x7F);
|
|
buf[1] = 0x00;
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
|
|
//---enable fw crc---
|
|
buf[0] = EVENT_MAP_HOST_CMD & (0x7F);
|
|
buf[1] = 0xAE; //enable fw crc command
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen set boot ready function.
|
|
|
|
return:
|
|
N/A.
|
|
*******************************************************/
|
|
void nvt_boot_ready(void)
|
|
{
|
|
//---write BOOT_RDY status cmds---
|
|
nvt_write_addr(ts->mmap->BOOT_RDY_ADDR, 1);
|
|
|
|
mdelay(5);
|
|
|
|
if (!ts->hw_crc) {
|
|
//---write BOOT_RDY status cmds---
|
|
nvt_write_addr(ts->mmap->BOOT_RDY_ADDR, 0);
|
|
|
|
//---write POR_CD cmds---
|
|
nvt_write_addr(ts->mmap->POR_CD_ADDR, 0xA0);
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen eng reset cmd
|
|
function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
void nvt_eng_reset(void)
|
|
{
|
|
//---eng reset cmds to ENG_RST_ADDR---
|
|
nvt_write_addr(ENG_RST_ADDR, 0x5A);
|
|
|
|
mdelay(1); //wait tMCU_Idle2TP_REX_Hi after TP_RST
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen reset MCU
|
|
function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
void nvt_sw_reset(void)
|
|
{
|
|
//---software reset cmds to SWRST_N8_ADDR---
|
|
nvt_write_addr(SWRST_N8_ADDR, 0x55);
|
|
|
|
msleep(10);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen reset MCU then into idle mode
|
|
function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
void nvt_sw_reset_idle(void)
|
|
{
|
|
//---MCU idle cmds to SWRST_N8_ADDR---
|
|
nvt_write_addr(SWRST_N8_ADDR, 0xAA);
|
|
|
|
msleep(15);
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen reset MCU (boot) function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
void nvt_bootloader_reset(void)
|
|
{
|
|
//---reset cmds to SWRST_N8_ADDR---
|
|
nvt_write_addr(SWRST_N8_ADDR, 0x69);
|
|
|
|
mdelay(5); //wait tBRST2FR after Bootload RST
|
|
|
|
if (SPI_RD_FAST_ADDR) {
|
|
/* disable SPI_RD_FAST */
|
|
nvt_write_addr(SPI_RD_FAST_ADDR, 0x00);
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen clear FW status function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -1---fail.
|
|
*******************************************************/
|
|
int32_t nvt_clear_fw_status(void)
|
|
{
|
|
uint8_t buf[8] = {0};
|
|
int32_t i = 0;
|
|
const int32_t retry = 20;
|
|
|
|
for (i = 0; i < retry; i++) {
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR | EVENT_MAP_HANDSHAKING_or_SUB_CMD_BYTE);
|
|
|
|
//---clear fw status---
|
|
buf[0] = EVENT_MAP_HANDSHAKING_or_SUB_CMD_BYTE;
|
|
buf[1] = 0x00;
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
|
|
//---read fw status---
|
|
buf[0] = EVENT_MAP_HANDSHAKING_or_SUB_CMD_BYTE;
|
|
buf[1] = 0xFF;
|
|
CTP_SPI_READ(ts->client, buf, 2);
|
|
|
|
if (buf[1] == 0x00)
|
|
break;
|
|
|
|
usleep_range(10000, 10000);
|
|
}
|
|
|
|
if (i >= retry) {
|
|
NVT_ERR("failed, i=%d, buf[1]=0x%02X\n", i, buf[1]);
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen check FW status function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -1---failed.
|
|
*******************************************************/
|
|
int32_t nvt_check_fw_status(void)
|
|
{
|
|
uint8_t buf[8] = {0};
|
|
int32_t i = 0;
|
|
const int32_t retry = 50;
|
|
|
|
for (i = 0; i < retry; i++) {
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR | EVENT_MAP_HANDSHAKING_or_SUB_CMD_BYTE);
|
|
|
|
//---read fw status---
|
|
buf[0] = EVENT_MAP_HANDSHAKING_or_SUB_CMD_BYTE;
|
|
buf[1] = 0x00;
|
|
CTP_SPI_READ(ts->client, buf, 2);
|
|
|
|
if ((buf[1] & 0xF0) == 0xA0)
|
|
break;
|
|
|
|
usleep_range(10000, 10000);
|
|
}
|
|
|
|
if (i >= retry) {
|
|
NVT_ERR("failed, i=%d, buf[1]=0x%02X\n", i, buf[1]);
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen check FW reset state function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -1---failed.
|
|
*******************************************************/
|
|
int32_t nvt_check_fw_reset_state(RST_COMPLETE_STATE check_reset_state)
|
|
{
|
|
uint8_t buf[8] = {0};
|
|
int32_t ret = 0;
|
|
int32_t retry = 0;
|
|
int32_t retry_max = (check_reset_state == RESET_STATE_INIT) ? 10 : 50;
|
|
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR | EVENT_MAP_RESET_COMPLETE);
|
|
|
|
while (1) {
|
|
//---read reset state---
|
|
buf[0] = EVENT_MAP_RESET_COMPLETE;
|
|
buf[1] = 0x00;
|
|
CTP_SPI_READ(ts->client, buf, 6);
|
|
|
|
if ((buf[1] >= check_reset_state) && (buf[1] <= RESET_STATE_MAX)) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
|
|
retry++;
|
|
if(unlikely(retry > retry_max)) {
|
|
NVT_ERR("error, retry=%d, buf[1]=0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X\n",
|
|
retry, buf[1], buf[2], buf[3], buf[4], buf[5]);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
usleep_range(10000, 10000);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen get novatek project id information
|
|
function.
|
|
|
|
return:
|
|
Executive outcomes. 0---success. -1---fail.
|
|
*******************************************************/
|
|
int32_t nvt_read_pid(void)
|
|
{
|
|
uint8_t buf[3] = {0};
|
|
int32_t ret = 0;
|
|
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR | EVENT_MAP_PROJECTID);
|
|
|
|
//---read project id---
|
|
buf[0] = EVENT_MAP_PROJECTID;
|
|
buf[1] = 0x00;
|
|
buf[2] = 0x00;
|
|
CTP_SPI_READ(ts->client, buf, 3);
|
|
|
|
ts->nvt_pid = (buf[2] << 8) + buf[1];
|
|
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR);
|
|
|
|
NVT_LOG("PID=%04X\n", ts->nvt_pid);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen get firmware related information
|
|
function.
|
|
|
|
return:
|
|
Executive outcomes. 0---success. -1---fail.
|
|
*******************************************************/
|
|
int32_t nvt_get_fw_info(void)
|
|
{
|
|
uint8_t buf[64] = {0};
|
|
uint32_t retry_count = 0;
|
|
int32_t ret = 0;
|
|
|
|
info_retry:
|
|
//---set xdata index to EVENT BUF ADDR---
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR | EVENT_MAP_FWINFO);
|
|
|
|
//---read fw info---
|
|
buf[0] = EVENT_MAP_FWINFO;
|
|
CTP_SPI_READ(ts->client, buf, 17);
|
|
ts->fw_ver = buf[1];
|
|
ts->x_num = buf[3];
|
|
ts->y_num = buf[4];
|
|
ts->abs_x_max = (uint16_t)((buf[5] << 8) | buf[6]);
|
|
ts->abs_y_max = (uint16_t)((buf[7] << 8) | buf[8]);
|
|
ts->max_button_num = buf[11];
|
|
|
|
//---clear x_num, y_num if fw info is broken---
|
|
if ((buf[1] + buf[2]) != 0xFF) {
|
|
NVT_ERR("FW info is broken! fw_ver=0x%02X, ~fw_ver=0x%02X\n", buf[1], buf[2]);
|
|
ts->fw_ver = 0;
|
|
ts->x_num = 18;
|
|
ts->y_num = 32;
|
|
#ifdef CONFIG_MTK_FB
|
|
ts->abs_x_max = DISP_GetScreenWidth();
|
|
ts->abs_y_max = DISP_GetScreenHeight();
|
|
#endif
|
|
ts->max_button_num = TOUCH_KEY_NUM;
|
|
|
|
if(retry_count < 3) {
|
|
retry_count++;
|
|
NVT_ERR("retry_count=%d\n", retry_count);
|
|
goto info_retry;
|
|
} else {
|
|
NVT_ERR("Set default fw_ver=%d, x_num=%d, y_num=%d, "
|
|
"abs_x_max=%d, abs_y_max=%d, max_button_num=%d!\n",
|
|
ts->fw_ver, ts->x_num, ts->y_num,
|
|
ts->abs_x_max, ts->abs_y_max, ts->max_button_num);
|
|
ret = -1;
|
|
}
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
|
|
NVT_LOG("fw_ver = 0x%02X, fw_type = 0x%02X\n", ts->fw_ver, buf[14]);
|
|
|
|
//---Get Novatek PID---
|
|
nvt_read_pid();
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Create Device Node (Proc Entry)
|
|
*******************************************************/
|
|
#if NVT_TOUCH_PROC
|
|
static struct proc_dir_entry *NVT_proc_entry;
|
|
#define DEVICE_NAME "NVTSPI"
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen /proc/NVTSPI read function.
|
|
|
|
return:
|
|
Executive outcomes. 2---succeed. -5,-14---failed.
|
|
*******************************************************/
|
|
static ssize_t nvt_flash_read(struct file *file, char __user *buff, size_t count, loff_t *offp)
|
|
{
|
|
uint8_t *str = NULL;
|
|
int32_t ret = 0;
|
|
int32_t retries = 0;
|
|
int8_t spi_wr = 0;
|
|
uint8_t *buf;
|
|
|
|
if ((count > NVT_TRANSFER_LEN + 3) || (count < 3)) {
|
|
NVT_ERR("invalid transfer len!\n");
|
|
return -EFAULT;
|
|
}
|
|
|
|
/* allocate buffer for spi transfer */
|
|
str = (uint8_t *)kzalloc((count), GFP_KERNEL);
|
|
if(str == NULL) {
|
|
NVT_ERR("kzalloc for buf failed!\n");
|
|
ret = -ENOMEM;
|
|
goto kzalloc_failed;
|
|
}
|
|
|
|
buf = (uint8_t *)kzalloc((count), GFP_KERNEL | GFP_DMA);
|
|
if(buf == NULL) {
|
|
NVT_ERR("kzalloc for buf failed!\n");
|
|
ret = -ENOMEM;
|
|
kfree(str);
|
|
str = NULL;
|
|
goto kzalloc_failed;
|
|
}
|
|
|
|
if (copy_from_user(str, buff, count)) {
|
|
NVT_ERR("copy from user error\n");
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
/*
|
|
* stop esd check work to avoid case that 0x77 report righ after here to enable esd check again
|
|
* finally lead to trigger esd recovery bootloader reset
|
|
*/
|
|
cancel_delayed_work_sync(&nvt_esd_check_work);
|
|
nvt_esd_check_enable(false);
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
spi_wr = str[0] >> 7;
|
|
memcpy(buf, str+2, ((str[0] & 0x7F) << 8) | str[1]);
|
|
|
|
if (spi_wr == NVTWRITE) { //SPI write
|
|
while (retries < 3) {
|
|
ret = CTP_SPI_WRITE(ts->client, buf, ((str[0] & 0x7F) << 8) | str[1]);
|
|
if (!ret)
|
|
break;
|
|
else
|
|
NVT_ERR("error, retries=%d, ret=%d\n", retries, ret);
|
|
|
|
retries++;
|
|
}
|
|
|
|
if (unlikely(retries == 20)) {
|
|
NVT_ERR("error, ret = %d\n", ret);
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
} else if (spi_wr == NVTREAD) { //SPI read
|
|
while (retries < 3) {
|
|
ret = CTP_SPI_READ(ts->client, buf, ((str[0] & 0x7F) << 8) | str[1]);
|
|
if (!ret)
|
|
break;
|
|
else
|
|
NVT_ERR("error, retries=%d, ret=%d\n", retries, ret);
|
|
|
|
retries++;
|
|
}
|
|
|
|
memcpy(str+2, buf, ((str[0] & 0x7F) << 8) | str[1]);
|
|
// copy buff to user if spi transfer
|
|
if (retries < 3) {
|
|
if (copy_to_user(buff, str, count)) {
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if (unlikely(retries == 3)) {
|
|
NVT_ERR("error, ret = %d\n", ret);
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
} else {
|
|
NVT_ERR("Call error, str[0]=%d\n", str[0]);
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
kfree(str);
|
|
kfree(buf);
|
|
kzalloc_failed:
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen /proc/NVTSPI open function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -12---failed.
|
|
*******************************************************/
|
|
static int32_t nvt_flash_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct nvt_flash_data *dev;
|
|
|
|
dev = kmalloc(sizeof(struct nvt_flash_data), GFP_KERNEL);
|
|
if (dev == NULL) {
|
|
NVT_ERR("Failed to allocate memory for nvt flash data\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
rwlock_init(&dev->lock);
|
|
file->private_data = dev;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen /proc/NVTSPI close function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed.
|
|
*******************************************************/
|
|
static int32_t nvt_flash_close(struct inode *inode, struct file *file)
|
|
{
|
|
struct nvt_flash_data *dev = file->private_data;
|
|
|
|
if (dev)
|
|
kfree(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations nvt_flash_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = nvt_flash_open,
|
|
.release = nvt_flash_close,
|
|
.read = nvt_flash_read,
|
|
};
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen /proc/NVTSPI initial function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. -12---failed.
|
|
*******************************************************/
|
|
static int32_t nvt_flash_proc_init(void)
|
|
{
|
|
NVT_proc_entry = proc_create(DEVICE_NAME, 0444, NULL,&nvt_flash_fops);
|
|
if (NVT_proc_entry == NULL) {
|
|
NVT_ERR("Failed!\n");
|
|
return -ENOMEM;
|
|
} else {
|
|
NVT_LOG("Succeeded!\n");
|
|
}
|
|
|
|
NVT_LOG("============================================================\n");
|
|
NVT_LOG("Create /proc/%s\n", DEVICE_NAME);
|
|
NVT_LOG("============================================================\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen /proc/NVTSPI deinitial function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
static void nvt_flash_proc_deinit(void)
|
|
{
|
|
if (NVT_proc_entry != NULL) {
|
|
remove_proc_entry(DEVICE_NAME, NULL);
|
|
NVT_proc_entry = NULL;
|
|
NVT_LOG("Removed /proc/%s\n", DEVICE_NAME);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen parse device tree function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
static int32_t nvt_parse_dt(struct device *dev)
|
|
{
|
|
struct device_node *np = dev->of_node;
|
|
int32_t ret = 0;
|
|
ret = of_property_read_u32(np, "novatek,swrst-n8-addr", &SWRST_N8_ADDR);
|
|
if (ret) {
|
|
NVT_ERR("error reading novatek,swrst-n8-addr. ret=%d\n", ret);
|
|
return ret;
|
|
} else {
|
|
NVT_LOG("SWRST_N8_ADDR=0x%06X\n", SWRST_N8_ADDR);
|
|
}
|
|
|
|
ret = of_property_read_u32(np, "novatek,spi-rd-fast-addr", &SPI_RD_FAST_ADDR);
|
|
if (ret) {
|
|
NVT_LOG("not support novatek,spi-rd-fast-addr\n");
|
|
SPI_RD_FAST_ADDR = 0;
|
|
ret = 0;
|
|
} else {
|
|
NVT_LOG("SPI_RD_FAST_ADDR=0x%06X\n", SPI_RD_FAST_ADDR);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static uint8_t nvt_fw_recovery(uint8_t *point_data)
|
|
{
|
|
uint8_t i = 0;
|
|
uint8_t detected = true;
|
|
|
|
/* check pattern */
|
|
for (i=1 ; i<7 ; i++) {
|
|
if (point_data[i] != 0x77) {
|
|
detected = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return detected;
|
|
}
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
void nvt_esd_check_enable(uint8_t enable)
|
|
{
|
|
/* update interrupt timer */
|
|
irq_timer = jiffies;
|
|
/* clear esd_retry counter, if protect function is enabled */
|
|
esd_retry = enable ? 0 : esd_retry;
|
|
/* enable/disable esd check flag */
|
|
esd_check = enable;
|
|
}
|
|
|
|
static void nvt_esd_check_func(struct work_struct *work)
|
|
{
|
|
unsigned int timer = jiffies_to_msecs(jiffies - irq_timer);
|
|
|
|
//NVT_LOG("esd_check = %d (retry %d)\n", esd_check, esd_retry); //DEBUG
|
|
|
|
if ((timer > NVT_TOUCH_ESD_CHECK_PERIOD) && esd_check) {
|
|
mutex_lock(&ts->lock);
|
|
NVT_ERR("do ESD recovery, timer = %d, retry = %d\n", timer, esd_retry);
|
|
/* do esd recovery, reload fw */
|
|
nvt_choose_fw(true);
|
|
mutex_unlock(&ts->lock);
|
|
/* update interrupt timer */
|
|
irq_timer = jiffies;
|
|
/* update esd_retry counter */
|
|
esd_retry++;
|
|
}
|
|
|
|
queue_delayed_work(nvt_esd_check_wq, &nvt_esd_check_work,
|
|
msecs_to_jiffies(NVT_TOUCH_ESD_CHECK_PERIOD));
|
|
}
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
#if NVT_TOUCH_WDT_RECOVERY
|
|
static uint8_t recovery_cnt = 0;
|
|
static uint8_t nvt_wdt_fw_recovery(uint8_t *point_data)
|
|
{
|
|
uint32_t recovery_cnt_max = 10;
|
|
uint8_t recovery_enable = false;
|
|
uint8_t i = 0;
|
|
|
|
recovery_cnt++;
|
|
|
|
/* check pattern */
|
|
for (i=1 ; i<7 ; i++) {
|
|
if ((point_data[i] != 0xFD) && (point_data[i] != 0xFE)) {
|
|
recovery_cnt = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (recovery_cnt > recovery_cnt_max){
|
|
recovery_enable = true;
|
|
recovery_cnt = 0;
|
|
}
|
|
|
|
return recovery_enable;
|
|
}
|
|
void nvt_read_fw_history(uint32_t fw_history_addr)
|
|
{
|
|
uint8_t i = 0;
|
|
uint8_t buf[65];
|
|
char str[128];
|
|
|
|
if (fw_history_addr == 0)
|
|
return;
|
|
|
|
nvt_set_page(fw_history_addr);
|
|
|
|
buf[0] = (uint8_t) (fw_history_addr & 0x7F);
|
|
CTP_SPI_READ(ts->client, buf, 64+1); //read 64bytes history
|
|
|
|
//print all data
|
|
NVT_LOG("fw history 0x%x: \n", fw_history_addr);
|
|
for (i = 0; i < 4; i++) {
|
|
snprintf(str, sizeof(str),
|
|
"%02X %02X %02X %02X %02X %02X %02X %02X "
|
|
"%02X %02X %02X %02X %02X %02X %02X %02X\n",
|
|
buf[1+i*16], buf[2+i*16], buf[3+i*16], buf[4+i*16],
|
|
buf[5+i*16], buf[6+i*16], buf[7+i*16], buf[8+i*16],
|
|
buf[9+i*16], buf[10+i*16], buf[11+i*16], buf[12+i*16],
|
|
buf[13+i*16], buf[14+i*16], buf[15+i*16], buf[16+i*16]);
|
|
NVT_LOG("%s", str);
|
|
}
|
|
|
|
nvt_set_page(ts->mmap->EVENT_BUF_ADDR);
|
|
}
|
|
#endif /* #if NVT_TOUCH_WDT_RECOVERY */
|
|
|
|
#if POINT_DATA_CHECKSUM
|
|
static int32_t nvt_ts_point_data_checksum(uint8_t *buf, uint8_t length)
|
|
{
|
|
uint8_t checksum = 0;
|
|
int32_t i = 0;
|
|
|
|
// Generate checksum
|
|
for (i = 0; i < length - 1; i++) {
|
|
checksum += buf[i + 1];
|
|
}
|
|
checksum = (~checksum + 1);
|
|
|
|
// Compare ckecksum and dump fail data
|
|
if (checksum != buf[length]) {
|
|
NVT_ERR("i2c/spi packet checksum not match. (point_data[%d]=0x%02X, checksum=0x%02X)\n",
|
|
length, buf[length], checksum);
|
|
#if 0
|
|
for (i = 0; i < 10; i++) {
|
|
NVT_LOG("%02X %02X %02X %02X %02X %02X\n",
|
|
buf[1 + i*6], buf[2 + i*6], buf[3 + i*6], buf[4 + i*6], buf[5 + i*6], buf[6 + i*6]);
|
|
}
|
|
NVT_LOG("%02X %02X %02X %02X %02X\n", buf[61], buf[62], buf[63], buf[64], buf[65]);
|
|
#endif
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* POINT_DATA_CHECKSUM */
|
|
|
|
#define POINT_DATA_LEN 65
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen work function.
|
|
|
|
return:
|
|
n.a.
|
|
*******************************************************/
|
|
static irqreturn_t nvt_ts_work_func(int irq, void *data)
|
|
{
|
|
int32_t ret = -1;
|
|
uint8_t point_data[POINT_DATA_LEN + 1 + DUMMY_BYTES] = {0};
|
|
uint32_t position = 0;
|
|
static int input_x = 0;
|
|
static int input_y = 0;
|
|
uint32_t input_w = 0;
|
|
uint32_t input_p = 0;
|
|
uint8_t input_id = 0;
|
|
#if MT_PROTOCOL_B
|
|
uint8_t press_id[TOUCH_MAX_FINGER_NUM] = {0};
|
|
#endif /* MT_PROTOCOL_B */
|
|
int32_t i = 0;
|
|
int32_t finger_cnt = 0;
|
|
static int touch_down = 0;
|
|
|
|
#if WAKEUP_GESTURE
|
|
if (bTouchIsAwake == 0) {
|
|
pm_wakeup_event(&ts->input_dev->dev, 3000);
|
|
}
|
|
#endif
|
|
|
|
mutex_lock(&ts->lock);
|
|
|
|
ret = CTP_SPI_READ(ts->client, point_data, POINT_DATA_LEN + 1);
|
|
if (ret < 0) {
|
|
NVT_ERR("CTP_SPI_READ failed.(%d)\n", ret);
|
|
goto XFER_ERROR;
|
|
}
|
|
#if NVT_TOUCH_WDT_RECOVERY
|
|
/* ESD protect by WDT */
|
|
if (nvt_wdt_fw_recovery(point_data)) {
|
|
NVT_ERR("Recover for fw reset, %02X\n", point_data[1]);
|
|
if (point_data[1] == 0xFE) {
|
|
nvt_sw_reset_idle();
|
|
}
|
|
nvt_read_fw_history(ts->mmap->MMAP_HISTORY_EVENT0);
|
|
nvt_read_fw_history(ts->mmap->MMAP_HISTORY_EVENT1);
|
|
nvt_choose_fw(true);
|
|
if (bTouchIsAwake == 0) {
|
|
point_data[0] = EVENT_MAP_HOST_CMD;
|
|
point_data[1] = 0x13;
|
|
CTP_SPI_WRITE(ts->client, point_data, 2);
|
|
NVT_LOG("Enabled touch wakeup gesture\n");
|
|
}
|
|
goto XFER_ERROR;
|
|
}
|
|
#endif /* #if NVT_TOUCH_WDT_RECOVERY */
|
|
|
|
/* ESD protect by FW handshake */
|
|
if (nvt_fw_recovery(point_data)) {
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
nvt_esd_check_enable(true);
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
goto XFER_ERROR;
|
|
}
|
|
|
|
#if POINT_DATA_CHECKSUM
|
|
if (POINT_DATA_LEN >= POINT_DATA_CHECKSUM_LEN) {
|
|
ret = nvt_ts_point_data_checksum(point_data, POINT_DATA_CHECKSUM_LEN);
|
|
if (ret) {
|
|
goto XFER_ERROR;
|
|
}
|
|
}
|
|
#endif /* POINT_DATA_CHECKSUM */
|
|
|
|
#if WAKEUP_GESTURE
|
|
if (bTouchIsAwake == 0) {
|
|
input_id = (uint8_t)(point_data[1] >> 3);
|
|
mutex_unlock(&ts->lock);
|
|
return IRQ_HANDLED;
|
|
}
|
|
#endif
|
|
|
|
if((point_data[1]==0xF0) && (point_data[2]==0x04) && (point_data[3]==0x01)){
|
|
NVT_LOG ("got PalmPress");
|
|
input_report_key(ts->input_dev, KEY_F14, 1);
|
|
input_sync(ts->input_dev);
|
|
}else if((point_data[1]==0xF0) && (point_data[2]==0x04) && (point_data[3]==0x02)){
|
|
NVT_LOG ("got PalmLeave");
|
|
input_report_key(ts->input_dev, KEY_F14, 0);
|
|
input_sync(ts->input_dev);
|
|
}
|
|
|
|
finger_cnt = 0;
|
|
|
|
for (i = 0; i < ts->max_touch_num; i++) {
|
|
position = 1 + 6 * i;
|
|
input_id = (uint8_t)(point_data[position + 0] >> 3);
|
|
if ((input_id == 0) || (input_id > ts->max_touch_num))
|
|
continue;
|
|
|
|
if (((point_data[position] & 0x07) == 0x01) || ((point_data[position] & 0x07) == 0x02)) { //finger down (enter & moving)
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
/* update interrupt timer */
|
|
irq_timer = jiffies;
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
input_x = (uint32_t)(point_data[position + 1] << 4) + (uint32_t) (point_data[position + 3] >> 4);
|
|
input_y = (uint32_t)(point_data[position + 2] << 4) + (uint32_t) (point_data[position + 3] & 0x0F);
|
|
if ((input_x < 0) || (input_y < 0))
|
|
continue;
|
|
if ((input_x > ts->abs_x_max) || (input_y > ts->abs_y_max))
|
|
continue;
|
|
input_w = (uint32_t)(point_data[position + 4]);
|
|
if (input_w == 0)
|
|
input_w = 1;
|
|
if (i < 2) {
|
|
input_p = (uint32_t)(point_data[position + 5]) + (uint32_t)(point_data[i + 63] << 8);
|
|
if (input_p > TOUCH_FORCE_NUM)
|
|
input_p = TOUCH_FORCE_NUM;
|
|
} else {
|
|
input_p = (uint32_t)(point_data[position + 5]);
|
|
}
|
|
if (input_p == 0)
|
|
input_p = 1;
|
|
if(!touch_down)
|
|
{
|
|
NVT_LOG("touch down (input_x,input_y)=(%d, %d)", input_x, input_y);
|
|
touch_down++;
|
|
}
|
|
|
|
#if MT_PROTOCOL_B
|
|
press_id[input_id - 1] = 1;
|
|
input_mt_slot(ts->input_dev, input_id - 1);
|
|
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
|
|
#else /* MT_PROTOCOL_B */
|
|
input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, input_id - 1);
|
|
input_report_key(ts->input_dev, BTN_TOUCH, 1);
|
|
#endif /* MT_PROTOCOL_B */
|
|
|
|
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);
|
|
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);
|
|
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
|
|
input_report_abs(ts->input_dev, ABS_MT_PRESSURE, input_p);
|
|
|
|
#if MT_PROTOCOL_B
|
|
#else /* MT_PROTOCOL_B */
|
|
input_mt_sync(ts->input_dev);
|
|
#endif /* MT_PROTOCOL_B */
|
|
|
|
finger_cnt++;
|
|
}
|
|
|
|
}
|
|
if(finger_cnt == 0){
|
|
touch_down = 0;
|
|
NVT_LOG("touch up (input_x,input_y)=(%d, %d)", input_x, input_y);
|
|
}
|
|
|
|
#if MT_PROTOCOL_B
|
|
for (i = 0; i < ts->max_touch_num; i++) {
|
|
if (press_id[i] != 1) {
|
|
input_mt_slot(ts->input_dev, i);
|
|
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
|
|
input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
|
|
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
|
|
}
|
|
}
|
|
|
|
input_report_key(ts->input_dev, BTN_TOUCH, (finger_cnt > 0));
|
|
#else /* MT_PROTOCOL_B */
|
|
if (finger_cnt == 0) {
|
|
input_report_key(ts->input_dev, BTN_TOUCH, 0);
|
|
input_mt_sync(ts->input_dev);
|
|
}
|
|
#endif /* MT_PROTOCOL_B */
|
|
|
|
#if TOUCH_KEY_NUM > 0
|
|
if (point_data[61] == 0xF8) {
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
/* update interrupt timer */
|
|
irq_timer = jiffies;
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
for (i = 0; i < ts->max_button_num; i++) {
|
|
input_report_key(ts->input_dev, touch_key_array[i], ((point_data[62] >> i) & 0x01));
|
|
}
|
|
} else {
|
|
for (i = 0; i < ts->max_button_num; i++) {
|
|
input_report_key(ts->input_dev, touch_key_array[i], 0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
input_sync(ts->input_dev);
|
|
|
|
XFER_ERROR:
|
|
|
|
mutex_unlock(&ts->lock);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen check chip version trim function.
|
|
|
|
return:
|
|
Executive outcomes. 0---NVT IC. -1---not NVT IC.
|
|
*******************************************************/
|
|
static int8_t nvt_ts_check_chip_ver_trim(uint32_t chip_ver_trim_addr)
|
|
{
|
|
uint8_t buf[8] = {0};
|
|
int32_t retry = 0;
|
|
int32_t list = 0;
|
|
int32_t i = 0;
|
|
int32_t found_nvt_chip = 0;
|
|
int32_t ret = -1;
|
|
|
|
//---Check for 5 times---
|
|
for (retry = 3; retry > 0; retry--) {
|
|
|
|
nvt_bootloader_reset();
|
|
|
|
//---set xdata index to 0x1F600---
|
|
nvt_set_page(chip_ver_trim_addr);
|
|
|
|
buf[0] = chip_ver_trim_addr & 0x7F;
|
|
buf[1] = 0x00;
|
|
buf[2] = 0x00;
|
|
buf[3] = 0x00;
|
|
buf[4] = 0x00;
|
|
buf[5] = 0x00;
|
|
buf[6] = 0x00;
|
|
CTP_SPI_READ(ts->client, buf, 7);
|
|
NVT_LOG("buf[1]=0x%02X, buf[2]=0x%02X, buf[3]=0x%02X, buf[4]=0x%02X, buf[5]=0x%02X, buf[6]=0x%02X\n",
|
|
buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
|
|
|
|
// compare read chip id on supported list
|
|
for (list = 0; list < (sizeof(trim_id_table) / sizeof(struct nvt_ts_trim_id_table)); list++) {
|
|
found_nvt_chip = 0;
|
|
|
|
// compare each byte
|
|
for (i = 0; i < NVT_ID_BYTE_MAX; i++) {
|
|
if (trim_id_table[list].mask[i]) {
|
|
if (buf[i + 1] != trim_id_table[list].id[i])
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == NVT_ID_BYTE_MAX) {
|
|
found_nvt_chip = 1;
|
|
}
|
|
|
|
if (found_nvt_chip) {
|
|
NVT_LOG("This is NVT touch IC\n");
|
|
ts->mmap = trim_id_table[list].mmap;
|
|
ts->carrier_system = trim_id_table[list].hwinfo->carrier_system;
|
|
ts->hw_crc = trim_id_table[list].hwinfo->hw_crc;
|
|
ret = 0;
|
|
goto out;
|
|
} else {
|
|
ts->mmap = NULL;
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
msleep(10);
|
|
}
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
static char *lcm_names[]={
|
|
"nt36672c_fhdp_dsi_vdo_dsc_txd_boe",
|
|
};
|
|
|
|
static char *tp_names[]={
|
|
"TXD_NT36672C_00",
|
|
};
|
|
int32_t nvt_choose_fw(bool normal_fw)
|
|
{
|
|
char *lcm_name = mtkfb_find_lcm_driver();
|
|
if(normal_fw){
|
|
return nvt_update_firmware(BOOT_UPDATE_FIRMWARE_NAME);
|
|
}else{
|
|
return nvt_update_firmware(MP_UPDATE_FIRMWARE_NAME);
|
|
}
|
|
}
|
|
static ssize_t tp_firmware_version_show(struct device *dev,struct device_attribute *attr,char *buf)
|
|
{
|
|
nvt_get_fw_info();
|
|
return snprintf(buf,32,"0x%02x,bv:0x%02x\n", ts->fw_ver,ts->bv);
|
|
}
|
|
|
|
static ssize_t tp_firmware_version_store(struct device *dev,struct device_attribute *attr,const char *buf, size_t count)
|
|
{
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR(tp_firmware_version, 0644, tp_firmware_version_show, tp_firmware_version_store);
|
|
|
|
static ssize_t tp_vendor_show(struct device *dev,struct device_attribute *attr,char *buf)
|
|
{
|
|
int i=0;
|
|
char *lcm_name= mtkfb_find_lcm_driver();
|
|
for(i=0;i<sizeof(lcm_names)/sizeof(lcm_names[0]);i++){
|
|
if(strcmp(lcm_name,lcm_names[i])==0){
|
|
return sprintf(buf,"%s",tp_names[i]);
|
|
}
|
|
}
|
|
return sprintf(buf,"%s","unknow");
|
|
}
|
|
|
|
static ssize_t tp_vendor_store(struct device *dev,struct device_attribute *attr,const char *buf,size_t count)
|
|
{
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR(tp_vendor, 0644, tp_vendor_show, tp_vendor_store);
|
|
|
|
static struct device_attribute *novatek_attrs[] = {
|
|
&dev_attr_tp_firmware_version,
|
|
&dev_attr_tp_vendor,
|
|
};
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen driver probe function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed. negative---failed
|
|
*******************************************************/
|
|
static int32_t nvt_ts_probe(struct spi_device *client)
|
|
{
|
|
int32_t ret = 0;
|
|
|
|
struct device_node *np = NULL;
|
|
NVT_LOG("start\n");
|
|
|
|
ts = kmalloc(sizeof(struct nvt_ts_data), GFP_KERNEL);
|
|
if (ts == NULL) {
|
|
NVT_ERR("failed to allocated memory for nvt ts data\n");
|
|
return -ENOMEM;
|
|
}
|
|
ts->xbuf = (uint8_t *)kzalloc((NVT_TRANSFER_LEN+1+DUMMY_BYTES), GFP_KERNEL);
|
|
if(ts->xbuf == NULL) {
|
|
NVT_ERR("kzalloc for xbuf failed!\n");
|
|
goto err_malloc_xbuf;
|
|
}
|
|
|
|
ts->rbuf = (uint8_t *)kzalloc(NVT_READ_LEN, GFP_KERNEL);
|
|
if(ts->rbuf == NULL) {
|
|
NVT_ERR("kzalloc for rbuf failed!\n");
|
|
goto err_malloc_rbuf;
|
|
}
|
|
ts->client = client;
|
|
spi_set_drvdata(client, ts);
|
|
|
|
//---prepare for spi parameter---
|
|
if (ts->client->master->flags & SPI_MASTER_HALF_DUPLEX) {
|
|
NVT_ERR("Full duplex not supported by master\n");
|
|
ret = -EIO;
|
|
goto err_ckeck_full_duplex;
|
|
}
|
|
ts->client->bits_per_word = 8;
|
|
ts->client->mode = SPI_MODE_0;
|
|
|
|
ret = spi_setup(ts->client);
|
|
if (ret < 0) {
|
|
NVT_ERR("Failed to perform SPI setup\n");
|
|
goto err_spi_setup;
|
|
}
|
|
|
|
#ifdef CONFIG_MTK_SPI
|
|
/* old usage of MTK spi API */
|
|
memcpy(&ts->spi_ctrl, &spi_ctrdata, sizeof(struct mt_chip_conf));
|
|
ts->client->controller_data = (void *)&ts->spi_ctrl;
|
|
#endif
|
|
|
|
#ifdef CONFIG_SPI_MT65XX
|
|
/* new usage of MTK spi API */
|
|
memcpy(&ts->spi_ctrl, &spi_ctrdata, sizeof(struct mtk_chip_config));
|
|
ts->client->controller_data = (void *)&ts->spi_ctrl;
|
|
#endif
|
|
|
|
NVT_LOG("mode=%d, max_speed_hz=%d\n", ts->client->mode, ts->client->max_speed_hz);
|
|
|
|
//---parse dts---
|
|
ret = nvt_parse_dt(&client->dev);
|
|
if (ret) {
|
|
NVT_ERR("parse dt error\n");
|
|
goto err_spi_setup;
|
|
}
|
|
|
|
mutex_init(&ts->lock);
|
|
mutex_init(&ts->xbuf_lock);
|
|
|
|
//---eng reset before TP_RESX high
|
|
nvt_eng_reset();
|
|
|
|
#if NVT_TOUCH_SUPPORT_HW_RST
|
|
gpio_set_value(ts->reset_gpio, 1);
|
|
#endif
|
|
|
|
// need 10ms delay after POR(power on reset)
|
|
msleep(10);
|
|
|
|
//---check chip version trim---
|
|
ret = nvt_ts_check_chip_ver_trim(CHIP_VER_TRIM_ADDR);
|
|
if (ret) {
|
|
NVT_LOG("try to check from nt36528 chip ver trim address\n");
|
|
ret = nvt_ts_check_chip_ver_trim(CHIP_VER_TRIM_NT36528_ADDR);
|
|
if (ret) {
|
|
NVT_ERR("chip is not identified\n");
|
|
ret = -EINVAL;
|
|
goto err_chipvertrim_failed;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_MTK_FB
|
|
ts->abs_x_max = DISP_GetScreenWidth();
|
|
ts->abs_y_max = DISP_GetScreenHeight();
|
|
#endif
|
|
|
|
ts->input_dev = tpd->dev;
|
|
if (ts->input_dev == NULL) {
|
|
NVT_ERR("allocate input device failed\n");
|
|
ret = -ENOMEM;
|
|
goto err_input_dev_alloc_failed;
|
|
}
|
|
|
|
ts->max_touch_num = TOUCH_MAX_FINGER_NUM;
|
|
|
|
#if TOUCH_KEY_NUM > 0
|
|
ts->max_button_num = TOUCH_KEY_NUM;
|
|
#endif
|
|
|
|
ts->int_trigger_type = INT_TRIGGER_TYPE;
|
|
|
|
//---set input device info.---
|
|
ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
|
|
ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
|
|
ts->input_dev->propbit[0] = BIT(INPUT_PROP_DIRECT);
|
|
|
|
#if MT_PROTOCOL_B
|
|
input_mt_init_slots(ts->input_dev, ts->max_touch_num, 0);
|
|
#endif
|
|
|
|
input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, TOUCH_FORCE_NUM, 0, 0); //pressure = TOUCH_FORCE_NUM
|
|
|
|
#if TOUCH_MAX_FINGER_NUM > 1
|
|
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); //area = 255
|
|
|
|
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);
|
|
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);
|
|
#if MT_PROTOCOL_B
|
|
// no need to set ABS_MT_TRACKING_ID, input_mt_init_slots() already set it
|
|
#else
|
|
input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, ts->max_touch_num, 0, 0);
|
|
#endif //MT_PROTOCOL_B
|
|
#endif //TOUCH_MAX_FINGER_NUM > 1
|
|
|
|
#if TOUCH_KEY_NUM > 0
|
|
for (retry = 0; retry < ts->max_button_num; retry++) {
|
|
input_set_capability(ts->input_dev, EV_KEY, touch_key_array[retry]);
|
|
}
|
|
#endif
|
|
|
|
input_set_capability(ts->input_dev, EV_KEY, KEY_F13);
|
|
input_set_capability(ts->input_dev, EV_KEY, KEY_F14);
|
|
|
|
np=of_find_matching_node(np, touch_of_match);;
|
|
client->irq =irq_of_parse_and_map(np, 0);
|
|
if (client->irq) {
|
|
ts->irq_enabled = true;
|
|
|
|
ret = request_threaded_irq(client->irq, NULL, nvt_ts_work_func,
|
|
IRQF_TRIGGER_RISING | IRQF_ONESHOT, NVT_SPI_NAME, ts);
|
|
if (ret != 0) {
|
|
NVT_ERR("request irq failed. ret=%d\n", ret);
|
|
goto err_int_request_failed;
|
|
} else {
|
|
nvt_irq_enable(false);
|
|
NVT_LOG("request irq %d succeed\n", client->irq);
|
|
}
|
|
}
|
|
|
|
#if WAKEUP_GESTURE
|
|
device_init_wakeup(&ts->input_dev->dev, 1);
|
|
#endif
|
|
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
nvt_fwu_wq = alloc_workqueue("nvt_fwu_wq", WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
|
|
if (!nvt_fwu_wq) {
|
|
NVT_ERR("nvt_fwu_wq create workqueue failed\n");
|
|
ret = -ENOMEM;
|
|
goto err_create_nvt_fwu_wq_failed;
|
|
}
|
|
INIT_DELAYED_WORK(&ts->nvt_fwu_work, Boot_Update_Firmware);
|
|
// please make sure boot update start after display reset(RESX) sequence
|
|
queue_delayed_work(nvt_fwu_wq, &ts->nvt_fwu_work, msecs_to_jiffies(3000));
|
|
#endif
|
|
|
|
NVT_LOG("NVT_TOUCH_ESD_PROTECT is %d\n", NVT_TOUCH_ESD_PROTECT);
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
INIT_DELAYED_WORK(&nvt_esd_check_work, nvt_esd_check_func);
|
|
nvt_esd_check_wq = alloc_workqueue("nvt_esd_check_wq", WQ_MEM_RECLAIM, 1);
|
|
if (!nvt_esd_check_wq) {
|
|
NVT_ERR("nvt_esd_check_wq create workqueue failed\n");
|
|
ret = -ENOMEM;
|
|
goto err_create_nvt_esd_check_wq_failed;
|
|
}
|
|
queue_delayed_work(nvt_esd_check_wq, &nvt_esd_check_work,
|
|
msecs_to_jiffies(NVT_TOUCH_ESD_CHECK_PERIOD));
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
//---set device node---
|
|
#if NVT_TOUCH_PROC
|
|
ret = nvt_flash_proc_init();
|
|
if (ret != 0) {
|
|
NVT_ERR("nvt flash proc init failed. ret=%d\n", ret);
|
|
goto err_flash_proc_init_failed;
|
|
}
|
|
#endif
|
|
|
|
#if NVT_TOUCH_EXT_PROC
|
|
ret = nvt_extra_proc_init();
|
|
if (ret != 0) {
|
|
NVT_ERR("nvt extra proc init failed. ret=%d\n", ret);
|
|
goto err_extra_proc_init_failed;
|
|
}
|
|
#endif
|
|
|
|
#if NVT_TOUCH_MP
|
|
ret = nvt_mp_proc_init();
|
|
if (ret != 0) {
|
|
NVT_ERR("nvt mp proc init failed. ret=%d\n", ret);
|
|
goto err_mp_proc_init_failed;
|
|
}
|
|
#endif
|
|
//gesture_init_node();
|
|
bTouchIsAwake = 1;
|
|
tpd_load_status=1;
|
|
nvt_irq_enable(true);
|
|
NVT_LOG("end\n");
|
|
return 0;
|
|
|
|
#if NVT_TOUCH_MP
|
|
err_mp_proc_init_failed:
|
|
nvt_mp_proc_deinit();
|
|
#endif
|
|
#if NVT_TOUCH_EXT_PROC
|
|
nvt_extra_proc_deinit();
|
|
err_extra_proc_init_failed:
|
|
#endif
|
|
#if NVT_TOUCH_PROC
|
|
nvt_flash_proc_deinit();
|
|
err_flash_proc_init_failed:
|
|
#endif
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
if (nvt_esd_check_wq) {
|
|
cancel_delayed_work_sync(&nvt_esd_check_work);
|
|
destroy_workqueue(nvt_esd_check_wq);
|
|
nvt_esd_check_wq = NULL;
|
|
}
|
|
err_create_nvt_esd_check_wq_failed:
|
|
#endif
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
if (nvt_fwu_wq) {
|
|
cancel_delayed_work_sync(&ts->nvt_fwu_work);
|
|
destroy_workqueue(nvt_fwu_wq);
|
|
nvt_fwu_wq = NULL;
|
|
}
|
|
err_create_nvt_fwu_wq_failed:
|
|
#endif
|
|
#if WAKEUP_GESTURE
|
|
device_init_wakeup(&ts->input_dev->dev, 0);
|
|
#endif
|
|
free_irq(client->irq, ts);
|
|
err_int_request_failed:
|
|
err_input_dev_alloc_failed:
|
|
err_chipvertrim_failed:
|
|
mutex_destroy(&ts->xbuf_lock);
|
|
mutex_destroy(&ts->lock);
|
|
err_spi_setup:
|
|
err_ckeck_full_duplex:
|
|
spi_set_drvdata(client, NULL);
|
|
if (ts->rbuf) {
|
|
kfree(ts->rbuf);
|
|
ts->rbuf = NULL;
|
|
}
|
|
err_malloc_rbuf:
|
|
if (ts->xbuf) {
|
|
kfree(ts->xbuf);
|
|
ts->xbuf = NULL;
|
|
}
|
|
err_malloc_xbuf:
|
|
if (ts) {
|
|
kfree(ts);
|
|
ts = NULL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen driver release function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed.
|
|
*******************************************************/
|
|
static int32_t nvt_ts_remove(struct spi_device *client)
|
|
{
|
|
NVT_LOG("Removing driver...\n");
|
|
|
|
#if NVT_TOUCH_MP
|
|
nvt_mp_proc_deinit();
|
|
#endif
|
|
#if NVT_TOUCH_EXT_PROC
|
|
nvt_extra_proc_deinit();
|
|
#endif
|
|
#if NVT_TOUCH_PROC
|
|
nvt_flash_proc_deinit();
|
|
#endif
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
if (nvt_esd_check_wq) {
|
|
cancel_delayed_work_sync(&nvt_esd_check_work);
|
|
nvt_esd_check_enable(false);
|
|
destroy_workqueue(nvt_esd_check_wq);
|
|
nvt_esd_check_wq = NULL;
|
|
}
|
|
#endif
|
|
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
if (nvt_fwu_wq) {
|
|
cancel_delayed_work_sync(&ts->nvt_fwu_work);
|
|
destroy_workqueue(nvt_fwu_wq);
|
|
nvt_fwu_wq = NULL;
|
|
}
|
|
#endif
|
|
|
|
#if WAKEUP_GESTURE
|
|
device_init_wakeup(&ts->input_dev->dev, 0);
|
|
#endif
|
|
|
|
nvt_irq_enable(false);
|
|
free_irq(client->irq, ts);
|
|
|
|
mutex_destroy(&ts->xbuf_lock);
|
|
mutex_destroy(&ts->lock);
|
|
|
|
if (ts->input_dev) {
|
|
input_unregister_device(ts->input_dev);
|
|
ts->input_dev = NULL;
|
|
}
|
|
|
|
spi_set_drvdata(client, NULL);
|
|
|
|
if (ts) {
|
|
kfree(ts);
|
|
ts = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void nvt_ts_shutdown(struct spi_device *client)
|
|
{
|
|
NVT_LOG("Shutdown driver...\n");
|
|
disable_irq_nosync(client->irq);
|
|
#if NVT_TOUCH_MP
|
|
nvt_mp_proc_deinit();
|
|
#endif
|
|
#if NVT_TOUCH_EXT_PROC
|
|
nvt_extra_proc_deinit();
|
|
#endif
|
|
#if NVT_TOUCH_PROC
|
|
nvt_flash_proc_deinit();
|
|
#endif
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
if (nvt_esd_check_wq) {
|
|
cancel_delayed_work_sync(&nvt_esd_check_work);
|
|
nvt_esd_check_enable(false);
|
|
destroy_workqueue(nvt_esd_check_wq);
|
|
nvt_esd_check_wq = NULL;
|
|
}
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
if (nvt_fwu_wq) {
|
|
cancel_delayed_work_sync(&ts->nvt_fwu_work);
|
|
destroy_workqueue(nvt_fwu_wq);
|
|
nvt_fwu_wq = NULL;
|
|
}
|
|
#endif
|
|
|
|
#if WAKEUP_GESTURE
|
|
device_init_wakeup(&ts->input_dev->dev, 0);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen driver suspend function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed.
|
|
*******************************************************/
|
|
static void nvt_ts_suspend(struct device *dev)
|
|
{
|
|
uint8_t buf[4] = {0};
|
|
/*
|
|
#if MT_PROTOCOL_B
|
|
uint32_t i = 0;
|
|
#endif */
|
|
|
|
if (!bTouchIsAwake) {
|
|
NVT_LOG("Touch is already suspend\n");
|
|
return;
|
|
}
|
|
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
NVT_LOG("cancel delayed work sync\n");
|
|
cancel_delayed_work_sync(&nvt_esd_check_work);
|
|
nvt_esd_check_enable(false);
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
mutex_lock(&ts->lock);
|
|
|
|
//NVT_LOG("%s start\n",(jran_gesture_fun_enable=SetDozeStatus())?"gesture mode":"deep mode");
|
|
|
|
bTouchIsAwake = 0;
|
|
if(jran_gesture_fun_enable){
|
|
//---write command to enter "wakeup gesture mode"---
|
|
buf[0] = EVENT_MAP_HOST_CMD;
|
|
buf[1] = 0x13;
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
enable_irq_wake(ts->client->irq);
|
|
}else{
|
|
//---write command to enter "deep sleep mode"---
|
|
buf[0] = EVENT_MAP_HOST_CMD;
|
|
buf[1] = 0x11;
|
|
CTP_SPI_WRITE(ts->client, buf, 2);
|
|
}
|
|
|
|
mutex_unlock(&ts->lock);
|
|
/* release all touches */
|
|
/*
|
|
#if MT_PROTOCOL_B
|
|
for (i = 0; i < ts->max_touch_num; i++) {
|
|
input_mt_slot(ts->input_dev, i);
|
|
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
|
|
input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
|
|
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);
|
|
}
|
|
#endif
|
|
input_report_key(ts->input_dev, BTN_TOUCH, 0);
|
|
#if !MT_PROTOCOL_B
|
|
input_mt_sync(ts->input_dev);
|
|
#endif
|
|
input_sync(ts->input_dev);*/
|
|
msleep(50);
|
|
|
|
NVT_LOG("end\n");
|
|
|
|
return;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Novatek touchscreen driver resume function.
|
|
|
|
return:
|
|
Executive outcomes. 0---succeed.
|
|
*******************************************************/
|
|
static void nvt_ts_resume(struct device *dev)
|
|
{
|
|
#if MT_PROTOCOL_B
|
|
uint32_t i = 0;
|
|
#endif
|
|
/* release all touches */
|
|
#if MT_PROTOCOL_B
|
|
for (i = 0; i < ts->max_touch_num; i++) {
|
|
input_mt_slot(ts->input_dev, i);
|
|
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
|
|
input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
|
|
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);
|
|
}
|
|
#endif
|
|
input_report_key(ts->input_dev, BTN_TOUCH, 0);
|
|
#if !MT_PROTOCOL_B
|
|
input_mt_sync(ts->input_dev);
|
|
#endif
|
|
input_sync(ts->input_dev);
|
|
if (bTouchIsAwake) {
|
|
NVT_LOG("Touch is already resume\n");
|
|
return;
|
|
}
|
|
|
|
mutex_lock(&ts->lock);
|
|
|
|
NVT_LOG("start\n");
|
|
|
|
if (nvt_choose_fw(true)) {
|
|
NVT_ERR("download firmware failed, ignore check fw state\n");
|
|
} else {
|
|
nvt_check_fw_reset_state(RESET_STATE_REK);
|
|
}
|
|
#if NVT_TOUCH_ESD_PROTECT
|
|
nvt_esd_check_enable(false);
|
|
queue_delayed_work(nvt_esd_check_wq, &nvt_esd_check_work,
|
|
msecs_to_jiffies(NVT_TOUCH_ESD_CHECK_PERIOD));
|
|
#endif /* #if NVT_TOUCH_ESD_PROTECT */
|
|
|
|
bTouchIsAwake = 1;
|
|
|
|
mutex_unlock(&ts->lock);
|
|
|
|
NVT_LOG("end\n");
|
|
|
|
return;
|
|
}
|
|
|
|
static const struct spi_device_id nvt_ts_id[] = {
|
|
{ NVT_SPI_NAME, 0 },
|
|
{ }
|
|
};
|
|
|
|
#ifdef CONFIG_OF
|
|
static struct of_device_id nvt_match_table[] = {
|
|
{ .compatible = "novatek,NVT-ts-spi",},
|
|
{ .compatible = "focaltech,fts",},
|
|
{ .compatible = "tchip,ILITEK_TDDI",},
|
|
{ },
|
|
};
|
|
#endif
|
|
|
|
static struct spi_driver nvt_spi_driver = {
|
|
.probe = nvt_ts_probe,
|
|
.remove = nvt_ts_remove,
|
|
.shutdown = nvt_ts_shutdown,
|
|
.id_table = nvt_ts_id,
|
|
.driver = {
|
|
.name = NVT_SPI_NAME,
|
|
.owner = THIS_MODULE,
|
|
#ifdef CONFIG_OF
|
|
.of_match_table = nvt_match_table,
|
|
#endif
|
|
},
|
|
};
|
|
|
|
static int nvt_local_init(void)
|
|
{
|
|
int ret = 0;
|
|
|
|
NVT_LOG("start %s\n",__func__);
|
|
|
|
ret = spi_register_driver(&nvt_spi_driver);
|
|
if (ret) {
|
|
NVT_ERR("unable to add spi driver.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (tpd_load_status == 0) {
|
|
NVT_ERR("add error touch panel driver.\n");
|
|
spi_unregister_driver(&nvt_spi_driver);
|
|
return -1;
|
|
}
|
|
|
|
if (tpd_dts_data.use_tpd_button) {
|
|
/*initialize tpd button data*/
|
|
tpd_button_setting(tpd_dts_data.tpd_key_num, tpd_dts_data.tpd_key_local,
|
|
tpd_dts_data.tpd_key_dim_local);
|
|
}
|
|
|
|
tpd_type_cap = 1;
|
|
|
|
NVT_LOG("end\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct tpd_driver_t nvt_device_driver =
|
|
{
|
|
.tpd_device_name = NVT_SPI_NAME,
|
|
.tpd_local_init = nvt_local_init,
|
|
.suspend = nvt_ts_suspend,
|
|
.resume = nvt_ts_resume,
|
|
.attrs = {
|
|
.attr = novatek_attrs,
|
|
.num = ARRAY_SIZE(novatek_attrs),
|
|
},
|
|
};
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Driver Install function.
|
|
|
|
return:
|
|
Executive Outcomes. 0---succeed. not 0---failed.
|
|
********************************************************/
|
|
static int32_t __init nvt_driver_init(void)
|
|
{
|
|
int32_t ret = 0;
|
|
|
|
NVT_LOG("start\n");
|
|
tpd_get_dts_info();
|
|
ret = tpd_driver_add(&nvt_device_driver);
|
|
if (ret < 0){
|
|
NVT_ERR("failed to add i2c driver");
|
|
goto err_driver;
|
|
}
|
|
|
|
NVT_LOG("end\n");
|
|
|
|
err_driver:
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************
|
|
Description:
|
|
Driver uninstall function.
|
|
|
|
return:
|
|
n.a.
|
|
********************************************************/
|
|
static void __exit nvt_driver_exit(void)
|
|
{
|
|
tpd_driver_remove(&nvt_device_driver);
|
|
#if BOOT_UPDATE_FIRMWARE
|
|
if (nvt_fwu_wq)
|
|
destroy_workqueue(nvt_fwu_wq);
|
|
#endif
|
|
}
|
|
|
|
module_init(nvt_driver_init);
|
|
module_exit(nvt_driver_exit);
|
|
|
|
MODULE_DESCRIPTION("Novatek Touchscreen Driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|