2018-04-10 19:19:56 feixiaoxing 阅读数 2372

【 声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com


    早在诺基亚手机还比较流行的时候,那时候触摸屏用的还不多。但是随着触摸屏手机、即智能手机的流行,触摸屏基本成了手机的标配。所以,今天可以看看触摸屏驱动在linux上是如何进行的。


1、驱动目录

drivers/input


2、看看这个目录的Makefile如何设计

obj-$(CONFIG_INPUT)		+= input-core.o
input-core-y := input.o input-compat.o input-mt.o ff-core.o

obj-$(CONFIG_INPUT_TOUCHSCREEN)	+= touchscreen/


3、除了input-core.o这个文件外,只需要看touchscreen目录就可以了

config TOUCHSCREEN_S3C2410
	tristate "Samsung S3C2410/generic touchscreen input driver"
	depends on ARCH_S3C24XX || SAMSUNG_DEV_TS
	depends on S3C_ADC
	help
	  Say Y here if you have the s3c2410 touchscreen.

	  If unsure, say N.

	  To compile this driver as a module, choose M here: the
	  module will be called s3c2410_ts.


4、看懂了Kconfig之后,再阅读Makefile,注意S3C_ADC宏可以参考arch/arm/plat-samsung/adc.c

obj-$(CONFIG_TOUCHSCREEN_S3C2410)	+= s3c2410_ts.o

5、继续阅读s3c2410_ts.c文件

static const struct platform_device_id s3cts_driver_ids[] = {
	{ "s3c2410-ts", 0 },
	{ "s3c2440-ts", 0 },
	{ "s3c64xx-ts", FEAT_PEN_IRQ },
	{ }
};
MODULE_DEVICE_TABLE(platform, s3cts_driver_ids);

static struct platform_driver s3c_ts_driver = {
	.driver         = {
		.name   = "samsung-ts",
#ifdef CONFIG_PM
		.pm	= &s3c_ts_pmops,
#endif
	},
	.id_table	= s3cts_driver_ids,
	.probe		= s3c2410ts_probe,
	.remove		= s3c2410ts_remove,
};
module_platform_driver(s3c_ts_driver);


6、根据probe函数,看看有什么需要注意的内容

	ts.client = s3c_adc_register(pdev, s3c24xx_ts_select,
				     s3c24xx_ts_conversion, 1);
	if (IS_ERR(ts.client)) {
		dev_err(dev, "failed to register adc client\n");
		ret = PTR_ERR(ts.client);
		goto err_iomap;
	}


7、接着,查看是否有中断函数被注册

	ret = request_irq(ts.irq_tc, stylus_irq, 0,
			  "s3c2410_ts_pen", ts.input);

8、最后

    很明显,触摸屏驱动本质上还是由TOUCHSCREEN_S3C2410和S3C_ADC两个macro一起完成的。


2014-01-06 16:19:25 tianshiyalin 阅读数 0

硬件平台:FL2440

内核版本:2.6.28

主机平台:Ubuntu 11.04

内核版本:2.6.39

原创作品,转载请标明出处http://blog.csdn.net/yming0221/article/details/6580981

1、下面是ADC和触摸屏接口的模块图

当触摸屏接口使用时,XM或YM接触摸屏接口的地

当触摸屏接口不使用时,XM或YM接模拟信号,做普通ADC使用。

2、触摸屏接口的几种操作模式

(1) 正常转换模式

通过设置ADCCON(adc控制寄存器)来完成初始化,并对ADCDAT0数据寄存器进行操作。

(2) 分离XY坐标模式

X坐标模式写X坐标转换数据到ADCDAT0,触摸屏接口产生中断到中断控制寄存器。Y坐标模式写Y坐标转换数据到ADCDAT1,触摸屏接口产生中断到中断控制寄存器。两种模

式可以选择一种模式工作。

相应的引脚连接:

(3) 自动XY坐标模式

触摸屏控制器连续的转换X和Y的坐标,在X坐标转换后的值存入ADCDAT0后,自动将Y坐标转换后的值存入ADCDAT1,触摸屏接口产生中断到中断控制器。

相应的引脚连接:

(4) 等待中断模式

当光标被按下,触摸屏控制器产生中断IRQ_TC,当产生中断信号时,等待中断模式必须被清除。

引脚定义如下:

3、下面是s3c2440触摸屏驱动的分析

  1. //#define CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  2.   
  3. #include <linux/errno.h>  
  4. #include <linux/kernel.h>  
  5. #include <linux/module.h>  
  6. #include <linux/slab.h>  
  7. #include <linux/input.h>  
  8. #include <linux/init.h>  
  9. #include <linux/serio.h>  
  10. #include <linux/delay.h>  
  11. #include <linux/platform_device.h>  
  12. #include <linux/clk.h>  
  13. #include <asm/io.h>  
  14. #include <asm/irq.h>  
  15.   
  16. #include <mach/regs-gpio.h>  
  17. #include <mach/s3c2410_ts.h>  
  18.   
  19. #include <plat/regs-adc.h>  
  20.   
  21. #define TRUE 1    //CoAsia added  
  22. #define FALSE 0    //CoAsia added  
  23. #define FILTER_LIMIT 25    //CoAsia added  
  24.   
  25. /* For ts.dev.id.version */  
  26. #define S3C2410TSVERSION    0x0101  
  27.   
  28. #define TSC_SLEEP  (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))  
  29.   
  30. #define WAIT4INT(x)  (((x)<<8) | \  
  31.              S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \  
  32.              S3C2410_ADCTSC_XY_PST(3))  
  33.   
  34. #define AUTOPST      (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \  
  35.              S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))  
  36.   
  37. #define DEBUG_LVL   "<3>" //KERN_DEBUG  
  38.   
  39. static char *s3c2440ts_name = "s3c2440 TouchScreen";  
  40.   
  41. /* 
  42.  * Per-touchscreen data. 
  43.  */  
  44. //定义s3c2440触摸屏使用的数据结构体  
  45. struct s3c2440ts {  
  46.     struct input_dev *dev;  
  47.     long xp;  
  48.     long yp;  
  49.     int count;  
  50.     int shift;  
  51. };  
  52.   
  53. static struct s3c2440ts ts;  
  54. static struct clk   *adc_clock;  
  55.   
  56. //__iomem声明地址空间是设备地址映射空间  
  57. static void __iomem *base_addr;  
  58.   
  59. //函数声明  
  60. static void touch_timer_fire(unsigned long data);  
  61. static irqreturn_t tc_irq(int irq, void *dev_id);  
  62. static irqreturn_t adc_irq(int irq, void *dev_id);  
  63. static int __init s3c2440ts_probe(struct platform_device *pdev);  
  64. static int s3c2440ts_remove(struct platform_device *pdev);  
  65. static int s3c2440ts_resume(struct platform_device *pdev);  
  66.   
  67. //定义定时器  
  68. static struct timer_list touch_timer =  
  69.         TIMER_INITIALIZER(touch_timer_fire, 0, 0);  
  70.   
  71.   
  72. //IRQ_TC中断处理函数  
  73. static irqreturn_t tc_irq(int irq, void *dev_id)  
  74. {  
  75.     //data0,data1用于存放读取的ADCDAT数据寄存器的值  
  76.     unsigned long data0;  
  77.     unsigned long data1;  
  78.     int updown;//用于存放光标的按下或提起的状态  
  79.       
  80.     //读取ADCDAT0、ADCDAT1数据寄存器的值  
  81.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  82.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  83.       
  84.     //查看数据寄存器的第15位的值  
  85.     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));  
  86.   
  87.     /* TODO we should never get an interrupt with updown set while 
  88.      * the timer is running, but maybe we ought to verify that the 
  89.      * timer isn't running anyways. */  
  90.        
  91.     //如果data0和data1的第15位都是0,则updown为1,则通过函数touch_timer_fire()函数来启动ADC转换  
  92.     if (updown)  
  93.         touch_timer_fire(0);  
  94.   
  95.     return IRQ_HANDLED;  
  96. }  
  97.   
  98. static void touch_timer_fire(unsigned long data)  
  99. {  
  100.     //用于存储数据寄存器ADCDAT0、ADCDAT1的值  
  101.     unsigned long data0;  
  102.     unsigned long data1;  
  103.       
  104.     //用于存放光标是否被按下  
  105.     int updown;  
  106.   
  107.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  108.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  109.   
  110.     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));  
  111. //printk("The number of 'updown' is %d\n ",updown);  
  112.     //如果光标被按下,执行  
  113.     if (updown)   
  114.     {  
  115.         //ts.count!=0表示ADC已经转换过,下面就报告事件和光标位置数据  
  116.         if (ts.count != 0)   
  117.         {  
  118.             ts.xp >>= ts.shift;//这里shift为2,这里实际上是求均值,四次的和/4,这样定位更加准确  
  119.             ts.yp >>= ts.shift;  
  120.   
  121. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  122.             {  
  123.                 struct timeval tv;  
  124.                 do_gettimeofday(&tv);  
  125.                 printk(DEBUG_LVL "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts.xp, ts.yp);  
  126.             }  
  127. #endif  
  128. /* 
  129. 下面的函数位于/include/linux/input.h,作用是报告事件 
  130. static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value) 
  131. { 
  132.     input_event(dev, EV_ABS, code, value); 
  133. } 
  134. */  
  135.             //报告X,Y的绝对坐标  
  136.             input_report_abs(ts.dev, ABS_X, ts.xp);  
  137.             input_report_abs(ts.dev, ABS_Y, ts.yp);  
  138.               
  139.             //报告事件,1代表光标被按下  
  140.             input_report_key(ts.dev, BTN_TOUCH, 1);  
  141.             //报告触摸屏状态,1代表触摸屏被按下  
  142.             input_report_abs(ts.dev, ABS_PRESSURE, 1);  
  143.             //等待接收方的确认,用于事件的同步  
  144.             input_sync(ts.dev);  
  145.         }  
  146.         //现在光标被按下,并且ADC转换没有启动  
  147.         ts.xp = 0;  
  148.         ts.yp = 0;  
  149.         ts.count = 0;  
  150.           
  151.         //设置触摸屏控制寄存器的值为 0xdc B:1101 1100,设置控制寄存器上拉无效,自动转换X,Y坐标  
  152.         //printk("S3C2410_ADCTSC: 0x%x\n",S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST);  
  153.         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);  
  154.         //启动ADC转换  
  155.         writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);  
  156.     }   
  157.     else//光标没有被按下  
  158.     {  
  159.         ts.count = 0;  
  160.         //报告事件及光标的位置状态  
  161.         input_report_key(ts.dev, BTN_TOUCH, 0);  
  162.         input_report_abs(ts.dev, ABS_PRESSURE, 0);  
  163.         //等待接收方的应答,用于同步  
  164.         input_sync(ts.dev);  
  165.         //设置触摸屏控制寄存器为等待中断模式  
  166.         writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  167.     }  
  168. }  
  169.   
  170.   
  171. static irqreturn_t adc_irq(int irq, void *dev_id)  
  172. {  
  173.     //用于存放数据寄存器的数据  
  174.     unsigned long data0;  
  175.     unsigned long data1;  
  176.     //读取数据,这次主要读取的是位置数据  
  177.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  178.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  179.       
  180.     ts.xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;//累加四次准换结果的X坐标和  
  181.     ts.yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;//累加四次准换结果的Y坐标和  
  182.   
  183.     ts.count++;//转换次数加一  
  184.       
  185.     //如果转换次数小于4  
  186.     if (ts.count < (1<<ts.shift))   
  187.     {  
  188.         //再次设置触摸屏控制寄存器上拉不使能、自动X、Y转换模式  
  189.         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);  
  190.         //再次启动ADC转换  
  191.         writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);  
  192.     }  
  193.     else//这时,ADC转换四次完成,延迟一个系统滴答,执行touch_timer_fire()函数  
  194.     {  
  195.         mod_timer(&touch_timer, jiffies+1);   
  196.         writel(WAIT4INT(1), base_addr+S3C2410_ADCTSC);  
  197.     }  
  198.   
  199.     return IRQ_HANDLED;  
  200. }  
  201.   
  202.   
  203.   
  204. /* 
  205.  * The functions for inserting/removing us as a module. 
  206.  */  
  207. /* 
  208. 该结构体定义在/include/linux/platform_device.h 
  209. struct platform_device { 
  210.     const char  * name; 
  211.     int     id; 
  212.     struct device   dev; 
  213.     u32     num_resources; 
  214.     struct resource * resource; 
  215. }; 
  216. */  
  217. static int __init s3c2440ts_probe(struct platform_device *pdev)  
  218. {  
  219.     int rc;  
  220.     /* 
  221.     下面结构体定义在/include/mach/s3c2410_ts.h 
  222.     struct s3c2410_ts_mach_info { 
  223.        int             delay; 
  224.        int             presc; 
  225.        int             oversampling_shift; 
  226.     }; 
  227.     */  
  228.     struct s3c2410_ts_mach_info *info;  
  229.     struct input_dev *input_dev;  
  230.     /* 
  231.         void        *platform_data;//Platform specific data, device core doesn't touch it  
  232.     */  
  233.     info = ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data;  
  234.   
  235.     if (!info)  
  236.     {  
  237.         printk(KERN_ERR "Hm... too bad : no platform data for ts\n");  
  238.         return -EINVAL;  
  239.     }  
  240.   
  241. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  242.     printk(DEBUG_LVL "Entering s3c2440ts_init\n");  
  243. #endif  
  244.     //由于ADC转换需要时钟,这里获取时钟  
  245.     adc_clock = clk_get(NULL, "adc");  
  246.     if (!adc_clock) {  
  247.         printk(KERN_ERR "failed to get adc clock source\n");  
  248.         return -ENOENT;  
  249.     }  
  250.     clk_enable(adc_clock);//使能时钟  
  251.   
  252. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  253.     printk(DEBUG_LVL "got and enabled clock\n");  
  254. #endif  
  255.     //通过ioremap实现物理地址到虚拟地址的转换  
  256.     base_addr = ioremap(S3C2410_PA_ADC,0x20);  
  257.     if (base_addr == NULL) {  
  258.         printk(KERN_ERR "Failed to remap register block\n");  
  259.         return -ENOMEM;  
  260.     }  
  261.       
  262.     //设置ADCCON控制寄存器为0x4c40,设置预分频有效,预分频值为B:110001 D:49  
  263.     //printk("ADCCON is 0x%x\n",S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF));  
  264.     if ((info->presc&0xff) > 0)  
  265.         writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\  
  266.                  base_addr+S3C2410_ADCCON);  
  267.     else  
  268.         writel(0,base_addr+S3C2410_ADCCON);  
  269.   
  270.   
  271.     /* Initialise registers */  
  272.     /* 
  273.         设置ADC开始延时寄存器ADCDLY: 0x4e20 
  274.     */  
  275.     //printk("ADCDLY: 0x%x\n",info->delay & 0xffff);  
  276.     if ((info->delay&0xffff) > 0)  
  277.         writel(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  
  278.     /* 
  279.         设置ADC触摸屏控制寄存器ADC_TSC: 0xd3 B:1101 0011 
  280.         [8]检测光标按下中断信号 
  281.         [7]YM输出驱动有效(GND) 
  282.         [6]YP输出驱动无效(AIN5) 
  283.         [5]XM输出驱动无效(Hi-z) 
  284.         [4]XP输出驱动无效(AIN7) 
  285.         [3]XP上拉有效 
  286.         [2]普通ADC转换 
  287.         [0:1]等待中断模式 测量X和Y的坐标 
  288.     */  
  289.     //printk("ADC_TSC: 0x%x\n",WAIT4INT(0));  
  290.     writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  291.   
  292.     /* Initialise input stuff */  
  293.     memset(&ts, 0, sizeof(struct s3c2440ts));  
  294.   
  295.     /* 
  296.     下面的函数 
  297.     为新的输入设备分配内存。 
  298.     使用free_device()释放没有被注册的函数,使用input_unregister_device()解除已经注册的设备 
  299.     定义在/drivers/input/input.c 
  300.     struct input_dev *input_allocate_device(void) 
  301.     { 
  302.     struct input_dev *dev; 
  303.  
  304.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 
  305.     if (dev) { 
  306.         dev->dev.type = &input_dev_type; 
  307.         dev->dev.class = &input_class; 
  308.         device_initialize(&dev->dev); 
  309.         mutex_init(&dev->mutex); 
  310.         spin_lock_init(&dev->event_lock); 
  311.         INIT_LIST_HEAD(&dev->h_list); 
  312.         INIT_LIST_HEAD(&dev->node); 
  313.  
  314.         __module_get(THIS_MODULE); 
  315.     } 
  316.     return dev; 
  317.     } 
  318.     */  
  319.     input_dev = input_allocate_device();  
  320.   
  321.     if (!input_dev) {  
  322.         printk(KERN_ERR "Unable to allocate the input device !!\n");  
  323.         return -ENOMEM;  
  324.     }  
  325.     //下面初始化输入设备信息  
  326.     ts.dev = input_dev;  
  327.     ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) |  
  328.                BIT_MASK(EV_ABS);  
  329.     ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);  
  330.     input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0);  
  331.     input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0);  
  332.     input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0);  
  333.   
  334.     //ts.dev->private = &ts;  
  335.     ts.dev->name = s3c2440ts_name;  
  336.     ts.dev->id.bustype = BUS_RS232;  
  337.     ts.dev->id.vendor = 0xDEAD;  
  338.     ts.dev->id.product = 0xBEEF;  
  339.     ts.dev->id.version = S3C2410TSVERSION;  
  340.   
  341.     ts.shift = info->oversampling_shift;  
  342.     //printk("shift: %d\n",ts.shift);  
  343.       
  344.     /* Get irqs */  
  345.     //申请ADC中断,注意,中断类型为IRQF_SAMPLE_RANDOM | IRQF_SHARED,这样在使用触摸屏的时候  
  346.     //可以调试自己的ADC转换驱动,中断处理函数为adc_irq  
  347.     if (request_irq(IRQ_ADC, adc_irq, IRQF_SAMPLE_RANDOM | IRQF_SHARED,  
  348.         "s3c2440_action", ts.dev)) {  
  349.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_ADC !\n");  
  350.         iounmap(base_addr);  
  351.         return -EIO;  
  352.     }  
  353.     //申请TC中断,中断处理函数为tc_irq  
  354.     if (request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM,  
  355.             "s3c2440_action", ts.dev)) {  
  356.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_TC !\n");  
  357.         free_irq(IRQ_ADC, ts.dev);  
  358.         iounmap(base_addr);  
  359.         return -EIO;  
  360.     }  
  361.   
  362.     printk(KERN_INFO "%s successfully loaded\n", s3c2440ts_name);  
  363.   
  364.     /* All went ok, so register to the input system */  
  365.     /*这里注册设备 
  366.     函数功能: 
  367.      * This function registers device with input core. The device must be 
  368.      * allocated with input_allocate_device() and all it's capabilities 
  369.      * set up before registering. 
  370.      * If function fails the device must be freed with input_free_device(). 
  371.      * Once device has been successfully registered it can be unregistered 
  372.      * with input_unregister_device(); input_free_device() should not be 
  373.      * called in this case. 
  374.     函数原型如下: 
  375.     int input_register_device(struct input_dev *dev) 
  376.     { 
  377.         static atomic_t input_no = ATOMIC_INIT(0); 
  378.         struct input_handler *handler; 
  379.         const char *path; 
  380.         int error; 
  381.  
  382.         __set_bit(EV_SYN, dev->evbit); 
  383.  
  384.         init_timer(&dev->timer); 
  385.         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  386.             dev->timer.data = (long) dev; 
  387.             dev->timer.function = input_repeat_key; 
  388.             dev->rep[REP_DELAY] = 250; 
  389.             dev->rep[REP_PERIOD] = 33; 
  390.         } 
  391.  
  392.         if (!dev->getkeycode) 
  393.             dev->getkeycode = input_default_getkeycode; 
  394.  
  395.         if (!dev->setkeycode) 
  396.             dev->setkeycode = input_default_setkeycode; 
  397.  
  398.         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 
  399.              "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); 
  400.  
  401.         error = device_add(&dev->dev); 
  402.         if (error) 
  403.             return error; 
  404.  
  405.         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 
  406.         printk(KERN_INFO "input: %s as %s\n", 
  407.             dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  408.         kfree(path); 
  409.  
  410.         error = mutex_lock_interruptible(&input_mutex); 
  411.         if (error) { 
  412.             device_del(&dev->dev); 
  413.             return error; 
  414.         } 
  415.  
  416.         list_add_tail(&dev->node, &input_dev_list); 
  417.  
  418.         list_for_each_entry(handler, &input_handler_list, node) 
  419.             input_attach_handler(dev, handler); 
  420.  
  421.         input_wakeup_procfs_readers(); 
  422.  
  423.         mutex_unlock(&input_mutex); 
  424.  
  425.         return 0; 
  426.     } 
  427.     */  
  428.       
  429.     rc = input_register_device(ts.dev);  
  430.     if (rc) {  
  431.         free_irq(IRQ_TC, ts.dev);  
  432.         free_irq(IRQ_ADC, ts.dev);  
  433.         clk_disable(adc_clock);  
  434.         iounmap(base_addr);  
  435.         return -EIO;  
  436.     }  
  437.   
  438.     return 0;  
  439. }  
  440.   
  441. static int s3c2440ts_remove(struct platform_device *pdev)  
  442. {  
  443.     disable_irq(IRQ_ADC);  
  444.     disable_irq(IRQ_TC);  
  445.     free_irq(IRQ_TC,ts.dev);  
  446.     free_irq(IRQ_ADC,ts.dev);  
  447.   
  448.     if (adc_clock) {  
  449.         clk_disable(adc_clock);  
  450.         clk_put(adc_clock);  
  451.         adc_clock = NULL;  
  452.     }  
  453.   
  454.     input_unregister_device(ts.dev);  
  455.     iounmap(base_addr);  
  456.   
  457.     return 0;  
  458. }  
  459.   
  460. #ifdef CONFIG_PM  
  461. static int s3c2440ts_suspend(struct platform_device *pdev, pm_message_t state)  
  462. {  
  463.     writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC);  
  464.     writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM,  
  465.            base_addr+S3C2410_ADCCON);  
  466.   
  467.     disable_irq(IRQ_ADC);  
  468.     disable_irq(IRQ_TC);  
  469.   
  470.     clk_disable(adc_clock);  
  471.   
  472.     return 0;  
  473. }  
  474.   
  475. static int s3c2440ts_resume(struct platform_device *pdev)  
  476. {  
  477.     struct s3c2440_ts_mach_info *info =  
  478.         ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data;  
  479.   
  480.     clk_enable(adc_clock);  
  481.     msleep(1);  
  482.   
  483.     enable_irq(IRQ_ADC);  
  484.     enable_irq(IRQ_TC);  
  485.   
  486.     if ((info->presc&0xff) > 0)  
  487.         writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\  
  488.                  base_addr+S3C2410_ADCCON);  
  489.     else  
  490.         writel(0,base_addr+S3C2410_ADCCON);  
  491.   
  492.     /* Initialise registers */  
  493.     if ((info->delay&0xffff) > 0)  
  494.         writel(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  
  495.   
  496.     writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  497.   
  498.     return 0;  
  499. }  
  500.   
  501. #else  
  502. #define s3c2440ts_suspend NULL  
  503. #define s3c2440ts_resume  NULL  
  504. #endif  
  505. /* 
  506. 下面是/linux/platform_device.h定义的platform_driver结构体 
  507. struct platform_driver { 
  508.     int (*probe)(struct platform_device *);//设备的检测,所以需要先前的设备注册 
  509.     int (*remove)(struct platform_device *);//删除该设备 
  510.     void (*shutdown)(struct platform_device *); //关闭该设备 
  511.     int (*suspend)(struct platform_device *, pm_message_t state); 
  512.     int (*suspend_late)(struct platform_device *, pm_message_t state); 
  513.     int (*resume_early)(struct platform_device *); 
  514.     int (*resume)(struct platform_device *); 
  515.     struct pm_ext_ops *pm; 
  516.     struct device_driver driver;//设备驱动,定义在include/linux/device.h中 
  517. }; 
  518. 内核提供的platform_driver结构体的注册函数为platform_driver_register(),该函数定义在driver/base/platform.c中 
  519. */  
  520. static struct platform_driver s3c2440ts_driver = {  
  521.        .driver         = {  
  522.            .name   = "s3c2440-ts",  
  523.            .owner  = THIS_MODULE,  
  524.        },  
  525.        .probe          = s3c2440ts_probe,  
  526.        .remove         = s3c2440ts_remove,  
  527.        .suspend        = s3c2440ts_suspend,  
  528.        .resume         = s3c2440ts_resume,  
  529.   
  530. };  
  531.   
  532. static int __init s3c2440ts_init(void)  
  533. {  
  534.     int rc;  
  535.     rc = platform_driver_register(&s3c2440ts_driver);  
  536.     if (rc < 0)  
  537.         printk(KERN_ERR "platform_driver_register error!\n");  
  538.     return rc;  
  539. }  
  540.   
  541. static void __exit s3c2440ts_exit(void)  
  542. {  
  543.     platform_driver_unregister(&s3c2440ts_driver);  
  544. }  
  545.   
  546. module_init(s3c2440ts_init);  
  547. module_exit(s3c2440ts_exit);  
  548.   
  549. MODULE_AUTHOR("YANMING");  
  550. MODULE_DESCRIPTION("My s3c2440 touchscreen driver");  
  551. MODULE_LICENSE("GPL");  
4、分析完成后对触摸屏的工作过程就有了一个比较明确的认识

从触摸屏被按下到系统相应的过程如下:

(1) 当触摸屏感觉到触摸,触发IRQ_TC中断,然后读取触摸屏控制寄存器的值,判断是否被按下,如果被按下,启动定时器,执行touch_timer_fire()函数启动ADC转换。

(2) ADC转换完成后,会触发IRQ_ADC中断,执行相应的中断处理函数,如果ADC转换次数小于4,再次启动ADC转换;如果ADC转换次数为4,则启动一个系统滴答定时器,执行touch_timer_fire()函数

(3) 执行定时器服务程序时,如果此时触摸屏仍被按下,则上报事件和坐标数据,重复(2);如果没有被按下,上报时间和坐标数据,将触摸屏控制寄存器设置为中断等待状态
可见,触摸屏驱动的服务是一个封闭的循环过程。

http://blog.csdn.net/yming0221/article/details/6580981


2019-07-22 21:09:54 qasxc78563 阅读数 0

==================== 输入子系统=================
触摸屏原理

从技术原理角度讲,触摸屏是一套透明的绝对定位系统,因此他必须具备三个特性:
第一是透明性能:透明材质的好坏会直接影响到触摸屏的视觉效果,主要体现在屏幕的反光性和清晰度。
第二是绝对坐标系统:我们传统的鼠标是一种相对的定位系统,定位只参照前一次的鼠标位置的坐标,而触摸屏需要选哪里就指哪里,这是一种绝对的坐标系统,
两者在坐标的本质上有绝对区别。

第三是检测与定位:触摸屏技术是依靠屏幕下面的传感器工作的,因此定位的原理和所采用的传感器决定了触摸屏的大部分技术指标,包括反应速度、可靠性、稳定性和寿命等。

电容屏和电阻屏区别

电容屏触控工作方式:
电容式触摸屏利用人体的电应进行工作,其触摸屏由一块四层复合玻璃屏构成,并在表面贴上一层透明的特殊金属导电物质。当手指触摸在触摸屏上时,由于人体电场、
用户和触摸屏表面形成以一个耦合电容,对于高频电流来说,电容是直接导体,于是手指从接触点吸走一个很小的电流。这个电流分别从触摸屏四角上的电极中流出,
并且流经这四个电极的电流与手指到四角的距离成正比,控制器通过对这四个电流比例的精确计算,得出触摸点的位置信息。

特点是屏幕是硬屏,触摸灵敏,不用用力按压屏幕,支持多点触摸。

电阻屏触控工作方式:
电阻触摸屏的屏体部分是一块多层复合薄膜,由一层玻璃或有机玻璃作为基层,表面涂有一层透明的导电层(ITO膜),上面再盖有一层外表面经过硬化处理、光滑防刮的
塑料层。它的内表面也涂有一层ITO(导电玻璃),在两层导电层之间有许多细小(小于千分之一英寸)的透明隔离点把它们隔开。当手指接触屏幕时,两层 ITO发生接触,电阻发生变
化,在X和Y两个方向上产生信号,控制器根据检测到的电阻变化来计算接触点的XY坐标,再依照这个坐标来进行相应的操作,因此这种技术必须是要使用硬物施力到屏幕
上,才能获得触控效果。

特点是屏幕是软屏,按下去有轻微的凹陷,需稍用力触摸,可用任何手写笔,但不支持多点触控。

1.什么是子系统? //子公司
输入子系统:
定义:Linux系统支持的输入设备繁多,例如键盘、鼠标、触摸屏、手柄或者是一些输入设备像体感输入等等,Linux系统是如何管理如此之多的不同类型、
不同原理、不同的输入信息的输入设备的呢?其实就是通过input输入子系统这套软件体系来完成的。
内核是操作系统的核心。Linux内核提供很多基本功能,如虚拟内存、多任务、共享库、需求加载、共享写时拷贝(Copy-On-Write)以及网络功能等。
增加各种不同功能导致内核代码不断增加。 Linux内核把不同功能分成不同的子系统的方法,通过一种整体的结构把各种功能集合在一起,提高了工作效率。
同时还提供动态加载模块的方式,为动态修改内核功能提供了灵活性。

2.linux input子系统

input 子系统是对linux输入设备驱动进行了高度抽象最终分成了三层:包括input设备驱动层,核心层,事件处理层,触摸屏驱动代码也只是子系统的一部分,
input 子系统这种机制的出现,最大的优点我觉得就是为内核大大的简化了驱动程序!!!这个input子系统最神秘之处就是它的核心层部分,
linux输入子系统的体系结构可以分为三个层面,分别为:硬件驱动层、子系统核心层、事件处理层 ,意思就是每个层次只是负责单独的一个功能,无需参与其他的功能,

三个层面具体的功能如下:

硬件驱动层:其中硬件驱动层负责操作具体的硬件设备,这层的代码是针对具体的驱动程序的,需要驱动程序的作者来编写。
子系统核心层:子系统核心层是链接其他两个层之间的纽带与桥梁,向下提供驱动层的接口,向上提供事件处理层的接口。
事件处理层:事件处理层负责与用户程序打交道,将硬件驱动层传来的事件报告给用户程序。

输入子系统的实现需要满足以下需求:
①输入子系统要为每个输入设备在/dev/目录下生成一个设备文件,以方便应用程序读取指定输入设备产生的事件。
②对于每一个输入设备,在输入子系统只需要实现其事件获取即可,至于事件如何处理、如何到达设备文件则不需要考虑。
③Linux输入设备可以分为事件类(如USB鼠标、USB键盘、触摸屏等)、MOUSE类(特指PS/2接口的输入设备)、游戏杆类3种,
为这些输入设备实现的设备文件的接口必须有所差别。因此,输入子系统需要为不同类型的输入设备实现正确的设备文件接口。

触摸屏设备文件:/dev/input/event0

注意:一般来说,设备特殊,数据也是特殊的格式

输入子系统:
控制输入设备结构体如下:
struct input_event {
struct timeval time; //事件发生的时间 两个成员 一个ms us ----》时间戳
__u16 type; //事件的类型—》初次确定事件的类型
__u16 code; //事件码 ----》进一步确定是哪个事件
__s32 value; //值
};

常见的事件类型如下 type:

 EV_KEY,键盘
 EV_REL,相对坐标   (鼠标 )
 EV_ABS,绝对坐标   (触摸屏) (0,0)
 
 EV_SYN          0x00    表示设备支持所有的事件(同步事件)
 EV_KEY          0x01    键盘或者按键,表示一个键码  
 EV_REL          0x02    鼠标设备,表示一个相对的光标位置结果
 EV_ABS          0x03    手写板产生的值,其是一个绝对整数值 
 EV_MSC          0x04    其他类型 
 EV_LED          0x11    LED灯设备
 EV_SND          0x12    蜂鸣器,输入声音 
 EV_REP          0x14    允许重复按键类型 
 EV_PWR          0x16    电源管理事件 	 

常用的触摸屏的事件码如下 code :
触摸屏: ABS_X(X坐标) ABS_Y(Y坐标) ABS_PRESSURE(压力值)

获取坐标的流程
1、打开设备文件
2、定义一个结构体 struct input_event 用于保存读到 的数据
3、读取触摸屏设备文件(/dev/input/event0)将数据保存在 结构体
4、将数据打印
5、关闭设备文件

=================================
type:1 code:14a value:1 //按下的状态 1 按下 0松开
type:0 code:0 value:0 //同步事件
type:3 code:0 value:1ac // x 事件 1ac具体的坐标值
type:3 code:1 value:117 //y 事件
type:3 code:18 value:c8 // 压力值 200 按下
type:0 code:0 value:0 //同步事件
type:3 code:18 value:0 // 压力值 0 松开
type:1 code:14a value:0 //按下的状态 0松开

2014-08-08 09:13:04 linpuliang 阅读数 886

硬件平台:FL2440

内核版本:2.6.28

主机系统:Ubuntu 11.04

内核版本:2.6.39

原创作品,转载请标明出处 http://blog.csdn.net/yming0221/archive/2011/07/01/6579577.aspx

 

1、由于自己编译的内核触摸屏驱动选项选择的问题,触摸屏搞了好久

由于自己编译内核将触摸屏驱动以模块的形式编译的,方便自己调试ADC驱动和触摸屏驱动。遇到以下问题:

编译完触摸屏驱动完成后,利用insmod ts.ko加载驱动,之后在/dev/下生成鼠标结点文件mouse0,没有生成ts0

由于将触摸屏接口也一M的形式编译了,改成*

/dev下不生成event*节点,编译选项中选择Event interface

后面的touch screen驱动以模块的形式编译进内核,手动加载,方便自己调试

重新编译内核,内核编译完毕,烧写内核。

2、使用tslib更改环境变量

将环境变量写入/ec/profile

 

export QTDIR=/usr

export QPEDIR=/usr

export LD_LIBRARY_PATH=/usr/lib

export HOME=/usr/Settings

 

export QTDIR=/usr

export QPEDIR=/usr

export LD_LIBRARY_PATH=/usr/lib

export TSLIB_TSDEVICE=/dev/ts0

export TSLIB_TSEVENTTYPE=H3600

 

export QWS_MOUSE_PROTO="TPanel:/dev/ts0"

export TSLIB_CONFFILE=/usr/ts.conf

export TSLIB_PLUGINDIR=/usr/lib/ts

3、删除/etc/pointercal触摸屏校准文件,重新启动,执行校准
校准完毕,终于搞定,触摸屏正常使用。

 

2015-04-25 12:54:22 aifei7320 阅读数 0

应公司需要,在现有设备上面要使用触摸屏,显示器的尺寸是15寸,于是自己从淘宝上面买了个15寸4线电阻屏回来,带Windows下的驱动,售后告诉我不支持Linux。在pc上面使用很不错。接下来的任务是用到ARM开发板上面。

当把4根线,直接连接到开发板上面,为电阻屏预留的4个AD上面后,确实能够使用,不过鼠标并不能实时跟随触屏,会有跳动,而且在左侧区域按下后,鼠标跟随过来,当松开触摸屏后,鼠标并没有固定在按下的区域,而是回到右侧区域,类似于回到原点一样。触摸屏的最右下角还没有反映,但是在Windows下触屏是没有问题的。查看了内核的AD输出结果,看不出来什么原因,不得已只好放弃。

在Windows下的驱动文件中找到了一份使用手册,里面介绍了USB的协议,比较详细。然后查找看看内核是不是能够支持USB的触摸屏,在网上找到资料说能够支持,文件在Linux3.6.9/drivers/input/touchscreen/usbtouchscreen.c,找到后,跟协议进行比较,发现egalax的数据协议和手册里面描述的基本一样。看到了曙光!对内核进行配置Device Drivers--->Input Device Support--->Touchscreens--->USB TouchScreen Driver--->eGalax, eTurboTouch CT-410/510/700 device support。这样就配置好了内核,编译移植到开发板,确实可以用,但是总有一个轴是反的(从左向右滑动时,鼠标从右向左运动,当我把4根触屏线,颠倒后,变成从上到下滑动时,鼠标从下向上运动),单独颠倒x轴或者y轴的两个线也解决不了。最后想到可以认为的通过软件颠倒一下。协议使用的是11位数据,即2048。所以在usbtouchscreen.c中更改egalax_read_data函数,在dev->x = ((pkt[0] & 0x0F) << 7) | (pkt[4] & 0x7F);下增加一行dev->x = 2048 - dev->x;重新编译移植。Ok!!!触屏完全可以使用。下图是使用的触摸屏。

        经过之后的验证,这种方式不能算作是触摸屏,而更应该称之为触摸板,类似于笔记本的触摸板一样。如果要求没那么严格倒是可以使用。