USB触摸屏驱动

最新推荐文章于 2023-11-27 09:59:43 发布
最新推荐文章于 2023-11-27 09:59:43 发布
阅读量6.1k 收藏 3
点赞数
分类专栏： 嵌入式 文章标签： struct input interface module report descriptor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hot_zcy2012/article/details/8036741
版权

 

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/usb.h>
#include <linux/usb/input.h>
#include <linux/hid.h>


#define DRIVER_VERSION  "v0.6"
#define DRIVER_AUTHOR  "Zhang Chunyang"
#define DRIVER_DESC  "USB Touchscreen Driver"

static int swap_xy;
module_param(swap_xy, bool, 0644);
MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");

static int hwcalib_xy;
module_param(hwcalib_xy, bool, 0644);
MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");

struct usbtouch_usb;
struct usbtouch_device_info {
 int min_xc, max_xc;
 int min_yc, max_yc;
 int min_press, max_press;
 int rept_size;

 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);

 int  (*get_pkt_len) (unsigned char *pkt, int len);

 int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
 int  (*init)        (struct usbtouch_usb *usbtouch);
};

struct usbtouch_usb {
 unsigned char *data;
 dma_addr_t data_dma;
 unsigned char *buffer;
 int buf_len;
 struct urb *irq;
 struct usb_device *udev;
 struct input_dev *input;
 struct usbtouch_device_info *type;
 char name[128];
 char phys[64];

 int x, y;
 int touch, press;
};


enum {
 DEVTYPE_IGNORE = -1,
 DEVTYPE_EGALAX,
 DEVTYPE_PANJIT,
 DEVTYPE_3M,
 DEVTYPE_ITM,
 DEVTYPE_ETURBO,
 DEVTYPE_GUNZE,
 DEVTYPE_DMC_TSC10,
 DEVTYPE_IRTOUCH,
 DEVTYPE_IDEALTEK,
 DEVTYPE_GENERAL_TOUCH,
 DEVTYPE_GOTOP,
};

#define USB_DEVICE_HID_CLASS(vend, prod) \
 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
  | USB_DEVICE_ID_MATCH_INT_PROTOCOL \
  | USB_DEVICE_ID_MATCH_DEVICE, \
 .idVendor = (vend), \
 .idProduct = (prod), \
 .bInterfaceClass = USB_INTERFACE_CLASS_HID, \
 .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE

static struct usb_device_id usbtouch_devices[] = {
#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 /* ignore the HID capable devices, handled by usbhid */
 {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
 {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},

 /* normal device IDs */
 {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
 {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
 {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
 {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
 {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_3M
 {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_ITM
 {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
 {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
 {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
#endif

 {}
};


/*****************************************************************************
 * eGalax part
 */

#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX

#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif

#define EGALAX_PKT_TYPE_MASK  0xFE
#define EGALAX_PKT_TYPE_REPT  0x80
#define EGALAX_PKT_TYPE_DIAG  0x0A

static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
  return 0;

 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
 dev->touch = pkt[0] & 0x01;

 return 1;
}

static int egalax_get_pkt_len(unsigned char *buf, int len)
{
 switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
 case EGALAX_PKT_TYPE_REPT:
  return 5;

 case EGALAX_PKT_TYPE_DIAG:
  if (len < 2)
   return -1;

  return buf[1] + 2;
 }

 return 0;
}
#endif


/*****************************************************************************
 * PanJit Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
 dev->touch = pkt[0] & 0x01;

 return 1;
}
#endif


/*****************************************************************************
 * 3M/Microtouch Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_3M

#define MTOUCHUSB_ASYNC_REPORT          1
#define MTOUCHUSB_RESET                 7
#define MTOUCHUSB_REQ_CTRLLR_ID         10

static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 if (hwcalib_xy) {
  dev->x = (pkt[4] << 8) | pkt[3];
  dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]);
 } else {
  dev->x = (pkt[8] << 8) | pkt[7];
  dev->y = (pkt[10] << 8) | pkt[9];
 }
 dev->touch = (pkt[2] & 0x40) ? 1 : 0;

 return 1;
}

static int mtouch_init(struct usbtouch_usb *usbtouch)
{
 int ret, i;

 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
                       MTOUCHUSB_RESET,
                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                       1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
     __func__, ret);
 if (ret < 0)
  return ret;
 msleep(150);

 for (i = 0; i < 3; i++) {
  ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
          MTOUCHUSB_ASYNC_REPORT,
          USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
          1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
  dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
      __func__, ret);
  if (ret >= 0)
   break;
  if (ret != -EPIPE)
   return ret;
 }

 /* Default min/max xy are the raw values, override if using hw-calib */
 if (hwcalib_xy) {
  input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0);
  input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0);
 }

 return 0;
}
#endif


/*****************************************************************************
 * ITM Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_ITM
static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 int touch;
 /*
  * ITM devices report invalid x/y data if not touched.
  * if the screen was touched before but is not touched any more
  * report touch as 0 with the last valid x/y data once. then stop
  * reporting data until touched again.
  */
 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);

 touch = ~pkt[7] & 0x20;
 if (!touch) {
  if (dev->touch) {
   dev->touch = 0;
   return 1;
  }

  return 0;
 }

 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
 dev->touch = touch;

 return 1;
}
#endif


/*****************************************************************************
 * eTurboTouch part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif
static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 unsigned int shift;

 /* packets should start with sync */
 if (!(pkt[0] & 0x80))
  return 0;

 shift = (6 - (pkt[0] & 0x03));
 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
 dev->touch = (pkt[0] & 0x10) ? 1 : 0;

 return 1;
}

static int eturbo_get_pkt_len(unsigned char *buf, int len)
{
 if (buf[0] & 0x80)
  return 5;
 if (buf[0] == 0x01)
  return 3;
 return 0;
}
#endif


/*****************************************************************************
 * Gunze part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
  return 0;

 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
 dev->touch = pkt[0] & 0x20;

 return 1;
}
#endif

/*****************************************************************************
 * DMC TSC-10/25 Part
 *
 * Documentation about the controller and it's protocol can be found at
 *   http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
 *   http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
 */
#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10

/* supported data rates. currently using 130 */
#define TSC10_RATE_POINT 0x50
#define TSC10_RATE_30  0x40
#define TSC10_RATE_50  0x41
#define TSC10_RATE_80  0x42
#define TSC10_RATE_100  0x43
#define TSC10_RATE_130  0x44
#define TSC10_RATE_150  0x45

/* commands */
#define TSC10_CMD_RESET  0x55
#define TSC10_CMD_RATE  0x05
#define TSC10_CMD_DATA1  0x01

static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
{
 struct usb_device *dev = usbtouch->udev;
 int ret = -ENOMEM;
 unsigned char *buf;

 buf = kmalloc(2, GFP_KERNEL);
 if (!buf)
  goto err_nobuf;
 /* reset */
 buf[0] = buf[1] = 0xFF;
 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
                       TSC10_CMD_RESET,
                       USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                       0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 if (ret < 0)
  goto err_out;
 if (buf[0] != 0x06) {
  ret = -ENODEV;
  goto err_out;
 }

 /* set coordinate output rate */
 buf[0] = buf[1] = 0xFF;
 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
                       TSC10_CMD_RATE,
                       USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                       TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 if (ret < 0)
  goto err_out;
 if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) {
  ret = -ENODEV;
  goto err_out;
 }

 /* start sending data */
 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
                       TSC10_CMD_DATA1,
                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                       0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
err_out:
 kfree(buf);
err_nobuf:
 return ret;
}


static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
 dev->touch = pkt[0] & 0x01;

 return 1;
}
#endif


/*****************************************************************************
 * IRTOUCH Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 dev->x = (pkt[3] << 8) | pkt[2];
 dev->y = (pkt[5] << 8) | pkt[4];
 dev->touch = (pkt[1] & 0x03) ? 1 : 0;

 return 1;
}
#endif


/*****************************************************************************
 * IdealTEK URTC1000 Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif
static int idealtek_get_pkt_len(unsigned char *buf, int len)
{
 if (buf[0] & 0x80)
  return 5;
 if (buf[0] == 0x01)
  return len;
 return 0;
}

static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 switch (pkt[0] & 0x98) {
 case 0x88:
  /* touch data in IdealTEK mode */
  dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
  dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
  dev->touch = (pkt[0] & 0x40) ? 1 : 0;
  return 1;

 case 0x98:
  /* touch data in MT emulation mode */
  dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
  dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
  dev->touch = (pkt[0] & 0x40) ? 1 : 0;
  return 1;

 default:
  return 0;
 }
}
#endif

/*****************************************************************************
 * General Touch Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
 dev->press = pkt[5] & 0xff;
 dev->touch = pkt[0] & 0x01;

 return 1;
}
#endif

/*****************************************************************************
 * GoTop Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
 dev->touch = pkt[0] & 0x01;
 return 1;
}
#endif


/*****************************************************************************
 * the different device descriptors
 */
#ifdef MULTI_PACKET
static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
       unsigned char *pkt, int len);
#endif

static struct usbtouch_device_info usbtouch_dev_info[] = {
#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 [DEVTYPE_EGALAX] = {
  .min_xc  = 0x0,
  .max_xc  = 0x07ff,
  .min_yc  = 0x0,
  .max_yc  = 0x07ff,
  .rept_size = 16,
  .process_pkt = usbtouch_process_multi,
  .get_pkt_len = egalax_get_pkt_len,
  .read_data = egalax_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 [DEVTYPE_PANJIT] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0fff,
  .min_yc  = 0x0,
  .max_yc  = 0x0fff,
  .rept_size = 8,
  .read_data = panjit_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_3M
 [DEVTYPE_3M] = {
  .min_xc  = 0x0,
  .max_xc  = 0x4000,
  .min_yc  = 0x0,
  .max_yc  = 0x4000,
  .rept_size = 11,
  .read_data = mtouch_read_data,
  .init  = mtouch_init,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_ITM
 [DEVTYPE_ITM] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0fff,
  .min_yc  = 0x0,
  .max_yc  = 0x0fff,
  .max_press = 0xff,
  .rept_size = 8,
  .read_data = itm_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 [DEVTYPE_ETURBO] = {
  .min_xc  = 0x0,
  .max_xc  = 0x07ff,
  .min_yc  = 0x0,
  .max_yc  = 0x07ff,
  .rept_size = 8,
  .process_pkt = usbtouch_process_multi,
  .get_pkt_len = eturbo_get_pkt_len,
  .read_data = eturbo_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 [DEVTYPE_GUNZE] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0fff,
  .min_yc  = 0x0,
  .max_yc  = 0x0fff,
  .rept_size = 4,
  .read_data = gunze_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 [DEVTYPE_DMC_TSC10] = {
  .min_xc  = 0x0,
  .max_xc  = 0x03ff,
  .min_yc  = 0x0,
  .max_yc  = 0x03ff,
  .rept_size = 5,
  .init  = dmc_tsc10_init,
  .read_data = dmc_tsc10_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 [DEVTYPE_IRTOUCH] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0fff,
  .min_yc  = 0x0,
  .max_yc  = 0x0fff,
  .rept_size = 8,
  .read_data = irtouch_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 [DEVTYPE_IDEALTEK] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0fff,
  .min_yc  = 0x0,
  .max_yc  = 0x0fff,
  .rept_size = 8,
  .process_pkt = usbtouch_process_multi,
  .get_pkt_len = idealtek_get_pkt_len,
  .read_data = idealtek_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 [DEVTYPE_GENERAL_TOUCH] = {
  .min_xc  = 0x0,
  .max_xc  = 0x0500,
  .min_yc  = 0x0,
  .max_yc  = 0x0500,
  .rept_size = 7,
  .read_data = general_touch_read_data,
 },
#endif

#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 [DEVTYPE_GOTOP] = {
  .min_xc  = 0x0,
  .max_xc  = 0x03ff,
  .min_yc  = 0x0,
  .max_yc  = 0x03ff,
  .rept_size = 4,
  .read_data = gotop_read_data,
 },
#endif
};


/*****************************************************************************
 * Generic Part
 */
static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
                                 unsigned char *pkt, int len)
{
 struct usbtouch_device_info *type = usbtouch->type;

 if (!type->read_data(usbtouch, pkt))
   return;

 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);

 if (swap_xy) {
  input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
  input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
 } else {
  input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
  input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
 }
 if (type->max_press)
  input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
 input_sync(usbtouch->input);
}


#ifdef MULTI_PACKET
static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
                                   unsigned char *pkt, int len)
{
 unsigned char *buffer;
 int pkt_len, pos, buf_len, tmp;

 /* process buffer */
 if (unlikely(usbtouch->buf_len)) {
  /* try to get size */
  pkt_len = usbtouch->type->get_pkt_len(
    usbtouch->buffer, usbtouch->buf_len);

  /* drop? */
  if (unlikely(!pkt_len))
   goto out_flush_buf;

  /* need to append -pkt_len bytes before able to get size */
  if (unlikely(pkt_len < 0)) {
   int append = -pkt_len;
   if (unlikely(append > len))
          append = len;
   if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
    goto out_flush_buf;
   memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
   usbtouch->buf_len += append;

   pkt_len = usbtouch->type->get_pkt_len(
     usbtouch->buffer, usbtouch->buf_len);
   if (pkt_len < 0)
    return;
  }

  /* append */
  tmp = pkt_len - usbtouch->buf_len;
  if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
   goto out_flush_buf;
  memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
  usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);

  buffer = pkt + tmp;
  buf_len = len - tmp;
 } else {
  buffer = pkt;
  buf_len = len;
 }

 /* loop over the received packet, process */
 pos = 0;
 while (pos < buf_len) {
  /* get packet len */
  pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
       buf_len - pos);

  /* unknown packet: skip one byte */
  if (unlikely(!pkt_len)) {
   pos++;
   continue;
  }

  /* full packet: process */
  if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
   usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
  } else {
   /* incomplete packet: save in buffer */
   memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
   usbtouch->buf_len = buf_len - pos;
   return;
  }
  pos += pkt_len;
 }

out_flush_buf:
 usbtouch->buf_len = 0;
 return;
}
#endif


static void usbtouch_irq(struct urb *urb)
{
 struct usbtouch_usb *usbtouch = urb->context;
 int retval;

 switch (urb->status) {
 case 0:
  /* success */
  break;
 case -ETIME:
  /* this urb is timing out */
  dbg("%s - urb timed out - was the device unplugged?",
      __func__);
  return;
 case -ECONNRESET:
 case -ENOENT:
 case -ESHUTDOWN:
  /* this urb is terminated, clean up */
  dbg("%s - urb shutting down with status: %d",
      __func__, urb->status);
  return;
 default:
  dbg("%s - nonzero urb status received: %d",
      __func__, urb->status);
  goto exit;
 }

 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);

exit:
 retval = usb_submit_urb(urb, GFP_ATOMIC);
 if (retval)
  err("%s - usb_submit_urb failed with result: %d",
      __func__, retval);
}

static int usbtouch_open(struct input_dev *input)
{
 struct usbtouch_usb *usbtouch = input_get_drvdata(input);

 usbtouch->irq->dev = usbtouch->udev;

 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL))
  return -EIO;

 return 0;
}

static void usbtouch_close(struct input_dev *input)
{
 struct usbtouch_usb *usbtouch = input_get_drvdata(input);

 usb_kill_urb(usbtouch->irq);
}


static void usbtouch_free_buffers(struct usb_device *udev,
      struct usbtouch_usb *usbtouch)
{
 usb_buffer_free(udev, usbtouch->type->rept_size,
                 usbtouch->data, usbtouch->data_dma);
 kfree(usbtouch->buffer);
}


static int usbtouch_probe(struct usb_interface *intf,
     const struct usb_device_id *id)
{
 struct usbtouch_usb *usbtouch;
 struct input_dev *input_dev;
 struct usb_host_interface *interface;
 struct usb_endpoint_descriptor *endpoint;
 struct usb_device *udev = interface_to_usbdev(intf);
 struct usbtouch_device_info *type;
 int err = -ENOMEM;

 /* some devices are ignored */
 if (id->driver_info == DEVTYPE_IGNORE)
  return -ENODEV;

 interface = intf->cur_altsetting;
 endpoint = &interface->endpoint[0].desc;

 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
 input_dev = input_allocate_device();
 if (!usbtouch || !input_dev)
  goto out_free;

 type = &usbtouch_dev_info[id->driver_info];
 usbtouch->type = type;
 if (!type->process_pkt)
  type->process_pkt = usbtouch_process_pkt;

 usbtouch->data = usb_buffer_alloc(udev, type->rept_size,
                                   GFP_KERNEL, &usbtouch->data_dma);
 if (!usbtouch->data)
  goto out_free;

 if (type->get_pkt_len) {
  usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
  if (!usbtouch->buffer)
   goto out_free_buffers;
 }

 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
 if (!usbtouch->irq) {
  dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
  goto out_free_buffers;
 }

 usbtouch->udev = udev;
 usbtouch->input = input_dev;

 if (udev->manufacturer)
  strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));

 if (udev->product) {
  if (udev->manufacturer)
   strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
  strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
 }

 if (!strlen(usbtouch->name))
  snprintf(usbtouch->name, sizeof(usbtouch->name),
   "USB Touchscreen %04x:%04x",
    le16_to_cpu(udev->descriptor.idVendor),
    le16_to_cpu(udev->descriptor.idProduct));

 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));

 input_dev->name = usbtouch->name;
 input_dev->phys = usbtouch->phys;
 usb_to_input_id(udev, &input_dev->id);
 input_dev->dev.parent = &intf->dev;

 input_set_drvdata(input_dev, usbtouch);

 input_dev->open = usbtouch_open;
 input_dev->close = usbtouch_close;

 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
 if (type->max_press)
  input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
                       type->max_press, 0, 0);

 usb_fill_int_urb(usbtouch->irq, usbtouch->udev,
    usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress),
    usbtouch->data, type->rept_size,
    usbtouch_irq, usbtouch, endpoint->bInterval);

 usbtouch->irq->dev = usbtouch->udev;
 usbtouch->irq->transfer_dma = usbtouch->data_dma;
 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

 /* device specific init */
 if (type->init) {
  err = type->init(usbtouch);
  if (err) {
   dbg("%s - type->init() failed, err: %d", __func__, err);
   goto out_free_buffers;
  }
 }

 err = input_register_device(usbtouch->input);
 if (err) {
  dbg("%s - input_register_device failed, err: %d", __func__, err);
  goto out_free_buffers;
 }

 usb_set_intfdata(intf, usbtouch);

 return 0;

out_free_buffers:
 usbtouch_free_buffers(udev, usbtouch);
out_free:
 input_free_device(input_dev);
 kfree(usbtouch);
 return err;
}

static void usbtouch_disconnect(struct usb_interface *intf)
{
 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);

 dbg("%s - called", __func__);

 if (!usbtouch)
  return;

 dbg("%s - usbtouch is initialized, cleaning up", __func__);
 usb_set_intfdata(intf, NULL);
 usb_kill_urb(usbtouch->irq);
 input_unregister_device(usbtouch->input);
 usb_free_urb(usbtouch->irq);
 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
 kfree(usbtouch);
}

MODULE_DEVICE_TABLE(usb, usbtouch_devices);

static struct usb_driver usbtouch_driver = {
 .name  = "usbtouchscreen",
 .probe  = usbtouch_probe,
 .disconnect = usbtouch_disconnect,
 .id_table = usbtouch_devices,
};

static int __init usbtouch_init(void)
{
 return usb_register(&usbtouch_driver);
}

static void __exit usbtouch_cleanup(void)
{
 usb_deregister(&usbtouch_driver);
}

module_init(usbtouch_init);
module_exit(usbtouch_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

MODULE_ALIAS("touchkitusb");
MODULE_ALIAS("itmtouch");
MODULE_ALIAS("mtouchusb");

 

小狼阳阳阳
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
usb触摸屏驱动
paomadi的专栏
04-03 7722
源码在/drivers/input/touchscreen/usbtouchscreen.c中static int __init usbtouch_init(void) //入口函数 { return usb_register(&usbtouch_driver); //注册usb触摸屏驱动 } module_init(usbtouch_init); 看usbtouch_driver的定义 s
usb 接口触摸屏驱动
嵌入式技术博客
11-19 7729
以前写的 USB 接口的触摸屏驱动，那段时间简单的看了下 USB 协议的一些东西，主要是 HID 相关的，代码留着作为记录： /* Created by_fire 2012.2.13 */ #include #include #include #include #include #include #include #include #include #include #in
【输入子系统01】USB触摸屏驱动
|~~~热爱生活、努力学习的小伙汁~~~|
03-16 885
USB触摸屏驱动驱动编译注册usb驱动 驱动编译 目前的kernel中都是自带了usbtouchscreen驱动的，我的版本3.1.10 源码位于：/kernel/drivers/input/touchscreen/usbtouchscreen.c 从这个路径可以看出所属驱动分支，我这边平台本身是没放开的，并没有编译进kernel，谁会想到触摸电视呢~ 可以在make menuconfig之后，...
USB触摸屏的驱动
热门推荐
s_jason的博客
06-19 1万+
我们都知道410c没有配套的触摸屏，如果有屏的话，在调试或者其他方面就方便多了，所以我们自己买了一个usb触摸屏，现在让我们看看usb触摸屏的驱动。 　　驱动路经：drivers/input/touchscreen/usbtouchscreen.c 　　（１）设备匹配 　　　　module_usb_driver(usbtouch_driver); 　　 static struc
usb4-配置usb触摸屏
weixin_30505043的博客
10-31 293
淘了一个触摸屏,usb接口,四线电阻,usb芯片是cy7c63723c。 此芯片一端接触摸屏的四根线，对触摸动作采样然后ad转换，一端通过usb接mini2440，即将ad转换后的数据通过usb接口发给mini2440. linux2.6.32已经集成usb 触摸屏驱动，mini2440默认是不配置的。可以配置一下 make menuconfig 之后选择 Device Dri...
搭载Ubuntu触摸屏系统--（2、硬件配置）
qq_33571718的博客
12-17 2203
声明：本博文用于学习总结及工作心得 先上图 配件设施: 主板：D525 驱动板： 高压板： 显示屏信号控制板，触屏驱动板： 以下信息需根据实际情况来看，元器件不同，配置方法也可能不同； 一 ：接线： 1. 将主板LVDS打开，并设置好屏幕分辨率，在购买主版的时候一定需要给供应商说明，第一次购买的时候忘记说，结
Android usb 触摸屏驱动
04-01
在Android系统中，USB触摸屏驱动是连接外部触摸设备与操作系统之间的重要桥梁，它使得用户可以通过触摸屏与设备进行交互。本主题将深入探讨USB触摸屏驱动的工作原理、支持的屏幕类型以及在Android和Linux环境下的...
Android系统USB触摸驱动
01-20
Android系统USB触摸驱动是连接Android设备与USB红外触摸屏的关键技术，...理解并掌握这些知识点对于开发和调试USB触摸屏驱动至关重要。如果你在使用过程中遇到问题，可以寻求专业开发者或者社区的帮助，共同解决难题。
usb 触摸屏驱动
02-13
usb 触摸屏的驱动 支持电阻屏和电容屏，在安卓上和linux都可以
70系列USB触摸屏驱动
02-14
【70系列USB触摸屏驱动】是专为PC计算机设计的一款关键硬件组件，它使得用户可以通过手指或者其他触摸设备与电脑屏幕进行直接交互。在现代计算机技术中，触摸屏已经成为人机交互的重要方式，尤其在平板电脑、一体机...
2440触摸屏驱动程序
在不断学习中。。。
10-03 703
2440触摸屏驱动程序 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include struct s3c_ts_regs {
win10万能触摸屏驱动_万能红外触摸屏驱动下载-万能usb红外触摸屏驱动下载
weixin_39578674的博客
01-26 8665
万能usb红外触摸屏驱动是一款适用于win7系统的触摸屏驱动程序，主要应用于支持红外线的电脑屏幕，是很多用户必备的驱动程序之一，本站同时为你提供该驱动的安装教程，欢迎来下载使用！万能红外线触摸屏驱动介绍红外屏专用的驱动程序，适合win7系统的usb触摸屏驱动程序，如果你在使用红外触摸屏，也不知道品牌是什么，可以试试本驱动，它是自动安装的版本无需手动过多的设置，我们只需要完整安装就行了，安装后测试触...
eGalax触摸屏相关知识
zuosifengli的专栏
02-27 4050
egalax触摸屏： 1.在需要转屏和特定分辨率的时候，可用cvt命令和xrandr命令来设定其分辨率。 …………$ xrandr Screen 0: minimum 320 x 200, current 1280 x 1024, maximum 4096 x 4096 VGA1 connected 1280x1024+0+0 (normal left inverted r
如何下载并安装触控板驱动
最新发布
famous_pengfei的博客
11-27 407
在如今这个触摸屏设备普及的时代，触控板已成为我们与电子设备进行交互的重要工具。然而，当我们使用触控板时，有时会遇到各种问题，如操作不灵敏、手势失灵等。此时，下载并安装触控板驱动就显得尤为重要。本文将分享下载并安装触控板驱动的方法，希望能够帮助大家解决触控板问题，提高设备使用体验。
触摸屏与usb鼠标同时支持
linux
11-24 4484
最近，做系统移植，根文件系统自己做的，移植好tslib，也可以触摸屏校准，触摸屏也可以正常使用，但是插上usb鼠标时，系统能枚举出usb的信息，也能判断出是鼠标设备，但是移动鼠标，左右点击鼠标，屏幕上的鼠标就是没反应。经过一番搜索，终于找到了解决方法。 1. 首先找到设备文件(/dev/input)下有这样几个节点，mice, mouse0, event0, event1 ... ... 输入
eGalax Touchkit触摸屏支持
jackielee524的专栏
03-25 7224
前段时间由于工作的需要，基于2.6.29内核，完善了其对eGalax Touchkit两款触摸屏的支持。     我所用到的这两款触摸屏，一个是电阻屏vendor =0x0eef, product=0x0002，另一个是电容屏vendor =0x0eef,product= 0x7241。这两款触摸屏均为usb接口的，其驱动所涉及的文件是\drivers\input\touchscreen\usb
Android 底层新增按键系统上层适配详解
wenzhi的博客
10-11 935
在Android系统 上外界按键板或者在原有的按键新增个按键都是需要内核和系统层进行代码适配。
RK平台SIS触摸驱动和其它触摸屏驱动冲突问题解决方法
com6339663的专栏
02-22 1164
\\192.168.1.113\jd_work3_rk3399_sdk\rk3188_5.1_mid\kernel\drivers\hid\hid-multitouch.c   //SiS set noget for not init reports if (hdev-&gt;vendor == USB_VENDOR_ID_SIS_TOUCH) { hdev-&gt;quirks |= ...
Linux 平台下的 ilitek2510 usb触摸屏驱动
05-25
ilitek2510 是一款常见的 USB 触摸屏控制器芯片，Linux 平台下可以使用 HID 触摸屏驱动来支持 ilitek2510 触摸屏。 以下是步骤： 1. 确保系统已经加载了 hid-multitouch 驱动，可以使用以下命令来检查： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值