1、概述
Android 和PC系统本身是支持 usb hid输入设备的。不过由于业务的发展，需要采用高精度触摸框。重新设计框架，改变原来 串口+usb_hid的方式。采用俩路usb，一路usb_buik+一路usb_hid方式。具体架构如下图:
2、触摸驱动
该驱动是基于Android 8.0 内核 4.9版本上调试的。驱动主要从俩个方面去分析：1) USB 驱动框架 2)input 驱动
2.1 USB驱动框架
USB驱动基于Linux USB总线完成的。主要注册USB 设备和填充USB设备结构体相关信息。
static int __init usb_touch_init(void)
{
int retval = usb_register(&XX_driver); //注册usb driver到系统中
printk(KERN_ALERT "usb touch init\r\n");
if(retval)
printk(KERN_ALERT "usb touch init error %d\r\n",retval);
return retval;
}
static void __exit usb_touch_exit(void)
{
printk(KERN_ALERT "usb touch exit");
usb_deregister(&XX_driver);
}
module_init(usb_touch_init);
module_exit(usb_touch_exit);
Linux 内核驱动都是从init函数开始执行，相当于应用程序里面的main函数。在init函数中主要做了usb_register(),注册usb driver到
系统中。usb_register() 参数为struct usb_driver 结构。
static struct usb_driver XX_driver = {
.name = "XXXXXX", //usb driver name
.probe = XX_probe, //usb 匹配后执行probe
.disconnect = XX_disconnect, //usb 设备断开
.id_table = XX_id_table, // 用于usb 匹配信息
};
在usb_driver结构中重要的几个参数为 .probe 该函数用于usb 设备匹配正确后执行的。匹配规则后面会讲到 ,.disconnect该函数用于usb设备断开后执行的，主要做一些资源的释放。id_table 用于usb设备匹配信息，下面会讲。.name 用于usb driver name
static struct usb_device_id XX_id_table [] ={
{
.match_flags = USB_DEVICE_ID_MATCH_VENDOR,//匹配规则，根据vid pid 去匹配设备
.idVendor = XXXX,
.idProduct = XXXXX,
},
{
.match_flags = USB_DEVICE_ID_MATCH_VENDOR, //可以匹配多个usb设备
.idVendor = XXXXX,
.idProduct = XXXXX,
},
//{ USB_DEVICE(USB_TOUCH_VENDOR_ID, USB_TOUCH_PRODUCT_ID) },
{}
};
MODULE_DEVICE_TABLE (usb, XX_id_table );
usb _device_id 写明usb 设备与驱动匹配的规则，这里采用的 是根据vid pid去匹配。每个usb设备的pid vid都是唯一的，当然也可以根据class Subclass (设备描述符)去匹配usb 设备.同时一个usb 驱动可以匹配多个usb 设备。MODULE_DEVICE_TABLE 宏将你写好的匹配规则带入到系统中.
注意 usb_device_id XX_id_table 要与 usb_driver 中的.id_table 关联起来，系统才可以识别相关的usb 设备。
static int usb_touch_probe(struct usb_interface *intf,const struct usb_device_id *id)
{
//获取usb_device 通过结构体成员指针获取结构体首地址
struct usb_device *dev = interface_to_usbdev(intf);
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint_in=NULL,*endpoint_out;
//将接口描述符赋为当前接口
interface = intf->cur_altsetting;
//获取端点个数
endpoint_num=interface->desc.bNumEndpoints;
//申请touch 结构体空间
touch = kzalloc(sizeof(struct usb_touch), GFP_KERNEL);
//查找端点的属性，In端点还是Out端点
for(i=0;i<interface->desc.bNumEndpoints;i++){
if(!touch->input_ep && usb_endpoint_dir_in(&interface->endpoint[i].desc)){
endpoint_in=&interface->endpoint[i].desc;
touch->input_ep = interface->endpoint[i].desc.bEndpointAddress;
maxp= usb_maxpacket(dev, touch->input_ep, usb_pipeout(touch->input_ep));
printk(KERN_ALERT "In bDescriptorType -> %x bEndpointAddress -> %x bmAttributes -> %x wMaxPacketSize ->%x\r\n",
endpoint_in->bDescriptorType,endpoint_in->bEndpointAddress,endpoint_in->bmAttributes,endpoint_in->wMaxPacketSize);
}
if(!touch->output_ep && usb_endpoint_dir_out(&interface->endpoint[i].desc)){
endpoint_out=&interface->endpoint[i].desc;
touch->output_ep = interface->endpoint[i].desc.bEndpointAddress;
maxp= usb_maxpacket(dev, touch->output_ep, usb_pipeout(touch->output_ep));
printk(KERN_ALERT "Out bDescriptorType -> %x bEndpointAddress -> %x bmAttributes -> %x wMaxPacketSize ->%x\r\n",
endpoint_out->bDescriptorType,endpoint_out->bEndpointAddress,endpoint_out->bmAttributes,endpoint_out->wMaxPacketSize);
}
}
//申请data空间和buff空间
touch->data = usb_alloc_coherent(dev,512*20,GFP_KERNEL,&touch->data_dma);
touch->buff = kmalloc(512*20, GFP_ATOMIC);
if(!touch->data || !touch->buff)
goto fail1;
/*
* 为 urb 结构体申请内存空间，第一个参数表示等时传输时需要传送包的数量，其它传输方式则为0。
* 申请的内存将通过下面即将见到的 usb_fill_int_urb 函数进行填充。
*/
touch->irq = usb_alloc_urb(0,GFP_KERNEL);
if(!touch->irq)
goto fail2;
/* 填充 usb 设备结构体和输入设备结构体 */
touch->usbdev=dev;
touch->usb_touch_input_dev=input_dev;
/* 获取Usb_hid设备的名称 */
printk(KERN_ALERT "usb touch probe manufacturer %s\r\n",dev->manufacturer);
if(dev->manufacturer)
strlcpy(touch->name, dev->manufacturer, sizeof(touch->name));
printk(KERN_ALERT "usb touch probe touch->name %s\r\n",touch->name);
printk(KERN_ALERT "usb touch probe product %s\r\n",dev->product);
if (dev->product) {
if (dev->manufacturer)
strlcat(touch->name, " ", sizeof(touch->name));
strlcat(touch->name, dev->product, sizeof(touch->name));
printk(KERN_ALERT "usb touch probe touch->name22 %s\r\n",touch->name);
}
if (!strlen(touch->name))
snprintf(touch->name, sizeof(touch->name),
"XXXX touch %04x:%04x",
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
printk(KERN_ALERT "usb touch probe touch->name333 %s\r\n",touch->name);
//初始化一个buik_urb块用于异步传输数据
usb_fill_bulk_urb(touch->irq, dev, usb_rcvbulkpipe(dev, touch->input_ep), touch->data,
512*20,
usb_touch_irq, touch);
touch->irq->transfer_dma = touch->data_dma;//dma数据缓冲区指向设备的data_dma成员
touch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;// DMA 有效
//提交urb到系统中
retval = usb_submit_urb(touch->irq,GFP_KERNEL);
if (retval) {
printk(KERN_ALERT "retval %d\r\n",retval);
}
}
在probe函数主要是一些初始化，首先通过interface_to_usbdev函数获取到usb_dev.这种手法在内核中很常用。申请相关的结构体的空间，判断usb设备端点的属性和初始化一个urb用于传输数据。在初始化urb时 usb_fill_bulk_urb() 第六个参数是一个回调函数，当有数据是系统会调用这个函数。类似于中断函数。第五个参数是参数数据的buff。
static void usb_touch_irq(struct urb* urb)
{
//根据上下文可获取到usb_touch 结构体 urb的私有成员。不过在这里设置usb_touch为全局变量，
//struct usb_touch *touch = urb->context;
int status=0;
//判断urb 块传输数据的状态
switch (urb->status) {
case 0:
/*success */
break;
case -ECONNRESET: /* unlink */
case -ENOENT:
case -ESHUTDOWN:
printk(KERN_ALERT "ESHUTDOWN\r\n");
return;
/* -EPIPE: should clear the halt */
default: /* error */
goto resubmit;
}
//接收数据的长度
urb->actual_length;
//touch->data 接收的数据。
//urb 状态未知时，再次提交urb到系统中
resubmit:
status = usb_submit_urb (urb, GFP_ATOMIC);
if (status)
printk(KERN_ALERT "can't resubmit intr, %s-%s/input0, status %d",
touch->usbdev->bus->bus_name,
touch->usbdev->devpath, status);
}
在irq里判断urb的状态，然后就可以读到数据和数据的长度。
static void usb_touch_disconnect(struct usb_interface *intf)
{
struct usb_touch *touch = usb_get_intfdata (intf);
usb_set_intfdata(intf, NULL);
if (touch) {
usb_kill_urb(touch->irq);
usb_free_urb(touch->irq);
usb_free_coherent(interface_to_usbdev(intf), 512, touch->data, touch->data_dma);
kfree(touch);
}
}
在disconnect 中释放之前申请的资源。
2.2 input 部分
Input部分相对来讲会简单一些，在probe函数里面做相关初始化，在disconnect里面释放相关资源。然后再irq函数中拿到数据后上报数据给系统即可。Android系统本事的input子系统会识别相关的event 事件，触摸正常。
static int usb_touch_probe(struct usb_interface *intf,const struct usb_device_id *id)
{
struct input_dev *input_dev;
input_dev = input_allocate_device();//为input设备申请空间
/*
* 填充usb设备结构体中的节点名。usb_make_path 用来获取 USB 设备在 Sysfs 中的路径，格式
* 为：usb-usb 总线号-路径名。
*/
usb_make_path(dev, touch->phys, sizeof(touch->phys));
input_dev->name = touch->name;
input_dev->phys=touch->phys;
usb_to_input_id(dev, &input_dev->id);//设置输入设备的bustype,vendor,product,version
input_dev->dev.parent = &intf->dev;//usb接口设备为输入设备的父设备
//设备支持X Y ID 事件
//支持同步事件
set_bit(EV_SYN, input_dev->evbit);
//设置绝对坐标，触摸屏采用绝对坐标，鼠标采用相对坐标
set_bit(EV_ABS, input_dev->evbit);
//设置点击事件
set_bit(BTN_TOUCH, input_dev->keybit);
//设置压力
set_bit(ABS_MT_PRESSURE, input_dev->absbit);
//点的ID ,多钱根据ID区分
set_bit(ABS_MT_TRACKING_ID, input_dev->keybit);
//设置X 事件
set_bit(ABS_MT_POSITION_X, input_dev->absbit);
//设置Y事件
set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
//设置触摸笔的类型，粗细笔
set_bit(ABS_MT_TOOL_TYPE, input_dev->absbit);
//设置触摸屏设备
set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
//设置压力的范围
input_set_abs_params(input_dev, ABS_MT_PRESSURE,0,255,0,0);
//设置X Y坐标的范围
input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, 0x7fff, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, 0x7fff, 0, 0);
//设置多点的ID个数 10点
input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);
//设置面积的长宽
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
//设置粗细笔个数
input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,0, 3, 0, 0);
//关联input_dev与touch设备
input_set_drvdata(input_dev, touch);
//注册input驱动
input_register_device(touch->usb_touch_input_dev);
}
在probe中做相关的初始化，到此input相关已经初始化完成，在irq函数中直接上报函数即可。
for (i = 0; i < pointnum; i++) {
if (((data->points[i].mPresstype & 0x07) == 0x07)) {
input_report_abs(dev, ABS_MT_TRACKING_ID, data->points[i].mID);
input_report_abs(dev, ABS_MT_PRESSURE, 1);
input_report_key(dev, BTN_TOUCH,1);
input_report_abs(dev, ABS_MT_POSITION_X, data->points[i].mX);
input_report_abs(dev, ABS_MT_POSITION_Y, data->points[i].mY);
input_report_abs(dev, ABS_MT_TOUCH_MAJOR,max(data- >points[i].mWidth,data->points[i].mHeight));
input_report_abs(dev, ABS_MT_TOUCH_MINOR,min(data->points[i].mWidth,data->points[i].mHeight));
input_report_abs(dev, ABS_MT_TOOL_TYPE,data->points[i].mPresstype>>5);
}
input_mt_sync(dev);//以一个点的信息为结尾
}
input_sync(dev);//以一次事件为结尾
}
这里只截取上报数据部分，直接上报相关数据即可。需要注意的是多点时，需要先上报每个点的数据，然后用 input_mt_sync()函数同步每个点数据，当多点都上报完以后还需要用input_sync()同步，对于系统来说，多点时同一个事件。
2.3 device_attribute的使用。
device_attribute 主要用于在sys子系统中，用户空间与内核空间的交互，在这里采用device_attribute 将版本信息输出到sys子系统中。用户空间用cat指令即可查看。
//在sys子系统下Class目录下创建一个XXX目录
touch->myclass = class_create(THIS_MODULE, "XXX");
if(IS_ERR(touch->myclass))
{
printk("XXXtouchscreen class_create error\n");
return 0;
}
//在XXX目录下创建一个XXX_touch目录
touch->mydevice=device_create(touch->myclass, NULL, touch->chrdev_no, NULL, "XXX_touch");
//在XXX_touch目录下创建drvinfo节点，通过读取节点即可获取信息版本
device_create_file(touch->mydevice, &drvinfo);
//device_attribute 结构体中重要俩个函数 这里只用了.show .attr包括模式和名字
static struct device_attribute drvinfo = {
.attr = {
.name = "drvinfo",
.mode = 0444,
},
.show = drvinfo_show,
};
在drvinfo_show中采用sprintf()直接将信息输出。用户层利用cat就可获取数据信息
static ssize_t drvinfo_show(struct device *dev,struct device_attribute * attr,char * buf)
{
return sprintf();
}
3、驱动框架
整体触摸驱动的流程。
4、总结
驱动主要分为俩大部分，USB驱动和INPUT驱动。利用USB通信，采集数据然后通过算法算出数据后，通过INPUT子系统直接上报系统。在Linux 中USB 驱动和INPUT驱动的相关的API内核已经提供，只需按照相应的流程去操作就可以了。USB驱动前期会难一些，你要理解明白USB的枚举过程和四大描述符的作用。这样写起来就会很快。USB的触摸驱动到这里就结束了，后面还会跟新串口触摸驱动。