diff options
| -rw-r--r-- | 0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch | 1001 | ||||
| -rw-r--r-- | config-generic | 1 | ||||
| -rw-r--r-- | kernel.spec | 9 |
3 files changed, 1011 insertions, 0 deletions
diff --git a/0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch b/0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch new file mode 100644 index 00000000..63217460 --- /dev/null +++ b/0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch @@ -0,0 +1,1001 @@ +Bugzilla: 1048314 +Upstream-status: Queued for 3.16 + +From 39141443c8ea2900af627d688a255e064e2b6e19 Mon Sep 17 00:00:00 2001 +From: Benjamin Tissoires <benjamin.tissoires@redhat.com> +Date: Wed, 9 Apr 2014 11:09:21 -0400 +Subject: [PATCH] HID: rmi: introduce RMI driver for Synaptics touchpads + +This driver add support for RMI4 over USB or I2C. +The current state is that it uses its own RMI4 implementation, but once +RMI4 is merged upstream, the driver will be a transport driver for the +RMI4 library. + +Part of this driver should be considered as temporary. Most of the RMI4 +processing and input handling will be deleted at some point. + +I based my work on Andrew's regarding its port of RMI4 over HID (see +https://github.com/mightybigcar/synaptics-rmi4/tree/rmihid ) +This repo presents how the driver may looks like at the end: +https://github.com/mightybigcar/synaptics-rmi4/blob/rmihid/drivers/input/rmi4/rmi_hid.c + +Without this temporary solution, the workaround we gave to users +is to disable i2c-hid, which leads to disabling the touchscreen on the +XPS 11 and 12 (Haswell generation). + +Related bugs: +https://bugzilla.redhat.com/show_bug.cgi?id=1048314 +https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1218973 + +Signed-off-by: Andrew Duggan <aduggan@synaptics.com> +Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com> +Signed-off-by: Jiri Kosina <jkosina@suse.cz> + +- Removed obviously wrong hid_hw_stop() at the end of probe + +Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com> +--- + drivers/hid/Kconfig | 8 + + drivers/hid/Makefile | 1 + + drivers/hid/hid-core.c | 2 + + drivers/hid/hid-rmi.c | 890 +++++++++++++++++++++++++++++++++++++++++++++++++ + include/linux/hid.h | 2 + + 6 files changed, 946 insertions(+) + create mode 100644 drivers/hid/hid-rmi.c + +diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig +index 34e2d39..b2d733b 100644 +--- a/drivers/hid/Kconfig ++++ b/drivers/hid/Kconfig +@@ -645,6 +645,14 @@ config HID_SUNPLUS + ---help--- + Support for Sunplus wireless desktop. + ++config HID_RMI ++ tristate "Synaptics RMI4 device support" ++ depends on HID ++ ---help--- ++ Support for Synaptics RMI4 touchpads. ++ Say Y here if you have a Synaptics RMI4 touchpads over i2c-hid or usbhid ++ and want support for its special functionalities. ++ + config HID_GREENASIA + tristate "GreenAsia (Product ID 0x12) game controller support" + depends on HID +diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile +index 30e4431..b326f79 100644 +--- a/drivers/hid/Makefile ++++ b/drivers/hid/Makefile +@@ -96,6 +96,7 @@ obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \ + hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \ + hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \ + hid-roccat-lua.o hid-roccat-pyra.o hid-roccat-ryos.o hid-roccat-savu.o ++obj-$(CONFIG_HID_RMI) += hid-rmi.o + obj-$(CONFIG_HID_SAITEK) += hid-saitek.o + obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o + obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 253fe23..543dd1f 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -1836,6 +1836,8 @@ static const struct hid_device_id hid_have_special_driver[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) }, + { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) }, + { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, HID_ANY_ID) }, ++ { HID_I2C_DEVICE(USB_VENDOR_ID_SYNAPTICS, HID_ANY_ID) }, + { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) }, + { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) }, + { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) }, +diff --git a/drivers/hid/hid-rmi.c b/drivers/hid/hid-rmi.c +new file mode 100644 +index 0000000..a4f04d4 +--- /dev/null ++++ b/drivers/hid/hid-rmi.c +@@ -0,0 +1,890 @@ ++/* ++ * Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com> ++ * Copyright (c) 2013 Synaptics Incorporated ++ * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com> ++ * Copyright (c) 2014 Red Hat, Inc ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License as published by the Free ++ * Software Foundation; either version 2 of the License, or (at your option) ++ * any later version. ++ */ ++ ++#include <linux/kernel.h> ++#include <linux/hid.h> ++#include <linux/input.h> ++#include <linux/input/mt.h> ++#include <linux/module.h> ++#include <linux/pm.h> ++#include <linux/slab.h> ++#include <linux/wait.h> ++#include <linux/sched.h> ++#include "hid-ids.h" ++ ++/* removed backported compat.h include */ ++ ++#define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */ ++#define RMI_WRITE_REPORT_ID 0x09 /* Output Report */ ++#define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */ ++#define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */ ++#define RMI_ATTN_REPORT_ID 0x0c /* Input Report */ ++#define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */ ++ ++/* flags */ ++#define RMI_READ_REQUEST_PENDING BIT(0) ++#define RMI_READ_DATA_PENDING BIT(1) ++#define RMI_STARTED BIT(2) ++ ++enum rmi_mode_type { ++ RMI_MODE_OFF = 0, ++ RMI_MODE_ATTN_REPORTS = 1, ++ RMI_MODE_NO_PACKED_ATTN_REPORTS = 2, ++}; ++ ++struct rmi_function { ++ unsigned page; /* page of the function */ ++ u16 query_base_addr; /* base address for queries */ ++ u16 command_base_addr; /* base address for commands */ ++ u16 control_base_addr; /* base address for controls */ ++ u16 data_base_addr; /* base address for datas */ ++ unsigned int interrupt_base; /* cross-function interrupt number ++ * (uniq in the device)*/ ++ unsigned int interrupt_count; /* number of interrupts */ ++ unsigned int report_size; /* size of a report */ ++ unsigned long irq_mask; /* mask of the interrupts ++ * (to be applied against ATTN IRQ) */ ++}; ++ ++/** ++ * struct rmi_data - stores information for hid communication ++ * ++ * @page_mutex: Locks current page to avoid changing pages in unexpected ways. ++ * @page: Keeps track of the current virtual page ++ * ++ * @wait: Used for waiting for read data ++ * ++ * @writeReport: output buffer when writing RMI registers ++ * @readReport: input buffer when reading RMI registers ++ * ++ * @input_report_size: size of an input report (advertised by HID) ++ * @output_report_size: size of an output report (advertised by HID) ++ * ++ * @flags: flags for the current device (started, reading, etc...) ++ * ++ * @f11: placeholder of internal RMI function F11 description ++ * @f30: placeholder of internal RMI function F30 description ++ * ++ * @max_fingers: maximum finger count reported by the device ++ * @max_x: maximum x value reported by the device ++ * @max_y: maximum y value reported by the device ++ * ++ * @gpio_led_count: count of GPIOs + LEDs reported by F30 ++ * @button_count: actual physical buttons count ++ * @button_mask: button mask used to decode GPIO ATTN reports ++ * @button_state_mask: pull state of the buttons ++ * ++ * @input: pointer to the kernel input device ++ * ++ * @reset_work: worker which will be called in case of a mouse report ++ * @hdev: pointer to the struct hid_device ++ */ ++struct rmi_data { ++ struct mutex page_mutex; ++ int page; ++ ++ wait_queue_head_t wait; ++ ++ u8 *writeReport; ++ u8 *readReport; ++ ++ int input_report_size; ++ int output_report_size; ++ ++ unsigned long flags; ++ ++ struct rmi_function f11; ++ struct rmi_function f30; ++ ++ unsigned int max_fingers; ++ unsigned int max_x; ++ unsigned int max_y; ++ unsigned int x_size_mm; ++ unsigned int y_size_mm; ++ ++ unsigned int gpio_led_count; ++ unsigned int button_count; ++ unsigned long button_mask; ++ unsigned long button_state_mask; ++ ++ struct input_dev *input; ++ ++ struct work_struct reset_work; ++ struct hid_device *hdev; ++}; ++ ++#define RMI_PAGE(addr) (((addr) >> 8) & 0xff) ++ ++static int rmi_write_report(struct hid_device *hdev, u8 *report, int len); ++ ++/** ++ * rmi_set_page - Set RMI page ++ * @hdev: The pointer to the hid_device struct ++ * @page: The new page address. ++ * ++ * RMI devices have 16-bit addressing, but some of the physical ++ * implementations (like SMBus) only have 8-bit addressing. So RMI implements ++ * a page address at 0xff of every page so we can reliable page addresses ++ * every 256 registers. ++ * ++ * The page_mutex lock must be held when this function is entered. ++ * ++ * Returns zero on success, non-zero on failure. ++ */ ++static int rmi_set_page(struct hid_device *hdev, u8 page) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ int retval; ++ ++ data->writeReport[0] = RMI_WRITE_REPORT_ID; ++ data->writeReport[1] = 1; ++ data->writeReport[2] = 0xFF; ++ data->writeReport[4] = page; ++ ++ retval = rmi_write_report(hdev, data->writeReport, ++ data->output_report_size); ++ if (retval != data->output_report_size) { ++ dev_err(&hdev->dev, ++ "%s: set page failed: %d.", __func__, retval); ++ return retval; ++ } ++ ++ data->page = page; ++ return 0; ++} ++ ++static int rmi_set_mode(struct hid_device *hdev, u8 mode) ++{ ++ int ret; ++ u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode}; ++ ++ ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, txbuf, ++ sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT); ++ if (ret < 0) { ++ dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode, ++ ret); ++ return ret; ++ } ++ ++ return 0; ++} ++ ++static int rmi_write_report(struct hid_device *hdev, u8 *report, int len) ++{ ++ int ret; ++ ++ ret = hid_hw_output_report(hdev, (void *)report, len); ++ if (ret < 0) { ++ dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret); ++ return ret; ++ } ++ ++ return ret; ++} ++ ++static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf, ++ const int len) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ int ret; ++ int bytes_read; ++ int bytes_needed; ++ int retries; ++ int read_input_count; ++ ++ mutex_lock(&data->page_mutex); ++ ++ if (RMI_PAGE(addr) != data->page) { ++ ret = rmi_set_page(hdev, RMI_PAGE(addr)); ++ if (ret < 0) ++ goto exit; ++ } ++ ++ for (retries = 5; retries > 0; retries--) { ++ data->writeReport[0] = RMI_READ_ADDR_REPORT_ID; ++ data->writeReport[1] = 0; /* old 1 byte read count */ ++ data->writeReport[2] = addr & 0xFF; ++ data->writeReport[3] = (addr >> 8) & 0xFF; ++ data->writeReport[4] = len & 0xFF; ++ data->writeReport[5] = (len >> 8) & 0xFF; ++ ++ set_bit(RMI_READ_REQUEST_PENDING, &data->flags); ++ ++ ret = rmi_write_report(hdev, data->writeReport, ++ data->output_report_size); ++ if (ret != data->output_report_size) { ++ clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); ++ dev_err(&hdev->dev, ++ "failed to write request output report (%d)\n", ++ ret); ++ goto exit; ++ } ++ ++ bytes_read = 0; ++ bytes_needed = len; ++ while (bytes_read < len) { ++ if (!wait_event_timeout(data->wait, ++ test_bit(RMI_READ_DATA_PENDING, &data->flags), ++ msecs_to_jiffies(1000))) { ++ hid_warn(hdev, "%s: timeout elapsed\n", ++ __func__); ++ ret = -EAGAIN; ++ break; ++ } ++ ++ read_input_count = data->readReport[1]; ++ memcpy(buf + bytes_read, &data->readReport[2], ++ read_input_count < bytes_needed ? ++ read_input_count : bytes_needed); ++ ++ bytes_read += read_input_count; ++ bytes_needed -= read_input_count; ++ clear_bit(RMI_READ_DATA_PENDING, &data->flags); ++ } ++ ++ if (ret >= 0) { ++ ret = 0; ++ break; ++ } ++ } ++ ++exit: ++ clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); ++ mutex_unlock(&data->page_mutex); ++ return ret; ++} ++ ++static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf) ++{ ++ return rmi_read_block(hdev, addr, buf, 1); ++} ++ ++static void rmi_f11_process_touch(struct rmi_data *hdata, int slot, ++ u8 finger_state, u8 *touch_data) ++{ ++ int x, y, wx, wy; ++ int wide, major, minor; ++ int z; ++ ++ input_mt_slot(hdata->input, slot); ++ input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER, ++ finger_state == 0x01); ++ if (finger_state == 0x01) { ++ x = (touch_data[0] << 4) | (touch_data[2] & 0x07); ++ y = (touch_data[1] << 4) | (touch_data[2] >> 4); ++ wx = touch_data[3] & 0x07; ++ wy = touch_data[3] >> 4; ++ wide = (wx > wy); ++ major = max(wx, wy); ++ minor = min(wx, wy); ++ z = touch_data[4]; ++ ++ /* y is inverted */ ++ y = hdata->max_y - y; ++ ++ input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x); ++ input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y); ++ input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide); ++ input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z); ++ input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); ++ input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); ++ } ++} ++ ++static void rmi_reset_work(struct work_struct *work) ++{ ++ struct rmi_data *hdata = container_of(work, struct rmi_data, ++ reset_work); ++ ++ /* switch the device to RMI if we receive a generic mouse report */ ++ rmi_set_mode(hdata->hdev, RMI_MODE_ATTN_REPORTS); ++} ++ ++static inline int rmi_schedule_reset(struct hid_device *hdev) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ return schedule_work(&hdata->reset_work); ++} ++ ++static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data, ++ int size) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ int offset; ++ int i; ++ ++ if (size < hdata->f11.report_size) ++ return 0; ++ ++ if (!(irq & hdata->f11.irq_mask)) ++ return 0; ++ ++ offset = (hdata->max_fingers >> 2) + 1; ++ for (i = 0; i < hdata->max_fingers; i++) { ++ int fs_byte_position = i >> 2; ++ int fs_bit_position = (i & 0x3) << 1; ++ int finger_state = (data[fs_byte_position] >> fs_bit_position) & ++ 0x03; ++ ++ rmi_f11_process_touch(hdata, i, finger_state, ++ &data[offset + 5 * i]); ++ } ++ input_mt_sync_frame(hdata->input); ++ input_sync(hdata->input); ++ return hdata->f11.report_size; ++} ++ ++static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data, ++ int size) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ int i; ++ int button = 0; ++ bool value; ++ ++ if (!(irq & hdata->f30.irq_mask)) ++ return 0; ++ ++ for (i = 0; i < hdata->gpio_led_count; i++) { ++ if (test_bit(i, &hdata->button_mask)) { ++ value = (data[i / 8] >> (i & 0x07)) & BIT(0); ++ if (test_bit(i, &hdata->button_state_mask)) ++ value = !value; ++ input_event(hdata->input, EV_KEY, BTN_LEFT + button++, ++ value); ++ } ++ } ++ return hdata->f30.report_size; ++} ++ ++static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ unsigned long irq_mask = 0; ++ unsigned index = 2; ++ ++ if (!(test_bit(RMI_STARTED, &hdata->flags))) ++ return 0; ++ ++ irq_mask |= hdata->f11.irq_mask; ++ irq_mask |= hdata->f30.irq_mask; ++ ++ if (data[1] & ~irq_mask) ++ hid_warn(hdev, "unknown intr source:%02lx %s:%d\n", ++ data[1] & ~irq_mask, __FILE__, __LINE__); ++ ++ if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) { ++ index += rmi_f11_input_event(hdev, data[1], &data[index], ++ size - index); ++ index += rmi_f30_input_event(hdev, data[1], &data[index], ++ size - index); ++ } else { ++ index += rmi_f30_input_event(hdev, data[1], &data[index], ++ size - index); ++ index += rmi_f11_input_event(hdev, data[1], &data[index], ++ size - index); ++ } ++ ++ return 1; ++} ++ ++static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ ++ if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) { ++ hid_err(hdev, "no read request pending\n"); ++ return 0; ++ } ++ ++ memcpy(hdata->readReport, data, size < hdata->input_report_size ? ++ size : hdata->input_report_size); ++ set_bit(RMI_READ_DATA_PENDING, &hdata->flags); ++ wake_up(&hdata->wait); ++ ++ return 1; ++} ++ ++static int rmi_raw_event(struct hid_device *hdev, ++ struct hid_report *report, u8 *data, int size) ++{ ++ switch (data[0]) { ++ case RMI_READ_DATA_REPORT_ID: ++ return rmi_read_data_event(hdev, data, size); ++ case RMI_ATTN_REPORT_ID: ++ return rmi_input_event(hdev, data, size); ++ case RMI_MOUSE_REPORT_ID: ++ rmi_schedule_reset(hdev); ++ break; ++ } ++ ++ return 0; ++} ++ ++static int rmi_post_reset(struct hid_device *hdev) ++{ ++ return rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); ++} ++ ++static int rmi_post_resume(struct hid_device *hdev) ++{ ++ return rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); ++} ++ ++#define RMI4_MAX_PAGE 0xff ++#define RMI4_PAGE_SIZE 0x0100 ++ ++#define PDT_START_SCAN_LOCATION 0x00e9 ++#define PDT_END_SCAN_LOCATION 0x0005 ++#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff) ++ ++struct pdt_entry { ++ u8 query_base_addr:8; ++ u8 command_base_addr:8; ++ u8 control_base_addr:8; ++ u8 data_base_addr:8; ++ u8 interrupt_source_count:3; ++ u8 bits3and4:2; ++ u8 function_version:2; ++ u8 bit7:1; ++ u8 function_number:8; ++} __attribute__((__packed__)); ++ ++static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count) ++{ ++ return GENMASK(irq_count + irq_base - 1, irq_base); ++} ++ ++static void rmi_register_function(struct rmi_data *data, ++ struct pdt_entry *pdt_entry, int page, unsigned interrupt_count) ++{ ++ struct rmi_function *f = NULL; ++ u16 page_base = page << 8; ++ ++ switch (pdt_entry->function_number) { ++ case 0x11: ++ f = &data->f11; ++ break; ++ case 0x30: ++ f = &data->f30; ++ break; ++ } ++ ++ if (f) { ++ f->page = page; ++ f->query_base_addr = page_base | pdt_entry->query_base_addr; ++ f->command_base_addr = page_base | pdt_entry->command_base_addr; ++ f->control_base_addr = page_base | pdt_entry->control_base_addr; ++ f->data_base_addr = page_base | pdt_entry->data_base_addr; ++ f->interrupt_base = interrupt_count; ++ f->interrupt_count = pdt_entry->interrupt_source_count; ++ f->irq_mask = rmi_gen_mask(f->interrupt_base, ++ f->interrupt_count); ++ } ++} ++ ++static int rmi_scan_pdt(struct hid_device *hdev) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ struct pdt_entry entry; ++ int page; ++ bool page_has_function; ++ int i; ++ int retval; ++ int interrupt = 0; ++ u16 page_start, pdt_start , pdt_end; ++ ++ hid_info(hdev, "Scanning PDT...\n"); ++ ++ for (page = 0; (page <= RMI4_MAX_PAGE); page++) { ++ page_start = RMI4_PAGE_SIZE * page; ++ pdt_start = page_start + PDT_START_SCAN_LOCATION; ++ pdt_end = page_start + PDT_END_SCAN_LOCATION; ++ ++ page_has_function = false; ++ for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) { ++ retval = rmi_read_block(hdev, i, &entry, sizeof(entry)); ++ if (retval) { ++ hid_err(hdev, ++ "Read of PDT entry at %#06x failed.\n", ++ i); ++ goto error_exit; ++ } ++ ++ if (RMI4_END_OF_PDT(entry.function_number)) ++ break; ++ ++ page_has_function = true; ++ ++ hid_info(hdev, "Found F%02X on page %#04x\n", ++ entry.function_number, page); ++ ++ rmi_register_function(data, &entry, page, interrupt); ++ interrupt += entry.interrupt_source_count; ++ } ++ ++ if (!page_has_function) ++ break; ++ } ++ ++ hid_info(hdev, "%s: Done with PDT scan.\n", __func__); ++ retval = 0; ++ ++error_exit: ++ return retval; ++} ++ ++static int rmi_populate_f11(struct hid_device *hdev) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ u8 buf[20]; ++ int ret; ++ bool has_query12; ++ bool has_physical_props; ++ unsigned x_size, y_size; ++ ++ if (!data->f11.query_base_addr) { ++ hid_err(hdev, "No 2D sensor found, giving up.\n"); ++ return -ENODEV; ++ } ++ ++ /* query 0 contains some useful information */ ++ ret = rmi_read(hdev, data->f11.query_base_addr, buf); ++ if (ret) { ++ hid_err(hdev, "can not get query 0: %d.\n", ret); ++ return ret; ++ } ++ has_query12 = !!(buf[0] & BIT(5)); ++ ++ /* query 1 to get the max number of fingers */ ++ ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf); ++ if (ret) { ++ hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret); ++ return ret; ++ } ++ data->max_fingers = (buf[0] & 0x07) + 1; ++ if (data->max_fingers > 5) ++ data->max_fingers = 10; ++ ++ data->f11.report_size = data->max_fingers * 5 + ++ DIV_ROUND_UP(data->max_fingers, 4); ++ ++ if (!(buf[0] & BIT(4))) { ++ hid_err(hdev, "No absolute events, giving up.\n"); ++ return -ENODEV; ++ } ++ ++ /* ++ * query 12 to know if the physical properties are reported ++ * (query 12 is at offset 10 for HID devices) ++ */ ++ if (has_query12) { ++ ret = rmi_read(hdev, data->f11.query_base_addr + 10, buf); ++ if (ret) { ++ hid_err(hdev, "can not get query 12: %d.\n", ret); ++ return ret; ++ } ++ has_physical_props = !!(buf[0] & BIT(5)); ++ ++ if (has_physical_props) { ++ ret = rmi_read_block(hdev, ++ data->f11.query_base_addr + 11, buf, 4); ++ if (ret) { ++ hid_err(hdev, "can not read query 15-18: %d.\n", ++ ret); ++ return ret; ++ } ++ ++ x_size = buf[0] | (buf[1] << 8); ++ y_size = buf[2] | (buf[3] << 8); ++ ++ data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10); ++ data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10); ++ ++ hid_info(hdev, "%s: size in mm: %d x %d\n", ++ __func__, data->x_size_mm, data->y_size_mm); ++ } ++ } ++ ++ /* retrieve the ctrl registers */ ++ ret = rmi_read_block(hdev, data->f11.control_base_addr, buf, 20); ++ if (ret) { ++ hid_err(hdev, "can not read ctrl block of size 20: %d.\n", ret); ++ return ret; ++ } ++ ++ data->max_x = buf[6] | (buf[7] << 8); ++ data->max_y = buf[8] | (buf[9] << 8); ++ ++ return 0; ++} ++ ++static int rmi_populate_f30(struct hid_device *hdev) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ u8 buf[20]; ++ int ret; ++ bool has_gpio, has_led; ++ unsigned bytes_per_ctrl; ++ u8 ctrl2_addr; ++ int ctrl2_3_length; ++ int i; ++ ++ /* function F30 is for physical buttons */ ++ if (!data->f30.query_base_addr) { ++ hid_err(hdev, "No GPIO/LEDs found, giving up.\n"); ++ return -ENODEV; ++ } ++ ++ ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2); ++ if (ret) { ++ hid_err(hdev, "can not get F30 query registers: %d.\n", ret); ++ return ret; ++ } ++ ++ has_gpio = !!(buf[0] & BIT(3)); ++ has_led = !!(buf[0] & BIT(2)); ++ data->gpio_led_count = buf[1] & 0x1f; ++ ++ /* retrieve ctrl 2 & 3 registers */ ++ bytes_per_ctrl = (data->gpio_led_count + 7) / 8; ++ /* Ctrl0 is present only if both has_gpio and has_led are set*/ ++ ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0; ++ /* Ctrl1 is always be present */ ++ ctrl2_addr += bytes_per_ctrl; ++ ctrl2_3_length = 2 * bytes_per_ctrl; ++ ++ data->f30.report_size = bytes_per_ctrl; ++ ++ ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr, ++ buf, ctrl2_3_length); ++ if (ret) { ++ hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n", ++ ctrl2_3_length, ret); ++ return ret; ++ } ++ ++ for (i = 0; i < data->gpio_led_count; i++) { ++ int byte_position = i >> 3; ++ int bit_position = i & 0x07; ++ u8 dir_byte = buf[byte_position]; ++ u8 data_byte = buf[byte_position + bytes_per_ctrl]; ++ bool dir = (dir_byte >> bit_position) & BIT(0); ++ bool dat = (data_byte >> bit_position) & BIT(0); ++ ++ if (dir == 0) { ++ /* input mode */ ++ if (dat) { ++ /* actual buttons have pull up resistor */ ++ data->button_count++; ++ set_bit(i, &data->button_mask); ++ set_bit(i, &data->button_state_mask); ++ } ++ } ++ ++ } ++ ++ return 0; ++} ++ ++static int rmi_populate(struct hid_device *hdev) ++{ ++ int ret; ++ ++ ret = rmi_scan_pdt(hdev); ++ if (ret) { ++ hid_err(hdev, "PDT scan failed with code %d.\n", ret); ++ return ret; ++ } ++ ++ ret = rmi_populate_f11(hdev); ++ if (ret) { ++ hid_err(hdev, "Error while initializing F11 (%d).\n", ret); ++ return ret; ++ } ++ ++ ret = rmi_populate_f30(hdev); ++ if (ret) ++ hid_warn(hdev, "Error while initializing F30 (%d).\n", ret); ++ ++ return 0; ++} ++ ++static void rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) ++{ ++ struct rmi_data *data = hid_get_drvdata(hdev); ++ struct input_dev *input = hi->input; ++ int ret; ++ int res_x, res_y, i; ++ ++ data->input = input; ++ ++ hid_dbg(hdev, "Opening low level driver\n"); ++ ret = hid_hw_open(hdev); ++ if (ret) ++ return; ++ ++ /* Allow incoming hid reports */ ++ hid_device_io_start(hdev); ++ ++ ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); ++ if (ret < 0) { ++ dev_err(&hdev->dev, "failed to set rmi mode\n"); ++ goto exit; ++ } ++ ++ ret = rmi_set_page(hdev, 0); ++ if (ret < 0) { ++ dev_err(&hdev->dev, "failed to set page select to 0.\n"); ++ goto exit; ++ } ++ ++ ret = rmi_populate(hdev); ++ if (ret) ++ goto exit; ++ ++ __set_bit(EV_ABS, input->evbit); ++ input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0); ++ input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0); ++ ++ if (data->x_size_mm && data->x_size_mm) { ++ res_x = (data->max_x - 1) / data->x_size_mm; ++ res_y = (data->max_y - 1) / data->x_size_mm; ++ ++ input_abs_set_res(input, ABS_MT_POSITION_X, res_x); ++ input_abs_set_res(input, ABS_MT_POSITION_Y, res_y); ++ } ++ ++ input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0); ++ input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0); ++ input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0); ++ input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0); ++ ++ input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER); ++ ++ if (data->button_count) { ++ __set_bit(EV_KEY, input->evbit); ++ for (i = 0; i < data->button_count; i++) ++ __set_bit(BTN_LEFT + i, input->keybit); ++ ++ if (data->button_count == 1) ++ __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); ++ } ++ ++ set_bit(RMI_STARTED, &data->flags); ++ ++exit: ++ hid_device_io_stop(hdev); ++ hid_hw_close(hdev); ++} ++ ++static int rmi_input_mapping(struct hid_device *hdev, ++ struct hid_input *hi, struct hid_field *field, ++ struct hid_usage *usage, unsigned long **bit, int *max) ++{ ++ /* we want to make HID ignore the advertised HID collection */ ++ return -1; ++} ++ ++static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) ++{ ++ struct rmi_data *data = NULL; ++ int ret; ++ size_t alloc_size; ++ ++ data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL); ++ if (!data) ++ return -ENOMEM; ++ ++ INIT_WORK(&data->reset_work, rmi_reset_work); ++ data->hdev = hdev; ++ ++ hid_set_drvdata(hdev, data); ++ ++ hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; ++ ++ ret = hid_parse(hdev); ++ if (ret) { ++ hid_err(hdev, "parse failed\n"); ++ return ret; ++ } ++ ++ data->input_report_size = (hdev->report_enum[HID_INPUT_REPORT] ++ .report_id_hash[RMI_ATTN_REPORT_ID]->size >> 3) ++ + 1 /* report id */; ++ data->output_report_size = (hdev->report_enum[HID_OUTPUT_REPORT] ++ .report_id_hash[RMI_WRITE_REPORT_ID]->size >> 3) ++ + 1 /* report id */; ++ ++ alloc_size = data->output_report_size + data->input_report_size; ++ ++ data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); ++ if (!data->writeReport) { ++ ret = -ENOMEM; ++ return ret; ++ } ++ ++ data->readReport = data->writeReport + data->output_report_size; ++ ++ init_waitqueue_head(&data->wait); ++ ++ mutex_init(&data->page_mutex); ++ ++ ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); ++ if (ret) { ++ hid_err(hdev, "hw start failed\n"); ++ return ret; ++ } ++ ++ if (!test_bit(RMI_STARTED, &data->flags)) { ++ hid_hw_stop(hdev); ++ return -EIO; ++ } ++ ++ return 0; ++} ++ ++static void rmi_remove(struct hid_device *hdev) ++{ ++ struct rmi_data *hdata = hid_get_drvdata(hdev); ++ ++ clear_bit(RMI_STARTED, &hdata->flags); ++ ++ hid_hw_stop(hdev); ++} ++ ++static const struct hid_device_id rmi_id[] = { ++ { HID_I2C_DEVICE(USB_VENDOR_ID_SYNAPTICS, HID_ANY_ID) }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, HID_ANY_ID) }, ++ { } ++}; ++MODULE_DEVICE_TABLE(hid, rmi_id); ++ ++static struct hid_driver rmi_driver = { ++ .name = "hid-rmi", ++ .id_table = rmi_id, ++ .probe = rmi_probe, ++ .remove = rmi_remove, ++ .raw_event = rmi_raw_event, ++ .input_mapping = rmi_input_mapping, ++ .input_configured = rmi_input_configured, ++#ifdef CONFIG_PM ++ .resume = rmi_post_resume, ++ .reset_resume = rmi_post_reset, ++#endif ++}; ++ ++module_hid_driver(rmi_driver); ++ ++MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>"); ++MODULE_DESCRIPTION("RMI HID driver"); ++MODULE_LICENSE("GPL"); +diff --git a/include/linux/hid.h b/include/linux/hid.h +index 31b9d29..1b5f1e9 100644 +--- a/include/linux/hid.h ++++ b/include/linux/hid.h +@@ -571,6 +571,8 @@ struct hid_descriptor { + .bus = BUS_USB, .vendor = (ven), .product = (prod) + #define HID_BLUETOOTH_DEVICE(ven, prod) \ + .bus = BUS_BLUETOOTH, .vendor = (ven), .product = (prod) ++#define HID_I2C_DEVICE(ven, prod) \ ++ .bus = BUS_I2C, .vendor = (ven), .product = (prod) + + #define HID_REPORT_ID(rep) \ + .report_type = (rep) +-- +1.8.3.1 + diff --git a/config-generic b/config-generic index e85fcf27..1d219016 100644 --- a/config-generic +++ b/config-generic @@ -3590,6 +3590,7 @@ CONFIG_HID_ORTEK=m CONFIG_HID_PANTHERLORD=m CONFIG_HID_PETALYNX=m CONFIG_HID_PICOLCD=m +CONFIG_HID_RMI=m CONFIG_HID_ROCCAT=m CONFIG_HID_ROCCAT_KONE=m CONFIG_HID_SAMSUNG=m diff --git a/kernel.spec b/kernel.spec index 8da5868c..89d1a743 100644 --- a/kernel.spec +++ b/kernel.spec @@ -637,6 +637,9 @@ Patch25061: gpio-ACPI-Dont-crash-on-NULL-chip-dev.patch #CVE-2014-0155 rhbz 1081589 1085016 Patch25060: KVM-ioapic-fix-assignment-of-ioapic-rtc_status-pending_eoi.patch +#rhbz 1048314 +Patch25062: 0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch + # END OF PATCH DEFINITIONS %endif @@ -1283,6 +1286,9 @@ ApplyPatch gpio-ACPI-Dont-crash-on-NULL-chip-dev.patch #CVE-2014-0155 rhbz 1081589 1085016 ApplyPatch KVM-ioapic-fix-assignment-of-ioapic-rtc_status-pending_eoi.patch +#rhbz 1048314 +ApplyPatch 0001-HID-rmi-introduce-RMI-driver-for-Synaptics-touchpads.patch + # END OF PATCH APPLICATIONS %endif @@ -2062,6 +2068,9 @@ fi # ||----w | # || || %changelog +* Thu Apr 10 2014 Josh Boyer <jwboyer@fedoraproject.org> +- Backported HID RMI driver for Haswell Dell XPS machines from Benjamin Tissoires (rhbz 1048314) + * Wed Apr 09 2014 Josh Boyer <jwboyer@fedoraproject.org> - 3.15.0-0.rc0.git10.1 - Linux v3.14-12042-g69cd9eba3886 |