EDA365电子论坛网

标题: linux 输入子系统之电阻式触摸屏驱动 [打印本页]

---

作者: haidaowang    时间: 2020-4-20 09:58
标题: linux 输入子系统之电阻式触摸屏驱动
一、输入子系统情景回忆ING......

在Linux中，输入子系统是由输入子系统设备驱动层、输入子系统核心层(Input Core)和输入子系统事件处理层(Event Handler)组成。其中设备驱动层提供对硬件各寄存器的读写访问和将底层硬件对用户输入访问的响应转换为标准的输入事件，再通过核心层提交给事件处理层；而核心层对下提供了设备驱动层的编程接口，对上又提供了事件处理层的编程接口；而事件处理层就为我们用户空间的应用程序提供了统一访问设备的接口和驱动层提交来的事件处理。所以这使得我们输入设备的驱动部分不在用关心对设备文件的操作，而是要关心对各硬件寄存器的操作和提交的输入事件。下面用图形来描述一下这三者的关系吧！



& l# a* H. c; o" q, A* g2 c二、S3C2440触摸屏接口预热ING......
0 n/ \, c6 w4 P- ^0 P
S3C2440提供的触摸屏接口有4种处理模式，分别是：正常转换模式、单独的X/Y位置转换模式、自动X/Y位置转换模式

& ]! M, U( O" i8 X; o8 S和等待中断模式，对于在每种模式下工作的要求，请详细查看数据手册的描述。本驱动实例将采用自动X/Y位置转换
) @  a- z3 h8 X: i1 ]
模式和等待中断模式。

* ?3 X; L7 s* j, [三、tq2440_ts.c源码分析
. [; @1 u1 s2 G, Q" a+ c
1.入口函数，为了方便分析，清晰架构，这里省去了返回值的判断，最详细的还请参考后面的源码。

& r) |* j+ C' Y2 z* q; N
static int __init tq2440ts_init(void)
{
        struct input_dev *input_dev;

( m2 K! i" c6 a0 t! C        /* 获取ADC时钟，使能时钟(CLKCON[15])
0 I. L3 ]! r6 w  l3 {5 D0 O' ^         * ADC(&Touch Screen) [15], Control PCLK into ADC block.
: G/ W9 p9 z& _         */
4 Q  \! D! o4 `* j+ J1 Z# {        adc_clock = clk_get(NULL, "adc");
; ]; Q5 C+ L$ F* \        clk_enable(adc_clock);
6 R- S# w8 Q" _1 C
8 n6 k8 z# i# v3 X, P: ^8 f        /* ADCCON寄存器地址:0x58000000 */
& w$ I( C& A  i- O        base_addr=ioremap(S3C2410_PA_ADC,0x20);       
& t3 o* T# _( y" {, v0 w- R
* ^: F) g% ?: A( ^' {  T        /* 使能预分频，预分频系数PRSCVL为0xff */
        iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF),base_addr+S3C2410_ADCCON);
       
        /* ADCDLY = 0xffff */
3 @2 Z( x3 l( O! R% ?  {% z        iowrite32(0xffff,  base_addr+S3C2410_ADCDLY);
       
  j$ ^. y; p4 ~+ p        /* 进入等待按下中断模式 */
        iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);

        /* 分配一个input_dev结构体 */
        input_dev = input_allocate_device();       
& B: W1 M, e' r+ a# p* ~6 \
        /* 初始化输入设备,即input_dev成员 */
        dev = input_dev;

        /* 支持同步事件、按键事件、绝对位移事件 */
        dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
) f$ ~; z- I3 Q  K
        /* 支持按键类中的触摸屏点击 */
        dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);
( O& V  f) X# w- O  v2 Y! e* B
7 I' p+ P% h. l        /* 设置触摸屏的X坐标、Y坐标、压力 */
* y2 V, u7 h/ J  V5 R        input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0);  /* Resolution: 10-bit,0x3ff即10位 */
        input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0);
8 G) k9 B% T8 {2 @" }        input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0);

        /* 下面这些信息在驱动挂载后在/proc/bus/input/devices中看到 */
7 L+ n. F; Q/ b- g6 |7 y8 H        dev->name = tq2440ts_name;
2 q# \4 e, t2 D- E% y4 j& d1 p" m        dev->id.bustype = BUS_RS232;
# o4 S4 a' z$ k/ M, u        dev->id.vendor = 0xDEAD;
& w' o( K) R  ]) v7 t: a6 f/ q        dev->id.product = 0xBEEF;
+ o7 r+ a* s0 a: K/ e$ y9 s        dev->id.version = S3C2410TSVERSION;

        /* 分别申请ADC、TC中断，在ADC中断里使用了IRQF_SHARED
         * 共享中断标志，因为在ADC驱动里也使用了ADC中断
         */
$ P- s( N1 R7 m) t- M2 p3 z- n" `        request_irq(IRQ_ADC, stylus_action, IRQF_SHARED|IRQF_SAMPLE_RANDOM, tq2440ts_name, dev)
        request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM, tq2440ts_name, dev)
  u8 `, V9 G% a4 Y
( c9 M. x4 E0 |% i4 K7 R# h+ A        printk(KERN_INFO "%s successfully loaded\n", tq2440ts_name);

        /* 将触摸屏输入设备注册到输入子系统 */
/ u4 r/ D! @; w  ?        input_register_device(dev);
        return 0;
}
驱动加载函数tq2440ts_init主要做了以下一些事情：获取ADC时钟，使能ADC时钟，映射ADC的IO地址，使能预分频、设ADCDLY寄存器，进入等待按下中断模式，分配一个input_dev结构体，初始化input_dev结构体成员，如：支持哪类事件、支持这类事件的哪些事件，申请ADC、TC中断，最后注册一个触摸屏输入设备。万事具备，只欠东风。加载函数准备好一切条件后，就当你触摸触摸屏了，当触摸屏被触摸后，即被按下后，会进入触摸屏中断处理函数stylus_updown
6 Y, V9 W8 c2 E- D) ~- r
2 [/ G3 m' I! b$ O
* x6 q- X% M, o0 I+ r( R/* 触摸屏中断服务程序，当触摸屏按下或抬起时触发执行 */
# `6 g5 ~  _. zstatic irqreturn_t stylus_updown(int irq, void *dev_id)
5 l7 Y  [; G% m* [0 M{
! A9 T9 p5 B+ O; X        unsigned long data0;
        unsigned long data1;
4 [9 Y5 W; d1 `, H; L' a        /* 用于判断触摸屏是按下还是抬起 */
        int updown;

0 A0 q7 Q1 [. G0 ^% B, x4 N8 }        /* ADC资源可以获取，即上锁 */
5 M8 N$ w( Q' Q* g* G# E        if (down_trylock(&ADC_LOCK) == 0)
& u! r  K* p- C' V        {
4 [! h" \' ~  s$ s; O7 T                /* 标识触摸屏资源可用 */
1 I5 ?; H7 x) B, F* L                OwnADC = 1;
' e, ^: ^- r. Q1 f1 P& ?5 n
. B, a1 p( i: q# @- O( V                /* 读取AD转换后的值，注意这次重点是读出状态 */
                data0 = ioread32(base_addr+S3C2410_ADCDAT0);
+ P/ m- H3 |# x1 `                data1 = ioread32(base_addr+S3C2410_ADCDAT1);
                updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

                if (updown)
  _# o4 U6 d1 n& C, t                {
                        /*        ADCDAT0[15] = 0,则updown = 1，此时表示按下状态
                         *  那么调用touch_timer_fire函数启动ADC转换
                         */
- I0 c' k. I# Q% H$ u- y  ^; P: b                        touch_timer_fire(0);
                }
                else
                {
. @, B6 e' h' G" v3 ]* m4 D                        /* 如果是抬起状态,就结束这次的操作，并释放ADC资源的占用，即解锁 */
) Z4 W7 s9 H# y                        OwnADC = 0;
                        up(&ADC_LOCK);
+ l% i' x! ~  B                }
% [" v  u- [) _; E# M7 B/ G) P8 Z9 f        }
6 c. o1 I) |& H1 v        return IRQ_HANDLED;
( J- r. Z9 }+ M6 |# r}
stylus_updown函数首先获得ADC资源，因为在ADC驱动里也有可能使用了ADC资源，然后获得触摸屏状态，判断触摸屏是被按下还是被抬起，如果是被按下，那么调用touch_timer_fire函数启动ADC转换；如果是抬起状态,就结束这次的操作，并释放ADC资源的占用。
touch_timer_fire函数分析

0 l- e1 D& {8 L6 r$ r. Hstatic void touch_timer_fire(unsigned long data)
{
          unsigned long data0;
3 B3 f+ F' @7 ?          unsigned long data1;
+ X( Y. @5 B4 b        int updown;
& @' X2 Y/ E3 A* q
& y4 {# t! N( c) A  P' S* ?        /* 读取AD转换后的值，注意这次重点是读出状态 */
2 e& g6 ^& C+ x6 S7 t/ L  o, r          data0 = ioread32(base_addr+S3C2410_ADCDAT0);
          data1 = ioread32(base_addr+S3C2410_ADCDAT1);
        updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

4 l: P- w8 r, x3 _/ @- S         if (updown) {
                /* 如果是按下状态，并且ADC已经转换，就报告事件和数据 */
                if (count != 0)
                {
9 B/ F9 e% \+ `0 Z                        long tmp;
                        tmp = xp;
                        xp = yp;
+ Z1 z# n* U9 q9 K7 Y1 h! {/ D                        yp = tmp;

5 r2 e8 K0 d7 m9 x) ~7 j  y: y                        /* stylus_action函数是4次采样，所以要除以4 */                                                                                                                                                                         
            xp >>= 2;
                        yp >>= 2;
- r! {) x5 C+ K# v! Y5 J/ i
                        /* 上报X/Y坐标数据 */
                        input_report_abs(dev, ABS_X, xp);
0 o6 ?0 ?/ x6 u4 o( A% q( G+ o                         input_report_abs(dev, ABS_Y, yp);
4 Z+ ~+ ?3 l1 x2 }- K" _
                        /* 报告按键事件，键值为1表示触摸点被按下 */
                        input_report_key(dev, BTN_TOUCH, 1);
  h0 o' I5 q3 ~; Z
0 c/ F9 ]3 }) {. K0 A: n                        /* 报告触摸屏状态，键值为1表示触摸屏被按下 */
                        input_report_abs(dev, ABS_PRESSURE, 1);

                        /* 报告完后，上报同步事件 */
                        input_sync(dev);
. P5 Q" v4 K1 f6 G                 }
               
                /* 如果是按下状态，但ADC还没开始转换，就启动ADC转换 */
' G3 ~* p3 q: \7 ^) l: V                 xp = 0;
) n! t, Z% I* R3 O7 X8 b- [4 o                 yp = 0;
7 A7 V5 w: y( R                 count = 0;

  ^3 @4 L. b: `7 @+ \                /* 设置触摸屏模式为自动X/Y位置转换模式 */
                iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
9 p! }5 q* e3 E/ W
+ D- k7 F1 S0 a) u                /* 启动ADC转换,转换完成后进入stylus_action(ADC中断处理函数) */
                iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
7 b/ `0 p' j: `5 o* W. a4 u9 ?0 W         }
        else
9 a. o9 v% ^& _         {
                /* 如果是抬起状态 */
                count = 0;
- l$ h8 k$ j7 _3 G# A& q
                /* 报告按键事件，键值为0表示触摸点被释放 */
2 r0 A# ~1 Y7 h& Z% Z/ K3 \                 input_report_key(dev, BTN_TOUCH, 0);

9 u: _$ R6 V" i: N# B' a8 w                /* 报告触摸屏绝对位移事件，键值为0表示触摸屏没有被按下 */
                input_report_abs(dev, ABS_PRESSURE, 0);

                /* 报告完后，上报同步事件 */
% v2 I+ c5 ~$ U9 G, ^$ l                 input_sync(dev);
2 k/ Z8 _; J3 g+ G5 u* z5 h2 D! |5 b
3 f6 e6 M* F( G: F% x4 k                /* 将触摸屏重设置为等待按下中断模式 */
+ q3 b% H8 b. h+ ~% R$ P9 _                 iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
: w0 d# N2 X% [- L8 S, J6 g
' u( @) L1 t/ j& S4 ?" [0 J                /* 如果触摸屏抬起，意味着这一次的操作结束，所以应该释放ADC资源的占用 */
                if (OwnADC)
                {
                        OwnADC = 0;
                        up(&ADC_LOCK);
                }
        }
}
0 }4 r" I$ H" D' Itouch_timer_fire函数首先读出触摸屏状态，如果是按下状态，并且ADC已经转换，就报告事件和数据；如果是按下状态，但ADC还没开始转换，就启动ADC转换；如果是抬起状态，报告事件后，将触摸屏重设置为等待按下中断模式；如果触摸屏抬起，意味着这一次的操作结束，所以应该释放ADC资源的占用。
当ADC转换完成后触发ADC中断，就会进入ADC中断处理函数stylus_action
1 H/ w0 p6 \: L' ^% e1 r6 T' O/ T, b; C
2 G* v* B2 y2 v9 t# T
/* ADC中断处理程序，AD转换完成后触发执行 */
static irqreturn_t stylus_action(int irq, void *dev_id)
8 G  E& E9 }+ w8 O4 M* B! `{
        unsigned long data0;
7 w& h. _1 z9 P/ S* Q6 B  f9 L        unsigned long data1;
' F5 h8 }/ u$ Y3 v% F0 ?" [+ @
1 z# }6 d" E# `* A4 O        /* 标识触摸屏资源可用 */
        if (OwnADC)
        {
                /* 读取AD转换后的值，注意这次重点读X/Y坐标数据 */
( V, p0 }( b, [7 U( t1 f. [                data0 = ioread32(base_addr+S3C2410_ADCDAT0);
- x# [! F' T2 ^                data1 = ioread32(base_addr+S3C2410_ADCDAT1);
8 x" y: V7 s4 y: o* i4 g
                /* 取出bit[9:0]，即X/Y坐标数据 */
! I4 }  z2 f5 Q+ u. E; Y                xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
* w$ h& y# ^  @+ N8 u1 _9 v* z9 A                yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
# Y; @# M$ |% M  y
) n4 H/ @2 Y# |9 L1 ?3 g, v) [" s$ z                /* 记录这一次AD转换次数 */
                count++;

                if (count < (1<<2))
- t' x1 J/ f4 E. O% O  }, h                {
% [' t8 I% V. y+ \8 g% x  @                        /* 如果转换次数小于4，则重启动ADC转换 */
                        iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
2 A- r) M6 T5 x8 H& N/ s; q                        iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
                }
                else
                {
' D8 }7 u' n4 ^' u/ G                        /* 否则，启动1个时间滴答的定时器，这就会去执行
                         * touch_timer_fire定时器超时函数的上报事件和数据
                         */
                        mod_timer(&touch_timer, jiffies+1);

1 g3 |( j8 ?3 ]" D1 m9 L' m4 e: Y                        /* 停止ADC转换,防止屏幕抖动 */
                        iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC);
1 V6 h& Q, y+ g% F! }3 m, r                }
+ q/ R5 v4 R1 U' I0 D        }
        return IRQ_HANDLED;
}
8 D( q$ l* e( i( Q! d在stylus_action函数里，首先读取ADC转换后的数据，判断是否连续转换够4次，如果没有则重新启动ADC转换；否则，启动1个时间滴答的定时器，这就会去执行touch_timer_fire定时器超时函数的上报事件和数据。
在本驱动的定时器的定义和初始化与以往不一样，这里使用了简易的方法
7 B/ n3 t8 V* X* w' y$ @4 S( {
' D: i3 e1 E" L/ m
; x% w2 Z- s0 J  c* ]% L4 i/* 定义并初始化了一个touch_timer定时器，超时处理函数为touch_timer_fire */
, O* M. {( ?3 k& v* y& `7 ystatic struct timer_list touch_timer =
! f0 e6 z, u; P$ B& I                TIMER_INITIALIZER(touch_timer_fire, 0, 0);
在这里总结一下触摸的工作流程：
( T- ]! e4 Z' N(1)如果触摸屏感觉到触摸，则触发触摸屏中断即进入stylus_updown，获取ADC_LOCK后判断触摸屏状态为按下，
9 p0 l8 R* |+ d# V$ s' n* J* w
则调用touch_timer_fire启动ADC转换；
* ^5 Q* A& G" O0 O8 c% Y(2)当ADC转换启动后，触发ADC中断即进入stylus_action，如果这一次转换的次数小于4，则重新启动ADC进行转换，
7 T$ i2 C' a; y1 {* A
如果4次完毕后，启动1个时间滴答的定时器，停止ADC转换，也就是说在这个时间滴答内，ADC转换是停止的；

! F- o' _4 G5 y. [(3)这里为什么要在1个时间滴答到来之前停止ADC的转换呢？这是为了防止屏幕抖动。
. Z# V. L' @& i) o4 i$ N(4)如果1个时间滴答到来则进入定时器服务程序touch_timer_fire，判断触摸屏仍然处于按下状态则上报事件和
' `* T9 x3 T! O; }3 `
转换的数据，并重启ADC转换，重复第(2)步；
0 h! z2 b3 V# T/ t/ @(5)如果触摸抬起了，则上报释放事件，并将触摸屏重新设置为等待中断状态。
7 R- r5 A  H2 C4 s) b1 u/ {" T4 i9 }7 \* ~触摸屏驱动参考源码

1 s, p7 `$ k& K' F( L0 q6 i
& J$ F6 f6 n6 U# I9 t& b  W#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
- ?% w1 m0 v" e: ~1 W2 C#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
9 @0 K1 ^5 I! v7 p, |; V/ c0 |#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
% a3 \# h3 T, y#include <linux/clk.h>
#include <asm/io.h>
' M. L$ M9 a8 D, O#include <asm/irq.h>
6 J" N6 L9 b- ~7 M  o* B4 ~
#include <plat/regs-adc.h>
#include <mach/regs-gpio.h>

/* For ts.dev.id.version */
& }& U) ], k) S  n9 s* l7 ^#define S3C2410TSVERSION        0x0101
3 T$ S0 t8 {1 u/ a2 F' N7 n$ L- H; l; K
6 T. U3 X& C7 h/* x = 0:等待按下中断模式，即ADCTSC = 0xd3
5 t0 G, Q& t2 w: u) ` * x = 1:等待松开中断模式, 即ADCTSC = 0x1d3
*/
#define WAIT4INT(x)  (((x)<<8) | \
/ Z4 B: K7 x6 S5 n                     S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
                     S3C2410_ADCTSC_XY_PST(3))

; U- o9 A0 H& w. a% t/* 自动X/Y位置转换模式 */
+ D# h, g! p2 ^/ q#define AUTOPST             (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
                     S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))

& S8 e* d% A1 ?: b( f+ b* estatic char *tq2440ts_name = "TQ2440 TouchScreen";
. K& }& ~9 v% s/ T. y. ~
static        struct input_dev *dev;
( M/ W& w6 ?7 I4 \  Fstatic        long xp;
: q9 p/ E7 P3 `static        long yp;
static        int count;
4 J2 |2 O) e, ~1 F7 Q5 R; p
/* 外部信号量ADC_LOCK,在ADC驱动中有定义 */
- b7 I2 \6 l: B5 y* Oextern struct semaphore ADC_LOCK;
1 Z5 j$ L$ L6 A- b1 ]  h$ r8 G& b. K* h% M/ |static int OwnADC = 0;

static void __iomem *base_addr;
/*
# N, x: {, X4 v( n7 H0 Cstatic inline void tq2440_ts_connect(void)
! p- e) I) f! `& v{
# h" \8 o1 \( z" }1 K- d        s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPG12_XMON);
        s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPG13_nXPON);
8 b- D5 a5 O0 M% Y        s3c2410_gpio_cfgpin(S3C2410_GPG14, S3C2410_GPG14_YMON);
" m3 T8 t+ m) m: R0 {  i        s3c2410_gpio_cfgpin(S3C2410_GPG15, S3C2410_GPG15_nYPON);
}
*/
static void touch_timer_fire(unsigned long data)
: i4 c) I- g( l$ z{
          unsigned long data0;
          unsigned long data1;
9 d8 G8 J1 a. t. A& F6 `/ [        int updown;

        /* 读取AD转换后的值，注意这次重点是读出状态 */
          data0 = ioread32(base_addr+S3C2410_ADCDAT0);
          data1 = ioread32(base_addr+S3C2410_ADCDAT1);
: B8 ?9 Y# F6 p7 T         updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

3 a4 G% D1 y, K, x3 x# {         if (updown) {
                /* 如果是按下状态，并且ADC已经转换，就报告事件和数据 */
# X5 h- D# N4 h                 if (count != 0)
2 H  I% ~5 t# H% a$ R                 {
                        long tmp;
# e3 C5 h0 g4 u                        tmp = xp;
; p. W8 r$ c: Y/ k9 h. y9 {5 E8 ~                        xp = yp;
                        yp = tmp;

                        /* stylus_action函数是4次采样，所以要除以4 */                                                                                                                                                                         
5 h3 ^' h) b5 `: x  |            xp >>= 2;
* U8 Q$ ?5 |/ L6 r                        yp >>= 2;

& L% p. z4 u5 R, d6 G0 _) G                        /* 上报X/Y坐标数据 */
                        input_report_abs(dev, ABS_X, xp);
$ S" b( d. e7 q" l+ I' u                         input_report_abs(dev, ABS_Y, yp);
/ }) y% K5 P7 `: M6 R7 @6 w( z0 y
. K8 r. H% q$ g& t2 m9 M                        /* 报告按键事件，键值为1表示触摸点被按下 */
6 F2 |0 u2 o' o                         input_report_key(dev, BTN_TOUCH, 1);

                        /* 报告触摸屏状态，键值为1表示触摸屏被按下 */
                        input_report_abs(dev, ABS_PRESSURE, 1);
$ n( }+ a4 f+ E# a( ~* |
                        /* 报告完后，上报同步事件 */
+ s' }* Z$ U. n& V8 X7 P                         input_sync(dev);
4 e, s3 n* S% A                 }
6 Q: `9 ]/ N$ _8 `4 s, u               
                /* 如果是按下状态，但ADC还没开始转换，就启动ADC转换 */
                xp = 0;
                yp = 0;
                count = 0;
, _& e5 u! p- l- y; ]
                /* 设置触摸屏模式为自动X/Y位置转换模式 */
$ e8 Z2 v2 n+ {% |/ I                 iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
9 ]/ H0 C  H3 h  n7 n3 T. K( P
                /* 启动ADC转换,转换完成后进入stylus_action(ADC中断处理函数) */
6 K. z6 z+ z* Y; O9 I6 h                iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
        }
        else
) E- P3 a0 D8 _0 p2 g         {
                /* 如果是抬起状态 */
                count = 0;

                /* 报告按键事件，键值为0表示触摸点被释放 */
0 N! W, g: J/ K2 G5 M, d                 input_report_key(dev, BTN_TOUCH, 0);

! C; G; @& D! E. t" S- ^                /* 报告触摸屏绝对位移事件，键值为0表示触摸屏没有被按下 */
                input_report_abs(dev, ABS_PRESSURE, 0);

- Z6 b$ V, `' w) K8 L' }/ |8 I* v                /* 报告完后，上报同步事件 */
                input_sync(dev);
3 _% \  W, L1 U  S) F# V4 x
                /* 将触摸屏重设置为等待按下中断模式 */
                iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
* C9 o9 n6 [" I4 z' a
                /* 如果触摸屏抬起，意味着这一次的操作结束，所以应该释放ADC资源的占用 */
                if (OwnADC)
3 a* g9 F! f% L$ f                {
                        OwnADC = 0;
                        up(&ADC_LOCK);
                }
        }
}

3 j2 ]1 C5 q3 E- X
/* 定义并初始化了一个touch_timer定时器，超时处理函数为touch_timer_fire */
0 k3 X: D3 F  K7 |+ m7 [. c+ ?static struct timer_list touch_timer =
                TIMER_INITIALIZER(touch_timer_fire, 0, 0);
* w7 S3 ]+ X5 h3 }, F- @

/* 触摸屏中断服务程序，当触摸屏按下或抬起时触发执行 */
static irqreturn_t stylus_updown(int irq, void *dev_id)
{
        unsigned long data0;
        unsigned long data1;
        /* 用于判断触摸屏是按下还是抬起 */
( B  s/ m. R4 Q; Q& k' z        int updown;
2 O: q/ C( [; a' W8 A$ Q
        /* ADC资源可以获取，即上锁 */
. e: g/ i, \" J        if (down_trylock(&ADC_LOCK) == 0)
        {
                /* 标识触摸屏资源可用 */
                OwnADC = 1;

                /* 读取AD转换后的值，注意这次重点是读出状态 */
                data0 = ioread32(base_addr+S3C2410_ADCDAT0);
                data1 = ioread32(base_addr+S3C2410_ADCDAT1);
  |( q$ p- R9 g! i; `                updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));
* p2 s* ~" G# L" X( b! E
! w7 s3 S% t7 ?7 [1 d/ v6 S& B                if (updown)
4 d; m' V: P8 S: k' j                {
                        /*        ADCDAT0[15] = 0,则updown = 1，此时表示按下状态
( M; e$ R( w- _( k                         *  那么调用touch_timer_fire函数启动ADC转换
                         */
                        touch_timer_fire(0);
- J) W  ~6 C1 O4 R                }
                else
                {
4 F8 U1 L6 \' |. }/ o2 |! P9 R0 F                        /* 如果是抬起状态,就结束这次的操作，并释放ADC资源的占用，即解锁 */
! k0 D& O; m) F$ U/ ~& a                        OwnADC = 0;
                        up(&ADC_LOCK);
                }
8 f0 c) q1 s  ~. F- L6 Y/ ^        }
6 e1 W7 `/ R  _9 c" B* `& e7 O        return IRQ_HANDLED;
0 y0 }9 L( j* j2 \}


/* ADC中断处理程序，AD转换完成后触发执行 */
static irqreturn_t stylus_action(int irq, void *dev_id)
{
        unsigned long data0;
        unsigned long data1;

        /* 标识触摸屏资源可用 */
; r/ e; z9 h( K        if (OwnADC)
6 l* g  g( L% F8 Y5 ~: T        {
; `" X" ]* l/ ], f4 y! d                /* 读取AD转换后的值，注意这次重点读X/Y坐标数据 */
* ~4 [6 a* `. G                data0 = ioread32(base_addr+S3C2410_ADCDAT0);
5 E& Q8 x) X6 n, H5 }/ j, F                data1 = ioread32(base_addr+S3C2410_ADCDAT1);
) \; R) I* l9 H) b
                /* 取出bit[9:0]，即X/Y坐标数据 */
                xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
, g: E$ Q: R0 u" C" [0 C' \                yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;

$ \. _( p) Z8 A& `$ ?                /* 记录这一次AD转换次数 */
                count++;

8 q  l: d5 C& D                if (count < (1<<2))
2 Q# n% d( X% k5 R* p9 W8 D4 X                {
                        /* 如果转换次数小于4，则重启动ADC转换 */
8 V/ o7 s! F3 S3 g4 i5 x                        iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
+ i8 a2 B9 \( u* I                        iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
, L; L, g" Q) B3 [8 n                }
4 S: N" b0 r1 s8 A  U3 r& j. g                else
                {
6 \6 H% O: j  U+ t                        /* 否则，启动1个时间滴答的定时器，这就会去执行
                         * touch_timer_fire定时器超时函数的上报事件和数据
- N/ v4 U8 }5 p3 U7 G                         */
                        mod_timer(&touch_timer, jiffies+1);
" [) u. n0 E) D9 Y
                        /* 停止ADC转换,防止屏幕抖动 */
$ Y1 }1 X" a1 B" z; G                        iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC);
                }
" e: l4 y' P2 Z* e$ j8 g        }
        return IRQ_HANDLED;
8 I: V# {! v8 N' F' B! R6 D( P; @}

' e3 C: C5 [- M0 m% Mstatic struct clk        *adc_clock;

/ V; n% D- X( Q) H9 I! mstatic int __init tq2440ts_init(void)
{
        struct input_dev *input_dev;
% G  c9 s5 Q# ]# W) z; R" X
0 s+ p+ b% B4 f        /* 获取ADC时钟，使能时钟(CLKCON[15])
         * ADC(&Touch Screen) [15], Control PCLK into ADC block.
         */
% k, n9 b" A: Y( Q3 z7 w        adc_clock = clk_get(NULL, "adc");
        if (!adc_clock)
* [! a2 |, ~% W1 S        {
4 t  I& H; E5 K' A1 M                printk(KERN_ERR "failed to get adc clock source\n");
- G! p( K' t/ Z: B  R                return -ENOENT;
        }
2 s$ ~! N( z$ O' s) }$ R6 t/ H        clk_enable(adc_clock);

        /* ADCCON寄存器地址:0x58000000 */
. N: o0 b* ~% t6 f7 G" A3 b) O! K9 Q        base_addr=ioremap(S3C2410_PA_ADC,0x20);       
        if (base_addr == NULL)
* x" ?9 o- M$ x+ x: W+ d) s, Z( @        {
                printk(KERN_ERR "Failed to remap register block\n");
+ A2 x! n" u% J* a8 J  V' F                return -ENOMEM;
; B; p5 [' C. t* I& p' v4 ~! F        }
7 e  f+ W+ H! m& O/ w5 l3 [& g
/ h* s+ n: Y* Z* ]6 z( v7 Y        /* Configure GPIOs */
//        tq2440_ts_connect();

        /* 使能预分频，预分频系数PRSCVL为0xff */
' E* L5 w$ J/ G- v        iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF),base_addr+S3C2410_ADCCON);
" I9 g0 H3 N9 @       
# f1 z; B1 a9 E        /* ADCDLY = 0xffff */
  I; v% P  f3 {        iowrite32(0xffff,  base_addr+S3C2410_ADCDLY);
% `% @0 Y3 m; C       
        /* 进入等待按下中断模式 */
        iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
+ x; F4 E, t6 X8 u# ^( s
        /* 分配一个input_dev结构体 */
2 G1 A- p' H* \6 @/ O        input_dev = input_allocate_device();       

# i5 f  n! u; ?  I& i        if (!input_dev)
% P7 \6 {. Z& @) u        {
& s; H% K8 w5 I                printk(KERN_ERR "Unable to allocate the input device !!\n");
                return -ENOMEM;
1 G8 E, L/ c8 |* H. `: O        }

        /* 初始化输入设备,即input_dev成员 */
        dev = input_dev;

$ k- [3 I' V! h/ K. i; P; t" i        /* 支持同步事件、按键事件、绝对位移事件 */
1 V3 q. D6 o0 [! m        dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);

        /* 支持按键类中的触摸屏点击 */
  i! h1 P7 R6 o  x+ p        dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);
2 Q3 u8 h9 l. Y5 \
8 Q' |0 p" [, Q$ }3 _2 k        /* 设置触摸屏的X坐标、Y坐标、压力 */
2 d! n+ s& J# e+ r        input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0);  /* Resolution: 10-bit,0x3ff即10位 */
& N' T$ ?! N! n! C( {; m5 H( a- v8 r: N        input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0);
        input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0);

        /* 下面这些信息在驱动挂载后在/proc/bus/input/devices中看到 */
0 B. {; }7 j- J        dev->name = tq2440ts_name;
        dev->id.bustype = BUS_RS232;
' X+ O' w2 |) ^7 u" Z, M        dev->id.vendor = 0xDEAD;
% I. x' H9 Q8 @3 y8 k        dev->id.product = 0xBEEF;
7 n, ~; \3 M- w) A        dev->id.version = S3C2410TSVERSION;
& r/ I1 \, i7 {# h* I
1 d$ D9 F9 V; }/ G9 Y0 l- i
        /* 分别申请ADC、TC中断，在ADC中断里使用了IRQF_SHARED
         * 共享中断标志，因为在ADC驱动里也使用了ADC中断
         */
8 T  n! Z4 K& `$ ]/ N        if (request_irq(IRQ_ADC, stylus_action, IRQF_SHARED|IRQF_SAMPLE_RANDOM, tq2440ts_name, dev))
/ `" T3 y8 v+ n& J        {
8 W; v" l5 N! r+ k) E$ W( |                printk(KERN_ERR "tq2440_ts.c: Could not allocate ts IRQ_ADC !\n");
                iounmap(base_addr);
! }$ z) g5 E+ @                return -EIO;
        }
        if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM, tq2440ts_name, dev))
        {
+ _: {% j5 }6 w) p; W+ i/ ^                printk(KERN_ERR "tq2440_ts.c: Could not allocate ts IRQ_ADC !\n");
                iounmap(base_addr);
4 ^' a) k! m. Y# G6 i. E4 z$ z1 |                return -EIO;
& M& J$ J, A  X6 M% B% f4 q        }

        printk(KERN_INFO "%s successfully loaded\n", tq2440ts_name);

% u- N) Y+ P7 O+ u5 d3 D        /* 将触摸屏输入设备注册到输入子系统 */
& s( @' s; v0 j8 B' E        input_register_device(dev);
) F. ?7 B9 h9 G5 N- n  ?
        return 0;
}

9 o9 w9 r* m: t$ Jstatic void __exit tq2440ts_exit(void)
$ @' l, G3 B; J{
        disable_irq(IRQ_ADC);
        disable_irq(IRQ_TC);
        free_irq(IRQ_TC,dev);
, S: U3 B2 S* ?/ O# m0 ]2 }1 z0 b3 G        free_irq(IRQ_ADC,dev);
7 M2 w; C  d( U/ W# U
        if (adc_clock)
0 X% |! S8 w- Z6 e% M' z6 |        {
                clk_disable(adc_clock);
7 J+ ?% A- J! |8 b$ D# z( O/ {* {                clk_put(adc_clock);
                adc_clock = NULL;
        }

, j' h2 @$ G" k( L8 W% u! h9 {! C( q; A        input_unregister_device(dev);
        iounmap(base_addr);
}


module_init(tq2440ts_init);
module_exit(tq2440ts_exit);
0 C8 S! F; T( _. u! e+ t测试，使用tslib库来测试，关于如何测试请参考韦东山视频的“第16课第3节 触摸屏驱动程序之使用TSLIB测试_P”，在这里再说显得有点多余。

2014-01-20补充

[WJ2440]# cat proc/bus/input/devices
I: Bus=0013 Vendor=dead Product=beef Version=0101
N: Name="TQ2440 TouchScreen"
; A$ ?0 [% N/ r1 n/ bP: Phys=
9 P2 O  r* E0 _( ]1 H9 AS: Sysfs=/devices/virtual/input/input0
U: Uniq=
6 \; P* W! z: x* ^4 a$ V4 Z  fH: Handlers=event0
" n8 N- R) I0 I, OB: EV=b
( W& Q/ s0 K- G# l7 ]B: KEY=0
, A( y( O' S+ ?& _) OB: ABS=1000003
与源码里的信息是一致的
        dev->name = tq2440ts_name;
        dev->id.bustype = BUS_RS232;
        dev->id.vendor = 0xDEAD;
! A2 l+ p) y' }: ^) n        dev->id.product = 0xBEEF;
        dev->id.version = S3C2410TSVERSION;
; o6 |1 v9 D# O# S, X5 Q( k


; N2 m; D+ f' n; |" N9 C

---

作者: yin123    时间: 2020-4-20 13:25
linux 输入子系统之电阻式触摸屏驱动

---

欢迎光临 EDA365电子论坛网 (https://bbs.eda365.com/)

Powered by Discuz! X3.2