drivers/input/touchscreen/tinker_ft5406.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *
   4  * TINKER BOARD FT5406 touch driver.
   5  *
   6  * Copyright (c) 2016 ASUSTek Computer Inc.
   7  * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
   8  *
   9  * This software is licensed under the terms of the GNU General Public
  10  * License version 2, as published by the Free Software Foundation, and
  11  * may be copied, distributed, and modified under those terms.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/slab.h>
  22 #include <linux/delay.h>
  23 #include <linux/i2c.h>
  24 #include <linux/input.h>
  25 #include <linux/input/mt.h>
  26 #include <linux/module.h>
  27 #include <linux/workqueue.h>
  28
  29 #define LOG_DBG(fmt, arg...) pr_debug("tinker-ft5406: %s: "fmt, __func__, ##arg)
  30 #define LOG_INFO(fmt, arg...) pr_info("tinker-ft5406: %s: "fmt, __func__, ##arg)
  31 #define LOG_ERR(fmt, arg...) pr_err("tinker-ft5406: %s: "fmt, __func__, ##arg)
  32
  33 #define RETRY_COUNT 10
  34 #define FT_ONE_TCH_LEN  6
  35
  36 #define FT_REG_FW_VER                   0xA6
  37 #define FT_REG_FW_MIN_VER               0xB2
  38 #define FT_REG_FW_SUB_MIN_VER   0xB3
  39
  40 #define VALID_TD_STATUS_VAL             10
  41 #define MAX_TOUCH_POINTS                1
  42
  43 #define FT_PRESS                        0x7F
  44 #define FT_MAX_ID                       0x0F
  45
  46 #define FT_TOUCH_X_H    0
  47 #define FT_TOUCH_X_L    1
  48 #define FT_TOUCH_Y_H    2
  49 #define FT_TOUCH_Y_L    3
  50 #define FT_TOUCH_EVENT  0
  51 #define FT_TOUCH_ID             2
  52
  53 #define FT_TOUCH_X_H_REG        3
  54 #define FT_TOUCH_X_L_REG        4
  55 #define FT_TOUCH_Y_H_REG        5
  56 #define FT_TOUCH_Y_L_REG        6
  57 #define FT_TD_STATUS_REG        2
  58 #define FT_TOUCH_EVENT_REG      3
  59 #define FT_TOUCH_ID_REG         5
  60
  61 #define FT_TOUCH_DOWN           0
  62 #define FT_TOUCH_CONTACT        2
  63
  64 struct ts_event {
  65         u16 au16_x[MAX_TOUCH_POINTS]; /*x coordinate */
  66         u16 au16_y[MAX_TOUCH_POINTS]; /*y coordinate */
  67         u8 au8_touch_event[MAX_TOUCH_POINTS]; /*touch event: 0:down; 1:up; 2:contact */
  68         u8 au8_finger_id[MAX_TOUCH_POINTS]; /*touch ID */
  69         u16 pressure;
  70         u8 touch_point;
  71         u8 point_num;
  72 };
  73
  74 struct tinker_ft5406_data {
  75         struct device *dev;
  76         struct i2c_client *client;
  77         struct input_dev *input_dev;
  78         struct ts_event event;
  79         struct work_struct ft5406_work;
  80
  81         int screen_width;
  82         int screen_height;
  83         int xy_reverse;
  84         int is_polling;
  85         int known_ids;
  86         int retry_count;
  87 };
  88
  89 struct tinker_ft5406_data *g_ts_data;
  90 int g_mcu_ready;
  91
  92 static int fts_i2c_read(struct i2c_client *client, char *writebuf,
  93                            int writelen, char *readbuf, int readlen)
  94 {
  95         int ret;
  96
  97         if (writelen > 0) {
  98                 struct i2c_msg msgs[] = {
  99                         {
 100                                  .addr = client->addr,
 101                                  .flags = 0,
 102                                  .len = writelen,
 103                                  .buf = writebuf,
 104                          },
 105                         {
 106                                  .addr = client->addr,
 107                                  .flags = I2C_M_RD,
 108                                  .len = readlen,
 109                                  .buf = readbuf,
 110                          },
 111                 };
 112                 ret = i2c_transfer(client->adapter, msgs, 2);
 113                 if (ret < 0)
 114                         LOG_ERR("i2c read error, %d\n", ret);
 115         } else {
 116                 struct i2c_msg msgs[] = {
 117                         {
 118                                  .addr = client->addr,
 119                                  .flags = I2C_M_RD,
 120                                  .len = readlen,
 121                                  .buf = readbuf,
 122                          },
 123                 };
 124                 ret = i2c_transfer(client->adapter, msgs, 1);
 125                 if (ret < 0)
 126                         LOG_ERR("i2c read error, %d\n", ret);
 127         }
 128
 129         return ret;
 130 }
 131
 132 static int fts_read_reg(struct i2c_client *client, u8 addr, u8 *val)
 133 {
 134         return fts_i2c_read(client, &addr, 1, val, 1);
 135 }
 136
 137 static int fts_check_fw_ver(struct i2c_client *client)
 138 {
 139         u8 reg_addr, fw_ver[3];
 140         int ret;
 141
 142         reg_addr = FT_REG_FW_VER;
 143         ret = fts_i2c_read(client, &reg_addr, 1, &fw_ver[0], 1);
 144         if (ret < 0)
 145                 goto error;
 146
 147         reg_addr = FT_REG_FW_MIN_VER;
 148         ret = fts_i2c_read(client, &reg_addr, 1, &fw_ver[1], 1);
 149         if (ret < 0)
 150                 goto error;
 151
 152         reg_addr = FT_REG_FW_SUB_MIN_VER;
 153         ret = fts_i2c_read(client, &reg_addr, 1, &fw_ver[2], 1);
 154         if (ret < 0)
 155                 goto error;
 156
 157         LOG_INFO("Firmware version = %d.%d.%d\n", fw_ver[0], fw_ver[1], fw_ver[2]);
 158         return 0;
 159
 160 error:
 161         return ret;
 162 }
 163
 164 static int fts_read_td_status(struct tinker_ft5406_data *ts_data)
 165 {
 166         u8 td_status;
 167         int ret = -1;
 168
 169         ret = fts_read_reg(ts_data->client, FT_TD_STATUS_REG, &td_status);
 170         if (ret < 0) {
 171                 LOG_ERR("get reg td_status failed, %d\n", ret);
 172                 return ret;
 173         }
 174         return (int)td_status;
 175 }
 176
 177 static int fts_read_touchdata(struct tinker_ft5406_data *ts_data)
 178 {
 179         struct ts_event *event = &ts_data->event;
 180         int ret = -1, i;
 181         u8 buf[FT_ONE_TCH_LEN-2] = { 0 };
 182         u8 reg_addr, pointid = FT_MAX_ID;
 183
 184         for (i = 0; i < event->touch_point && i < MAX_TOUCH_POINTS; i++) {
 185                 reg_addr = FT_TOUCH_X_H_REG + (i * FT_ONE_TCH_LEN);
 186                 ret = fts_i2c_read(ts_data->client, &reg_addr, 1, buf, FT_ONE_TCH_LEN-2);
 187                 if (ret < 0) {
 188                         LOG_ERR("read touchdata failed.\n");
 189                         return ret;
 190                 }
 191
 192                 pointid = (buf[FT_TOUCH_ID]) >> 4;
 193                 if (pointid >= MAX_TOUCH_POINTS)
 194                         break;
 195                 event->au8_finger_id[i] = pointid;
 196                 event->au16_x[i] = (s16) (buf[FT_TOUCH_X_H] & 0x0F) << 8 | (s16) buf[FT_TOUCH_X_L];
 197                 event->au16_y[i] = (s16) (buf[FT_TOUCH_Y_H] & 0x0F) << 8 | (s16) buf[FT_TOUCH_Y_L];
 198                 event->au8_touch_event[i] = buf[FT_TOUCH_EVENT] >> 6;
 199
 200                 if (ts_data->xy_reverse) {
 201                         event->au16_x[i] = ts_data->screen_width - event->au16_x[i] - 1;
 202                         event->au16_y[i] = ts_data->screen_height - event->au16_y[i] - 1;
 203                 }
 204         }
 205         event->pressure = FT_PRESS;
 206
 207         return 0;
 208 }
 209
 210 static void fts_report_value(struct tinker_ft5406_data *ts_data)
 211 {
 212         struct ts_event *event = &ts_data->event;
 213         int i, modified_ids = 0, released_ids;
 214
 215         for (i = 0; i < event->touch_point && i < MAX_TOUCH_POINTS; i++) {
 216                 if (event->au8_touch_event[i] == FT_TOUCH_DOWN ||
 217                         event->au8_touch_event[i] == FT_TOUCH_CONTACT) {
 218                         modified_ids |= 1 << event->au8_finger_id[i];
 219                         input_mt_slot(ts_data->input_dev, event->au8_finger_id[i]);
 220                         input_mt_report_slot_state(ts_data->input_dev, MT_TOOL_FINGER,
 221                                 true);
 222                         input_report_abs(ts_data->input_dev, ABS_MT_TOUCH_MAJOR,
 223                                         event->pressure);
 224                         input_report_abs(ts_data->input_dev, ABS_MT_POSITION_X,
 225                                         event->au16_x[i]);
 226                         input_report_abs(ts_data->input_dev, ABS_MT_POSITION_Y,
 227                                         event->au16_y[i]);
 228
 229                         if (!((1 << event->au8_finger_id[i]) & ts_data->known_ids))
 230                                 LOG_DBG("Touch id-%d: x = %d, y = %d\n",
 231                                         event->au8_finger_id[i],
 232                                         event->au16_x[i],
 233                                         event->au16_y[i]);
 234                 }
 235         }
 236
 237         released_ids = ts_data->known_ids & ~modified_ids;
 238         for (i = 0; released_ids && i < MAX_TOUCH_POINTS; i++) {
 239                 if (released_ids & (1<<i)) {
 240                         LOG_DBG("Release id-%d, known = %x modified = %x\n",
 241                                         i, ts_data->known_ids, modified_ids);
 242                         input_mt_slot(ts_data->input_dev, i);
 243                         input_mt_report_slot_state(ts_data->input_dev, MT_TOOL_FINGER, false);
 244                         modified_ids &= ~(1 << i);
 245                 }
 246         }
 247         ts_data->known_ids = modified_ids;
 248         input_mt_report_pointer_emulation(ts_data->input_dev, true);
 249         input_sync(ts_data->input_dev);
 250 }
 251
 252 static void fts_retry_clear(struct tinker_ft5406_data *ts_data)
 253 {
 254         if (ts_data->retry_count != 0)
 255                 ts_data->retry_count = 0;
 256 }
 257
 258 static int fts_retry_wait(struct tinker_ft5406_data *ts_data)
 259 {
 260         if (ts_data->retry_count < RETRY_COUNT) {
 261                 LOG_INFO("wait and retry, count = %d\n", ts_data->retry_count);
 262                 ts_data->retry_count++;
 263                 msleep(1000);
 264                 return 1;
 265         }
 266         LOG_ERR("attach retry count\n");
 267         return 0;
 268 }
 269
 270 static void tinker_ft5406_work(struct work_struct *work)
 271 {
 272         struct ts_event *event = &g_ts_data->event;
 273         int ret = 0, count = 5, td_status;
 274
 275         while (count > 0) {
 276                 ret = fts_check_fw_ver(g_ts_data->client);
 277                 if (ret == 0)
 278                         break;
 279                 LOG_INFO("checking touch ic, countdown: %d\n", count);
 280                 msleep(1000);
 281                 count--;
 282         }
 283         if (!count) {
 284                 LOG_ERR("checking touch ic timeout, %d\n", ret);
 285                 g_ts_data->is_polling = 0;
 286                 return;
 287         }
 288
 289         /* polling 60fps */
 290         while (1) {
 291                 td_status = fts_read_td_status(g_ts_data);
 292                 if (td_status < 0) {
 293                         ret = fts_retry_wait(g_ts_data);
 294                         if (ret == 0) {
 295                                 LOG_ERR("stop touch polling\n");
 296                                 g_ts_data->is_polling = 0;
 297                                 break;
 298                         }
 299                 } else if (td_status < VALID_TD_STATUS_VAL + 1 &&
 300                         (td_status > 0 || g_ts_data->known_ids != 0)) {
 301                         fts_retry_clear(g_ts_data);
 302                         memset(event, -1, sizeof(struct ts_event));
 303                         event->touch_point = td_status;
 304                         ret = fts_read_touchdata(g_ts_data);
 305                         if (ret == 0)
 306                                 fts_report_value(g_ts_data);
 307                 }
 308                 msleep_interruptible(17);
 309         }
 310 }
 311
 312 void tinker_ft5406_start_polling(void)
 313 {
 314         if (g_ts_data == NULL) {
 315                 LOG_ERR("touch is not ready\n");
 316         } else if (g_ts_data->is_polling == 1) {
 317                 LOG_ERR("touch is busy\n");
 318         } else {
 319                 g_ts_data->is_polling = 1;
 320                 schedule_work(&g_ts_data->ft5406_work);
 321         }
 322         g_mcu_ready = 1;
 323 }
 324 EXPORT_SYMBOL_GPL(tinker_ft5406_start_polling);
 325
 326 static int tinker_ft5406_probe(struct i2c_client *client,
 327                         const struct i2c_device_id *id)
 328 {
 329         struct input_dev *input_dev;
 330         int ret = 0;
 331
 332         g_mcu_ready = 1;
 333
 334         LOG_INFO("address = 0x%x\n", client->addr);
 335
 336         g_ts_data = kzalloc(sizeof(struct tinker_ft5406_data), GFP_KERNEL);
 337         if (g_ts_data == NULL) {
 338                 LOG_ERR("no memory for device\n");
 339                 return -ENOMEM;
 340         }
 341
 342         g_ts_data->client = client;
 343         i2c_set_clientdata(client, g_ts_data);
 344
 345         g_ts_data->screen_width = 800;
 346         g_ts_data->screen_height = 480;
 347         g_ts_data->xy_reverse = 1;
 348
 349         LOG_INFO("width = %d, height = %d, reverse = %d\n",
 350                         g_ts_data->screen_width, g_ts_data->screen_height, g_ts_data->xy_reverse);
 351
 352         input_dev = input_allocate_device();
 353         if (!input_dev) {
 354                 LOG_ERR("failed to allocate input device\n");
 355                 goto input_allocate_failed;
 356         }
 357         input_dev->name = "fts_ts";
 358         input_dev->id.bustype = BUS_I2C;
 359         input_dev->dev.parent = &g_ts_data->client->dev;
 360
 361         g_ts_data->input_dev = input_dev;
 362         input_set_drvdata(input_dev, g_ts_data);
 363
 364         __set_bit(EV_SYN, input_dev->evbit);
 365         __set_bit(EV_KEY, input_dev->evbit);
 366         __set_bit(EV_ABS, input_dev->evbit);
 367         __set_bit(BTN_TOUCH, input_dev->keybit);
 368
 369         input_mt_init_slots(input_dev, MAX_TOUCH_POINTS, 0);
 370         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, g_ts_data->screen_width, 0, 0);
 371         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, g_ts_data->screen_height, 0, 0);
 372
 373         ret = input_register_device(input_dev);
 374         if (ret) {
 375                 LOG_ERR("Input device registration failed\n");
 376                 goto input_register_failed;
 377         }
 378
 379         INIT_WORK(&g_ts_data->ft5406_work, tinker_ft5406_work);
 380         if (g_mcu_ready == 1)
 381                 schedule_work(&g_ts_data->ft5406_work);
 382
 383         return 0;
 384
 385 input_register_failed:
 386         input_free_device(input_dev);
 387 input_allocate_failed:
 388         kfree(g_ts_data);
 389         g_ts_data = NULL;
 390         return ret;
 391 }
 392
 393 static int tinker_ft5406_remove(struct i2c_client *client)
 394 {
 395         cancel_work_sync(&g_ts_data->ft5406_work);
 396         if (g_ts_data->input_dev) {
 397                 input_unregister_device(g_ts_data->input_dev);
 398                 input_free_device(g_ts_data->input_dev);
 399         }
 400         kfree(g_ts_data);
 401         g_ts_data = NULL;
 402         g_mcu_ready = 0;
 403         return 0;
 404 }
 405
 406 static const struct i2c_device_id tinker_ft5406_id[] = {
 407         {"tinker_ft5406", 0},
 408         {},
 409 };
 410
 411 static struct i2c_driver tinker_ft5406_driver = {
 412         .driver = {
 413                 .name = "tinker_ft5406",
 414         },
 415         .probe = tinker_ft5406_probe,
 416         .remove = tinker_ft5406_remove,
 417         .id_table = tinker_ft5406_id,
 418 };
 419 module_i2c_driver(tinker_ft5406_driver);
 420
 421 MODULE_DESCRIPTION("TINKER BOARD FT5406 Touch driver");
 422 MODULE_LICENSE("GPL v2");