1501 lines
36 KiB
C
1501 lines
36 KiB
C
/*
|
|
*
|
|
* FocalTech ft5x06 TouchScreen driver.
|
|
*
|
|
* Copyright (c) 2010 Focal tech Ltd.
|
|
* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* 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/i2c.h>
|
|
#include <linux/input.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#include <linux/firmware.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/input/ft5x06_ts.h>
|
|
|
|
#if defined(CONFIG_FB)
|
|
#include <linux/notifier.h>
|
|
#include <linux/fb.h>
|
|
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
#include <linux/earlysuspend.h>
|
|
/* Early-suspend level */
|
|
#define FT_SUSPEND_LEVEL 1
|
|
#endif
|
|
|
|
#define CFG_MAX_TOUCH_POINTS 5
|
|
|
|
#define FT_STARTUP_DLY 150
|
|
#define FT_RESET_DLY 20
|
|
|
|
#define FT_PRESS 0x7F
|
|
#define FT_MAX_ID 0x0F
|
|
#define FT_TOUCH_STEP 6
|
|
#define FT_TOUCH_X_H_POS 3
|
|
#define FT_TOUCH_X_L_POS 4
|
|
#define FT_TOUCH_Y_H_POS 5
|
|
#define FT_TOUCH_Y_L_POS 6
|
|
#define FT_TOUCH_EVENT_POS 3
|
|
#define FT_TOUCH_ID_POS 5
|
|
|
|
#define POINT_READ_BUF (3 + FT_TOUCH_STEP * CFG_MAX_TOUCH_POINTS)
|
|
|
|
/*register address*/
|
|
#define FT_REG_DEV_MODE 0x00
|
|
#define FT_DEV_MODE_REG_CAL 0x02
|
|
#define FT_REG_ID 0xA3
|
|
#define FT_REG_PMODE 0xA5
|
|
#define FT_REG_FW_VER 0xA6
|
|
#define FT_REG_POINT_RATE 0x88
|
|
#define FT_REG_THGROUP 0x80
|
|
#define FT_REG_ECC 0xCC
|
|
#define FT_REG_RESET_FW 0x07
|
|
|
|
/* power register bits*/
|
|
#define FT_PMODE_ACTIVE 0x00
|
|
#define FT_PMODE_MONITOR 0x01
|
|
#define FT_PMODE_STANDBY 0x02
|
|
#define FT_PMODE_HIBERNATE 0x03
|
|
#define FT_FACTORYMODE_VALUE 0x40
|
|
#define FT_WORKMODE_VALUE 0x00
|
|
#define FT_RST_CMD_REG 0xFC
|
|
#define FT_READ_ID_REG 0x90
|
|
#define FT_ERASE_APP_REG 0x61
|
|
#define FT_ERASE_PANEL_REG 0x63
|
|
#define FT_FW_START_REG 0xBF
|
|
|
|
|
|
#define FT_VTG_MIN_UV 2600000
|
|
#define FT_VTG_MAX_UV 3300000
|
|
#define FT_I2C_VTG_MIN_UV 1800000
|
|
#define FT_I2C_VTG_MAX_UV 1800000
|
|
|
|
#define FT_COORDS_ARR_SIZE 4
|
|
#define MAX_BUTTONS 4
|
|
|
|
#define FT_8BIT_SHIFT 8
|
|
#define FT_4BIT_SHIFT 4
|
|
#define FT_FW_NAME_MAX_LEN 50
|
|
|
|
#define FT5316_ID 0x0A
|
|
#define FT5306I_ID 0x55
|
|
|
|
#define FT_UPGRADE_AA 0xAA
|
|
#define FT_UPGRADE_55 0x55
|
|
|
|
/*upgrade config of FT5606*/
|
|
#define FT5606_UPGRADE_AA_DELAY 50
|
|
#define FT5606_UPGRADE_55_DELAY 10
|
|
#define FT5606_UPGRADE_ID_1 0x79
|
|
#define FT5606_UPGRADE_ID_2 0x06
|
|
#define FT5606_UPGRADE_READID_DELAY 100
|
|
#define FT5606_UPGRADE_EARSE_DELAY 2000
|
|
|
|
/*upgrade config of FT5316*/
|
|
#define FT5316_UPGRADE_AA_DELAY 50
|
|
#define FT5316_UPGRADE_55_DELAY 30
|
|
#define FT5316_UPGRADE_ID_1 0x79
|
|
#define FT5316_UPGRADE_ID_2 0x07
|
|
#define FT5316_UPGRADE_READID_DELAY 1
|
|
#define FT5316_UPGRADE_EARSE_DELAY 1500
|
|
|
|
/*upgrade config of FT5x06(x=2,3,4)*/
|
|
#define FT5X06_UPGRADE_AA_DELAY 50
|
|
#define FT5X06_UPGRADE_55_DELAY 30
|
|
#define FT5X06_UPGRADE_ID_1 0x79
|
|
#define FT5X06_UPGRADE_ID_2 0x03
|
|
#define FT5X06_UPGRADE_READID_DELAY 1
|
|
#define FT5X06_UPGRADE_EARSE_DELAY 2000
|
|
|
|
/*upgrade config of FT6208*/
|
|
#define FT6208_UPGRADE_AA_DELAY 60
|
|
#define FT6208_UPGRADE_55_DELAY 10
|
|
#define FT6208_UPGRADE_ID_1 0x79
|
|
#define FT6208_UPGRADE_ID_2 0x05
|
|
#define FT6208_UPGRADE_READID_DELAY 10
|
|
#define FT6208_UPGRADE_EARSE_DELAY 2000
|
|
|
|
#define FT_UPGRADE_INFO(x, y) do { \
|
|
x->delay_55 = y##_UPGRADE_55_DELAY; \
|
|
x->delay_aa = y##_UPGRADE_AA_DELAY; \
|
|
x->upgrade_id_1 = y##_UPGRADE_ID_1; \
|
|
x->upgrade_id_2 = y##_UPGRADE_ID_2; \
|
|
x->delay_readid = y##_UPGRADE_READID_DELAY; \
|
|
x->delay_earse_flash = y##_UPGRADE_EARSE_DELAY; \
|
|
} while (0)
|
|
|
|
#define FT_FW_MIN_SIZE 8
|
|
#define FT_FW_MAX_SIZE 32768
|
|
#define FT_FW_FILE_VER(x) ((x)->data[(x)->size - 2])
|
|
#define FT_FW_CHECK(x) \
|
|
(((x)->data[(x)->size - 8] ^ (x)->data[(x)->size - 6]) == 0xFF \
|
|
&& (((x)->data[(x)->size - 7] ^ (x)->data[(x)->size - 5]) == 0xFF \
|
|
&& (((x)->data[(x)->size - 3] ^ (x)->data[(x)->size - 4]) == 0xFF)))
|
|
|
|
#define FT_MAX_TRIES 5
|
|
#define FT_RETRY_DLY 20
|
|
|
|
#define FT_MAX_WR_BUF 10
|
|
#define FT_MAX_RD_BUF 2
|
|
#define FT_FW_PKT_LEN 128
|
|
#define FT_FW_PKT_META_LEN 6
|
|
#define FT_FW_PKT_DLY_MS 20
|
|
#define FT_FW_LAST_PKT 0x6ffa
|
|
#define FT_EARSE_DLY_MS 100
|
|
|
|
#define FT_UPGRADE_LOOP 3
|
|
#define FT_CAL_START 0x04
|
|
#define FT_CAL_FIN 0x00
|
|
#define FT_CAL_STORE 0x05
|
|
#define FT_CAL_RETRY 100
|
|
#define FT_REG_CAL 0x00
|
|
#define FT_CAL_MASK 0x70
|
|
|
|
#define FT_DEBUG_DIR_NAME "ft_debug"
|
|
|
|
struct ts_event {
|
|
u16 x[CFG_MAX_TOUCH_POINTS]; /*x coordinate */
|
|
u16 y[CFG_MAX_TOUCH_POINTS]; /*y coordinate */
|
|
/* touch event: 0 -- down; 1-- contact; 2 -- contact */
|
|
u8 touch_event[CFG_MAX_TOUCH_POINTS];
|
|
u8 finger_id[CFG_MAX_TOUCH_POINTS]; /*touch ID */
|
|
u16 pressure;
|
|
u8 touch_point;
|
|
};
|
|
|
|
struct upgrade_info {
|
|
u16 delay_aa; /*delay of write FT_UPGRADE_AA */
|
|
u16 delay_55; /*delay of write FT_UPGRADE_55 */
|
|
u8 upgrade_id_1; /*upgrade id 1 */
|
|
u8 upgrade_id_2; /*upgrade id 2 */
|
|
u16 delay_readid; /*delay of read id */
|
|
u16 delay_earse_flash; /*delay of earse flash*/
|
|
};
|
|
|
|
struct ft5x06_ts_data {
|
|
struct i2c_client *client;
|
|
struct input_dev *input_dev;
|
|
struct ts_event event;
|
|
const struct ft5x06_ts_platform_data *pdata;
|
|
struct regulator *vdd;
|
|
struct regulator *vcc_i2c;
|
|
char fw_name[FT_FW_NAME_MAX_LEN];
|
|
bool loading_fw;
|
|
u8 family_id;
|
|
struct dentry *dir;
|
|
u16 addr;
|
|
bool suspended;
|
|
#if defined(CONFIG_FB)
|
|
struct notifier_block fb_notif;
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
struct early_suspend early_suspend;
|
|
#endif
|
|
};
|
|
|
|
static int ft5x06_i2c_read(struct i2c_client *client, char *writebuf,
|
|
int writelen, char *readbuf, int readlen)
|
|
{
|
|
int ret;
|
|
|
|
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,
|
|
},
|
|
};
|
|
ret = i2c_transfer(client->adapter, msgs, 2);
|
|
if (ret < 0)
|
|
dev_err(&client->dev, "%s: i2c read error.\n",
|
|
__func__);
|
|
} else {
|
|
struct i2c_msg msgs[] = {
|
|
{
|
|
.addr = client->addr,
|
|
.flags = I2C_M_RD,
|
|
.len = readlen,
|
|
.buf = readbuf,
|
|
},
|
|
};
|
|
ret = i2c_transfer(client->adapter, msgs, 1);
|
|
if (ret < 0)
|
|
dev_err(&client->dev, "%s:i2c read error.\n", __func__);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int ft5x06_i2c_write(struct i2c_client *client, char *writebuf,
|
|
int writelen)
|
|
{
|
|
int ret;
|
|
|
|
struct i2c_msg msgs[] = {
|
|
{
|
|
.addr = client->addr,
|
|
.flags = 0,
|
|
.len = writelen,
|
|
.buf = writebuf,
|
|
},
|
|
};
|
|
ret = i2c_transfer(client->adapter, msgs, 1);
|
|
if (ret < 0)
|
|
dev_err(&client->dev, "%s: i2c write error.\n", __func__);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ft5x0x_write_reg(struct i2c_client *client, u8 addr, const u8 val)
|
|
{
|
|
u8 buf[2] = {0};
|
|
|
|
buf[0] = addr;
|
|
buf[1] = val;
|
|
|
|
return ft5x06_i2c_write(client, buf, sizeof(buf));
|
|
}
|
|
|
|
static int ft5x0x_read_reg(struct i2c_client *client, u8 addr, u8 *val)
|
|
{
|
|
return ft5x06_i2c_read(client, &addr, 1, val, 1);
|
|
}
|
|
|
|
static void ft5x06_report_value(struct ft5x06_ts_data *data)
|
|
{
|
|
struct ts_event *event = &data->event;
|
|
int i;
|
|
int fingerdown = 0;
|
|
|
|
for (i = 0; i < event->touch_point; i++) {
|
|
if (event->touch_event[i] == 0 || event->touch_event[i] == 2) {
|
|
event->pressure = FT_PRESS;
|
|
fingerdown++;
|
|
} else {
|
|
event->pressure = 0;
|
|
}
|
|
|
|
input_report_abs(data->input_dev, ABS_MT_POSITION_X,
|
|
event->x[i]);
|
|
input_report_abs(data->input_dev, ABS_MT_POSITION_Y,
|
|
event->y[i]);
|
|
input_report_abs(data->input_dev, ABS_MT_PRESSURE,
|
|
event->pressure);
|
|
input_report_abs(data->input_dev, ABS_MT_TRACKING_ID,
|
|
event->finger_id[i]);
|
|
input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR,
|
|
event->pressure);
|
|
input_mt_sync(data->input_dev);
|
|
}
|
|
|
|
input_report_key(data->input_dev, BTN_TOUCH, !!fingerdown);
|
|
input_sync(data->input_dev);
|
|
}
|
|
|
|
static int ft5x06_handle_touchdata(struct ft5x06_ts_data *data)
|
|
{
|
|
struct ts_event *event = &data->event;
|
|
int ret, i;
|
|
u8 buf[POINT_READ_BUF] = { 0 };
|
|
u8 pointid = FT_MAX_ID;
|
|
|
|
ret = ft5x06_i2c_read(data->client, buf, 1, buf, POINT_READ_BUF);
|
|
if (ret < 0) {
|
|
dev_err(&data->client->dev, "%s read touchdata failed.\n",
|
|
__func__);
|
|
return ret;
|
|
}
|
|
memset(event, 0, sizeof(struct ts_event));
|
|
|
|
event->touch_point = 0;
|
|
for (i = 0; i < CFG_MAX_TOUCH_POINTS; i++) {
|
|
pointid = (buf[FT_TOUCH_ID_POS + FT_TOUCH_STEP * i]) >> 4;
|
|
if (pointid >= FT_MAX_ID)
|
|
break;
|
|
else
|
|
event->touch_point++;
|
|
event->x[i] =
|
|
(s16) (buf[FT_TOUCH_X_H_POS + FT_TOUCH_STEP * i] & 0x0F) <<
|
|
8 | (s16) buf[FT_TOUCH_X_L_POS + FT_TOUCH_STEP * i];
|
|
event->y[i] =
|
|
(s16) (buf[FT_TOUCH_Y_H_POS + FT_TOUCH_STEP * i] & 0x0F) <<
|
|
8 | (s16) buf[FT_TOUCH_Y_L_POS + FT_TOUCH_STEP * i];
|
|
event->touch_event[i] =
|
|
buf[FT_TOUCH_EVENT_POS + FT_TOUCH_STEP * i] >> 6;
|
|
event->finger_id[i] =
|
|
(buf[FT_TOUCH_ID_POS + FT_TOUCH_STEP * i]) >> 4;
|
|
}
|
|
|
|
ft5x06_report_value(data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static irqreturn_t ft5x06_ts_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_id;
|
|
int rc;
|
|
|
|
rc = ft5x06_handle_touchdata(data);
|
|
if (rc)
|
|
pr_err("%s: handling touchdata failed\n", __func__);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int ft5x06_power_on(struct ft5x06_ts_data *data, bool on)
|
|
{
|
|
int rc;
|
|
|
|
if (!on)
|
|
goto power_off;
|
|
|
|
rc = regulator_enable(data->vdd);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator vdd enable failed rc=%d\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
rc = regulator_enable(data->vcc_i2c);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator vcc_i2c enable failed rc=%d\n", rc);
|
|
regulator_disable(data->vdd);
|
|
}
|
|
|
|
return rc;
|
|
|
|
power_off:
|
|
rc = regulator_disable(data->vdd);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator vdd disable failed rc=%d\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
rc = regulator_disable(data->vcc_i2c);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator vcc_i2c disable failed rc=%d\n", rc);
|
|
regulator_enable(data->vdd);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int ft5x06_power_init(struct ft5x06_ts_data *data, bool on)
|
|
{
|
|
int rc;
|
|
|
|
if (!on)
|
|
goto pwr_deinit;
|
|
|
|
data->vdd = regulator_get(&data->client->dev, "vdd");
|
|
if (IS_ERR(data->vdd)) {
|
|
rc = PTR_ERR(data->vdd);
|
|
dev_err(&data->client->dev,
|
|
"Regulator get failed vdd rc=%d\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
if (regulator_count_voltages(data->vdd) > 0) {
|
|
rc = regulator_set_voltage(data->vdd, FT_VTG_MIN_UV,
|
|
FT_VTG_MAX_UV);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator set_vtg failed vdd rc=%d\n", rc);
|
|
goto reg_vdd_put;
|
|
}
|
|
}
|
|
|
|
data->vcc_i2c = regulator_get(&data->client->dev, "vcc_i2c");
|
|
if (IS_ERR(data->vcc_i2c)) {
|
|
rc = PTR_ERR(data->vcc_i2c);
|
|
dev_err(&data->client->dev,
|
|
"Regulator get failed vcc_i2c rc=%d\n", rc);
|
|
goto reg_vdd_set_vtg;
|
|
}
|
|
|
|
if (regulator_count_voltages(data->vcc_i2c) > 0) {
|
|
rc = regulator_set_voltage(data->vcc_i2c, FT_I2C_VTG_MIN_UV,
|
|
FT_I2C_VTG_MAX_UV);
|
|
if (rc) {
|
|
dev_err(&data->client->dev,
|
|
"Regulator set_vtg failed vcc_i2c rc=%d\n", rc);
|
|
goto reg_vcc_i2c_put;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
reg_vcc_i2c_put:
|
|
regulator_put(data->vcc_i2c);
|
|
reg_vdd_set_vtg:
|
|
if (regulator_count_voltages(data->vdd) > 0)
|
|
regulator_set_voltage(data->vdd, 0, FT_VTG_MAX_UV);
|
|
reg_vdd_put:
|
|
regulator_put(data->vdd);
|
|
return rc;
|
|
|
|
pwr_deinit:
|
|
if (regulator_count_voltages(data->vdd) > 0)
|
|
regulator_set_voltage(data->vdd, 0, FT_VTG_MAX_UV);
|
|
|
|
regulator_put(data->vdd);
|
|
|
|
if (regulator_count_voltages(data->vcc_i2c) > 0)
|
|
regulator_set_voltage(data->vcc_i2c, 0, FT_I2C_VTG_MAX_UV);
|
|
|
|
regulator_put(data->vcc_i2c);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int ft5x06_ts_suspend(struct device *dev)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
char txbuf[2];
|
|
|
|
if (data->loading_fw) {
|
|
dev_info(dev, "Firmware loading in process...\n");
|
|
return 0;
|
|
}
|
|
|
|
if (data->suspended) {
|
|
dev_info(dev, "Already in suspend state\n");
|
|
return 0;
|
|
}
|
|
|
|
disable_irq(data->client->irq);
|
|
|
|
if (gpio_is_valid(data->pdata->reset_gpio)) {
|
|
txbuf[0] = FT_REG_PMODE;
|
|
txbuf[1] = FT_PMODE_HIBERNATE;
|
|
ft5x06_i2c_write(data->client, txbuf, sizeof(txbuf));
|
|
}
|
|
|
|
data->suspended = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_ts_resume(struct device *dev)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
|
|
if (!data->suspended) {
|
|
dev_info(dev, "Already in awake state\n");
|
|
return 0;
|
|
}
|
|
|
|
if (gpio_is_valid(data->pdata->reset_gpio)) {
|
|
gpio_set_value_cansleep(data->pdata->reset_gpio, 0);
|
|
msleep(FT_RESET_DLY);
|
|
gpio_set_value_cansleep(data->pdata->reset_gpio, 1);
|
|
}
|
|
enable_irq(data->client->irq);
|
|
|
|
data->suspended = false;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CONFIG_FB)
|
|
static int fb_notifier_callback(struct notifier_block *self,
|
|
unsigned long event, void *data)
|
|
{
|
|
struct fb_event *evdata = data;
|
|
int *blank;
|
|
struct ft5x06_ts_data *ft5x06_data =
|
|
container_of(self, struct ft5x06_ts_data, fb_notif);
|
|
|
|
if (evdata && evdata->data && event == FB_EVENT_BLANK &&
|
|
ft5x06_data && ft5x06_data->client) {
|
|
blank = evdata->data;
|
|
if (*blank == FB_BLANK_UNBLANK)
|
|
ft5x06_ts_resume(&ft5x06_data->client->dev);
|
|
else if (*blank == FB_BLANK_POWERDOWN)
|
|
ft5x06_ts_suspend(&ft5x06_data->client->dev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
static void ft5x06_ts_early_suspend(struct early_suspend *handler)
|
|
{
|
|
struct ft5x06_ts_data *data = container_of(handler,
|
|
struct ft5x06_ts_data,
|
|
early_suspend);
|
|
|
|
ft5x06_ts_suspend(&data->client->dev);
|
|
}
|
|
|
|
static void ft5x06_ts_late_resume(struct early_suspend *handler)
|
|
{
|
|
struct ft5x06_ts_data *data = container_of(handler,
|
|
struct ft5x06_ts_data,
|
|
early_suspend);
|
|
|
|
ft5x06_ts_resume(&data->client->dev);
|
|
}
|
|
#endif
|
|
|
|
static const struct dev_pm_ops ft5x06_ts_pm_ops = {
|
|
#if (!defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND))
|
|
.suspend = ft5x06_ts_suspend,
|
|
.resume = ft5x06_ts_resume,
|
|
#endif
|
|
};
|
|
#endif
|
|
|
|
static int ft5x06_auto_cal(struct i2c_client *client)
|
|
{
|
|
u8 temp = 0, i;
|
|
|
|
/* set to factory mode */
|
|
msleep(2 * FT_STARTUP_DLY);
|
|
ft5x0x_write_reg(client, FT_REG_DEV_MODE, FT_FACTORYMODE_VALUE);
|
|
msleep(FT_STARTUP_DLY);
|
|
|
|
/* start calibration */
|
|
ft5x0x_write_reg(client, FT_DEV_MODE_REG_CAL, FT_CAL_START);
|
|
msleep(2 * FT_STARTUP_DLY);
|
|
for (i = 0; i < FT_CAL_RETRY; i++) {
|
|
ft5x0x_read_reg(client, FT_REG_CAL, &temp);
|
|
/*return to normal mode, calibration finish */
|
|
if (((temp & FT_CAL_MASK) >> FT_4BIT_SHIFT) == FT_CAL_FIN)
|
|
break;
|
|
}
|
|
|
|
/*calibration OK */
|
|
msleep(2 * FT_STARTUP_DLY);
|
|
ft5x0x_write_reg(client, FT_REG_DEV_MODE, FT_FACTORYMODE_VALUE);
|
|
msleep(FT_STARTUP_DLY);
|
|
|
|
/* store calibration data */
|
|
ft5x0x_write_reg(client, FT_DEV_MODE_REG_CAL, FT_CAL_STORE);
|
|
msleep(2 * FT_STARTUP_DLY);
|
|
|
|
/* set to normal mode */
|
|
ft5x0x_write_reg(client, FT_REG_DEV_MODE, FT_WORKMODE_VALUE);
|
|
msleep(2 * FT_STARTUP_DLY);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_get_upgrade_info(u8 family_id, struct upgrade_info *info)
|
|
{
|
|
switch (family_id) {
|
|
case FT5306I_ID:
|
|
FT_UPGRADE_INFO(info, FT5X06);
|
|
break;
|
|
case FT5316_ID:
|
|
FT_UPGRADE_INFO(info, FT5316);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_fw_upgrade_start(struct i2c_client *client,
|
|
const u8 *data, u32 data_len)
|
|
{
|
|
struct ft5x06_ts_data *ts_data = i2c_get_clientdata(client);
|
|
struct upgrade_info info;
|
|
u8 w_buf[FT_MAX_WR_BUF] = {0}, r_buf[FT_MAX_RD_BUF] = {0};
|
|
u8 pkt_buf[FT_FW_PKT_LEN + FT_FW_PKT_META_LEN];
|
|
int rc, i, j, temp;
|
|
u32 pkt_num, pkt_len;
|
|
u8 fw_ecc;
|
|
|
|
rc = ft5x06_get_upgrade_info(ts_data->family_id, &info);
|
|
if (rc < 0) {
|
|
dev_err(&client->dev, "Cannot get upgrade information!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for (i = 0; i < FT_UPGRADE_LOOP; i++) {
|
|
/* reset - write 0xaa and 0x55 to register 0xfc */
|
|
ft5x0x_write_reg(client, FT_RST_CMD_REG, FT_UPGRADE_AA);
|
|
msleep(info.delay_aa);
|
|
|
|
ft5x0x_write_reg(client, FT_RST_CMD_REG, FT_UPGRADE_55);
|
|
msleep(info.delay_55);
|
|
|
|
/* Enter upgrade mode */
|
|
w_buf[0] = FT_UPGRADE_55;
|
|
w_buf[1] = FT_UPGRADE_AA;
|
|
do {
|
|
i++;
|
|
rc = ft5x06_i2c_write(client, w_buf, 2);
|
|
msleep(FT_RETRY_DLY);
|
|
} while (rc <= 0 && i < FT_MAX_TRIES);
|
|
|
|
/* check READ_ID */
|
|
msleep(info.delay_readid);
|
|
w_buf[0] = FT_READ_ID_REG;
|
|
w_buf[1] = 0x00;
|
|
w_buf[2] = 0x00;
|
|
w_buf[3] = 0x00;
|
|
|
|
ft5x06_i2c_read(client, w_buf, 4, r_buf, 2);
|
|
|
|
if (r_buf[0] != info.upgrade_id_1
|
|
|| r_buf[1] != info.upgrade_id_2) {
|
|
dev_err(&client->dev, "Upgrade ID mismatch(%d)\n", i);
|
|
} else
|
|
break;
|
|
}
|
|
|
|
if (i >= FT_UPGRADE_LOOP) {
|
|
dev_err(&client->dev, "Abort upgrade\n");
|
|
return -EIO;
|
|
}
|
|
|
|
/* erase app and panel paramenter area */
|
|
w_buf[0] = FT_ERASE_APP_REG;
|
|
ft5x06_i2c_write(client, w_buf, 1);
|
|
msleep(info.delay_earse_flash);
|
|
|
|
w_buf[0] = FT_ERASE_PANEL_REG;
|
|
ft5x06_i2c_write(client, w_buf, 1);
|
|
msleep(FT_EARSE_DLY_MS);
|
|
|
|
/* program firmware */
|
|
data_len = data_len - 8;
|
|
pkt_num = (data_len) / FT_FW_PKT_LEN;
|
|
pkt_len = FT_FW_PKT_LEN;
|
|
pkt_buf[0] = FT_FW_START_REG;
|
|
pkt_buf[1] = 0x00;
|
|
fw_ecc = 0;
|
|
|
|
for (i = 0; i < pkt_num; i++) {
|
|
temp = i * FT_FW_PKT_LEN;
|
|
pkt_buf[2] = (u8) (temp >> FT_8BIT_SHIFT);
|
|
pkt_buf[3] = (u8) temp;
|
|
pkt_buf[4] = (u8) (pkt_len >> FT_8BIT_SHIFT);
|
|
pkt_buf[5] = (u8) pkt_len;
|
|
|
|
for (j = 0; j < FT_FW_PKT_LEN; j++) {
|
|
pkt_buf[6 + j] = data[i * FT_FW_PKT_LEN + j];
|
|
fw_ecc ^= pkt_buf[6 + j];
|
|
}
|
|
|
|
ft5x06_i2c_write(client, pkt_buf,
|
|
FT_FW_PKT_LEN + FT_FW_PKT_META_LEN);
|
|
msleep(FT_FW_PKT_DLY_MS);
|
|
}
|
|
|
|
/* send remaining bytes */
|
|
if ((data_len) % FT_FW_PKT_LEN > 0) {
|
|
temp = pkt_num * FT_FW_PKT_LEN;
|
|
pkt_buf[2] = (u8) (temp >> FT_8BIT_SHIFT);
|
|
pkt_buf[3] = (u8) temp;
|
|
temp = (data_len) % FT_FW_PKT_LEN;
|
|
pkt_buf[4] = (u8) (temp >> FT_8BIT_SHIFT);
|
|
pkt_buf[5] = (u8) temp;
|
|
|
|
for (i = 0; i < temp; i++) {
|
|
pkt_buf[6 + i] = data[pkt_num * FT_FW_PKT_LEN + i];
|
|
fw_ecc ^= pkt_buf[6 + i];
|
|
}
|
|
|
|
ft5x06_i2c_write(client, pkt_buf, temp + FT_FW_PKT_META_LEN);
|
|
msleep(FT_FW_PKT_DLY_MS);
|
|
}
|
|
|
|
/* send the finishing packet */
|
|
for (i = 0; i < 6; i++) {
|
|
temp = FT_FW_LAST_PKT + i;
|
|
pkt_buf[2] = (u8) (temp >> 8);
|
|
pkt_buf[3] = (u8) temp;
|
|
temp = 1;
|
|
pkt_buf[4] = (u8) (temp >> 8);
|
|
pkt_buf[5] = (u8) temp;
|
|
pkt_buf[6] = data[data_len + i];
|
|
fw_ecc ^= pkt_buf[6];
|
|
ft5x06_i2c_write(client, pkt_buf, temp + FT_FW_PKT_META_LEN);
|
|
msleep(FT_FW_PKT_DLY_MS);
|
|
}
|
|
|
|
/* verify checksum */
|
|
w_buf[0] = FT_REG_ECC;
|
|
ft5x06_i2c_read(client, w_buf, 1, r_buf, 1);
|
|
if (r_buf[0] != fw_ecc) {
|
|
dev_err(&client->dev, "ECC error! dev_ecc=%02x fw_ecc=%02x\n",
|
|
r_buf[0], fw_ecc);
|
|
return -EIO;
|
|
}
|
|
|
|
/* reset */
|
|
w_buf[0] = FT_REG_RESET_FW;
|
|
ft5x06_i2c_write(client, w_buf, 1);
|
|
msleep(FT_STARTUP_DLY);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_fw_upgrade(struct device *dev, bool force)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
const struct firmware *fw = NULL;
|
|
int rc;
|
|
u8 val = 0;
|
|
|
|
rc = request_firmware(&fw, data->fw_name, dev);
|
|
if (rc < 0) {
|
|
dev_err(dev, "Request firmware failed - %s (%d)\n",
|
|
data->fw_name, rc);
|
|
return rc;
|
|
}
|
|
|
|
if (fw->size < FT_FW_MIN_SIZE || fw->size > FT_FW_MAX_SIZE) {
|
|
dev_err(dev, "Invalid firmware size (%d)\n", fw->size);
|
|
rc = -EIO;
|
|
goto rel_fw;
|
|
}
|
|
|
|
/* check firmware version */
|
|
rc = ft5x0x_read_reg(data->client, FT_REG_FW_VER, &val);
|
|
if (rc < 0) {
|
|
dev_err(dev, "Get firmware version failed\n");
|
|
goto rel_fw;
|
|
}
|
|
|
|
if (val == FT_FW_FILE_VER(fw) && !force) {
|
|
dev_err(dev, "No need to update (0x%x)\n", val);
|
|
rc = -EFAULT;
|
|
goto rel_fw;
|
|
}
|
|
|
|
dev_info(dev, "upgrade to fw ver 0x%x from 0x%x\n",
|
|
FT_FW_FILE_VER(fw), val);
|
|
|
|
/* start firmware upgrade */
|
|
if (FT_FW_CHECK(fw)) {
|
|
rc = ft5x06_fw_upgrade_start(data->client, fw->data, fw->size);
|
|
if (rc < 0)
|
|
dev_err(dev, "update failed (%d)\n", rc);
|
|
else
|
|
ft5x06_auto_cal(data->client);
|
|
} else {
|
|
dev_err(dev, "FW format error\n");
|
|
rc = -EIO;
|
|
}
|
|
|
|
rel_fw:
|
|
release_firmware(fw);
|
|
return rc;
|
|
}
|
|
|
|
static ssize_t ft5x06_update_fw_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
return snprintf(buf, 2, "%d\n", data->loading_fw);
|
|
}
|
|
|
|
static ssize_t ft5x06_update_fw_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
unsigned long val;
|
|
int rc;
|
|
|
|
if (size > 2)
|
|
return -EINVAL;
|
|
|
|
rc = kstrtoul(buf, 10, &val);
|
|
if (rc != 0)
|
|
return rc;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
if (!data->loading_fw && val) {
|
|
data->loading_fw = true;
|
|
ft5x06_fw_upgrade(dev, false);
|
|
data->loading_fw = false;
|
|
}
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(update_fw, 0664, ft5x06_update_fw_show,
|
|
ft5x06_update_fw_store);
|
|
|
|
static ssize_t ft5x06_force_update_fw_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
unsigned long val;
|
|
int rc;
|
|
|
|
if (size > 2)
|
|
return -EINVAL;
|
|
|
|
rc = kstrtoul(buf, 10, &val);
|
|
if (rc != 0)
|
|
return rc;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
if (!data->loading_fw && val) {
|
|
data->loading_fw = true;
|
|
ft5x06_fw_upgrade(dev, true);
|
|
data->loading_fw = false;
|
|
}
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(force_update_fw, 0664, ft5x06_update_fw_show,
|
|
ft5x06_force_update_fw_store);
|
|
|
|
static ssize_t ft5x06_fw_name_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
return snprintf(buf, FT_FW_NAME_MAX_LEN - 1, "%s\n", data->fw_name);
|
|
}
|
|
|
|
static ssize_t ft5x06_fw_name_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct ft5x06_ts_data *data = dev_get_drvdata(dev);
|
|
|
|
if (size > FT_FW_NAME_MAX_LEN - 1)
|
|
return -EINVAL;
|
|
|
|
strlcpy(data->fw_name, buf, size);
|
|
if (data->fw_name[size-1] == '\n')
|
|
data->fw_name[size-1] = 0;
|
|
|
|
return size;
|
|
}
|
|
|
|
static DEVICE_ATTR(fw_name, 0664, ft5x06_fw_name_show, ft5x06_fw_name_store);
|
|
|
|
static bool ft5x06_debug_addr_is_valid(int addr)
|
|
{
|
|
if (addr < 0 || addr > 0xFF) {
|
|
pr_err("FT reg address is invalid: 0x%x\n", addr);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int ft5x06_debug_data_set(void *_data, u64 val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
|
|
if (ft5x06_debug_addr_is_valid(data->addr))
|
|
dev_info(&data->client->dev,
|
|
"Writing into FT registers not supported\n");
|
|
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_debug_data_get(void *_data, u64 *val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
int rc;
|
|
u8 reg;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
|
|
if (ft5x06_debug_addr_is_valid(data->addr)) {
|
|
rc = ft5x0x_read_reg(data->client, data->addr, ®);
|
|
if (rc < 0)
|
|
dev_err(&data->client->dev,
|
|
"FT read register 0x%x failed (%d)\n",
|
|
data->addr, rc);
|
|
else
|
|
*val = reg;
|
|
}
|
|
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(debug_data_fops, ft5x06_debug_data_get,
|
|
ft5x06_debug_data_set, "0x%02llX\n");
|
|
|
|
static int ft5x06_debug_addr_set(void *_data, u64 val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
|
|
if (ft5x06_debug_addr_is_valid(val)) {
|
|
mutex_lock(&data->input_dev->mutex);
|
|
data->addr = val;
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_debug_addr_get(void *_data, u64 *val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
|
|
if (ft5x06_debug_addr_is_valid(data->addr))
|
|
*val = data->addr;
|
|
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(debug_addr_fops, ft5x06_debug_addr_get,
|
|
ft5x06_debug_addr_set, "0x%02llX\n");
|
|
|
|
static int ft5x06_debug_suspend_set(void *_data, u64 val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
|
|
if (val)
|
|
ft5x06_ts_suspend(&data->client->dev);
|
|
else
|
|
ft5x06_ts_resume(&data->client->dev);
|
|
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_debug_suspend_get(void *_data, u64 *val)
|
|
{
|
|
struct ft5x06_ts_data *data = _data;
|
|
|
|
mutex_lock(&data->input_dev->mutex);
|
|
*val = data->suspended;
|
|
mutex_unlock(&data->input_dev->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(debug_suspend_fops, ft5x06_debug_suspend_get,
|
|
ft5x06_debug_suspend_set, "%lld\n");
|
|
|
|
#ifdef CONFIG_OF
|
|
static int ft5x06_get_dt_coords(struct device *dev, char *name,
|
|
struct ft5x06_ts_platform_data *pdata)
|
|
{
|
|
u32 coords[FT_COORDS_ARR_SIZE];
|
|
struct property *prop;
|
|
struct device_node *np = dev->of_node;
|
|
int coords_size, rc;
|
|
|
|
prop = of_find_property(np, name, NULL);
|
|
if (!prop)
|
|
return -EINVAL;
|
|
if (!prop->value)
|
|
return -ENODATA;
|
|
|
|
coords_size = prop->length / sizeof(u32);
|
|
if (coords_size != FT_COORDS_ARR_SIZE) {
|
|
dev_err(dev, "invalid %s\n", name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
rc = of_property_read_u32_array(np, name, coords, coords_size);
|
|
if (rc && (rc != -EINVAL)) {
|
|
dev_err(dev, "Unable to read %s\n", name);
|
|
return rc;
|
|
}
|
|
|
|
if (!strcmp(name, "focaltech,panel-coords")) {
|
|
pdata->panel_minx = coords[0];
|
|
pdata->panel_miny = coords[1];
|
|
pdata->panel_maxx = coords[2];
|
|
pdata->panel_maxy = coords[3];
|
|
} else if (!strcmp(name, "focaltech,display-coords")) {
|
|
pdata->x_min = coords[0];
|
|
pdata->y_min = coords[1];
|
|
pdata->x_max = coords[2];
|
|
pdata->y_max = coords[3];
|
|
} else {
|
|
dev_err(dev, "unsupported property %s\n", name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ft5x06_parse_dt(struct device *dev,
|
|
struct ft5x06_ts_platform_data *pdata)
|
|
{
|
|
int rc;
|
|
struct device_node *np = dev->of_node;
|
|
struct property *prop;
|
|
u32 temp_val, num_buttons;
|
|
u32 button_map[MAX_BUTTONS];
|
|
|
|
rc = ft5x06_get_dt_coords(dev, "focaltech,panel-coords", pdata);
|
|
if (rc && (rc != -EINVAL))
|
|
return rc;
|
|
|
|
rc = ft5x06_get_dt_coords(dev, "focaltech,display-coords", pdata);
|
|
if (rc)
|
|
return rc;
|
|
|
|
pdata->i2c_pull_up = of_property_read_bool(np,
|
|
"focaltech,i2c-pull-up");
|
|
|
|
pdata->no_force_update = of_property_read_bool(np,
|
|
"focaltech,no-force-update");
|
|
/* reset, irq gpio info */
|
|
pdata->reset_gpio = of_get_named_gpio_flags(np, "focaltech,reset-gpio",
|
|
0, &pdata->reset_gpio_flags);
|
|
if (pdata->reset_gpio < 0)
|
|
return pdata->reset_gpio;
|
|
|
|
pdata->irq_gpio = of_get_named_gpio_flags(np, "focaltech,irq-gpio",
|
|
0, &pdata->irq_gpio_flags);
|
|
if (pdata->irq_gpio < 0)
|
|
return pdata->irq_gpio;
|
|
|
|
rc = of_property_read_u32(np, "focaltech,family-id", &temp_val);
|
|
if (!rc)
|
|
pdata->family_id = temp_val;
|
|
else
|
|
return rc;
|
|
|
|
prop = of_find_property(np, "focaltech,button-map", NULL);
|
|
if (prop) {
|
|
num_buttons = prop->length / sizeof(temp_val);
|
|
if (num_buttons > MAX_BUTTONS)
|
|
return -EINVAL;
|
|
|
|
rc = of_property_read_u32_array(np,
|
|
"focaltech,button-map", button_map,
|
|
num_buttons);
|
|
if (rc) {
|
|
dev_err(dev, "Unable to read key codes\n");
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
static int ft5x06_parse_dt(struct device *dev,
|
|
struct ft5x06_ts_platform_data *pdata)
|
|
{
|
|
return -ENODEV;
|
|
}
|
|
#endif
|
|
|
|
static int ft5x06_ts_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct ft5x06_ts_platform_data *pdata;
|
|
struct ft5x06_ts_data *data;
|
|
struct input_dev *input_dev;
|
|
struct dentry *dir, *temp;
|
|
u8 reg_value;
|
|
u8 reg_addr;
|
|
int err;
|
|
|
|
if (client->dev.of_node) {
|
|
pdata = devm_kzalloc(&client->dev,
|
|
sizeof(struct ft5x06_ts_platform_data), GFP_KERNEL);
|
|
if (!pdata) {
|
|
dev_err(&client->dev, "Failed to allocate memory\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
err = ft5x06_parse_dt(&client->dev, pdata);
|
|
if (err)
|
|
return err;
|
|
} else
|
|
pdata = client->dev.platform_data;
|
|
|
|
if (!pdata) {
|
|
dev_err(&client->dev, "Invalid pdata\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
|
dev_err(&client->dev, "I2C not supported\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
data = kzalloc(sizeof(struct ft5x06_ts_data), GFP_KERNEL);
|
|
if (!data) {
|
|
dev_err(&client->dev, "Not enough memory\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
input_dev = input_allocate_device();
|
|
if (!input_dev) {
|
|
err = -ENOMEM;
|
|
dev_err(&client->dev, "failed to allocate input device\n");
|
|
goto free_mem;
|
|
}
|
|
|
|
data->input_dev = input_dev;
|
|
data->client = client;
|
|
data->pdata = pdata;
|
|
|
|
input_dev->name = "ft5x06_ts";
|
|
input_dev->id.bustype = BUS_I2C;
|
|
input_dev->dev.parent = &client->dev;
|
|
|
|
input_set_drvdata(input_dev, data);
|
|
i2c_set_clientdata(client, data);
|
|
|
|
__set_bit(EV_KEY, input_dev->evbit);
|
|
__set_bit(EV_ABS, input_dev->evbit);
|
|
__set_bit(BTN_TOUCH, input_dev->keybit);
|
|
__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
|
|
|
|
input_set_abs_params(input_dev, ABS_MT_POSITION_X, pdata->x_min,
|
|
pdata->x_max, 0, 0);
|
|
input_set_abs_params(input_dev, ABS_MT_POSITION_Y, pdata->y_min,
|
|
pdata->y_max, 0, 0);
|
|
input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0,
|
|
CFG_MAX_TOUCH_POINTS, 0, 0);
|
|
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, FT_PRESS, 0, 0);
|
|
input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, FT_PRESS, 0, 0);
|
|
|
|
err = input_register_device(input_dev);
|
|
if (err) {
|
|
dev_err(&client->dev, "Input device registration failed\n");
|
|
goto free_inputdev;
|
|
}
|
|
|
|
if (pdata->power_init) {
|
|
err = pdata->power_init(true);
|
|
if (err) {
|
|
dev_err(&client->dev, "power init failed");
|
|
goto unreg_inputdev;
|
|
}
|
|
} else {
|
|
err = ft5x06_power_init(data, true);
|
|
if (err) {
|
|
dev_err(&client->dev, "power init failed");
|
|
goto unreg_inputdev;
|
|
}
|
|
}
|
|
|
|
if (pdata->power_on) {
|
|
err = pdata->power_on(true);
|
|
if (err) {
|
|
dev_err(&client->dev, "power on failed");
|
|
goto pwr_deinit;
|
|
}
|
|
} else {
|
|
err = ft5x06_power_on(data, true);
|
|
if (err) {
|
|
dev_err(&client->dev, "power on failed");
|
|
goto pwr_deinit;
|
|
}
|
|
}
|
|
|
|
if (gpio_is_valid(pdata->irq_gpio)) {
|
|
err = gpio_request(pdata->irq_gpio, "ft5x06_irq_gpio");
|
|
if (err) {
|
|
dev_err(&client->dev, "irq gpio request failed");
|
|
goto pwr_off;
|
|
}
|
|
err = gpio_direction_input(pdata->irq_gpio);
|
|
if (err) {
|
|
dev_err(&client->dev,
|
|
"set_direction for irq gpio failed\n");
|
|
goto free_irq_gpio;
|
|
}
|
|
}
|
|
|
|
if (gpio_is_valid(pdata->reset_gpio)) {
|
|
err = gpio_request(pdata->reset_gpio, "ft5x06_reset_gpio");
|
|
if (err) {
|
|
dev_err(&client->dev, "reset gpio request failed");
|
|
goto free_irq_gpio;
|
|
}
|
|
|
|
err = gpio_direction_output(pdata->reset_gpio, 0);
|
|
if (err) {
|
|
dev_err(&client->dev,
|
|
"set_direction for reset gpio failed\n");
|
|
goto free_reset_gpio;
|
|
}
|
|
msleep(FT_RESET_DLY);
|
|
gpio_set_value_cansleep(data->pdata->reset_gpio, 1);
|
|
}
|
|
|
|
/* make sure CTP already finish startup process */
|
|
msleep(FT_STARTUP_DLY);
|
|
|
|
/* check the controller id */
|
|
reg_addr = FT_REG_ID;
|
|
err = ft5x06_i2c_read(client, ®_addr, 1, ®_value, 1);
|
|
if (err < 0) {
|
|
dev_err(&client->dev, "version read failed");
|
|
return err;
|
|
}
|
|
|
|
dev_info(&client->dev, "Device ID = 0x%x\n", reg_value);
|
|
|
|
if (pdata->family_id != reg_value) {
|
|
dev_err(&client->dev, "%s:Unsupported controller\n", __func__);
|
|
goto free_reset_gpio;
|
|
}
|
|
|
|
data->family_id = reg_value;
|
|
|
|
/*get some register information */
|
|
reg_addr = FT_REG_FW_VER;
|
|
err = ft5x06_i2c_read(client, ®_addr, 1, ®_value, 1);
|
|
if (err < 0)
|
|
dev_err(&client->dev, "version read failed");
|
|
|
|
dev_info(&client->dev, "Firmware version = 0x%x\n", reg_value);
|
|
|
|
reg_addr = FT_REG_POINT_RATE;
|
|
ft5x06_i2c_read(client, ®_addr, 1, ®_value, 1);
|
|
if (err < 0)
|
|
dev_err(&client->dev, "report rate read failed");
|
|
|
|
dev_info(&client->dev, "report rate = %dHz\n", reg_value * 10);
|
|
|
|
reg_addr = FT_REG_THGROUP;
|
|
err = ft5x06_i2c_read(client, ®_addr, 1, ®_value, 1);
|
|
if (err < 0)
|
|
dev_err(&client->dev, "threshold read failed");
|
|
|
|
dev_dbg(&client->dev, "touch threshold = %d\n", reg_value * 4);
|
|
|
|
err = request_threaded_irq(client->irq, NULL,
|
|
ft5x06_ts_interrupt, pdata->irqflags,
|
|
client->dev.driver->name, data);
|
|
if (err) {
|
|
dev_err(&client->dev, "request irq failed\n");
|
|
goto free_reset_gpio;
|
|
}
|
|
|
|
err = device_create_file(&client->dev, &dev_attr_fw_name);
|
|
if (err) {
|
|
dev_err(&client->dev, "sys file creation failed\n");
|
|
goto irq_free;
|
|
}
|
|
|
|
err = device_create_file(&client->dev, &dev_attr_update_fw);
|
|
if (err) {
|
|
dev_err(&client->dev, "sys file creation failed\n");
|
|
goto free_fw_name_sys;
|
|
}
|
|
|
|
err = device_create_file(&client->dev, &dev_attr_force_update_fw);
|
|
if (err) {
|
|
dev_err(&client->dev, "sys file creation failed\n");
|
|
goto free_update_fw_sys;
|
|
}
|
|
|
|
dir = debugfs_create_dir(FT_DEBUG_DIR_NAME, NULL);
|
|
if (dir == NULL || IS_ERR(dir)) {
|
|
pr_err("debugfs_create_dir failed: rc=%ld\n", PTR_ERR(dir));
|
|
err = PTR_ERR(dir);
|
|
goto free_force_update_fw_sys;
|
|
}
|
|
|
|
temp = debugfs_create_file("addr", S_IRUSR | S_IWUSR, dir, data,
|
|
&debug_addr_fops);
|
|
if (temp == NULL || IS_ERR(temp)) {
|
|
pr_err("debugfs_create_file failed: rc=%ld\n", PTR_ERR(temp));
|
|
err = PTR_ERR(temp);
|
|
goto free_debug_dir;
|
|
}
|
|
|
|
temp = debugfs_create_file("data", S_IRUSR | S_IWUSR, dir, data,
|
|
&debug_data_fops);
|
|
if (temp == NULL || IS_ERR(temp)) {
|
|
pr_err("debugfs_create_file failed: rc=%ld\n", PTR_ERR(temp));
|
|
err = PTR_ERR(temp);
|
|
goto free_debug_dir;
|
|
}
|
|
|
|
temp = debugfs_create_file("suspend", S_IRUSR | S_IWUSR, dir, data,
|
|
&debug_suspend_fops);
|
|
if (temp == NULL || IS_ERR(temp)) {
|
|
pr_err("debugfs_create_file failed: rc=%ld\n", PTR_ERR(temp));
|
|
err = PTR_ERR(temp);
|
|
goto free_debug_dir;
|
|
}
|
|
|
|
#if defined(CONFIG_FB)
|
|
data->fb_notif.notifier_call = fb_notifier_callback;
|
|
|
|
err = fb_register_client(&data->fb_notif);
|
|
|
|
if (err)
|
|
dev_err(&client->dev, "Unable to register fb_notifier: %d\n",
|
|
err);
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN +
|
|
FT_SUSPEND_LEVEL;
|
|
data->early_suspend.suspend = ft5x06_ts_early_suspend;
|
|
data->early_suspend.resume = ft5x06_ts_late_resume;
|
|
register_early_suspend(&data->early_suspend);
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
free_debug_dir:
|
|
debugfs_remove_recursive(data->dir);
|
|
free_force_update_fw_sys:
|
|
device_remove_file(&client->dev, &dev_attr_force_update_fw);
|
|
free_update_fw_sys:
|
|
device_remove_file(&client->dev, &dev_attr_update_fw);
|
|
free_fw_name_sys:
|
|
device_remove_file(&client->dev, &dev_attr_fw_name);
|
|
irq_free:
|
|
free_irq(client->irq, data);
|
|
free_reset_gpio:
|
|
if (gpio_is_valid(pdata->reset_gpio))
|
|
gpio_free(pdata->reset_gpio);
|
|
free_irq_gpio:
|
|
if (gpio_is_valid(pdata->irq_gpio))
|
|
gpio_free(pdata->irq_gpio);
|
|
pwr_off:
|
|
if (pdata->power_on)
|
|
pdata->power_on(false);
|
|
else
|
|
ft5x06_power_on(data, false);
|
|
pwr_deinit:
|
|
if (pdata->power_init)
|
|
pdata->power_init(false);
|
|
else
|
|
ft5x06_power_init(data, false);
|
|
unreg_inputdev:
|
|
input_unregister_device(input_dev);
|
|
input_dev = NULL;
|
|
free_inputdev:
|
|
input_free_device(input_dev);
|
|
free_mem:
|
|
kfree(data);
|
|
return err;
|
|
}
|
|
|
|
static int __devexit ft5x06_ts_remove(struct i2c_client *client)
|
|
{
|
|
struct ft5x06_ts_data *data = i2c_get_clientdata(client);
|
|
|
|
debugfs_remove_recursive(data->dir);
|
|
device_remove_file(&client->dev, &dev_attr_force_update_fw);
|
|
device_remove_file(&client->dev, &dev_attr_update_fw);
|
|
device_remove_file(&client->dev, &dev_attr_fw_name);
|
|
|
|
#if defined(CONFIG_FB)
|
|
if (fb_unregister_client(&data->fb_notif))
|
|
dev_err(&client->dev, "Error occurred while unregistering fb_notifier.\n");
|
|
#elif defined(CONFIG_HAS_EARLYSUSPEND)
|
|
unregister_early_suspend(&data->early_suspend);
|
|
#endif
|
|
free_irq(client->irq, data);
|
|
|
|
if (gpio_is_valid(data->pdata->reset_gpio))
|
|
gpio_free(data->pdata->reset_gpio);
|
|
|
|
if (gpio_is_valid(data->pdata->irq_gpio))
|
|
gpio_free(data->pdata->irq_gpio);
|
|
|
|
if (data->pdata->power_on)
|
|
data->pdata->power_on(false);
|
|
else
|
|
ft5x06_power_on(data, false);
|
|
|
|
if (data->pdata->power_init)
|
|
data->pdata->power_init(false);
|
|
else
|
|
ft5x06_power_init(data, false);
|
|
|
|
input_unregister_device(data->input_dev);
|
|
kfree(data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_device_id ft5x06_ts_id[] = {
|
|
{"ft5x06_ts", 0},
|
|
{},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(i2c, ft5x06_ts_id);
|
|
|
|
#ifdef CONFIG_OF
|
|
static struct of_device_id ft5x06_match_table[] = {
|
|
{ .compatible = "focaltech,5x06",},
|
|
{ },
|
|
};
|
|
#else
|
|
#define ft5x06_match_table NULL
|
|
#endif
|
|
|
|
static struct i2c_driver ft5x06_ts_driver = {
|
|
.probe = ft5x06_ts_probe,
|
|
.remove = __devexit_p(ft5x06_ts_remove),
|
|
.driver = {
|
|
.name = "ft5x06_ts",
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = ft5x06_match_table,
|
|
#ifdef CONFIG_PM
|
|
.pm = &ft5x06_ts_pm_ops,
|
|
#endif
|
|
},
|
|
.id_table = ft5x06_ts_id,
|
|
};
|
|
|
|
static int __init ft5x06_ts_init(void)
|
|
{
|
|
return i2c_add_driver(&ft5x06_ts_driver);
|
|
}
|
|
module_init(ft5x06_ts_init);
|
|
|
|
static void __exit ft5x06_ts_exit(void)
|
|
{
|
|
i2c_del_driver(&ft5x06_ts_driver);
|
|
}
|
|
module_exit(ft5x06_ts_exit);
|
|
|
|
MODULE_DESCRIPTION("FocalTech ft5x06 TouchScreen driver");
|
|
MODULE_LICENSE("GPL v2");
|