15、電容觸摸屏驅動

 

在讀者學習本章以及后續章節之前，最好擁有ADC和觸摸屏裸機基礎，可以參考：ADC和觸摸屏編程。

 

和按鍵驅動類似，觸摸屏也是通過電平來體現按下或松開。因此如果想要寫出通用的觸摸屏驅動，需要使用輸入子系統完成。

考慮到我是用的並不是之前的TINY4412，在此給出下文所分析的文件：

https://files.cnblogs.com/files/Lioker/15_ts.zip

 

 

一、電容觸摸屏檢測原理

此段來源於百度百科，讀者可查看：電容式觸摸屏。

電容式觸摸屏技術是利用人體的電流感應進行工作的。

電容式觸摸屏是一塊四層復合玻璃屏，玻璃屏的內表面和夾層各塗有一層ITO（導電玻璃），最外層是一薄層矽土玻璃保護層，夾層ITO塗層作為工作面，四個角上引出四個電極，內層ITO為屏蔽層以保證良好的工作環境。

當用戶觸摸電容屏時，由於人體電場，用戶手指和工作面形成一個耦合電容，因為工作面上接有高頻信號，於是手指吸收走一個很小的電流，這個電流分別從屏的四個角上的電極中流出，且理論上流經四個電極的電流與手指頭到四角的距離成比例，控制器通過對四個電流比例的精密計算得出位置。可以達到99%的精確度，具備小於3ms的響應速度。

 

 

二、電容觸摸屏控制芯片驅動分析

我使用的開發板iTOP4412的觸摸屏IC為ft5406，對應的驅動文件是drivers/input/touchscreen/ft5x06_ts.c。下面來分析此文件。

首先從init()函數分析：

static int __init ft5x0x_ts_init(void)
{
    int ret;
    int type;

    type = get_lcd_type();

    /* 設置GPIO引腳 */
    ret = gpio_request(EXYNOS4_GPL0(2), "TP1_EN");
...
    gpio_direction_output(EXYNOS4_GPL0(2), 1);

    s3c_gpio_cfgpin(EXYNOS4_GPL0(2), S3C_GPIO_OUTPUT);
    gpio_free(EXYNOS4_GPL0(2));

    mdelay(5);

    printk("==%s: reset==\n", __FUNCTION__);
    ret = gpio_request(EXYNOS4_GPX0(3), "GPX0_3");
...
    gpio_direction_output(EXYNOS4_GPX0(3), 0);
    mdelay(200);
    /* 給觸摸芯片復位 */
    gpio_direction_output(EXYNOS4_GPX0(3), 1);

    s3c_gpio_cfgpin(EXYNOS4_GPX0(3), S3C_GPIO_OUTPUT);
    gpio_free(EXYNOS4_GPX0(3));
    msleep(300);
...
    /* 注冊I2C驅動 */
    return i2c_add_driver(&ft5x0x_ts_driver);
}

 

此觸摸屏使用的是i2c驅動，我們來看看此驅動結構體定義了什么。

static struct i2c_driver ft5x0x_ts_driver = {
    .probe        = ft5x0x_ts_probe,
    .remove        = __devexit_p(ft5x0x_ts_remove),
    .id_table    = ft5x0x_ts_id,
    .driver    = {
        .name    = FT5X0X_NAME,    // #define FT5X0X_NAME "ft5x0x_ts"
        .owner    = THIS_MODULE,
    },
};

 

接下來，我們來查看probe()函數：

static int ft5x0x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    struct ft5x0x_i2c_platform_data *pdata;
    struct ft5x0x_ts_data *ts;
    struct input_dev *input_dev;
    unsigned char val;
    int err = -EINVAL;
    /* 判斷是否為i2c設備 */
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
...
    }
    /* 分配空間，此結構體用於存儲坐標, 壓力值, 事件 */
    ts = kzalloc(sizeof(*ts), GFP_KERNEL);
...
    /* 獲取dev的平台數據 */
    pdata = client->dev.platform_data;

    ts->screen_max_x = pdata->screen_max_x;
    ts->screen_max_y = pdata->screen_max_y;
    ts->pressure_max = pdata->pressure_max;
    /* 設置引腳為中斷模式 */
    ts->gpio_irq = pdata->gpio_irq;
    if (ts->gpio_irq != -EINVAL) {
        client->irq = gpio_to_irq(ts->gpio_irq);
    } else {
        goto exit_no_pdata;
    }
    if (pdata->irq_cfg) {
        s3c_gpio_cfgpin(ts->gpio_irq, pdata->irq_cfg);
        s3c_gpio_setpull(ts->gpio_irq, S3C_GPIO_PULL_NONE);
    }

    ts->gpio_wakeup = pdata->gpio_wakeup;
    ts->gpio_reset = pdata->gpio_reset;
    /* 創建工作隊列 */
    INIT_WORK(&ts->work, ft5x0x_ts_pen_irq_work);
    this_client = client;
    i2c_set_clientdata(client, ts);

    ts->queue = create_singlethread_workqueue(dev_name(&client->dev));
...
    /* 分配設置注冊輸入子系統 */
    input_dev = input_allocate_device();
    ts->input_dev = input_dev;

    set_bit(EV_SYN, input_dev->evbit);    /* 同步事件 */
    set_bit(EV_ABS, input_dev->evbit);    /* 絕對位移事件，存儲坐標 */
    set_bit(EV_KEY, input_dev->evbit);    /* 按鍵事件 */

#ifdef CONFIG_FT5X0X_MULTITOUCH
    set_bit(ABS_MT_TRACKING_ID, input_dev->absbit);
    set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);
    set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);
    set_bit(ABS_MT_POSITION_X, input_dev->absbit);
    set_bit(ABS_MT_POSITION_Y, input_dev->absbit);

    input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, ts->screen_max_x, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, ts->screen_max_y, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, ts->pressure_max, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, FT5X0X_PT_MAX, 0, 0);
#else
    set_bit(ABS_X, input_dev->absbit);    /* 絕對位移事件中的x坐標 */
    set_bit(ABS_Y, input_dev->absbit);    /* 絕對位移事件中的y坐標 */
    set_bit(ABS_PRESSURE, input_dev->absbit);    /* 絕對位移事件中的壓力值 */
    set_bit(BTN_TOUCH, input_dev->keybit);        /* 按鍵事件中的觸摸屏事件 */
    /* 設置x, y, 壓力值的范圍和初始值 */
    input_set_abs_params(input_dev, ABS_X, 0, ts->screen_max_x, 0, 0);
    input_set_abs_params(input_dev, ABS_Y, 0, ts->screen_max_y, 0, 0);
    input_set_abs_params(input_dev, ABS_PRESSURE, 0, ts->pressure_max, 0 , 0);
#endif

    input_dev->name = FT5X0X_NAME;
    input_dev->id.bustype = BUS_I2C;
    input_dev->id.vendor = 0x12FA;
    input_dev->id.product = 0x2143;
    input_dev->id.version = 0x0100;

    err = input_register_device(input_dev);
...
    /* 讀取芯片硬件信息 */
    msleep(3);
    err = ft5x0x_read_fw_ver(&val);

    err = request_irq(client->irq, ft5x0x_ts_interrupt, IRQ_TYPE_EDGE_FALLING, "ft5x0x_ts", ts);
    disable_irq(client->irq);
    dev_info(&client->dev, "Firmware version 0x%02x\n", val);
    /* 支持休眠功能 */
#ifdef CONFIG_HAS_EARLYSUSPEND
    ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;//EARLY_SUSPEND_LEVEL_DISABLE_FB + 1;
    ts->early_suspend.suspend = ft5x0x_ts_suspend;
    ts->early_suspend.resume = ft5x0x_ts_resume;
    register_early_suspend(&ts->early_suspend);
#endif

    enable_irq(client->irq);

    dev_info(&client->dev, "FocalTech ft5x0x TouchScreen initialized\n");

    return err;
}

probe()函數所做的事情主要有：

1. 判斷是否為i2c設備

2. 分配並設置struct ft5x0x_ts_data，此結構體中存儲有最大y坐標，最大壓力值，工作隊列等。

struct ft5x0x_ts_data {
    struct input_dev *input_dev;
    struct ft5x0x_event event;

    uint32_t gpio_irq;
    uint32_t gpio_wakeup;
    uint32_t gpio_reset;

    int screen_max_x;
    int screen_max_y;
    int pressure_max;

    struct work_struct work;
    struct workqueue_struct *queue;

#ifdef CONFIG_HAS_EARLYSUSPEND
    struct early_suspend early_suspend;
#endif
};

3. 設置中斷

4. 初始化工作隊列（工作隊列可以休眠）

5. 分配、設置並注冊input_device

 

當有觸摸屏事件發生時，會跳轉到probe()函數中注冊的中斷處理函數ft5x0x_ts_interrupt()中執行，由於在probe()函數中設置了工作隊列，因此中斷函數會跳轉至工作隊列函數ft5x0x_ts_pen_irq_work()：

static irqreturn_t ft5x0x_ts_interrupt(int irq, void *dev_id) {
    struct ft5x0x_ts_data *ts = dev_id;

    disable_irq_nosync(this_client->irq);

    if (!work_pending(&ts->work)) {
        queue_work(ts->queue, &ts->work);
    }

    return IRQ_HANDLED;
}

由於i2c讀取函數底層可能擁有休眠操作，但是中斷中並不允許休眠，因此需要設置工作隊列。

 

在工作隊列函數中，首先完成讀取x，y和壓力值等參數的工作，之后完成參數的上報工作。

static int ft5x0x_read_data(struct ft5x0x_ts_data *ts) {
    struct ft5x0x_event *event = &ts->event;
    u8 buf[64] = { 0 };
    int ret;
...
    ret = ft5x0x_i2c_rxdata(buf, 7);
...
    memset(event, 0, sizeof(struct ft5x0x_event));
    event->touch_point = buf[2] & 0x0F;

    if (!event->touch_point) {
        ft5x0x_ts_release(ts);
        return 1;
    }
    /* 判斷有幾個點按下，也就是支持多指觸控 */
#ifdef CONFIG_FT5X0X_MULTITOUCH
    switch (event->touch_point) {
        case 10:
            event->x[9] = (s16)(buf[57] & 0x0F)<<8 | (s16)buf[58];
            event->y[9] = (s16)(buf[59] & 0x0F)<<8 | (s16)buf[60];
        case 9:
            event->x[8] = (s16)(buf[51] & 0x0F)<<8 | (s16)buf[52];
            event->y[8] = (s16)(buf[53] & 0x0F)<<8 | (s16)buf[54];
        case 8:
            event->x[7] = (s16)(buf[45] & 0x0F)<<8 | (s16)buf[46];
            event->y[7] = (s16)(buf[47] & 0x0F)<<8 | (s16)buf[48];
        case 7:
            event->x[6] = (s16)(buf[39] & 0x0F)<<8 | (s16)buf[40];
            event->y[6] = (s16)(buf[41] & 0x0F)<<8 | (s16)buf[42];
        case 6:
            event->x[5] = (s16)(buf[33] & 0x0F)<<8 | (s16)buf[34];
            event->y[5] = (s16)(buf[35] & 0x0F)<<8 | (s16)buf[36];
        case 5:
            event->x[4] = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];
            event->y[4] = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];
        case 4:
            event->x[3] = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];
            event->y[3] = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];
            //printk("x:%d, y:%d\n", event->x[3], event->y[3]);
        case 3:
            event->x[2] = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];
            event->y[2] = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];
            //printk("x:%d, y:%d\n", event->x[2], event->y[2]);
        case 2:
            event->x[1] = (s16)(buf[0x09] & 0x0F)<<8 | (s16)buf[0x0a];
            event->y[1] = (s16)(buf[0x0b] & 0x0F)<<8 | (s16)buf[0x0c];
            //printk("x:%d, y:%d\n", event->x[1], event->y[1]);
        case 1:
            event->x[0] = (s16)(buf[0x03] & 0x0F)<<8 | (s16)buf[0x04];
            event->y[0] = (s16)(buf[0x05] & 0x0F)<<8 | (s16)buf[0x06];
            //printk("x:%d, y:%d\n", event->x[0], event->y[0]);
            break;
        default:
            printk("%s: invalid touch data, %d\n", __func__, event->touch_point);
            return -1;
    }
#else
    if (event->touch_point == 1) {
        event->x[0] = (s16)(buf[0x03] & 0x0F)<<8 | (s16)buf[0x04];
        event->y[0] = (s16)(buf[0x05] & 0x0F)<<8 | (s16)buf[0x06];
    }
#endif

    event->pressure = 200;

    return 0;
}

static void ft5x0x_ts_report(struct ft5x0x_ts_data *ts) {
    struct ft5x0x_event *event = &ts->event;
    int x, y;
    int i = 0;
    /* 上報事件 */
    if (event->touch_point == 1) {
        if (swap_xy) {
            x = event->y[i];
            y = event->x[i];
        } else {
            x = event->x[i];
            y = event->y[i];
        }

        if (scal_xy) {
            x = (x * ts->screen_max_x) / TOUCH_MAX_X;
            y = (y * ts->screen_max_y) / TOUCH_MAX_Y;
        }

        input_report_abs(ts->input_dev, ABS_X, x);
        input_report_abs(ts->input_dev, ABS_Y, y);
        input_report_abs(ts->input_dev, ABS_PRESSURE, event->pressure);
    }

    input_report_key(ts->input_dev, BTN_TOUCH, 1);

    input_sync(ts->input_dev);
}

static void ft5x0x_ts_pen_irq_work(struct work_struct *work) {
    struct ft5x0x_ts_data *ts = container_of(work, struct ft5x0x_ts_data, work);

    if (!ft5x0x_read_data(ts)) {
        ft5x0x_ts_report(ts);
    }

    enable_irq(this_client->irq);
}

 

下面我們來總結一下整體過程：

1. 設置GPIO引腳

2. 注冊i2c設備驅動

3. 分配、設置和注冊struct input_dev

4. 設置、注冊觸摸屏中斷，注冊觸摸屏中斷函數底半部函數

5. 中斷函數中調用工作隊列

6. 工作隊列中讀取數據后上報數據

 

 

下一章我們根據分析的文件來自己實現觸摸屏驅動。

三、自己實現觸摸屏驅動

觸摸屏驅動源代碼：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/irq.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>

#include <asm/io.h>
#include <asm/uaccess.h>

#include <mach/gpio.h>
#include <mach/regs-gpio.h>

#include <plat/gpio-cfg.h>

static struct work_struct wq;

struct ft5x0x_event {
    int touch_point;
    u16 x[2];
    u16 y[2];
    u16 pressure;
};

int TOUCH_MAX_X = 1024;
int TOUCH_MAX_Y = 768;

static struct input_dev *ftinput;

static struct i2c_client *ft5x0x_client;

static int swap_xy;
static int touch_size;

static void ft5x0x_release(void)
{
    input_report_abs(ftinput, ABS_PRESSURE, 0);
    input_report_key(ftinput, BTN_TOUCH, 0);
    input_sync(ftinput);
}

static void ft5x0x_report(struct ft5x0x_event *event)
{
    int x, y;
    int i = 0;

    if (swap_xy) {
        x = event->y[i];
        y = event->x[i];
    }
    else {
        x = event->x[i];
        y = event->y[i];
    }

    input_report_abs(ftinput, ABS_X, x);
    input_report_abs(ftinput, ABS_Y, y);
    input_report_abs(ftinput, ABS_PRESSURE, event->pressure);

    input_report_key(ftinput, BTN_TOUCH, 1);

    input_sync(ftinput);
}


static int master_rx(char *rxdata, int length) {
    int ret;
    struct i2c_msg msgs[] = {
        {
            .addr    = ft5x0x_client->addr,
            .flags    = 0,
            .len    = 1,
            .buf    = rxdata,
        },
        {
            .addr    = ft5x0x_client->addr,
            .flags    = I2C_M_RD,
            .len    = length,
            .buf    = rxdata,
        },
    };

    ret = i2c_transfer(ft5x0x_client->adapter, msgs, 2);
    if (ret < 0)
        printk(KERN_ERR "i2c_transfer error\n");

    return ret;
}

static int ft5x0x_read_data(struct ft5x0x_event *event)
{
    int ret;
    u8 buf[64] = { 0 };

    ret = master_rx(buf, 7);

    memset(event, 0, sizeof(struct ft5x0x_event));

    event->touch_point = buf[2] & 0x0F;
    if (!event->touch_point) {
        ft5x0x_release();
        return 1;
    }

    event->x[0] = (s16)(buf[0x03] & 0x0F)<<8 | (s16)buf[0x04];
    event->y[0] = (s16)(buf[0x05] & 0x0F)<<8 | (s16)buf[0x06];

    event->pressure = 200;

    return 0;
}

static void i2c_wq_irq(unsigned long arg)
{
    struct ft5x0x_event event;
    
    if (!ft5x0x_read_data(&event)) {
        ft5x0x_report(&event);
    }
    
    printk("(%d, %d)\n", event.x[0], event.y[0]);
}

static irqreturn_t ft5x0x_irq(int irq, void *arg)
{
    schedule_work(&wq);
    return IRQ_HANDLED;
}

static int read_device_info(u8 addr, u8 *val) 
{
    int ret;
    u8 buf = { 0 };
    struct i2c_msg msgs[2];

    msgs[0].addr  = ft5x0x_client->addr;
    msgs[0].buf      = &buf;
    msgs[0].flags = 0;
    msgs[0].len   = 1;

    msgs[1].addr  = ft5x0x_client->addr;
    msgs[1].buf      = &buf;
    msgs[1].flags = 1;
    msgs[1].len   = 1;

    buf = addr;
    ret = i2c_transfer(ft5x0x_client->adapter, msgs, 2);
    if (ret < 0)
        printk(KERN_ERR "i2c_transfer addr 0x%02x error!", buf);
    else
        *val = buf;

    return ret;
}

static int device_info(unsigned char *val)
{
    int ret;

    ret = read_device_info(0xA6, val);

    printk("device_info: %d\n",*val);

    return ret;
}

static int ft5x0x_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret;
    ft5x0x_client = client;
    unsigned char val = 0;

    /* 設置中斷引腳 */
    client->irq = gpio_to_irq(EXYNOS4_GPX0(4));
    s3c_gpio_cfgpin(client->irq, S3C_GPIO_SFN(0xf));
    s3c_gpio_setpull(client->irq, S3C_GPIO_PULL_NONE);

    /* 分配設置input_device */
    ftinput = input_allocate_device();

    set_bit(EV_ABS, ftinput->evbit);
    set_bit(EV_KEY, ftinput->evbit);
    set_bit(EV_SYN, ftinput->evbit);
    
    set_bit(ABS_X, ftinput->absbit);
    set_bit(ABS_Y, ftinput->absbit);
    set_bit(ABS_PRESSURE, ftinput->absbit);
    set_bit(BTN_TOUCH, ftinput->keybit);

    input_set_abs_params(ftinput, ABS_X, 0, 768, 0, 0);
    input_set_abs_params(ftinput, ABS_Y, 0, 1024, 0, 0);
    input_set_abs_params(ftinput, ABS_PRESSURE, 0, 255, 0 , 0);

    ftinput->name = "ft5x0x";
    ftinput->id.bustype = BUS_I2C;

    ret = input_register_device(ftinput);
    if (ret) {
        printk(KERN_ERR "input_register_device error\n");
        input_free_device(ftinput);
    }

    ret = request_irq(client->irq, ft5x0x_irq, IRQ_TYPE_EDGE_FALLING, "ft5x0x", NULL);
    if (ret < 0) {
        printk(KERN_ERR "request_irq %d error\n", client->irq);
        goto exit_irq_request_failed;
    }

    /* 注冊中斷底半部 */
    INIT_WORK(&wq, i2c_wq_irq);
    
    device_info(&val);
    
    return 0;

exit_irq_request_failed:
    input_unregister_device(ftinput);

    return ret;
}

static int ft5x0x_remove(struct i2c_client *client)
{
    /* 鏡像注銷 */
    input_unregister_device(ftinput);
    cancel_work_sync(&wq);
    client->irq = gpio_to_irq(EXYNOS4_GPX0(4));
    free_irq(client->irq, NULL);
    
    return 0;
}

static const struct i2c_device_id ft5x0x_table[] = {
    { "ft5x0x", 0 },
    { },
};

static struct i2c_driver ft5x0x_driver = {
    .driver = {
        .name    = "ft5x0x",
        .owner    = THIS_MODULE,
    },
    .probe        = ft5x0x_probe,
    .remove        = __devexit_p(ft5x0x_remove),
    .id_table    = ft5x0x_table,
};

static int ft5x0x_init(void)
{
    int ret;
    ret = gpio_request(EXYNOS4_GPL0(2), "TP1_EN");
    if (ret)
        printk(KERN_ERR "failed to request TP1_EN for I2C control\n");
    
    gpio_direction_output(EXYNOS4_GPL0(2), 1);

    s3c_gpio_cfgpin(EXYNOS4_GPL0(2), S3C_GPIO_OUTPUT);
    gpio_free(EXYNOS4_GPL0(2));

    mdelay(5);
    
    ret = gpio_request(EXYNOS4_GPX0(3), "GPX0_3");
    if (ret) {
        gpio_free(EXYNOS4_GPX0(3));
        ret = gpio_request(EXYNOS4_GPX0(3), "GPX0_3");
        if (ret) {
            printk(KERN_ERR "failed to request GPX0_3 \n");
        }
    }
    gpio_direction_output(EXYNOS4_GPX0(3), 0);
    mdelay(200);

    gpio_direction_output(EXYNOS4_GPX0(3), 1);

    s3c_gpio_cfgpin(EXYNOS4_GPX0(3), S3C_GPIO_OUTPUT);
    gpio_free(EXYNOS4_GPX0(3));
    msleep(300);

    touch_size = 1;
    swap_xy = 1;
    
    return i2c_add_driver(&ft5x0x_driver);
}

static void ft5x0x_exit(void)
{
    i2c_del_driver(&ft5x0x_driver);
}

module_init(ft5x0x_init);
module_exit(ft5x0x_exit);

MODULE_LICENSE("GPL");

Makefile：

KERN_DIR = /work/itop4412/tools/linux-3.5

all:
    make -C $(KERN_DIR) M=`pwd` modules 

clean:
    make -C $(KERN_DIR) M=`pwd` modules clean
    rm -rf modules.order

obj-m    += ts.o

 

由於觸摸屏驅動已經被編譯到了內核，我們要先取消它：

$ make menuconfig

Device Drivers --->

Input device support --->

Touchscreens --->

去掉FT5X0X based touchscreens

 

我並沒有編寫i2c_client層，而是在mach-itop4412.c中進行更改：

在第2078行代碼的基礎上，加入#else內容：

#if defined(CONFIG_TOUCHSCREEN_FT5X0X)
    {
        I2C_BOARD_INFO("ft5x0x_ts", 0x70>>1),
        .irq = IRQ_EINT(4),
        .platform_data = &ft5x0x_pdata,
    },
/* 加入的代碼 */
#else
    {
        I2C_BOARD_INFO("ft5x0x", 0x70 >> 1),
    },
#endif

 

在重新編譯燒寫內核后，insmod自己的觸摸屏驅動，點擊屏幕可發現如下現象：

 

 

下一章  16、USB驅動