Chinaunix首页 | 论坛 | 博客

旭日的博客mxh20999.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

FreedomXura

  • 博客访问： 921861
  • 博文数量： 84
  • 博客积分： 4334
  • 博客等级： 上校
  • 技术积分： 1610
  • 用 户 组： 普通用户
  • 注册时间： 2008-11-27 07:49
文章分类

全部博文（84）

文章存档

2012年（5）

2011年（21）

2010年（58）

我的朋友
最近访客
推荐博文
相关博文
触摸屏驱动移植

分类： 嵌入式

2010-11-07 16:44:21

一.触摸屏驱动:有3个文件:s3c2410_ts.c, s3c2440_adc.c, s3c2440adc.h ,参考友善之臂。

1.s3c2410_ts.c

  1. #include <linux/errno.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  4. #include <linux/slab.h>
  5. #include <linux/input.h>
  6. #include <linux/init.h>
  7. #include <linux/serio.h>
  8. #include <linux/delay.h>
  9. #include <linux/platform_device.h>
  10. #include <linux/clk.h>
  11. #include <linux/gpio.h>
  12. #include <asm/io.h>
  13. #include <asm/irq.h>

  15. #include <plat/regs-adc.h>
  16. #include <mach/regs-gpio.h>

  18. /* For ts.dev.id.version */
  19. #define S3C2410TSVERSION    0x0101

  21. #define WAIT4INT(x) (((x)<<8) | \
  22.          S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
  23.          S3C2410_ADCTSC_XY_PST(3))

  25. #define AUTOPST     (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
  26.          S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))

  28. static char *s3c2410ts_name = "s3c2410 TouchScreen";

  30. static    struct input_dev *dev;
  31. static    long xp;
  32. static    long yp;
  33. static    int count;

  35. extern struct semaphore ADC_LOCK;
  36. static int OwnADC = 0;

  38. static void __iomem *base_addr;

  40. static inline void s3c2410_ts_connect(void)
  41. {
  42.     s3c2410_gpio_cfgpin(S3C2410_GPG(12), S3C2410_GPG12_XMON);
  43.     s3c2410_gpio_cfgpin(S3C2410_GPG(13), S3C2410_GPG13_nXPON);
  44.     s3c2410_gpio_cfgpin(S3C2410_GPG(14), S3C2410_GPG14_YMON);
  45.     s3c2410_gpio_cfgpin(S3C2410_GPG(15), S3C2410_GPG15_nYPON);
  46. }

  48. static void touch_timer_fire(unsigned long data)
  49. {
  50.       unsigned long data0;
  51.       unsigned long data1;
  52.     int updown;

  54.       data0 = ioread32(base_addr+S3C2410_ADCDAT0);
  55.       data1 = ioread32(base_addr+S3C2410_ADCDAT1);

  57.      updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

  59.      if (updown) {
  60.          if (count != 0) {
  61.             long tmp;
  62.                                                                                                  
  63.             tmp = xp;
  64.             xp = yp;
  65.             yp = tmp;
  66.                                                                                                  
  67.                         xp >>= 2;
  68.                         yp >>= 2;

  70.              input_report_abs(dev, ABS_X, xp);
  71.              input_report_abs(dev, ABS_Y, yp);

  73.              input_report_key(dev, BTN_TOUCH, 1);
  74.              input_report_abs(dev, ABS_PRESSURE, 1);
  75.              input_sync(dev);
  76.          }

  78.          xp = 0;
  79.          yp = 0;
  80.          count = 0;

  82.          iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
  83.          iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
  84.      } else {
  85.          count = 0;

  87.          input_report_key(dev, BTN_TOUCH, 0);
  88.          input_report_abs(dev, ABS_PRESSURE, 0);
  89.          input_sync(dev);

  91.          iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
  92.         if (OwnADC) {
  93.             OwnADC = 0;
  94.             up(&ADC_LOCK);
  95.         }
  96.      }
  97. }

  99. static struct timer_list touch_timer =
  100.         TIMER_INITIALIZER(touch_timer_fire, 0, 0);

  102. static irqreturn_t stylus_updown(int irq, void *dev_id)
  103. {
  104.     unsigned long data0;
  105.     unsigned long data1;
  106.     int updown;

  108.     if (down_trylock(&ADC_LOCK) == 0) {
  109.         OwnADC = 1;
  110.         data0 = ioread32(base_addr+S3C2410_ADCDAT0);
  111.         data1 = ioread32(base_addr+S3C2410_ADCDAT1);

  113.         updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

  115.         if (updown) {
  116.             touch_timer_fire(0);
  117.         } else {
  118.             OwnADC = 0;
  119.             up(&ADC_LOCK);
  120.         }
  121.     }

  123.     return IRQ_HANDLED;
  124. }


  127. static irqreturn_t stylus_action(int irq, void *dev_id)
  128. {
  129.     unsigned long data0;
  130.     unsigned long data1;

  132.     if (OwnADC) {
  133.         data0 = ioread32(base_addr+S3C2410_ADCDAT0);
  134.         data1 = ioread32(base_addr+S3C2410_ADCDAT1);

  136.         xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
  137.         yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
  138.         count++;

  140.      if (count < (1<<2)) {
  141.             iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
  142.             iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
  143.         } else {
  144.             mod_timer(&touch_timer, jiffies+1);
  145.             iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC);
  146.         }
  147.     }

  149.     return IRQ_HANDLED;
  150. }

  152. static struct clk    *adc_clock;

  154. static int __init s3c2410ts_init(void)
  155. {
  156.     struct input_dev *input_dev;

  158.     adc_clock = clk_get(NULL, "adc");
  159.     if (!adc_clock) {
  160.         printk(KERN_ERR "failed to get adc clock source\n");
  161.         return -ENOENT;
  162.     }
  163.     clk_enable(adc_clock);

  165.     base_addr=ioremap(S3C2410_PA_ADC,0x20);
  166.     if (base_addr == NULL) {
  167.         printk(KERN_ERR "Failed to remap register block\n");
  168.         return -ENOMEM;
  169.     }

  171.     /* Configure GPIOs */
  172.     s3c2410_ts_connect();

  174.     iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF),\
  175.          base_addr+S3C2410_ADCCON);
  176.     iowrite32(0xffff, base_addr+S3C2410_ADCDLY);
  177.     iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);

  179.     /* Initialise input stuff */
  180.     input_dev = input_allocate_device();

  182.     if (!input_dev) {
  183.         printk(KERN_ERR "Unable to allocate the input device !!\n");
  184.         return -ENOMEM;
  185.     }

  187.     dev = input_dev;
  188.     dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
  189.     dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);
  190.     input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0);
  191.     input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0);
  192.     input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0);

  194.     dev->name = s3c2410ts_name;
  195.     dev->id.bustype = BUS_RS232;
  196.     dev->id.vendor = 0xDEAD;
  197.     dev->id.product = 0xBEEF;
  198.     dev->id.version = S3C2410TSVERSION;


  201.     /* Get irqs */
  202.     if (request_irq(IRQ_ADC, stylus_action, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
  203.         "s3c2410_action", dev)) {
  204.         printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_ADC !\n");
  205.         iounmap(base_addr);
  206.         return -EIO;
  207.     }
  208.     if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
  209.             "s3c2410_action", dev)) {
  210.         printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_TC !\n");
  211.         iounmap(base_addr);
  212.         return -EIO;
  213.     }

  215.     printk(KERN_INFO "%s successfully loaded\n", s3c2410ts_name);

  217.     /* All went ok, so register to the input system */
  218.     input_register_device(dev);

  220.     return 0;
  221. }

  223. static void __exit s3c2410ts_exit(void)
  224. {
  225.     disable_irq(IRQ_ADC);
  226.     disable_irq(IRQ_TC);
  227.     free_irq(IRQ_TC,dev);
  228.     free_irq(IRQ_ADC,dev);

  230.     if (adc_clock) {
  231.         clk_disable(adc_clock);
  232.         clk_put(adc_clock);
  233.         adc_clock = NULL;
  234.     }

  236.     input_unregister_device(dev);
  237.     iounmap(base_addr);
  238. }


  241. module_init(s3c2410ts_init);
  242. module_exit(s3c2410ts_exit);

2.s3c2440_adc.h

  1. #ifndef _S3C2410_ADC_H_
  2. #define _S3C2410_ADC_H_

  4. #define ADC_WRITE(ch, prescale)    ((ch)<<16|(prescale))

  6. #define ADC_WRITE_GETCH(data)    (((data)>>16)&0x7)
  7. #define ADC_WRITE_GETPRE(data)    ((data)&0xff)

  9. #endif /* _S3C2410_ADC_H_ */

3.s3c2440_adc.c

 

  1. #include <linux/errno.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  4. #include <linux/slab.h>
  5. #include <linux/input.h>
  6. #include <linux/init.h>
  7. #include <linux/serio.h>
  8. #include <linux/delay.h>
  9. #include <linux/clk.h>
  10. #include <linux/wait.h>
  11. #include <linux/sched.h>
  12. #include <asm/io.h>
  13. #include <asm/irq.h>
  14. #include <asm/uaccess.h>
  15. #include <mach/regs-clock.h>
  16. #include <plat/regs-timer.h>
  17.     
  18. #include <plat/regs-adc.h>
  19. #include <mach/regs-gpio.h>
  20. #include <linux/cdev.h>
  21. #include <linux/miscdevice.h>

  23. #include "s3c2440_adc.h"

  25. #undef DEBUG
  26. //#define DEBUG
  27. #ifdef DEBUG
  28. #define DPRINTK(x...) {printk(__FUNCTION__"(%d): ",__LINE__);printk(##x);}
  29. #else
  30. #define DPRINTK(x...) (void)(0)
  31. #endif

  33. #define DEVICE_NAME    "adc"

  35. static void __iomem *base_addr;

  37. typedef struct {
  38.     wait_queue_head_t wait;
  39.     int channel;
  40.     int prescale;
  41. }ADC_DEV;

  43. DECLARE_MUTEX(ADC_LOCK);
  44. static int OwnADC = 0;

  46. static ADC_DEV adcdev;
  47. static volatile int ev_adc = 0;
  48. static int adc_data;

  50. static struct clk    *adc_clock;

  52. #define ADCCON (*(volatile unsigned long *)(base_addr + S3C2410_ADCCON))    //ADC control
  53. #define ADCTSC (*(volatile unsigned long *)(base_addr + S3C2410_ADCTSC))    //ADC touch screen control
  54. #define ADCDLY (*(volatile unsigned long *)(base_addr + S3C2410_ADCDLY))    //ADC start or Interval Delay
  55. #define ADCDAT0 (*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT0))    //ADC conversion data 0
  56. #define ADCDAT1 (*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT1))    //ADC conversion data 1
  57. #define ADCUPDN (*(volatile unsigned long *)(base_addr + 0x14))    //Stylus Up/Down interrupt status

  59. #define PRESCALE_DIS (0 << 14)
  60. #define PRESCALE_EN (1 << 14)
  61. #define PRSCVL(x) ((x) << 6)
  62. #define ADC_INPUT(x) ((x) << 3)
  63. #define ADC_START (1 << 0)
  64. #define ADC_ENDCVT (1 << 15)

  66. #define START_ADC_AIN(ch, prescale) \
  67.     do{ \
  68.         ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
  69.         ADCCON |= ADC_START; \
  70.     }while(0)


  73. static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
  74. {
  75.     if (OwnADC) {
  76.         adc_data = ADCDAT0 & 0x3ff;

  78.         ev_adc = 1;
  79.         wake_up_interruptible(&adcdev.wait);
  80.     }

  82.     return IRQ_HANDLED;
  83. }

  85. static ssize_t s3c2410_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
  86. {
  87.     char str[20];
  88.     int value;
  89.     size_t len;
  90.     if (down_trylock(&ADC_LOCK) == 0) {
  91.         OwnADC = 1;
  92.         START_ADC_AIN(adcdev.channel, adcdev.prescale);
  93.         wait_event_interruptible(adcdev.wait, ev_adc);

  95.         ev_adc = 0;

  97.         DPRINTK("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ADCCON & 0x80 ? 1:0);

  99.         value = adc_data;

  101.         OwnADC = 0;
  102.         up(&ADC_LOCK);
  103.     } else {
  104.         value = -1;
  105.     }

  107.     len = sprintf(str, "%d\n", value);
  108.     if (count >= len) {
  109.         int r = copy_to_user(buffer, str, len);
  110.         return r ? r : len;
  111.     } else {
  112.         return -EINVAL;
  113.     }
  114. }

  116. static int s3c2410_adc_open(struct inode *inode, struct file *filp)
  117. {
  118.     init_waitqueue_head(&(adcdev.wait));

  120.     adcdev.channel=0;
  121.     adcdev.prescale=0xff;

  123.     DPRINTK( "adc opened\n");
  124.     return 0;
  125. }

  127. static int s3c2410_adc_release(struct inode *inode, struct file *filp)
  128. {
  129.     DPRINTK( "adc closed\n");
  130.     return 0;
  131. }


  134. static struct file_operations dev_fops = {
  135.     owner:    THIS_MODULE,
  136.     open:    s3c2410_adc_open,
  137.     read:    s3c2410_adc_read,    
  138.     release:    s3c2410_adc_release,
  139. };

  141. static struct miscdevice misc = {
  142.     .minor = MISC_DYNAMIC_MINOR,
  143.     .name = DEVICE_NAME,
  144.     .fops = &dev_fops,
  145. };

  147. static int __init dev_init(void)
  148. {
  149.     int ret;

  151.     base_addr=ioremap(S3C2410_PA_ADC,0x20);
  152.     if (base_addr == NULL) {
  153.         printk(KERN_ERR "Failed to remap register block\n");
  154.         return -ENOMEM;
  155.     }

  157.     adc_clock = clk_get(NULL, "adc");
  158.     if (!adc_clock) {
  159.         printk(KERN_ERR "failed to get adc clock source\n");
  160.         return -ENOENT;
  161.     }
  162.     clk_enable(adc_clock);
  163.     
  164.     /* normal ADC */
  165.     ADCTSC = 0;

  167.     ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
  168.     if (ret) {
  169.         iounmap(base_addr);
  170.         return ret;
  171.     }

  173.     ret = misc_register(&misc);

  175.     printk (DEVICE_NAME"\tinitialized\n");
  176.     return ret;
  177. }

  179. static void __exit dev_exit(void)
  180. {
  181.     free_irq(IRQ_ADC, &adcdev);
  182.     iounmap(base_addr);

  184.     if (adc_clock) {
  185.         clk_disable(adc_clock);
  186.         clk_put(adc_clock);
  187.         adc_clock = NULL;
  188.     }

  190.     misc_deregister(&misc);
  191. }

  193. EXPORT_SYMBOL(ADC_LOCK);
  194. module_init(dev_init);
  195. module_exit(dev_exit);
  196. MODULE_LICENSE("GPL");
  197. MODULE_AUTHOR("FriendlyARM Inc.");

二. 部署驱动源代码到内核中

#cp -f s3c2440_adc.h s3c2440_adc.c linux-2.6.31/drivers/char/

#cp -f s3c2410_ts.c linux-2.6.31/drivers/input/touchscreen/


三. 将驱动模块添加到内核配置文件中
 

#gedit linux-2.6.30.4/drivers/char/Kconfig  //添加如下内容

config MY2440_ADC
    bool "ADC device for my2440"
    default y


#gedit drivers/char/Makefile  //添加如下内容

obj-$(CONFIG_MY2440_ADC)  += s3c2440_adc.o

#gedit drivers/input/touchscreen/Kconfig  //添加如下内容

config TOUCHSCREEN_MY2440
    tristate "MY2440 touchscreens input driver"
    default y
 
config TOUCHSCREEN_MY2440_DEBUG
    boolean "MY2440 touchscreens input driver debug messages"
    depends on TOUCHSCREEN_MY2440
    help
        Select this if you want debug messages

#gedit drivers/input/touchscreen/Makefile  //添加如下内容

obj-$(CONFIG_TOUCHSCREEN_MY2440) += s3c2410_ts.o

四. 修改内核配置选项
 

Device Drivers --->
    Input device support --->
        (240) Horizontal screen resolution 
        (320) Vertical screen resolution 
        [*] Touchscreens ---> 
            <*> MY2440 touchscreens input driver (NEW)
            [*] MY2440 touchscreens input driver debug messages 
    Character devices ---> 
        [*] ADC device for my2440 (NEW)


五. 编译内核并下载到开发板上，从启动信息可以看到触摸屏驱动加载成功

s3c2410 TouchScreen successfully loaded
input: s3c2410 TouchScreen as /class/input/input0


#cat /proc/devices   可以查看到input设备

得知输入类设备的主设备号为13，又查看总线的具体输入设备可得知该设备的详细信息，根据这些信息我们建立好设备节点，设置内核调试级别为8，然后打开触摸屏设备.

#mkdir /dev/input
#mknod /dev/input/event0 c 13 64

#echo 8 > /proc/sys/kernel/printk

#cat /dev/input/event0

点击触摸屏，此时可以看到打印的坐标信息，即触摸屏可正常使用了.

阅读(3421) | 评论(0) | 转发(1) |
0

上一篇：USB驱动移植

下一篇：LCD驱动移植

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6