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 +#include +#include +#include +#include +#include +#include +#include + +#include + +/*-------------------------------------------------------------------------*/ +#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 + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_ARCH_MESON64_ODROIDC2) + +#include +#include + +#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 "); +MODULE_DESCRIPTION("SX865X TouchScreen Driver"); +MODULE_LICENSE("GPL");