Commit 3c7d2684 authored by Zhang Jiejing's avatar Zhang Jiejing Committed by Jason Liu

ENGR00234781 input: add novatek touch screen driver.

This patch add device drvier for novatek touch screen driver.
This touch screen chip will be support because it have
more populary screen size.
Signed-off-by: default avatarZhang Jiejing <jiejing.zhang@freescale.com>
parent d1f42226
......@@ -662,6 +662,19 @@ config TOUCHSCREEN_USB_NEXIO
bool "NEXIO/iNexio device support" if EXPERT
depends on TOUCHSCREEN_USB_COMPOSITE
config TOUCHSCREEN_NOVATEK
tristate "NOVATEK touchscreens"
depends on I2C
help
Say Y here if you have a Novatek NT11003 Touchscreen
controller.
If unsure, say N.
To compile this driver as a module, choose M here: the
module will be called novatek_ts
config TOUCHSCREEN_TOUCHIT213
tristate "Sahara TouchIT-213 touchscreen"
select SERIO
......@@ -748,7 +761,6 @@ config TOUCHSCREEN_P1003
To compile this driver as a module, choose M here: the
module will be called p1003-ts.
config TOUCHSCREEN_TPS6507X
tristate "TPS6507x based touchscreens"
depends on I2C
......
......@@ -63,5 +63,6 @@ obj-$(CONFIG_TOUCHSCREEN_W90X900) += w90p910_ts.o
obj-$(CONFIG_TOUCHSCREEN_P1003) += p1003_ts.o
obj-$(CONFIG_TOUCHSCREEN_TPS6507X) += tps6507x-ts.o
obj-$(CONFIG_TOUCHSCREEN_MAX11801) += max11801_ts.o
obj-$(CONFIG_TOUCHSCREEN_NOVATEK) += novatek_ts.o
obj-$(CONFIG_TOUCHSCREEN_EGALAX) += egalax_ts.o
obj-$(CONFIG_TOUCHSCREEN_ELAN) += elan_ts.o
/*
* Driver for Novatek NT11003 Multiple Touch Controller
*
* Copyright (C) 2012 Novatek Ltd.
* Copyright (C) 2012 Freescale Semiconductor, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/i2c/novatek_ts.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#define NOVATEK_I2C_NAME "novatek-ts"
#define MAX_SUPPORT_POINTS 5
#define FINGER_EVENT_LEN 6
#define NOVATEK_MAX_X 1280
#define NOVATEK_MAX_Y 800
struct tp_event {
u16 x;
u16 y;
s16 id;
u16 pressure;
u8 status;
};
struct novatek_ts_data {
struct i2c_client *client;
struct input_dev *input_dev;
u8 fingers[MAX_SUPPORT_POINTS];
uint16_t abs_x_max;
uint16_t abs_y_max;
uint8_t max_touch_num;
};
static struct i2c_client *this_client;
#ifdef CONFIG_HAS_EARLYSUSPEND
static struct early_suspend novatek_power;
static void novatek_suspend_early(struct early_suspend *h);
static void novatek_resume_early(struct early_suspend *h);
#endif
#define FINGER_STATUS_MASK 0x3;
enum {
FINGER_DOWN = 1,
FINGER_MOVE,
FINGER_UP,
};
static int novatek_init_panel(struct novatek_ts_data *ts)
{
ts->abs_x_max = NOVATEK_MAX_X;
ts->abs_y_max = NOVATEK_MAX_Y;
ts->max_touch_num = MAX_SUPPORT_POINTS;
return 0;
}
static void parser_finger_events(u8 *buf, struct tp_event *event)
{
event->id = (buf[0] >> 3) - 1;
event->status = buf[0] & FINGER_STATUS_MASK;
event->x = (buf[1] << 4) | ((buf[3] & 0xf0) >> 4);
event->y = (buf[2] << 4) | (buf[3] & 0xf);
event->pressure = buf[5];
}
static int novatek_ts_chipid(struct i2c_client *client)
{
struct novatek_ts_data *ts = i2c_get_clientdata(client);
u8 id_data[] = { 0xff, 0xf0, 0x00 };
int ret;
ret = i2c_master_send(ts->client, id_data, ARRAY_SIZE(id_data));
if (ret < 0)
return -ret;
return i2c_smbus_read_byte_data(ts->client, 0);
}
static irqreturn_t novatek_ts_threaded_irq_handler(int irq, void *dev_id)
{
struct novatek_ts_data *ts = dev_id;
struct i2c_client *client = ts->client;
struct input_dev *input_dev = ts->input_dev;
u8 buffer[MAX_SUPPORT_POINTS * FINGER_EVENT_LEN];
struct tp_event event;
bool down;
int ret;
int i;
memset(buffer, 0, ARRAY_SIZE(buffer));
ret = i2c_smbus_read_i2c_block_data(client, 0,
ARRAY_SIZE(buffer), buffer);
dev_vdbg(&client->dev, "------------------------\n");
for (i = 0; i < ARRAY_SIZE(buffer); i++)
dev_vdbg(&client->dev, "reg:%d val:0x%X\n", i, buffer[i]);
for (i = 0; i < MAX_SUPPORT_POINTS; i++) {
memset(&event, 0, sizeof(event));
parser_finger_events(&buffer[i * FINGER_EVENT_LEN], &event);
if (event.status == 0 /* || event.id > MAX_SUPPORT_POINTS */)
continue;
/* ignore the event already up. */
if (event.status == FINGER_UP && ts->fingers[i] == FINGER_UP)
continue;
input_mt_slot(input_dev, event.id);
down = (event.status == FINGER_UP) ? false : true;
dev_dbg(&client->dev,
"id: %d status:%d x:%d y:%d pressure:%d down:%d\n",
event.id, event.status, event.x, event.y,
event.pressure, down);
ts->fingers[i] = event.status;
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, down);
if (down) {
input_report_abs(input_dev, ABS_MT_POSITION_X, event.x);
input_report_abs(input_dev, ABS_MT_POSITION_Y, event.y);
input_report_abs(input_dev, ABS_MT_PRESSURE,
event.pressure);
}
input_mt_report_pointer_emulation(input_dev, true);
input_sync(input_dev);
}
return IRQ_HANDLED;
}
static int novatek_gpio_reset_chip(struct i2c_client *client, int gpio)
{
int ret;
ret = gpio_request(gpio, "novatek reset");
if (ret) {
dev_err(&client->dev, "failed to request reset gpio.\n");
return ret;
}
gpio_direction_output(gpio, 1);
udelay(1);
gpio_set_value(gpio, 0);
msleep(25);
gpio_set_value(gpio, 1);
gpio_free(gpio);
/* This chip needs time after reset pin. Otherwise, the i2c
* command will failed.*/
msleep(25);
return 0;
}
static int novatek_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
int chipid = 0;
int reset_gpio;
struct novatek_ts_data *ts;
struct novatek_platform_data *pdata;
pdata = client->dev.platform_data;
reset_gpio = pdata->reset_gpio;
if (reset_gpio > 0)
novatek_gpio_reset_chip(client, reset_gpio);
else
dev_warn(&client->dev,
"no reset gpio given, can not reset chip\n");
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
ret = -ENODEV;
goto err_check_functionality_failed;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
ret = novatek_init_panel(ts);
ts->client = this_client = client;
i2c_set_clientdata(client, ts);
chipid = novatek_ts_chipid(ts->client);
if (chipid < 0) {
dev_err(&client->dev, "read chip id failed: %d\n", chipid);
goto err_init_panel_fail;
} else
dev_info(&client->dev, "success read chip id:%x\n", chipid);
ret = request_threaded_irq(client->irq, NULL,
novatek_ts_threaded_irq_handler,
IRQF_TRIGGER_FALLING, "novatek_ts", ts);
if (ret != 0) {
dev_err(&client->dev, "request irq failed.\n");
goto err_irq_request_failed;
}
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
ret = -ENOMEM;
dev_err(&client->dev, "failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
__set_bit(EV_ABS, ts->input_dev->evbit);
__set_bit(EV_KEY, ts->input_dev->evbit);
__set_bit(BTN_TOUCH, ts->input_dev->keybit);
input_set_abs_params(ts->input_dev, ABS_X, 0, ts->abs_x_max, 0, 0);
input_set_abs_params(ts->input_dev, ABS_Y, 0, ts->abs_y_max, 0, 0);
input_set_abs_params(ts->input_dev,
ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);
input_set_abs_params(ts->input_dev,
ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);
input_mt_init_slots(ts->input_dev, MAX_SUPPORT_POINTS);
input_set_drvdata(ts->input_dev, ts);
ts->input_dev->name = "Novatek NT11003 Touch Screen";
ts->input_dev->id.bustype = BUS_I2C;
ret = input_register_device(ts->input_dev);
if (ret != 0) {
dev_err(&client->dev,
"Probe: unable to register %s input device\n",
ts->input_dev->name);
goto err_input_register_device_failed;
}
i2c_set_clientdata(client, ts);
#ifdef CONFIG_HAS_EARLYSUSPEND
novatek_power.suspend = novatek_suspend_early;
novatek_power.resume = novatek_resume_early;
novatek_power.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
novatek_power.data = &client->dev;
register_early_suspend(&novatek_power);
#endif
return 0;
err_input_register_device_failed:
input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
free_irq(client->irq, ts);
err_irq_request_failed:
err_init_panel_fail:
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
return ret;
}
static int novatek_ts_remove(struct i2c_client *client)
{
struct novatek_ts_data *ts = i2c_get_clientdata(client);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&novatek_power);
#endif
i2c_set_clientdata(client, NULL);
input_unregister_device(ts->input_dev);
free_irq(client->irq, ts);
kfree(ts);
return 0;
}
#ifdef CONFIG_PM
static int novatek_suspend_resume_cmd(struct i2c_client *client, bool suspend)
{
int ret;
uint8_t serial_mode_data[] = { 0xFF, 0x8F, 0xFF };
uint8_t resume_data[] = { 0x00, 0x00 };
uint8_t suspend_data[] = { 0x00, 0xAE };
ret = i2c_master_send(client, serial_mode_data,
ARRAY_SIZE(serial_mode_data));
if (ret < 0) {
dev_err(&client->dev, "i2c master send failed:%d\n", ret);
goto err;
}
if (suspend)
ret = i2c_master_send(client, suspend_data,
ARRAY_SIZE(suspend_data));
else
ret = i2c_master_send(client, resume_data,
ARRAY_SIZE(resume_data));
if (ret < 0) {
dev_err(&client->dev, "i2c master send failed:%d\n", ret);
goto err;
}
return 0;
err:
return ret;
}
int novatek_ts_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
return novatek_suspend_resume_cmd(client, true);
}
int novatek_ts_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
return novatek_suspend_resume_cmd(client, false);
}
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
static void novatek_suspend_early(struct early_suspend *h)
{
struct device *dev = h->data;
novatek_ts_suspend(dev);
}
static void novatek_resume_early(struct early_suspend *h)
{
struct device *dev = h->data;
novatek_ts_resume(dev);
}
#endif
static const struct i2c_device_id novatek_ts_id[] = {
{NOVATEK_I2C_NAME, 0},
{}
};
static SIMPLE_DEV_PM_OPS(novatek_ts_pm_ops, novatek_ts_suspend, \
novatek_ts_resume);
static struct i2c_driver novatek_ts_driver = {
.driver = {
.name = NOVATEK_I2C_NAME,
.owner = THIS_MODULE,
#if (defined CONFIG_PM) && !(defined CONFIG_HAS_EARLYSUSPEND)
.pm = &novatek_ts_pm_ops,
#endif
},
.probe = novatek_ts_probe,
.remove = novatek_ts_remove,
.id_table = novatek_ts_id,
};
static int __devinit novatek_ts_init(void)
{
return i2c_add_driver(&novatek_ts_driver);
}
static void __exit novatek_ts_exit(void)
{
i2c_del_driver(&novatek_ts_driver);
}
module_init(novatek_ts_init);
module_exit(novatek_ts_exit);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("Touchscreen driver for Novatek NT11003 touch controller");
MODULE_LICENSE("GPL");
/* Copyright (C) 2012 Freescale Semiconductor, Inc. */
#ifndef NOVATEK_TS_H
#define NOVATEK_TS_H
/**
* struct novatek_platform_data - platform data for novatek touch screen chip.
* @reset_gpio: gpio for chip reset pin
*/
struct novatek_platform_data {
int reset_gpio;
};
#endif
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment