新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > ARM-Linux驱动-触摸屏驱动分析

ARM-Linux驱动-触摸屏驱动分析

作者： 时间：2016-11-20 来源：网络
收藏
硬件平台：FL2440

内核版本：2.6.28

本文引用地址：https://www.eepw.com.cn/article/201611/318865.htm

主机平台：Ubuntu 11.04

内核版本：2.6.39

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. //#defineCONFIG_TOUCHSCREEN_S3C2410_DEBUG
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include
  14. #include
  16. #include
  17. #include
  19. #include
  21. #defineTRUE1//CoAsiaadded
  22. #defineFALSE0//CoAsiaadded
  23. #defineFILTER_LIMIT25//CoAsiaadded
  25. /*Forts.dev.id.version*/
  26. #defineS3C2410TSVERSION0x0101
  28. #defineTSC_SLEEP(S3C2410_ADCTSC_PULL_UP_DISABLE|S3C2410_ADCTSC_XY_PST(0))
  30. #defineWAIT4INT(x)(((x)<<8)|
  31. S3C2410_ADCTSC_YM_SEN|S3C2410_ADCTSC_YP_SEN|S3C2410_ADCTSC_XP_SEN|
  32. S3C2410_ADCTSC_XY_PST(3))
  34. #defineAUTOPST(S3C2410_ADCTSC_YM_SEN|S3C2410_ADCTSC_YP_SEN|S3C2410_ADCTSC_XP_SEN|
  35. S3C2410_ADCTSC_AUTO_PST|S3C2410_ADCTSC_XY_PST(0))
  37. #defineDEBUG_LVL"<3>"//KERN_DEBUG
  39. staticchar*s3c2440ts_name="s3c2440TouchScreen";
  41. /*
  42. *Per-touchscreendata.
  43. */
  44. //定义s3c2440触摸屏使用的数据结构体
  45. structs3c2440ts{
  46. structinput_dev*dev;
  47. longxp;
  48. longyp;
  49. intcount;
  50. intshift;
  51. };
  53. staticstructs3c2440tsts;
  54. staticstructclk*adc_clock;
  56. //__iomem声明地址空间是设备地址映射空间
  57. staticvoid__iomem*base_addr;
  59. //函数声明
  60. staticvoidtouch_timer_fire(unsignedlongdata);
  61. staticirqreturn_ttc_irq(intirq,void*dev_id);
  62. staticirqreturn_tadc_irq(intirq,void*dev_id);
  63. staticint__inits3c2440ts_probe(structplatform_device*pdev);
  64. staticints3c2440ts_remove(structplatform_device*pdev);
  65. staticints3c2440ts_resume(structplatform_device*pdev);
  67. //定义定时器
  68. staticstructtimer_listtouch_timer=
  69. TIMER_INITIALIZER(touch_timer_fire,0,0);
  72. //IRQ_TC中断处理函数
  73. staticirqreturn_ttc_irq(intirq,void*dev_id)
  74. {
  75. //data0,data1用于存放读取的ADCDAT数据寄存器的值
  76. unsignedlongdata0;
  77. unsignedlongdata1;
  78. intupdown;//用于存放光标的按下或提起的状态
  80. //读取ADCDAT0、ADCDAT1数据寄存器的值
  81. data0=readl(base_addr+S3C2410_ADCDAT0);
  82. data1=readl(base_addr+S3C2410_ADCDAT1);
  84. //查看数据寄存器的第15位的值
  85. updown=(!(data0&S3C2410_ADCDAT0_UPDOWN))&&(!(data1&S3C2410_ADCDAT0_UPDOWN));
  87. /*TODOweshouldnevergetaninterruptwithupdownsetwhile
  88. *thetimerisrunning,butmaybeweoughttoverifythatthe
  89. *timerisntrunninganyways.*/
  91. //如果data0和data1的第15位都是0，则updown为1，则通过函数touch_timer_fire()函数来启动ADC转换
  92. if(updown)
  93. touch_timer_fire(0);
  95. returnIRQ_HANDLED;
  96. }
  98. staticvoidtouch_timer_fire(unsignedlongdata)
  99. {
  100. //用于存储数据寄存器ADCDAT0、ADCDAT1的值
  101. unsignedlongdata0;
  102. unsignedlongdata1;
  104. //用于存放光标是否被按下
  105. intupdown;
  107. data0=readl(base_addr+S3C2410_ADCDAT0);
  108. data1=readl(base_addr+S3C2410_ADCDAT1);
  110. updown=(!(data0&S3C2410_ADCDAT0_UPDOWN))&&(!(data1&S3C2410_ADCDAT0_UPDOWN));
  111. //printk("Thenumberofupdownis%dn",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;
  121. #ifdefCONFIG_TOUCHSCREEN_S3C2410_DEBUG
  122. {
  123. structtimevaltv;
  124. do_gettimeofday(&tv);
  125. printk(DEBUG_LVL"T:%06d,X:%03ld,Y:%03ldn",(int)tv.tv_usec,ts.xp,ts.yp);
  126. }
  127. #endif
  128. /*
  129. 下面的函数位于/include/linux/input.h，作用是报告事件
  130. staticinlinevoidinput_report_abs(structinput_dev*dev,unsignedintcode,intvalue)
  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);
  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;
  151. //设置触摸屏控制寄存器的值为0xdcB:11011100，设置控制寄存器上拉无效，自动转换X，Y坐标
  152. //printk("S3C2410_ADCTSC:0x%xn",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. }
  171. staticirqreturn_tadc_irq(intirq,void*dev_id)
  172. {
  173. //用于存放数据寄存器的数据
  174. unsignedlongdata0;
  175. unsignedlongdata1;
  176. //读取数据，这次主要读取的是位置数据
  177. data0=readl(base_addr+S3C2410_ADCDAT0);
  178. data1=readl(base_addr+S3C2410_ADCDAT1);
  180. ts.xp+=data0&S3C2410_ADCDAT0_XPDATA_MASK;//累加四次准换结果的X坐标和
  181. ts.yp+=data1&S3C2410_ADCDAT1_YPDATA_MASK;//累加四次准换结果的Y坐标和
  183. ts.count++;//转换次数加一
  185. //如果转换次数小于4
  186. if(ts.count<(1<
  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. }
  199. returnIRQ_HANDLED;
  200. }
  204. /*
  205. *Thefunctionsforinserting/removingusasamodule.
  206. */
  207. /*
  208. 该结构体定义在/include/linux/platform_device.h
  209. structplatform_device{
  210. constchar*name;
  211. intid;
  212. structdevicedev;
  213. u32num_resources;
  214. structresource*resource;
  215. };
  216. */
  217. staticint__inits3c2440ts_probe(structplatform_device*pdev)
  218. {
  219. intrc;
  220. /*
  221. 下面结构体定义在/include/mach/s3c2410_ts.h
  222. structs3c2410_ts_mach_info{
  223. intdelay;
  224. intpresc;
  225. intoversampling_shift;
  226. };
  227. */
  228. structs3c2410_ts_mach_info*info;
  229. structinput_dev*input_dev;
  230. /*
  231. void*platform_data;//Platformspecificdata,devicecoredoesnttouchit
  232. */
  233. info=(structs3c2440_ts_mach_info*)pdev->dev.platform_data;
  235. if(!info)
  236. {
  237. printk(KERN_ERR"Hm...toobad:noplatformdatafortsn");
  238. return-EINVAL;
  239. }
  241. #ifdefCONFIG_TOUCHSCREEN_S3C2410_DEBUG
  242. printk(DEBUG_LVL"Enterings3c2440ts_initn");
  243. #endif
  244. //由于ADC转换需要时钟，这里获取时钟
  245. adc_clock=clk_get(NULL,"adc");
  246. if(!adc_clock){
  247. printk(KERN_ERR"failedtogetadcclocksourcen");
  248. return-ENOENT;
  249. }
  250. clk_enable(adc_clock);//使能时钟
  252. #ifdefCONFIG_TOUCHSCREEN_S3C2410_DEBUG
  253. printk(DEBUG_LVL"gotandenabledclockn");
  254. #endif
  255. //通过ioremap实现物理地址到虚拟地址的转换
  256. base_addr=ioremap(S3C2410_PA_ADC,0x20);
  257. if(base_addr==NULL){
  258. printk(KERN_ERR"Failedtoremapregisterblockn");
  259. return-ENOMEM;
  260. }
  262. //设置ADCCON控制寄存器为0x4c40,设置预分频有效，预分频值为B：110001D：49
  263. //printk("ADCCONis0x%xn",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);
  271. /*Initialiseregisters*/
  272. /*
  273. 设置ADC开始延时寄存器ADCDLY:0x4e20
  274. */
  275. //printk("ADCDLY:0x%xn",info->delay&0xffff);
  276. if((info->delay&0xffff)>0)
  277. writel(info->delay&0xffff,base_addr+S3C2410_ADCDLY);
  278. /*
  279. 设置ADC触摸屏控制寄存器ADC_TSC:0xd3B:11010011
  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%xn",WAIT4INT(0));
  290. writel(WAIT4INT(0),base_addr+S3C2410_ADCTSC);
  292. /*Initialiseinputstuff*/
  293. memset(&ts,0,sizeof(structs3c2440ts));
  295. /*
  296. 下面的函数
  297. 为新的输入设备分配内存。
  298. 使用free_device()释放没有被注册的函数，使用input_unregister_device()解除已经注册的设备
  299. 定义在/drivers/input/input.c
  300. structinput_dev*input_allocate_device(void)
  301. {
  302. structinput_dev*dev;
  304. dev=kzalloc(sizeof(structinput_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);
  314. __module_get(THIS_MODULE);
  315. }
  316. returndev;
  317. }
  318. */
  319. input_dev=input_allocate_device();
  321. if(!input_dev){
  322. printk(KERN_ERR"Unabletoallocatetheinputdevice!!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);
  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;
  341. ts.shift=info->oversampling_shift;
  342. //printk("shift:%dn",ts.shift);
  344. /*Getirqs*/
  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:CouldnotallocatetsIRQ_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:CouldnotallocatetsIRQ_TC!n");
  357. free_irq(IRQ_ADC,ts.dev);
  358. iounmap(base_addr);
  359. return-EIO;
  360. }
  362. printk(KERN_INFO"%ssuccessfullyloadedn",s3c2440ts_name);
  364. /*Allwentok,soregistertotheinputsystem*/
  365. /*这里注册设备
  366. 函数功能：
  367. *Thisfunctionregistersdevicewithinputcore.Thedevicemustbe
  368. *allocatedwithinput_allocate_device()andallitscapabilities
  369. *setupbeforeregistering.
  370. *Iffunctionfailsthedevicemustbefreedwithinput_free_device().
  371. *Oncedevicehasbeensuccessfullyregistereditcanbeunregistered
  372. *withinput_unregister_device();input_free_device()shouldnotbe
  373. *calledinthiscase.
  374. 函数原型如下：
  375. intinput_register_device(structinput_dev*dev)
  376. {
  377. staticatomic_tinput_no=ATOMIC_INIT(0);
  378. structinput_handler*handler;
  379. constchar*path;
  380. interror;
  382. __set_bit(EV_SYN,dev->evbit);
  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. }
  392. if(!dev->getkeycode)
  393. dev->getkeycode=input_default_getkeycode;
  395. if(!dev->setkeycode)
  396. dev->setkeycode=input_default_setkeycode;
  398. snprintf(dev->dev.bus_id,sizeof(dev->dev.bus_id),
  399. "input%ld",(unsignedlong)atomic_inc_return(&input_no)-1);
  401. error=device_add(&dev->dev);
  402. if(error)
  403. returnerror;
  405. path=kobject_get_path(&dev->dev.kobj,GFP_KERNEL);
  406. printk(KERN_INFO"input:%sas%sn",
  407. dev->name?dev->name:"Unspecifieddevice",path?path:"N/A");
  408. kfree(path);
  410. error=mutex_lock_interruptible(&input_mutex);
  411. if(error){
  412. device_del(&dev->dev);
  413. returnerror;
  414. }
  416. list_add_tail(&dev->node,&input_dev_list);
  418. list_for_each_entry(handler,&input_handler_list,node)
  419. input_attach_handler(dev,handler);
  421. input_wakeup_procfs_readers();
  423. mutex_unlock(&input_mutex);
  425. return0;
  426. }
  427. */
  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. }
  438. return0;
  439. }
  441. staticints3c2440ts_remove(structplatform_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);
  448. if(adc_clock){
  449. clk_disable(adc_clock);
  450. clk_put(adc_clock);
  451. adc_clock=NULL;
  452. }
  454. input_unregister_device(ts.dev);
  455. iounmap(base_addr);
  457. return0;
  458. }
  460. #ifdefCONFIG_PM
  461. staticints3c2440ts_suspend(structplatform_device*pdev,pm_message_tstate)
  462. {
  463. writel(TSC_SLEEP,base_addr+S3C2410_ADCTSC);
  464. writel(readl(base_addr+S3C2410_ADCCON)|S3C2410_ADCCON_STDBM,
  465. base_addr+S3C2410_ADCCON);
  467. disable_irq(IRQ_ADC);
  468. disable_irq(IRQ_TC);
  470. clk_disable(adc_clock);
  472. return0;
  473. }
  475. staticints3c2440ts_resume(structplatform_device*pdev)
  476. {
  477. structs3c2440_ts_mach_info*info=
  478. (structs3c2440_ts_mach_info*)pdev->dev.platform_data;
  480. clk_enable(adc_clock);
  481. msleep(1);
  483. enable_irq(IRQ_ADC);
  484. enable_irq(IRQ_TC);
  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);
  492. /*Initialiseregisters*/
  493. if((info->delay&0xffff)>0)
  494. writel(info->delay&0xffff,base_addr+S3C2410_ADCDLY);
  496. writel(WAIT4INT(0),base_addr+S3C2410_ADCTSC);
  498. return0;
  499. }
  501. #else
  502. #defines3c2440ts_suspendNULL
  503. #defines3c2440ts_resumeNULL
  504. #endif
  505. /*
  506. 下面是/linux/platform_device.h定义的platform_driver结构体
  507. structplatform_driver{
  508. int(*probe)(structplatform_device*);//设备的检测，所以需要先前的设备注册
  509. int(*remove)(structplatform_device*);//删除该设备
  510. void(*shutdown)(structplatform_device*);//关闭该设备
  511. int(*suspend)(structplatform_device*,pm_message_tstate);
  512. int(*suspend_late)(structplatform_device*,pm_message_tstate);
  513. int(*resume_early)(structplatform_device*);
  514. int(*resume)(structplatform_device*);
  515. structpm_ext_ops*pm;
  516. structdevice_driverdriver;//设备驱动，定义在include/linux/device.h中
  517. };
  518. 内核提供的platform_driver结构体的注册函数为platform_driver_register(),该函数定义在driver/base/platform.c中
  519. */
  520. staticstructplatform_drivers3c2440ts_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,
  530. };
  532. staticint__inits3c2440ts_init(void)
  533. {
  534. intrc;
  535. rc=platform_driver_register(&s3c2440ts_driver);
  536. if(rc<0)
  537. printk(KERN_ERR"platform_driver_registererror!n");
  538. returnrc;
  539. }
  541. staticvoid__exits3c2440ts_exit(void)
  542. {
  543. platform_driver_unregister(&s3c2440ts_driver);
  544. }
  546. module_init(s3c2440ts_init);
  547. module_exit(s3c2440ts_exit);
  549. MODULE_AUTHOR("YANMING");
  550. MODULE_DESCRIPTION("Mys3c2440touchscreendriver");
  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）；如果没有被按下，上报时间和坐标数据，将触摸屏控制寄存器设置为中断等待状态
可见，触摸屏驱动的服务是一个封闭的循环过程。

关键词： ARMLinux驱动触摸屏驱

评论


相关推荐

技术专区

关闭