MINI2440Linux驱动02-mini2440_ts

于 2011-10-13 19:12:36 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 嵌入式Linux 文章标签： linux semaphore struct input timer report
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kekuixiong/article/details/6871132
版权 
//linux-src/drivers/input/touchscreen/s3c2410_ts.c
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/clk.h>

#include <linux/gpio.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <plat/regs-adc.h>
#include <mach/regs-gpio.h>

/* For ts.dev.id.version */
#define S3C2410TSVERSION 0x0101
/*定义一个WAIT4INT宏，该宏将对ADC触摸屏控制寄存器进行操作
S3C2410_ADCTSC_YM_SEN这些宏都定义在regs-adc.h中*/
#define WAIT4INT(x) (((x)<<8) | \
S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
S3C2410_ADCTSC_XY_PST(3))

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

static char *s3c2410ts_name = "s3c2410 TouchScreen";   /*设备名称*/
static struct input_dev *dev;        /*定义一个输入设备来表示我们的触摸屏设备*/
static long xp;
static long yp;
static int count;

extern struct semaphore ADC_LOCK;    //声明外部信号量
static int OwnADC = 0;

static void __iomem *base_addr;      /*定义了一个用来保存经过虚拟映射后的内存地址*/

static inline void s3c2410_ts_connect(void)
{
  s3c2410_gpio_cfgpin(S3C2410_GPG(12), S3C2410_GPG12_XMON);
  s3c2410_gpio_cfgpin(S3C2410_GPG(13), S3C2410_GPG13_nXPON);
  s3c2410_gpio_cfgpin(S3C2410_GPG(14), S3C2410_GPG14_YMON);
  s3c2410_gpio_cfgpin(S3C2410_GPG(15), S3C2410_GPG15_nYPON);
}

static void touch_timer_fire(unsigned long data)
{
  unsigned long data0;
  unsigned long data1;
  int updown;
  data0 = ioread32(base_addr+S3C2410_ADCDAT0);
  data1 = ioread32(base_addr+S3C2410_ADCDAT1);
  updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));
  if (updown) 
  	{
    if (count != 0) 
    	{
       long tmp;
       tmp = xp;
       xp = yp;
       yp = tmp;
       xp >>= 2;
       yp >>= 2;
       input_report_abs(dev, ABS_X, xp);
       input_report_abs(dev, ABS_Y, yp);
       input_report_key(dev, BTN_TOUCH, 1);
       input_report_abs(dev, ABS_PRESSURE, 1);
       input_sync(dev);
      }
     xp = 0;
     yp = 0;
     count = 0;
     iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
     iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START,
      base_addr+S3C2410_ADCCON);
    } 
    else 
    {
     count = 0;
     input_report_key(dev, BTN_TOUCH, 0);
     input_report_abs(dev, ABS_PRESSURE, 0);
     input_sync(dev);
     iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
      if (OwnADC) 
      	{
         OwnADC = 0;
         up(&ADC_LOCK);
        }
    }
}

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

/*申请触摸屏中断，对触摸屏按下或提笔时触发*/
static irqreturn_t stylus_updown(int irq, void *dev_id)
{
  unsigned long data0;
  unsigned long data1;
  int updown;
  if (down_trylock(&ADC_LOCK) == 0) 
  	{
     OwnADC = 1;
     data0 = ioread32(base_addr+S3C2410_ADCDAT0);
     data1 = ioread32(base_addr+S3C2410_ADCDAT1);
     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));
     if (updown) 
     	{
       touch_timer_fire(0);//这是一个定时器函数，当然在这里是作为普通函数调用，用来启动ADC
      } 
      else 
      {
       OwnADC = 0;
       up(&ADC_LOCK);
      }
    }
  return IRQ_HANDLED;
}

static irqreturn_t stylus_action(int irq, void *dev_id)
{
  unsigned long data0;
  unsigned long data1;
  if (OwnADC) 
  	{
     data0 = ioread32(base_addr+S3C2410_ADCDAT0);
     data1 = ioread32(base_addr+S3C2410_ADCDAT1);
     xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
     yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
     count++;
     if (count < (1<<2)) 
     	{
       iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST,base_addr+S3C2410_ADCTSC);
       iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START,
        base_addr+S3C2410_ADCCON);
      } 
      else 
      {
       mod_timer(&touch_timer, jiffies+1);
       iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC);//开始检测松开中断
      }
    }
  return IRQ_HANDLED;
}

static struct clk *adc_clock;

static int __init s3c2410ts_init(void)
{
  struct input_dev *input_dev;
   /*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
    系统的一些时钟定义在arch/arm/plat-s3c24xx/s3c2410-clock.c中*/    
  adc_clock = clk_get(NULL, "adc");
  if (!adc_clock) 
  	{
     printk(KERN_ERR "failed to get adc clock source\n");
     return -ENOENT;
    }
  /*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
  clk_enable(adc_clock);
  /*将ADC的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中。
     注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作,
     S3C2410_PA_ADC是ADC控制器的基地址，定义在mach-s3c2410/include/mach/map.h中，0x20是虚拟地址长度大小*/  
  base_addr=ioremap(S3C2410_PA_ADC,0x20);
  if (base_addr == NULL) 
  	{
     printk(KERN_ERR "Failed to remap register block\n");
     return -ENOMEM;
    }
  /* Configure GPIOs */
  s3c2410_ts_connect();
  iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF),\
   base_addr+S3C2410_ADCCON);                      //使能预分频和设置分频系数
  iowrite32(0xffff, base_addr+S3C2410_ADCDLY);     //设置ADC 延时，在等待中断
  iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);//按照等待中断的模式设置TSC
  /* Initialise input stuff */
  //allocate memory for new input device,用来给输入设备分配空间，并做一些输入设备通用的初始的设
  //置
  input_dev = input_allocate_device();//返回的是1个input_dev的结构体，此结构体用于表征1个输入设备。
  if (!input_dev) 
  	{
     printk(KERN_ERR "Unable to allocate the input device !!\n");
     return -ENOMEM;
    }
  dev = input_dev;
  dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
  dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);
  input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0);
  input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0);
  input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0);
  dev->name = s3c2410ts_name;
  dev->id.bustype = BUS_RS232;
  dev->id.vendor = 0xDEAD;
  dev->id.product = 0xBEEF;
  dev->id.version = S3C2410TSVERSION;
  
  /* Get irqs */
  /*申请ADC中断，AD转换完成后触发。这里使用共享中断IRQF_SHARED是因为该中断号在ADC驱动中也使用了，
    最后一个参数1是随便给的一个值，因为如果不给值设为NULL的话，中断就申请不成功*/
  if (request_irq(IRQ_ADC, stylus_action, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
   "s3c2410_action", dev)) 
   {
    printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_ADC !\n");
    iounmap(base_addr);
    return -EIO;
   }
  /*申请触摸屏中断，对触摸屏按下或提笔时触发*/
   if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
   "s3c2410_action", dev)) 
   {
    printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_TC !\n");
    iounmap(base_addr);
    return -EIO;
   }
  printk(KERN_INFO "%s successfully loaded\n", s3c2410ts_name);
 /* All went ok, so register to the input system */
  input_register_device(dev);
  return 0;
}

static void __exit s3c2410ts_exit(void)
{
  disable_irq(IRQ_ADC);
  disable_irq(IRQ_TC);
  free_irq(IRQ_TC,dev);
  free_irq(IRQ_ADC,dev);
  if (adc_clock) 
  	{
     clk_disable(adc_clock);
     clk_put(adc_clock);
     adc_clock = NULL;
   }
  input_unregister_device(dev);
  iounmap(base_addr);
}

module_init(s3c2410ts_init);
module_exit(s3c2410ts_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("MyARM Inc.");

 

 

一、字符设备(char device)
extern int register_chrdev(unsigned int, const char *,struct file_operations *);//int为0时候动态注册，非零时候静态注册。
extern int register_chrdev_region(dev_t, unsigned, const char *);               //静态的申请和注册设备号
extern int alloc_chrdev_region(dev_t, unsigned, const char *);                  //动态的申请注册一个设备号
extern int unregister_chrdev(unsigned int, const char *);
extern void unregister_chrdev_region(dev_t, unsigned);

使用register_chrdev_region()首先需要定义一个dev_t变量来作为一个设备号，dev_t   dev_num;
如果想静态申请，那么dev_num=MKDEV(major_no,0);major是一个表示设备号的变量
然后便可以用register_chrdev_region（dev_num,2,"my_dev"）;第二个参数表示注册的此设备数目，第三个表示驱动名
如果要动态的注册主设备号，使用下面
alloc_chrdev_region(&dev_num, 0, 2, "memdev"); //次设备号从0开始,注册两个设备，设备名是Memdev
    mem_major = MAJOR(devno);  //取出主设备号保存在mem_major中
前面只是注册了设备号，后面要向内核添加设备了。


使用注册字符设备驱动程序时，如果有多个设备使用该函数注册驱动程序，LED_MAJOR不能相同，否则几个设备都无法注册(
我已验证)。如果模块使用该方式注册并且LED_MAJOR为0(自动分配主设备号)，使用insmod
命令加载模块时会在终端显示分配的主设备号和次设备号，在/dev目录下建立该节点，比
如设备leds，如果加载该模块时分配的主设备号和次设备号为253和0，则建立节点:mknod leds c 253 0。
使用register_chrdev (LED_MAJOR,DEVICE_NAME,&dev_fops)注册字符设备驱动程序时都要手动建立节
点，否则在应用程序无法打开该设备。
其中，major是为设备驱动程序向系统申请的主设备号，如果为0则系统为此驱动程序动态地分配一个
主设备号。name是设备名。fops就是前面所说的对各个调用的入口点的说明。此函数返回0表示成功。
返回-EINVAL表示申请的主设备号非法，一般来说是主设备号大于系统所允许的最大设备号。返回-EBUSY
表示所申请的主设备号正在被其它设备驱动程序使用。如果是动态分配主设备号成功，此函数将返回所
分配的主设备号。如果register_chrdev操作成功，设备名就会出现在/proc/devices文件里。
在成功的向系统注册了设备驱动程序后(调用register_chrdev()成功后)，就可以用mknod命令来把设
备映射为一个特别文件，其它程序使用这个设备的时候，只要对此特别文件进行操作就行了。

 

二、杂项设备(misc device)
杂项设备也是在嵌入式系统中用得比较多的一种设备驱动。在 Linux 内核的include\linux\miscdevice.h
文件，要把自己定义的misc device从设备定义在这里。其实是因为这些字符设备不符合预
先确定的字符设备范畴，所有这些设备采用主设备号10 ，一起归于misc device，其实
misc_register就是用主设备号10调用register_chrdev()的。也就是说，misc设备其实
也就是特殊的字符设备。
misc_device是特殊的字符设备。注册驱动程序时采用misc_register函数注册，此函数
中会自动创建设备节点，即设备文件。无需mknod指令创建设备文件。因为misc_register()
会调用class_device_create()或者device_create()。
struct miscdevice  {
    int minor;
    const char *name;
    struct file_operations *fops;
    struct list_head list;
    struct device *dev;
    struct class_device *class;
    char devfs_name[64];
};

三、Input driver编写要点
1、分配、注册、注销input设备
 struct input_dev;
 struct input_dev *input_allocate_device(void);
 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);
 void input_register_device(struct input_dev *);
 void input_unregister_device(struct input_dev *);
 void input_register_handler(struct input_handler *);
 void input_unregister_handler(struct input_handler *);
 
struct input_dev {
  void *private;
  int number;
  char *name;
  unsigned short idbus;
  unsigned short idvendor;
  unsigned short idproduct;
  unsigned short idversion;

  unsigned long evbit[NBITS(EV_MAX)];
  unsigned long keybit[NBITS(KEY_MAX)];
  unsigned long relbit[NBITS(REL_MAX)];
  unsigned long absbit[NBITS(ABS_MAX)];
  unsigned long mscbit[NBITS(MSC_MAX)];
  unsigned long ledbit[NBITS(LED_MAX)];
  unsigned long sndbit[NBITS(SND_MAX)];
  unsigned long ffbit[NBITS(FF_MAX)];
  int ff_effects_max;

  unsigned int keycodemax;
  unsigned int keycodesize;
  void *keycode;

  unsigned int repeat_key;
  struct timer_list timer;

  int abs[ABS_MAX + 1];
  int rep[REP_MAX + 1];

  unsigned long key[NBITS(KEY_MAX)];
  unsigned long led[NBITS(LED_MAX)];
  unsigned long snd[NBITS(SND_MAX)];

  int absmax[ABS_MAX + 1];
  int absmin[ABS_MAX + 1];
  int absfuzz[ABS_MAX + 1];
  int absflat[ABS_MAX + 1];

  int (*open)(struct input_dev *dev);
  void (*close)(struct input_dev *dev);
  int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
  int (*upload_effect)(struct input_dev *dev, struct ff_effect *effect);
  int (*erase_effect)(struct input_dev *dev, int effect_id);

  struct input_handle *handle;
  struct input_dev *next;
};

定义按键：
  EV_KEY：Keys and buttons（按键与按钮）。
  EV_REL：Relative axes（相对坐标）。
  EV_ABS：Absolute axes（绝对坐标）。
  EV_MSC：Misc events（其它事件）。
  EV_LED：LEDs。
  EV_SND：Sounds（声音输入）。
  EV_REP：Autorepeat values（自动重复数值）。
  EV_FF：Force feedback事件。

Report 按键：
使用者的按键往上层回报所使用的API如下：
  input_report_key(struct input_dev *dev, unsigned int code, int value);
  input_report_rel(struct input_dev *dev, unsigned int code, int value);
  input_report_abs(struct input_dev *dev, unsigned int code, int value);


四、time_list结构体位于内核文件include/linux/timer.h

struct timer_list {
 struct list_head entry; //timer_list结构体链表的头部
 unsigned long expires; //用于存放延时结束时间  
 void (*function)(unsigned long); //延时结束时执行的回调函数，注意这里传递一个无符号长整型数字 
 unsigned long data;  //常用于存储数据的指针 
 struct tvec_base *base;
#ifdef CONFIG_TIMER_STATS
 void *start_site; 
 char start_comm[16]; 
 int start_pid;  
#endif
};

void init_timer(struct timer_list *timer);
static inline void add_timer(struct timer_list *timer);
int del_timer(struct timer_list *timer); 

当一个定时器已经被插入到内核动态定时器链表中后，我们还可以修改该定时器的expires值。函数mod_timer()实现这一点
修改注册入计时器列表的handler的起动时间
int mod_timer(struct timer_list *timer, unsigned long expires)
{
  int ret;
  unsigned long flags;
  spin_lock_irqsave(&timerlist_lock, flags);
  timer->expires = expires;
  ret = detach_timer(timer);
  internal_add_timer(timer);
  spin_unlock_irqrestore(&timerlist_lock, flags);
  return ret;
}

信号量
一．信号量的实现
实际的信号量可以通过以下几种方法来声明和初始化
1.       直接创建信号量，通过 sema_init 完成
Void sema_init (struct semaphore *sem , int val);
其中val是赋予信号量的初始值。
2.       也可以用 DECLARE_MUTEX、DECLARE_MUTEX_LOCKED
DECLARE_MUTEX(name)、初始化为1
DECLARE_MUTEX_LOCKED(name) 初始化为0
3.       如果互斥体必须在运行时被初始化（例如在动态分配互斥体的情况下）应该使用下面的情况之一。
a)         Void init_MUTEX(struct semaphore *sem);
b)        Void init_MUTEX_LOCKED(struct semaphore *sem);
4.       up和down操作
up(struct semaphore *sem);
void down(struct semaphore *sem);
int down_interruptible(struct semaphore *sem);
int down_trylock(struct semaphore *sem);
信号量会让调用者进入休眠状态，down_interruptible(struct semaphore *sem);是可以中断的，使用down_interruptible(struct semaphore *sem)需要格外的小心，如果操作被中断，该函数会返回非零值，而调用者不会拥有该信号量，使用时需要始终检查返回值，并作出相应的响应。而int down_trylock(struct semaphore *sem);永远不会休眠，如果信号量在调用的时候不可获得，down_trylock(struct semaphore *sem)会立即返回一个非零值。

二．信号量的使用
1.       DECLARE_MUTEX(name)；//1 例子摘自linux2.6.14 driver/i2c/i2c-core.c
static DECLARE_MUTEX(core_lists);
down(&core_lists);
……..
……..保护的内容
……..
up(&core_lists);
2.       DECLARE_MUTEX_LOCKED(name) 初始化为0//driver/scsi/cpqfcTSworkor.c
DECLARE_MUTEX_LOCKED(fcQueReady);
down_interruptible( &fcQueReady); // wait for something to do
……
……
……
up( &fcQueReady );
           没有明白初始化为0后，为什么又要down_interruptible( &fcQueReady)，那这个操作不是不能操作吗？得不到信号量吗？又没有地方释放，那不是一直在哪里等啊？
3.       通过init_MUTEX 来初始化。
先定义一个信号量：
        Struct semaphore sem;
初始化这个信号另：
        Init_MUTEX(&sem);
现在就可以使用了：
Down(&sem);
……
……
……
Up(&sem);
NOTE:
在使用down操作的时候都可以针对情况选：
void down(struct semaphore *sem);int down_interruptible(struct semaphore *sem);
int down_trylock(struct semaphore *sem);中的一种。
自选锁
一，              自旋锁可在不能休眠的代码中使用，比如在终端处理例程中。通常自旋锁能提供比信号量更高的性能。<linux/spinlock.h>,
自旋锁的基本使用如下：
spinlock_t myr_lock = SPIN_LOCK_UNLOCKED;
//也可在运行的时候初始化
//spin_lock_init(spinlock_t &myr_lock)
spin_lock(&myr_lock);
/*临界区*/
spin_unlock(&myr_lock);
所有自旋锁等待在本质上都是不可中断的，一旦调用了spin_locd,在获得自旋锁之前都是出于自旋状态。

 


 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值