基于GPL329xx linux平台电容屏gsl1680的驱动调试分析

因客户有用到了gsl1680 7寸电容屏，所以拿了一块过来，便在329xx的平台上面开始调试了。

大概浏览了一下所提供的资料，只有介绍模组的资料跟一份中文版的datasheet，datasheet只是说了个大概，没有提到读取触摸坐标的寄存器。不过还好有给一份在其他处理器平台的驱动，所以读取坐标的部分代码移植过来就可以了。

gsl1680接口跟其他的电容屏一样，也是i2c接口的，貌似市面上的电容屏都是i2c接口，电容屏自带了微控制器MCU，用与处理采样，坐标转换等，还有一些抖动算法处理，完后将坐标保存在固定的寄存器里面，之后会给出一个中断信号输出到pin脚，通知主控读取坐标。不过手上拿到这一款内部是没有flash的，即自身不带firmware的，初始化时要靠主控将firmware透过i2c接口加载到触摸屏的RAM里面，之后电容屏才能正常工作。个人觉得这种方式有两个缺点：1.firmware有8000多个值，加载需要花掉大概10s左右，增加了开机时间(后续可以将i2c
clk调为400K试试看)；2.本身不带firmware，需要加载才能工作，无疑给调试增加了难度。不过，相对电阻屏，电容屏的调试还是比较简单的，不必处理采样/转换，还有干扰/抖动等问题。电容屏而言，自带了的MCU，所以这些工作都已经帮你做好了，倒是很方便。

下面我们具体先看一下gsl1680硬件模组的接口，总共有12个pin，有效的只有6个pin，分别是GND,VCC,SDA,SCL,IO CNTL,INT。

1----GND 2-----NC

3----NC 4-----NC

5----NC 6-----GND

7----SDA 8-----SCL

9----IO Cntl 10-----INT

11----VDD 12-----VDD

简单说明一下：

1,6 ：pin接GND；

2，3，4，5 悬空

7，8 i2c接口

9 IO Cntl 硬件reset/wake pin

10 INT 中断pin脚

11，12 VCC接3.0或者3.3V

了解了上面的硬件接口，触摸屏需要占用的主控的硬件资源有：i2c接口，一个外部中断，一个GPIO（用于控制触摸屏硬件reset/power down进入省电模式）就可以完成触摸屏坐标的获取了。

下面，先介绍一下驱动具体流程。

1.module_init函数里面，注册平台设备platform device；

2.注册platform device driver；

static struct platform_device gp_tp_device = {

.name = "gp_tp",

.id = -1,

.dev = {

.release = gp_tp_device_release,

}

};

static struct platform_driver gp_tp_driver = {

.driver = {

.name = "gp_tp",

.owner = THIS_MODULE,

},

.probe = gp_tp_probe,

.remove = gp_tp_remove,

.suspend = gp_tp_suspend,

.resume = gp_tp_resume,

};

上面的platform_driver里面的probe函数将会完成以下几件事情：

1）创建单一内核线程，注册内核线程函数，用于中断下半部的触摸屏坐标的读取，以及将坐标值上报给linux input子系统；

通过调用create_singlethread_workqueue API创建一个工作队列内核线程；

2）创建一个event设备，从触摸屏获取到的坐标会上报给event，用户层将会从这个event读取到触摸屏按下的坐标；

3）i2c 设备的申请；用于与触摸屏通信跟加载firmware；

4）申请一个GPIO口，用于控制触摸屏的reset/wake ，即接到9 IO Cntl pin脚；

5）软件/硬件复位触摸屏，加载firmware；

6）申请/注册外部中断函数；

以上就是在probe函数里面完成的工作，接下来就是等待触摸屏按下，然后中断函数通知内核线程函数去读取触摸的坐标，上报给event，

之后也是不断循环这个过程。

触摸屏驱动probe函数完整的实现代码如下所示：

/** device driver probe*/

static int __init gp_tp_probe(struct platform_device *pdev)

{

int rc;

int ret = 0;

int intidx, slaveAddr;

int io_wake= -1;

gpio_content_t ctx;

unsigned int debounce = 1;//27000; /*1ms*/

//gp_board_touch_t *touch_config = NULL;

print_info("Entering gp_tp_probe\n");

#ifdef VIRTUAL_KEYS

virtual_keys_init();

#endif

memset(&ts, 0, sizeof(gp_tp_t));

/* Create single thread work queue */

ts.touch_wq = create_singlethread_workqueue("touch_wq");

if (!ts.touch_wq)

{

print_info("%s unable to create single thread work queue\n", __func__);

ret = -ENOMEM;

goto __err_work_queue;

}

INIT_WORK(&ts.mt_set_nice_work, gp_mt_set_nice_work);

queue_work(ts.touch_wq, &ts.mt_set_nice_work);

ts.dev = input_allocate_device();

if ( NULL==ts.dev ){

print_info("Unable to alloc input device\n");

ret = -ENOMEM;

goto __err_alloc;

}

I2C_REQUEST:

gp_i2c_handle = gslx680_i2c_request();

if (gp_i2c_handle == -1) {

DIAG_ERROR("cap touch panel iic request error!\n");

goto I2C_REQUEST;

return -ENOMEM;

}

__set_bit(EV_ABS, ts.dev->evbit);

input_set_abs_params(ts.dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_X - 1, 0, 0);

input_set_abs_params(ts.dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y - 1, 0, 0);

input_set_abs_params(ts.dev, ABS_MT_TRACKING_ID, 0, (MAX_CONTACTS + 1), 0, 0);

input_set_abs_params(ts.dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);

input_set_capability(ts.dev, EV_KEY, KEY_BACK);

input_set_capability(ts.dev, EV_KEY, KEY_HOME);

input_set_capability(ts.dev, EV_KEY, KEY_MENU);

ts.dev->name = "gp_ts";

ts.dev->phys = "gp_ts";

ts.dev->id.bustype = BUS_I2C;

/* All went ok, so register to the input system */

rc = input_register_device(ts.dev);

if (rc) {

ret = -EIO;

goto __err_reg_input;

}

/* request cpt reset pin*/

intidx = MK_GPIO_INDEX( RST_CHANNEL, RST_FUNC, RST_GID, RST_PIN );

touch_reset = gp_gpio_request(intidx, "touch_reset"); /* GPIO1[7] ---- */

if(IS_ERR((void*)touch_reset)) {

print_info("%s unable to register client\n", __func__);

ret = -ENOMEM;

goto __err_register;

}

gp_gpio_set_output(touch_reset, 1,0);

DBG_PRINT("=======gslx680 ctp test=====\n");

gp_i2c_handle = gslx680_i2c_request();

if (gp_i2c_handle == -1) {

DIAG_ERROR("cap touch panel iic request error!\n");

return -ENOMEM;

}

gp_gpio_set_output(touch_reset, 0,0);

msleep(100);

gp_gpio_set_output(touch_reset, 1,0);

msleep(100);

reset_chip();

gp_load_ctp_fw();

startup_chip();

msleep(50);

reset_chip();

startup_chip();

//gp_i2c_bus_release(gp_i2c_handle);

INIT_WORK(&ts.mt_work, gp_multi_touch_work);

intidx = MK_GPIO_INDEX( INT_IRQ_CHANNEL, INT_IRQ_FUNC, INT_IRQ_GID, INT_IRQ_PIN );

ts.client = gp_gpio_request(intidx, "touch_int"); /* GPIO1[7] ---- */

if(IS_ERR((void*)ts.client)) {

print_info("%s unable to register client\n", __func__);

ret = -ENOMEM;

goto __err_register;

}

gp_gpio_set_input(ts.client, GPIO_PULL_LOW);

gp_gpio_irq_property(ts.client, GPIO_IRQ_EDGE_TRIGGER|GPIO_IRQ_ACTIVE_RISING, &debounce);

gp_gpio_register_isr(ts.client, gp_ts_callback, (void *)ts.client);

print_info("End gp_tp_probe\n");

return 0;

__err_register:

input_unregister_device(ts.dev);

__err_reg_input:

//gp_ti2c_bus_release(ts.i2c_handle);

__err_i2c:

// kfree(ts.i2c_handle);

__err_i2c_allocate:

//gp_gpio_release(ts.touch_reset);

__err_pin_request:

input_free_device(ts.dev);

__err_alloc:

destroy_workqueue(ts.touch_wq);

__err_work_queue:

return ret;

}

触摸屏按下中断处理函数如下所示

/**

* interrupt callback

*/

void gp_ts_callback(void* client)

{

gp_gpio_enable_irq(ts.client, 0);

queue_work(ts.touch_wq, &ts.mt_work);

}

linux的中断机制一般分为两个部分：上半部跟下半部。上半部处理的工作一般要尽可能的少，快速；而将繁重、繁琐、处理时间比较长的工作留在下半部去处理。所以，上半部执行的任务算是比较轻松的，这里只是清掉了外部中端状态寄存器，然后调度下半部工作的运行。

下面我们再看一下，触摸屏按下中断的下半部的工作：

static void

gp_mt_set_nice_work(

struct work_struct *work

)

{

print_info("[%s:%d]\n", __FUNCTION__, __LINE__);

set_user_nice(current, -20);

}

static inline unsigned int join_bytes(unsigned char a, unsigned char b)

{

unsigned int ab = 0;

ab = ab | a;

ab = ab << 8 | b;

return ab;

}

static void

gp_multi_touch_work(

struct work_struct *work

)

{

int i,ret;

char touched, id;

unsigned short x, y;

unsigned int pending;

int irq_state;

char tp_data[(MULTI_TP_POINTS + 1)*4 ];

//print_info("WQ gp_multi_touch_work.\n");

#if ADJUST_CPU_FREQ

clockstatus_configure(CLOCK_STATUS_TOUCH,1);

#endif

ret = gsl_ts_read(0x80, tp_data, sizeof(tp_data));

if( ret < 0) {

print_info("gp_tp_get_data fail,return %d\n",ret);

gp_gpio_enable_irq(ts.client, 1);

return;

}

touched = (tp_data[0]< MULTI_TP_POINTS ? tp_data[0] : MULTI_TP_POINTS);

for (i=1;i<=MAX_CONTACTS;i++) {

id_state_flag[i] = 0;

}

//printk("point = %d ",touched);

for (i = 0; i < touched; i++) {

id = tp_data[4 *( i + 1) + 3] >> 4;

x = join_bytes(tp_data[4 *( i + 1) + 3] & 0xf,tp_data[4 *( i + 1) + 2]);

y = join_bytes(tp_data[4 *( i + 1) + 1],tp_data[4 *( i + 1) + 0]);

if(1 <= id && id <= MAX_CONTACTS){

record_point(x, y, id);

report_data(x_new, y_new, 10, id);

id_state_flag[id] = 1;

}

}

if (touched == 0) {

input_mt_sync(ts.dev);

}

for(i=1;i<=MAX_CONTACTS;i++)

{

if( (0 == touched) || ((0 != id_state_old_flag[i]) && (0 == id_state_flag[i])) )

{

id_sign[i]=0;

}

id_state_old_flag[i] = id_state_flag[i];

}

#if ADJUST_CPU_FREQ

if(touched == 0){

clockstatus_configure(CLOCK_STATUS_TOUCH,0);

}

#endif

ts.prev_touched = touched;

input_sync(ts.dev);

__error_check_touch_int:

__error_get_mt_data:

/* Clear interrupt flag */

pending = (1 << GPIO_PIN_NUMBER(ts.intIoIndex));

gpHalGpioSetIntPending(ts.intIoIndex, pending);

gp_gpio_enable_irq(ts.client, 1);

}

先从触摸屏控制器0x80的寄存器开始读取24个byte，然后将读回来的数据进行解析，得到当前触摸的点数，坐标等，之后经过相关的处理后，上报给event。因为是采集多点坐标，然后一起处理这些点的坐标，所以上报完一个点要调用input_mt_sync，直到上报完当前所有按下的点的坐标之后，再调用input_sync 函数达到同步的目的。

以上大致分析了gsl1680电容屏的linux驱动，其实电容屏的驱动处理流程都是大同小异的，处理流程都差不多，具有通用性。

之前还调试过一款墩泰的ft5x06的电容屏，这款比较简单，初始化不用加载firmware，接口也基本差不多，只是ft5x06 手指按下时中断输出引脚为低电平，然而gsl1680这款手指按下的中断信号为周期性的方波。

以上仅供参考，不足之处还请指正。