From patchwork Tue Oct 13 07:48:47 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yuger X-Patchwork-Id: 7381791 Return-Path: X-Original-To: patchwork-linux-input@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id D43E89F36A for ; Tue, 13 Oct 2015 07:57:47 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 355712065E for ; Tue, 13 Oct 2015 07:57:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 2EB1820656 for ; Tue, 13 Oct 2015 07:57:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752470AbbJMH5X (ORCPT ); Tue, 13 Oct 2015 03:57:23 -0400 Received: from 42-73-98-95.EMOME-IP.hinet.net ([42.73.98.95]:42379 "EHLO yuger-ThinkCentre-M70e" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1752342AbbJMH5W (ORCPT ); Tue, 13 Oct 2015 03:57:22 -0400 X-Greylist: delayed 502 seconds by postgrey-1.27 at vger.kernel.org; Tue, 13 Oct 2015 03:57:21 EDT Received: by yuger-ThinkCentre-M70e (Postfix, from userid 1000) id 66415360856; Tue, 13 Oct 2015 15:48:55 +0800 (CST) From: "Ko-Hao, Yu" To: Dmitry Torokhov Cc: linux-input@vger.kernel.org, yuger.yu@gmail.com, yuger_yu@sis.com, tammy_tseng@sis.com Subject: [PATCH] Add support for SiS i2c touch driver Date: Tue, 13 Oct 2015 15:48:47 +0800 Message-Id: <1444722527-10202-1-git-send-email-yuger_yu@sis.com> X-Mailer: git-send-email 1.9.1 Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=ham version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Hi, This patch is to add support for SiS i2c touch panel. Thanks a lot. Signed-off-by: Ko-Hao, Yu --- drivers/input/touchscreen/Kconfig | 11 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/sis_i2c.c | 525 ++++++++++++++++++++++++++++++++++++ 3 files changed, 537 insertions(+) create mode 100644 drivers/input/touchscreen/sis_i2c.c diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 600dcce..5782dd5 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -1064,4 +1064,15 @@ config TOUCHSCREEN_COLIBRI_VF50 To compile this driver as a module, choose M here: the module will be called colibri_vf50_ts. +config TOUCHSCREEN_SIS_I2C + tristate "SiS 9200 family I2C touchscreen driver" + depends on I2C && CRC_ITU_T + help + Say Y here to enable support for I2C connected SiS touch panels. + + If unsure, say N. + + To compile this driver as a module, choose M here: the + module will be called sis_i2c. + endif diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 1b79cc0..360b577 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -87,3 +87,4 @@ obj-$(CONFIG_TOUCHSCREEN_SX8654) += sx8654.o obj-$(CONFIG_TOUCHSCREEN_TPS6507X) += tps6507x-ts.o obj-$(CONFIG_TOUCHSCREEN_ZFORCE) += zforce_ts.o obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50) += colibri-vf50-ts.o +obj-$(CONFIG_TOUCHSCREEN_SIS_I2C) += sis_i2c.o diff --git a/drivers/input/touchscreen/sis_i2c.c b/drivers/input/touchscreen/sis_i2c.c new file mode 100644 index 0000000..f7b6ac5 --- /dev/null +++ b/drivers/input/touchscreen/sis_i2c.c @@ -0,0 +1,525 @@ +/* + * Touch Screen driver for SiS 9200 family I2C Touch panels + * + * Copyright (C) 2015 SiS, Inc. + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include /*For Type-B Slot function*/ +#include /*For CRC Check*/ + +#define SIS_I2C_NAME "sis_i2c_ts" +#define SIS_SLAVE_ADDR 0x5c +#define MAX_FINGERS 10 + +/*Resolution mode*/ +/*Constant value*/ +#define SIS_MAX_X 4095 +#define SIS_MAX_Y 4095 + +#define PACKET_BUFFER_SIZE 128 + +#define SIS_CMD_NORMAL 0x0 + +/* for new i2c format */ +#define TOUCHDOWN 0x3 +#define TOUCHUP 0x0 +#define MAX_BYTE 64 +#define PRESSURE_MAX 255 + +/*Resolution diagonal */ +#define AREA_LENGTH_LONGER 5792 +/*((SIS_MAX_X^2) + (SIS_MAX_Y^2))^0.5*/ +#define AREA_LENGTH_SHORT 5792 +#define AREA_UNIT (5792/32) + +#define P_BYTECOUNT 0 +#define ALL_IN_ONE_PACKAGE 0x10 +#define IS_TOUCH(x) (x & 0x1) +#define IS_HIDI2C(x) ((x & 0xF) == 0x06) +#define IS_AREA(x) ((x >> 4) & 0x1) +#define IS_PRESSURE(x) ((x >> 5) & 0x1) +#define IS_SCANTIME(x) ((x >> 6) & 0x1) +#define NORMAL_LEN_PER_POINT 6 +#define AREA_LEN_PER_POINT 2 +#define PRESSURE_LEN_PER_POINT 1 + +#define TOUCH_FORMAT 0x1 +#define HIDI2C_FORMAT 0x6 +#define P_REPORT_ID 2 +#define BYTE_BYTECOUNT 2 +#define BYTE_ReportID 1 +#define BYTE_CRC_HIDI2C 0 +#define BYTE_CRC_I2C 2 +#define BYTE_SCANTIME 2 + +#define MAX_SLOTS 15 + +struct sis_slot { + int check_id; + int id; + unsigned short x, y; + u16 pressure; + u16 width; + u16 height; +}; + +struct point { + int id; + unsigned short x, y; + u16 pressure; + u16 width; + u16 height; +}; + +struct sistp_driver_data { + int id; + int fingers; + struct point pt[MAX_FINGERS]; +}; + +struct sis_ts_data { + struct i2c_client *client; + struct input_dev *input_dev; + struct sistp_driver_data *tp_info; +}; + +/* Addresses to scan */ +static void sis_tpinfo_clear(struct sistp_driver_data *tp_info, int max); + +static int sis_cul_unit(u8 report_id) +{ + int ret = NORMAL_LEN_PER_POINT; + + if (report_id != ALL_IN_ONE_PACKAGE) { + if (IS_AREA(report_id)) + ret += AREA_LEN_PER_POINT; + if (IS_PRESSURE(report_id)) + ret += PRESSURE_LEN_PER_POINT; + } + + return ret; +} + +static int sis_readpacket(struct i2c_client *client, u8 cmd, u8 *buf) +{ + u8 tmpbuf[MAX_BYTE] = {0}; /*MAX_BYTE = 64;*/ + int ret; + int touchnum = 0; + int p_count = 0; + int touch_format_id = 0; + int locate = 0; + bool read_first = true; + /* + * New i2c format + * buf[0] = Low 8 bits of byte count value + * buf[1] = High 8 bits of byte count value + * buf[2] = Report ID + * buf[touch num * 6 + 2 ] = Touch information; + * 1 touch point has 6 bytes, it could be none if no touch + * buf[touch num * 6 + 3] = Touch numbers + * + * One touch point information include 6 bytes, the order is + * + * 1. status = touch down or touch up + * 2. id = finger id + * 3. x axis low 8 bits + * 4. x axis high 8 bits + * 5. y axis low 8 bits + * 6. y axis high 8 bits + */ + do { + if (locate >= PACKET_BUFFER_SIZE) { + dev_err(&client->dev, "sis_readpacket: Buf Overflow\n"); + return -EPERM; + } + ret = i2c_master_recv(client, tmpbuf, MAX_BYTE); + + if (ret < 0) { + dev_err(&client->dev, "sis_readpacket: i2c transfer error\n"); + return ret; + } + /*error package length of receiving data*/ + else if (tmpbuf[P_BYTECOUNT] > MAX_BYTE) { + dev_err(&client->dev, "sis_readpacket: Error Bytecount\n"); + return -EPERM; + } + if (read_first) { + /*access NO TOUCH event unless BUTTON NO TOUCH event*/ + if (tmpbuf[P_BYTECOUNT] == 0) + return 0; /*touchnum is 0*/ + } + /* + * skip parsing data when two devices are registered + * at the same slave address + * parsing data when P_REPORT_ID && 0xf is TOUCH_FORMAT + * or P_REPORT_ID is ALL_IN_ONE_PACKAGE + */ + touch_format_id = tmpbuf[P_REPORT_ID] & 0xf; + if ((touch_format_id != TOUCH_FORMAT) && + (touch_format_id != HIDI2C_FORMAT) && + (tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE)) { + dev_err(&client->dev, "sis_readpacket: Error Report_ID\n"); + return -EPERM; + } + p_count = (int) tmpbuf[P_BYTECOUNT] - 1; /*start from 0*/ + if (tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE) { + if (IS_TOUCH(tmpbuf[P_REPORT_ID])) { + /*delete 2 byte crc*/ + p_count -= BYTE_CRC_I2C; + } else if (IS_HIDI2C(tmpbuf[P_REPORT_ID])) { + p_count -= BYTE_CRC_HIDI2C; + } else { /*should not be happen*/ + dev_err(&client->dev, "sis_readpacket: delete crc error\n"); + return -EPERM; + } + if (IS_SCANTIME(tmpbuf[P_REPORT_ID])) + p_count -= BYTE_SCANTIME; + } + /*For ALL_IN_ONE_PACKAGE*/ + if (read_first) { + touchnum = tmpbuf[p_count]; + } else { + if (tmpbuf[p_count] != 0) { + dev_err(&client->dev, "sis_readpacket: get error package\n"); + return -EPERM; + } + } + + if ((touch_format_id != HIDI2C_FORMAT) && + (tmpbuf[P_BYTECOUNT] > 3)) { + int crc_end = p_count + (IS_SCANTIME( + tmpbuf[P_REPORT_ID]) * 2); + u16 buf_crc = crc_itu_t( + 0, tmpbuf + 2, crc_end - 1); + int l_package_crc = (IS_SCANTIME( + tmpbuf[P_REPORT_ID]) * 2) + p_count + 1; + u16 package_crc = get_unaligned_le16( + &tmpbuf[l_package_crc]); + + if (buf_crc != package_crc) { + dev_err(&client->dev, "sis_readpacket: CRC Error\n"); + return -EPERM; + } + } + + memcpy(&buf[locate], &tmpbuf[0], MAX_BYTE); + /*Buf_Data [0~63] [64~128]*/ + locate += MAX_BYTE; + read_first = false; + } while (tmpbuf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE && + tmpbuf[p_count] > 5); + return touchnum; +} + +static int sis_parse_i2c_event(u8 *buf, u8 fingers, + struct sistp_driver_data *tp_info, + int *check_id, struct sis_slot *sisdata) +{ + int point_unit; + u8 i = 0, pstatus = 0; + u8 px = 0, py = 0; + u8 p_area = 0; + u8 p_preasure = 0; + /*Parser and Get the sis data*/ + point_unit = sis_cul_unit(buf[P_REPORT_ID]); + tp_info->fingers = fingers = (fingers > MAX_FINGERS ? 0 : fingers); + + /*fingers 10 = 0 ~ 9*/ + for (i = 0; i < fingers; i++) { + if ((buf[P_REPORT_ID] != ALL_IN_ONE_PACKAGE) && (i >= 5)) { + /*Calc point status*/ + pstatus = BYTE_BYTECOUNT + BYTE_ReportID + + ((i - 5) * point_unit); + pstatus += 64; + } else { + pstatus = BYTE_BYTECOUNT + BYTE_ReportID + + (i * point_unit); + /*Calc point status*/ + } + px = pstatus + 2; /*Calc point x_coord*/ + py = px + 2; /*Calc point y_coord*/ + if ((buf[pstatus]) == TOUCHUP) { + tp_info->pt[i].width = 0; + tp_info->pt[i].height = 0; + tp_info->pt[i].pressure = 0; + } else if (buf[P_REPORT_ID] == ALL_IN_ONE_PACKAGE + && (buf[pstatus]) == TOUCHDOWN) { + tp_info->pt[i].width = 1; + tp_info->pt[i].height = 1; + tp_info->pt[i].pressure = 1; + } else if ((buf[pstatus]) == TOUCHDOWN) { + p_area = py + 2; + p_preasure = py + 2 + (IS_AREA(buf[P_REPORT_ID]) * 2); + /*area*/ + if (IS_AREA(buf[P_REPORT_ID])) { + tp_info->pt[i].width = buf[p_area]; + tp_info->pt[i].height = buf[p_area + 1]; + } else { + tp_info->pt[i].width = 1; + tp_info->pt[i].height = 1; + } + /*pressure*/ + if (IS_PRESSURE(buf[P_REPORT_ID])) + tp_info->pt[i].pressure = (buf[p_preasure]); + else + tp_info->pt[i].pressure = 1; + } else + return -EPERM; + + tp_info->pt[i].id = (buf[pstatus + 1]); + tp_info->pt[i].x = get_unaligned_le16(&buf[px]); + tp_info->pt[i].y = get_unaligned_le16(&buf[py]); + + check_id[tp_info->pt[i].id] = 1; + sisdata[tp_info->pt[i].id].id = tp_info->pt[i].id; + sisdata[tp_info->pt[i].id].pressure = tp_info->pt[i].pressure; + sisdata[tp_info->pt[i].id].x = tp_info->pt[i].x; + sisdata[tp_info->pt[i].id].y = tp_info->pt[i].y; + sisdata[tp_info->pt[i].id].width = tp_info->pt[i].width + * AREA_UNIT; + sisdata[tp_info->pt[i].id].height = tp_info->pt[i].height + * AREA_UNIT; + } + return 0; +} + +static irqreturn_t sis_ts_irq_handler(int irq, void *dev_id) +{ + struct sis_ts_data *ts = dev_id; + struct sistp_driver_data *tp_info = ts->tp_info; + int ret; + u8 buf[PACKET_BUFFER_SIZE] = {0}; + u8 i = 0, fingers = 0; + int check_id[MAX_FINGERS]; + static int pre_check_id[MAX_FINGERS]; + struct sis_slot sisdata[MAX_FINGERS]; + + memset(check_id, 0, sizeof(int)*MAX_FINGERS); + + /*I2C or SMBUS block data read*/ + ret = sis_readpacket(ts->client, SIS_CMD_NORMAL, buf); + /*Error Number*/ + if (ret < 0) + goto out; + /*access NO TOUCH event unless BUTTON NO TOUCH event*/ + else if (ret == 0) { + fingers = 0; + sis_tpinfo_clear(tp_info, MAX_FINGERS); + goto type_b_report; + } + + sis_tpinfo_clear(tp_info, MAX_FINGERS); + fingers = ret; + + ret = sis_parse_i2c_event(buf, fingers, tp_info, check_id, sisdata); + if (ret < 0) + goto out; + +type_b_report: + for (i = 0; i < MAX_FINGERS; i++) { + if ((check_id[i] != pre_check_id[i]) && (check_id[i] != 1)) + check_id[i] = -1; + } + + for (i = 0; i < MAX_FINGERS; i++) { + if (check_id[i] == 1) { + input_mt_slot(ts->input_dev, i+1); + if (sisdata[i].pressure > 0) { + input_mt_report_slot_state(ts->input_dev, + MT_TOOL_FINGER, true); + input_report_abs(ts->input_dev, + ABS_MT_PRESSURE, sisdata[i].pressure); + input_report_abs(ts->input_dev, + ABS_MT_TOUCH_MAJOR, sisdata[i].width); + input_report_abs(ts->input_dev, + ABS_MT_TOUCH_MINOR, sisdata[i].height); + input_report_abs(ts->input_dev, + ABS_MT_POSITION_X, sisdata[i].x); + input_report_abs(ts->input_dev, + ABS_MT_POSITION_Y, sisdata[i].y); + } else { + input_mt_report_slot_state(ts->input_dev, + MT_TOOL_FINGER, false); + check_id[i] = 0; + } + } else if (check_id[i] == -1) { + input_mt_slot(ts->input_dev, i+1); + input_mt_report_slot_state(ts->input_dev, + MT_TOOL_FINGER, false); + check_id[i] = 0; + } + pre_check_id[i] = check_id[i]; + } + + input_sync(ts->input_dev); + +out: + return IRQ_HANDLED; +} + +static void sis_tpinfo_clear(struct sistp_driver_data *tp_info, int max) +{ + int i = 0; + + for (i = 0; i < max; i++) { + tp_info->pt[i].id = -1; + tp_info->pt[i].x = 0; + tp_info->pt[i].y = 0; + tp_info->pt[i].pressure = 0; + tp_info->pt[i].width = 0; + } + tp_info->id = 0x0; + tp_info->fingers = 0; +} + +static int sis_ts_probe( + struct i2c_client *client, const struct i2c_device_id *id) +{ + int err = 0; + struct sis_ts_data *ts; + + dev_dbg(&client->dev, "sis_ts_probe\n"); + ts = devm_kzalloc(&client->dev, sizeof(struct sis_ts_data), + GFP_KERNEL); + if (!ts) + return -ENOMEM; + ts->tp_info = devm_kzalloc(&client->dev, + sizeof(struct sistp_driver_data), + GFP_KERNEL); + if (!ts->tp_info) { + dev_err(&client->dev, "Failed to allocate memory\n"); + return -ENOMEM; + } + + /*1. Init necessary buffers*/ + ts->client = client; + i2c_set_clientdata(client, ts); + + /*2. Allocate input device*/ + ts->input_dev = devm_input_allocate_device(&client->dev); + if (!ts->input_dev) { + err = -ENOMEM; + dev_err(&client->dev, "sis_ts_probe: Failed to allocate input device\n"); + goto err_input_dev_alloc_failed; + } + ts->input_dev->name = "sis_touch"; + + set_bit(EV_ABS, ts->input_dev->evbit); + set_bit(EV_KEY, ts->input_dev->evbit); + input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, + 0, PRESSURE_MAX, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, + 0, AREA_LENGTH_LONGER, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MINOR, + 0, AREA_LENGTH_SHORT, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, + 0, SIS_MAX_X, 0, 0); + input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, + 0, SIS_MAX_Y, 0, 0); + input_mt_init_slots(ts->input_dev, MAX_SLOTS, INPUT_MT_DIRECT); + + /* add for touch keys */ + set_bit(KEY_COMPOSE, ts->input_dev->keybit); + set_bit(KEY_BACK, ts->input_dev->keybit); + set_bit(KEY_MENU, ts->input_dev->keybit); + set_bit(KEY_HOME, ts->input_dev->keybit); + + /*3. Register input device to core*/ + err = input_register_device(ts->input_dev); + if (err) { + dev_err(&client->dev, + "sis_ts_probe: Unable to register %s input device\n", + ts->input_dev->name); + goto err_input_register_device_failed; + } + + /*4. irq setup*/ + err = devm_request_threaded_irq(&client->dev, client->irq, NULL, + sis_ts_irq_handler, + IRQF_TRIGGER_FALLING, client->name, + ts); + if (err < 0) { + dev_err(&client->dev, "Failed to request touchscreen IRQ\n"); + goto err_request_threaded_irq; + } + + dev_dbg(&client->dev, "sis SIS_SLAVE_ADDR: %d\n", SIS_SLAVE_ADDR); + return 0; +err_request_threaded_irq: +err_input_register_device_failed: + input_free_device(ts->input_dev); +err_input_dev_alloc_failed: + kfree(ts->tp_info); + kfree(ts); + return err; +} + +static int sis_ts_remove(struct i2c_client *client) +{ + struct sis_ts_data *ts = i2c_get_clientdata(client); + + input_unregister_device(ts->input_dev); + input_free_device(ts->input_dev); + kfree(ts->tp_info); + kfree(ts); + return 0; +} + +static int __maybe_unused sis_ts_suspend(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + + disable_irq(client->irq); + return 0; +} + +static int __maybe_unused sis_ts_resume(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + + enable_irq(client->irq); + return 0; +} + +static SIMPLE_DEV_PM_OPS(sis_ts_pm, sis_ts_suspend, sis_ts_resume); + +static const struct i2c_device_id sis_ts_id[] = { + { SIS_I2C_NAME, 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, sis_ts_id); + +static struct i2c_driver sis_ts_driver = { + .driver = { + .name = SIS_I2C_NAME, + .owner = THIS_MODULE, + .pm = &sis_ts_pm, + }, + .probe = sis_ts_probe, + .remove = sis_ts_remove, + .id_table = sis_ts_id, +}; +module_i2c_driver(sis_ts_driver); + +MODULE_DESCRIPTION("SiS 9200 Family Touchscreen Driver"); +MODULE_LICENSE("GPL v2");