diff mbox series

[v2] HID: multitouch: Add quirks for flipped axes

Message ID 20221208165145.1.I69657e84c0606b2e5ccfa9fedbf42b7676a1e129@changeid
State New
Headers show
Series [v2] HID: multitouch: Add quirks for flipped axes | expand

Commit Message

Allen Ballway Dec. 8, 2022, 4:58 p.m. UTC 
Certain touchscreen devices, such as the ELAN9034, are oriented
incorrectly and report touches on opposite points on the X and Y axes.
For example, a 100x200 screen touched at (10,20) would report (90, 180)
and vice versa.

This is fixed by adding device quirks to transform the touch points
into the correct spaces, from X -> MAX(X) - X, and Y -> MAX(Y) - Y.

Signed-off-by: Allen Ballway <ballway@chromium.org>
---
V1 -> V2: Address review comments, change to use DMI match. Confirmed
MT_TOOL_X/Y require transformation and update orientation based on
flipped axes.

 drivers/hid/hid-multitouch.c | 72 +++++++++++++++++++++++++++++++++---
 1 file changed, 67 insertions(+), 5 deletions(-)

--
2.39.0.rc1.256.g54fd8350bd-goog

Comments

Dmitry Torokhov Dec. 12, 2022, 6:46 p.m. UTC | #1 
On Thu, Dec 08, 2022 at 04:58:36PM +0000, Allen Ballway wrote:
> Certain touchscreen devices, such as the ELAN9034, are oriented
> incorrectly and report touches on opposite points on the X and Y axes.
> For example, a 100x200 screen touched at (10,20) would report (90, 180)
> and vice versa.
> 
> This is fixed by adding device quirks to transform the touch points
> into the correct spaces, from X -> MAX(X) - X, and Y -> MAX(Y) - Y.
> 
> Signed-off-by: Allen Ballway <ballway@chromium.org>
> ---
> V1 -> V2: Address review comments, change to use DMI match. Confirmed
> MT_TOOL_X/Y require transformation and update orientation based on
> flipped axes.

I think you might need to push the DMI match into i2c-hid driver, and
bubble the quirks up here, otherwise if you connect a 2nd USB
touchscreen to such a system will also result in the quirk being applied
to it as far as I understand. In i2c-hid you can make a fine-grained
match on vendor/product and system to limit the quirk to hopefully the
right peripheral.

Thanks.
Benjamin Tissoires Dec. 13, 2022, 9:19 a.m. UTC | #2 
On Tue, Dec 13, 2022 at 2:01 AM Allen Ballway <ballway@chromium.org> wrote:
>
> Certain touchscreen devices, such as the ELAN9034, are oriented
> incorrectly and report touches on opposite points on the X and Y axes.
> For example, a 100x200 screen touched at (10,20) would report (90, 180)
> and vice versa.
>
> This changed fixes the issue by adding device quirks to transform
> the touch points into the correct spaces, from X -> MAX(X) - X,
> and Y -> MAX(Y) - Y. These quirks are added in hid-quirks checking
> both DMI information and device vendor and product IDs. The quirk
> is handled in hid-multitouch to do the actual transformation.
>
> Signed-off-by: Allen Ballway <ballway@chromium.org>
> ---
> V2 -> V3: Use existing HID_QUIRK_*_INVERT and match the quirk in
> hid-quirk, passing down to hid-multitouch through the hid device.
>
> V1 -> V2: Address review comments, change to use DMI match. Confirmed
> MT_TOOL_X/Y require transformation and update orientation based on
> flipped axes.
>
>
>  drivers/hid/hid-multitouch.c | 43 ++++++++++++++++++++++++++++++++----
>  drivers/hid/hid-quirks.c     | 33 +++++++++++++++++++++++++++
>  2 files changed, 72 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
> index 91a4d3fc30e08..1f4c2aa511359 100644
> --- a/drivers/hid/hid-multitouch.c
> +++ b/drivers/hid/hid-multitouch.c
> @@ -71,6 +71,8 @@ MODULE_LICENSE("GPL");
>  #define MT_QUIRK_SEPARATE_APP_REPORT   BIT(19)
>  #define MT_QUIRK_FORCE_MULTI_INPUT     BIT(20)
>  #define MT_QUIRK_DISABLE_WAKEUP                BIT(21)
> +#define MT_QUIRK_X_INVERT              BIT(22)
> +#define MT_QUIRK_Y_INVERT              BIT(23)

Why duplicate the already available quirks in struct hid_device?

>
>  #define MT_INPUTMODE_TOUCHSCREEN       0x02
>  #define MT_INPUTMODE_TOUCHPAD          0x03
> @@ -1086,6 +1088,10 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
>                 int orientation = wide;
>                 int max_azimuth;
>                 int azimuth;
> +               int x;
> +               int y;
> +               int cx;
> +               int cy;
>
>                 if (slot->a != DEFAULT_ZERO) {
>                         /*
> @@ -1104,6 +1110,16 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
>                         if (azimuth > max_azimuth * 2)
>                                 azimuth -= max_azimuth * 4;
>                         orientation = -azimuth;
> +
> +                       /* Orientation is inverted if the X or Y axes are
> +                        * flipped, but normalized if both are inverted.
> +                        */
> +                       if (quirks & (MT_QUIRK_X_INVERT | MT_QUIRK_Y_INVERT) &&
> +                           !((quirks & MT_QUIRK_X_INVERT)
> +                             && (quirks & MT_QUIRK_Y_INVERT))) {

This is done in every finger slot in every report. We should probably
cache that information somewhere.

> +                               orientation = -orientation;
> +                       }
> +
>                 }
>
>                 if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
> @@ -1115,10 +1131,23 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
>                         minor = minor >> 1;
>                 }
>
> -               input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
> -               input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
> -               input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
> -               input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
> +               x = quirks & MT_QUIRK_X_INVERT ?
> +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
> +                       *slot->x;
> +               y = quirks & MT_QUIRK_Y_INVERT ?
> +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
> +                       *slot->y;
> +               cx = quirks & MT_QUIRK_X_INVERT ?
> +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
> +                       *slot->cx;
> +               cy = quirks & MT_QUIRK_Y_INVERT ?
> +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
> +                       *slot->cy;

I can't help but think that there must be a better way of doing that.
If I didn't postpone HID-BPF to 6.3 I would have asked you to do this
as a BPF program.

Still, the whole point of the slot pointers was to remove the data
copy everywhere, and you are adding it back.  Not to mention that the
same tests and accesses to variables are called multiple times.

> +
> +               input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
> +               input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
> +               input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
> +               input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
>                 input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
>                 input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
>                 input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
> @@ -1735,6 +1764,12 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
>         if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
>                 td->serial_maybe = true;
>
> +       if (hdev->quirks & HID_QUIRK_X_INVERT)
> +               td->mtclass.quirks |= MT_QUIRK_X_INVERT;
> +
> +       if (hdev->quirks & HID_QUIRK_Y_INVERT)
> +               td->mtclass.quirks |= MT_QUIRK_Y_INVERT;

As mentioned above, I don't see the point in doing that duplication of quirks.

> +
>         /* This allows the driver to correctly support devices
>          * that emit events over several HID messages.
>          */
> diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c

AFAICT, Dmitry told you twice to use i2c-hid, not hid-quirks.c.

We already have i2c-hid-dmi-quirks.c that you could extend. The
rationale is that this way, the dmi check will be done only for
internal peripherals, leaving aside the USB ones.

Cheers,
Benjamin

> index 0e9702c7f7d6c..47c6cd62f019a 100644
> --- a/drivers/hid/hid-quirks.c
> +++ b/drivers/hid/hid-quirks.c
> @@ -16,6 +16,7 @@
>  #include <linux/export.h>
>  #include <linux/slab.h>
>  #include <linux/mutex.h>
> +#include <linux/dmi.h>
>  #include <linux/input/elan-i2c-ids.h>
>
>  #include "hid-ids.h"
> @@ -957,6 +958,29 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
>         { }
>  };
>
> +static const struct hid_device_id elan_flipped_quirks[] = {
> +       { HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_ELAN, 0x2dcd),
> +               HID_QUIRK_X_INVERT | HID_QUIRK_Y_INVERT },
> +       { }
> +};
> +
> +/*
> + * This list contains devices which have specific issues based on the system
> + * they're on and not just the device itself. The driver_data will have a
> + * specific hid device to match against.
> + */
> +static const struct dmi_system_id dmi_override_table[] = {
> +       {
> +               .ident = "DynaBook K50/FR",
> +               .matches = {
> +                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dynabook Inc."),
> +                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "dynabook K50/FR"),
> +               },
> +               .driver_data = (void *)elan_flipped_quirks,
> +       },
> +       { }     /* Terminate list */
> +};
> +
>  bool hid_ignore(struct hid_device *hdev)
>  {
>         int i;
> @@ -1238,6 +1262,7 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
>  {
>         const struct hid_device_id *bl_entry;
>         unsigned long quirks = 0;
> +       const struct dmi_system_id *system_id;
>
>         if (hid_match_id(hdev, hid_ignore_list))
>                 quirks |= HID_QUIRK_IGNORE;
> @@ -1249,6 +1274,14 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
>         if (bl_entry != NULL)
>                 quirks |= bl_entry->driver_data;
>
> +       system_id = dmi_first_match(dmi_override_table);
> +       if (system_id != NULL) {
> +               bl_entry = hid_match_id(hdev, system_id->driver_data);
> +               if (bl_entry != NULL)
> +                       quirks |= bl_entry->driver_data;
> +       }
> +
> +
>         if (quirks)
>                 dbg_hid("Found squirk 0x%lx for HID device 0x%04x:0x%04x\n",
>                         quirks, hdev->vendor, hdev->product);
> --
> 2.39.0.rc1.256.g54fd8350bd-goog
>
Allen Ballway Dec. 13, 2022, 4:45 p.m. UTC | #3 
On Tue, Dec 13, 2022 at 1:19 AM Benjamin Tissoires
<benjamin.tissoires@redhat.com> wrote:
>
> On Tue, Dec 13, 2022 at 2:01 AM Allen Ballway <ballway@chromium.org> wrote:
> >
> > Certain touchscreen devices, such as the ELAN9034, are oriented
> > incorrectly and report touches on opposite points on the X and Y axes.
> > For example, a 100x200 screen touched at (10,20) would report (90, 180)
> > and vice versa.
> >
> > This changed fixes the issue by adding device quirks to transform
> > the touch points into the correct spaces, from X -> MAX(X) - X,
> > and Y -> MAX(Y) - Y. These quirks are added in hid-quirks checking
> > both DMI information and device vendor and product IDs. The quirk
> > is handled in hid-multitouch to do the actual transformation.
> >
> > Signed-off-by: Allen Ballway <ballway@chromium.org>
> > ---
> > V2 -> V3: Use existing HID_QUIRK_*_INVERT and match the quirk in
> > hid-quirk, passing down to hid-multitouch through the hid device.
> >
> > V1 -> V2: Address review comments, change to use DMI match. Confirmed
> > MT_TOOL_X/Y require transformation and update orientation based on
> > flipped axes.
> >
> >
> >  drivers/hid/hid-multitouch.c | 43 ++++++++++++++++++++++++++++++++----
> >  drivers/hid/hid-quirks.c     | 33 +++++++++++++++++++++++++++
> >  2 files changed, 72 insertions(+), 4 deletions(-)
> >
> > diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
> > index 91a4d3fc30e08..1f4c2aa511359 100644
> > --- a/drivers/hid/hid-multitouch.c
> > +++ b/drivers/hid/hid-multitouch.c
> > @@ -71,6 +71,8 @@ MODULE_LICENSE("GPL");
> >  #define MT_QUIRK_SEPARATE_APP_REPORT   BIT(19)
> >  #define MT_QUIRK_FORCE_MULTI_INPUT     BIT(20)
> >  #define MT_QUIRK_DISABLE_WAKEUP                BIT(21)
> > +#define MT_QUIRK_X_INVERT              BIT(22)
> > +#define MT_QUIRK_Y_INVERT              BIT(23)
>
> Why duplicate the already available quirks in struct hid_device?

This no longer seems necessary, and will be removed.

>
> >
> >  #define MT_INPUTMODE_TOUCHSCREEN       0x02
> >  #define MT_INPUTMODE_TOUCHPAD          0x03
> > @@ -1086,6 +1088,10 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> >                 int orientation = wide;
> >                 int max_azimuth;
> >                 int azimuth;
> > +               int x;
> > +               int y;
> > +               int cx;
> > +               int cy;
> >
> >                 if (slot->a != DEFAULT_ZERO) {
> >                         /*
> > @@ -1104,6 +1110,16 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> >                         if (azimuth > max_azimuth * 2)
> >                                 azimuth -= max_azimuth * 4;
> >                         orientation = -azimuth;
> > +
> > +                       /* Orientation is inverted if the X or Y axes are
> > +                        * flipped, but normalized if both are inverted.
> > +                        */
> > +                       if (quirks & (MT_QUIRK_X_INVERT | MT_QUIRK_Y_INVERT) &&
> > +                           !((quirks & MT_QUIRK_X_INVERT)
> > +                             && (quirks & MT_QUIRK_Y_INVERT))) {
>
> This is done in every finger slot in every report. We should probably
> cache that information somewhere.

I can do this once in mt_probe and keep it saved as its own quirk.

>
> > +                               orientation = -orientation;
> > +                       }
> > +
> >                 }
> >
> >                 if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
> > @@ -1115,10 +1131,23 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> >                         minor = minor >> 1;
> >                 }
> >
> > -               input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
> > -               input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
> > -               input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
> > -               input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
> > +               x = quirks & MT_QUIRK_X_INVERT ?
> > +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
> > +                       *slot->x;
> > +               y = quirks & MT_QUIRK_Y_INVERT ?
> > +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
> > +                       *slot->y;
> > +               cx = quirks & MT_QUIRK_X_INVERT ?
> > +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
> > +                       *slot->cx;
> > +               cy = quirks & MT_QUIRK_Y_INVERT ?
> > +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
> > +                       *slot->cy;
>
> I can't help but think that there must be a better way of doing that.
> If I didn't postpone HID-BPF to 6.3 I would have asked you to do this
> as a BPF program.
>
> Still, the whole point of the slot pointers was to remove the data
> copy everywhere, and you are adding it back.  Not to mention that the
> same tests and accesses to variables are called multiple times.

I can move the transformation to mt_touch_input_mapping which has easier access
to the quirks coming from hid_device rather than using duplicated quirks for
mt_application/class.

>
> > +
> > +               input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
> > +               input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
> > +               input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
> > +               input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
> >                 input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
> >                 input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
> >                 input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
> > @@ -1735,6 +1764,12 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
> >         if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
> >                 td->serial_maybe = true;
> >
> > +       if (hdev->quirks & HID_QUIRK_X_INVERT)
> > +               td->mtclass.quirks |= MT_QUIRK_X_INVERT;
> > +
> > +       if (hdev->quirks & HID_QUIRK_Y_INVERT)
> > +               td->mtclass.quirks |= MT_QUIRK_Y_INVERT;
>
> As mentioned above, I don't see the point in doing that duplication of quirks.

Will remove

>
> > +
> >         /* This allows the driver to correctly support devices
> >          * that emit events over several HID messages.
> >          */
> > diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c
>
> AFAICT, Dmitry told you twice to use i2c-hid, not hid-quirks.c.
>
> We already have i2c-hid-dmi-quirks.c that you could extend. The
> rationale is that this way, the dmi check will be done only for
> internal peripherals, leaving aside the USB ones.

I had added the quirks to hid_device to i2c-hid-dmi-quirks before
trying this but they were getting stomped by the quirks coming from
hid-quirks. I will move these back to i2c-hid-dmi-quirks and change
hid-device to add them to whatever quirks come from hid-quirks.

>
> Cheers,
> Benjamin
>
> > index 0e9702c7f7d6c..47c6cd62f019a 100644
> > --- a/drivers/hid/hid-quirks.c
> > +++ b/drivers/hid/hid-quirks.c
> > @@ -16,6 +16,7 @@
> >  #include <linux/export.h>
> >  #include <linux/slab.h>
> >  #include <linux/mutex.h>
> > +#include <linux/dmi.h>
> >  #include <linux/input/elan-i2c-ids.h>
> >
> >  #include "hid-ids.h"
> > @@ -957,6 +958,29 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
> >         { }
> >  };
> >
> > +static const struct hid_device_id elan_flipped_quirks[] = {
> > +       { HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_ELAN, 0x2dcd),
> > +               HID_QUIRK_X_INVERT | HID_QUIRK_Y_INVERT },
> > +       { }
> > +};
> > +
> > +/*
> > + * This list contains devices which have specific issues based on the system
> > + * they're on and not just the device itself. The driver_data will have a
> > + * specific hid device to match against.
> > + */
> > +static const struct dmi_system_id dmi_override_table[] = {
> > +       {
> > +               .ident = "DynaBook K50/FR",
> > +               .matches = {
> > +                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dynabook Inc."),
> > +                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "dynabook K50/FR"),
> > +               },
> > +               .driver_data = (void *)elan_flipped_quirks,
> > +       },
> > +       { }     /* Terminate list */
> > +};
> > +
> >  bool hid_ignore(struct hid_device *hdev)
> >  {
> >         int i;
> > @@ -1238,6 +1262,7 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
> >  {
> >         const struct hid_device_id *bl_entry;
> >         unsigned long quirks = 0;
> > +       const struct dmi_system_id *system_id;
> >
> >         if (hid_match_id(hdev, hid_ignore_list))
> >                 quirks |= HID_QUIRK_IGNORE;
> > @@ -1249,6 +1274,14 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
> >         if (bl_entry != NULL)
> >                 quirks |= bl_entry->driver_data;
> >
> > +       system_id = dmi_first_match(dmi_override_table);
> > +       if (system_id != NULL) {
> > +               bl_entry = hid_match_id(hdev, system_id->driver_data);
> > +               if (bl_entry != NULL)
> > +                       quirks |= bl_entry->driver_data;
> > +       }
> > +
> > +
> >         if (quirks)
> >                 dbg_hid("Found squirk 0x%lx for HID device 0x%04x:0x%04x\n",
> >                         quirks, hdev->vendor, hdev->product);
> > --
> > 2.39.0.rc1.256.g54fd8350bd-goog
> >
>

Thanks for the comments,
Allen
Allen Ballway Dec. 13, 2022, 9:46 p.m. UTC | #4 
On Tue, Dec 13, 2022 at 8:45 AM Allen Ballway <ballway@chromium.org> wrote:
>
> On Tue, Dec 13, 2022 at 1:19 AM Benjamin Tissoires
> <benjamin.tissoires@redhat.com> wrote:
> >
> > On Tue, Dec 13, 2022 at 2:01 AM Allen Ballway <ballway@chromium.org> wrote:
> > >
> > > Certain touchscreen devices, such as the ELAN9034, are oriented
> > > incorrectly and report touches on opposite points on the X and Y axes.
> > > For example, a 100x200 screen touched at (10,20) would report (90, 180)
> > > and vice versa.
> > >
> > > This changed fixes the issue by adding device quirks to transform
> > > the touch points into the correct spaces, from X -> MAX(X) - X,
> > > and Y -> MAX(Y) - Y. These quirks are added in hid-quirks checking
> > > both DMI information and device vendor and product IDs. The quirk
> > > is handled in hid-multitouch to do the actual transformation.
> > >
> > > Signed-off-by: Allen Ballway <ballway@chromium.org>
> > > ---
> > > V2 -> V3: Use existing HID_QUIRK_*_INVERT and match the quirk in
> > > hid-quirk, passing down to hid-multitouch through the hid device.
> > >
> > > V1 -> V2: Address review comments, change to use DMI match. Confirmed
> > > MT_TOOL_X/Y require transformation and update orientation based on
> > > flipped axes.
> > >
> > >
> > >  drivers/hid/hid-multitouch.c | 43 ++++++++++++++++++++++++++++++++----
> > >  drivers/hid/hid-quirks.c     | 33 +++++++++++++++++++++++++++
> > >  2 files changed, 72 insertions(+), 4 deletions(-)
> > >
> > > diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
> > > index 91a4d3fc30e08..1f4c2aa511359 100644
> > > --- a/drivers/hid/hid-multitouch.c
> > > +++ b/drivers/hid/hid-multitouch.c
> > > @@ -71,6 +71,8 @@ MODULE_LICENSE("GPL");
> > >  #define MT_QUIRK_SEPARATE_APP_REPORT   BIT(19)
> > >  #define MT_QUIRK_FORCE_MULTI_INPUT     BIT(20)
> > >  #define MT_QUIRK_DISABLE_WAKEUP                BIT(21)
> > > +#define MT_QUIRK_X_INVERT              BIT(22)
> > > +#define MT_QUIRK_Y_INVERT              BIT(23)
> >
> > Why duplicate the already available quirks in struct hid_device?
>
> This no longer seems necessary, and will be removed.
>
> >
> > >
> > >  #define MT_INPUTMODE_TOUCHSCREEN       0x02
> > >  #define MT_INPUTMODE_TOUCHPAD          0x03
> > > @@ -1086,6 +1088,10 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> > >                 int orientation = wide;
> > >                 int max_azimuth;
> > >                 int azimuth;
> > > +               int x;
> > > +               int y;
> > > +               int cx;
> > > +               int cy;
> > >
> > >                 if (slot->a != DEFAULT_ZERO) {
> > >                         /*
> > > @@ -1104,6 +1110,16 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> > >                         if (azimuth > max_azimuth * 2)
> > >                                 azimuth -= max_azimuth * 4;
> > >                         orientation = -azimuth;
> > > +
> > > +                       /* Orientation is inverted if the X or Y axes are
> > > +                        * flipped, but normalized if both are inverted.
> > > +                        */
> > > +                       if (quirks & (MT_QUIRK_X_INVERT | MT_QUIRK_Y_INVERT) &&
> > > +                           !((quirks & MT_QUIRK_X_INVERT)
> > > +                             && (quirks & MT_QUIRK_Y_INVERT))) {
> >
> > This is done in every finger slot in every report. We should probably
> > cache that information somewhere.
>
> I can do this once in mt_probe and keep it saved as its own quirk.
>
> >
> > > +                               orientation = -orientation;
> > > +                       }
> > > +
> > >                 }
> > >
> > >                 if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
> > > @@ -1115,10 +1131,23 @@ static int mt_process_slot(struct mt_device *td, struct input_dev *input,
> > >                         minor = minor >> 1;
> > >                 }
> > >
> > > -               input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
> > > -               input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
> > > -               input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
> > > -               input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
> > > +               x = quirks & MT_QUIRK_X_INVERT ?
> > > +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
> > > +                       *slot->x;
> > > +               y = quirks & MT_QUIRK_Y_INVERT ?
> > > +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
> > > +                       *slot->y;
> > > +               cx = quirks & MT_QUIRK_X_INVERT ?
> > > +                       input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
> > > +                       *slot->cx;
> > > +               cy = quirks & MT_QUIRK_Y_INVERT ?
> > > +                       input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
> > > +                       *slot->cy;
> >
> > I can't help but think that there must be a better way of doing that.
> > If I didn't postpone HID-BPF to 6.3 I would have asked you to do this
> > as a BPF program.
> >
> > Still, the whole point of the slot pointers was to remove the data
> > copy everywhere, and you are adding it back.  Not to mention that the
> > same tests and accesses to variables are called multiple times.
>
> I can move the transformation to mt_touch_input_mapping which has easier access
> to the quirks coming from hid_device rather than using duplicated quirks for
> mt_application/class.

It looks like I won't be able to make the change in
mt_touch_input_mapping because
the slot values I need to transform are pointers into the hid_report
coming through the device.
The other use of HID_QUIRK_*_INVERT is in hid-input.c and is
transforming the value
before calling input_event. I see some changes to the field values happening in
mt_need_to_apply_feature and doing a hid_hw_raw_request, but those
seem to happen
once with a fixed value and seems more expensive than just doing the
transform every time,
if that would even work for this.

>
> >
> > > +
> > > +               input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
> > > +               input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
> > > +               input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
> > > +               input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
> > >                 input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
> > >                 input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
> > >                 input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
> > > @@ -1735,6 +1764,12 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
> > >         if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
> > >                 td->serial_maybe = true;
> > >
> > > +       if (hdev->quirks & HID_QUIRK_X_INVERT)
> > > +               td->mtclass.quirks |= MT_QUIRK_X_INVERT;
> > > +
> > > +       if (hdev->quirks & HID_QUIRK_Y_INVERT)
> > > +               td->mtclass.quirks |= MT_QUIRK_Y_INVERT;
> >
> > As mentioned above, I don't see the point in doing that duplication of quirks.
>
> Will remove
>
> >
> > > +
> > >         /* This allows the driver to correctly support devices
> > >          * that emit events over several HID messages.
> > >          */
> > > diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c
> >
> > AFAICT, Dmitry told you twice to use i2c-hid, not hid-quirks.c.
> >
> > We already have i2c-hid-dmi-quirks.c that you could extend. The
> > rationale is that this way, the dmi check will be done only for
> > internal peripherals, leaving aside the USB ones.
>
> I had added the quirks to hid_device to i2c-hid-dmi-quirks before
> trying this but they were getting stomped by the quirks coming from
> hid-quirks. I will move these back to i2c-hid-dmi-quirks and change
> hid-device to add them to whatever quirks come from hid-quirks.

I can get the quirks to come from i2c-hid-dmi-quirks.c, but the hid_device
quirks reset on probe so I will need to get them again in hid_lookup_quirk.
I can at least put it behind an if (bus == I2C) to keep the DMI checks to
a minimum but I don't see a way to get the quirk from i2c-hid-dmi-quirks
without going through hid-quirks.

>
> >
> > Cheers,
> > Benjamin
> >
> > > index 0e9702c7f7d6c..47c6cd62f019a 100644
> > > --- a/drivers/hid/hid-quirks.c
> > > +++ b/drivers/hid/hid-quirks.c
> > > @@ -16,6 +16,7 @@
> > >  #include <linux/export.h>
> > >  #include <linux/slab.h>
> > >  #include <linux/mutex.h>
> > > +#include <linux/dmi.h>
> > >  #include <linux/input/elan-i2c-ids.h>
> > >
> > >  #include "hid-ids.h"
> > > @@ -957,6 +958,29 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
> > >         { }
> > >  };
> > >
> > > +static const struct hid_device_id elan_flipped_quirks[] = {
> > > +       { HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_ELAN, 0x2dcd),
> > > +               HID_QUIRK_X_INVERT | HID_QUIRK_Y_INVERT },
> > > +       { }
> > > +};
> > > +
> > > +/*
> > > + * This list contains devices which have specific issues based on the system
> > > + * they're on and not just the device itself. The driver_data will have a
> > > + * specific hid device to match against.
> > > + */
> > > +static const struct dmi_system_id dmi_override_table[] = {
> > > +       {
> > > +               .ident = "DynaBook K50/FR",
> > > +               .matches = {
> > > +                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dynabook Inc."),
> > > +                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "dynabook K50/FR"),
> > > +               },
> > > +               .driver_data = (void *)elan_flipped_quirks,
> > > +       },
> > > +       { }     /* Terminate list */
> > > +};
> > > +
> > >  bool hid_ignore(struct hid_device *hdev)
> > >  {
> > >         int i;
> > > @@ -1238,6 +1262,7 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
> > >  {
> > >         const struct hid_device_id *bl_entry;
> > >         unsigned long quirks = 0;
> > > +       const struct dmi_system_id *system_id;
> > >
> > >         if (hid_match_id(hdev, hid_ignore_list))
> > >                 quirks |= HID_QUIRK_IGNORE;are
> > > @@ -1249,6 +1274,14 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev)
> > >         if (bl_entry != NULL)
> > >                 quirks |= bl_entry->driver_data;
> > >
> > > +       system_id = dmi_first_match(dmi_override_table);
> > > +       if (system_id != NULL) {
> > > +               bl_entry = hid_match_id(hdev, system_id->driver_data);
> > > +               if (bl_entry != NULL)
> > > +                       quirks |= bl_entry->driver_data;
> > > +       }
> > > +
> > > +
> > >         if (quirks)
> > >                 dbg_hid("Found squirk 0x%lx for HID device 0x%04x:0x%04x\n",
> > >                         quirks, hdev->vendor, hdev->product);
> > > --
> > > 2.39.0.rc1.256.g54fd8350bd-goog
> > >
> >
>
> Thanks for the comments,
> Allen

Thanks,
Allen
diff mbox series

Patch

diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 91a4d3fc30e08..8a4f77e534a75 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -39,6 +39,7 @@ 
 #include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/timer.h>
+#include <linux/dmi.h>


 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
@@ -71,6 +72,8 @@  MODULE_LICENSE("GPL");
 #define MT_QUIRK_SEPARATE_APP_REPORT	BIT(19)
 #define MT_QUIRK_FORCE_MULTI_INPUT	BIT(20)
 #define MT_QUIRK_DISABLE_WAKEUP		BIT(21)
+#define MT_QUIRK_FLIP_X			BIT(22)
+#define MT_QUIRK_FLIP_Y			BIT(23)

 #define MT_INPUTMODE_TOUCHSCREEN	0x02
 #define MT_INPUTMODE_TOUCHPAD		0x03
@@ -212,6 +215,7 @@  static void mt_post_parse(struct mt_device *td, struct mt_application *app);
 #define MT_CLS_GOOGLE				0x0111
 #define MT_CLS_RAZER_BLADE_STEALTH		0x0112
 #define MT_CLS_SMART_TECH			0x0113
+#define MT_CLS_ELAN_FLIPPED			0x0114

 #define MT_DEFAULT_MAXCONTACT	10
 #define MT_MAX_MAXCONTACT	250
@@ -396,9 +400,36 @@  static const struct mt_class mt_classes[] = {
 			MT_QUIRK_CONTACT_CNT_ACCURATE |
 			MT_QUIRK_SEPARATE_APP_REPORT,
 	},
+	{ .name = MT_CLS_ELAN_FLIPPED,
+		.quirks = MT_QUIRK_ALWAYS_VALID |
+			MT_QUIRK_IGNORE_DUPLICATES |
+			MT_QUIRK_HOVERING |
+			MT_QUIRK_CONTACT_CNT_ACCURATE |
+			MT_QUIRK_STICKY_FINGERS |
+			MT_QUIRK_WIN8_PTP_BUTTONS |
+			MT_QUIRK_FLIP_X |
+			MT_QUIRK_FLIP_Y,
+		.export_all_inputs = true },
+
 	{ }
 };

+/*
+ * This list contains devices which have specific issues based on the system
+ * they're on and not just the device itself.
+ */
+static const struct dmi_system_id mt_devices_dmi_override_table[] = {
+	{
+		.ident = "DynaBook K50/FR",
+		.matches = {
+			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dynabook Inc."),
+			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "dynabook K50/FR"),
+		},
+		.driver_data = (void *)MT_CLS_ELAN_FLIPPED,
+	},
+	{ }	/* Terminate list */
+};
+
 static ssize_t mt_show_quirks(struct device *dev,
 			   struct device_attribute *attr,
 			   char *buf)
@@ -1086,6 +1117,10 @@  static int mt_process_slot(struct mt_device *td, struct input_dev *input,
 		int orientation = wide;
 		int max_azimuth;
 		int azimuth;
+		int x;
+		int y;
+		int cx;
+		int cy;

 		if (slot->a != DEFAULT_ZERO) {
 			/*
@@ -1104,6 +1139,16 @@  static int mt_process_slot(struct mt_device *td, struct input_dev *input,
 			if (azimuth > max_azimuth * 2)
 				azimuth -= max_azimuth * 4;
 			orientation = -azimuth;
+
+			/* Orientation is inverted if the X or Y axes are
+			 * flipped, but normalized if both are inverted.
+			 */
+			if (quirks & (MT_QUIRK_FLIP_X | MT_QUIRK_FLIP_Y) &&
+			    !((quirks & MT_QUIRK_FLIP_X)
+			      && (quirks & MT_QUIRK_FLIP_Y))) {
+				orientation = -orientation;
+			}
+
 		}

 		if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
@@ -1115,10 +1160,23 @@  static int mt_process_slot(struct mt_device *td, struct input_dev *input,
 			minor = minor >> 1;
 		}

-		input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
-		input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
-		input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
-		input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
+		x = quirks & MT_QUIRK_FLIP_X ?
+			input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
+			*slot->x;
+		y = quirks & MT_QUIRK_FLIP_Y ?
+			input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
+			*slot->y;
+		cx = quirks & MT_QUIRK_FLIP_X ?
+			input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
+			*slot->cx;
+		cy = quirks & MT_QUIRK_FLIP_Y ?
+			input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
+			*slot->cy;
+
+		input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
+		input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
+		input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
+		input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
 		input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
 		input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
 		input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
@@ -1711,9 +1769,13 @@  static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
 	int ret, i;
 	struct mt_device *td;
 	const struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
+	const struct dmi_system_id *system_id
+			= dmi_first_match(mt_devices_dmi_override_table);
+	const long driver_data_name = system_id ?
+			(long)(system_id->driver_data) : id->driver_data;

 	for (i = 0; mt_classes[i].name ; i++) {
-		if (id->driver_data == mt_classes[i].name) {
+		if (driver_data_name == mt_classes[i].name) {
 			mtclass = &(mt_classes[i]);
 			break;
 		}