d-two/operating-system
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
2d870984e248c8845c73109f3e86e0386fa759bc
operating-system/buildroot-external/board/hardkernel/odroid-c2/patches/linux/072_linux-4.16.y-input_touchscreen-vu5-vu7plus.patch
Ryan Bray 75e721e77e OdroidC2: Updating Kernel (#277)
2018-12-06 10:09:16 +01:00

1236 lines
34 KiB
Diff
Raw Blame History

diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c
index e92b77fa5..53bdf9725 100644
--- a/drivers/hid/hid-quirks.c
+++ b/drivers/hid/hid-quirks.c
@@ -869,6 +869,8 @@ static const struct hid_device_id hid_ignore_list[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
#endif
{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_ODROID, USB_DEVICE_ID_VU5) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_ODROID, USB_DEVICE_ID_VU7PLUS) },
{ }
};
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index ff539c0b4..b09d5ea03 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -1164,4 +1164,10 @@
#define USB_VENDOR_ID_UGTIZER 0x2179
#define USB_DEVICE_ID_UGTIZER_TABLET_GP0610 0x0053
+#define USB_DEVICE_ID_DWAV_MULTITOUCH 0x0005
+
+#define USB_VENDOR_ID_ODROID 0x16b4
+#define USB_DEVICE_ID_VU5 0x0704
+#define USB_DEVICE_ID_VU7PLUS 0x0705
+
#endif
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 64b30fe27..05e834eed 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -1246,4 +1246,23 @@ config TOUCHSCREEN_ROHM_BU21023
To compile this driver as a module, choose M here: the
module will be called bu21023_ts.
+config TOUCHSCREEN_DWAV_USB_MT
+ tristate "D-WAV Scientific USB MultiTouch"
+ depends on USB_ARCH_HAS_HCD
+ select USB
+ help
+ Say Y here if you have a D-WAV Scientific USB(HID) based MultiTouch
+ controller.
+
+ If unsure, say N.
+
+ To compile this driver as a module, choose M here: the
+ module will be called dwav-usb-mt.
+
+config TOUCHSCREEN_SX865X
+ tristate "Semtech multitouch resistive touchscreen"
+ depends on I2C
+ help
+ This enables support for Semtech multitouch resistive touchscreen.
+
endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 850c15625..bc3f0e1d5 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -104,3 +104,5 @@ obj-$(CONFIG_TOUCHSCREEN_ZET6223) += zet6223.o
obj-$(CONFIG_TOUCHSCREEN_ZFORCE) += zforce_ts.o
obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50) += colibri-vf50-ts.o
obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o
+obj-$(CONFIG_TOUCHSCREEN_DWAV_USB_MT) += dwav-usb-mt.o
+obj-$(CONFIG_TOUCHSCREEN_SX865X) += sx865x.o
diff -urN a/drivers/input/touchscreen/dwav-usb-mt.c b/drivers/input/touchscreen/dwav-usb-mt.c
--- a/drivers/input/touchscreen/dwav-usb-mt.c 1970-01-01 01:00:00.000000000 +0100
+++ b/drivers/input/touchscreen/dwav-usb-mt.c 2018-05-06 10:03:40.485939294 +0200
@@ -0,0 +1,577 @@
+/*-------------------------------------------------------------------------
+
+ D-WAV Scientific USB(HID) MultiTouch Screen Driver(Based on usbtouchscreen.c)
+ Hardkernel : 2015/09/17
+
+-------------------------------------------------------------------------*/
+#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>
+
+#include <linux/input/mt.h>
+
+/*-------------------------------------------------------------------------*/
+#define USB_VENDOR_ID_DWAV 0x0eef /* 800 x 480, 7" DWAV touch */
+#define USB_DEVICE_ID_VU7 0x0005
+
+#define USB_VENDOR_ID_ODROID 0x16b4
+#define USB_DEVICE_ID_VU5 0x0704
+#define USB_DEVICE_ID_VU7PLUS 0x0705
+
+enum {
+ ODROID_VU7 = 0, /* 800 x 480, 7" Touch */
+ ODROID_VU5, /* 800 x 480, 5" Touch */
+ ODROID_VU7PLUS, /* 1024 x 600, 7" Touch */
+};
+
+/*-------------------------------------------------------------------------*/
+struct usbtouch_device_info {
+ char name[64];
+ int max_x;
+ int max_y;
+ int max_press;
+ int max_finger;
+};
+
+/*-------------------------------------------------------------------------*/
+const struct usbtouch_device_info DEV_INFO[] = {
+ [ODROID_VU7] = {
+ .name = "ODROID VU7 MultiTouch(800x480)",
+ .max_x = 800,
+ .max_y = 480,
+ .max_press = 255,
+ .max_finger = 5,
+ },
+ [ODROID_VU5] = {
+ .name = "ODROID VU5 MultiTouch(800x480)",
+ .max_x = 800,
+ .max_y = 480,
+ .max_press = 255,
+ .max_finger = 5,
+ },
+ [ODROID_VU7PLUS] = {
+ .name = "ODROID VU7 Plus MultiTouch(1024x600)",
+ .max_x = 1024,
+ .max_y = 600,
+ .max_press = 255,
+ .max_finger = 5,
+ },
+};
+
+/*-------------------------------------------------------------------------*/
+static const struct usb_device_id dwav_usb_mt_devices[] = {
+ {USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_VU7),
+ .driver_info = ODROID_VU7},
+ {USB_DEVICE(USB_VENDOR_ID_ODROID, USB_DEVICE_ID_VU5),
+ .driver_info = ODROID_VU5},
+ {USB_DEVICE(USB_VENDOR_ID_ODROID, USB_DEVICE_ID_VU7PLUS),
+ .driver_info = ODROID_VU7PLUS},
+ {}
+};
+
+/*-------------------------------------------------------------------------*/
+struct dwav_raw { /* Total 25 bytes */
+ unsigned char header; /* frame header 0xAA*/
+ unsigned char press;
+ /* Touch flag (1:valid touch data, 0:touch finished) */
+ unsigned short x1; /* 1st x */
+ unsigned short y1; /* 1st y */
+ unsigned char end;
+ /* 1st touch finish flags 0xBB, RPI only uses the first 7 bytes */
+ unsigned char ids; /* touch ID(bit field) */
+ unsigned short y2;
+ unsigned short x2;
+ unsigned short y3;
+ unsigned short x3;
+ unsigned short y4;
+ unsigned short x4;
+ unsigned short y5;
+ unsigned short x5;
+ unsigned char tail; /* frame end 0xCC */
+};
+
+/*-------------------------------------------------------------------------
+ Touch Event type define
+-------------------------------------------------------------------------*/
+#define TS_EVENT_UNKNOWN 0x00
+#define TS_EVENT_PRESS 0x01
+#define TS_EVENT_RELEASE 0x02
+
+struct finger_t {
+ unsigned int status; /* ts event type */
+ unsigned int x; /* ts data x */
+ unsigned int y; /* ts data y */
+} __packed;
+
+struct dwav_usb_mt {
+ char name[128], phys[64];
+
+ int dev_id;
+ /* for URB Data DMA */
+ dma_addr_t data_dma;
+ unsigned char *data;
+ int data_size;
+
+ struct urb *irq;
+ struct usb_interface *interface;
+ struct input_dev *input;
+
+ struct finger_t *finger;
+};
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_report(struct dwav_usb_mt *dwav_usb_mt)
+{
+ int id, max_x, max_y, max_press, max_finger;
+
+ max_x = DEV_INFO[dwav_usb_mt->dev_id].max_x;
+ max_y = DEV_INFO[dwav_usb_mt->dev_id].max_y;
+ max_press = DEV_INFO[dwav_usb_mt->dev_id].max_press;
+ max_finger = DEV_INFO[dwav_usb_mt->dev_id].max_finger;
+
+ for (id = 0; id < max_finger; id++) {
+
+ if (dwav_usb_mt->finger[id].status == TS_EVENT_UNKNOWN)
+ continue;
+
+ if (dwav_usb_mt->finger[id].x >= max_x ||
+ dwav_usb_mt->finger[id].y >= max_y)
+ continue;
+
+ input_mt_slot(dwav_usb_mt->input, id);
+
+ if (dwav_usb_mt->finger[id].status != TS_EVENT_RELEASE) {
+ input_mt_report_slot_state(dwav_usb_mt->input,
+ MT_TOOL_FINGER, true);
+ input_report_abs(dwav_usb_mt->input,
+ ABS_MT_POSITION_X,
+ dwav_usb_mt->finger[id].x);
+ input_report_abs(dwav_usb_mt->input,
+ ABS_MT_POSITION_Y,
+ dwav_usb_mt->finger[id].y);
+ input_report_abs(dwav_usb_mt->input,
+ ABS_MT_PRESSURE,
+ max_press);
+ } else {
+ input_mt_report_slot_state(dwav_usb_mt->input,
+ MT_TOOL_FINGER, false);
+ dwav_usb_mt->finger[id].status = TS_EVENT_UNKNOWN;
+ }
+ input_mt_report_pointer_emulation(dwav_usb_mt->input, true);
+ input_sync(dwav_usb_mt->input);
+ }
+}
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_process(struct dwav_usb_mt *dwav_usb_mt,
+ unsigned char *pkt, int len)
+{
+ struct dwav_raw *dwav_raw = (struct dwav_raw *)pkt;
+ unsigned char bit_mask, cnt;
+
+ for (cnt = 0, bit_mask = 0x01;
+ cnt < DEV_INFO[dwav_usb_mt->dev_id].max_finger;
+ cnt++, bit_mask <<= 1) {
+ if ((dwav_raw->ids & bit_mask) && dwav_raw->press) {
+ dwav_usb_mt->finger[cnt].status = TS_EVENT_PRESS;
+ switch (cnt) {
+ case 0:
+ dwav_usb_mt->finger[cnt].x
+ = cpu_to_be16(dwav_raw->x1);
+ dwav_usb_mt->finger[cnt].y
+ = cpu_to_be16(dwav_raw->y1);
+ break;
+ case 1:
+ dwav_usb_mt->finger[cnt].x
+ = cpu_to_be16(dwav_raw->x2);
+ dwav_usb_mt->finger[cnt].y
+ = cpu_to_be16(dwav_raw->y2);
+ break;
+ case 2:
+ dwav_usb_mt->finger[cnt].x
+ = cpu_to_be16(dwav_raw->x3);
+ dwav_usb_mt->finger[cnt].y
+ = cpu_to_be16(dwav_raw->y3);
+ break;
+ case 3:
+ dwav_usb_mt->finger[cnt].x
+ = cpu_to_be16(dwav_raw->x4);
+ dwav_usb_mt->finger[cnt].y
+ = cpu_to_be16(dwav_raw->y4);
+ break;
+ case 4:
+ dwav_usb_mt->finger[cnt].x
+ = cpu_to_be16(dwav_raw->x5);
+ dwav_usb_mt->finger[cnt].y
+ = cpu_to_be16(dwav_raw->y5);
+ break;
+ default:
+ break;
+ }
+ } else {
+ if (dwav_usb_mt->finger[cnt].status == TS_EVENT_PRESS)
+ dwav_usb_mt->finger[cnt].status
+ = TS_EVENT_RELEASE;
+ else
+ dwav_usb_mt->finger[cnt].status
+ = TS_EVENT_UNKNOWN;
+ }
+ }
+ dwav_usb_mt_report(dwav_usb_mt);
+}
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_irq(struct urb *urb)
+{
+ struct dwav_usb_mt *dwav_usb_mt = urb->context;
+ struct device *dev = &dwav_usb_mt->interface->dev;
+ int retval;
+
+ switch (urb->status) {
+ case 0:
+ /* success */
+ break;
+ case -ETIME:
+ /* this urb is timing out */
+ dev_dbg(dev, "%s - urb timed out - was the device unplugged?\n",
+ __func__);
+ return;
+ case -ECONNRESET:
+ case -ENOENT:
+ case -ESHUTDOWN:
+ case -EPIPE:
+ /* this urb is terminated, clean up */
+ dev_dbg(dev, "%s - urb shutting down with status: %d\n",
+ __func__, urb->status);
+ return;
+ default:
+ dev_dbg(dev, "%s - nonzero urb status received: %d\n",
+ __func__, urb->status);
+ goto exit;
+ }
+
+ dwav_usb_mt_process(dwav_usb_mt, dwav_usb_mt->data, urb->actual_length);
+
+exit:
+ usb_mark_last_busy(interface_to_usbdev(dwav_usb_mt->interface));
+ retval = usb_submit_urb(urb, GFP_ATOMIC);
+ if (retval) {
+ dev_err(dev, "%s - usb_submit_urb failed with result: %d\n",
+ __func__, retval);
+ }
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_open(struct input_dev *input)
+{
+ struct dwav_usb_mt *dwav_usb_mt = input_get_drvdata(input);
+ int r;
+
+ dwav_usb_mt->irq->dev = interface_to_usbdev(dwav_usb_mt->interface);
+
+ r = usb_autopm_get_interface(dwav_usb_mt->interface) ? -EIO : 0;
+ if (r < 0)
+ goto out;
+
+ if (usb_submit_urb(dwav_usb_mt->irq, GFP_KERNEL)) {
+ r = -EIO;
+ goto out_put;
+ }
+
+ dwav_usb_mt->interface->needs_remote_wakeup = 1;
+out_put:
+ usb_autopm_put_interface(dwav_usb_mt->interface);
+out:
+ return r;
+}
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_close(struct input_dev *input)
+{
+ struct dwav_usb_mt *dwav_usb_mt = input_get_drvdata(input);
+ int r;
+
+ usb_kill_urb(dwav_usb_mt->irq);
+
+ r = usb_autopm_get_interface(dwav_usb_mt->interface);
+
+ dwav_usb_mt->interface->needs_remote_wakeup = 0;
+ if (!r)
+ usb_autopm_put_interface(dwav_usb_mt->interface);
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_suspend(struct usb_interface *intf, pm_message_t message)
+{
+ struct dwav_usb_mt *dwav_usb_mt = usb_get_intfdata(intf);
+
+ usb_kill_urb(dwav_usb_mt->irq);
+
+ return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_resume(struct usb_interface *intf)
+{
+ struct dwav_usb_mt *dwav_usb_mt = usb_get_intfdata(intf);
+ struct input_dev *input = dwav_usb_mt->input;
+ int result = 0;
+
+ mutex_lock(&input->mutex);
+ if (input->users)
+ result = usb_submit_urb(dwav_usb_mt->irq, GFP_NOIO);
+ mutex_unlock(&input->mutex);
+
+ return result;
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_reset_resume(struct usb_interface *intf)
+{
+ struct dwav_usb_mt *dwav_usb_mt = usb_get_intfdata(intf);
+ struct input_dev *input = dwav_usb_mt->input;
+ int err = 0;
+
+ /* restart IO if needed */
+ mutex_lock(&input->mutex);
+ if (input->users)
+ err = usb_submit_urb(dwav_usb_mt->irq, GFP_NOIO);
+ mutex_unlock(&input->mutex);
+
+ return err;
+}
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_free_buffers(struct usb_device *udev,
+ struct dwav_usb_mt *dwav_usb_mt)
+{
+ usb_free_coherent(udev, dwav_usb_mt->data_size,
+ dwav_usb_mt->data, dwav_usb_mt->data_dma);
+}
+
+/*-------------------------------------------------------------------------*/
+static struct usb_endpoint_descriptor *dwav_usb_mt_get_input_endpoint(
+ struct usb_host_interface *interface)
+{
+ int i;
+
+ for (i = 0; i < interface->desc.bNumEndpoints; i++) {
+ if (usb_endpoint_dir_in(&interface->endpoint[i].desc))
+ return &interface->endpoint[i].desc;
+ }
+
+ return NULL;
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_init(struct dwav_usb_mt *dwav_usb_mt, void *dev)
+{
+ int err;
+ struct input_dev *input_dev = (struct input_dev *)dev;
+
+ input_dev->name = dwav_usb_mt->name;
+ input_dev->phys = dwav_usb_mt->phys;
+
+ input_set_drvdata(input_dev, dwav_usb_mt);
+
+ input_dev->open = dwav_usb_mt_open;
+ input_dev->close = dwav_usb_mt_close;
+
+ input_dev->id.bustype = BUS_USB;
+
+ /* single touch */
+ 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, 0,
+ DEV_INFO[dwav_usb_mt->dev_id].max_x, 0, 0);
+ input_set_abs_params(input_dev, ABS_Y, 0,
+ DEV_INFO[dwav_usb_mt->dev_id].max_y, 0, 0);
+
+ /* multi touch */
+ input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
+ DEV_INFO[dwav_usb_mt->dev_id].max_x, 0, 0);
+ input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
+ DEV_INFO[dwav_usb_mt->dev_id].max_y, 0, 0);
+ input_mt_init_slots(input_dev,
+ DEV_INFO[dwav_usb_mt->dev_id].max_finger, 0);
+
+ err = input_register_device(input_dev);
+ if (err) {
+ pr_err("%s - input_register_device failed, err: %d\n",
+ __func__, err);
+ return err;
+ }
+
+ dwav_usb_mt->input = input_dev;
+
+ return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+static int dwav_usb_mt_probe(struct usb_interface *intf,
+ const struct usb_device_id *id)
+{
+ struct dwav_usb_mt *dwav_usb_mt = NULL;
+ struct input_dev *input_dev = NULL;
+ struct usb_endpoint_descriptor *endpoint;
+ struct usb_device *udev = interface_to_usbdev(intf);
+
+ int err = 0;
+
+ endpoint = dwav_usb_mt_get_input_endpoint(intf->cur_altsetting);
+ if (!endpoint)
+ return -ENXIO;
+
+ dwav_usb_mt = kzalloc(sizeof(struct dwav_usb_mt), GFP_KERNEL);
+ if (!dwav_usb_mt)
+ return -ENOMEM;
+
+ dwav_usb_mt->dev_id = id->driver_info;
+
+ dwav_usb_mt->finger = kzalloc(sizeof(struct finger_t) *
+ DEV_INFO[dwav_usb_mt->dev_id].max_finger,
+ GFP_KERNEL);
+
+ if (!dwav_usb_mt->finger)
+ goto err_free_mem;
+
+ input_dev = input_allocate_device();
+ if (!input_dev)
+ goto err_free_mem;
+
+ dwav_usb_mt->data_size = sizeof(struct dwav_raw);
+ dwav_usb_mt->data = usb_alloc_coherent(udev, dwav_usb_mt->data_size,
+ GFP_KERNEL, &dwav_usb_mt->data_dma);
+ if (!dwav_usb_mt->data)
+ goto err_free_mem;
+
+ dwav_usb_mt->irq = usb_alloc_urb(0, GFP_KERNEL);
+ if (!dwav_usb_mt->irq) {
+ dev_dbg(&intf->dev,
+ "%s - usb_alloc_urb failed: usbtouch->irq\n",
+ __func__);
+ goto err_free_buffers;
+ }
+
+ if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) {
+ usb_fill_int_urb(dwav_usb_mt->irq, udev,
+ usb_rcvintpipe(udev, endpoint->bEndpointAddress),
+ dwav_usb_mt->data, dwav_usb_mt->data_size,
+ dwav_usb_mt_irq, dwav_usb_mt, endpoint->bInterval);
+ } else {
+ usb_fill_bulk_urb(dwav_usb_mt->irq, udev,
+ usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
+ dwav_usb_mt->data, dwav_usb_mt->data_size,
+ dwav_usb_mt_irq, dwav_usb_mt);
+ }
+
+ dwav_usb_mt->irq->dev = udev;
+ dwav_usb_mt->irq->transfer_dma = dwav_usb_mt->data_dma;
+ dwav_usb_mt->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+ dwav_usb_mt->interface = intf;
+
+ if (udev->manufacturer)
+ strlcpy(dwav_usb_mt->name,
+ udev->manufacturer, sizeof(dwav_usb_mt->name));
+
+ if (udev->product) {
+ if (udev->manufacturer)
+ strlcat(dwav_usb_mt->name,
+ " ", sizeof(dwav_usb_mt->name));
+
+ strlcat(dwav_usb_mt->name,
+ udev->product, sizeof(dwav_usb_mt->name));
+ }
+
+ if (!strlen(dwav_usb_mt->name)) {
+ snprintf(dwav_usb_mt->name, sizeof(dwav_usb_mt->name),
+ "D-WAV Scientific MultiTouch %04x:%04x",
+ le16_to_cpu(udev->descriptor.idVendor),
+ le16_to_cpu(udev->descriptor.idProduct));
+ }
+
+ usb_make_path(udev, dwav_usb_mt->phys, sizeof(dwav_usb_mt->phys));
+ strlcat(dwav_usb_mt->phys, "/input0", sizeof(dwav_usb_mt->phys));
+
+ usb_to_input_id(udev, &input_dev->id);
+
+ input_dev->dev.parent = &intf->dev;
+
+ err = dwav_usb_mt_init(dwav_usb_mt, (void *)input_dev);
+ if (err)
+ goto err_free_urb;
+
+ usb_set_intfdata(intf, dwav_usb_mt);
+
+ dev_info(&intf->dev, "%s\n", DEV_INFO[dwav_usb_mt->dev_id].name);
+
+ return 0;
+
+err_free_urb:
+ usb_free_urb(dwav_usb_mt->irq);
+
+err_free_buffers:
+ dwav_usb_mt_free_buffers(udev, dwav_usb_mt);
+
+err_free_mem:
+ if (input_dev)
+ input_free_device(input_dev);
+ kfree(dwav_usb_mt);
+
+ return err;
+}
+
+/*-------------------------------------------------------------------------*/
+static void dwav_usb_mt_disconnect(struct usb_interface *intf)
+{
+ struct dwav_usb_mt *dwav_usb_mt = usb_get_intfdata(intf);
+
+ if (!dwav_usb_mt)
+ return;
+
+ dev_dbg(&intf->dev,
+ "%s - dwav_usb_mt is initialized, cleaning up\n",
+ __func__);
+
+ usb_set_intfdata(intf, NULL);
+
+ /* this will stop IO via close */
+ input_unregister_device(dwav_usb_mt->input);
+
+ usb_free_urb(dwav_usb_mt->irq);
+
+ dwav_usb_mt_free_buffers(interface_to_usbdev(intf), dwav_usb_mt);
+
+ kfree(dwav_usb_mt);
+}
+
+/*-------------------------------------------------------------------------*/
+MODULE_DEVICE_TABLE(usb, dwav_usb_mt_devices);
+
+static struct usb_driver dwav_usb_mt_driver = {
+ .name = "dwav_usb_mt",
+ .probe = dwav_usb_mt_probe,
+ .disconnect = dwav_usb_mt_disconnect,
+ .suspend = dwav_usb_mt_suspend,
+ .resume = dwav_usb_mt_resume,
+ .reset_resume = dwav_usb_mt_reset_resume,
+ .id_table = dwav_usb_mt_devices,
+ .supports_autosuspend = 1,
+};
+
+module_usb_driver(dwav_usb_mt_driver);
+
+/*-------------------------------------------------------------------------*/
+MODULE_AUTHOR("Hardkernel Co.,Ltd");
+MODULE_DESCRIPTION("D-WAV USB(HID) MultiTouch Driver");
+MODULE_LICENSE("GPL");
+
+MODULE_ALIAS("dwav_usb_mt");
+/*-------------------------------------------------------------------------*/
diff -urN a/drivers/input/touchscreen/sx865x.c b/drivers/input/touchscreen/sx865x.c
--- a/drivers/input/touchscreen/sx865x.c 1970-01-01 01:00:00.000000000 +0100
+++ b/drivers/input/touchscreen/sx865x.c 2018-05-06 10:03:40.553940699 +0200
@@ -0,0 +1,584 @@
+/*
+ * drivers/input/touchscreen/sx865x.c
+ *
+ * Copyright (c) 2013 U-MoBo Srl
+ * Pierluigi Passaro <p.passaro@u-mobo.com>
+ *
+ * Using code from:
+ * - sx8650.c
+ * Copyright (c) 2009 Wayne Roberts
+ * - tsc2007.c
+ * Copyright (c) 2008 Kwangwoo Lee
+ * - ads7846.c
+ * Copyright (c) 2005 David Brownell
+ * Copyright (c) 2006 Nokia Corporation
+ * - corgi_ts.c
+ * Copyright (C) 2004-2005 Richard Purdie
+ * - omap_ts.[hc], ads7846.h, ts_osk.c
+ * Copyright (C) 2002 MontaVista Software
+ * Copyright (C) 2004 Texas Instruments
+ * Copyright (C) 2005 Dirk Behme
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_device.h>
+#include <linux/delay.h>
+
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+
+#include <linux/amlogic/pinctrl_amlogic.h>
+#include <linux/amlogic/aml_gpio_consumer.h>
+
+#define AMLGPIO_IRQ_BASE 96
+
+#endif
+
+/* timeout expires after pen is lifted, no more PENIRQs comming */
+/* adjust with POWDLY setting */
+#define TS_TIMEOUT (8 * 1000000)
+
+/* analog channels */
+#define CH_X 0
+#define CH_Y 1
+#define CH_Z1 2
+#define CH_Z2 3
+#define CH_AUX 4
+#define CH_RX 5
+#define CH_RY 6
+#define CH_SEQ 7
+
+/* commands */
+#define SX865X_WRITE_REGISTER 0x00
+#define SX865X_READ_REGISTER 0x40
+#define SX865X_SELECT_CH(ch) (0x80 | ch)
+#define SX865X_CONVERT_CH(ch) (0x90 | ch)
+#define SX865X_POWDWN 0xb0 /* power down, ignore pen */
+#define SX865X_PENDET 0xc0 /* " " with pen sensitivity */
+#define SX865X_PENTRG 0xe0 /* " " " " and sample channels */
+
+/* register addresses */
+#define I2C_REG_CTRL0 0x00
+#define I2C_REG_CTRL1 0x01
+#define I2C_REG_CTRL2 0x02
+#define I2C_REG_CTRL3 0x03
+#define I2C_REG_CHANMASK 0x04
+#define I2C_REG_STAT 0x05
+#define I2C_REG_SOFTRESET 0x1f
+
+#define I2C_EXTENDED_REG_STAT 0x24
+#define I2C_EXTENDED_REG_SOFTRESET 0x3f
+
+#define SOFTRESET_VALUE 0xde
+
+/* bits for I2C_REG_STAT */
+/* I2C_REG_STAT: end of conversion flag */
+#define STATUS_CONVIRQ 0x80
+/* I2C_REG_STAT: pen detected */
+#define STATUS_PENIRQ 0x40
+
+/* bits for I2C_EXTENDED_REG_STAT */
+/* I2C_EXTENDED_REG_STAT: end of conversion flag */
+#define EXTENDED_STATUS_CONVIRQ 0x08
+/* I2C_EXTENDED_REG_STAT: pen detected */
+#define EXTENDED_STATUS_PENIRQ 0x04
+
+/* sx865x bits for RegCtrl1 */
+#define CONDIRQ 0x20
+/* no averaging */
+#define FILT_NONE 0x00
+/* 3 sample averaging */
+#define FILT_3SA 0x01
+/* 5 sample averaging */
+#define FILT_5SA 0x02
+/* 7 samples, sort, then average of 3 middle samples */
+#define FILT_7SA 0x03
+
+/* bits for register 2, I2CRegChanMsk */
+#define CONV_X 0x80
+#define CONV_Y 0x40
+#define CONV_Z1 0x20
+#define CONV_Z2 0x10
+#define CONV_AUX 0x08
+#define CONV_RX 0x04
+#define CONV_RY 0x02
+
+/* power delay: lower nibble of CTRL0 register */
+#define POWDLY_IMMEDIATE 0x00
+#define POWDLY_1_1US 0x01
+#define POWDLY_2_2US 0x02
+#define POWDLY_4_4US 0x03
+#define POWDLY_8_9US 0x04
+#define POWDLY_17_8US 0x05
+#define POWDLY_35_5US 0x06
+#define POWDLY_71US 0x07
+#define POWDLY_140US 0x08
+#define POWDLY_280US 0x09
+#define POWDLY_570US 0x0a
+#define POWDLY_1_1MS 0x0b
+#define POWDLY_2_3MS 0x0c
+#define POWDLY_4_6MS 0x0d
+#define POWDLY_9MS 0x0e
+#define POWDLY_18MS 0x0f
+
+#define MAX_12BIT ((1 << 12) - 1)
+
+/* when changing the channel mask, also change the read length appropriately */
+#define CHAN_MASK (CONV_X | CONV_Y | CONV_Z1 | CONV_RX | CONV_RY)
+#define NUM_CHANNELS_SEQ 5
+#define CHAN_READ_LENGTH (NUM_CHANNELS_SEQ * 2)
+
+#define SX_MULTITOUCH 0x01
+#define SX_PROXIMITY_SENSING 0x02
+#define SX_HAPTICS_GENERIC 0x04
+#define SX_HAPTICS_IMMERSION 0x08
+#define SX_EXTENDED_REGS (SX_PROXIMITY_SENSING | SX_HAPTICS_GENERIC | SX_HAPTICS_IMMERSION)
+
+#define SX865X_UP_SCANTIME_MS (100)
+#define SX865X_DOWN_SCANTIME_MS (20)
+
+struct ts_event {
+ u16 x, y;
+ u16 z1;
+ u16 rx, ry;
+};
+
+struct sx865x {
+ struct input_dev *input;
+ struct ts_event tc;
+
+ struct i2c_client *client;
+
+ u32 invert_x;
+ u32 invert_y;
+ u32 swap_xy;
+ u32 gpio_pendown;
+ u32 gpio_reset;
+
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+ int irq_bank;
+#endif
+ unsigned pendown;
+ int irq;
+};
+
+static struct i2c_device_id sx865x_idtable[] = {
+ { "sx8650", 0 },
+ { }
+};
+
+MODULE_DEVICE_TABLE(i2c, sx865x_idtable);
+
+static const struct of_device_id sx865x_of_match[] = {
+ { .compatible = "semtech,sx8650", .data = (void *)0 },
+ {}
+};
+
+MODULE_DEVICE_TABLE(of, sx865x_of_match);
+
+static void sx865x_send_event(struct sx865x *ts)
+{
+ u32 rt;
+ u16 x, y, z1;
+
+ x = ts->tc.x;
+ y = ts->tc.y;
+ z1 = ts->tc.z1;
+
+ /* range filtering */
+ if (y == MAX_12BIT)
+ y = 0;
+
+ /* compute touch pressure resistance */
+ if (likely(y && z1))
+ rt = z1;
+ else
+ rt = 0;
+
+ /* Sample found inconsistent by debouncing or pressure is beyond
+ * the maximum. Don't report it to user space, repeat at least
+ * once more the measurement
+ */
+ if (rt > MAX_12BIT) {
+ dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
+ return;
+ }
+
+ /* NOTE: We can't rely on the pressure to determine the pen down
+ * state, even this controller has a pressure sensor. The pressure
+ * value can fluctuate for quite a while after lifting the pen and
+ * in some cases may not even settle at the expected value.
+ *
+ * The only safe way to check for the pen up condition is in the
+ * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
+ */
+ if (rt) {
+ struct input_dev *input = ts->input;
+
+ if (ts->invert_x) x = (~x) & MAX_12BIT;
+
+ if (ts->invert_y) y = (~y) & MAX_12BIT;
+
+ if (ts->swap_xy) swap(x, y);
+
+ if (!ts->pendown) {
+ dev_dbg(&ts->client->dev, "DOWN\n");
+ ts->pendown = 1;
+ input_report_key(input, BTN_TOUCH, 1);
+ }
+
+ input_report_abs(input, ABS_X, x);
+ input_report_abs(input, ABS_Y, y);
+ input_report_abs(input, ABS_PRESSURE, rt);
+ input_sync(input);
+
+ dev_dbg(&ts->client->dev, "point(%4d,%4d), pressure (%4u)\n",
+ x, y, rt);
+ }
+}
+
+static int sx865x_read_values(struct sx865x *ts)
+{
+ s32 data;
+ u16 vals[NUM_CHANNELS_SEQ+1]; /* +1 for last dummy read */
+ int length;
+ int i;
+
+ memset(&(ts->tc), 0, sizeof(ts->tc));
+ /* The protocol and raw data format from i2c interface:
+ * S Addr R A [DataLow] A [DataHigh] A (repeat) NA P
+ * Where DataLow has (channel | [D11-D8]), DataHigh has [D7-D0].
+ */
+ length = i2c_master_recv(ts->client, (char *)vals, CHAN_READ_LENGTH);
+
+ if (likely(length == CHAN_READ_LENGTH)) {
+ length >>= 1;
+ for (i = 0; i < length; i++) {
+ u16 ch;
+ data = swab16(vals[i]);
+ if (unlikely(data & 0x8000)) {
+ dev_dbg(&ts->client->dev,
+ "hibit @ %d [0x%04x]\n", i, data);
+ continue;
+ }
+ ch = data >> 12;
+ if (ch == CH_X) {
+ ts->tc.x = data & 0xfff;
+ } else if (ch == CH_Y) {
+ ts->tc.y = data & 0xfff;
+ } else if (ch == CH_Z1) {
+ ts->tc.z1 = data & 0xfff;
+ } else if (ch == CH_RX) {
+ ts->tc.rx = data & 0xfff;
+ } else if (ch == CH_RY) {
+ ts->tc.ry = data & 0xfff;
+ } else {
+ dev_err(&ts->client->dev, "? CH%d %x\n",
+ ch, data & 0xfff);
+ }
+ }
+ } else {
+ dev_err(&ts->client->dev, "%d = recv()\n", length);
+ }
+
+ dev_dbg(&ts->client->dev, "X:%03x Y:%03x Z1:%03x RX:%03x RY:%03x\n",
+ ts->tc.x, ts->tc.y, ts->tc.z1, ts->tc.rx, ts->tc.ry);
+
+ return !ts->tc.z1; /* return 0 only if pressure not 0 */
+}
+
+static void sx865x_pen_up(struct sx865x *ts)
+{
+ struct input_dev *input = ts->input;
+
+ /* This timer expires after PENIRQs havent been coming in for some time.
+ * It means that the pen is now UP. */
+ input_report_key(input, BTN_TOUCH, 0);
+ input_report_abs(input, ABS_PRESSURE, 0);
+ input_sync(input);
+
+ ts->pendown = 0;
+ dev_dbg(&ts->client->dev, "UP\n");
+}
+
+static int sx865x_data_available(struct sx865x *ts)
+{
+ u8 status;
+
+ status = i2c_smbus_read_byte_data(ts->client,
+ (SX865X_READ_REGISTER | I2C_REG_STAT));
+ return status & STATUS_CONVIRQ;
+}
+
+static int get_pendown_status(struct sx865x *ts)
+{
+ return gpio_get_value(ts->gpio_pendown) ? 0 : 1;
+}
+
+static irqreturn_t sx865x_hw_irq(int irq, void *handle)
+{
+ struct sx865x *ts = handle;
+
+ return get_pendown_status(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
+}
+
+static irqreturn_t sx865x_irq(int irq, void *handle)
+{
+ struct sx865x *ts = handle;
+
+ while (sx865x_data_available(ts)) {
+ /* valid data was read in */
+ if (likely(sx865x_read_values(ts) == 0))
+ sx865x_send_event(ts);
+ else
+ dev_dbg(&ts->client->dev, "data error!\n");
+
+ msleep(SX865X_DOWN_SCANTIME_MS);
+ }
+
+ if (ts->pendown)
+ sx865x_pen_up(ts);
+
+ return IRQ_HANDLED;
+}
+
+static void sx865x_hw_reset(struct sx865x *ts)
+{
+ gpio_direction_output(ts->gpio_reset, 0);
+ udelay(1000);
+ gpio_direction_output(ts->gpio_reset, 1);
+ udelay(1000);
+}
+
+static int sx865x_dt_probe(struct i2c_client *client, struct sx865x *ts)
+{
+ struct device_node *node = client->dev.of_node;
+ const struct of_device_id *match;
+
+ if (!node) {
+ dev_err(&client->dev,
+ "Device dost not have associated DT data\n");
+ return -EINVAL;
+ }
+
+ match = of_match_device(sx865x_of_match, &client->dev);
+ if (!match) {
+ dev_err(&client->dev,
+ "Unknown device model\n");
+ return -EINVAL;
+ }
+
+ of_property_read_u32(node, "swap-xy", &ts->swap_xy);
+ of_property_read_u32(node, "invert-x", &ts->invert_x);
+ of_property_read_u32(node, "invert-y", &ts->invert_y);
+
+ ts->gpio_pendown = of_get_named_gpio(node, "gpio-pendown", 0);
+ ts->gpio_reset = of_get_named_gpio(node, "gpio-reset", 0);
+
+ if (gpio_request(ts->gpio_pendown, "ts-pendown"))
+ dev_err(&client->dev,
+ "gpio request fail (%d)!\n", ts->gpio_pendown);
+ else
+ gpio_direction_input(ts->gpio_pendown);
+
+ if (gpio_request(ts->gpio_reset, "ts-reset"))
+ dev_err(&client->dev,
+ "gpio request fail (%d)!\n", ts->gpio_reset);
+ else
+ sx865x_hw_reset(ts);
+
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+ /* irq setup */
+ ts->irq_bank = meson_fix_irqbank(ts->irq_bank);
+ if (ts->irq_bank < 0) {
+ dev_err(&client->dev,
+ "Could not find irq bank!\n");
+ return -EINVAL;
+ }
+
+ {
+ int ret;
+ /* AMLogic gpio irq setup */
+ ret = gpio_for_irq(ts->gpio_pendown,
+ AML_GPIO_IRQ(ts->irq_bank, FILTER_NUM7, GPIO_IRQ_FALLING));
+
+ if (ret) {
+ dev_err(&client->dev,
+ "AML_GPIO_IRQ setup fail!\n");
+ return -EINVAL;
+ }
+ /* Amlogic gpio based irq setup */
+ ts->irq = AMLGPIO_IRQ_BASE + ts->irq_bank;
+ }
+#else
+ ts->irq = gpio_to_irq(ts->gpio_pendown);
+ if (ts->irq < 0)
+ return -EINVAL;
+#endif
+
+ /* platform data info display */
+ dev_info(&client->dev, "swap_xy (%d)\n", ts->swap_xy);
+ dev_info(&client->dev, "invert_x (%d)\n", ts->invert_x);
+ dev_info(&client->dev, "invert_y (%d)\n", ts->invert_y);
+ dev_info(&client->dev, "gpio pendown (%d)\n", ts->gpio_pendown);
+ dev_info(&client->dev, "gpio reset (%d)\n", ts->gpio_reset);
+ dev_info(&client->dev, "gpio irq (%d)\n", ts->irq);
+
+ return 0;
+}
+
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+static void sx865x_irq_free(struct i2c_client *client, struct sx865x *ts)
+{
+ int irq_banks[2];
+
+ meson_free_irq(gpio_to_irq(ts->gpio_pendown), &irq_banks[0]);
+
+ /* rising irq bank */
+ if (irq_banks[0] != -1)
+ free_irq(irq_banks[0] + AMLGPIO_IRQ_BASE, ts);
+
+ /* falling irq bank */
+ if (irq_banks[1] != -1)
+ free_irq(irq_banks[1] + AMLGPIO_IRQ_BASE, ts);
+}
+#endif
+
+static int sx865x_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct sx865x *ts;
+ struct input_dev *input_dev;
+ int err = 0;
+
+ dev_info(&client->dev, "sx865x_probe()\n");
+
+ if (!i2c_check_functionality(client->adapter,
+ I2C_FUNC_SMBUS_READ_WORD_DATA))
+ return -EIO;
+
+ ts = devm_kzalloc(&client->dev, sizeof(struct sx865x), GFP_KERNEL);
+ input_dev = devm_input_allocate_device(&client->dev);
+ if (!ts || !input_dev)
+ return -ENOMEM;
+
+ if (sx865x_dt_probe(client, ts) != 0)
+ return -EIO;
+
+ i2c_set_clientdata(client, ts);
+
+ input_dev->name = "SX865X Touchscreen";
+ input_dev->id.bustype = BUS_I2C;
+ input_dev->dev.parent = &client->dev;
+ input_set_drvdata(input_dev, ts);
+
+ 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, 0, MAX_12BIT, 0, 0);
+ input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
+ input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);
+
+ /* soft reset: SX8650 fails to nak at the end, ignore return value */
+ i2c_smbus_write_byte_data(client, I2C_REG_SOFTRESET, SOFTRESET_VALUE);
+
+ /* set mask to convert X, Y, Z1, RX, RY for CH_SEQ */
+ err = i2c_smbus_write_byte_data(client, I2C_REG_CHANMASK, CHAN_MASK);
+ if (err != 0) return -EIO;
+
+ err = i2c_smbus_write_byte_data(client, I2C_REG_CTRL1,
+ CONDIRQ | FILT_7SA);
+ if (err != 0) return -EIO;
+
+ /* set POWDLY settling time -- adjust TS_TIMEOUT accordingly */
+ err = i2c_smbus_write_byte_data(client, I2C_REG_CTRL0, POWDLY_1_1MS);
+ if (err != 0) return -EIO;
+
+ /* enter pen-trigger mode */
+ err = i2c_smbus_write_byte(client, SX865X_PENTRG);
+ if (err != 0) return -EIO;
+
+ err = request_threaded_irq(ts->irq, sx865x_hw_irq, sx865x_irq,
+ IRQF_ONESHOT,
+ client->dev.driver->name, ts);
+
+ if (err < 0) {
+ dev_err(&client->dev, "irq %d busy?\n", ts->irq);
+ return -EIO;
+ }
+
+ err = input_register_device(input_dev);
+ if (err)
+ goto err_free_irq;
+
+ ts->client = client;
+ ts->input = input_dev;
+
+ dev_info(&client->dev, "probe ok! registered with irq (%d)\n", ts->irq);
+
+ return 0;
+
+err_free_irq:
+ if (ts->gpio_pendown)
+ gpio_free(ts->gpio_pendown);
+ if (ts->gpio_reset)
+ gpio_free(ts->gpio_reset);
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+ sx865x_irq_free(client, ts);
+#else
+ if (ts->irq)
+ free_irq(ts->irq, ts);
+#endif
+ return err;
+}
+
+static int sx865x_remove(struct i2c_client *client)
+{
+ struct sx865x *ts = i2c_get_clientdata(client);
+ struct sx865x_platform_data *pdata;
+
+ pdata = client->dev.platform_data;
+
+ if (ts->gpio_pendown)
+ gpio_free(ts->gpio_pendown);
+ if (ts->gpio_reset)
+ gpio_free(ts->gpio_reset);
+#if defined(CONFIG_ARCH_MESON64_ODROIDC2)
+ sx865x_irq_free(client, ts);
+#else
+ if (ts->irq)
+ free_irq(ts->irq, ts);
+#endif
+ input_unregister_device(ts->input);
+
+ return 0;
+}
+
+static struct i2c_driver sx865x_driver = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "sx865x",
+ .of_match_table = of_match_ptr(sx865x_of_match),
+ },
+ .id_table = sx865x_idtable,
+ .probe = sx865x_probe,
+ .remove = sx865x_remove,
+};
+
+module_i2c_driver(sx865x_driver);
+
+MODULE_AUTHOR("Pierluigi Passaro <info@phoenixsoftware.it>");
+MODULE_DESCRIPTION("SX865X TouchScreen Driver");
+MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink