代码示例_触摸屏驱动

---

#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/delay.h>

#include <plat/gpio-cfg.h>

#define TS_MAX_WIDTH 800
#define TS_MAX_HEIGHT 480


#define TS_INT_GPIO  S5PV210_GPH1(6)
#define TS_RESET_GPIO  S5PV210_GPD0(3)


//设计一个全局的设备对象
struct ts_global{
    int irqno;
    int flags; // 中断触发方式
    struct i2c_client *client; //记录匹配之后的i2c client
    struct input_dev *inputdev;

    struct work_struct work; //中断下半部
};

struct ts_global *gt811_dev;



//重写类似于i2c_master_send()/i2c_master_recv()
int gt811_i2c_send(struct i2c_client *client, char *buf, int count)
{
    int ret;
    
    struct i2c_adapter *adapter = client->adapter;
    struct i2c_msg msg;
    
    msg.addr = client->addr;
    msg.flags = 0; //读1还是写0
    msg.len = count; 
    msg.buf = buf;
    //参数1---适配器--来自于i2c client 
    //参数2--数据包
    //参数3--数据包的个数
    //返回值--正确返回消息的个数，错误返回负数
    ret = i2c_transfer(adapter, &msg, 1);

    return ret==1?count:ret;
    
}


// char rbuf[10] = {0x7, 0x21 /*寄存器地址*/,  };  // 后面8个字节用于存放读取到的数据
// gt811_i2c_recv_reg(client , rbuf, 10);
int gt811_i2c_recv_reg(struct i2c_client *client, char *buf, int count)
{
    int ret;
    
    struct i2c_adapter *adapter = client->adapter;
    struct i2c_msg msg[2];
    
    msg[0].addr = client->addr;
    msg[0].flags = 0; //先写
    msg[0].len = 2;   //寄存器地址为16bit
    msg[0].buf = &buf[0];

    msg[1].addr = client->addr;
    msg[1].flags = 1; //后读
    msg[1].len = count-2;   //
    msg[1].buf = &buf[2]; 
    
    //参数1---适配器--来自于i2c client 
    //参数2--数据包
    //参数3--数据包的个数
    //返回值--正确返回消息的个数，错误返回负数
    ret = i2c_transfer(adapter, msg, 2);

    return ret==2?count-2:ret;

}


int gt811_init_reg(void)
{
    int ret;
    
    uint8_t config_info[] = {
        0x06,0xA2,   //寄存器地址
        
        0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,0x05,0x55,0x15,0x55,0x25,0x55,
        0x35,0x55,0x45,0x55,0x55,0x55,0x65,0x55,0x75,0x55,0x85,0x55,0x95,0x55,0xA5,0x55,
        0xB5,0x55,0xC5,0x55,0xD5,0x55,0xE5,0x55,0xF5,0x55,0x1B,0x03,0x00,0x00,0x00,0x13,
        0x13,0x13,0x0F,0x0F,0x0A,0x50,0x30,0x0D,0x03,0x00,0x05,0x58,0x02,0x00,0x04,0x00,
        0x00,0x32,0x2C,0x34,0x2E,0x00,0x00,0x04,0x14,0x22,0x04,0x00,0x00,0x00,0x00,0x00,
        0x20,0x14,0xEC,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x30,
        0x25,0x28,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x01
    };

    config_info[57] &= ~(1<<3);
    gt811_dev->flags = IRQF_TRIGGER_FALLING;

    config_info[61] = TS_MAX_HEIGHT & 0xff;
    config_info[62] = TS_MAX_HEIGHT >> 8;

    config_info[63] = TS_MAX_WIDTH& 0xff;
    config_info[64] = TS_MAX_WIDTH >> 8;
    
    ret = gt811_i2c_send(gt811_dev->client, config_info, ARRAY_SIZE(config_info));

    return ret>0?0:ret;

}



void gt811_irq_work(struct work_struct *work)
{

    /*
        1，通过i2c_tranfser(会导致休眠)读取到坐标
        2， 分析坐标
        3， 上报坐标

    */

    int ret;
    uint8_t axis_buf[36] = {0x7, 0x21,};
    
    ret = gt811_i2c_recv_reg(gt811_dev->client, axis_buf, 36);
    if(ret < 0)
    {
        printk("gt811_i2c_recv_reg error
");
        return;
    }

    //先进行校验
    //先要知道当前是哪几个点
    unsigned char temp = axis_buf[2] & 0x1f; // 取低5bit
    int i;
    unsigned char soft_chksum = 0;
    int index;
    switch(temp)
    {
        case 0: //没有点，表示抬起
            index = 4;
            break;
        case 1:  //表示第0点被点
            index = 9;
            break;
        case 2: 
        case 3:  //表示第1点被点
            index = 14;
            break;

        default: //表示 2， 3， 4点
            index = 35;
            break;

    }
    for(i=2; i<index; i++)
            soft_chksum += axis_buf[i];

    if(soft_chksum != axis_buf[index])
    {
        printk("check sum error
");
        return ;
    }

    // 判断出当前有几个点，具体是那几个点
    temp = axis_buf[2] & 0x1f; // 取低5bit
    int pcount = 0 ; //点的个数
    int pset[5]; //当前被点的点号集合
    for(i=0; i<5; i++)
    {
        if(temp & 1)
        {
            pset[pcount++]  = i;
        }
        temp = temp >> 1;
    }

    int j;
    __u16 x;
    __u16 y;
    __u8 p;
    int pindex = 0;
    if(pcount > 0)
    {
        for(j=0; j<pcount; j++)
        {
            switch(pset[j])
            {
                case 0:
                    pindex = 4;
                    break;
                case 1:
                    pindex = 9;
                    break;
                case 2:
                    pindex = 14;
                    break;
                case 3:
                    pindex = 19;
                    break;
                case 4:
                    pindex = 30;
                    break;
            }
            if(pset[j] == 3)
            {
                x = axis_buf[19]<<8 | axis_buf[26];
                y = axis_buf[27]<<8 | axis_buf[28];
                p = axis_buf[29];
            }else
            {
                x = axis_buf[pindex]<<8 | axis_buf[pindex+1];
                y = axis_buf[pindex+2]<<8 | axis_buf[pindex+3];
                p = axis_buf[pindex+4];
            }

            swap(x, y);

            y = 480-y;
            //printk("x = %d, y = %d, p = %d, id = %d
", x, y, p, pset[j]);

            input_event(gt811_dev->inputdev, EV_ABS, ABS_MT_POSITION_X, x);
            input_event(gt811_dev->inputdev, EV_ABS, ABS_MT_POSITION_Y, y);
            input_event(gt811_dev->inputdev, EV_ABS, ABS_MT_PRESSURE, p);
            input_event(gt811_dev->inputdev, EV_ABS, ABS_MT_TOUCH_MAJOR, p);
            input_event(gt811_dev->inputdev, EV_ABS, ABS_MT_TRACKING_ID, pset[j]);
            input_mt_sync(gt811_dev->inputdev);
            
        }
    }
    //按下和抬起
    input_report_key(gt811_dev->inputdev, BTN_TOUCH, pcount > 0);
    input_sync(gt811_dev->inputdev);
}


irqreturn_t  gt811_irq_svc(int irqno, void *dev_id)
{


    //启动下半部--委托
    schedule_work(&gt811_dev->work);
    

    return IRQ_HANDLED;
}



int gt811_drv_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret;
    
    gt811_dev = kzalloc(sizeof(struct ts_global), GFP_KERNEL);

    // 0--记录当前的i2c client
    gt811_dev->client = client;

    /*
    4, 硬件初始化：
                    a， 初始化寄存器
                        1， 设置中断引脚为悬浮输入态，RESET设置成GPIO(内部上拉)
                        2， RESET引脚设置成输出低(开始复位)， 延时1ms， 转成输入态
                        3， 延迟至少20ms，通过i2c寻址gt811  (确认复位是否成功)
                        4，如果有响应，分一次或者多次初始化寄存器
                        5，如果没有响应，重复2步骤
                    b， 申请中断--request_irq(), 还要用中断下半部(tasklet, 工作队列(选择这个))
                            |
                            1，通过i2c_tranfser读取到坐标
                            2， 分析坐标
                            3， 上报坐标
    
    */

    gpio_request(TS_INT_GPIO, "ts_int");
    gpio_direction_input(TS_INT_GPIO);
    gpio_free(TS_INT_GPIO);

    gpio_request(TS_RESET_GPIO, "ts_reset");
    s3c_gpio_setpull(TS_RESET_GPIO, S3C_GPIO_PULL_UP);
    mdelay(2);
    gpio_direction_output(TS_RESET_GPIO, 0);
    mdelay(1);
    gpio_direction_input(TS_RESET_GPIO);
    gpio_free(TS_RESET_GPIO);

    mdelay(25);
    //通过发送数据给gt811， 看看是否成功
    char test = 1;
    ret = i2c_master_send(gt811_dev->client, &test, 1);
    if(ret < 0)
    {
        printk("gt811 reset failed or not found
");
        kfree(gt811_dev);
        return ret;
    }else
    {
        printk("gt811 reset ok
");
    }
    
    ret = gt811_init_reg();
    if(ret < 0)
    {
        printk("gt811_init_reg failed
");
        kfree(gt811_dev);
        return ret;
    }else
    {
        printk("gt811 init  ok
");
    }

    // 4， 硬件初始化，获取到硬件的数据，上报给input handler
    //申请中断
    //初始化中断下半部
    INIT_WORK(&gt811_dev->work,  gt811_irq_work);
    
    gt811_dev->irqno = gpio_to_irq(TS_INT_GPIO);
    ret = request_irq(gt811_dev->irqno, gt811_irq_svc, gt811_dev->flags,
                            "ts_eint14", NULL);

    // 1,  构建一个input device 
    gt811_dev->inputdev = input_allocate_device();

    //为输入设备提供额外信息--供用户查看--/sys/class/input/eventX/device/..
    gt811_dev->inputdev->name = "gt811_ts";
    gt811_dev->inputdev->phys = "goodix/ts/input0";
    gt811_dev->inputdev->uniq = "goodix/gt811";
    gt811_dev->inputdev->id.bustype = BUS_I2C;
    gt811_dev->inputdev->id.vendor = 0xDEAD;
    gt811_dev->inputdev->id.product = 0x0007;
    gt811_dev->inputdev->id.version = 0x0001;
    
    // 2, 初始化 input device 
    // 2.1 设置当前输入设备能够产生那些类型数据
    __set_bit(EV_ABS, gt811_dev->inputdev->evbit);
    __set_bit(EV_KEY, gt811_dev->inputdev->evbit);


    // 2.2设置要产生那些按键
    __set_bit(BTN_TOUCH, gt811_dev->inputdev->keybit);
    __set_bit(KEY_MENU, gt811_dev->inputdev->keybit);
    __set_bit(KEY_HOME, gt811_dev->inputdev->keybit);
    __set_bit(KEY_ESC, gt811_dev->inputdev->keybit);


    //  2.3 设置要产生那些绝对数据
    //针对单点
    __set_bit(ABS_X, gt811_dev->inputdev->absbit);
    __set_bit(ABS_Y, gt811_dev->inputdev->absbit);
    __set_bit(ABS_PRESSURE, gt811_dev->inputdev->absbit);

    //针对多点
    __set_bit(ABS_MT_POSITION_X, gt811_dev->inputdev->absbit);
    __set_bit(ABS_MT_POSITION_Y, gt811_dev->inputdev->absbit);
    __set_bit(ABS_MT_PRESSURE, gt811_dev->inputdev->absbit);
    __set_bit(ABS_MT_TOUCH_MAJOR, gt811_dev->inputdev->absbit);
    __set_bit(ABS_MT_TRACKING_ID, gt811_dev->inputdev->absbit);
    

    // 2.4 --如果有abs的值，还需要设置abs的最大值和最小值
    //参数1---设置哪个设备
    //参数2--坐标
    //参数3-4;最小值和最大值
    //参数5-6: 一般填0
    input_set_abs_params(gt811_dev->inputdev, ABS_X, 0, TS_MAX_WIDTH, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_Y, 0, TS_MAX_HEIGHT, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_PRESSURE, 0, 16, 0, 0);

    input_set_abs_params(gt811_dev->inputdev, ABS_MT_POSITION_X, 0, TS_MAX_WIDTH, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_MT_POSITION_Y, 0, TS_MAX_HEIGHT, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_MT_PRESSURE, 0, 16, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_MT_TOUCH_MAJOR, 0, 16, 0, 0);
    input_set_abs_params(gt811_dev->inputdev, ABS_MT_TRACKING_ID, 0, 4, 0, 0);
    
    // 3, 注册input device 
    ret = input_register_device(gt811_dev->inputdev);


    
    
    
    

    return 0;

}


int gt811_drv_remove(struct i2c_client *client)
{
    
    input_unregister_device(gt811_dev->inputdev);
    input_free_device(gt811_dev->inputdev);

    cancel_work_sync(&gt811_dev->work);
    free_irq(gt811_dev->irqno, NULL);
    
    kfree(gt811_dev);

    return 0;
}


const struct i2c_device_id  gt811_id_table[] = {
        {"gt811_i2c_ts", 0x811},
        {}
};


struct i2c_driver gt811_i2c_drv = {
    .probe = gt811_drv_probe,
    .remove = gt811_drv_remove,
    .driver = {
        .name = "gt811_drv",
    },
    .id_table = gt811_id_table,

};




static int __init gt811_drv_init(void)
{
    //注册一个i2c driver
    return i2c_add_driver(&gt811_i2c_drv);

}


static void __exit gt811_drv_exit(void)
{
    
    i2c_del_driver(&gt811_i2c_drv);
}

module_init(gt811_drv_init);
module_exit(gt811_drv_exit);
MODULE_LICENSE("GPL");

---

CROSS_COMPILE = arm-none-linux-gnueabi-
CC = $(CROSS_COMPILE)gcc

#指定内核源码路径
KERNEL_DIR = /home/kernel/linux-3.0.8
CUR_DIR = $(shell pwd)

MYAPP = ts_app

MODULE = gt811_i2c_drv

all:
    #让make进入内核源码编译，同时将当前目录中的c程序作为内核模块一起编译
    make -C $(KERNEL_DIR) M=$(CUR_DIR) modules
ifneq ($(MYAPP), )    
    $(CC)  -o $(MYAPP) $(MYAPP).c
endif

clean:
    #删除上面编译生成的文件
    make -C $(KERNEL_DIR) M=$(CUR_DIR) clean
    rm -rf $(MYAPP)

install:
    cp *.ko $(MYAPP) /opt/rootfs/drv_module

#指定当前目录下哪个文件作为内核模块编
obj-m += $(MODULE).o

---

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/input.h>


int main(void)
{

    int fd;
    int ret;

    struct input_event package;

 
    fd = open("/dev/event0",O_RDWR);
    if(fd < 0)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        bzero(&package,sizeof(package));
        ret = read(fd, &package,sizeof(package));
        if(ret < 0)
        {
            perror("read");
            exit(1);
        }
        //拆包
        if(package.type == EV_KEY)
        {
            if(package.code == KEY_DOWN)
            {
                if(package.value)
                {
                    printf("<app>-- KEY_DOWN pressed
");
                }else
                {
                    printf("<app>-- KEY_DOWN up
");
                }
            }
            if(package.code == KEY_POWER)
            {
                if(package.value)
                {
                    printf("<app>-- KEY_POWER pressed
");
                }else
                {
                    printf("<app>-- KEY_POWER up
");
                }
            }
        }


        if(package.type == EV_ABS)
        {
            switch(package.code)
            {
                case ABS_MT_POSITION_X:
                    printf(" x = %d ", package.value);
                    break;
                case ABS_MT_POSITION_Y:
                    printf(" y = %d ", package.value);
                    break;
                case ABS_MT_PRESSURE:
                    printf(" p = %d ", package.value);
                    break;
                case ABS_MT_TRACKING_ID:
                    printf(" id = %d 
", package.value);
                    break;

            }
        }
    }

    close(fd);
    
    return 0;
}