| /* |
| * |
| * 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/input/mt.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_INFO_MAX_LEN 200 |
| |
| #define FT_STORE_TS_INFO(buf, id, fw_ver) \ |
| snprintf(buf, FT_INFO_MAX_LEN, \ |
| "controller\t= focaltech\n" \ |
| "model\t\t= 0x%x\n" \ |
| "fw_ver\t\t= 0x%x\n", id, fw_ver) |
| |
| #define FT_DEBUG_DIR_NAME "ts_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; |
| char *ts_info; |
| #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_mt_slot(data->input_dev, i); |
| input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, |
| !!event->pressure); |
| |
| if (event->pressure == FT_PRESS) { |
| 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_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; |
| } |
| |
| FT_STORE_TS_INFO(data->ts_info, data->family_id, FT_FW_FILE_VER(fw)); |
| 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"); |
| |
| static int ft5x06_debug_dump_info(struct seq_file *m, void *v) |
| { |
| struct ft5x06_ts_data *data = m->private; |
| |
| seq_printf(m, "%s\n", data->ts_info); |
| |
| return 0; |
| } |
| |
| static int debugfs_dump_info_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, ft5x06_debug_dump_info, inode->i_private); |
| } |
| |
| static const struct file_operations debug_dump_info_fops = { |
| .owner = THIS_MODULE, |
| .open = debugfs_dump_info_open, |
| .read = seq_read, |
| .release = single_release, |
| }; |
| |
| #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 *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_mt_init_slots(input_dev, CFG_MAX_TOUCH_POINTS); |
| 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_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; |
| |
| 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; |
| } |
| |
| data->dir = debugfs_create_dir(FT_DEBUG_DIR_NAME, NULL); |
| if (data->dir == NULL || IS_ERR(data->dir)) { |
| pr_err("debugfs_create_dir failed(%ld)\n", PTR_ERR(data->dir)); |
| err = PTR_ERR(data->dir); |
| goto free_force_update_fw_sys; |
| } |
| |
| temp = debugfs_create_file("addr", S_IRUSR | S_IWUSR, data->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, data->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, data->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; |
| } |
| |
| temp = debugfs_create_file("dump_info", S_IRUSR | S_IWUSR, data->dir, |
| data, &debug_dump_info_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; |
| } |
| |
| data->ts_info = kzalloc(FT_INFO_MAX_LEN, GFP_KERNEL); |
| if (!data->ts_info) { |
| dev_err(&client->dev, "Not enough memory\n"); |
| goto free_debug_dir; |
| } |
| |
| /*get some register information */ |
| 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); |
| |
| 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); |
| |
| FT_STORE_TS_INFO(data->ts_info, data->family_id, reg_value); |
| |
| #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->ts_info); |
| 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"); |