Universal Stylus Interface (USI) is a new HID hardware spec for
supporting Pen input devices. These devices have a few additional
features compared to the existing HID pen support, and they are mapped
via the EV_MSC interface. A new HID driver is added for supporting the
USI pens, to isolate the quirks these devices have.
USI HID events are documented in the public USB-HID usage table:
https://usb.org/document-library/hid-usage-tables-122
See chapter 16, Digitizers Page (0x0D)
Signed-off-by: Tero Kristo <tero.kristo@xxxxxxxxxxxxxxx>
---
drivers/hid/Kconfig | 5 +
drivers/hid/Makefile | 1 +
drivers/hid/hid-usi.c | 774 ++++++++++++++++++++++++++++++++++++++++++
include/linux/hid.h | 7 +
4 files changed, 787 insertions(+)
create mode 100644 drivers/hid/hid-usi.c
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 3c33bf572d6d..c235ecb8f037 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -1222,6 +1222,11 @@ config HID_MCP2221
To compile this driver as a module, choose M here: the module
will be called hid-mcp2221.ko.
+config HID_USI
+ tristate "USI (Universal Stylus Interface) support"
+ help
+ Provides USI support over I2C HID interface.
+
endmenu
endif # HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index e29efcb1c040..86bafd2b147e 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -124,6 +124,7 @@ hid-uclogic-objs := hid-uclogic-core.o \
hid-uclogic-params.o
obj-$(CONFIG_HID_UCLOGIC) += hid-uclogic.o
obj-$(CONFIG_HID_UDRAW_PS3) += hid-udraw-ps3.o
+obj-$(CONFIG_HID_USI) += hid-usi.o
obj-$(CONFIG_HID_LED) += hid-led.o
obj-$(CONFIG_HID_XINMO) += hid-xinmo.o
obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o
diff --git a/drivers/hid/hid-usi.c b/drivers/hid/hid-usi.c
new file mode 100644
index 000000000000..4674e6993f6e
--- /dev/null
+++ b/drivers/hid/hid-usi.c
@@ -0,0 +1,774 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * HID driver for USI (Universal Stylus Interface)
+ *
+ * Copyright (C) 2021, Intel Corporation
+ * Authors: Tero Kristo <tero.kristo@xxxxxxxxxxxxxxx>
+ * Mika Westerberg <mika.westerberg@xxxxxxxxxxxxxxx>
+ * Rajmohan Mani <rajmohan.mani@xxxxxxxxx>
+ */
+
+#include <linux/module.h>
+#include <linux/sysfs.h>
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/leds.h>
+#include <linux/workqueue.h>
+
+#include "hid-ids.h"
+
+#define USI_HAS_PENS 0
+#define USI_PENS_CONFIGURED 1
+
+enum {
+ USI_PEN_FLAGS = 0,
+ USI_PEN_ID,
+ USI_PEN_COLOR,
+ USI_PEN_LINE_WIDTH,
+ USI_PEN_LINE_STYLE,
+ USI_NUM_ATTRS
+};
+
+enum {
+ USI_QUIRK_STYLE_MAX_VAL = 0,
+ USI_QUIRK_QUERY_DATA,
+};
+
+#define USI_MAX_PENS 10
+#define MSC_PEN_FIRST MSC_PEN_ID
+#define MSC_PEN_LAST MSC_PEN_LINE_STYLE
+
+struct usi_pen {
+ int index;
+ int values[MSC_PEN_LAST - MSC_PEN_FIRST + 1];
+};
+
+struct usi_drvdata {
+ struct hid_report *features[USI_NUM_ATTRS];
+ struct hid_field *inputs[USI_NUM_ATTRS];
+ unsigned long quirks;
+ unsigned long timeout;
+ u8 in_range_bit;
+ u8 tip_switch_bit;
+ int min_pen;
+ int max_pen;
+ unsigned long flags;
+ struct usi_pen *pens;
+ unsigned long sync_point;
+ size_t npens;
+ struct input_dev *idev;
+ struct hid_device *hdev;
+ struct usi_pen *current_pen;
+ unsigned long query_pending;
+ unsigned long update_pending;
+ unsigned long query_running;
+ bool need_flush;
+ struct delayed_work work;
+ u8 saved_data[USI_NUM_ATTRS];
+ spinlock_t lock; /* private data lock */
+};
+
+static bool _has_quirk(struct usi_drvdata *usi, int quirk)
+{
+ if (test_bit(quirk, &usi->quirks))
+ return true;
+
+ return false;
+}
+
+static int __map_usage(struct hid_usage *usage, struct hid_field *field,
+ u8 *bit)
+{
+ if (usage->hid == HID_DG_TRANSDUCER_INDEX)
+ return USI_PEN_ID;
+
+ if (usage->hid == HID_DG_INRANGE ||
+ usage->hid == HID_DG_TIPSWITCH) {
+ *bit = usage->usage_index;
+ return USI_PEN_FLAGS;
+ }
+
+ if (usage->hid == HID_DG_PEN_COLOR)
+ return USI_PEN_COLOR;
+
+ if (usage->hid == HID_DG_PEN_LINE_WIDTH)
+ return USI_PEN_LINE_WIDTH;
+
+ if (field->logical == HID_DG_PEN_LINE_STYLE &&
+ usage->hid >= HID_DG_PEN_LINE_STYLE_IS_LOCKED &&
+ usage->hid <= HID_DG_PEN_LINE_STYLE_NO_PREFERENCE)
+ return USI_PEN_LINE_STYLE;
+
+ return -EINVAL;
+}
+
+static inline int __usi_to_msc_id(int id)
+{
+ if (id < USI_PEN_ID || id > USI_PEN_LINE_STYLE)
+ return -EINVAL;
+
+ return id - USI_PEN_ID + MSC_PEN_ID;
+}
+
+static inline int __msc_to_usi_id(unsigned int code)
+{
+ if (code < MSC_PEN_ID || code > MSC_PEN_LINE_STYLE)
+ return -EINVAL;
+
+ return code - MSC_PEN_ID + USI_PEN_ID;
+}
+
+static inline int __usi_pen_get_value(const struct usi_pen *pen,
+ unsigned int code)
+{
+ if (!pen)
+ return -ENODEV;
+
+ return pen->values[code - MSC_PEN_FIRST];
+}
+
+static inline void __usi_pen_set_value(struct usi_pen *pen,
+ unsigned int code, int value)
+{
+ if (!pen)
+ return;
+
+ pen->values[code - MSC_PEN_FIRST] = value;
+}
+
+static struct usi_pen *usi_find_pen(struct usi_drvdata *usi, int index)
+{
+ int i;
+
+ for (i = 0; i < usi->npens; i++) {
+ if (usi->pens[i].index == index)
+ return &usi->pens[i];
+ }
+
+ return NULL;
+}
+
+static bool _in_range(struct usi_drvdata *usi, unsigned long flags)
+{
+ return !!(test_bit(usi->in_range_bit, &flags));
+}
+
+static bool _is_touching(struct usi_drvdata *usi, unsigned long flags)
+{
+ return !!(test_bit(usi->tip_switch_bit, &flags));
+}
+
+static struct usi_pen *_usi_select_pen(struct usi_drvdata *usi, int index,
+ bool in_range)
+{
+ struct usi_pen *pen, *found;
+ int i;
+
+ /* If not in range, forget current pen, and report to input-layer */
+ if (!in_range) {
+ usi->current_pen = NULL;
+ usi->update_pending = 0;
+ usi->query_pending = 0;
+ usi->query_running = 0;
+ input_event(usi->idev, EV_MSC, MSC_PEN_ID, 0);
+ input_sync(usi->idev);
+ return NULL;
+ }
+
+ pen = usi->current_pen;
+ if (pen && pen->index == index)
+ return pen;
+
+ found = usi_find_pen(usi, index);
+ if (!found) {
+ /* Pick next available pen */
+ for (i = 0; i < usi->npens; i++) {
+ pen = &usi->pens[i];
+
+ if (pen->index == -1) {
+ pen->index = index;
+
+ __usi_pen_set_value(pen, MSC_PEN_ID, index);
+ __usi_pen_set_value(pen, MSC_PEN_LINE_STYLE, 1);
+
+ hid_dbg(usi->hdev, "pen %u allocated\n",
+ index);
+
+ found = pen;
+
+ break;
+ }
+ }
+ }
+
+ if (!found)
+ return ERR_PTR(-ENOMEM);
+
+ usi->sync_point = jiffies;
+ usi->current_pen = found;
+
+ input_event(usi->idev, EV_MSC, MSC_PEN_ID, found->index);
+
+ if (_has_quirk(usi, USI_QUIRK_QUERY_DATA)) {
+ for (i = USI_PEN_COLOR; i <= USI_PEN_LINE_STYLE; i++)
+ set_bit(i, &usi->query_pending);
+ cancel_delayed_work_sync(&usi->work);
+ schedule_delayed_work(&usi->work, 0);
+ } else {
+ // HW reads the pen automatically
+ for (i = USI_PEN_COLOR; i <= USI_PEN_LINE_STYLE; i++)
+ set_bit(i, &usi->query_running);
+ }
+
+ return found;
+}
+
+/**
+ * __usi_input_event - Parse input event passed from input layer
+ * @usi: USI handle
+ * @code: input event code
+ * @value: input event value
+ *
+ * Parses input event passed from input layer. This is used to detect
+ * any writes to the USI driver from userspace and to program hardware
+ * to the new value. No return value.
+ */
+static void __usi_input_event(struct usi_drvdata *usi, unsigned int code,
+ int value)
+{
+ struct usi_pen *pen = usi->current_pen;
+ int cached;
+ unsigned long flags;
+
+ hid_dbg(usi->hdev, "input-event: pen=%d, code=%x, value=%d, cached=%d, update-pending=%lx\n",
+ pen ? pen->index : -1, code, value,
+ pen ? __usi_pen_get_value(pen, code) : -1,
+ usi->update_pending);
+
+ if (code < MSC_PEN_COLOR || code > MSC_PEN_LINE_STYLE)
+ return;
+
+ if (!pen)
+ return;
+
+ if (test_bit(__msc_to_usi_id(code), &usi->update_pending))
+ return;
+
+ /*
+ * Check if we get a value that is different than what is in cache,
+ * in this case userspace has written a new value.
+ */
+ cached = __usi_pen_get_value(pen, code);
+ if (cached == value)
+ return;
+
+ /*
+ * New value received, kick off the work for actually re-programming HW
+ */
+ spin_lock_irqsave(&usi->lock, flags);
+ set_bit(__msc_to_usi_id(code), &usi->update_pending);
+ spin_unlock_irqrestore(&usi->lock, flags);
+
+ __usi_pen_set_value(pen, code, value);
+
+ if (!delayed_work_pending(&usi->work)) {
+ long delay = usi->timeout - (jiffies - usi->sync_point);
+
+ if (delay < 0)
+ delay = 0;
+
+ schedule_delayed_work(&usi->work, delay);
+ }
+}
+
+static int _usi_input_event(struct input_dev *input, unsigned int type,
+ unsigned int code, int value)
+{
+ struct hid_device *dev = input_get_drvdata(input);
+ struct usi_drvdata *usi = hid_get_drvdata(dev);
+
+ if (value < 0)
+ return 0;
+
+ if (type == EV_MSC) {
+ switch (code) {
+ case MSC_PEN_COLOR:
+ case MSC_PEN_LINE_WIDTH:
+ case MSC_PEN_LINE_STYLE:
+ __usi_input_event(usi, code, value);
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static int _usi_input_open(struct input_dev *input)
+{
+ struct hid_device *hdev = input_get_drvdata(input);
+ struct usi_drvdata *usi = hid_get_drvdata(hdev);
+
+ /*
+ * When a new input handle is opened, we must flush the current
+ * pen attributes, otherwise client will not know current values.
+ */
+ usi->need_flush = true;
+
+ return hid_hw_open(hdev);
+}
+
+/**
+ * usi_input_mapping - Parse input mappings passed from HID core
+ * @hdev: HID device
+ * @hi: HID input
+ * @field: HID field
+ * @usage: HID usage
+ * @bit: HID usage bitmap (output)
+ * @max: max usage (output)
+ *
+ * Parse input mappings and apply USI specific tweaks.
+ * Always returns 0 for success.
+ */
+static int usi_input_mapping(struct hid_device *hdev,
+ struct hid_input *hi, struct hid_field *field,
+ struct hid_usage *usage, unsigned long **bit,
+ int *max)
+{
+ struct usi_drvdata *usi = hid_get_drvdata(hdev);
+ int usi_id;
+ u8 bit_idx;
+
+ hid_dbg(hdev, "input-field[%d] usage=%x[%d], phys=%x, log=%x, app=%x\n",
+ field->index, usage->hid, usage->usage_index, field->physical,
+ field->logical, field->application);
+
+ if ((usage->hid & HID_USAGE_PAGE) != HID_UP_DIGITIZER ||
+ field->application != HID_DG_PEN ||
+ field->physical != HID_DG_STYLUS)
+ return 0;
+
+ /*
+ * Pen line style report appears to contain strange encoding
+ * which confuses HID core. Fix this by forcing it to be
+ * a variable.
+ */
+ if (field->logical == HID_DG_PEN_LINE_STYLE)
+ field->flags |= HID_MAIN_ITEM_VARIABLE;
+
+ /*
+ * Save the field for any USI inputs, needed for parsing
+ * raw events.
+ */
+ usi_id = __map_usage(usage, field, &bit_idx);
+ if (usi_id < 0)
+ return 0;
+
+ hid_dbg(usi->hdev, "usi-id %d mapped to offset %d\n",
+ usi_id, field->report_offset);
+
+ usi->inputs[usi_id] = field;
+
+ if (usi_id == USI_PEN_FLAGS) {
+ if (usage->hid == HID_DG_INRANGE)
+ usi->in_range_bit = bit_idx;
+ if (usage->hid == HID_DG_TIPSWITCH)
+ usi->tip_switch_bit = bit_idx;
+ }
+
+ return 0;
+}
+
+/**
+ * usi_raw_event - Parse raw USI events
+ * @hdev: HID device
+ * @report: report being parsed
+ * @data: raw data being parsed
+ * @size: size of the data
+ *
+ * Parses raw events passed directly from HID low level drivers. Used to
+ * select the current pen, and also updates the cached pen variables
+ * to the data if these differ from the ones coming from HW. This is done
+ * because HW reports incorrect values when coming to contact with screen.
+ * Returns 0 in success, negative error value with failure.
+ */
+static int usi_raw_event(struct hid_device *hdev,
+ struct hid_report *report, u8 *data, int size)
+{
+ struct usi_drvdata *usi = hid_get_drvdata(hdev);
+ struct usi_pen *pen;
+ int i, index;
+ unsigned long flags;
+ u8 *ptr;
+ bool check_work = false;
+ struct hid_field *config;
+ bool touching;
+
+ if (report->application != HID_DG_PEN)
+ return 0;
+
+ hid_dbg(usi->hdev, "%s: qp:%lx, qr:%lx, up:%lx, data=%*ph\n",
+ __func__, usi->query_pending, usi->query_running,
+ usi->update_pending, size, data);
+
+ /* Get pen index */
+ index = data[usi->inputs[USI_PEN_ID]->report_offset / 8 + 1];
+ flags = data[usi->inputs[USI_PEN_FLAGS]->report_offset / 8 + 1];
+
+ pen = _usi_select_pen(usi, index, _in_range(usi, flags));
+ if (!pen)
+ return -ENOENT;
+
+ touching = _is_touching(usi, flags);
+
+ for (i = USI_PEN_COLOR; i < USI_NUM_ATTRS; i++) {
+ int cached = __usi_pen_get_value(pen, __usi_to_msc_id(i));
+ bool changed = false;
+
+ config = usi->inputs[i];
+ ptr = &data[config->report_offset / 8 + 1];
+
+ if (usi->saved_data[i] != *ptr)
+ changed = true;
+
+ hid_dbg(usi->hdev, "%s: i=%d, saved=%x, val=%x, cached=%x, changed=%d\n",
+ __func__, i,
+ usi->saved_data[i],
+ *ptr, cached, changed);
+
+ usi->saved_data[i] = *ptr;
+
+ /*
+ * Limit logical values to min/max. Pen style has strange
+ * mapping that goes outside ranges.
+ */
+ if (*ptr < config->logical_minimum)
+ *ptr = config->logical_minimum;
+
+ if (*ptr > config->logical_maximum)
+ *ptr = config->logical_maximum;
+
+ if (!touching && !_has_quirk(usi, USI_QUIRK_QUERY_DATA)) {
+ usi->sync_point = jiffies;
+ spin_lock_irqsave(&usi->lock, flags);
+ set_bit(i, &usi->query_running);
+ spin_unlock_irqrestore(&usi->lock, flags);
+ }
+
+ if (test_bit(i, &usi->query_running)) {
+ if (changed ||
+ time_after(jiffies, usi->sync_point +
+ usi->timeout)) {
+ if (!test_bit(i, &usi->update_pending)) {
+ __usi_pen_set_value(pen,
+ __usi_to_msc_id(i),
+ *ptr);
+ cached = *ptr;
+ spin_lock_irqsave(&usi->lock, flags);
+ clear_bit(i, &usi->query_running);
+ spin_unlock_irqrestore(&usi->lock,
+ flags);
+ }
+
+ check_work = true;
+ }
+ }
+
+ /* Ignore any unexpected data changes */
+ *ptr = cached;
+
+ if (usi->need_flush) {
+ input_event(usi->idev, EV_MSC, __usi_to_msc_id(i), -1);
+ input_event(usi->idev, EV_MSC, __usi_to_msc_id(i),
+ cached);
+ }
+ }
+
+ usi->need_flush = false;
+
+ if (check_work) {
+ if (usi->update_pending || usi->query_pending) {
+ cancel_delayed_work_sync(&usi->work);
+ schedule_delayed_work(&usi->work, 0);
+ }
+ }
+
+ return 0;
+}
+
+static void _apply_quirks(struct usi_drvdata *usi, struct hid_device *hdev)
+{
+ if (hdev->vendor == I2C_VENDOR_ID_GOODIX &&
+ hdev->product == 0xe00) {
+ set_bit(USI_QUIRK_STYLE_MAX_VAL, &usi->quirks);
+ set_bit(USI_QUIRK_QUERY_DATA, &usi->quirks);
+ usi->timeout = msecs_to_jiffies(75);
+ } else {
+ usi->timeout = msecs_to_jiffies(100);
+ }
+}
+
+static int usi_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+ int ret;
+ struct usi_drvdata *usi;
+
+ hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
+
+ usi = devm_kzalloc(&hdev->dev, sizeof(*usi), GFP_KERNEL);
+ if (!usi)
+ return -ENOMEM;
+
+ usi->hdev = hdev;
+
+ hid_set_drvdata(hdev, usi);
+
+ ret = hid_parse(hdev);
+ if (ret)
+ return ret;
+
+ ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+ if (ret)
+ goto err;
+
+ _apply_quirks(usi, hdev);
+
+ return 0;
+
+err:
+ hid_hw_stop(hdev);
+ return ret;
+}
+
+static void usi_remove(struct hid_device *hdev)
+{
+ hid_hw_stop(hdev);
+}
+
+/**
+ * usi_getset_feature - Read/write USI feature from LL drivers
+ * @usi: USI handle
+ * @code: field to access
+ * @value: value to write (ignored for reads)
+ * @write: true if write access
+ *
+ * Sends a HID HW request to low level drivers to read/write a USI
+ * feature value. Returns 0 on success, negative error value in failure.
+ */
+static int usi_getset_feature(struct usi_drvdata *usi,
+ unsigned int code, int value, bool write)
+{
+ struct hid_device *hdev = usi->hdev;
+ struct hid_report *report;
+ struct usi_pen *pen = usi->current_pen;
+ size_t len;
+ u8 *buf;
+ int ret;
+
+ hid_dbg(usi->hdev, "%s: pen=%d, code=%x, value=%d, op=%s\n",
+ __func__, pen ? pen->index : 0, code, value,
+ write ? "wr" : "rd");
+
+ if (!pen)
+ return -ENODEV;
+
+ if (code >= USI_NUM_ATTRS)
+ return -ENODEV;
+
+ report = usi->features[code];
+ if (!report)
+ return -EOPNOTSUPP;
+
+ buf = hid_alloc_report_buf(report, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ len = hid_report_len(report);
+ memset(buf, 0, len);
+
+ if (_has_quirk(usi, USI_QUIRK_STYLE_MAX_VAL))
+ if (code == USI_PEN_LINE_STYLE)
+ if (value >= report->field[1]->logical_maximum)
+ value = 255;
+
+ buf[0] = report->id;
+ buf[1] = pen->index;
+ if (write)
+ buf[2] = value;
+
+ ret = hid_hw_raw_request(hdev, buf[0], buf, len, HID_FEATURE_REPORT,
+ write ? HID_REQ_SET_REPORT :
+ HID_REQ_GET_REPORT);
+
+ kfree(buf);
+
+ return ret < 0 ? ret : 0;
+}
+
+/**
+ * usi_feature_mapping - map any HID reported features for USI
+ * @hdev: HID device
+ * @field: HID field
+ * @usage: HID usage info
+ *
+ * Does any USI specific tweaks to the HID core reported features,
+ * and stores required fields for later use. No return value.
+ */
+static void usi_feature_mapping(struct hid_device *hdev,
+ struct hid_field *field,
+ struct hid_usage *usage)
+{
+ struct usi_drvdata *usi = hid_get_drvdata(hdev);
+ int usi_id;
+ u8 bit;
+
+ /* Re-map vendor specific usage fields to digitizer */
+ if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
+ usage->hid &= HID_USAGE;
+ usage->hid |= HID_UP_DIGITIZER;
+ field->logical &= HID_USAGE;
+ field->logical |= HID_UP_DIGITIZER;
+ }
+
+ if (usage->hid == HID_DG_TRANSDUCER_INDEX) {
+ if (!test_bit(USI_HAS_PENS, &usi->flags)) {
+ /*
+ * Transducer index reports us the amount of pens
+ * supported by HW, store this for later use.
+ */
+ set_bit(USI_HAS_PENS, &usi->flags);
+ usi->min_pen = field->logical_minimum;
+ usi->max_pen = field->logical_maximum;
+ }
+ } else {
+ usi_id = __map_usage(usage, field, &bit);
+ /*
+ * For any USI specific usage, store the report for later
+ * use; needed for read/write access to the feature over
+ * HID LL drivers
+ */
+ if (usi_id >= 0)
+ usi->features[usi_id] = field->report;
+ }
+}
+
+/**
+ * usi_work - work function for the USI driver
+ * @work: handle to the work
+ *
+ * Parses any pending USI low level operations and executes one of them.
+ * If there are more pending, the work is re-scheduled to execute again
+ * later. USI driver must execute these from a work, as some of the
+ * control flows entering USI driver are run in interrupt context.
+ * No return value.
+ */
+static void usi_work(struct work_struct *work)
+{
+ struct usi_drvdata *usi =
+ container_of(work, struct usi_drvdata, work.work);
+ int code;
+ bool running = false;
+ unsigned long flags;
+
+ hid_dbg(usi->hdev, "work: update=%lx, query=%lx\n",
+ usi->update_pending, usi->query_pending);
+
+ if (!usi->current_pen)
+ return;
+
+ /* Update first pending value */
+ code = find_first_bit(&usi->update_pending, USI_NUM_ATTRS);
+ if (code < USI_NUM_ATTRS) {
+ usi_getset_feature(usi, code,
+ __usi_pen_get_value(usi->current_pen,
+ __usi_to_msc_id(code)),
+ true);
+ spin_lock_irqsave(&usi->lock, flags);
+ clear_bit(code, &usi->update_pending);
+ clear_bit(code, &usi->query_running);
+ spin_unlock_irqrestore(&usi->lock, flags);
+ running = true;
+ }
+
+ /*
+ * Query first pending value. Only execute if we didn't have any
+ * updates pending.
+ */
+ code = find_first_bit(&usi->query_pending, USI_NUM_ATTRS);
+ if (!running && code < USI_NUM_ATTRS) {
+ usi_getset_feature(usi, code, 0, false);
+ spin_lock_irqsave(&usi->lock, flags);
+ clear_bit(code, &usi->query_pending);
+ set_bit(code, &usi->query_running);
+ spin_unlock_irqrestore(&usi->lock, flags);
+ running = true;
+ }
+
+ if (running) {
+ usi->sync_point = jiffies;
+ schedule_delayed_work(&usi->work, usi->timeout);
+ }
+}
+
+static int usi_allocate_pens(struct usi_drvdata *usi,
+ struct hid_input *hidinput)
+{
+ size_t max_pens = usi->max_pen - usi->min_pen + 1;
+ int i;
+
+ INIT_DELAYED_WORK(&usi->work, usi_work);
+ spin_lock_init(&usi->lock);
+ usi->idev = hidinput->input;
+ usi->npens = min_t(size_t, max_pens, USI_MAX_PENS);
+ usi->pens = devm_kcalloc(&usi->hdev->dev, usi->npens,
+ sizeof(*usi->pens), GFP_KERNEL);
+ if (!usi->pens)
+ return -ENOMEM;
+
+ for (i = 0; i < usi->npens; i++) {
+ __usi_pen_set_value(&usi->pens[i], MSC_PEN_ID, -1);
+ usi->pens[i].index = -1;
+ }
+
+ usi->idev->event = _usi_input_event;
+ usi->idev->open = _usi_input_open;
+ hid_dbg(usi->hdev, "allocated %zd pens\n", usi->npens);
+
+ return 0;
+}
+
+static int usi_input_configured(struct hid_device *hdev,
+ struct hid_input *hidinput)
+{
+ struct usi_drvdata *usi = hid_get_drvdata(hdev);
+
+ if (test_bit(USI_HAS_PENS, &usi->flags) &&
+ !test_bit(USI_PENS_CONFIGURED, &usi->flags) &&
+ hidinput->application == HID_DG_PEN) {
+ set_bit(USI_PENS_CONFIGURED, &usi->flags);
+ return usi_allocate_pens(usi, hidinput);
+ }
+
+ return 0;
+}
+
+static const struct hid_device_id usi_devices[] = {
+ { HID_DEVICE(HID_BUS_ANY, HID_GROUP_USI, HID_ANY_ID, HID_ANY_ID) },
+ { }
+};
+
+MODULE_DEVICE_TABLE(hid, usi_devices);
+
+static struct hid_driver usi_driver = {
+ .name = "usi",
+ .id_table = usi_devices,
+ .input_configured = usi_input_configured,
+ .input_mapping = usi_input_mapping,
+ .probe = usi_probe,
+ .remove = usi_remove,
+ .raw_event = usi_raw_event,
+ .feature_mapping = usi_feature_mapping,
+};
+module_hid_driver(usi_driver);
+
+MODULE_LICENSE("GPL");
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 000fd3cf06ce..05822873b39b 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -257,6 +257,13 @@ struct hid_item {
#define HID_DG_PEN_COLOR 0x000d005c
#define HID_DG_PEN_LINE_WIDTH 0x000d005e
#define HID_DG_PEN_LINE_STYLE 0x000d0070
+#define HID_DG_PEN_LINE_STYLE_IS_LOCKED 0x000d0071
+#define HID_DG_PEN_LINE_STYLE_INK 0x000d0072
+#define HID_DG_PEN_LINE_STYLE_PENCIL 0x000d0073
+#define HID_DG_PEN_LINE_STYLE_HIGHLIGHTER 0x000d0074
+#define HID_DG_PEN_LINE_STYLE_CHISEL_MARKER 0x000d0075
+#define HID_DG_PEN_LINE_STYLE_BRUSH 0x000d0076
+#define HID_DG_PEN_LINE_STYLE_NO_PREFERENCE 0x000d0077
#define HID_CP_CONSUMERCONTROL 0x000c0001
#define HID_CP_NUMERICKEYPAD 0x000c0002
--
2.25.1
