S5pc100 触摸屏驱动分析（linux 2.6.35.13内核） -liaoye学习笔记，方便日后复习
我是根据 s3c2410_ts.c驱动文件来移植该驱动的。
这个驱动是基于input子系统来编写的，所有首先需要分析input子系统
Input子系统分为三层
事件处理层
核心层
设备驱动层
其中 evdev.c是万能驱动，能支持所有的设备
Input.c 输入设备子系统核心与上下层api
S3c2410ts.c、usbmouse.c usbkbd.c等等是一些设备的驱动，直接来获取硬件的状态，让后上报给子系统
具体列出三个最主要的结构体：
一、input子系统最核心的结构体：
struct input_dev {
const char *name;
const char *phys;
const char *uniq;
struct input_id id;
//支持事件码位图
unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //事件位图
unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //键码~
unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
unsigned int keycodemax; //码表最大索引
unsigned int keycodesize; //一个码字节尺寸
void *keycode; //扫描码=>键码映射表，数组
int (*setkeycode)(struct input_dev *dev, int scancode, int keycode); //系统有默认，可替换
int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode); //系统有默认，可替换
struct ff_device *ff; //力反馈输入设备
unsigned int repeat_key; //最后一次的重复键码
struct timer_list timer; //软件 autorepeat的timer
int sync; //事件报告同步标志,
//发生事件记录暂存
int abs[ABS_MAX + 1];
int rep[REP_MAX + 1];
unsigned long key[BITS_TO_LONGS(KEY_CNT)];
unsigned long led[BITS_TO_LONGS(LED_CNT)];
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
unsigned long sw[BITS_TO_LONGS(SW_CNT)];
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 (*flush)(struct input_dev *dev, struct file *file); //可选
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); //可选
//事件由设备处理
struct input_handle *grab; //会话(RCU)
spinlock_t event_lock;
struct mutex mutex;
unsigned int users; //用户使用计数
int going_away; //设备移开？
struct device dev;
struct list_head h_list; // input_handle链头 (RCU)
struct list_head node; //全局 input_dev_list 设备链节点
};
二、input_handler
输入设备处理驱动(相当于虚拟主机或总线) 描述
struct input_handler {
void *private; //驱动特定数据
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);//事件由handler处理,(主要是暂存,传递给用户层处理) ,必须
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id); //连接设备,probe ,必须
void (*disconnect)(struct input_handle *handle); //断开设备,shutdown,必须
void (*start)(struct input_handle *handle); //可选
const struct file_operations *fops; //子类 文件系统操作(核心)
int minor; //确定在input_table[8]的位置,是32的倍数,须唯一
const char *name; //命名, 显示在/proc/bus/input/handlers下
const struct input_device_id *id_table; //可以probe 设备id列表
const struct input_device_id *blacklist; //黑名单设备id列表，过滤
struct list_head h_list; // input_handle链头
struct list_head node; //全局 input_handler链节点
};
三、input_handle
输入设备描述 input_dev 与驱动描述input_handler的连接，相当于会话连接
struct input_handle {
void *private; //驱动特定数据
int open; //打开计数
const char *name; //会话命名
struct input_dev *dev; //所在设备
struct input_handler *handler; //所在驱动描述
struct list_head d_node; // input_dev. h_list链节点，同一设备多次会话 (RCU)
struct list_head h_node; // input_handler.h_list 链节点
};
Input.c分析
先看input的入口和出口
static int __init input_init(void)
{
int err;
err = class_register(&input_class);
//向内核注册一个类，用于linux设备模型，注册后会在/sys/class/下面出现input目录
if (err) {
pr_err("unable to register input_dev class\n");
return err;
}
err = input_proc_init();//与proc文件系统有关
if (err)
goto fail1;
/*注册字符设备，主设备号为13表示input设备,可以在/proc/devices下看到*/
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (err) {
pr_err("unable to register char major %d", INPUT_MAJOR);
goto fail2;
}
return 0;
fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
在注册input的时候绑定的操作函数集
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file, //取出handler，调用底层open
};
static int input_open_file(struct inode *inode, struct file *file)
这个函数只要是得到handler的操作函数集，如果获得成功，使用新的操作函数集代替旧的，并调用新函数集的open函数。
struct input_handler *handler; //定义一个处理函数，以便待会儿使用
//旧file_operations接口，新file_operations接口
const struct file_operations *old_fops, *new_fops = NULL;
/* No load-on-demand here? */
handler = input_table[iminor(inode) >> 5];
//获得handler，因为每个注册的handler都会把自己注册到input_table这个数组里，下标右移5位表示除以32，因为每个handler最大可以处理32个设备，所以是以32为倍数对齐
if (handler)
new_fops = fops_get(handler->fops);//获得handler的操作函数集
old_fops = file->f_op;
file->f_op = new_fops;
/*调用新的操作方法 然后将handler中的fops替换掉当前的fops.如果新的fops中有open() 函数，则调用它*/
err = new_fops->open(inode, file);
驱动、设备（handler和device）匹配追踪：
设备加载时调用 input_register_device函数向input子系统注册
驱动加载时调用 input_register_handler函数向input子系统注册
下面分析这两个函数：
int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);//原子变量，代表总共注册的input设备，每注册一个加1，由于是静态变量，每次调用都不会清零
struct input_handler *handler;
const char *path;
int error;
/* Every input device generates EV_SYN/SYN_REPORT events. */
__set_bit(EV_SYN, dev->evbit);//EV_SYN这个是所有设备要支持的事件类型，所以要设置
/* KEY_RESERVED is not supposed to be transmitted to userspace. */
__clear_bit(KEY_RESERVED, dev->keybit);//KEY_RESERVED（版权）不应该传到用户空间
/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
input_cleanse_bitmasks(dev);//确保dev->evbit被清零是不介意的
if (!dev->hint_events_per_packet)
dev->hint_events_per_packet =
input_estimate_events_per_packet(dev);
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);//为了重复按键设置内核定时器
/*初始化内核定时器，如果没有定义相关重复按键值，使用默认值*/
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
/*如果没有dev->getkeycode和dev->setkeycode使用由input提供的默认函数*/
if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
/*设置input_dev中device的名字，名字将在/class/input/中出现*/
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1);
error = device_add(&dev->dev);//将device加到linux设备模型中
if (error)
return error;
/*得到device的路径*/
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
pr_info("%s as %s\n",
dev->name ? dev->name : "Unspecified device",
path ? path : "N/A");
kfree(path);
error = mutex_lock_interruptible(&input_mutex);//上锁
if (error) {
device_del(&dev->dev);
return error;
}
list_add_tail(&dev->node, &input_dev_list);//将device的节点加到input_dev_list链表上
/*遍历input_handler_list链表，配对input_dev和input_handler*/
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
return 0;
}
EXPORT_SYMBOL(input_register_device);
在注册input_dev主要完成嘞一些初始化设置，然后调用 input_attach_handler来匹配input_dev和input_handler.
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;
}
list_add_tail(&handler->node, &input_handler_list);
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
out:
mutex_unlock(&input_mutex);
return retval;
}
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
/*主要的配对函数，主要比较ID中的各项*/
id = input_match_device(handler, dev);
if (!id)
return -ENODEV;
/*配对成功调用 handler->connect函数，在事件处理器中定义，主要生成input_handle结构，并初始化，还生成一个事件处理器相关的结构*/
error = handler->connect(handler, dev, id);
if (error && error != -ENODEV)
pr_err("failed to attach handler %s to device %s, error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
匹配首先调用了 input_match_device，在匹配成功以后调用了handler的connect函数
static const struct input_device_id *input_match_device(struct input_handler *handler,
struct input_dev *dev)
{
const struct input_device_id *id;
int i;
/*遍历传入的handler->id_table，寻找合适的ID进行配对*/
for (id = handler->id_table; id->flags || id->driver_info; id++) {
/*根据flags来，来筛选出同种类型的ID，否者进入下一个ID*/
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
if (id->bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->vendor != dev->id.vendor)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;
MATCH_BIT(evbit, EV_MAX);
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
MATCH_BIT(swbit, SW_MAX);
if (!handler->match || handler->match(handler, dev))
return id;
}
return NULL;
}
这个函数主要从handler->id_table中找出和input_dev同种类型的input_handler，然后比较支持的事件，最后看handler是否提供了match函数，提供了就调用handler的match进行匹配，没有提供直接返回同类型的id.
#define MATCH_BIT(bit, max) \
for (i = 0; i < BITS_TO_LONGS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != BITS_TO_LONGS(max)) \
continue;
这个可以看出这里是按位比较，比较成功，进入下一个MATCH_BIT比较下一个事件类型，否则进行下一个ID的比较。对于触摸屏来说对应的事件处理器为evdev，在evdev事件处理器中没有提供match函数，所以只要flag和事件类型都匹配成功，就会返回这个handler的id。当然evdev提供了connect函数evdev_connect
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
struct evdev *evdev;
int minor;
int error;
/*由于EVDEV_MINORS等于32，说明evdev可以同时有32个设备和它配对，evdev_table的下标minor并不是次设备号*/
for (minor = 0; minor < EVDEV_MINORS; minor++)
if (!evdev_table[minor])
break;
/*说明32个设备全部被占用了，链接失败*/
if (minor == EVDEV_MINORS) {
pr_err("no more free evdev devices\n");
return -ENFILE;
}
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
if (!evdev)
return -ENOMEM;
INIT_LIST_HEAD(&evdev->client_list);
spin_lock_init(&evdev->client_lock);
mutex_init(&evdev->mutex);
init_waitqueue_head(&evdev->wait);
/* 设置evdev中device的名字，它也将出现在/class/input/下，但是他和input_dev下面的device是有区别的，
* evdev配对以后的虚拟设备结构，没有对应的硬件，但是可以通过它找到相应的硬件*/
dev_set_name(&evdev->dev, "event%d", minor);
evdev->exist = true;
evdev->minor = minor;
evdev->handle.dev = input_get_device(dev);
evdev->handle.name = dev_name(&evdev->dev);
evdev->handle.handler = handler;
evdev->handle.private = evdev;
evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);//minor不是真正的次设备号，还要加上EVDEV_MINOR_BASE
evdev->dev.class = &input_class;
evdev->dev.parent = &dev->dev;//配对生成新的device，父设备是与他相关联的input_dev
evdev->dev.release = evdev_free;
device_initialize(&evdev->dev);
error = input_register_handle(&evdev->handle);//注册handle结构体
if (error)
goto err_free_evdev;
error = evdev_install_chrdev(evdev);//把evdev结构保存到evdev_table中，这个数组以minor为索引
if (error)
goto err_unregister_handle;
error = device_add(&evdev->dev);//将evdev下面的device注册到linux设备模型中
if (error)
goto err_cleanup_evdev;
return 0;
err_cleanup_evdev:
evdev_cleanup(evdev);
err_unregister_handle:
input_unregister_handle(&evdev->handle);
err_free_evdev:
put_device(&evdev->dev);
return error;
}
connect函数evdev的分配和初始化，保存到evdev_table数组中，并注册一个handle。
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error;
/*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error;
/*
* Filters go to the head of the list, normal handlers
* to the tail.
*/
if (handler->filter)
list_add_rcu(&handle->d_node, &dev->h_list);//将handle的d_node链接到相关input_dev的h_list链表中
else
list_add_tail_rcu(&handle->d_node, &dev->h_list);
mutex_unlock(&dev->mutex);
/*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
list_add_tail_rcu(&handle->h_node, &handler->h_list);//将handle的h_node链接到其相关的input_handler的h_list链表中
if (handler->start)
handler->start(handle);
return 0;
}
EXPORT_SYMBOL(input_register_handle);
从上面可以看出，connect调用input_register_handle主要就是通过handle充当桥梁，建立input_dev和input_handler的关联。
input_handler的注册，一般事件处理层入口处注册input_handler,比如evdev事件处理器
static int __init evdev_init(void)
{
/*将evdev_handler注册到系统中*/
return input_register_handler(&evdev_handler);
}
static void __exit evdev_exit(void)
{
input_unregister_handler(&evdev_handler);
}
module_init(evdev_init);
module_exit(evdev_exit);
input_handler的注册有什么作用呢？
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;
INIT_LIST_HEAD(&handler->h_list);
/*每次注册一个handler都会将其保存到input_table，这里索引值等于handler->minor左移5位，也就是除以32
* 因为每个handler最多可以处理32个input_dev设备，所以要以32为对齐minor是传进来的handler的MINOR_BASE*/
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;
}
list_add_tail(&handler->node, &input_handler_list);//将handler连接到input_handler_list链表中
/*遍历input_dev链表，开始匹配*/
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
out:
mutex_unlock(&input_mutex);
return retval;
}
EXPORT_SYMBOL(input_register_handler);
从上面的代码可以看出注册handler主要完成两件事，首先将handler链接到input_handler_list链表，然后匹配input_dev和input_handler.在注册input_dev的时候需要匹配input_dev和input_handler，是遍历的handler的链表，表示从device来找handler。在注册input_handler的时候也需要匹配input_dev和input_handler，但是是遍历的dev的链表，表示是从handler来找device。
触摸屏驱动分析：
主要涉及文件：
S3c2410_ts.c //控制器驱动
Adc.c //坐标AD转换
Evdev.c //事件处理
触摸屏工作流程：
(1)如果触摸屏感觉到触摸，则触发触摸屏中断即进入tc_irq，
获取ADC_LOCK后判断触摸屏状态为按下，
则调用touch_timer_fire启动ADC转换；
(2)当ADC转换启动后，触发ADC中断即进入adc_irq，
如果这一次转换的次数小于4，则重新启动ADC进行转换，
如果4次完毕后，启动1个时间滴答的定时器，停止ADC转换，
也就是说在这个时间滴答内，ADC转换是停止的；
(3)这里为什么要在1个时间滴答到来之前停止ADC的转换呢？这是为了防止屏幕抖动。
(4)如果1个时间滴答到来则进入定时器服务程序touch_timer_fire，
判断触摸屏仍然处于按下状态则上报事件和转换的数据，并重启ADC转换，重复第(2)步；
(5)如果触摸抬起了，则上报释放事件，
并将触摸屏重新设置为等待中断状态。
触摸屏采样程序
当触笔按下时，就开始进行触摸屏触摸坐标的采样，同时打开定时中断，为10ms后的定时器中断做好准备。下面是采样过程：
⑴通过对ADC控制寄存器ADCCON和ADC触摸屏控制寄存ADCTSC的设置，启动自动测量X坐标和Y坐标。
⑵等待AD转换完成，通过对ADCCON的ECFLG的访问可以判断AD转换完成与否。
⑶ AD转换完成后，就通过对ADC转换数据寄存器ADCDAT0和ADCDAT1的读取触摸屏坐标的Y坐标和X坐标值。
⑷回到第一步，连续取得5组数据，求和并计算其平均值，
如果平均值和这5组数据中最近一次数据的差值大于我们规定的阈值
(这个阈值应该需要根据我们采用的LCD屏的分辨率来决定)时，认为此次采样值无效，
同时对修改寄存器ADCTSC的设置，让其处于等待中断模式，为下次中断(触笔抬起中断做好准备)。
S3c2410_ts.c分析
/*定义一个关于触摸屏的平台驱动结构体*/
static struct platform_driver s3c_ts_driver = {
.driver = {
.name = "samsung-ts",
.owner = THIS_MODULE,
#ifdef CONFIG_PM
.pm = &s3c_ts_pmops,
#endif
},
.id_table = s3cts_driver_ids,
.probe = s3c2410ts_probe, //当相应驱动加载时调用
.remove = __devexit_p(s3c2410ts_remove),
};
/*初始化驱动时候将该结构体加入至平台虚拟总线platform_bus_type*/
static int __init s3c2410ts_init(void)
{
return platform_driver_register(&s3c_ts_driver);
}
static int __devinit s3c2410ts_probe
struct s3c2410_ts_mach_info *info;
struct device *dev = &pdev->dev;
struct input_dev *input_dev;
struct resource *res;
info = pdev->dev.platform_data; //获取平台数据
/*ADC时钟获取和启动*/
ts.clock = clk_get(dev, "adc");
clk_enable(ts.clock);
/*获取TC中断*/
ts.irq_tc = ret = platform_get_irq(pdev, 0);
/*获取平台资源*/
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
/*映射IO资源*/
ts.io = ioremap(res->start, resource_size(res));
/* inititalise the gpio */
if (info->cfg_gpio)
info->cfg_gpio(to_platform_device(ts.dev));
/*注册adc*/
ts.client = s3c_adc_register(pdev, s3c24xx_ts_select,
s3c24xx_ts_conversion, 1);
/* Initialise registers */
if ((info->delay & 0xffff) > 0)
writel(info->delay & 0xffff, ts.io + S3C2410_ADCDLY);
/*分配一个input_dev结构体*/
input_dev = input_allocate_device();
ts.input = input_dev; //放入TS结构体
//设置支持的事件，按键和绝对位移
ts.input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
//按键类事件的触摸事件的支持
ts.input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
//设置绝对位移的参数，X轴、Y轴和按压三个方向
input_set_abs_params(ts.input, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.input, ABS_Y, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.input,ABS_PRESSURE,0,1,0,0);
//次要的设置
ts.input->name = "S3C24XX TouchScreen";
ts.input->id.bustype = BUS_HOST;
ts.input->id.vendor = 0xDEAD;
ts.input->id.product = 0xBEEF;
ts.input->id.version = 0x0102;
//注册中断
ret = request_irq(ts.irq_tc, stylus_irq, IRQF_DISABLED,
"s3c2410_ts_pen", ts.input);
//所有设置完毕，注册input结构体
/* All went ok, so register to the input system */
ret = input_register_device(ts.input);
触摸屏中断产生以及AD转换，上报事件的过程：
当我们按下触摸屏时：
1，首先进入触摸屏中断，RQ_TC
2，如果触摸屏是被按下的状态，则调用touch_timer_fire启动ADC中断adc_irq
3，如果1个时间滴答到来则进入定时器服务程序touch_timer_fire
4，判断触摸屏是否仍然处于按下状态
5，如果是，则上报事件和转换的数据，并重启ADC转换，重复第(2)步
6，如果不是（松开），则上报事件和转换的数据，本次转换完成
函数追踪：
/*触摸屏中断服务程序*/
static irqreturn_t stylus_irq(int irq, void *dev_id)
{
//printk("stylus_irq\n");
/*用于记录这一次AD转换后的值*/
unsigned long data0;
unsigned long data1;
bool down;
/*本次读取时为了判断，还有获取坐标 */
data0 = readl(ts.io + S3C2410_ADCDAT0);
data1 = readl(ts.io + S3C2410_ADCDAT1);
/*在等待中断的时候，获取触摸屏按下的状态*/
down = get_down(data0, data1);
/* TODO we should never get an interrupt with down set while
* the timer is running, but maybe we ought to verify that the
* timer isn't running anyways. */
/*如果触摸屏被按下，则启动ADC*/
if (down)
s3c_adc_start(ts.client, 0, 1 << ts.shift);
else/*如果是抬起状态，就结束了这一次的操作，所以就释放ADC资源的占有*/
dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count);
if (ts.features & FEAT_PEN_IRQ) {
/* Clear pen down/up interrupt 清中断*/
writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP);
}
return IRQ_HANDLED;
}
/*定时器中断服务程序*/
/*如果是按下状态，则调用touch_timer_fire函数来启动ADC转换*/
static void touch_timer_fire(unsigned long data)
{
//printk("touch_timer_fire\n");
/*用于记录这一次AD转换后的值*/
unsigned long data0;
unsigned long data1;
bool down;
/*本次读取时只为了判断是否还是按下状态 */
data0 = readl(ts.io + S3C2410_ADCDAT0);
data1 = readl(ts.io + S3C2410_ADCDAT1);
down = get_down(data0, data1);
if (down) {
if (ts.count == (1 << ts.shift)) {
ts.xp >>= ts.shift;
ts.yp >>= ts.shift;
dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n",
__func__, ts.xp, ts.yp, ts.count);
/*报告X、Y的绝对坐标值*/
input_report_abs(ts.input, ABS_X, ts.xp);
input_report_abs(ts.input, ABS_Y, ts.yp);
/*报告按键事件，键值为1(代表触摸屏对应的按键被按下)*/
input_report_key(ts.input, BTN_TOUCH, 1);
/*报告触摸屏的状态，1表明触摸屏被按下*/
input_report_abs(ts.input,ABS_PRESSURE,1);
/*等待接收方受到数据后回复确认，用于同步*/
input_sync(ts.input);
ts.xp = 0;
ts.yp = 0;
ts.count = 0;
}
/*如果状态还是按下，并且ADC还没有开始转换就启动ADC进行转换*/
s3c_adc_start(ts.client, 0, 1 << ts.shift);
} else {
ts.xp = 0;
ts.yp = 0;
ts.count = 0;
/*报告按键事件，键值为0(代表触摸屏对应的按键被释放)*/
input_report_key(ts.input, BTN_TOUCH, 0);
/*报告触摸屏的状态，0表明触摸屏没被按下*/
input_report_abs(ts.input,ABS_PRESSURE,0);
/*等待接收方收到数据后回复确认，用于同步*/
input_sync(ts.input);
/*将触摸屏重新设置为等待中断状态*/
writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC);
}
}
int s3c_adc_start(struct s3c_adc_client *client,
unsigned int channel, unsigned int nr_samples)
{
//printk("adc_start..............\n");
struct adc_device *adc = adc_dev;
unsigned long flags;
if (!adc) {
printk(KERN_ERR "%s: failed to find adc\n", __func__);
return -EINVAL;
}
if (client->is_ts && adc->ts_pend)
return -EAGAIN;
/*获取自旋锁，关中断，并保存状态字*/
spin_lock_irqsave(&adc->lock, flags);
client->channel = channel;
client->nr_samples = nr_samples;
if (client->is_ts)
adc->ts_pend = client;
else
list_add_tail(&client->pend, &adc_pending); //插入链表末尾, 即 链表表头之前
if (!adc->cur)
s3c_adc_try(adc);
spin_unlock_irqrestore(&adc->lock, flags);
return 0;
}
/*开始转换*/
static void s3c_adc_try(struct adc_device *adc)
{
//printk("adc_try\n");
struct s3c_adc_client *next = adc->ts_pend;
/* 不为空*/
if (!next && !list_empty(&adc_pending)) {
next = list_first_entry(&adc_pending,
struct s3c_adc_client, pend);
list_del(&next->pend);
} else
adc->ts_pend = NULL; //若为空
if (next) {
adc_dbg(adc, "new client is %p\n", next); //调试信息
adc->cur = next;
s3c_adc_select(adc, next);
s3c_adc_convert(adc);
s3c_adc_dbgshow(adc);
}
}
/*设置并启动转换*/
static inline void s3c_adc_convert(struct adc_device *adc)
{
/*读取出ADCCON 数据然后使能转换位ADCCON [0] */
//printk("adc_convert..............\n");
unsigned con = readl(adc->regs + S3C2410_ADCCON);
con |= S3C2410_ADCCON_ENABLE_START;
writel(con, adc->regs + S3C2410_ADCCON); //启动adc转换，进入adc服务程序
}
/*ADC中断服务程序*/
static irqreturn_t s3c_adc_irq(int irq, void *pw)
{
//printk("adc_irqreturn_t..............\n");
struct adc_device *adc = pw;
struct s3c_adc_client *client = adc->cur;
enum s3c_cpu_type cpu = platform_get_device_id(adc->pdev)->driver_data;
unsigned data0, data1;
if (!client) {
dev_warn(&adc->pdev->dev, "%s: no adc pending\n", __func__);
goto exit;
}
data0 = readl(adc->regs + S3C2410_ADCDAT0);
data1 = readl(adc->regs + S3C2410_ADCDAT1);
adc_dbg(adc, "read %d: 0x%04x, 0x%04x\n", client->nr_samples, data0, data1);
/*进一次转换中断程序nr_samples 减一，总共转换四次*/
client->nr_samples--;
if (cpu == TYPE_S3C64XX) {
/* S3C64XX ADC resolution is 12-bit */
data0 &= 0xfff;
data1 &= 0xfff;
} else {
data0 &= 0x3ff;
data1 &= 0x3ff;
}
//printk("x_data:%d\n",data0);
//printk("y_data:%d\n",data1);
if (client->convert_cb)
(client->convert_cb)(client, data0, data1, &client->nr_samples);
if (client->nr_samples > 0) { /*如果没有四次，则继续下一次转换*/
/* fire another conversion for this */
client->select_cb(client, 1);
s3c_adc_convert(adc);
} else {
/*获取自旋锁*/
spin_lock(&adc->lock);
(client->select_cb)(client, 0); /*否则启动定时器*/
adc->cur = NULL;
s3c_adc_try(adc);
spin_unlock(&adc->lock);
}
exit:
if (cpu == TYPE_S3C64XX) {
/* Clear ADC interrupt */
writel(0, adc->regs + S3C64XX_ADCCLRINT);
}
return IRQ_HANDLED;
}
1252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
