* BUG: palm recognition / confidence is not working properly
From: Jon Moeller @ 2024-04-16 18:21 UTC (permalink / raw)
To: linux-input
[-- Attachment #1: Type: text/plain, Size: 3922 bytes --]
Hello -
I think I've found a bug, either with hid-multitouch, or with the
quirks for my device.
I have an HP Spectre x360, which has a nice haptic touchpad, with
excellent finger tracking; the model is ELAN07CE:00 04F3:32C8
Touchpad.
I noticed that palm rejection wasn't working, and after some
investigation found that the touchpad uses "Confidence" as a way to
indicate whether a given touch is a finger or a palm. So I disabled
MT_QUIRK_ALWAYS_VALID and enabled MT_QUIRK_VALID_IS_CONFIDENCE.
While this worked, and palm touches were now not being sent via evdev,
occasionally the cursor will "lock up" after I have been typing or
doing other things that involve resting my palms on the touchpad. I've
examined the hidraw output during these situations, and the touchpad
is sending correct data.
I believe what is happening is that the kernel is holding a slot for a
finger/palm that is no longer there, and so all subsequent touches,
even if single-finger, are interpreted as "gestures" by libinput.
I've tried setting MT_QUIRK_SLOT_IS_CONTACTID, since the touchpad
reliably maps each touch to a contactID - this doesn't help.
I've tried using MT_QUIRK_CONFIDENCE instead, which seemed promising,
but never see any ABS_MT_TOOL_TYPE event codes (neither MT_TOOL_FINGER
or MT_TOOL_PALM) reported by evtest.
So my questions are:
1) Is the MT_QUIRK_VALID_IS_CONFIDENCE messing up event/slot tracking
somehow? The "lock up" doesn't happen when this quirk is not set.
I've attached a recording of the issue in the attached yaml file from
`libinput record --with-hidraw`. It includes the initial palm touches,
followed by a one finger motion that was ignored or misinterpreted
somewhere in the stack due to the prior palm touches, followed by a
6-finger touch on the touchpad, which reliably resets the tracking
state since the touchpad only supports 5 fingers.
2) Why am I unable to get MT_TOOL_FINGER or MT_TOOL_PALM reports to
show up anywhere? It seems like there is some kind of legacy emulation
going on (converting finger tools to BTN_TOOL?), but I haven't figured
out how or why this is happening.
Happy to provide more info if necessary.
Set of quirks I'm using:
default (no issues except false touches)
MT_QUIRK_ALWAYS_VALID | MT_QUIRK_CONTACT_CNT_ACCURATE
palm-reject (rejects palm, but appears to hold slots for fingers that
aren't there any more):
MT_QUIRK_VALID_IS_CONFIDENCE | MT_QUIRK_CONTACT_CNT_ACCURATE
use-tool (attempt to get "real" tools working - currently has the same
effect as default):
MT_QUIRK_CONFIDENCE | MT_QUIRK_CONTACT_CNT_ACCURATE
Thanks,
Jon
Attachments follow:
$ evtest /dev/input.event12
Input driver version is 1.0.1
Input device ID: bus 0x18 vendor 0x4f3 product 0x32c8 version 0x100
Input device name: "ELAN07CE:00 04F3:32C8 Touchpad"
Supported events:
Event type 0 (EV_SYN)
Event type 1 (EV_KEY)
Event code 272 (BTN_LEFT)
Event code 325 (BTN_TOOL_FINGER)
Event code 328 (BTN_TOOL_QUINTTAP)
Event code 330 (BTN_TOUCH)
Event code 333 (BTN_TOOL_DOUBLETAP)
Event code 334 (BTN_TOOL_TRIPLETAP)
Event code 335 (BTN_TOOL_QUADTAP)
Event type 3 (EV_ABS)
Event code 0 (ABS_X)
Value 2470
Min 0
Max 4936
Resolution 31
Event code 1 (ABS_Y)
Value 696
Min 0
Max 3045
Resolution 31
Event code 47 (ABS_MT_SLOT)
Value 1
Min 0
Max 4
Event code 53 (ABS_MT_POSITION_X)
Value 0
Min 0
Max 4936
Resolution 31
Event code 54 (ABS_MT_POSITION_Y)
Value 0
Min 0
Max 3045
Resolution 31
Event code 57 (ABS_MT_TRACKING_ID)
Value 0
Min 0
Max 65535
Event type 4 (EV_MSC)
Event code 5 (MSC_TIMESTAMP)
Properties:
Property type 0 (INPUT_PROP_POINTER)
Property type 2 (INPUT_PROP_BUTTONPAD)
[-- Attachment #2: touchbug3.yaml --]
[-- Type: application/yaml, Size: 288274 bytes --]
^ permalink raw reply
* [dtor-input:next] BUILD SUCCESS 48c0687a322d54ac7e7a685c0b6db78d78f593af
From: kernel test robot @ 2024-04-16 20:34 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: linux-input
tree/branch: https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
branch HEAD: 48c0687a322d54ac7e7a685c0b6db78d78f593af Input: pm8xxx-vibrator - correct VIB_MAX_LEVELS calculation
elapsed time: 1218m
configs tested: 158
configs skipped: 3
The following configs have been built successfully.
More configs may be tested in the coming days.
tested configs:
alpha allnoconfig gcc
alpha allyesconfig gcc
alpha defconfig gcc
arc allmodconfig gcc
arc allnoconfig gcc
arc allyesconfig gcc
arc defconfig gcc
arc randconfig-001-20240416 gcc
arc randconfig-002-20240416 gcc
arm allmodconfig gcc
arm allnoconfig clang
arm allyesconfig gcc
arm assabet_defconfig clang
arm defconfig clang
arm h3600_defconfig gcc
arm randconfig-003-20240416 gcc
arm sama5_defconfig gcc
arm stm32_defconfig gcc
arm wpcm450_defconfig gcc
arm64 allmodconfig clang
arm64 allnoconfig gcc
arm64 allyesconfig clang
arm64 defconfig gcc
arm64 randconfig-001-20240416 gcc
arm64 randconfig-003-20240416 gcc
arm64 randconfig-004-20240416 gcc
csky allmodconfig gcc
csky allnoconfig gcc
csky allyesconfig gcc
csky defconfig gcc
csky randconfig-001-20240416 gcc
csky randconfig-002-20240416 gcc
hexagon allmodconfig clang
hexagon allnoconfig clang
hexagon allyesconfig clang
hexagon defconfig clang
i386 allmodconfig gcc
i386 allnoconfig gcc
i386 allyesconfig gcc
i386 buildonly-randconfig-001-20240416 gcc
i386 buildonly-randconfig-002-20240416 gcc
i386 buildonly-randconfig-003-20240416 clang
i386 buildonly-randconfig-004-20240416 clang
i386 buildonly-randconfig-005-20240416 clang
i386 buildonly-randconfig-006-20240416 gcc
i386 defconfig clang
i386 randconfig-001-20240416 clang
i386 randconfig-002-20240416 clang
i386 randconfig-003-20240416 gcc
i386 randconfig-004-20240416 clang
i386 randconfig-005-20240416 gcc
i386 randconfig-006-20240416 gcc
i386 randconfig-011-20240416 clang
i386 randconfig-012-20240416 gcc
i386 randconfig-013-20240416 clang
i386 randconfig-014-20240416 gcc
i386 randconfig-015-20240416 clang
i386 randconfig-016-20240416 clang
loongarch allmodconfig gcc
loongarch allnoconfig gcc
loongarch defconfig gcc
loongarch randconfig-001-20240416 gcc
loongarch randconfig-002-20240416 gcc
m68k allmodconfig gcc
m68k allnoconfig gcc
m68k allyesconfig gcc
m68k defconfig gcc
microblaze allmodconfig gcc
microblaze allnoconfig gcc
microblaze allyesconfig gcc
microblaze defconfig gcc
mips allnoconfig gcc
mips allyesconfig gcc
nios2 alldefconfig gcc
nios2 allmodconfig gcc
nios2 allnoconfig gcc
nios2 allyesconfig gcc
nios2 defconfig gcc
nios2 randconfig-001-20240416 gcc
nios2 randconfig-002-20240416 gcc
openrisc allnoconfig gcc
openrisc allyesconfig gcc
openrisc defconfig gcc
parisc allmodconfig gcc
parisc allnoconfig gcc
parisc allyesconfig gcc
parisc defconfig gcc
parisc randconfig-001-20240416 gcc
parisc randconfig-002-20240416 gcc
parisc64 defconfig gcc
powerpc allmodconfig gcc
powerpc allnoconfig gcc
powerpc allyesconfig clang
powerpc bamboo_defconfig clang
powerpc holly_defconfig clang
powerpc mpc866_ads_defconfig clang
powerpc randconfig-002-20240416 gcc
powerpc64 randconfig-001-20240416 gcc
powerpc64 randconfig-002-20240416 gcc
powerpc64 randconfig-003-20240416 gcc
riscv allmodconfig clang
riscv allnoconfig gcc
riscv allyesconfig clang
riscv defconfig clang
riscv randconfig-001-20240416 gcc
riscv randconfig-002-20240416 gcc
riscv rv32_defconfig clang
s390 allmodconfig clang
s390 allnoconfig clang
s390 allyesconfig gcc
s390 defconfig clang
s390 randconfig-002-20240416 gcc
sh allmodconfig gcc
sh allnoconfig gcc
sh allyesconfig gcc
sh defconfig gcc
sh espt_defconfig gcc
sh r7780mp_defconfig gcc
sh randconfig-001-20240416 gcc
sh randconfig-002-20240416 gcc
sh se7712_defconfig gcc
sh se7724_defconfig gcc
sparc allmodconfig gcc
sparc allnoconfig gcc
sparc defconfig gcc
sparc64 allmodconfig gcc
sparc64 allyesconfig gcc
sparc64 defconfig gcc
sparc64 randconfig-001-20240416 gcc
sparc64 randconfig-002-20240416 gcc
um allmodconfig clang
um allnoconfig clang
um allyesconfig gcc
um defconfig clang
um i386_defconfig gcc
um randconfig-001-20240416 gcc
um randconfig-002-20240416 gcc
um x86_64_defconfig clang
x86_64 allnoconfig clang
x86_64 allyesconfig clang
x86_64 buildonly-randconfig-001-20240416 gcc
x86_64 buildonly-randconfig-002-20240416 gcc
x86_64 buildonly-randconfig-003-20240416 gcc
x86_64 buildonly-randconfig-005-20240416 gcc
x86_64 defconfig gcc
x86_64 randconfig-003-20240416 gcc
x86_64 randconfig-006-20240416 gcc
x86_64 randconfig-011-20240416 gcc
x86_64 randconfig-016-20240416 gcc
x86_64 randconfig-075-20240416 gcc
x86_64 randconfig-076-20240416 gcc
x86_64 rhel-8.3-bpf gcc
x86_64 rhel-8.3-func gcc
x86_64 rhel-8.3-rust clang
x86_64 rhel-8.3 gcc
xtensa allnoconfig gcc
xtensa randconfig-001-20240416 gcc
xtensa randconfig-002-20240416 gcc
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* Re: [PATCH RESEND v10 4/5] Input: cs40l50 - Add support for the CS40L50 haptic driver
From: Dmitry Torokhov @ 2024-04-16 23:28 UTC (permalink / raw)
To: James Ogletree
Cc: robh+dt, krzysztof.kozlowski+dt, conor+dt, lee, broonie, jeff,
patches, linux-sound, linux-input, devicetree
In-Reply-To: <20240408153214.42368-5-jogletre@opensource.cirrus.com>
Hi James,
On Mon, Apr 08, 2024 at 03:32:13PM +0000, James Ogletree wrote:
> Introduce support for Cirrus Logic Device CS40L50: a
> haptic driver with waveform memory, integrated DSP,
> and closed-loop algorithms.
>
> The input driver provides the interface for control of
> haptic effects through the device.
>
> Signed-off-by: James Ogletree <jogletre@opensource.cirrus.com>
> ---
> v10:
> Minor concern that playback stop is still misused with respect to not
> specifying an effect ID. The device can only play one effect at a
> time, but setting max effects for the EVIOCGEFFECTS ioctl to 1 would
> restrict the number of uploads to 1 as well.
Sorry for a long delay on my part.
Unfortunately this is not a minor concern, because it breaks the API
that we so far been presenting to userspace. EVIOCGEFFECTS ioctl which returns
input->ff->max_effects is described as "Report number of effects
playable at the same time".
I suggest you limit number of effects to 1 so that we can merge the
driver with such limitation, and then try to figure out how to expand
the API. We will probably have to split the notion of number of playable
effects vs number of uploadable effects, and only accept uploads of
effects that exceed number of playable effects if they all have the same
owner, so that different processes would not be able to affect each
other in case when number of simultaneously playable effects is smaller.
A few code comments below...
>
> MAINTAINERS | 1 +
> drivers/input/misc/Kconfig | 10 +
> drivers/input/misc/Makefile | 1 +
> drivers/input/misc/cs40l50-vibra.c | 577 +++++++++++++++++++++++++++++
> 4 files changed, 589 insertions(+)
> create mode 100644 drivers/input/misc/cs40l50-vibra.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index e804f3766cba..49c2e6e57b09 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -4940,6 +4940,7 @@ M: Ben Bright <ben.bright@cirrus.com>
> L: patches@opensource.cirrus.com
> S: Supported
> F: Documentation/devicetree/bindings/input/cirrus,cs40l50.yaml
> +F: drivers/input/misc/cs40l*
> F: drivers/mfd/cs40l*
> F: include/linux/mfd/cs40l*
>
> diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
> index 6ba984d7f0b1..ee45dbb0636e 100644
> --- a/drivers/input/misc/Kconfig
> +++ b/drivers/input/misc/Kconfig
> @@ -140,6 +140,16 @@ config INPUT_BMA150
> To compile this driver as a module, choose M here: the
> module will be called bma150.
>
> +config INPUT_CS40L50_VIBRA
> + tristate "CS40L50 Haptic Driver support"
> + depends on MFD_CS40L50_CORE
> + help
> + Say Y here to enable support for Cirrus Logic's CS40L50
> + haptic driver.
> +
> + To compile this driver as a module, choose M here: the
> + module will be called cs40l50-vibra.
> +
> config INPUT_E3X0_BUTTON
> tristate "NI Ettus Research USRP E3xx Button support."
> default n
> diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
> index 04296a4abe8e..88279de6d3d5 100644
> --- a/drivers/input/misc/Makefile
> +++ b/drivers/input/misc/Makefile
> @@ -28,6 +28,7 @@ obj-$(CONFIG_INPUT_CMA3000) += cma3000_d0x.o
> obj-$(CONFIG_INPUT_CMA3000_I2C) += cma3000_d0x_i2c.o
> obj-$(CONFIG_INPUT_COBALT_BTNS) += cobalt_btns.o
> obj-$(CONFIG_INPUT_CPCAP_PWRBUTTON) += cpcap-pwrbutton.o
> +obj-$(CONFIG_INPUT_CS40L50_VIBRA) += cs40l50-vibra.o
> obj-$(CONFIG_INPUT_DA7280_HAPTICS) += da7280.o
> obj-$(CONFIG_INPUT_DA9052_ONKEY) += da9052_onkey.o
> obj-$(CONFIG_INPUT_DA9055_ONKEY) += da9055_onkey.o
> diff --git a/drivers/input/misc/cs40l50-vibra.c b/drivers/input/misc/cs40l50-vibra.c
> new file mode 100644
> index 000000000000..5440cf224f59
> --- /dev/null
> +++ b/drivers/input/misc/cs40l50-vibra.c
> @@ -0,0 +1,577 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * CS40L50 Advanced Haptic Driver with waveform memory,
> + * integrated DSP, and closed-loop algorithms
> + *
> + * Copyright 2024 Cirrus Logic, Inc.
> + *
> + * Author: James Ogletree <james.ogletree@cirrus.com>
> + */
> +
> +#include <linux/bitfield.h>
> +#include <linux/input.h>
> +#include <linux/mfd/cs40l50.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
> +
> +/* Wavetables */
> +#define CS40L50_RAM_INDEX_START 0x1000000
> +#define CS40L50_RAM_INDEX_END 0x100007F
> +#define CS40L50_RTH_INDEX_START 0x1400000
> +#define CS40L50_RTH_INDEX_END 0x1400001
> +#define CS40L50_ROM_INDEX_START 0x1800000
> +#define CS40L50_ROM_INDEX_END 0x180001A
> +#define CS40L50_TYPE_PCM 8
> +#define CS40L50_TYPE_PWLE 12
> +#define CS40L50_PCM_ID 0x0
> +#define CS40L50_OWT_CUSTOM_DATA_SIZE 2
> +#define CS40L50_CUSTOM_DATA_MASK 0xFFFFU
> +
> +/* DSP */
> +#define CS40L50_GPIO_BASE 0x2804140
> +#define CS40L50_OWT_BASE 0x2805C34
> +#define CS40L50_OWT_SIZE 0x2805C38
> +#define CS40L50_OWT_NEXT 0x2805C3C
> +
> +/* GPIO */
> +#define CS40L50_GPIO_NUM_MASK GENMASK(14, 12)
> +#define CS40L50_GPIO_EDGE_MASK BIT(15)
> +#define CS40L50_GPIO_MAPPING_NONE 0
> +#define CS40L50_GPIO_DISABLE 0x1FF
> +
> +enum cs40l50_bank_type {
> + CS40L50_WVFRM_BANK_RAM,
> + CS40L50_WVFRM_BANK_ROM,
> + CS40L50_WVFRM_BANK_OWT,
> + CS40L50_WVFRM_BANK_NUM,
> +};
> +
> +/* Describes an area in DSP memory populated by effects */
> +struct cs40l50_bank {
> + enum cs40l50_bank_type type;
> + u32 base_index;
> + u32 max_index;
This looks like it is written to the device, so I think this needs
proper endianness annotation. Is there any concern about padding between
the type and base_index?
> +};
> +
> +struct cs40l50_effect {
> + enum cs40l50_bank_type type;
> + struct list_head list;
> + u32 gpio_reg;
> + u32 index;
> + int id;
> +};
> +
> +/* Describes haptic interface of loaded DSP firmware */
> +struct cs40l50_vibra_dsp {
> + struct cs40l50_bank *banks;
> + u32 gpio_base_reg;
> + u32 owt_offset_reg;
> + u32 owt_size_reg;
> + u32 owt_base_reg;
> + u32 push_owt_cmd;
> + u32 delete_owt_cmd;
> + u32 stop_cmd;
> + int (*write)(struct device *dev, struct regmap *regmap, u32 val);
> +};
> +
> +/* Describes configuration and state of haptic operations */
> +struct cs40l50_vibra {
> + struct device *dev;
> + struct regmap *regmap;
> + struct input_dev *input;
> + struct mutex lock;
> + struct workqueue_struct *vibe_wq;
> + struct list_head effect_head;
> + struct cs40l50_vibra_dsp dsp;
> +};
> +
> +struct cs40l50_work {
> + struct cs40l50_vibra *vibra;
> + struct ff_effect *effect;
> + struct work_struct work;
> + s16 *custom_data;
> + int custom_len;
> + int count;
> + int error;
> +};
> +
> +static struct cs40l50_bank cs40l50_banks[] = {
> + {
> + .type = CS40L50_WVFRM_BANK_RAM,
> + .base_index = CS40L50_RAM_INDEX_START,
> + .max_index = CS40L50_RAM_INDEX_END,
> + },
> + {
> + .type = CS40L50_WVFRM_BANK_ROM,
> + .base_index = CS40L50_ROM_INDEX_START,
> + .max_index = CS40L50_ROM_INDEX_END,
> + },
> + {
> + .type = CS40L50_WVFRM_BANK_OWT,
> + .base_index = CS40L50_RTH_INDEX_START,
> + .max_index = CS40L50_RTH_INDEX_END,
> + },
> +};
> +
> +static struct cs40l50_vibra_dsp cs40l50_dsp = {
> + .banks = cs40l50_banks,
> + .gpio_base_reg = CS40L50_GPIO_BASE,
> + .owt_base_reg = CS40L50_OWT_BASE,
> + .owt_offset_reg = CS40L50_OWT_NEXT,
> + .owt_size_reg = CS40L50_OWT_SIZE,
> + .push_owt_cmd = CS40L50_OWT_PUSH,
> + .delete_owt_cmd = CS40L50_OWT_DELETE,
> + .stop_cmd = CS40L50_STOP_PLAYBACK,
> + .write = cs40l50_dsp_write,
> +};
> +
> +static struct cs40l50_effect *cs40l50_find_effect(int id, struct list_head *effect_head)
> +{
> + struct cs40l50_effect *effect;
> +
> + list_for_each_entry(effect, effect_head, list)
> + if (effect->id == id)
> + return effect;
> +
> + return NULL;
> +}
> +
> +static int cs40l50_effect_bank_set(struct cs40l50_work *work_data,
> + struct cs40l50_effect *effect)
> +{
> + s16 bank_type = work_data->custom_data[0] & CS40L50_CUSTOM_DATA_MASK;
> +
> + if (bank_type >= CS40L50_WVFRM_BANK_NUM) {
> + dev_err(work_data->vibra->dev, "Invalid bank (%d)\n", bank_type);
> + return -EINVAL;
> + }
> +
> + if (work_data->custom_len > CS40L50_OWT_CUSTOM_DATA_SIZE)
> + effect->type = CS40L50_WVFRM_BANK_OWT;
> + else
> + effect->type = bank_type;
> +
> + return 0;
> +}
> +
> +static int cs40l50_effect_gpio_mapping_set(struct cs40l50_work *work_data,
> + struct cs40l50_effect *effect)
> +{
> + u16 gpio_num, gpio_edge, button = work_data->effect->trigger.button;
> + struct cs40l50_vibra *vibra = work_data->vibra;
> +
> + if (button) {
> + gpio_num = FIELD_GET(CS40L50_GPIO_NUM_MASK, button);
> + gpio_edge = FIELD_GET(CS40L50_GPIO_EDGE_MASK, button);
> + effect->gpio_reg = vibra->dsp.gpio_base_reg + (gpio_num * 8) - gpio_edge;
> +
> + return regmap_write(vibra->regmap, effect->gpio_reg, button);
> + }
> +
> + effect->gpio_reg = CS40L50_GPIO_MAPPING_NONE;
> +
> + return 0;
> +}
> +
> +static int cs40l50_effect_index_set(struct cs40l50_work *work_data,
> + struct cs40l50_effect *effect)
> +{
> + struct cs40l50_vibra *vibra = work_data->vibra;
> + struct cs40l50_effect *owt_effect;
> + u32 base_index, max_index;
> +
> + base_index = vibra->dsp.banks[effect->type].base_index;
> + max_index = vibra->dsp.banks[effect->type].max_index;
> +
> + effect->index = base_index;
> +
> + switch (effect->type) {
> + case CS40L50_WVFRM_BANK_OWT:
> + list_for_each_entry(owt_effect, &vibra->effect_head, list)
> + if (owt_effect->type == CS40L50_WVFRM_BANK_OWT)
> + effect->index++;
> + break;
> + case CS40L50_WVFRM_BANK_ROM:
> + case CS40L50_WVFRM_BANK_RAM:
> + effect->index += work_data->custom_data[1] & CS40L50_CUSTOM_DATA_MASK;
> + break;
> + default:
> + dev_err(vibra->dev, "Bank type %d not supported\n", effect->type);
> + return -EINVAL;
> + }
> +
> + if (effect->index > max_index || effect->index < base_index) {
> + dev_err(vibra->dev, "Index out of bounds: %u\n", effect->index);
> + return -ENOSPC;
> + }
> +
> + return 0;
> +}
> +
> +/* Describes a header for an OWT effect */
> +struct cs40l50_owt_header {
> + u32 type;
> + u32 data_words;
> + u32 offset;
> +} __packed;
> +
> +static int cs40l50_upload_owt(struct cs40l50_work *work_data)
> +{
> + u32 len = 2 * work_data->custom_len, wt_offset, wt_size;
> + struct cs40l50_vibra *vibra = work_data->vibra;
> + struct cs40l50_owt_header header;
> + u8 *out_data;
> + int error;
> +
> + error = regmap_read(vibra->regmap, vibra->dsp.owt_size_reg, &wt_size);
> + if (error)
> + return error;
> +
> + if ((wt_size * sizeof(u32)) < sizeof(header) + len) {
> + dev_err(vibra->dev, "No space in OWT bank for effect\n");
> + return -ENOSPC;
> + }
> +
> + out_data = kzalloc(sizeof(header) + len, GFP_KERNEL);
You can make this as
u8 *out_data __free(kfree) = kzalloc(...);
and then you do not need to explicitly kfree() it.
Also, I wonder if you have to zero it and can't use kmalloc() given that
you copy over the entire thing.
> + if (!out_data)
> + return -ENOMEM;
> +
> + header.type = work_data->custom_data[0] == CS40L50_PCM_ID ? CS40L50_TYPE_PCM :
> + CS40L50_TYPE_PWLE;
> + header.offset = sizeof(header) / sizeof(u32);
> + header.data_words = len / sizeof(u32);
> +
> + memcpy(out_data, &header, sizeof(header));
> + memcpy(out_data + sizeof(header), work_data->custom_data, len);
> +
> + error = regmap_read(vibra->regmap, vibra->dsp.owt_offset_reg, &wt_offset);
> + if (error)
> + goto err_free;
> +
> + error = regmap_bulk_write(vibra->regmap, vibra->dsp.owt_base_reg +
> + (wt_offset * sizeof(u32)), out_data,
> + sizeof(header) + len);
> + if (error)
> + goto err_free;
> +
> + error = vibra->dsp.write(vibra->dev, vibra->regmap, vibra->dsp.push_owt_cmd);
> +err_free:
> + kfree(out_data);
> +
> + return error;
> +}
> +
> +static void cs40l50_add_worker(struct work_struct *work)
> +{
> + struct cs40l50_work *work_data = container_of(work, struct cs40l50_work, work);
> + struct cs40l50_vibra *vibra = work_data->vibra;
> + struct cs40l50_effect *effect;
> + bool is_new = false;
> + int error;
> +
> + error = pm_runtime_resume_and_get(vibra->dev);
> + if (error)
> + goto err_exit;
> +
> + mutex_lock(&vibra->lock);
> +
> + /* Update effect if already present, otherwise create new effect */
> + effect = cs40l50_find_effect(work_data->effect->id, &vibra->effect_head);
> + if (!effect) {
> + effect = kzalloc(sizeof(*effect), GFP_KERNEL);
> + if (!effect) {
> + error = -ENOMEM;
> + goto err_mutex;
> + }
> +
> + effect->id = work_data->effect->id;
> + is_new = true;
> + }
> +
> + error = cs40l50_effect_bank_set(work_data, effect);
> + if (error)
> + goto err_free;
> +
> + error = cs40l50_effect_index_set(work_data, effect);
> + if (error)
> + goto err_free;
> +
> + error = cs40l50_effect_gpio_mapping_set(work_data, effect);
> + if (error)
> + goto err_free;
> +
> + if (effect->type == CS40L50_WVFRM_BANK_OWT)
> + error = cs40l50_upload_owt(work_data);
> +err_free:
> + if (is_new) {
> + if (error)
> + kfree(effect);
> + else
> + list_add(&effect->list, &vibra->effect_head);
> + }
> +err_mutex:
> + mutex_unlock(&vibra->lock);
> +
> + pm_runtime_mark_last_busy(vibra->dev);
> + pm_runtime_put_autosuspend(vibra->dev);
> +err_exit:
> + work_data->error = error;
> +}
> +
> +static int cs40l50_add(struct input_dev *dev, struct ff_effect *effect,
> + struct ff_effect *old)
> +{
> + struct ff_periodic_effect *periodic = &effect->u.periodic;
> + struct cs40l50_vibra *vibra = input_get_drvdata(dev);
> + u32 len = effect->u.periodic.custom_len;
> + struct cs40l50_work work_data;
> +
> + if (effect->type != FF_PERIODIC || periodic->waveform != FF_CUSTOM) {
> + dev_err(vibra->dev, "Type (%#X) or waveform (%#X) unsupported\n",
> + effect->type, periodic->waveform);
> + return -EINVAL;
> + }
> +
> + work_data.custom_data = kcalloc(len, sizeof(s16), GFP_KERNEL);
> + if (!work_data.custom_data)
> + return -ENOMEM;
> +
> + if (copy_from_user(work_data.custom_data, effect->u.periodic.custom_data,
> + sizeof(s16) * len)) {
> + work_data.error = -EFAULT;
> + goto err_free;
> + }
work_data.custom_data = memdup_array_user(effect->u.periodic.custom_data,
len, sizeof(s16));
if (IS_ERR(work_data.custom_data))
return PTR_ERR(work_data.custom_data);
> +
> + work_data.custom_len = len;
> + work_data.vibra = vibra;
> + work_data.effect = effect;
> + INIT_WORK(&work_data.work, cs40l50_add_worker);
> +
> + /* Push to the workqueue to serialize with playbacks */
> + queue_work(vibra->vibe_wq, &work_data.work);
> + flush_work(&work_data.work);
> +err_free:
> + kfree(work_data.custom_data);
> +
> + return work_data.error;
> +}
> +
> +static void cs40l50_start_worker(struct work_struct *work)
> +{
> + struct cs40l50_work *work_data = container_of(work, struct cs40l50_work, work);
> + struct cs40l50_vibra *vibra = work_data->vibra;
> + struct cs40l50_effect *start_effect;
> +
> + if (pm_runtime_resume_and_get(vibra->dev) < 0)
> + goto err_free;
> +
> + mutex_lock(&vibra->lock);
> +
> + start_effect = cs40l50_find_effect(work_data->effect->id, &vibra->effect_head);
> + if (start_effect) {
> + while (--work_data->count >= 0) {
> + vibra->dsp.write(vibra->dev, vibra->regmap, start_effect->index);
> + usleep_range(work_data->effect->replay.length,
> + work_data->effect->replay.length + 100);
If (I am reading this right you are spinning here playing the effect. It
would be much better if you tracked outstanding number of replays for an
effect and had a work re-scheduled that would play an instance.
Similarly to what code in ff-memless.c is doing.
> + }
> + }
> +
> + mutex_unlock(&vibra->lock);
> +
> + if (!start_effect)
> + dev_err(vibra->dev, "Effect to play not found\n");
> +
> + pm_runtime_mark_last_busy(vibra->dev);
> + pm_runtime_put_autosuspend(vibra->dev);
> +err_free:
> + kfree(work_data);
> +}
> +
> +static void cs40l50_stop_worker(struct work_struct *work)
> +{
> + struct cs40l50_work *work_data = container_of(work, struct cs40l50_work, work);
> + struct cs40l50_vibra *vibra = work_data->vibra;
> +
> + if (pm_runtime_resume_and_get(vibra->dev) < 0)
> + return;
> +
> + mutex_lock(&vibra->lock);
> +
> + vibra->dsp.write(vibra->dev, vibra->regmap, vibra->dsp.stop_cmd);
> +
> + mutex_unlock(&vibra->lock);
> +
> + pm_runtime_mark_last_busy(vibra->dev);
> + pm_runtime_put_autosuspend(vibra->dev);
> +
> + kfree(work_data);
> +}
> +
> +static int cs40l50_playback(struct input_dev *dev, int effect_id, int val)
> +{
> + struct cs40l50_vibra *vibra = input_get_drvdata(dev);
> + struct cs40l50_work *work_data;
> +
> + work_data = kzalloc(sizeof(*work_data), GFP_ATOMIC);
> + if (!work_data)
> + return -ENOMEM;
> +
> + work_data->vibra = vibra;
> +
> + if (val > 0) {
> + work_data->effect = &dev->ff->effects[effect_id];
> + work_data->count = val;
> + INIT_WORK(&work_data->work, cs40l50_start_worker);
> + } else {
> + /* Just stop the amplifier as device drives only one effect */
> + INIT_WORK(&work_data->work, cs40l50_stop_worker);
> + }
> +
> + queue_work(vibra->vibe_wq, &work_data->work);
> +
> + return 0;
> +}
> +
> +static void cs40l50_erase_worker(struct work_struct *work)
> +{
> + struct cs40l50_work *work_data = container_of(work, struct cs40l50_work, work);
> + struct cs40l50_effect *owt_effect, *erase_effect;
> + struct cs40l50_vibra *vibra = work_data->vibra;
> + int error;
> +
> + error = pm_runtime_resume_and_get(vibra->dev);
> + if (error)
> + goto err_exit;
> +
> + mutex_lock(&vibra->lock);
> +
> + erase_effect = cs40l50_find_effect(work_data->effect->id, &vibra->effect_head);
> + if (!erase_effect) {
> + dev_err(vibra->dev, "Effect to erase not found\n");
> + error = -EINVAL;
> + goto err_mutex;
> + }
> +
> + if (erase_effect->gpio_reg != CS40L50_GPIO_MAPPING_NONE) {
> + error = regmap_write(vibra->regmap, erase_effect->gpio_reg,
> + CS40L50_GPIO_DISABLE);
> + if (error)
> + goto err_mutex;
> + }
> +
> + if (erase_effect->type == CS40L50_WVFRM_BANK_OWT) {
> + error = vibra->dsp.write(vibra->dev, vibra->regmap,
> + vibra->dsp.delete_owt_cmd |
> + erase_effect->index);
> + if (error)
> + goto err_mutex;
> +
> + list_for_each_entry(owt_effect, &vibra->effect_head, list)
> + if (owt_effect->type == CS40L50_WVFRM_BANK_OWT &&
> + owt_effect->index > erase_effect->index)
> + owt_effect->index--;
> + }
> +
> + list_del(&erase_effect->list);
> + kfree(erase_effect);
> +err_mutex:
> + mutex_unlock(&vibra->lock);
> +
> + pm_runtime_mark_last_busy(vibra->dev);
> + pm_runtime_put_autosuspend(vibra->dev);
> +err_exit:
> + work_data->error = error;
> +}
> +
> +static int cs40l50_erase(struct input_dev *dev, int effect_id)
> +{
> + struct cs40l50_vibra *vibra = input_get_drvdata(dev);
> + struct cs40l50_work work_data;
> +
> + work_data.vibra = vibra;
> + work_data.effect = &dev->ff->effects[effect_id];
> +
> + INIT_WORK(&work_data.work, cs40l50_erase_worker);
> +
> + /* Push to workqueue to serialize with playbacks */
> + queue_work(vibra->vibe_wq, &work_data.work);
> + flush_work(&work_data.work);
You already take the lock when you play, upload or erase an effect. Why
do we need additional single-thread workqueue for this? Why do we need
additional ordering and synchronization?
> +
> + return work_data.error;
> +}
> +
> +static void cs40l50_remove_wq(void *data)
> +{
> + flush_workqueue(data);
> + destroy_workqueue(data);
> +}
> +
> +static int cs40l50_vibra_probe(struct platform_device *pdev)
> +{
> + struct cs40l50 *cs40l50 = dev_get_drvdata(pdev->dev.parent);
> + struct cs40l50_vibra *vibra;
> + int error;
> +
> + vibra = devm_kzalloc(pdev->dev.parent, sizeof(*vibra), GFP_KERNEL);
> + if (!vibra)
> + return -ENOMEM;
> +
> + mutex_init(&vibra->lock);
> +
> + vibra->dev = cs40l50->dev;
> + vibra->regmap = cs40l50->regmap;
> + vibra->dsp = cs40l50_dsp;
> +
> + vibra->input = devm_input_allocate_device(vibra->dev);
> + if (!vibra->input)
> + return -ENOMEM;
> +
> + vibra->input->id.product = cs40l50->devid;
> + vibra->input->id.version = cs40l50->revid;
> + vibra->input->name = "cs40l50_vibra";
> +
> + input_set_drvdata(vibra->input, vibra);
> + input_set_capability(vibra->input, EV_FF, FF_PERIODIC);
> + input_set_capability(vibra->input, EV_FF, FF_CUSTOM);
> +
> + error = input_ff_create(vibra->input, FF_MAX_EFFECTS);
> + if (error) {
> + dev_err(vibra->dev, "Failed to create input device\n");
> + return error;
> + }
> +
> + vibra->input->ff->upload = cs40l50_add;
> + vibra->input->ff->playback = cs40l50_playback;
> + vibra->input->ff->erase = cs40l50_erase;
> +
> + INIT_LIST_HEAD(&vibra->effect_head);
> +
> + vibra->vibe_wq = alloc_ordered_workqueue("vibe_wq", WQ_HIGHPRI);
> + if (!vibra->vibe_wq)
> + return -ENOMEM;
> +
> + error = devm_add_action_or_reset(vibra->dev, cs40l50_remove_wq, vibra->vibe_wq);
> + if (error)
> + return error;
> +
> + return input_register_device(vibra->input);
Please no this kind of short hands when there are multiple exists from a
function.
error = input_register_device(vibra->input);
if (error)
return error;
return 0;
This way it is much easier to move the code around when needed.
> +}
> +
> +static const struct platform_device_id cs40l50_vibra_id_match[] = {
> + { "cs40l50-vibra", },
> + {}
> +};
> +MODULE_DEVICE_TABLE(platform, cs40l50_vibra_id_match);
> +
> +static struct platform_driver cs40l50_vibra_driver = {
> + .probe = cs40l50_vibra_probe,
> + .id_table = cs40l50_vibra_id_match,
> + .driver = {
> + .name = "cs40l50-vibra",
> + },
> +};
> +module_platform_driver(cs40l50_vibra_driver);
> +
> +MODULE_DESCRIPTION("CS40L50 Advanced Haptic Driver");
> +MODULE_AUTHOR("James Ogletree, Cirrus Logic Inc. <james.ogletree@cirrus.com>");
> +MODULE_LICENSE("GPL");
> --
> 2.25.1
>
Thanks.
--
Dmitry
^ permalink raw reply
* [PATCH v4 0/4] HID: Add support for Himax HX83102j touchscreen
From: Allen_Lin @ 2024-04-17 7:41 UTC (permalink / raw)
To: dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor, jikos,
benjamin.tissoires, linux-input, devicetree, linux-kernel
Cc: Allen_Lin
Hi,
This driver implements for Himax HID touchscreen HX83102j.
Using SPI interface to receive/send HID packets.
Changes in v2 :
-Added power description in YAML document.
-Added ddreset-gpios property in YAML document.
-Added firmware-name property in YAML document.
-Modified the description of pid.
-Modified the example.
Changes in v3:
-Fix "regulator" spelling in YAML file.
-Change himax,firmware-name to firmware-name in YAML file.
-Remove himax,pid in YAML file.
-Change driver name from hid-himax-83102j to hid-himax.
Changes in v4:
-Fix "no new line character at the end of file" error in YAML file.
Allen_Lin (4):
dt-bindings: input: Add Himax HX83102J touchscreen
HID: Add Himax HX83102J touchscreen driver
HID: Add DRM panel follower function
HID: Load firmware directly from file to IC
.../input/touchscreen/himax,hx83102j.yaml | 93 +
MAINTAINERS | 7 +
drivers/hid/Kconfig | 7 +
drivers/hid/Makefile | 2 +
drivers/hid/hid-himax.c | 3133 +++++++++++++++++
drivers/hid/hid-himax.h | 460 +++
6 files changed, 3702 insertions(+)
create mode 100644 Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
create mode 100644 drivers/hid/hid-himax.c
create mode 100644 drivers/hid/hid-himax.h
--
2.34.1
^ permalink raw reply
* [PATCH v4 1/4] dt-bindings: input: Add Himax HX83102J touchscreen
From: Allen_Lin @ 2024-04-17 7:41 UTC (permalink / raw)
To: dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor, jikos,
benjamin.tissoires, linux-input, devicetree, linux-kernel
Cc: Allen_Lin
In-Reply-To: <20240417074115.1137885-1-allencl_lin@hotmail.com>
Add the HX83102j touchscreen device tree bindings documents.
HX83102j is a Himax TDDI touchscreen controller.
It's power sequence should be bound with a lcm driver, thus it
needs to be a panel follower. Others are the same as normal SPI
touchscreen controller.
Reviewed-by: Rob Herring <robh@kernel.org>
Signed-off-by: Allen_Lin <allencl_lin@hotmail.com>
---
.../input/touchscreen/himax,hx83102j.yaml | 93 +++++++++++++++++++
MAINTAINERS | 6 ++
2 files changed, 99 insertions(+)
create mode 100644 Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
diff --git a/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml b/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
new file mode 100644
index 000000000000..d16fba2ef5f9
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/input/touchscreen/himax,hx83102j.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Himax hx83102j touchscreen
+
+maintainers:
+ - Allen Lin <allencl_lin@hotmail.com>
+
+description:
+ This Himax hx83102j touchscreen uses the spi protocol.
+
+allOf:
+ - $ref: /schemas/input/touchscreen/touchscreen.yaml#
+ - $ref: /schemas/spi/spi-peripheral-props.yaml#
+
+properties:
+ compatible:
+ const: himax,hx83102j
+
+ reg:
+ maxItems: 1
+
+ interrupts:
+ maxItems: 1
+
+ reset-gpios:
+ maxItems: 1
+
+ vccd-supply:
+ description: A phandle for the regulator supplying IO power.
+
+ vsn-supply:
+ description: Negative supply regulator.
+
+ vsp-supply:
+ description: Positive supply regulator.
+
+ ddreset-gpios:
+ description: A phandle of gpio for display reset controlled by the LCD driver.
+ This is the master reset, if this reset is triggered, the TP reset will
+ also be triggered.
+
+ spi-cpha: true
+
+ spi-cpol: true
+
+ spi-max-frequency: true
+
+ panel: true
+
+ firmware-name:
+ description: Specify the file name for firmware loading.
+
+required:
+ - compatible
+ - reg
+ - interrupts
+ - reset-gpios
+ - panel
+ - vccd-supply
+ - vsn-supply
+ - vsp-supply
+ - ddreset-gpios
+
+additionalProperties: false
+
+examples:
+ - |
+ #include <dt-bindings/gpio/gpio.h>
+ #include <dt-bindings/interrupt-controller/irq.h>
+ spi {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ ap_ts: touchscreen@0 {
+ compatible = "himax,hx83102j";
+ reg = <0>;
+ pinctrl-names = "default";
+ pinctrl-0 = <&touch_int0 &touch_reset>;
+ reset-gpios = <&gpio1 8 GPIO_ACTIVE_LOW>;
+ spi-cpha;
+ spi-cpol;
+ interrupt-parent = <&gpio1>;
+ interrupts = <7 IRQ_TYPE_LEVEL_LOW>;
+ panel = <&panel>;
+ vccd-supply = <®ulator>;
+ vsn-supply = <®ulator>;
+ vsp-supply = <®ulator>;
+ ddreset-gpios = <&gpio1>;
+ };
+ };
diff --git a/MAINTAINERS b/MAINTAINERS
index 43b39956694a..bb7b363cb2ed 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9669,6 +9669,12 @@ L: linux-kernel@vger.kernel.org
S: Maintained
F: drivers/misc/hisi_hikey_usb.c
+HIMAX HID TOUCHSCREEN
+M: Allen Lin <allencl_lin@hotmail.com>
+L: linux-input@vger.kernel.org
+S: Maintained
+F: Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
+
HIMAX HX83112B TOUCHSCREEN SUPPORT
M: Job Noorman <job@noorman.info>
L: linux-input@vger.kernel.org
--
2.34.1
^ permalink raw reply related
* [PATCH v4 2/4] HID: Add Himax HX83102J touchscreen driver
From: Allen_Lin @ 2024-04-17 7:41 UTC (permalink / raw)
To: dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor, jikos,
benjamin.tissoires, linux-input, devicetree, linux-kernel
Cc: Allen_Lin
In-Reply-To: <20240417074115.1137885-1-allencl_lin@hotmail.com>
Add a new driver for Himax HX83102J touchscreen controllers.
This driver supports Himax IC using the SPI interface to
acquire HID packets.
After confirmed the IC's exsitence the driver loads the firmware
image from flash to get the HID report descriptor, VID and PID.
And use those information to register HID device.
Signed-off-by: Allen_Lin <allencl_lin@hotmail.com>
---
MAINTAINERS | 1 +
drivers/hid/Kconfig | 7 +
drivers/hid/Makefile | 2 +
drivers/hid/hid-himax.c | 1768 +++++++++++++++++++++++++++++++++++++++
drivers/hid/hid-himax.h | 288 +++++++
5 files changed, 2066 insertions(+)
create mode 100644 drivers/hid/hid-himax.c
create mode 100644 drivers/hid/hid-himax.h
diff --git a/MAINTAINERS b/MAINTAINERS
index bb7b363cb2ed..34ec2f0241d7 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9674,6 +9674,7 @@ M: Allen Lin <allencl_lin@hotmail.com>
L: linux-input@vger.kernel.org
S: Maintained
F: Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml
+F: drivers/hid/hid-himax.*
HIMAX HX83112B TOUCHSCREEN SUPPORT
M: Job Noorman <job@noorman.info>
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 4c682c650704..0e5146ee40d6 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -376,6 +376,13 @@ config HID_GLORIOUS
Support for Glorious PC Gaming Race mice such as
the Glorious Model O, O- and D.
+config HID_HIMAX
+ tristate "Himax hx83102j touchscreen"
+ depends on HID
+ depends on SPI
+ help
+ Support for Himax TDDI hx83102j touchscreen.
+
config HID_HOLTEK
tristate "Holtek HID devices"
depends on USB_HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 082a728eac60..2ad21d60492e 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -170,3 +170,5 @@ obj-$(INTEL_ISH_FIRMWARE_DOWNLOADER) += intel-ish-hid/
obj-$(CONFIG_AMD_SFH_HID) += amd-sfh-hid/
obj-$(CONFIG_SURFACE_HID_CORE) += surface-hid/
+
+obj-$(CONFIG_HID_HIMAX) += hid-himax.o
diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c
new file mode 100644
index 000000000000..f8a417e07f0c
--- /dev/null
+++ b/drivers/hid/hid-himax.c
@@ -0,0 +1,1768 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Himax hx83102j SPI Driver Code for HID.
+ *
+ * Copyright (C) 2024 Himax Corporation.
+ */
+
+#include "hid-himax.h"
+
+static int himax_chip_init(struct himax_ts_data *ts);
+static void himax_ts_work(struct himax_ts_data *ts);
+
+/**
+ * himax_spi_read() - Read data from SPI
+ * @ts: Himax touch screen data
+ * @cmd_len: Length of command
+ * @buf: Buffer to store data
+ * @len: Length of data to read
+ *
+ * Himax spi_sync wrapper for read. Read protocol start with write command,
+ * and received the data after that.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_spi_read(struct himax_ts_data *ts, u8 cmd_len, u8 *buf, u32 len)
+{
+ int ret;
+ int retry_cnt;
+ struct spi_message msg;
+ struct spi_transfer xfer = {
+ .len = cmd_len + len,
+ .tx_buf = ts->xfer_tx_data,
+ .rx_buf = ts->xfer_rx_data
+ };
+
+ spi_message_init(&msg);
+ spi_message_add_tail(&xfer, &msg);
+
+ for (retry_cnt = 0; retry_cnt < HIMAX_BUS_RETRY; retry_cnt++) {
+ ret = spi_sync(ts->spi, &msg);
+ if (!ret)
+ break;
+ }
+
+ if (retry_cnt == HIMAX_BUS_RETRY) {
+ dev_err(ts->dev, "%s: SPI read error retry over %d\n", __func__, HIMAX_BUS_RETRY);
+ return -EIO;
+ }
+
+ if (ret < 0)
+ return ret;
+
+ if (msg.status < 0)
+ return msg.status;
+
+ memcpy(buf, ts->xfer_rx_data + cmd_len, len);
+
+ return 0;
+}
+
+/**
+ * himax_spi_write() - Write data to SPI
+ * @ts: Himax touch screen data
+ * @tx_buf: Buffer to write
+ * @tx_len: Length of data to write
+ * @written: Length of data written
+ *
+ * Himax spi_sync wrapper for write.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_spi_write(struct himax_ts_data *ts, u8 *tx_buf, u32 tx_len, u32 *written)
+{
+ int ret;
+ struct spi_message msg;
+ struct spi_transfer xfer = {
+ .tx_buf = tx_buf,
+ .len = tx_len,
+ };
+
+ spi_message_init(&msg);
+ spi_message_add_tail(&xfer, &msg);
+
+ *written = 0;
+ ret = spi_sync(ts->spi, &msg);
+
+ if (ret < 0)
+ return ret;
+
+ if (msg.status < 0)
+ return msg.status;
+
+ *written = msg.actual_length;
+
+ return 0;
+}
+
+/**
+ * himax_read() - Read data from Himax bus
+ * @ts: Himax touch screen data
+ * @cmd: Command to send
+ * @buf: Buffer to store data, caller should allocate the buffer
+ * @len: Length of data to read
+ *
+ * Basic read operation for Himax SPI bus. Which start with a 3 bytes command,
+ * 1st byte is the spi function select, 2nd byte is the command belong to the
+ * spi function and 3rd byte is the dummy byte for IC to process the command.
+ *
+ * The IC takes 1 basic operation at a time, so the read/write operation
+ * is proctected by rw_lock mutex_unlock. Also the buffer xfer_rx/tx_data is
+ * shared between read and write operation, protected by the same mutex lock.
+ * The xfer data limit by SPI constroller max xfer size + BUS_R/W_HLEN
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_read(struct himax_ts_data *ts, u8 cmd, u8 *buf, u32 len)
+{
+ int ret;
+
+ if (len + HIMAX_BUS_R_HLEN > ts->spi_xfer_max_sz) {
+ dev_err(ts->dev, "%s, len[%u] is over %u\n", __func__,
+ len + HIMAX_BUS_R_HLEN, ts->spi_xfer_max_sz);
+ return -EINVAL;
+ }
+
+ mutex_lock(&ts->rw_lock);
+
+ memset(ts->xfer_rx_data, 0, HIMAX_BUS_R_HLEN + len);
+ ts->xfer_tx_data[0] = HIMAX_SPI_FUNCTION_READ;
+ ts->xfer_tx_data[1] = cmd;
+ ts->xfer_tx_data[2] = 0x00;
+ ret = himax_spi_read(ts, HIMAX_BUS_R_HLEN, buf, len);
+
+ mutex_unlock(&ts->rw_lock);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: failed = %d\n", __func__, ret);
+
+ return ret;
+}
+
+/**
+ * himax_write() - Write data to Himax bus
+ * @ts: Himax touch screen data
+ * @cmd: Command to send
+ * @addr: Address to write
+ * @data: Data to write
+ * @len: Length of data to write
+ *
+ * Basic write operation for Himax IC. Which start with a 2 bytes command,
+ * 1st byte is the spi function select and 2nd byte is the command belong to the
+ * spi function. Else is the data to write.
+ *
+ * The IC takes 1 basic operation at a time, so the read/write operation
+ * is proctected by rw_lock mutex_unlock. Also the buffer xfer_tx_data is
+ * shared between read and write operation, protected by the same mutex lock.
+ * The xfer data limit by SPI constroller max xfer size + HIMAX_BUS_W_HLEN
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_write(struct himax_ts_data *ts, u8 cmd, u8 *addr, const u8 *data, u32 len)
+{
+ int ret;
+ u8 offset;
+ u32 written;
+ u32 tmp_len;
+
+ if (len + HIMAX_BUS_W_HLEN > ts->spi_xfer_max_sz) {
+ dev_err(ts->dev, "%s: len[%u] is over %u\n", __func__,
+ len + HIMAX_BUS_W_HLEN, ts->spi_xfer_max_sz);
+ return -EFAULT;
+ }
+
+ mutex_lock(&ts->rw_lock);
+
+ memset(ts->xfer_tx_data, 0, len + HIMAX_BUS_W_HLEN);
+ ts->xfer_tx_data[0] = HIMAX_SPI_FUNCTION_WRITE;
+ ts->xfer_tx_data[1] = cmd;
+ offset = HIMAX_BUS_W_HLEN;
+ tmp_len = len;
+
+ if (addr) {
+ memcpy(ts->xfer_tx_data + offset, addr, 4);
+ offset += 4;
+ tmp_len -= 4;
+ }
+
+ if (data)
+ memcpy(ts->xfer_tx_data + offset, data, tmp_len);
+
+ ret = himax_spi_write(ts, ts->xfer_tx_data, len + HIMAX_BUS_W_HLEN, &written);
+
+ mutex_unlock(&ts->rw_lock);
+
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: failed, ret = %d\n", __func__, ret);
+ return ret;
+ }
+
+ if (written != len + HIMAX_BUS_W_HLEN) {
+ dev_err(ts->dev, "%s: actual write length mismatched: %u != %u\n",
+ __func__, written, len + HIMAX_BUS_W_HLEN);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_mcu_set_burst_mode() - Set burst mode for MCU
+ * @ts: Himax touch screen data
+ * @auto_add_4_byte: Enable auto add 4 byte mode
+ *
+ * Set burst mode for MCU, which is used for read/write data from/to MCU.
+ * HIMAX_AHB_ADDR_CONTI config the IC to take data continuously,
+ * HIMAX_AHB_ADDR_INCR4 config the IC to auto increment the address by 4 byte when
+ * each 4 bytes read/write.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_set_burst_mode(struct himax_ts_data *ts, bool auto_add_4_byte)
+{
+ int ret;
+ u8 tmp_data[HIMAX_REG_SZ];
+
+ tmp_data[0] = HIMAX_AHB_CMD_CONTI;
+
+ ret = himax_write(ts, HIMAX_AHB_ADDR_CONTI, NULL, tmp_data, 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_conti failed\n", __func__);
+ return ret;
+ }
+
+ tmp_data[0] = HIMAX_AHB_CMD_INCR4;
+ if (auto_add_4_byte)
+ tmp_data[0] |= HIMAX_AHB_CMD_INCR4_ADD_4_BYTE;
+
+ ret = himax_write(ts, HIMAX_AHB_ADDR_INCR4, NULL, tmp_data, 1);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: write ahb_addr_incr4 failed\n", __func__);
+
+ return ret;
+}
+
+/**
+ * himax_burst_mode_enable() - Enable burst mode for MCU if possible
+ * @ts: Himax touch screen data
+ * @addr: Address to read/write
+ * @len: Length of data to read/write
+ *
+ * Enable burst mode for MCU, helper function to determine the burst mode
+ * operation for MCU. When the address is HIMAX_REG_ADDR_SPI200_DATA, the burst
+ * mode is disabled. When the length of data is over HIMAX_REG_SZ, the burst
+ * mode is enabled. Else the burst mode is disabled.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_burst_mode_enable(struct himax_ts_data *ts, u32 addr, u32 len)
+{
+ int ret;
+
+ if (addr == HIMAX_REG_ADDR_SPI200_DATA)
+ ret = himax_mcu_set_burst_mode(ts, false);
+ else if (len > HIMAX_REG_SZ)
+ ret = himax_mcu_set_burst_mode(ts, true);
+ else
+ ret = himax_mcu_set_burst_mode(ts, false);
+
+ if (ret)
+ dev_err(ts->dev, "%s: burst enable fail!\n", __func__);
+
+ return ret;
+}
+
+/**
+ * himax_mcu_register_read() - Read data from IC register/sram
+ * @ts: Himax touch screen data
+ * @addr: Address to read
+ * @buf: Buffer to store data, caller should allocate the buffer
+ * @len: Length of data to read
+ *
+ * Himax TP IC has its internal register and SRAM, this function is used to
+ * read data from it. The reading protocol require a sequence of write and read,
+ * which include write address to IC and read data from IC. Thus the read/write
+ * operation is proctected by reg_lock mutex_unlock to protect the sequence.
+ * The first step is to set the burst mode for MCU, then write the address to
+ * AHB register to tell where to read. Then set the access direction to read,
+ * and read the data from AHB register. The max length of data to read is decided
+ * by AHB register max transfer size, but if it could't bigger then SPI controller
+ * max transfer size. When the length of data is over the max transfer size,
+ * the data will be read in multiple times.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_register_read(struct himax_ts_data *ts, u32 addr, u8 *buf, u32 len)
+{
+ int i;
+ int ret;
+ u8 direction_switch = HIMAX_AHB_CMD_ACCESS_DIRECTION_READ;
+ u32 read_sz;
+ const u32 max_trans_sz =
+ min(HIMAX_HX83102J_REG_XFER_MAX, ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN);
+ union himax_dword_data target_addr;
+
+ mutex_lock(&ts->reg_lock);
+
+ ret = himax_burst_mode_enable(ts, addr, len);
+ if (ret)
+ goto read_end;
+
+ for (i = 0; i < len; i += read_sz) {
+ target_addr.dword = cpu_to_le32(addr + i);
+ ret = himax_write(ts, HIMAX_AHB_ADDR_BYTE_0, target_addr.byte, NULL, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_byte_0 failed\n", __func__);
+ goto read_end;
+ }
+
+ ret = himax_write(ts, HIMAX_AHB_ADDR_ACCESS_DIRECTION, NULL,
+ &direction_switch, 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_access_direction failed\n", __func__);
+ goto read_end;
+ }
+
+ read_sz = min((len - i), max_trans_sz);
+ ret = himax_read(ts, HIMAX_AHB_ADDR_RDATA_BYTE_0, buf + i, read_sz);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read ahb_addr_rdata_byte_0 failed\n", __func__);
+ goto read_end;
+ }
+ }
+
+read_end:
+ mutex_unlock(&ts->reg_lock);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: addr = 0x%08X, len = %u, ret = %d\n", __func__,
+ addr, len, ret);
+
+ return ret;
+}
+
+/**
+ * himax_mcu_register_write() - Write data to IC register/sram
+ * @ts: Himax touch screen data
+ * @addr: Address to write
+ * @buf: Data to write
+ * @len: Length of data to write
+ *
+ * Himax TP IC has its internal register and SRAM, this function is used to
+ * write data to it. The writing protocol require a sequence of write, which
+ * include write address to IC and write data to IC. Thus the write operation
+ * is proctected by reg_lock mutex_unlock to protect the sequence. The first
+ * step is to set the burst mode for MCU, then write the address and data to
+ * AHB register. The max length of data to read is decided by AHB register max
+ * transfer size, but if it could't bigger then SPI controller max transfer
+ * size. When the length of data is over the max transfer size, the data will
+ * be written in multiple times.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_register_write(struct himax_ts_data *ts, u32 addr, const u8 *buf, u32 len)
+{
+ int i;
+ int ret;
+ u32 write_sz;
+ const u32 max_trans_sz = min(HIMAX_HX83102J_REG_XFER_MAX,
+ ts->spi_xfer_max_sz - HIMAX_BUS_W_HLEN - HIMAX_REG_SZ);
+ union himax_dword_data target_addr;
+
+ mutex_lock(&ts->reg_lock);
+
+ ret = himax_burst_mode_enable(ts, addr, len);
+ if (ret)
+ goto write_end;
+
+ for (i = 0; i < len; i += max_trans_sz) {
+ write_sz = min((len - i), max_trans_sz);
+ target_addr.dword = cpu_to_le32(addr + i);
+ ret = himax_write(ts, HIMAX_AHB_ADDR_BYTE_0,
+ target_addr.byte, buf + i, write_sz + HIMAX_REG_SZ);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_byte_0 failed\n", __func__);
+ break;
+ }
+ }
+
+write_end:
+ mutex_unlock(&ts->reg_lock);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: addr = 0x%08X, len = %u, ret = %d\n", __func__,
+ addr, len, ret);
+
+ return ret;
+}
+
+/**
+ * himax_mcu_interface_on() - Wakeup IC bus interface
+ * @ts: Himax touch screen data
+ *
+ * This function is used to wakeup IC bus interface. The IC may enter sleep mode
+ * and need to wakeup before any operation. The wakeup process is to read a dummy
+ * AHB register to wakeup the IC bus interface. Also, the function setup the burst
+ * mode as default for MCU and read back the burst mode setting to confirm the
+ * setting is written. The action is a double check to confirm the IC bus interface
+ * is ready for operation.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_interface_on(struct himax_ts_data *ts)
+{
+ int ret;
+ u8 buf[2][HIMAX_REG_SZ];
+ u32 retry_cnt;
+ const u32 burst_retry_limit = 10;
+
+ mutex_lock(&ts->reg_lock);
+ /* Read a dummy register to wake up BUS. */
+ ret = himax_read(ts, HIMAX_AHB_ADDR_RDATA_BYTE_0, buf[0], 4);
+ mutex_unlock(&ts->reg_lock);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read ahb_addr_rdata_byte_0 failed\n", __func__);
+ return ret;
+ }
+
+ for (retry_cnt = 0; retry_cnt < burst_retry_limit; retry_cnt++) {
+ /* AHB: read/write to SRAM in sequential order */
+ buf[0][0] = HIMAX_AHB_CMD_CONTI;
+ ret = himax_write(ts, HIMAX_AHB_ADDR_CONTI, NULL, buf[0], 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_conti failed\n", __func__);
+ return ret;
+ }
+
+ /* AHB: Auto increment SRAM addr+4 while each 4 bytes read/write */
+ buf[0][0] = HIMAX_AHB_CMD_INCR4;
+ ret = himax_write(ts, HIMAX_AHB_ADDR_INCR4, NULL, buf[0], 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write ahb_addr_incr4 failed\n", __func__);
+ return ret;
+ }
+
+ /* Check cmd */
+ ret = himax_read(ts, HIMAX_AHB_ADDR_CONTI, buf[0], 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read ahb_addr_conti failed\n", __func__);
+ return ret;
+ }
+
+ ret = himax_read(ts, HIMAX_AHB_ADDR_INCR4, buf[1], 1);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read ahb_addr_incr4 failed\n", __func__);
+ return ret;
+ }
+
+ if (buf[0][0] == HIMAX_AHB_CMD_CONTI && buf[1][0] == HIMAX_AHB_CMD_INCR4)
+ return 0;
+
+ usleep_range(1000, 1100);
+ }
+
+ dev_err(ts->dev, "%s: failed!\n", __func__);
+
+ return -EIO;
+}
+
+/**
+ * hx83102j_pin_reset() - Reset the touch chip by hardware pin
+ * @ts: Himax touch screen data
+ *
+ * This function is used to hardware reset the touch chip. By pull down the
+ * reset pin to low over 20ms, ensure the reset circuit perform a complete reset
+ * to the touch chip.
+ *
+ * Return: None
+ */
+static void hx83102j_pin_reset(struct himax_ts_data *ts)
+{
+ gpiod_set_value(ts->pdata.gpiod_rst, 1);
+ usleep_range(10000, 10100);
+ gpiod_set_value(ts->pdata.gpiod_rst, 0);
+ usleep_range(20000, 20100);
+}
+
+/**
+ * himax_int_enable() - Enable/Disable interrupt
+ * @ts: Himax touch screen data
+ * @enable: true for enable, false for disable
+ *
+ * This function is used to enable or disable the interrupt.
+ *
+ * Return: None
+ */
+static void himax_int_enable(struct himax_ts_data *ts, bool enable)
+{
+ int irqnum = ts->himax_irq;
+ unsigned long flags;
+
+ spin_lock_irqsave(&ts->irq_lock, flags);
+ if (enable && atomic_read(&ts->irq_state) == 0) {
+ atomic_set(&ts->irq_state, 1);
+ enable_irq(irqnum);
+ } else if (!enable && atomic_read(&ts->irq_state) == 1) {
+ atomic_set(&ts->irq_state, 0);
+ disable_irq_nosync(irqnum);
+ }
+ spin_unlock_irqrestore(&ts->irq_lock, flags);
+ dev_info(ts->dev, "%s: Interrupt %s\n", __func__,
+ atomic_read(&ts->irq_state) ? "enabled" : "disabled");
+}
+
+/**
+ * himax_mcu_ic_reset() - Reset the touch chip and disable/enable interrupt
+ * @ts: Himax touch screen data
+ * @int_off: true for disable/enable interrupt, false for not
+ *
+ * This function is used to reset the touch chip with interrupt control. The
+ * TPIC will pull low the interrupt pin when IC is reset. When the ISR has been
+ * set and need to be take care of, the caller could set int_off to true to disable
+ * the interrupt before reset and enable the interrupt after reset.
+ *
+ * Return: None
+ */
+static void himax_mcu_ic_reset(struct himax_ts_data *ts, bool int_off)
+{
+ if (int_off)
+ himax_int_enable(ts, false);
+
+ hx83102j_pin_reset(ts);
+
+ if (int_off)
+ himax_int_enable(ts, true);
+}
+
+/**
+ * hx83102j_sense_off() - Stop MCU and enter safe mode
+ * @ts: Himax touch screen data
+ * @check_en: Check if need to ensure FW is stopped by its owne process
+ *
+ * Sense off is a process to make sure the MCU inside the touch chip is stopped.
+ * The process has two stage, first stage is to request FW to stop. Write
+ * HIMAX_REG_DATA_FW_GO_SAFEMODE to HIMAX_REG_ADDR_CTRL_FW tells the FW to stop by its own.
+ * Then read back the FW status to confirm the FW is stopped. When check_en is true,
+ * the function will resend the stop FW command until the retry limit reached.
+ * There maybe a chance that the FW is not stopped by its own, in this case, the
+ * safe mode in next stage still stop the MCU, but FW internal flag may not be
+ * configured correctly. The second stage is to enter safe mode and reset TCON.
+ * Safe mode is a mode that the IC circuit ensure the internal MCU is stopped.
+ * Since this IC is TDDI, the TCON need to be reset to make sure the IC is ready
+ * for next operation.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_sense_off(struct himax_ts_data *ts, bool check_en)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 stop_fw_retry_limit = 35;
+ const u32 enter_safe_mode_retry_limit = 5;
+ const union himax_dword_data safe_mode = {
+ .dword = cpu_to_le32(HIMAX_REG_DATA_FW_GO_SAFEMODE)
+ };
+ union himax_dword_data data;
+
+ dev_info(ts->dev, "%s: check %s\n", __func__, check_en ? "True" : "False");
+ if (!check_en)
+ goto without_check;
+
+ for (retry_cnt = 0; retry_cnt < stop_fw_retry_limit; retry_cnt++) {
+ if (retry_cnt == 0 ||
+ (data.byte[0] != HIMAX_REG_DATA_FW_GO_SAFEMODE &&
+ data.byte[0] != HIMAX_REG_DATA_FW_RE_INIT &&
+ data.byte[0] != HIMAX_REG_DATA_FW_IN_SAFEMODE)) {
+ ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_CTRL_FW,
+ safe_mode.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: stop FW failed\n", __func__);
+ return ret;
+ }
+ }
+ usleep_range(10000, 11000);
+
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_FW_STATUS, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read central state failed\n", __func__);
+ return ret;
+ }
+ if (data.byte[0] != HIMAX_REG_DATA_FW_STATE_RUNNING) {
+ dev_info(ts->dev, "%s: Do not need wait FW, Status = 0x%02X!\n", __func__,
+ data.byte[0]);
+ break;
+ }
+
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_CTRL_FW, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read ctrl FW failed\n", __func__);
+ return ret;
+ }
+ if (data.byte[0] == HIMAX_REG_DATA_FW_IN_SAFEMODE)
+ break;
+ }
+
+ if (data.byte[0] != HIMAX_REG_DATA_FW_IN_SAFEMODE)
+ dev_warn(ts->dev, "%s: Failed to stop FW!\n", __func__);
+
+without_check:
+ for (retry_cnt = 0; retry_cnt < enter_safe_mode_retry_limit; retry_cnt++) {
+ /* set Enter safe mode : 0x31 ==> 0x9527 */
+ data.word[0] = cpu_to_le16(HIMAX_HX83102J_SAFE_MODE_PASSWORD);
+ ret = himax_write(ts, HIMAX_AHB_ADDR_PSW_LB, NULL, data.byte, 2);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: enter safe mode failed\n", __func__);
+ return ret;
+ }
+
+ /* Check enter_save_mode */
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_FW_STATUS, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read central state failed\n", __func__);
+ return ret;
+ }
+
+ if (data.byte[0] == HIMAX_REG_DATA_FW_STATE_SAFE_MODE) {
+ dev_info(ts->dev, "%s: Safe mode entered\n", __func__);
+ /* Reset TCON */
+ data.dword = cpu_to_le32(HIMAX_REG_DATA_TCON_RST);
+ ret = himax_mcu_register_write(ts, HIMAX_HX83102J_REG_ADDR_TCON_RST,
+ data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: reset TCON failed\n", __func__);
+ return ret;
+ }
+ usleep_range(1000, 1100);
+ return 0;
+ }
+ usleep_range(5000, 5100);
+ hx83102j_pin_reset(ts);
+ }
+ dev_err(ts->dev, "%s: failed!\n", __func__);
+
+ return -EIO;
+}
+
+/**
+ * hx83102j_chip_detect() - Check if the touch chip is HX83102J
+ * @ts: Himax touch screen data
+ *
+ * This function is used to check if the touch chip is HX83102J. The process
+ * start with a hardware reset to the touch chip, then knock the IC bus interface
+ * to wakeup the IC bus interface. Then sense off the MCU to prevent bus conflict
+ * when reading the IC ID. The IC ID is read from the IC register, and compare
+ * with the expected ID. If the ID is matched, the chip is HX83102J. Due to display
+ * IC initial code may not ready before the IC ID is read, the function will retry
+ * to read the IC ID for several times to make sure the IC ID is read correctly.
+ * In any case, the SPI bus shouldn't have error when reading the IC ID, so the
+ * function will return error if the SPI bus has error. When the IC is not HX83102J,
+ * the function will return -ENODEV.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_chip_detect(struct himax_ts_data *ts)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 read_icid_retry_limit = 5;
+ const u32 ic_id_mask = GENMASK(31, 8);
+ union himax_dword_data data;
+
+ hx83102j_pin_reset(ts);
+ ret = himax_mcu_interface_on(ts);
+ if (ret)
+ return ret;
+
+ ret = hx83102j_sense_off(ts, false);
+ if (ret)
+ return ret;
+
+ for (retry_cnt = 0; retry_cnt < read_icid_retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_ICID, data.byte, 4);
+ if (ret) {
+ dev_err(ts->dev, "%s: Read IC ID Fail\n", __func__);
+ return ret;
+ }
+
+ data.dword = le32_to_cpu(data.dword);
+ if ((data.dword & ic_id_mask) == HIMAX_REG_DATA_ICID) {
+ ts->ic_data.icid = data.dword;
+ dev_info(ts->dev, "%s: Detect IC HX83102J successfully\n", __func__);
+ return 0;
+ }
+ }
+ dev_err(ts->dev, "%s: Read driver ID register Fail! IC ID = %X,%X,%X\n", __func__,
+ data.byte[3], data.byte[2], data.byte[1]);
+
+ return -ENODEV;
+}
+
+/**
+ * himax_ts_thread() - Thread for interrupt handling
+ * @irq: Interrupt number
+ * @ptr: Pointer to the touch screen data
+ *
+ * This function is used to handle the interrupt. The function will call himax_ts_work()
+ * to handle the interrupt.
+ *
+ * Return: IRQ_HANDLED
+ */
+static irqreturn_t himax_ts_thread(int irq, void *ptr)
+{
+ himax_ts_work((struct himax_ts_data *)ptr);
+
+ return IRQ_HANDLED;
+}
+
+/**
+ * __himax_ts_register_interrupt() - Register interrupt trigger
+ * @ts: Himax touch screen data
+ *
+ * This function is used to register the interrupt. The function will call
+ * devm_request_threaded_irq() to register the interrupt by the trigger type.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int __himax_ts_register_interrupt(struct himax_ts_data *ts)
+{
+ if (ts->ic_data.interrupt_is_edge)
+ return devm_request_threaded_irq(ts->dev, ts->himax_irq, NULL,
+ himax_ts_thread,
+ IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+ ts->dev->driver->name, ts);
+
+ return devm_request_threaded_irq(ts->dev, ts->himax_irq, NULL,
+ himax_ts_thread,
+ IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+ ts->dev->driver->name, ts);
+}
+
+/**
+ * himax_ts_register_interrupt() - Register interrupt
+ * @ts: Himax touch screen data
+ *
+ * This function is a wrapper to call __himax_ts_register_interrupt() to register the
+ * interrupt and set irq_state.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_ts_register_interrupt(struct himax_ts_data *ts)
+{
+ int ret;
+
+ if (!ts || !ts->himax_irq) {
+ dev_err(ts->dev, "%s: ts or ts->himax_irq invalid!\n", __func__);
+ return -EINVAL;
+ }
+
+ ret = __himax_ts_register_interrupt(ts);
+ if (!ret) {
+ atomic_set(&ts->irq_state, 1);
+ dev_info(ts->dev, "%s: irq enabled at: %d\n", __func__, ts->himax_irq);
+ return 0;
+ }
+
+ atomic_set(&ts->irq_state, 0);
+ dev_err(ts->dev, "%s: request_irq failed\n", __func__);
+
+ return ret;
+}
+
+/**
+ * hx83102j_read_event_stack() - Read event stack from touch chip
+ * @ts: Himax touch screen data
+ * @buf: Buffer to store the data
+ * @length: Length of data to read
+ *
+ * This function is used to read the event stack from the touch chip. The event stack
+ * is an AHB output buffer, which store the touch report data.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_read_event_stack(struct himax_ts_data *ts, u8 *buf, u32 length)
+{
+ u32 i;
+ int ret;
+ const u32 max_trunk_sz = ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN;
+
+ for (i = 0; i < length; i += max_trunk_sz) {
+ ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i,
+ min(length - i, max_trunk_sz));
+ if (ret) {
+ dev_err(ts->dev, "%s: read event stack error!\n", __func__);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * himax_touch_get() - Get touch data from touch chip
+ * @ts: Himax touch screen data
+ * @buf: Buffer to store the data
+ *
+ * This function is a wrapper to call hx83102j_read_event_stack() to read the touch
+ * data from the touch chip. The touch_data_sz is the size of the touch data to read,
+ * which is calculated by hid report descriptor provided by the firmware.
+ *
+ * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize
+ * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS
+ * when the read is successful. The reason is that the may need special handling when
+ * the read fails.
+ */
+static int himax_touch_get(struct himax_ts_data *ts, u8 *buf)
+{
+ if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) {
+ dev_err(ts->dev, "can't read data from chip!");
+ return HIMAX_TS_GET_DATA_FAIL;
+ }
+
+ return HIMAX_TS_SUCCESS;
+}
+
+/**
+ * himax_bin_desc_data_get() - Parse descriptor data from firmware token
+ * @ts: Himax touch screen data
+ * @addr: Address of the data in firmware image
+ * @descript_buf: token for parsing
+ *
+ * This function is used to parse the descriptor data from the firmware token. The
+ * descriptors are mappings of information in the firmware image. The function will
+ * check checksum of each token first, and then parse the token to get the related
+ * data. The data includes CID version, FW version, CFG version, touch config table,
+ * HID table, HID descriptor, and HID read descriptor.
+ *
+ * Return: true on success, false on failure
+ */
+static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf)
+{
+ u16 chk_end;
+ u16 chk_sum;
+ u32 hid_table_addr;
+ u32 i, j;
+ u32 image_offset;
+ u32 map_code;
+ const u32 data_sz = 16;
+ const u32 report_desc_offset = 24;
+ union {
+ u8 *buf;
+ u32 *word;
+ } map_data;
+
+ /* looking for mapping in page, each mapping is 16 bytes */
+ for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) {
+ chk_end = 0;
+ chk_sum = 0;
+ for (j = i; j < (i + data_sz); j++) {
+ chk_end |= descript_buf[j];
+ chk_sum += descript_buf[j];
+ }
+ if (!chk_end) { /* 1. Check all zero */
+ return false;
+ } else if (chk_sum % 0x100) { /* 2. Check sum */
+ dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr);
+ } else { /* 3. get data */
+ map_data.buf = &descript_buf[i];
+ map_code = le32_to_cpup(map_data.word);
+ map_data.buf = &descript_buf[i + 4];
+ image_offset = le32_to_cpup(map_data.word);
+ /* 4. load info from FW image by specified mapping offset */
+ switch (map_code) {
+ /* Config ID */
+ case HIMAX_FW_CID:
+ ts->fw_info_table.addr_cid_ver_major = image_offset;
+ ts->fw_info_table.addr_cid_ver_minor = image_offset + 1;
+ break;
+ /* FW version */
+ case HIMAX_FW_VER:
+ ts->fw_info_table.addr_fw_ver_major = image_offset;
+ ts->fw_info_table.addr_fw_ver_minor = image_offset + 1;
+ break;
+ /* Config version */
+ case HIMAX_CFG_VER:
+ ts->fw_info_table.addr_cfg_ver_major = image_offset;
+ ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1;
+ break;
+ /* Touch config table */
+ case HIMAX_TP_CONFIG_TABLE:
+ ts->fw_info_table.addr_cfg_table = image_offset;
+ break;
+ /* HID table */
+ case HIMAX_HID_TABLE:
+ ts->fw_info_table.addr_hid_table = image_offset;
+ hid_table_addr = image_offset;
+ ts->fw_info_table.addr_hid_desc = hid_table_addr;
+ ts->fw_info_table.addr_hid_rd_desc =
+ hid_table_addr + report_desc_offset;
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+/**
+ * himax_mcu_bin_desc_get() - Check and get the bin description from the data
+ * @fw: Firmware data
+ * @ts: Himax touch screen data
+ * @max_sz: Maximum size to check
+ *
+ * This function is used to check and get the bin description from the firmware data.
+ * It will check the given data to see if it match the bin description format, and
+ * call himax_bin_desc_data_get() to get the related data.
+ *
+ * Return: true on mapping_count > 0, false on otherwise
+ */
+static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz)
+{
+ bool keep_on_flag;
+ u32 addr;
+ u32 mapping_count;
+ unsigned char *fw_buf;
+ const u8 header_id = 0x87;
+ const u8 header_id_loc = 0x0e;
+ const u8 header_sz = 8;
+ const u8 header[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+
+ /* Check bin is with description table or not */
+ if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) {
+ dev_err(ts->dev, "%s: No description table\n", __func__);
+ return false;
+ }
+
+ for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) {
+ fw_buf = &fw[addr];
+ /* Get related data */
+ keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf);
+ if (keep_on_flag)
+ mapping_count++;
+ else
+ break;
+ }
+
+ return mapping_count > 0;
+}
+
+/**
+ * himax_hid_parse() - Parse the HID report descriptor
+ * @hid: HID device
+ *
+ * This function is used to parse the HID report descriptor.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_hid_parse(struct hid_device *hid)
+{
+ int ret;
+ struct himax_ts_data *ts;
+
+ if (!hid)
+ return -ENODEV;
+
+ ts = hid->driver_data;
+ if (!ts)
+ return -EINVAL;
+
+ ret = hid_parse_report(hid, ts->hid_rd_data.rd_data, ts->hid_rd_data.rd_length);
+ if (ret) {
+ dev_err(ts->dev, "%s: failed parse report\n", __func__);
+ return ret;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_hid_start - Start the HID device
+ * @hid: HID device
+ *
+ * The function for hid_ll_driver.start to start the HID device.
+ * This driver does not need to do anything here.
+ *
+ * Return: 0 for success
+ */
+static int himax_hid_start(struct hid_device *hid)
+{
+ return 0;
+}
+
+/**
+ * himax_hid_stop - Stop the HID device
+ * @hid: HID device
+ *
+ * The function for hid_ll_driver.stop to stop the HID device.
+ * This driver does not need to do anything here.
+ *
+ * Return: None
+ */
+static void himax_hid_stop(struct hid_device *hid)
+{
+}
+
+/**
+ * himax_hid_open - Open the HID device
+ * @hid: HID device
+ *
+ * The function for hid_ll_driver.open to open the HID device.
+ * This driver does not need to do anything here.
+ *
+ * Return: 0 for success
+ */
+static int himax_hid_open(struct hid_device *hid)
+{
+ return 0;
+}
+
+/**
+ * himax_hid_close - Close the HID device
+ * @hid: HID device
+ *
+ * The function for hid_ll_driver.close to close the HID device.
+ * This driver does not need to do anything here.
+ *
+ * Return: None
+ */
+static void himax_hid_close(struct hid_device *hid)
+{
+}
+
+/**
+ * himax_hid_get_raw_report - Process hidraw GET REPORT operation
+ * @hid: HID device
+ * @reportnum: Report ID
+ * @buf: Buffer for communication
+ * @len: Length of data in the buffer
+ * @report_type: Report type
+ *
+ * The function for hid_ll_driver.get_raw_report to handle the HIDRAW ioctl
+ * get report request. The report number to handle is based on the report
+ * descriptor of the HID device. The buf is used to communicate with user
+ * program, user pass the ID and parameters to the driver use this buf, and
+ * the driver will return the result to user also use this buf. The len is
+ * the length of data in the buf, passed by user program. The report_type is
+ * not used in this driver. We currently support the following report number:
+ * - HIMAX_ID_CONTACT_COUNT: Report the maximum number of touch points
+ * Case not listed here will return -EINVAL.
+ *
+ * Return: The length of the data in the buf on success, negative error code
+ */
+static int himax_hid_get_raw_report(const struct hid_device *hid,
+ unsigned char reportnum, __u8 *buf,
+ size_t len, unsigned char report_type)
+{
+ int ret;
+ struct himax_ts_data *ts;
+
+ ts = hid->driver_data;
+ if (!ts) {
+ dev_err(ts->dev, "hid->driver_data is NULL");
+ return -EINVAL;
+ }
+
+ switch (reportnum) {
+ case HIMAX_ID_CONTACT_COUNT:
+ /* buf[0] is ID; buf[1] and later used as parameters for ID */
+ buf[0] = HIMAX_ID_CONTACT_COUNT;
+ buf[1] = ts->ic_data.max_point;
+ ret = len;
+ break;
+ default:
+ dev_err(ts->dev, "%s: Invalid report number\n", __func__);
+ ret = -EINVAL;
+ break;
+ };
+
+ return ret;
+}
+
+/**
+ * himax_raw_request - Handle the HIDRAW ioctl request
+ * @hid: HID device
+ * @reportnum: Report ID
+ * @buf: Buffer for communication
+ * @len: Length of data in the buffer
+ * @rtype: Report type
+ * @reqtype: Request type
+ *
+ * The function for hid_ll_driver.raw_request to handle the HIDRAW ioctl
+ * request. We handle only the GET_REPORT and SET_REPORT request.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_raw_request(struct hid_device *hid, unsigned char reportnum, __u8 *buf,
+ size_t len, unsigned char rtype, int reqtype)
+{
+ int ret;
+
+ switch (reqtype) {
+ case HID_REQ_GET_REPORT:
+ ret = himax_hid_get_raw_report(hid, reportnum, buf, len, rtype);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static struct hid_ll_driver himax_hid_ll_driver = {
+ .parse = himax_hid_parse,
+ .start = himax_hid_start,
+ .stop = himax_hid_stop,
+ .open = himax_hid_open,
+ .close = himax_hid_close,
+ .raw_request = himax_raw_request
+};
+
+/**
+ * himax_hid_report() - Report input data to HID core
+ * @ts: Himax touch screen data
+ * @data: Data to report
+ * @len: Length of the data
+ *
+ * This function is a wrapper to report input data to HID core.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_hid_report(const struct himax_ts_data *ts, u8 *data, s32 len)
+{
+ return hid_input_report(ts->hid, HID_INPUT_REPORT, data, len, 1);
+}
+
+/**
+ * himax_hid_probe() - Probe the HID device
+ * @ts: Himax touch screen data
+ *
+ * This function is used to probe the HID device.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_hid_probe(struct himax_ts_data *ts)
+{
+ int ret;
+ struct hid_device *hid;
+
+ hid = ts->hid;
+ if (hid) {
+ dev_warn(ts->dev, "%s: hid device already exist!\n", __func__);
+ hid_destroy_device(hid);
+ hid = NULL;
+ }
+
+ hid = hid_allocate_device();
+ if (IS_ERR(hid)) {
+ ret = PTR_ERR(hid);
+ return ret;
+ }
+
+ hid->driver_data = ts;
+ hid->ll_driver = &himax_hid_ll_driver;
+ hid->bus = BUS_SPI;
+ hid->dev.parent = &ts->spi->dev;
+
+ hid->version = ts->hid_desc.bcd_version;
+ hid->vendor = ts->hid_desc.vendor_id;
+ hid->product = ts->hid_desc.product_id;
+ snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-hxtp",
+ hid->vendor, hid->product);
+
+ ret = hid_add_device(hid);
+ if (ret) {
+ dev_err(ts->dev, "%s: failed add hid device\n", __func__);
+ goto err_hid_data;
+ }
+ ts->hid = hid;
+
+ return 0;
+
+err_hid_data:
+ hid_destroy_device(hid);
+
+ return ret;
+}
+
+/**
+ * himax_hid_remove() - Remove the HID device
+ * @ts: Himax touch screen data
+ *
+ * This function is used to remove the HID device.
+ *
+ * Return: None
+ */
+static void himax_hid_remove(struct himax_ts_data *ts)
+{
+ if (ts && ts->hid)
+ hid_destroy_device(ts->hid);
+ else
+ return;
+
+ ts->hid = NULL;
+}
+
+/**
+ * himax_ts_operation() - Process the touch interrupt data
+ * @ts: Himax touch screen data
+ *
+ * This function is used to process the touch interrupt data. It will
+ * call the himax_touch_get() to get the touch data.
+ * If the hid is probed, it will call the himax_hid_report() to report the
+ * touch data to the HID core. Due to the report data must match the HID
+ * report descriptor, the size of report data is fixed. To prevent next report
+ * data being contaminated by the previous data, all the data must be reported
+ * wheather previous data is valid or not.
+ *
+ * Return: HIMAX_TS_SUCCESS on success, negative error code in
+ * himax_touch_report_status on failure
+ */
+static int himax_ts_operation(struct himax_ts_data *ts)
+{
+ int ret;
+ u32 offset;
+
+ memset(ts->xfer_buf, 0x00, ts->xfer_buf_sz);
+ ret = himax_touch_get(ts, ts->xfer_buf);
+ if (ret == HIMAX_TS_GET_DATA_FAIL)
+ return ret;
+ if (ts->hid_probed) {
+ offset = ts->hid_desc.max_input_length;
+ if (ts->ic_data.stylus_function) {
+ ret += himax_hid_report(ts,
+ ts->xfer_buf + offset + HIMAX_HID_REPORT_HDR_SZ,
+ ts->hid_desc.max_input_length -
+ HIMAX_HID_REPORT_HDR_SZ);
+ offset += ts->hid_desc.max_input_length;
+ }
+ }
+
+ if (ret != 0)
+ return HIMAX_TS_GET_DATA_FAIL;
+
+ return HIMAX_TS_SUCCESS;
+}
+
+/**
+ * himax_ts_work() - Work function for the touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to handle interrupt bottom half work. It will
+ * call the himax_ts_operation() to get the touch data, dispatch the data
+ * to HID core. If the touch data is not valid, it will reset the TPIC.
+ *
+ * Return: void
+ */
+static void himax_ts_work(struct himax_ts_data *ts)
+{
+ if (himax_ts_operation(ts) == HIMAX_TS_GET_DATA_FAIL) {
+ dev_info(ts->dev, "%s: Now reset the Touch chip\n", __func__);
+ himax_mcu_ic_reset(ts, true);
+ }
+}
+
+/**
+ * himax_hid_rd_init() - Initialize the HID report descriptor
+ * @ts: Himax touch screen data
+ *
+ * The function is used to calculate the size of the HID report descriptor,
+ * allocate the memory and copy the report descriptor from firmware data to
+ * the allocated memory for later hid device registration.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_hid_rd_init(struct himax_ts_data *ts)
+{
+ u32 rd_sz;
+
+ /* The rd_sz is taken from RD size in FW hid report table. */
+ rd_sz = ts->hid_desc.report_desc_length;
+ /* fw_info_table should contain address of hid_rd_desc in FW image */
+ if (ts->fw_info_table.addr_hid_rd_desc != 0) {
+ /* if rd_sz has been change, need to release old one */
+ if (ts->hid_rd_data.rd_data &&
+ rd_sz != ts->hid_rd_data.rd_length) {
+ devm_kfree(ts->dev, ts->hid_rd_data.rd_data);
+ ts->hid_rd_data.rd_data = NULL;
+ }
+
+ if (!ts->hid_rd_data.rd_data) {
+ ts->hid_rd_data.rd_data = devm_kzalloc(ts->dev, rd_sz, GFP_KERNEL);
+ if (!ts->hid_rd_data.rd_data)
+ return -ENOMEM;
+ }
+ /* Copy the base RD from firmware table */
+ memcpy((void *)ts->hid_rd_data.rd_data,
+ &ts->himax_fw_data[ts->fw_info_table.addr_hid_rd_desc],
+ ts->hid_desc.report_desc_length);
+ ts->hid_rd_data.rd_length = ts->hid_desc.report_desc_length;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_hid_register() - Register the HID device
+ * @ts: Himax touch screen data
+ *
+ * The function is used to register the HID device. If the hid is probed,
+ * it will destroy the previous hid device and re-probe the hid device.
+ *
+ * Return: None
+ */
+static void himax_hid_register(struct himax_ts_data *ts)
+{
+ if (ts->hid_probed) {
+ hid_destroy_device(ts->hid);
+ ts->hid = NULL;
+ ts->hid_probed = false;
+ }
+
+ if (himax_hid_probe(ts)) {
+ dev_err(ts->dev, "%s: hid probe fail\n", __func__);
+ ts->hid_probed = false;
+ } else {
+ ts->hid_probed = true;
+ }
+}
+
+/**
+ * himax_hid_report_data_init() - Calculate the size of the HID report data
+ * @ts: Himax touch screen data
+ *
+ * The function is used to calculate the final size of the HID report data.
+ * The base size is equal to the max_input_length of the hid descriptor.
+ * If the size of the HID report data is not equal to the previous size, it
+ * will free the previous allocated memory and allocate the new memory which
+ * size is equal to the final size of touch_data_sz.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_hid_report_data_init(struct himax_ts_data *ts)
+{
+ ts->touch_data_sz = ts->hid_desc.max_input_length;
+ if (ts->ic_data.stylus_function)
+ ts->touch_data_sz += ts->hid_desc.max_input_length;
+ if (ts->touch_data_sz != ts->xfer_buf_sz) {
+ kfree(ts->xfer_buf);
+ ts->xfer_buf_sz = 0;
+ ts->xfer_buf = kzalloc(ts->touch_data_sz, GFP_KERNEL);
+ if (!ts->xfer_buf)
+ return -ENOMEM;
+ ts->xfer_buf_sz = ts->touch_data_sz;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_power_set() - Set the power supply of touch screen
+ * @ts: Himax touch screen data
+ * @en: enable/disable regualtor
+ *
+ * This function is used to set the power supply of touch screen.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_power_set(struct himax_ts_data *ts, bool en)
+{
+ int ret;
+ struct himax_platform_data *pdata = &ts->pdata;
+
+ if (pdata->vccd_supply) {
+ if (en)
+ ret = regulator_enable(pdata->vccd_supply);
+ else
+ ret = regulator_disable(pdata->vccd_supply);
+ if (ret) {
+ dev_err(ts->dev, "%s: unable to %s vccd supply\n", __func__,
+ en ? "enable" : "disable");
+ return ret;
+ }
+ }
+
+ if (pdata->vccd_supply)
+ usleep_range(2000, 2100);
+
+ return 0;
+}
+
+/**
+ * himax_power_deconfig() - De-configure the power supply of touchsreen
+ * @pdata: Himax platform data
+ *
+ * This function is used to de-configure the power supply of touch screen.
+ *
+ * Return: None
+ */
+static void himax_power_deconfig(struct himax_platform_data *pdata)
+{
+ if (pdata->vccd_supply) {
+ regulator_disable(pdata->vccd_supply);
+ regulator_put(pdata->vccd_supply);
+ }
+}
+
+/* load firmware data from flash, parse HID info and register HID */
+/**
+ * himax_load_config() - Load the firmware from the flash
+ * @ts: Himax touch screen data
+ *
+ * This function is used to load the firmware from the flash. It will read
+ * the firmware from the flash and parse the HID info. If the HID info is
+ * valid, it will initialize the HID report descriptor and register the HID
+ * device. If the HID device is probed, it will initialize the report data
+ * and enable the interrupt.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_load_config(struct himax_ts_data *ts)
+{
+ int ret;
+ s32 i;
+ s32 page_sz = (s32)HIMAX_HX83102J_PAGE_SIZE;
+ s32 flash_sz = (s32)HIMAX_HX83102J_FLASH_SIZE;
+ bool fw_load_status = false;
+ const u32 fw_bin_header_sz = 1024;
+
+ ts->ic_boot_done = false;
+
+ ts->himax_fw_data = devm_kzalloc(ts->dev, HIMAX_HX83102J_FLASH_SIZE, GFP_KERNEL);
+ if (!ts->himax_fw_data)
+ return -ENOMEM;
+
+ for (i = 0; i < flash_sz; i += page_sz) {
+ ret = himax_mcu_register_read(ts, i, ts->himax_fw_data + i,
+ (flash_sz - i) > page_sz ? page_sz : (flash_sz - i));
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read FW from flash fail!\n", __func__);
+ return ret;
+ }
+ }
+ /* Search mapping table in 1k header */
+ fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw_data,
+ ts, fw_bin_header_sz);
+ if (!fw_load_status) {
+ dev_err(ts->dev, "%s: FW load status fail!\n", __func__);
+ return -EINVAL;
+ }
+
+ if (ts->fw_info_table.addr_hid_desc != 0) {
+ memcpy(&ts->hid_desc,
+ &ts->himax_fw_data[ts->fw_info_table.addr_hid_desc],
+ sizeof(struct himax_hid_desc));
+ ts->hid_desc.desc_length =
+ le16_to_cpu(ts->hid_desc.desc_length);
+ ts->hid_desc.bcd_version =
+ le16_to_cpu(ts->hid_desc.bcd_version);
+ ts->hid_desc.report_desc_length =
+ le16_to_cpu(ts->hid_desc.report_desc_length);
+ ts->hid_desc.max_input_length =
+ le16_to_cpu(ts->hid_desc.max_input_length);
+ ts->hid_desc.max_output_length =
+ le16_to_cpu(ts->hid_desc.max_output_length);
+ ts->hid_desc.max_fragment_length =
+ le16_to_cpu(ts->hid_desc.max_fragment_length);
+ ts->hid_desc.vendor_id =
+ le16_to_cpu(ts->hid_desc.vendor_id);
+ ts->hid_desc.product_id =
+ le16_to_cpu(ts->hid_desc.product_id);
+ ts->hid_desc.version_id =
+ le16_to_cpu(ts->hid_desc.version_id);
+ ts->hid_desc.flags =
+ le16_to_cpu(ts->hid_desc.flags);
+ }
+
+ if (himax_hid_rd_init(ts)) {
+ dev_err(ts->dev, "%s: hid rd init fail\n", __func__);
+ goto err_hid_rd_init_failed;
+ }
+
+ himax_hid_register(ts);
+ if (!ts->hid_probed) {
+ goto err_hid_probe_failed;
+ } else {
+ if (himax_hid_report_data_init(ts)) {
+ dev_err(ts->dev, "%s: report data init fail\n", __func__);
+ goto err_report_data_init_failed;
+ }
+ }
+
+ ts->himax_fw_data = NULL;
+ ts->ic_boot_done = true;
+ himax_int_enable(ts, true);
+
+ return 0;
+
+err_report_data_init_failed:
+ himax_hid_remove(ts);
+ ts->hid_probed = false;
+err_hid_probe_failed:
+err_hid_rd_init_failed:
+
+ return -EINVAL;
+}
+
+/**
+ * himax_chip_init() - Initialize the Himax touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to initialize the Himax touch screen. It will
+ * initialize interrupt lock, register the interrupt, and disable the
+ * interrupt. If later part of initialization succeed, then interrupt will
+ * be enabled.
+ * It will also load the firmware from the flash, parse the HID info, and
+ * register the HID device by calling the himax_load_config().
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_chip_init(struct himax_ts_data *ts)
+{
+ int ret;
+
+ if (himax_ts_register_interrupt(ts)) {
+ dev_err(ts->dev, "%s: register interrupt failed\n", __func__);
+ return -EIO;
+ }
+ himax_int_enable(ts, false);
+ ret = himax_load_config(ts);
+ if (ret < 0)
+ return ret;
+ ts->initialized = true;
+
+ return 0;
+}
+
+/**
+ * himax_platform_deinit() - Deinitialize the platform related settings
+ * @ts: Pointer to the himax_ts_data structure
+ *
+ * This function deinitializes the platform related settings, frees the
+ * xfer_buf.
+ *
+ * Return: None
+ */
+static void himax_platform_deinit(struct himax_ts_data *ts)
+{
+ struct himax_platform_data *pdata = &ts->pdata;
+
+ if (ts->xfer_buf_sz) {
+ kfree(ts->xfer_buf);
+ ts->xfer_buf = NULL;
+ ts->xfer_buf_sz = 0;
+ }
+ himax_power_deconfig(pdata);
+}
+
+/**
+ * himax_platform_init - Initialize the platform related settings
+ * @ts: Pointer to the himax_ts_data structure
+ *
+ * This function initializes the platform related settings.
+ * The xfer_buf is used for interrupt data receive. gpio reset pin is set to
+ * active and then deactivate to reset the IC.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_platform_init(struct himax_ts_data *ts)
+{
+ int ret;
+ struct himax_platform_data *pdata = &ts->pdata;
+
+ ts->xfer_buf_sz = 0;
+ ts->xfer_buf = kzalloc(HIMAX_HX83102J_FULL_STACK_SZ, GFP_KERNEL);
+ if (!ts->xfer_buf)
+ return -ENOMEM;
+ ts->xfer_buf_sz = HIMAX_HX83102J_FULL_STACK_SZ;
+
+ gpiod_set_value(pdata->gpiod_rst, 1);
+ ret = himax_power_set(ts, true);
+ if (ret) {
+ dev_err(ts->dev, "%s: gpio power config failed\n", __func__);
+ return ret;
+ }
+
+ usleep_range(2000, 2100);
+ gpiod_set_value(pdata->gpiod_rst, 0);
+
+ return 0;
+}
+
+/**
+ * himax_spi_drv_probe - Probe function for the SPI driver
+ * @spi: Pointer to the spi_device structure
+ *
+ * This function is called when the SPI driver is probed. It initializes the
+ * himax_ts_data structure and assign the settings from spi device to
+ * himax_ts_data. The buffer for SPI transfer is allocate here. The SPI
+ * transfer settings also setup before any communication starts.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_spi_drv_probe(struct spi_device *spi)
+{
+ int ret;
+ struct himax_ts_data *ts;
+ static struct himax_platform_data *pdata;
+
+ dev_info(&spi->dev, "%s: Himax SPI driver probe\n", __func__);
+ ts = devm_kzalloc(&spi->dev, sizeof(struct himax_ts_data), GFP_KERNEL);
+ if (!ts)
+ return -ENOMEM;
+ if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) {
+ dev_err(ts->dev, "%s: Full duplex not supported by host\n", __func__);
+ return -EIO;
+ }
+ pdata = &ts->pdata;
+ ts->dev = &spi->dev;
+ if (!spi->irq) {
+ dev_err(ts->dev, "%s: no IRQ?\n", __func__);
+ return -EINVAL;
+ }
+ ts->himax_irq = spi->irq;
+ pdata->gpiod_rst = devm_gpiod_get(ts->dev, "reset", GPIOD_OUT_HIGH);
+ if (IS_ERR(pdata->gpiod_rst)) {
+ dev_err(ts->dev, "%s: gpio-rst value is not valid\n", __func__);
+ return -EIO;
+ }
+
+ spi->bits_per_word = 8;
+ spi->mode = SPI_MODE_3;
+ spi->cs_setup.value = HIMAX_SPI_CS_SETUP_TIME;
+
+ ts->spi = spi;
+ /*
+ * The max_transfer_size is used to allocate the buffer for SPI transfer.
+ * The size should be given by the SPI master driver, but if not available
+ * then use the HIMAX_MAX_TP_EV_STACK_SZ as default. Which is the least size for
+ * each TP event data.
+ */
+ if (spi->master->max_transfer_size)
+ ts->spi_xfer_max_sz = spi->master->max_transfer_size(spi);
+ else
+ ts->spi_xfer_max_sz = HIMAX_MAX_TP_EV_STACK_SZ;
+
+ ts->spi_xfer_max_sz = min(ts->spi_xfer_max_sz, HIMAX_BUS_RW_MAX_LEN);
+ /* SPI full-duplex rx_buf and tx_buf should be equal */
+ ts->xfer_rx_data = devm_kzalloc(ts->dev, ts->spi_xfer_max_sz, GFP_KERNEL);
+ if (!ts->xfer_rx_data)
+ return -ENOMEM;
+
+ ts->xfer_tx_data = devm_kzalloc(ts->dev, ts->spi_xfer_max_sz, GFP_KERNEL);
+ if (!ts->xfer_tx_data)
+ return -ENOMEM;
+
+ spin_lock_init(&ts->irq_lock);
+ mutex_init(&ts->rw_lock);
+ mutex_init(&ts->reg_lock);
+ dev_set_drvdata(&spi->dev, ts);
+ spi_set_drvdata(spi, ts);
+
+ ts->probe_finish = false;
+ ts->initialized = false;
+ ts->ic_boot_done = false;
+
+ ret = himax_platform_init(ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: platform init failed\n", __func__);
+ return ret;
+ }
+
+ ret = hx83102j_chip_detect(ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: IC detect failed\n", __func__);
+ return ret;
+ }
+
+ ret = himax_chip_init(ts);
+ if (ret < 0)
+ return ret;
+ ts->probe_finish = true;
+
+ return ret;
+ himax_platform_deinit(ts);
+}
+
+/**
+ * himax_spi_drv_remove - Remove function for the SPI driver
+ * @spi: Pointer to the spi_device structure
+ *
+ * This function is called when the SPI driver is removed. It deinitializes the
+ * himax_ts_data structure and free the resources allocated for the SPI
+ * communication.
+ */
+static void himax_spi_drv_remove(struct spi_device *spi)
+{
+ struct himax_ts_data *ts = spi_get_drvdata(spi);
+
+ if (ts->probe_finish) {
+ if (ts->ic_boot_done) {
+ himax_int_enable(ts, false);
+
+ if (ts->hid_probed)
+ himax_hid_remove(ts);
+ }
+ himax_platform_deinit(ts);
+ }
+}
+
+/**
+ * himax_shutdown - Shutdown the touch screen
+ * @spi: Himax touch screen spi device
+ *
+ * This function is used to shutdown the touch screen. It will disable the
+ * interrupt, set the reset pin to activate state. Then remove the hid device.
+ *
+ * Return: None
+ */
+static void himax_shutdown(struct spi_device *spi)
+{
+ struct himax_ts_data *ts = spi_get_drvdata(spi);
+
+ if (!ts->initialized) {
+ dev_err(ts->dev, "%s: init not ready, skip!\n", __func__);
+ return;
+ }
+
+ himax_int_enable(ts, false);
+ gpiod_set_value(ts->pdata.gpiod_rst, 1);
+ himax_power_deconfig(&ts->pdata);
+ himax_hid_remove(ts);
+}
+
+#if defined(CONFIG_OF)
+static const struct of_device_id himax_table[] = {
+ { .compatible = "himax,hx83102j" },
+ {},
+};
+MODULE_DEVICE_TABLE(of, himax_table);
+#endif
+
+static struct spi_driver himax_hid_over_spi_driver = {
+ .driver = {
+ .name = "hx83102j",
+ .owner = THIS_MODULE,
+#if defined(CONFIG_OF)
+ .of_match_table = of_match_ptr(himax_table),
+#endif
+ },
+ .probe = himax_spi_drv_probe,
+ .remove = himax_spi_drv_remove,
+ .shutdown = himax_shutdown,
+};
+
+static int __init himax_ic_init(void)
+{
+ return spi_register_driver(&himax_hid_over_spi_driver);
+}
+
+static void __exit himax_ic_exit(void)
+{
+ spi_unregister_driver(&himax_hid_over_spi_driver);
+}
+
+module_init(himax_ic_init);
+module_exit(himax_ic_exit);
+
+MODULE_VERSION("1.3.4");
+MODULE_DESCRIPTION("Himax HX83102J SPI driver for HID");
+MODULE_AUTHOR("Himax, Inc.");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h
new file mode 100644
index 000000000000..26b47be49714
--- /dev/null
+++ b/drivers/hid/hid-himax.h
@@ -0,0 +1,288 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Himax hx83102j SPI Driver Code for HID.
+ *
+ * Copyright (C) 2024 Himax Corporation.
+ */
+
+#ifndef __HID_HIMAX_83102J_H__
+#define __HID_HIMAX_83102J_H__
+
+#include <linux/delay.h>
+#include <linux/hid.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/regulator/consumer.h>
+#include <linux/spi/spi.h>
+
+/* Constants */
+#define HIMAX_BUS_RETRY 3
+/* SPI bus read header length */
+#define HIMAX_BUS_R_HLEN 3U
+/* SPI bus write header length */
+#define HIMAX_BUS_W_HLEN 2U
+/* TP SRAM address size and data size */
+#define HIMAX_REG_SZ 4U
+/* TP MAX TX/RX number */
+#define HIMAX_MAX_RX 144U
+#define HIMAX_MAX_TX 48U
+/* TP FW main code size */
+#define HIMAX_FW_MAIN_CODE_SZ 0x20000U
+/* TP max event data size */
+#define HIMAX_MAX_TP_EVENT_SZ 128U
+/* TP max interrupt data size : event size + raw data size(rx * tx 16bits) */
+#define HIMAX_MAX_TP_EV_STACK_SZ (HIMAX_BUS_R_HLEN + \
+ HIMAX_MAX_TP_EVENT_SZ + \
+ (HIMAX_MAX_RX * HIMAX_MAX_TX) * 2)
+/* SPI Max read/write size for max possible usage, write FW main code */
+#define HIMAX_BUS_RW_MAX_LEN (HIMAX_FW_MAIN_CODE_SZ + \
+ HIMAX_BUS_W_HLEN + HIMAX_REG_SZ)
+/* SPI CS setup time */
+#define HIMAX_SPI_CS_SETUP_TIME 300
+/* HIDRAW report header size */
+#define HIMAX_HID_REPORT_HDR_SZ 2U
+/* hx83102j IC parameters */
+#define HIMAX_HX83102J_DSRAM_SZ 73728U
+#define HIMAX_HX83102J_FLASH_SIZE 261120U
+#define HIMAX_HX83102J_MAX_RX_NUM 50U
+#define HIMAX_HX83102J_MAX_TX_NUM 32U
+#define HIMAX_HX83102J_PAGE_SIZE 128U
+#define HIMAX_HX83102J_SAFE_MODE_PASSWORD 0x9527
+#define HIMAX_HX83102J_STACK_SIZE 128U
+#define HIMAX_HX83102J_FULL_STACK_SZ \
+ (HIMAX_HX83102J_STACK_SIZE + \
+ (2 + HIMAX_HX83102J_MAX_RX_NUM * HIMAX_HX83102J_MAX_TX_NUM + \
+ HIMAX_HX83102J_MAX_TX_NUM + HIMAX_HX83102J_MAX_RX_NUM) * 2)
+#define HIMAX_HX83102J_REG_XFER_MAX 4096U
+/* AHB register addresses */
+#define HIMAX_AHB_ADDR_BYTE_0 0x00
+#define HIMAX_AHB_ADDR_RDATA_BYTE_0 0x08
+#define HIMAX_AHB_ADDR_ACCESS_DIRECTION 0x0c
+#define HIMAX_AHB_ADDR_INCR4 0x0d
+#define HIMAX_AHB_ADDR_CONTI 0x13
+#define HIMAX_AHB_ADDR_EVENT_STACK 0x30
+#define HIMAX_AHB_ADDR_PSW_LB 0x31
+/* AHB register values/commands */
+#define HIMAX_AHB_CMD_ACCESS_DIRECTION_READ 0x00
+#define HIMAX_AHB_CMD_CONTI 0x31
+#define HIMAX_AHB_CMD_INCR4 0x10
+#define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01
+#define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000
+/* hx83102j-specific register/dsram flags/data */
+#define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004
+/* hardware register addresses */
+#define HIMAX_REG_ADDR_SPI200_DATA 0x8000002c
+#define HIMAX_REG_ADDR_CTRL_FW 0x9000005c
+#define HIMAX_REG_ADDR_FW_STATUS 0x900000a8
+#define HIMAX_REG_ADDR_ICID 0x900000d0
+/* hardware reg data/flags */
+#define HIMAX_REG_DATA_FW_STATE_RUNNING 0x05
+#define HIMAX_REG_DATA_FW_STATE_SAFE_MODE 0x0c
+#define HIMAX_REG_DATA_FW_RE_INIT 0x00
+#define HIMAX_REG_DATA_FW_GO_SAFEMODE 0xa5
+#define HIMAX_REG_DATA_FW_IN_SAFEMODE 0x87
+#define HIMAX_REG_DATA_ICID 0x83102900
+#define HIMAX_REG_DATA_TCON_RST 0x00000000
+/* HIMAX SPI function select, 1st byte of any SPI command sequence */
+#define HIMAX_SPI_FUNCTION_READ 0xf3
+#define HIMAX_SPI_FUNCTION_WRITE 0xf2
+/* Map code of FW 1k header */
+#define HIMAX_TP_CONFIG_TABLE 0x00000a00
+#define HIMAX_FW_CID 0x10000000
+#define HIMAX_FW_VER 0x10000100
+#define HIMAX_CFG_VER 0x10000600
+#define HIMAX_HID_TABLE 0x30000100
+#define HIMAX_FW_BIN_DESC 0x10000000
+
+/**
+ * enum himax_hidraw_id_function - HIDRAW report IDs
+ * @HIMAX_ID_CONTACT_COUNT: Contact count report ID
+ */
+enum himax_hidraw_id_function {
+ HIMAX_ID_CONTACT_COUNT = 0x03,
+};
+
+/**
+ * enum himax_touch_report_status - ts operation return code for touch report
+ * @HIMAX_TS_GET_DATA_FAIL: Get touch data fail
+ * @HIMAX_TS_SUCCESS: Get touch data success
+ */
+enum himax_touch_report_status {
+ HIMAX_TS_GET_DATA_FAIL = -4,
+ HIMAX_TS_SUCCESS = 0,
+};
+
+/**
+ * struct himax_fw_address_table - address/offset in firmware image
+ * @addr_fw_ver_major: Address to Major version of firmware
+ * @addr_fw_ver_minor: Address to Minor version of firmware
+ * @addr_cfg_ver_major: Address to Major version of config
+ * @addr_cfg_ver_minor: Address to Minor version of config
+ * @addr_cid_ver_major: Address to Major version of Customer ID
+ * @addr_cid_ver_minor: Address to Minor version of Customer ID
+ * @addr_cfg_table: Address to Configuration table
+ * @addr_hid_table: Address to HID tables start offset
+ * @addr_hid_desc: Address to HID descriptor table
+ * @addr_hid_rd_desc: Address to HID report descriptor table
+ */
+struct himax_fw_address_table {
+ u32 addr_fw_ver_major;
+ u32 addr_fw_ver_minor;
+ u32 addr_cfg_ver_major;
+ u32 addr_cfg_ver_minor;
+ u32 addr_cid_ver_major;
+ u32 addr_cid_ver_minor;
+ u32 addr_cfg_table;
+ u32 addr_hid_table;
+ u32 addr_hid_desc;
+ u32 addr_hid_rd_desc;
+};
+
+/**
+ * struct himax_hid_rd_data - HID report descriptor data
+ * @rd_data: Point to report description data
+ * @rd_length: Length of report description data
+ */
+struct himax_hid_rd_data {
+ u8 *rd_data;
+ u32 rd_length;
+};
+
+/**
+ * union himax_dword_data - 4 bytes data union
+ * @dword: 1 dword data
+ * @word: 2 words data in word array
+ * @byte: 4 bytes data in byte array
+ */
+union himax_dword_data {
+ u32 dword;
+ u16 word[2];
+ u8 byte[4];
+};
+
+/**
+ * struct himax_ic_data - IC information holder
+ * @stylus_ratio: Stylus ratio
+ * @rx_num: Number of RX
+ * @tx_num: Number of TX
+ * @button_num: Number of buttons
+ * @max_point: Maximum touch point
+ * @icid: IC ID
+ * @interrupt_is_edge: Interrupt is edge otherwise level
+ * @stylus_function: Stylus function available or not
+ * @stylus_v2: Is stylus version 2
+ */
+struct himax_ic_data {
+ u8 stylus_ratio;
+ u32 rx_num;
+ u32 tx_num;
+ u32 button_num;
+ u32 max_point;
+ u32 icid;
+ bool interrupt_is_edge;
+ bool stylus_function;
+ bool stylus_v2;
+};
+
+/**
+ * struct himax_hid_desc - HID descriptor
+ * @desc_length: Length of HID descriptor
+ * @bcd_version: BCD version
+ * @report_desc_length: Length of report descriptor
+ * @max_input_length: Maximum input length
+ * @max_output_length: Maximum output length
+ * @max_fragment_length: Maximum fragment length
+ * @vendor_id: Vendor ID
+ * @product_id: Product ID
+ * @version_id: Version ID
+ * @flags: Flags
+ * @reserved: Reserved
+ *
+ * This structure is used to hold the HID descriptor.
+ * It directly maps to a sequence of bytes in firmware image,
+ * thus need to be packed.
+ */
+struct himax_hid_desc {
+ u16 desc_length;
+ u16 bcd_version;
+ u16 report_desc_length;
+ u16 max_input_length;
+ u16 max_output_length;
+ u16 max_fragment_length;
+ u16 vendor_id;
+ u16 product_id;
+ u16 version_id;
+ u16 flags;
+ u32 reserved;
+} __packed;
+
+/**
+ * struct himax_platform_data - Platform data holder
+ * @vccd_supply: VCCD supply
+ * @gpiod_rst: GPIO reset
+ *
+ * This structure is used to hold the platform related data.
+ */
+struct himax_platform_data {
+ struct regulator *vccd_supply;
+ struct gpio_desc *gpiod_rst;
+};
+
+/**
+ * struct himax_ts_data - Touchscreen data holder
+ * @xfer_buf: Interrupt data buffer
+ * @xfer_rx_data: SPI Transfer receive data buffer
+ * @xfer_tx_data: SPI Transfer transmit data buffer
+ * @himax_fw_data: Firmware data holder from flash
+ * @himax_irq: IRQ number
+ * @spi_xfer_max_sz: Size of SPI controller max transfer size
+ * @xfer_buf_sz: Size of interrupt data buffer
+ * @irq_state: IRQ state
+ * @irq_lock: Spin lock for irq
+ * @initialized: Indicate the driver is initialized
+ * @probe_finish: Indicate the driver probe is finished
+ * @ic_boot_done: Indicate the IC boot is done
+ * @hid_probed: Indicate the HID device is probed
+ * @touch_data_sz: Size of each interrupt data from IC
+ * @dev: Device pointer
+ * @spi: SPI device pointer
+ * @hid: HID device pointer
+ * @reg_lock: Mutex lock for reg access
+ * @rw_lock: Mutex lock for read/write action
+ * @ic_data: IC information holder
+ * @pdata: Platform data holder
+ * @fw_info_table: Firmware information address table of firmware image
+ * @hid_desc: HID descriptor
+ * @hid_rd_data: HID report descriptor data
+ */
+struct himax_ts_data {
+ u8 *xfer_buf;
+ u8 *xfer_rx_data;
+ u8 *xfer_tx_data;
+ u8 *himax_fw_data;
+ s32 himax_irq;
+ u32 spi_xfer_max_sz;
+ u32 xfer_buf_sz;
+ atomic_t irq_state;
+ /* lock for irq_save */
+ spinlock_t irq_lock;
+ bool initialized;
+ bool probe_finish;
+ bool ic_boot_done;
+ bool hid_probed;
+ int touch_data_sz;
+ struct device *dev;
+ struct spi_device *spi;
+ struct hid_device *hid;
+ /* lock for register operation */
+ struct mutex reg_lock;
+ /* lock for bus read/write action */
+ struct mutex rw_lock;
+ struct himax_ic_data ic_data;
+ struct himax_platform_data pdata;
+ struct himax_fw_address_table fw_info_table;
+ struct himax_hid_desc hid_desc;
+ struct himax_hid_rd_data hid_rd_data;
+};
+#endif
--
2.34.1
^ permalink raw reply related
* [PATCH v4 3/4] HID: Add DRM panel follower function
From: Allen_Lin @ 2024-04-17 7:41 UTC (permalink / raw)
To: dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor, jikos,
benjamin.tissoires, linux-input, devicetree, linux-kernel
Cc: Allen_Lin
In-Reply-To: <20240417074115.1137885-1-allencl_lin@hotmail.com>
Add DRM panel follower[1] to trigger suspend/resume due to TDDI nature,
TP need to follow panel power sequence.
[1]:
https://lore.kernel.org/all/20230727171750.633410-1-dianders@chromium.org
Signed-off-by: Allen_Lin <allencl_lin@hotmail.com>
---
drivers/hid/hid-himax.c | 292 +++++++++++++++++++++++++++++++++++++---
drivers/hid/hid-himax.h | 10 ++
2 files changed, 286 insertions(+), 16 deletions(-)
diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c
index f8a417e07f0c..7b0ee48acfae 100644
--- a/drivers/hid/hid-himax.c
+++ b/drivers/hid/hid-himax.c
@@ -8,6 +8,7 @@
#include "hid-himax.h"
static int himax_chip_init(struct himax_ts_data *ts);
+static int himax_platform_init(struct himax_ts_data *ts);
static void himax_ts_work(struct himax_ts_data *ts);
/**
@@ -1145,7 +1146,6 @@ static int himax_hid_probe(struct himax_ts_data *ts)
hid = ts->hid;
if (hid) {
- dev_warn(ts->dev, "%s: hid device already exist!\n", __func__);
hid_destroy_device(hid);
hid = NULL;
}
@@ -1501,6 +1501,154 @@ static int himax_load_config(struct himax_ts_data *ts)
return -EINVAL;
}
+/**
+ * himax_ap_notify_fw_suspend() - Notify the FW of AP suspend status
+ * @ts: Himax touch screen data
+ * @suspend: Suspend status, true for suspend, false for resume
+ *
+ * This function is used to notify the FW of AP suspend status. It will write
+ * the suspend status to the DSRAM and read the status back to check if the
+ * status is written successfully. If IC is powered off when suspend, this
+ * function will only be used when resume.
+ *
+ * Return: None
+ */
+static void himax_ap_notify_fw_suspend(struct himax_ts_data *ts, bool suspend)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 retry_limit = 10;
+ union himax_dword_data rdata, data;
+
+ if (suspend)
+ data.dword = cpu_to_le32(HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND);
+ else
+ data.dword = cpu_to_le32(HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME);
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND,
+ data.byte, 4);
+ if (ret) {
+ dev_err(ts->dev, "%s: write suspend status failed!\n", __func__);
+ return;
+ }
+ usleep_range(1000, 1100);
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND,
+ rdata.byte, 4);
+ if (ret) {
+ dev_err(ts->dev, "%s: read suspend status failed!\n", __func__);
+ return;
+ }
+
+ if (rdata.dword == data.dword)
+ break;
+ }
+}
+
+/**
+ * himax_resume_proc() - Chip resume procedure of touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to resume the touch screen. It will call the
+ * himax_ap_notify_fw_suspend() to notify the FW of AP resume status.
+ *
+ * Return: None
+ */
+static void himax_resume_proc(struct himax_ts_data *ts)
+{
+ himax_ap_notify_fw_suspend(ts, false);
+}
+
+/**
+ * himax_chip_suspend() - Suspend the touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to suspend the touch screen. It will disable the
+ * interrupt and set the reset pin to activate state. Remove the HID at
+ * the end, to prevent stuck finger when resume.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_chip_suspend(struct himax_ts_data *ts)
+{
+ himax_int_enable(ts, false);
+ gpiod_set_value(ts->pdata.gpiod_rst, 1);
+ himax_power_set(ts, false);
+ himax_hid_remove(ts);
+
+ return 0;
+}
+
+/**
+ * himax_chip_resume() - Setup flags, I/O and resume
+ * @ts: Himax touch screen data
+ *
+ * This function is used to resume the touch screen. It will set the resume
+ * success flag to false, and disable reset pin. Then call the himax_resume_proc()
+ * to process detailed resume procedure.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_chip_resume(struct himax_ts_data *ts)
+{
+ if (himax_power_set(ts, true))
+ return -EIO;
+ gpiod_set_value(ts->pdata.gpiod_rst, 0);
+ himax_resume_proc(ts);
+ himax_hid_probe(ts);
+ himax_int_enable(ts, true);
+
+ return 0;
+}
+
+/**
+ * himax_suspend() - Suspend the touch screen
+ * @dev: Device structure
+ *
+ * Wrapper function for himax_chip_suspend() to be called by the PM or
+ * the DRM panel notifier.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_suspend(struct device *dev)
+{
+ struct himax_ts_data *ts = dev_get_drvdata(dev);
+
+ if (!ts->initialized) {
+ dev_err(ts->dev, "%s: init not ready, skip!\n", __func__);
+ return -ECANCELED;
+ }
+ himax_chip_suspend(ts);
+
+ return 0;
+}
+
+/**
+ * himax_resume() - Resume the touch screen
+ * @dev: Device structure
+ *
+ * Wrapper function for himax_chip_resume() to be called by the PM or
+ * the DRM panel notifier.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_resume(struct device *dev)
+{
+ int ret;
+ struct himax_ts_data *ts = dev_get_drvdata(dev);
+
+ if (!ts->initialized) {
+ if (himax_chip_init(ts))
+ return -ECANCELED;
+ }
+
+ ret = himax_chip_resume(ts);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: resume failed!\n", __func__);
+
+ return ret;
+}
+
/**
* himax_chip_init() - Initialize the Himax touch screen
* @ts: Himax touch screen data
@@ -1531,6 +1679,130 @@ static int himax_chip_init(struct himax_ts_data *ts)
return 0;
}
+/**
+ * __himax_initial_power_up() - Initial power up of the Himax touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to perform the initial power up sequence of the Himax
+ * touch screen for DRM panel notifier.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int __himax_initial_power_up(struct himax_ts_data *ts)
+{
+ int ret;
+
+ ret = himax_platform_init(ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: platform init failed\n", __func__);
+ return ret;
+ }
+
+ ret = hx83102j_chip_detect(ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: IC detect failed\n", __func__);
+ return ret;
+ }
+
+ ret = himax_chip_init(ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: chip init failed\n", __func__);
+ return ret;
+ }
+ ts->probe_finish = true;
+
+ return 0;
+}
+
+/**
+ * himax_panel_prepared() - Panel prepared callback
+ * @follower: DRM panel follower
+ *
+ * This function is called when the panel is prepared. It will call the
+ * __himax_initial_power_up() when the probe is not finished which means
+ * the first time driver start. Otherwise, it will call the himax_resume()
+ * to performed resume process.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_panel_prepared(struct drm_panel_follower *follower)
+{
+ struct himax_platform_data *pdata =
+ container_of(follower, struct himax_platform_data, panel_follower);
+ struct himax_ts_data *ts = container_of(pdata, struct himax_ts_data, pdata);
+
+ if (!ts->probe_finish)
+ return __himax_initial_power_up(ts);
+ else
+ return himax_resume(ts->dev);
+}
+
+/**
+ * himax_panel_unpreparing() - Panel unpreparing callback
+ * @follower: DRM panel follower
+ *
+ * This function is called when the panel is unpreparing. It will call the
+ * himax_suspend() to perform the suspend process.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_panel_unpreparing(struct drm_panel_follower *follower)
+{
+ struct himax_platform_data *pdata =
+ container_of(follower, struct himax_platform_data, panel_follower);
+ struct himax_ts_data *ts = container_of(pdata, struct himax_ts_data, pdata);
+
+ return himax_suspend(ts->dev);
+}
+
+/* Panel follower function table */
+static const struct drm_panel_follower_funcs himax_panel_follower_funcs = {
+ .panel_prepared = himax_panel_prepared,
+ .panel_unpreparing = himax_panel_unpreparing,
+};
+
+/**
+ * himax_register_panel_follower() - Register the panel follower
+ * @ts: Himax touch screen data
+ *
+ * This function is used to register the panel follower. It will set the
+ * pdata.is_panel_follower to true and register the panel follower.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_register_panel_follower(struct himax_ts_data *ts)
+{
+ struct device *dev = ts->dev;
+
+ ts->pdata.is_panel_follower = true;
+ ts->pdata.panel_follower.funcs = &himax_panel_follower_funcs;
+
+ if (device_can_wakeup(dev)) {
+ dev_warn(ts->dev, "Can't wakeup if following panel");
+ device_set_wakeup_capable(dev, false);
+ }
+
+ return drm_panel_add_follower(dev, &ts->pdata.panel_follower);
+}
+
+/**
+ * himax_initial_power_up() - Initial power up of the Himax touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function checks if the device is a panel follower and calls
+ * himax_register_panel_follower() if it is. Otherwise, it calls
+ * __himax_initial_power_up().
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_initial_power_up(struct himax_ts_data *ts)
+{
+ if (drm_is_panel_follower(ts->dev))
+ return himax_register_panel_follower(ts);
+ else
+ return __himax_initial_power_up(ts);
+}
+
/**
* himax_platform_deinit() - Deinitialize the platform related settings
* @ts: Pointer to the himax_ts_data structure
@@ -1660,25 +1932,13 @@ static int himax_spi_drv_probe(struct spi_device *spi)
ts->initialized = false;
ts->ic_boot_done = false;
- ret = himax_platform_init(ts);
- if (ret) {
- dev_err(ts->dev, "%s: platform init failed\n", __func__);
- return ret;
- }
-
- ret = hx83102j_chip_detect(ts);
+ ret = himax_initial_power_up(ts);
if (ret) {
- dev_err(ts->dev, "%s: IC detect failed\n", __func__);
- return ret;
+ dev_err(ts->dev, "%s: initial power up failed\n", __func__);
+ return -ENODEV;
}
- ret = himax_chip_init(ts);
- if (ret < 0)
- return ret;
- ts->probe_finish = true;
-
return ret;
- himax_platform_deinit(ts);
}
/**
diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h
index 26b47be49714..45dc3e6283ae 100644
--- a/drivers/hid/hid-himax.h
+++ b/drivers/hid/hid-himax.h
@@ -8,6 +8,7 @@
#ifndef __HID_HIMAX_83102J_H__
#define __HID_HIMAX_83102J_H__
+#include <drm/drm_panel.h>
#include <linux/delay.h>
#include <linux/hid.h>
#include <linux/interrupt.h>
@@ -69,6 +70,11 @@
#define HIMAX_AHB_CMD_INCR4 0x10
#define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01
#define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000
+/* DSRAM flag addresses */
+#define HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND 0x10007fd0
+/* dsram flag data */
+#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND 0xa55aa55a
+#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME 0x00000000
/* hx83102j-specific register/dsram flags/data */
#define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004
/* hardware register addresses */
@@ -219,13 +225,17 @@ struct himax_hid_desc {
/**
* struct himax_platform_data - Platform data holder
+ * @is_panel_follower: Is panel follower enabled
* @vccd_supply: VCCD supply
+ * @panel_follower: DRM panel follower
* @gpiod_rst: GPIO reset
*
* This structure is used to hold the platform related data.
*/
struct himax_platform_data {
+ bool is_panel_follower;
struct regulator *vccd_supply;
+ struct drm_panel_follower panel_follower;
struct gpio_desc *gpiod_rst;
};
--
2.34.1
^ permalink raw reply related
* [PATCH v4 4/4] HID: Load firmware directly from file to IC
From: Allen_Lin @ 2024-04-17 7:41 UTC (permalink / raw)
To: dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor, jikos,
benjamin.tissoires, linux-input, devicetree, linux-kernel
Cc: Allen_Lin
In-Reply-To: <20240417074115.1137885-1-allencl_lin@hotmail.com>
For HX83102J, often shipped without flash for costdown purpose.
This patch implement the function to load firmware file from
user-space, write into IC sram and make it running.
The procedure as following:
1. Check OF to get FW name specified: himax_parse_dt
2. Load specified FW: i_get_FW, upload process use workqueue
himax_boot_upgrade
3. Write FW into IC sram: i_update_FW
3-1. FW file contain a mapping table to indicate various section,
such code, data, version info and HID info
3-2. Call update process himax_mcu_firmware_update_0f, which stop
the internal MCU: i. system reset. ii. hx83102j_sense_off
3-3. Parsing FW and upload file: himax_zf_part_info. info[0] contain
the code section and will upload to ISRAM. Other info[x] are
data sections will be combined and upload to DSRAM separately.
After upload FW, driver will use crc to check integrity:
himax_sram_write_crc_check for code(HW CRC result must be 0),
himax_mcu_calculate_crc_with_ap for pre-calculate data CRC[1],
Upload data section by himax_mcu_register_write,
himax_mcu_check_crc use HW calculate CRC and compared with [1]
4. Disable HW reload FW from flash function before MCU start running:
himax_disable_fw_reload
5. Start running the FW: himax_mcu_power_on_init
5-1. Setting varies FW settings before FW start running
5-2. Start FW: hx83102j_sense_on
5-3. Wait until FW initial process complete: Read 0x72C0 from IC
6. Read HID info from FW
7. Read TP properties from IC: himax_mcu_tp_info_check
8. Read FW information fromIC: himax_mcu_read_FW_ver
9. Release FW, IC initial complete
The resume procedure do part of boot process, it also need to reload
FW from user-space into IC sram: himax_0f_op_file_dirly
1. Request FW
2. Upload FW: himax_mcu_firmware_update_0f
3. Disable HW reload FW from flash function: himax_disable_fw_reload
4. Start running the FW: himax_mcu_power_on_init
Signed-off-by: Allen_Lin <allencl_lin@hotmail.com>
---
drivers/hid/hid-himax.c | 1501 +++++++++++++++++++++++++++++++++------
drivers/hid/hid-himax.h | 166 ++++-
2 files changed, 1467 insertions(+), 200 deletions(-)
diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c
index 7b0ee48acfae..50acb87bee35 100644
--- a/drivers/hid/hid-himax.c
+++ b/drivers/hid/hid-himax.c
@@ -532,6 +532,92 @@ static void himax_mcu_ic_reset(struct himax_ts_data *ts, bool int_off)
himax_int_enable(ts, true);
}
+/**
+ * hx83102j_reload_to_active() - Reload to active mode
+ * @ts: Himax touch screen data
+ *
+ * This function is used to write a flag to the IC register to make MCU restart without
+ * reload the firmware.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_reload_to_active(struct himax_ts_data *ts)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 addr = HIMAX_REG_ADDR_RELOAD_TO_ACTIVE;
+ const u32 reload_to_active_cmd = 0xec;
+ const u32 reload_to_active_done = 0x01ec;
+ const u32 retry_limit = 5;
+ union himax_dword_data data;
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ data.dword = cpu_to_le32(reload_to_active_cmd);
+ ret = himax_mcu_register_write(ts, addr, data.byte, 4);
+ if (ret < 0)
+ return ret;
+ usleep_range(1000, 1100);
+ ret = himax_mcu_register_read(ts, addr, data.byte, 4);
+ if (ret < 0)
+ return ret;
+ data.dword = le32_to_cpu(data.dword);
+ if (data.word[0] == reload_to_active_done)
+ break;
+ }
+
+ if (data.word[0] != reload_to_active_done) {
+ dev_err(ts->dev, "%s: Reload to active failed!\n", __func__);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * hx83102j_en_hw_crc() - Enable/Disable HW CRC
+ * @ts: Himax touch screen data
+ * @en: true for enable, false for disable
+ *
+ * This function is used to enable or disable the HW CRC. The HW CRC
+ * is used to protect the SRAM data.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_en_hw_crc(struct himax_ts_data *ts, bool en)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 addr = HIMAX_HX83102J_REG_ADDR_HW_CRC;
+ const u32 retry_limit = 5;
+ union himax_dword_data data, wrt_data;
+
+ if (en)
+ data.dword = cpu_to_le32(HIMAX_HX83102J_REG_DATA_HW_CRC);
+ else
+ data.dword = cpu_to_le32(HIMAX_HX83102J_REG_DATA_HW_CRC_DISABLE);
+
+ wrt_data.dword = data.dword;
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_write(ts, addr, data.byte, 4);
+ if (ret < 0)
+ return ret;
+ usleep_range(1000, 1100);
+ ret = himax_mcu_register_read(ts, addr, data.byte, 4);
+ if (ret < 0)
+ return ret;
+
+ if (data.word[0] == wrt_data.word[0])
+ break;
+ }
+
+ if (data.word[0] != wrt_data.word[0]) {
+ dev_err(ts->dev, "%s: ECC fail!\n", __func__);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
/**
* hx83102j_sense_off() - Stop MCU and enter safe mode
* @ts: Himax touch screen data
@@ -641,6 +727,56 @@ static int hx83102j_sense_off(struct himax_ts_data *ts, bool check_en)
return -EIO;
}
+/**
+ * hx83102j_sense_on() - Sense on the touch chip
+ * @ts: Himax touch screen data
+ * @sw_reset: true for software reset, false for hardware reset
+ *
+ * This function is used to sense on the touch chip, which means to start running the
+ * FW. The process begin with wakeup the IC bus interface, then write a flag to the IC
+ * register to make MCU restart running the FW. When sw_reset is true, the function will
+ * send a command to the IC to leave safe mode. Otherwise, the function will call
+ * himax_mcu_ic_reset() to reset the touch chip by hardware pin.
+ * Then enable the HW CRC to protect sram data, and reload to active to make the MCU
+ * start running without reload the firmware.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int hx83102j_sense_on(struct himax_ts_data *ts, bool sw_reset)
+{
+ int ret;
+ const union himax_dword_data re_init = {
+ .dword = cpu_to_le32(HIMAX_REG_DATA_FW_RE_INIT)
+ };
+ union himax_dword_data data;
+
+ dev_info(ts->dev, "%s: software reset %s\n", __func__, sw_reset ? "true" : "false");
+ ret = himax_mcu_interface_on(ts);
+ if (ret < 0)
+ return ret;
+
+ ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_CTRL_FW, re_init.byte, 4);
+ if (ret < 0)
+ return ret;
+ usleep_range(10000, 11000);
+ if (!sw_reset) {
+ himax_mcu_ic_reset(ts, false);
+ } else {
+ data.word[0] = cpu_to_le16(HIMAX_AHB_CMD_LEAVE_SAFE_MODE);
+ ret = himax_write(ts, HIMAX_AHB_ADDR_PSW_LB, NULL, data.byte, 2);
+ if (ret < 0)
+ return ret;
+ }
+ ret = hx83102j_en_hw_crc(ts, true);
+ if (ret < 0)
+ return ret;
+ ret = hx83102j_reload_to_active(ts);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
/**
* hx83102j_chip_detect() - Check if the touch chip is HX83102J
* @ts: Himax touch screen data
@@ -783,166 +919,980 @@ static int hx83102j_read_event_stack(struct himax_ts_data *ts, u8 *buf, u32 leng
int ret;
const u32 max_trunk_sz = ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN;
- for (i = 0; i < length; i += max_trunk_sz) {
- ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i,
- min(length - i, max_trunk_sz));
+ for (i = 0; i < length; i += max_trunk_sz) {
+ ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i,
+ min(length - i, max_trunk_sz));
+ if (ret) {
+ dev_err(ts->dev, "%s: read event stack error!\n", __func__);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * hx83102j_chip_init_data() - Initialize the touch chip data
+ * @ts: Himax touch screen data
+ *
+ * This function is used to initialize hx83102j touch specific data in himax_ts_data.
+ * The chip_max_dsram_size is the maximum size of the DSRAM of hx83102j.
+ *
+ * Return: None
+ */
+static void hx83102j_chip_init_data(struct himax_ts_data *ts)
+{
+ ts->chip_max_dsram_size = HIMAX_HX83102J_DSRAM_SZ;
+}
+
+/**
+ * himax_touch_get() - Get touch data from touch chip
+ * @ts: Himax touch screen data
+ * @buf: Buffer to store the data
+ *
+ * This function is a wrapper to call hx83102j_read_event_stack() to read the touch
+ * data from the touch chip. The touch_data_sz is the size of the touch data to read,
+ * which is calculated by hid report descriptor provided by the firmware.
+ *
+ * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize
+ * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS
+ * when the read is successful. The reason is that the may need special handling when
+ * the read fails.
+ */
+static int himax_touch_get(struct himax_ts_data *ts, u8 *buf)
+{
+ if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) {
+ dev_err(ts->dev, "can't read data from chip!");
+ return HIMAX_TS_GET_DATA_FAIL;
+ }
+
+ return HIMAX_TS_SUCCESS;
+}
+
+/**
+ * himax_mcu_assign_sorting_mode() - Write sorting mode to dsram and verify
+ * @ts: Himax touch screen data
+ * @tmp_data_in: password to write
+ *
+ * This function is used to write the sorting mode password to dsram and verify the
+ * password is written correctly. The sorting mode password is used as a flag to
+ * FW to let it know which mode the touch chip is working on.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_assign_sorting_mode(struct himax_ts_data *ts, u8 *tmp_data_in)
+{
+ int ret;
+ u8 rdata[4];
+ u32 retry_cnt;
+ const u32 retry_limit = 3;
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_SORTING_MODE_EN,
+ tmp_data_in, HIMAX_REG_SZ);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write sorting mode fail\n", __func__);
+ return ret;
+ }
+ usleep_range(1000, 1100);
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_SORTING_MODE_EN,
+ rdata, HIMAX_REG_SZ);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read sorting mode fail\n", __func__);
+ return ret;
+ }
+
+ if (!memcmp(tmp_data_in, rdata, HIMAX_REG_SZ))
+ return 0;
+ }
+ dev_err(ts->dev, "%s: fail to write sorting mode\n", __func__);
+
+ return -EINVAL;
+}
+
+/**
+ * himax_mcu_read_FW_status() - Read FW status from touch chip
+ * @ts: Himax touch screen data
+ *
+ * This function is used to read the FW status from the touch chip. The FW status is
+ * values from dsram and register from TPIC. Which shows the FW vital working status
+ * for developer debug.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_read_FW_status(struct himax_ts_data *ts)
+{
+ int i;
+ int ret;
+ size_t len;
+ u8 data[4];
+ const char * const reg_name[] = {
+ "DBG_MSG",
+ "FW_STATUS",
+ "DD_STATUS",
+ "RESET_FLAG"
+ };
+ const u32 dbg_reg_array[] = {
+ HIMAX_DSRAM_ADDR_DBG_MSG,
+ HIMAX_REG_ADDR_FW_STATUS,
+ HIMAX_REG_ADDR_DD_STATUS,
+ HIMAX_REG_ADDR_RESET_FLAG
+ };
+
+ len = ARRAY_SIZE(dbg_reg_array);
+
+ for (i = 0; i < len; i++) {
+ ret = himax_mcu_register_read(ts, dbg_reg_array[i], data, HIMAX_REG_SZ);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read FW status fail\n", __func__);
+ return ret;
+ }
+
+ dev_info(ts->dev, "%s: %10s(0x%08X) = 0x%02X, 0x%02X, 0x%02X, 0x%02X\n",
+ __func__, reg_name[i], dbg_reg_array[i],
+ data[0], data[1], data[2], data[3]);
+ }
+
+ return 0;
+}
+
+/**
+ * himax_mcu_power_on_init() - Power on initialization
+ * @ts: Himax touch screen data
+ *
+ * This function is used to do the power on initialization after firmware has been
+ * loaded to sram. The process initialize varies IC register and dsram to make sure
+ * FW start running correctly. When all set, sense on the touch chip to make the FW
+ * start running and wait for the FW reload done password.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_power_on_init(struct himax_ts_data *ts)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 retry_limit = 30;
+ union himax_dword_data data;
+
+ /* RawOut select initial */
+ data.dword = cpu_to_le32(HIMAX_DATA_CLEAR);
+ ret = himax_mcu_register_write(ts, HIMAX_HX83102J_DSRAM_ADDR_RAW_OUT_SEL, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: set RawOut select fail\n", __func__);
+ return ret;
+ }
+ /* Initial sorting mode password to normal mode */
+ ret = himax_mcu_assign_sorting_mode(ts, data.byte);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: assign sorting mode fail\n", __func__);
+ return ret;
+ }
+ /* N frame initial */
+ /* reset N frame back to default value 1 for normal mode */
+ data.dword = cpu_to_le32(1);
+ ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_SET_NFRAME, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: set N frame fail\n", __func__);
+ return ret;
+ }
+ /* Initial FW reload status */
+ data.dword = cpu_to_le32(HIMAX_DATA_CLEAR);
+ ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: initial FW reload status fail\n", __func__);
+ return ret;
+ }
+
+ ret = hx83102j_sense_on(ts, false);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: sense on fail\n", __func__);
+ return ret;
+ }
+
+ dev_info(ts->dev, "%s: waiting for FW reload data\n", __func__);
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read FW reload status fail\n", __func__);
+ return ret;
+ }
+
+ /* use all 4 bytes to compare */
+ if (le32_to_cpu(data.dword) == HIMAX_DSRAM_DATA_FW_RELOAD_DONE) {
+ dev_info(ts->dev, "%s: FW reload done\n", __func__);
+ break;
+ }
+ dev_info(ts->dev, "%s: wait FW reload %u times\n", __func__, retry_cnt + 1);
+ ret = himax_mcu_read_FW_status(ts);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: read FW status fail\n", __func__);
+
+ usleep_range(10000, 11000);
+ }
+
+ if (retry_cnt == retry_limit) {
+ dev_err(ts->dev, "%s: FW reload fail!\n", __func__);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_mcu_calculate_crc() - Calculate CRC-32 of given data
+ * @data: Data to calculate CRC
+ * @len: Length of data
+ *
+ * This function is used to calculate the CRC-32 of the given data. The function
+ * calculate the CRC-32 value by the polynomial 0x82f63b78.
+ *
+ * Return: CRC-32 value
+ */
+static u32 himax_mcu_calculate_crc(const u8 *data, int len)
+{
+ int i, j, length;
+ u32 crc = GENMASK(31, 0);
+ u32 current_data;
+ u32 tmp;
+ const u32 mask = GENMASK(30, 0);
+
+ length = len / 4;
+
+ for (i = 0; i < length; i++) {
+ current_data = data[i * 4];
+
+ for (j = 1; j < 4; j++) {
+ tmp = data[i * 4 + j];
+ current_data += (tmp) << (8 * j);
+ }
+ crc = current_data ^ crc;
+ for (j = 0; j < 32; j++) {
+ if ((crc % 2) != 0)
+ crc = ((crc >> 1) & mask) ^ CRC32C_POLY_LE;
+ else
+ crc = (((crc >> 1) & mask));
+ }
+ }
+
+ return crc;
+}
+
+/**
+ * himax_mcu_check_crc() - Let TPIC check CRC itself
+ * @ts: Himax touch screen data
+ * @start_addr: Start address of the data in sram to check
+ * @reload_length: Length of the data to check
+ * @crc_result: CRC result for return
+ *
+ * This function is used to let TPIC check the CRC of the given data in sram. The
+ * function write the start address and length of the data to the TPIC, and wait for
+ * the TPIC to finish the CRC check. When the CRC check is done, the function read
+ * the CRC result from the TPIC.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_check_crc(struct himax_ts_data *ts, u32 start_addr,
+ int reload_length, u32 *crc_result)
+{
+ int ret;
+ int length = reload_length / HIMAX_REG_SZ;
+ u32 retry_cnt;
+ const u32 retry_limit = 100;
+ union himax_dword_data data, addr;
+
+ addr.dword = cpu_to_le32(start_addr);
+ ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_RELOAD_ADDR_FROM, addr.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write reload start address fail\n", __func__);
+ return ret;
+ }
+
+ data.word[1] = cpu_to_le16(HIMAX_REG_DATA_RELOAD_PASSWORD);
+ data.word[0] = cpu_to_le16(length);
+ ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write reload length and password fail!\n", __func__);
+ return ret;
+ }
+
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read reload length and password fail!\n", __func__);
+ return ret;
+ }
+
+ if (le16_to_cpu(data.word[0]) != length) {
+ dev_err(ts->dev, "%s: length verify failed!\n", __func__);
+ return -EINVAL;
+ }
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_STATUS, data.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read reload status fail!\n", __func__);
+ return ret;
+ }
+
+ data.dword = le32_to_cpu(data.dword);
+ if ((data.byte[0] & HIMAX_REG_DATA_RELOAD_DONE) != HIMAX_REG_DATA_RELOAD_DONE) {
+ ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_CRC32_RESULT,
+ data.byte, HIMAX_REG_SZ);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read crc32 result fail!\n", __func__);
+ return ret;
+ }
+ *crc_result = le32_to_cpu(data.dword);
+ return 0;
+ }
+
+ dev_info(ts->dev, "%s: Waiting for HW ready!\n", __func__);
+ usleep_range(1000, 1100);
+ }
+
+ if (retry_cnt == retry_limit) {
+ ret = himax_mcu_read_FW_status(ts);
+ if (ret < 0)
+ dev_err(ts->dev, "%s: read FW status fail\n", __func__);
+ }
+
+ return -EINVAL;
+}
+
+/**
+ * himax_mcu_read_FW_ver() - Read varies version from touch chip
+ * @ts: Himax touch screen data
+ *
+ * This function is used to read the firmware version, config version, touch config
+ * version, display config version, customer ID, customer info, and project info from
+ * the touch chip. The function will call himax_mcu_register_read() to read the data
+ * from the TPIC, and store the data to the IC data in himax_ts_data.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_read_FW_ver(struct himax_ts_data *ts)
+{
+ int ret;
+ u8 data[HIMAX_TP_INFO_STR_LEN];
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_FW_VER, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read FW version fail\n", __func__);
+ return ret;
+ }
+ ts->ic_data.vendor_panel_ver = data[0];
+ ts->ic_data.vendor_fw_ver = data[1] << 8 | data[2];
+ dev_info(ts->dev, "%s: PANEL_VER: %X\n", __func__, ts->ic_data.vendor_panel_ver);
+ dev_info(ts->dev, "%s: FW_VER: %X\n", __func__, ts->ic_data.vendor_fw_ver);
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_CFG, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read CFG version fail\n", __func__);
+ return ret;
+ }
+ ts->ic_data.vendor_config_ver = data[2] << 8 | data[3];
+ ts->ic_data.vendor_touch_cfg_ver = data[2];
+ dev_info(ts->dev, "%s: TOUCH_VER: %X\n", __func__, ts->ic_data.vendor_touch_cfg_ver);
+ ts->ic_data.vendor_display_cfg_ver = data[3];
+ dev_info(ts->dev, "%s: DISPLAY_VER: %X\n", __func__, ts->ic_data.vendor_display_cfg_ver);
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_VENDOR, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read customer ID fail\n", __func__);
+ return ret;
+ }
+ ts->ic_data.vendor_cid_maj_ver = data[2];
+ ts->ic_data.vendor_cid_min_ver = data[3];
+ dev_info(ts->dev, "%s: CID_VER: %X\n", __func__, (ts->ic_data.vendor_cid_maj_ver << 8
+ | ts->ic_data.vendor_cid_min_ver));
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_CUS_INFO, data, HIMAX_TP_INFO_STR_LEN);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read customer info fail\n", __func__);
+ return ret;
+ }
+ memcpy(ts->ic_data.vendor_cus_info, data, HIMAX_TP_INFO_STR_LEN);
+ dev_info(ts->dev, "%s: Cusomer ID : %s\n", __func__, ts->ic_data.vendor_cus_info);
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_PROJ_INFO, data, HIMAX_TP_INFO_STR_LEN);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read project info fail\n", __func__);
+ return ret;
+ }
+ memcpy(ts->ic_data.vendor_proj_info, data, HIMAX_TP_INFO_STR_LEN);
+ dev_info(ts->dev, "%s: Project ID : %s\n", __func__, ts->ic_data.vendor_proj_info);
+
+ return 0;
+}
+
+/**
+ * himax_bin_desc_data_get() - Parse descriptor data from firmware token
+ * @ts: Himax touch screen data
+ * @addr: Address of the data in firmware image
+ * @descript_buf: token for parsing
+ *
+ * This function is used to parse the descriptor data from the firmware token. The
+ * descriptors are mappings of information in the firmware image. The function will
+ * check checksum of each token first, and then parse the token to get the related
+ * data. The data includes CID version, FW version, CFG version, touch config table,
+ * HID table, HID descriptor, and HID read descriptor.
+ *
+ * Return: true on success, false on failure
+ */
+static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf)
+{
+ u16 chk_end;
+ u16 chk_sum;
+ u32 hid_table_addr;
+ u32 i, j;
+ u32 image_offset;
+ u32 map_code;
+ const u32 data_sz = 16;
+ const u32 report_desc_offset = 24;
+ union {
+ u8 *buf;
+ u32 *word;
+ } map_data;
+
+ /* looking for mapping in page, each mapping is 16 bytes */
+ for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) {
+ chk_end = 0;
+ chk_sum = 0;
+ for (j = i; j < (i + data_sz); j++) {
+ chk_end |= descript_buf[j];
+ chk_sum += descript_buf[j];
+ }
+ if (!chk_end) { /* 1. Check all zero */
+ return false;
+ } else if (chk_sum % 0x100) { /* 2. Check sum */
+ dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr);
+ } else { /* 3. get data */
+ map_data.buf = &descript_buf[i];
+ map_code = le32_to_cpup(map_data.word);
+ map_data.buf = &descript_buf[i + 4];
+ image_offset = le32_to_cpup(map_data.word);
+ /* 4. load info from FW image by specified mapping offset */
+ switch (map_code) {
+ /* Config ID */
+ case HIMAX_FW_CID:
+ ts->fw_info_table.addr_cid_ver_major = image_offset;
+ ts->fw_info_table.addr_cid_ver_minor = image_offset + 1;
+ break;
+ /* FW version */
+ case HIMAX_FW_VER:
+ ts->fw_info_table.addr_fw_ver_major = image_offset;
+ ts->fw_info_table.addr_fw_ver_minor = image_offset + 1;
+ break;
+ /* Config version */
+ case HIMAX_CFG_VER:
+ ts->fw_info_table.addr_cfg_ver_major = image_offset;
+ ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1;
+ break;
+ /* Touch config table */
+ case HIMAX_TP_CONFIG_TABLE:
+ ts->fw_info_table.addr_cfg_table = image_offset;
+ break;
+ /* HID table */
+ case HIMAX_HID_TABLE:
+ ts->fw_info_table.addr_hid_table = image_offset;
+ hid_table_addr = image_offset;
+ ts->fw_info_table.addr_hid_desc = hid_table_addr;
+ ts->fw_info_table.addr_hid_rd_desc =
+ hid_table_addr + report_desc_offset;
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+/**
+ * himax_mcu_bin_desc_get() - Check and get the bin description from the data
+ * @fw: Firmware data
+ * @ts: Himax touch screen data
+ * @max_sz: Maximum size to check
+ *
+ * This function is used to check and get the bin description from the firmware data.
+ * It will check the given data to see if it match the bin description format, and
+ * call himax_bin_desc_data_get() to get the related data.
+ *
+ * Return: true on mapping_count > 0, false on otherwise
+ */
+static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz)
+{
+ bool keep_on_flag;
+ u32 addr;
+ u32 mapping_count;
+ unsigned char *fw_buf;
+ const u8 header_id = 0x87;
+ const u8 header_id_loc = 0x0e;
+ const u8 header_sz = 8;
+ const u8 header[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+
+ /* Check bin is with description table or not */
+ if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) {
+ dev_err(ts->dev, "%s: No description table\n", __func__);
+ return false;
+ }
+
+ for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) {
+ fw_buf = &fw[addr];
+ /* Get related data */
+ keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf);
+ if (keep_on_flag)
+ mapping_count++;
+ else
+ break;
+ }
+
+ return mapping_count > 0;
+}
+
+/**
+ * himax_mcu_tp_info_check() - Read touch information from touch chip
+ * @ts: Himax touch screen data
+ *
+ * This function is used to read the touch information from the touch chip. The
+ * information includes the touch resolution, touch point number, interrupt type,
+ * button number, stylus function, stylus version, and stylus ratio. These information
+ * is filled by FW after the FW initialized, so it must be called after FW finish
+ * loading.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_mcu_tp_info_check(struct himax_ts_data *ts)
+{
+ int ret;
+ char data[HIMAX_REG_SZ];
+ u8 stylus_ratio;
+ u32 button_num;
+ u32 max_pt;
+ u32 rx_num;
+ u32 tx_num;
+ u32 x_res;
+ u32 y_res;
+ const u32 button_num_mask = 0x03;
+ const u32 interrupt_type_mask = 0x01;
+ const u32 interrupt_type_edge = 0x01;
+ bool int_is_edge;
+ bool stylus_func;
+ bool stylus_id_v2;
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_RXNUM_TXNUM, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read rx/tx num fail\n", __func__);
+ return ret;
+ }
+ rx_num = data[2];
+ tx_num = data[3];
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_MAXPT_XYRVS, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read max touch point fail\n", __func__);
+ return ret;
+ }
+ max_pt = data[0];
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_X_Y_RES, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read x/y resolution fail\n", __func__);
+ return ret;
+ }
+ y_res = be16_to_cpup((u16 *)&data[0]);
+ x_res = be16_to_cpup((u16 *)&data[2]);
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_INT_IS_EDGE, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read interrupt type fail\n", __func__);
+ return ret;
+ }
+ if ((data[1] & interrupt_type_mask) == interrupt_type_edge)
+ int_is_edge = true;
+ else
+ int_is_edge = false;
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_MKEY, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read button number fail\n", __func__);
+ return ret;
+ }
+ button_num = data[0] & button_num_mask;
+
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_STYLUS_FUNCTION, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read stylus function fail\n", __func__);
+ return ret;
+ }
+ stylus_func = data[3] ? true : false;
+
+ if (stylus_func) {
+ ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_STYLUS_VERSION, data, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: read stylus version fail\n", __func__);
+ return ret;
+ }
+ /* dsram_addr_stylus_version + 2 : 0=off 1=on */
+ stylus_id_v2 = data[2] ? true : false;
+ /* dsram_addr_stylus_version + 3 : 0=ratio_1 10=ratio_10 */
+ stylus_ratio = data[3];
+ }
+
+ ts->ic_data.button_num = button_num;
+ ts->ic_data.stylus_function = stylus_func;
+ ts->ic_data.rx_num = rx_num;
+ ts->ic_data.tx_num = tx_num;
+ ts->ic_data.x_res = x_res;
+ ts->ic_data.y_res = y_res;
+ ts->ic_data.max_point = max_pt;
+ ts->ic_data.interrupt_is_edge = int_is_edge;
+ if (stylus_func) {
+ ts->ic_data.stylus_v2 = stylus_id_v2;
+ ts->ic_data.stylus_ratio = stylus_ratio;
+ } else {
+ ts->ic_data.stylus_v2 = false;
+ ts->ic_data.stylus_ratio = 0;
+ }
+
+ dev_info(ts->dev, "%s: rx_num = %u, tx_num = %u\n", __func__,
+ ts->ic_data.rx_num, ts->ic_data.tx_num);
+ dev_info(ts->dev, "%s: max_point = %u\n", __func__, ts->ic_data.max_point);
+ dev_info(ts->dev, "%s: interrupt_is_edge = %s, stylus_function = %s\n", __func__,
+ ts->ic_data.interrupt_is_edge ? "true" : "false",
+ ts->ic_data.stylus_function ? "true" : "false");
+ dev_info(ts->dev, "%s: stylus_v2 = %s, stylus_ratio = %u\n", __func__,
+ ts->ic_data.stylus_v2 ? "true" : "false", ts->ic_data.stylus_ratio);
+ dev_info(ts->dev, "%s: TOUCH INFO updated\n", __func__);
+
+ return 0;
+}
+
+/**
+ * himax_disable_fw_reload() - Disable the FW reload data from flash
+ * @ts: Himax touch screen data
+ *
+ * This function is used to tell FW not to reload data from flash. It needs to be
+ * set before FW start running.
+ *
+ * return: 0 on success, negative error code on failure
+ */
+static int himax_disable_fw_reload(struct himax_ts_data *ts)
+{
+ union himax_dword_data data = {
+ /*
+ * HIMAX_DSRAM_ADDR_FLASH_RELOAD: 0x10007f00
+ * 0x10007f00 <= 0x9aa9, let FW know there's no flash
+ * <= 0x5aa5, there has flash, but not reload
+ * <= 0x0000, there has flash, and reload
+ */
+ .dword = cpu_to_le32(HIMAX_DSRAM_DATA_DISABLE_FLASH_RELOAD)
+ };
+
+ /* Disable Flash Reload */
+ return himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_FLASH_RELOAD, data.byte, 4);
+}
+
+/**
+ * himax_sram_write_crc_check() - Write the data to SRAM and check the CRC by hardware
+ * @ts: Himax touch screen data
+ * @addr: Address to write to
+ * @data: Data to write
+ * @len: Length of data
+ *
+ * This function is use to write FW code/data to SRAM and check the CRC by hardware to make
+ * sure the written data is correct. The FW code is designed to be CRC result 0, so if the
+ * CRC result is not 0, it means the written data is not correct.
+ *
+ * return: 0 on success, negative error code on failure
+ */
+static int himax_sram_write_crc_check(struct himax_ts_data *ts, u32 addr, const u8 *data, u32 len)
+{
+ int ret;
+ u32 crc;
+ u32 retry_cnt;
+ const u32 retry_limit = 3;
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ dev_info(ts->dev, "%s: Write FW to SRAM - total write size = %u\n", __func__, len);
+ ret = himax_mcu_register_write(ts, addr, data, len);
+ if (ret) {
+ dev_err(ts->dev, "%s: write FW to SRAM fail\n", __func__);
+ return ret;
+ }
+ ret = himax_mcu_check_crc(ts, addr, len, &crc);
+ if (ret) {
+ dev_err(ts->dev, "%s: check CRC fail\n", __func__);
+ return ret;
+ }
+ dev_info(ts->dev, "%s: HW CRC %s in %u time\n", __func__,
+ crc == 0 ? "OK" : "Fail", retry_cnt);
+
+ if (crc == 0)
+ break;
+ }
+
+ if (crc != 0) {
+ dev_err(ts->dev, "%s: HW CRC fail\n", __func__);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * himax_zf_part_info() - Get and write the partition from the firmware to SRAM
+ * @fw: Firmware data
+ * @ts: Himax touch screen data
+ *
+ * This function is used to get the partition information from the firmware and write
+ * the partition to SRAM. The partition information includes the DSRAM address, the
+ * firmware offset, and the write size. The function will get the partition information
+ * into a table, and then write the partition to SRAM according to the table. After
+ * writing the partition to SRAM, the function will check the CRC by hardware to make
+ * sure the written data is correct.
+ *
+ * return: 0 on success, negative error code on failure
+ */
+static int himax_zf_part_info(const struct firmware *fw, struct himax_ts_data *ts)
+{
+ int i;
+ int i_max = -1;
+ int i_min = -1;
+ int pnum;
+ int ret;
+ u8 buf[HIMAX_ZF_PARTITION_DESC_SZ];
+ u32 cfg_crc_sw;
+ u32 cfg_crc_hw;
+ u32 cfg_sz;
+ u32 dsram_base = 0xffffffff;
+ u32 dsram_max = 0;
+ u32 retry_cnt = 0;
+ u32 sram_min;
+ const u32 retry_limit = 3;
+ const u32 table_addr = ts->fw_info_table.addr_cfg_table;
+ struct himax_zf_info *info;
+
+ /* 1. initial check */
+ ret = hx83102j_en_hw_crc(ts, true);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: Failed to enable HW CRC\n", __func__);
+ return ret;
+ }
+ pnum = fw->data[table_addr + HIMAX_ZF_PARTITION_AMOUNT_OFFSET];
+ if (pnum < 2) {
+ dev_err(ts->dev, "%s: partition number is not correct\n", __func__);
+ return -EINVAL;
+ }
+
+ info = kcalloc(pnum, sizeof(struct himax_zf_info), GFP_KERNEL);
+ if (!info)
+ return -ENOMEM;
+
+ memset(info, 0, pnum * sizeof(struct himax_zf_info));
+
+ /*
+ * 2. record partition information:
+ * partition 0: FW main code
+ */
+ memcpy(buf, &fw->data[table_addr], HIMAX_ZF_PARTITION_DESC_SZ);
+ memcpy(info[0].sram_addr, buf, 4);
+ info[0].write_size = le32_to_cpup((u32 *)&buf[4]);
+ info[0].fw_addr = le32_to_cpup((u32 *)&buf[8]);
+
+ /* partition 1 ~ n: config data */
+ for (i = 1; i < pnum; i++) {
+ memcpy(buf, &fw->data[i * HIMAX_ZF_PARTITION_DESC_SZ + table_addr],
+ HIMAX_ZF_PARTITION_DESC_SZ);
+ memcpy(info[i].sram_addr, buf, 4);
+ info[i].write_size = le32_to_cpup((u32 *)&buf[4]);
+ info[i].fw_addr = le32_to_cpup((u32 *)&buf[8]);
+ info[i].cfg_addr = le32_to_cpup((u32 *)&info[i].sram_addr[0]);
+
+ /* Write address must be multiple of 4 */
+ if (info[i].cfg_addr % 4 != 0) {
+ info[i].cfg_addr -= (info[i].cfg_addr % 4);
+ info[i].fw_addr -= (info[i].cfg_addr % 4);
+ info[i].write_size += (info[i].cfg_addr % 4);
+ }
+
+ if (dsram_base > info[i].cfg_addr) {
+ dsram_base = info[i].cfg_addr;
+ i_min = i;
+ }
+ if (dsram_max < info[i].cfg_addr) {
+ dsram_max = info[i].cfg_addr;
+ i_max = i;
+ }
+ }
+
+ if (i_min < 0 || i_max < 0) {
+ dev_err(ts->dev, "%s: DSRAM address invalid!\n", __func__);
+ return -EINVAL;
+ }
+
+ /* 3. prepare data to update */
+ sram_min = info[i_min].cfg_addr;
+
+ cfg_sz = (dsram_max - dsram_base) + info[i_max].write_size;
+ /* Wrtie size must be multiple of 4 */
+ if (cfg_sz % 4 != 0)
+ cfg_sz = cfg_sz + 4 - (cfg_sz % 4);
+
+ dev_info(ts->dev, "%s: main code sz = %d, config sz = %d\n", __func__,
+ info[0].write_size, cfg_sz);
+ /* config size should be smaller than DSRAM size */
+ if (cfg_sz > ts->chip_max_dsram_size) {
+ dev_err(ts->dev, "%s: config size error[%d, %u]!!\n", __func__,
+ cfg_sz, ts->chip_max_dsram_size);
+ ret = -EINVAL;
+ goto alloc_cfg_buffer_failed;
+ }
+
+ memset(ts->zf_update_cfg_buffer, 0x00,
+ ts->chip_max_dsram_size * sizeof(u8));
+
+ /* Collect all partition in FW for DSRAM in a cfg buffer */
+ for (i = 1; i < pnum; i++)
+ memcpy(&ts->zf_update_cfg_buffer[info[i].cfg_addr - dsram_base],
+ &fw->data[info[i].fw_addr], info[i].write_size);
+
+ /*
+ * 4. write to sram
+ * First, write FW main code and check CRC by HW
+ */
+ ret = himax_sram_write_crc_check(ts, le32_to_cpup((u32 *)info[0].sram_addr),
+ &fw->data[info[0].fw_addr], info[0].write_size);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: HW CRC fail\n", __func__);
+ goto write_main_code_failed;
+ }
+
+ /*
+ * Second, FW config data: Calculate CRC of CFG data which is going to write.
+ * CFG data don't have CRC pre-defined in FW and need to be calculated by driver.
+ */
+ cfg_crc_sw = himax_mcu_calculate_crc(ts->zf_update_cfg_buffer, cfg_sz);
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ /* Write hole cfg data to DSRAM */
+ dev_info(ts->dev, "%s: Write cfg to SRAM - total write size = %d\n",
+ __func__, cfg_sz);
+ ret = himax_mcu_register_write(ts, sram_min, ts->zf_update_cfg_buffer, cfg_sz);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: write cfg to SRAM fail\n", __func__);
+ goto write_cfg_failed;
+ }
+ /*
+ * Check CRC: Tell HW to calculate CRC from CFG start address in SRAM and check
+ * size is equal to size of CFG buffer written. Then we compare the two CRC data
+ * make sure data written is correct.
+ */
+ ret = himax_mcu_check_crc(ts, sram_min, cfg_sz, &cfg_crc_hw);
if (ret) {
- dev_err(ts->dev, "%s: read event stack error!\n", __func__);
- return ret;
+ dev_err(ts->dev, "%s: check CRC failed!\n", __func__);
+ goto crc_failed;
}
- }
- return 0;
-}
+ if (cfg_crc_hw != cfg_crc_sw)
+ dev_err(ts->dev, "%s: Cfg CRC FAIL, HWCRC = %X, SWCRC = %X, retry = %u\n",
+ __func__, cfg_crc_hw, cfg_crc_sw, retry_cnt);
+ else
+ break;
+ }
-/**
- * himax_touch_get() - Get touch data from touch chip
- * @ts: Himax touch screen data
- * @buf: Buffer to store the data
- *
- * This function is a wrapper to call hx83102j_read_event_stack() to read the touch
- * data from the touch chip. The touch_data_sz is the size of the touch data to read,
- * which is calculated by hid report descriptor provided by the firmware.
- *
- * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize
- * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS
- * when the read is successful. The reason is that the may need special handling when
- * the read fails.
- */
-static int himax_touch_get(struct himax_ts_data *ts, u8 *buf)
-{
- if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) {
- dev_err(ts->dev, "can't read data from chip!");
- return HIMAX_TS_GET_DATA_FAIL;
+ if (retry_cnt == retry_limit && cfg_crc_hw != cfg_crc_sw) {
+ dev_err(ts->dev, "%s: Write cfg to SRAM fail\n", __func__);
+ ret = -EINVAL;
+ goto crc_not_match;
}
- return HIMAX_TS_SUCCESS;
+crc_not_match:
+crc_failed:
+write_cfg_failed:
+write_main_code_failed:
+alloc_cfg_buffer_failed:
+ kfree(info);
+
+ return ret;
}
/**
- * himax_bin_desc_data_get() - Parse descriptor data from firmware token
+ * himax_mcu_firmware_update_zf() - Update the firmware to the touch chip
+ * @fw: Firmware data
* @ts: Himax touch screen data
- * @addr: Address of the data in firmware image
- * @descript_buf: token for parsing
*
- * This function is used to parse the descriptor data from the firmware token. The
- * descriptors are mappings of information in the firmware image. The function will
- * check checksum of each token first, and then parse the token to get the related
- * data. The data includes CID version, FW version, CFG version, touch config table,
- * HID table, HID descriptor, and HID read descriptor.
+ * This function is used to update the firmware to the touch chip. The first step is
+ * to reset the touch chip, stop the MCU and then write the firmware to the touch chip.
*
- * Return: true on success, false on failure
+ * return: 0 on success, negative error code on failure
*/
-static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf)
+static int himax_mcu_firmware_update_zf(const struct firmware *fw, struct himax_ts_data *ts)
{
- u16 chk_end;
- u16 chk_sum;
- u32 hid_table_addr;
- u32 i, j;
- u32 image_offset;
- u32 map_code;
- const u32 data_sz = 16;
- const u32 report_desc_offset = 24;
- union {
- u8 *buf;
- u32 *word;
- } map_data;
+ int ret;
+ union himax_dword_data data_system_reset = {
+ .dword = cpu_to_le32(HIMAX_REG_DATA_SYSTEM_RESET)
+ };
- /* looking for mapping in page, each mapping is 16 bytes */
- for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) {
- chk_end = 0;
- chk_sum = 0;
- for (j = i; j < (i + data_sz); j++) {
- chk_end |= descript_buf[j];
- chk_sum += descript_buf[j];
- }
- if (!chk_end) { /* 1. Check all zero */
- return false;
- } else if (chk_sum % 0x100) { /* 2. Check sum */
- dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr);
- } else { /* 3. get data */
- map_data.buf = &descript_buf[i];
- map_code = le32_to_cpup(map_data.word);
- map_data.buf = &descript_buf[i + 4];
- image_offset = le32_to_cpup(map_data.word);
- /* 4. load info from FW image by specified mapping offset */
- switch (map_code) {
- /* Config ID */
- case HIMAX_FW_CID:
- ts->fw_info_table.addr_cid_ver_major = image_offset;
- ts->fw_info_table.addr_cid_ver_minor = image_offset + 1;
- break;
- /* FW version */
- case HIMAX_FW_VER:
- ts->fw_info_table.addr_fw_ver_major = image_offset;
- ts->fw_info_table.addr_fw_ver_minor = image_offset + 1;
- break;
- /* Config version */
- case HIMAX_CFG_VER:
- ts->fw_info_table.addr_cfg_ver_major = image_offset;
- ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1;
- break;
- /* Touch config table */
- case HIMAX_TP_CONFIG_TABLE:
- ts->fw_info_table.addr_cfg_table = image_offset;
- break;
- /* HID table */
- case HIMAX_HID_TABLE:
- ts->fw_info_table.addr_hid_table = image_offset;
- hid_table_addr = image_offset;
- ts->fw_info_table.addr_hid_desc = hid_table_addr;
- ts->fw_info_table.addr_hid_rd_desc =
- hid_table_addr + report_desc_offset;
- break;
- }
- }
+ dev_info(ts->dev, "%s: Updating FW - total FW size = %u\n", __func__, (u32)fw->size);
+ ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_SYSTEM_RESET, data_system_reset.byte, 4);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: system reset fail\n", __func__);
+ return ret;
}
- return true;
+ ret = hx83102j_sense_off(ts, false);
+ if (ret)
+ return ret;
+
+ ret = himax_zf_part_info(fw, ts);
+
+ return ret;
}
/**
- * himax_mcu_bin_desc_get() - Check and get the bin description from the data
- * @fw: Firmware data
+ * himax_zf_reload_from_file() - Complete firmware update sequence
+ * @file_name: File name of the firmware
* @ts: Himax touch screen data
- * @max_sz: Maximum size to check
*
- * This function is used to check and get the bin description from the firmware data.
- * It will check the given data to see if it match the bin description format, and
- * call himax_bin_desc_data_get() to get the related data.
+ * This function process the full sequence of updating the firmware to the touch chip.
+ * It will first check if the other thread is updating now, if not, it will request the
+ * firmware from user space and then call himax_mcu_firmware_update_zf() to update the
+ * firmware, and then tell firmware not to reload data from flash and initial the touch
+ * chip by calling himax_mcu_power_on_init().
*
- * Return: true on mapping_count > 0, false on otherwise
+ * return: 0 on success, negative error code on failure
*/
-static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz)
+static int himax_zf_reload_from_file(char *file_name, struct himax_ts_data *ts)
{
- bool keep_on_flag;
- u32 addr;
- u32 mapping_count;
- unsigned char *fw_buf;
- const u8 header_id = 0x87;
- const u8 header_id_loc = 0x0e;
- const u8 header_sz = 8;
- const u8 header[8] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
- };
+ int ret;
+ const struct firmware *fw;
- /* Check bin is with description table or not */
- if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) {
- dev_err(ts->dev, "%s: No description table\n", __func__);
- return false;
+ if (!mutex_trylock(&ts->zf_update_lock)) {
+ dev_warn(ts->dev, "%s: Other thread is updating now!\n", __func__);
+ return 0;
}
+ dev_info(ts->dev, "%s: Preparing to update %s!\n", __func__, file_name);
- for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) {
- fw_buf = &fw[addr];
- /* Get related data */
- keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf);
- if (keep_on_flag)
- mapping_count++;
- else
- break;
+ ret = request_firmware(&fw, file_name, ts->dev);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: request firmware fail, code[%d]!!\n", __func__, ret);
+ goto load_firmware_error;
}
- return mapping_count > 0;
+ ret = himax_mcu_firmware_update_zf(fw, ts);
+ release_firmware(fw);
+ if (ret < 0)
+ goto load_firmware_error;
+
+ ret = himax_disable_fw_reload(ts);
+ if (ret < 0)
+ goto load_firmware_error;
+ ret = himax_mcu_power_on_init(ts);
+
+load_firmware_error:
+ mutex_unlock(&ts->zf_update_lock);
+
+ return ret;
}
/**
@@ -1248,6 +2198,7 @@ static int himax_ts_operation(struct himax_ts_data *ts)
* This function is used to handle interrupt bottom half work. It will
* call the himax_ts_operation() to get the touch data, dispatch the data
* to HID core. If the touch data is not valid, it will reset the TPIC.
+ * It will also call the hx83102j_reload_to_active() after the reset action.
*
* Return: void
*/
@@ -1256,7 +2207,38 @@ static void himax_ts_work(struct himax_ts_data *ts)
if (himax_ts_operation(ts) == HIMAX_TS_GET_DATA_FAIL) {
dev_info(ts->dev, "%s: Now reset the Touch chip\n", __func__);
himax_mcu_ic_reset(ts, true);
+ if (hx83102j_reload_to_active(ts))
+ dev_warn(ts->dev, "%s: Reload to active failed\n", __func__);
+ }
+}
+
+/**
+ * himax_update_fw() - update firmware using firmware structure
+ * @ts: Himax touch screen data
+ *
+ * This function use already initialize firmware structure in ts to update
+ * firmware.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_update_fw(struct himax_ts_data *ts)
+{
+ int ret;
+ u32 retry_cnt;
+ const u32 retry_limit = 3;
+
+ for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) {
+ ret = himax_mcu_firmware_update_zf(ts->himax_fw, ts);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: TP upgrade error, upgrade_times = %d\n", __func__,
+ retry_cnt);
+ } else {
+ dev_info(ts->dev, "%s: TP FW upgrade OK\n", __func__);
+ return 0;
+ }
}
+
+ return -EIO;
}
/**
@@ -1289,9 +2271,8 @@ static int himax_hid_rd_init(struct himax_ts_data *ts)
if (!ts->hid_rd_data.rd_data)
return -ENOMEM;
}
- /* Copy the base RD from firmware table */
memcpy((void *)ts->hid_rd_data.rd_data,
- &ts->himax_fw_data[ts->fw_info_table.addr_hid_rd_desc],
+ &ts->himax_fw->data[ts->fw_info_table.addr_hid_rd_desc],
ts->hid_desc.report_desc_length);
ts->hid_rd_data.rd_length = ts->hid_desc.report_desc_length;
}
@@ -1401,81 +2382,95 @@ static void himax_power_deconfig(struct himax_platform_data *pdata)
}
}
-/* load firmware data from flash, parse HID info and register HID */
/**
- * himax_load_config() - Load the firmware from the flash
- * @ts: Himax touch screen data
+ * himax_initial_work() - Initial work for the touch screen
+ * @work: Work structure
+ *
+ * This function is used to do the initial work for the touch screen. It will
+ * call the request_firmware() to get the firmware from the file system, and parse the
+ * mapping table in 1k header. If the headers are parsed successfully, it will
+ * call the himax_update_fw() to update the firmware and power on the touch screen.
+ * If the power on action is successful, it will load the hid descriptor and
+ * check the touch panel information. If the touch panel information is correct,
+ * it will call the himax_hid_rd_init() to initialize the HID report descriptor,
+ * and call the himax_hid_register() to register the HID device. After all is done,
+ * it will release the firmware and enable the interrupt.
*
- * This function is used to load the firmware from the flash. It will read
- * the firmware from the flash and parse the HID info. If the HID info is
- * valid, it will initialize the HID report descriptor and register the HID
- * device. If the HID device is probed, it will initialize the report data
- * and enable the interrupt.
- *
- * Return: 0 on success, negative error code on failure
+ * Return: None
*/
-static int himax_load_config(struct himax_ts_data *ts)
+static void himax_initial_work(struct work_struct *work)
{
+ struct himax_ts_data *ts = container_of(work, struct himax_ts_data,
+ initial_work.work);
int ret;
- s32 i;
- s32 page_sz = (s32)HIMAX_HX83102J_PAGE_SIZE;
- s32 flash_sz = (s32)HIMAX_HX83102J_FLASH_SIZE;
- bool fw_load_status = false;
+ bool fw_load_status;
const u32 fw_bin_header_sz = 1024;
ts->ic_boot_done = false;
-
- ts->himax_fw_data = devm_kzalloc(ts->dev, HIMAX_HX83102J_FLASH_SIZE, GFP_KERNEL);
- if (!ts->himax_fw_data)
- return -ENOMEM;
-
- for (i = 0; i < flash_sz; i += page_sz) {
- ret = himax_mcu_register_read(ts, i, ts->himax_fw_data + i,
- (flash_sz - i) > page_sz ? page_sz : (flash_sz - i));
- if (ret < 0) {
- dev_err(ts->dev, "%s: read FW from flash fail!\n", __func__);
- return ret;
- }
+ dev_info(ts->dev, "%s: request file %s\n", __func__, ts->firmware_name);
+ ret = request_firmware(&ts->himax_fw, ts->firmware_name, ts->dev);
+ if (ret < 0) {
+ dev_err(ts->dev, "%s: request firmware failed, error code = %d\n", __func__, ret);
+ return;
}
- /* Search mapping table in 1k header */
- fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw_data,
+ /* Parse the mapping table in 1k header */
+ fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw->data,
ts, fw_bin_header_sz);
if (!fw_load_status) {
- dev_err(ts->dev, "%s: FW load status fail!\n", __func__);
- return -EINVAL;
+ dev_err(ts->dev, "%s: Failed to parse the mapping table!\n", __func__);
+ goto err_load_bin_descriptor;
}
- if (ts->fw_info_table.addr_hid_desc != 0) {
- memcpy(&ts->hid_desc,
- &ts->himax_fw_data[ts->fw_info_table.addr_hid_desc],
- sizeof(struct himax_hid_desc));
- ts->hid_desc.desc_length =
- le16_to_cpu(ts->hid_desc.desc_length);
- ts->hid_desc.bcd_version =
- le16_to_cpu(ts->hid_desc.bcd_version);
- ts->hid_desc.report_desc_length =
- le16_to_cpu(ts->hid_desc.report_desc_length);
- ts->hid_desc.max_input_length =
- le16_to_cpu(ts->hid_desc.max_input_length);
- ts->hid_desc.max_output_length =
- le16_to_cpu(ts->hid_desc.max_output_length);
- ts->hid_desc.max_fragment_length =
- le16_to_cpu(ts->hid_desc.max_fragment_length);
- ts->hid_desc.vendor_id =
- le16_to_cpu(ts->hid_desc.vendor_id);
- ts->hid_desc.product_id =
- le16_to_cpu(ts->hid_desc.product_id);
- ts->hid_desc.version_id =
- le16_to_cpu(ts->hid_desc.version_id);
- ts->hid_desc.flags =
- le16_to_cpu(ts->hid_desc.flags);
+ if (himax_update_fw(ts)) {
+ dev_err(ts->dev, "%s: Update FW fail\n", __func__);
+ goto err_update_fw_failed;
}
+ dev_info(ts->dev, "%s: Update FW success\n", __func__);
+ /* write flag to sram to stop fw reload again. */
+ if (himax_disable_fw_reload(ts))
+ goto err_disable_fw_reload;
+ if (himax_mcu_power_on_init(ts))
+ goto err_power_on_init;
+ /* get hid descriptors */
+ if (!ts->fw_info_table.addr_hid_desc) {
+ dev_err(ts->dev, "%s: No HID descriptor! Wrong FW!\n", __func__);
+ goto err_wrong_firmware;
+ }
+ memcpy(&ts->hid_desc,
+ &ts->himax_fw->data[ts->fw_info_table.addr_hid_desc],
+ sizeof(struct himax_hid_desc));
+ ts->hid_desc.desc_length =
+ le16_to_cpu(ts->hid_desc.desc_length);
+ ts->hid_desc.bcd_version =
+ le16_to_cpu(ts->hid_desc.bcd_version);
+ ts->hid_desc.report_desc_length =
+ le16_to_cpu(ts->hid_desc.report_desc_length);
+ ts->hid_desc.max_input_length =
+ le16_to_cpu(ts->hid_desc.max_input_length);
+ ts->hid_desc.max_output_length =
+ le16_to_cpu(ts->hid_desc.max_output_length);
+ ts->hid_desc.max_fragment_length =
+ le16_to_cpu(ts->hid_desc.max_fragment_length);
+ ts->hid_desc.vendor_id =
+ le16_to_cpu(ts->hid_desc.vendor_id);
+ ts->hid_desc.product_id =
+ le16_to_cpu(ts->hid_desc.product_id);
+ ts->hid_desc.version_id =
+ le16_to_cpu(ts->hid_desc.version_id);
+ ts->hid_desc.flags =
+ le16_to_cpu(ts->hid_desc.flags);
+
+ if (himax_mcu_tp_info_check(ts))
+ goto err_tp_info_failed;
+ if (himax_mcu_read_FW_ver(ts))
+ goto err_read_fw_ver;
if (himax_hid_rd_init(ts)) {
dev_err(ts->dev, "%s: hid rd init fail\n", __func__);
goto err_hid_rd_init_failed;
}
+ usleep_range(1000000, 1000100);
himax_hid_register(ts);
if (!ts->hid_probed) {
goto err_hid_probe_failed;
@@ -1486,19 +2481,28 @@ static int himax_load_config(struct himax_ts_data *ts)
}
}
- ts->himax_fw_data = NULL;
+ release_firmware(ts->himax_fw);
+ ts->himax_fw = NULL;
+
ts->ic_boot_done = true;
himax_int_enable(ts, true);
- return 0;
+ return;
err_report_data_init_failed:
himax_hid_remove(ts);
ts->hid_probed = false;
err_hid_probe_failed:
err_hid_rd_init_failed:
-
- return -EINVAL;
+err_read_fw_ver:
+err_tp_info_failed:
+err_wrong_firmware:
+err_power_on_init:
+err_disable_fw_reload:
+err_update_fw_failed:
+err_load_bin_descriptor:
+ release_firmware(ts->himax_fw);
+ ts->himax_fw = NULL;
}
/**
@@ -1550,12 +2554,22 @@ static void himax_ap_notify_fw_suspend(struct himax_ts_data *ts, bool suspend)
* @ts: Himax touch screen data
*
* This function is used to resume the touch screen. It will call the
+ * himax_zf_reload_from_file() to reload the firmware. And call the
* himax_ap_notify_fw_suspend() to notify the FW of AP resume status.
*
* Return: None
*/
static void himax_resume_proc(struct himax_ts_data *ts)
{
+ int ret;
+
+ ret = himax_zf_reload_from_file(ts->firmware_name, ts);
+ if (ret) {
+ dev_err(ts->dev, "%s: update FW fail, code[%d]!!\n", __func__, ret);
+ return;
+ }
+ ts->resume_succeeded = true;
+
himax_ap_notify_fw_suspend(ts, false);
}
@@ -1586,17 +2600,25 @@ static int himax_chip_suspend(struct himax_ts_data *ts)
* This function is used to resume the touch screen. It will set the resume
* success flag to false, and disable reset pin. Then call the himax_resume_proc()
* to process detailed resume procedure.
+ * If the resume action is succeeded, it will call the himax_hid_probe() to restore
+ * the HID device and enable the interrupt.
*
* Return: 0 on success, negative error code on failure
*/
static int himax_chip_resume(struct himax_ts_data *ts)
{
+ ts->resume_succeeded = false;
if (himax_power_set(ts, true))
return -EIO;
gpiod_set_value(ts->pdata.gpiod_rst, 0);
himax_resume_proc(ts);
- himax_hid_probe(ts);
- himax_int_enable(ts, true);
+ if (ts->resume_succeeded) {
+ himax_hid_probe(ts);
+ himax_int_enable(ts, true);
+ } else {
+ dev_err(ts->dev, "%s: resume failed!\n", __func__);
+ return -ECANCELED;
+ }
return 0;
}
@@ -1657,8 +2679,7 @@ static int himax_resume(struct device *dev)
* initialize interrupt lock, register the interrupt, and disable the
* interrupt. If later part of initialization succeed, then interrupt will
* be enabled.
- * It will also load the firmware from the flash, parse the HID info, and
- * register the HID device by calling the himax_load_config().
+ * And initialize varies flags, workqueue and delayed work for later use.
*
* Return: 0 on success, negative error code on failure
*/
@@ -1666,18 +2687,93 @@ static int himax_chip_init(struct himax_ts_data *ts)
{
int ret;
+ hx83102j_chip_init_data(ts);
if (himax_ts_register_interrupt(ts)) {
dev_err(ts->dev, "%s: register interrupt failed\n", __func__);
return -EIO;
}
himax_int_enable(ts, false);
- ret = himax_load_config(ts);
- if (ret < 0)
- return ret;
+ ts->zf_update_cfg_buffer = devm_kzalloc(ts->dev, ts->chip_max_dsram_size, GFP_KERNEL);
+ if (!ts->zf_update_cfg_buffer) {
+ ret = -ENOMEM;
+ goto err_update_cfg_buf_alloc_failed;
+ }
+ INIT_DELAYED_WORK(&ts->initial_work, himax_initial_work);
+ schedule_delayed_work(&ts->initial_work, msecs_to_jiffies(HIMAX_DELAY_BOOT_UPDATE_MS));
ts->initialized = true;
+ return 0;
+ cancel_delayed_work_sync(&ts->initial_work);
+err_update_cfg_buf_alloc_failed:
+
+ return ret;
+}
+
+/**
+ * himax_chip_deinit() - Deinitialize the Himax touch screen
+ * @ts: Himax touch screen data
+ *
+ * This function is used to deinitialize the Himax touch screen.
+ *
+ * Return: None
+ */
+static void himax_chip_deinit(struct himax_ts_data *ts)
+{
+ cancel_delayed_work_sync(&ts->initial_work);
+}
+
+#if defined(CONFIG_OF)
+/**
+ * himax_parse_dt() - Parse the device tree
+ * @dt: Device node
+ * @pdata: Himax platform data
+ *
+ * This function is used to parse the device tree. If "himax,pid" is found,
+ * it will parse the PID value and set it to the platform data. The firmware
+ * name will set to himax_i2chid_$PID.bin if the PID is found, or
+ * himax_i2chid.bin if the PID is not found.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int himax_parse_dt(struct device_node *dt, struct himax_platform_data *pdata)
+{
+ int err;
+ size_t fw_name_len;
+ const char *fw_name;
+ struct himax_ts_data *ts;
+
+ if (!dt || !pdata)
+ return -EINVAL;
+
+ ts = container_of(pdata, struct himax_ts_data, pdata);
+ /* Set default firmware name, without PID */
+ strscpy(ts->firmware_name, HIMAX_BOOT_UPGRADE_FWNAME HIMAX_FW_EXT_NAME,
+ sizeof(HIMAX_BOOT_UPGRADE_FWNAME HIMAX_FW_EXT_NAME));
+
+ if (of_property_read_bool(dt, "vccd-supply")) {
+ pdata->vccd_supply = regulator_get(ts->dev, "vccd");
+ if (IS_ERR(pdata->vccd_supply)) {
+ dev_err(ts->dev, "%s: DT:failed to get vccd supply\n", __func__);
+ err = PTR_ERR(pdata->vccd_supply);
+ pdata->vccd_supply = NULL;
+ return err;
+ }
+ dev_info(ts->dev, "%s: DT:vccd-supply=%p\n", __func__, pdata->vccd_supply);
+ } else {
+ pdata->vccd_supply = NULL;
+ }
+
+ if (of_property_read_string(dt, "firmware-name", &fw_name)) {
+ dev_info(ts->dev, "%s: DT:firmware-name not found\n", __func__);
+ } else {
+ fw_name_len = strlen(fw_name) + 1;
+ strscpy(ts->firmware_name, fw_name, min(sizeof(ts->firmware_name), fw_name_len));
+ dev_info(ts->dev, "%s: firmware-name = %s\n", __func__, ts->firmware_name);
+ }
+
return 0;
}
+#endif
/**
* __himax_initial_power_up() - Initial power up of the Himax touch screen
@@ -1895,6 +2991,13 @@ static int himax_spi_drv_probe(struct spi_device *spi)
dev_err(ts->dev, "%s: gpio-rst value is not valid\n", __func__);
return -EIO;
}
+#if defined(CONFIG_OF)
+ if (himax_parse_dt(spi->dev.of_node, pdata) < 0) {
+ dev_err(ts->dev, "%s: parse OF data failed!\n", __func__);
+ ts->dev = NULL;
+ return -ENODEV;
+ }
+#endif
spi->bits_per_word = 8;
spi->mode = SPI_MODE_3;
@@ -1925,6 +3028,7 @@ static int himax_spi_drv_probe(struct spi_device *spi)
spin_lock_init(&ts->irq_lock);
mutex_init(&ts->rw_lock);
mutex_init(&ts->reg_lock);
+ mutex_init(&ts->zf_update_lock);
dev_set_drvdata(&spi->dev, ts);
spi_set_drvdata(spi, ts);
@@ -1960,6 +3064,7 @@ static void himax_spi_drv_remove(struct spi_device *spi)
if (ts->hid_probed)
himax_hid_remove(ts);
}
+ himax_chip_deinit(ts);
himax_platform_deinit(ts);
}
}
diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h
index 45dc3e6283ae..e426ffdc4cf2 100644
--- a/drivers/hid/hid-himax.h
+++ b/drivers/hid/hid-himax.h
@@ -9,7 +9,9 @@
#define __HID_HIMAX_83102J_H__
#include <drm/drm_panel.h>
+#include <linux/crc32poly.h>
#include <linux/delay.h>
+#include <linux/firmware.h>
#include <linux/hid.h>
#include <linux/interrupt.h>
#include <linux/module.h>
@@ -41,6 +43,13 @@
HIMAX_BUS_W_HLEN + HIMAX_REG_SZ)
/* SPI CS setup time */
#define HIMAX_SPI_CS_SETUP_TIME 300
+/* Clear 4 bytes data */
+#define HIMAX_DATA_CLEAR 0x00000000
+/* boot update start delay */
+#define HIMAX_DELAY_BOOT_UPDATE_MS 2000
+#define HIMAX_TP_INFO_STR_LEN 12U
+#define HIMAX_ZF_PARTITION_AMOUNT_OFFSET 12
+#define HIMAX_ZF_PARTITION_DESC_SZ 16U
/* HIDRAW report header size */
#define HIMAX_HID_REPORT_HDR_SZ 2U
/* hx83102j IC parameters */
@@ -71,17 +80,48 @@
#define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01
#define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000
/* DSRAM flag addresses */
+#define HIMAX_DSRAM_ADDR_VENDOR 0x10007000
+#define HIMAX_DSRAM_ADDR_FW_VER 0x10007004
+#define HIMAX_DSRAM_ADDR_CUS_INFO 0x10007008
+#define HIMAX_DSRAM_ADDR_PROJ_INFO 0x10007014
+#define HIMAX_DSRAM_ADDR_CFG 0x10007084
+#define HIMAX_DSRAM_ADDR_INT_IS_EDGE 0x10007088
+#define HIMAX_DSRAM_ADDR_MKEY 0x100070e8
+#define HIMAX_DSRAM_ADDR_RXNUM_TXNUM 0x100070f4
+#define HIMAX_DSRAM_ADDR_MAXPT_XYRVS 0x100070f8
+#define HIMAX_DSRAM_ADDR_X_Y_RES 0x100070fc
+#define HIMAX_DSRAM_ADDR_STYLUS_FUNCTION 0x1000719c
+#define HIMAX_DSRAM_ADDR_STYLUS_VERSION 0x100071fc
+#define HIMAX_DSRAM_ADDR_SET_NFRAME 0x10007294
+#define HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD 0x100072c0
+#define HIMAX_DSRAM_ADDR_FLASH_RELOAD 0x10007f00
+#define HIMAX_DSRAM_ADDR_SORTING_MODE_EN 0x10007f04
+#define HIMAX_DSRAM_ADDR_DBG_MSG 0x10007f40
#define HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND 0x10007fd0
/* dsram flag data */
#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND 0xa55aa55a
#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME 0x00000000
+#define HIMAX_DSRAM_DATA_DISABLE_FLASH_RELOAD 0x00009aa9
+#define HIMAX_DSRAM_DATA_FW_RELOAD_DONE 0x000072c0
/* hx83102j-specific register/dsram flags/data */
+#define HIMAX_HX83102J_DSRAM_ADDR_RAW_OUT_SEL 0x100072ec
+#define HIMAX_HX83102J_REG_ADDR_HW_CRC 0x80010000
#define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004
+#define HIMAX_HX83102J_REG_DATA_HW_CRC 0x0000ecce
+#define HIMAX_HX83102J_REG_DATA_HW_CRC_DISABLE 0x00000000
/* hardware register addresses */
#define HIMAX_REG_ADDR_SPI200_DATA 0x8000002c
+#define HIMAX_REG_ADDR_RELOAD_STATUS 0x80050000
+#define HIMAX_REG_ADDR_RELOAD_CRC32_RESULT 0x80050018
+#define HIMAX_REG_ADDR_RELOAD_ADDR_FROM 0x80050020
+#define HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT 0x80050028
+#define HIMAX_REG_ADDR_SYSTEM_RESET 0x90000018
+#define HIMAX_REG_ADDR_RELOAD_TO_ACTIVE 0x90000048
#define HIMAX_REG_ADDR_CTRL_FW 0x9000005c
#define HIMAX_REG_ADDR_FW_STATUS 0x900000a8
#define HIMAX_REG_ADDR_ICID 0x900000d0
+#define HIMAX_REG_ADDR_RESET_FLAG 0x900000e4
+#define HIMAX_REG_ADDR_DD_STATUS 0x900000e8
/* hardware reg data/flags */
#define HIMAX_REG_DATA_FW_STATE_RUNNING 0x05
#define HIMAX_REG_DATA_FW_STATE_SAFE_MODE 0x0c
@@ -89,6 +129,9 @@
#define HIMAX_REG_DATA_FW_GO_SAFEMODE 0xa5
#define HIMAX_REG_DATA_FW_IN_SAFEMODE 0x87
#define HIMAX_REG_DATA_ICID 0x83102900
+#define HIMAX_REG_DATA_RELOAD_DONE 0x01
+#define HIMAX_REG_DATA_RELOAD_PASSWORD 0x99
+#define HIMAX_REG_DATA_SYSTEM_RESET 0x00000055
#define HIMAX_REG_DATA_TCON_RST 0x00000000
/* HIMAX SPI function select, 1st byte of any SPI command sequence */
#define HIMAX_SPI_FUNCTION_READ 0xf3
@@ -100,6 +143,8 @@
#define HIMAX_CFG_VER 0x10000600
#define HIMAX_HID_TABLE 0x30000100
#define HIMAX_FW_BIN_DESC 0x10000000
+#define HIMAX_BOOT_UPGRADE_FWNAME "himax_i2chid"
+#define HIMAX_FW_EXT_NAME ".bin"
/**
* enum himax_hidraw_id_function - HIDRAW report IDs
@@ -119,6 +164,20 @@ enum himax_touch_report_status {
HIMAX_TS_SUCCESS = 0,
};
+/**
+ * struct himax_zf_info - Zero flash update information
+ * @sram_addr: SRAM address byte array buffer
+ * @write_size: Write size of each chunk
+ * @fw_addr: Offset in firmware file
+ * @cfg_addr: target sram address
+ */
+struct himax_zf_info {
+ u8 sram_addr[4];
+ int write_size;
+ u32 fw_addr;
+ u32 cfg_addr;
+};
+
/**
* struct himax_fw_address_table - address/offset in firmware image
* @addr_fw_ver_major: Address to Major version of firmware
@@ -170,9 +229,21 @@ union himax_dword_data {
/**
* struct himax_ic_data - IC information holder
* @stylus_ratio: Stylus ratio
+ * @vendor_cus_info: Vendor customer information
+ * @vendor_proj_info: Vendor project information
+ * @vendor_fw_ver: Vendor firmware version
+ * @vendor_config_ver: Vendor config version
+ * @vendor_touch_cfg_ver: Vendor touch config version
+ * @vendor_display_cfg_ver: Vendor display config version
+ * @vendor_cid_maj_ver: Vendor CID major version
+ * @vendor_cid_min_ver: Vendor CID minor version
+ * @vendor_panel_ver: Vendor panel version
+ * @vendor_sensor_id: Vendor sensor ID
* @rx_num: Number of RX
* @tx_num: Number of TX
* @button_num: Number of buttons
+ * @x_res: X resolution
+ * @y_res: Y resolution
* @max_point: Maximum touch point
* @icid: IC ID
* @interrupt_is_edge: Interrupt is edge otherwise level
@@ -181,9 +252,21 @@ union himax_dword_data {
*/
struct himax_ic_data {
u8 stylus_ratio;
+ u8 vendor_cus_info[12];
+ u8 vendor_proj_info[12];
+ int vendor_fw_ver;
+ int vendor_config_ver;
+ int vendor_touch_cfg_ver;
+ int vendor_display_cfg_ver;
+ int vendor_cid_maj_ver;
+ int vendor_cid_min_ver;
+ int vendor_panel_ver;
+ int vendor_sensor_id;
u32 rx_num;
u32 tx_num;
u32 button_num;
+ u32 x_res;
+ u32 y_res;
u32 max_point;
u32 icid;
bool interrupt_is_edge;
@@ -191,6 +274,38 @@ struct himax_ic_data {
bool stylus_v2;
};
+/**
+ * struct himax_bin_desc - Firmware binary descriptor
+ * @passwd: Password to indicate the binary is valid
+ * @cid: Customer ID
+ * @panel_ver: Panel version
+ * @fw_ver: Firmware version
+ * @ic_sign: IC signature
+ * @customer: Customer name
+ * @project: Project name
+ * @fw_major: Major version of firmware
+ * @fw_minor: Minor version of firmware
+ * @date: Generate date of firmware
+ * @ic_sign_2: IC signature 2
+ *
+ * This structure is used to hold the firmware binary descriptor.
+ * It directly maps to a sequence of bytes in firmware image,
+ * thus need to be packed.
+ */
+struct himax_bin_desc {
+ u16 passwd;
+ u16 cid;
+ u8 panel_ver;
+ u16 fw_ver;
+ u8 ic_sign;
+ char customer[12];
+ char project[12];
+ char fw_major[12];
+ char fw_minor[12];
+ char date[12];
+ char ic_sign_2[12];
+} __packed;
+
/**
* struct himax_hid_desc - HID descriptor
* @desc_length: Length of HID descriptor
@@ -223,6 +338,39 @@ struct himax_hid_desc {
u32 reserved;
} __packed;
+/**
+ * struct himax_hid_info - IC information holder for HIDRAW function
+ * @vid: Vendor ID
+ * @pid: Product ID
+ * @cfg_info: Configuration information
+ * @cfg_version: Configuration version
+ * @disp_version: Display version
+ * @rx: Number of RX
+ * @tx: Number of TX
+ * @y_res: Y resolution
+ * @x_res: X resolution
+ * @pt_num: Number of touch points
+ * @mkey_num: Number of mkey
+ * @debug_info: Debug information
+ *
+ * This structure is used to hold the IC config information for HIDRAW.
+ * The format is binary fixed, thus need to be packed.
+ */
+struct himax_hid_info {
+ u16 vid;
+ u16 pid;
+ u8 cfg_info[32];
+ u8 cfg_version;
+ u8 disp_version;
+ u8 rx;
+ u8 tx;
+ u16 y_res;
+ u16 x_res;
+ u8 pt_num;
+ u8 mkey_num;
+ u8 debug_info[78];
+} __packed;
+
/**
* struct himax_platform_data - Platform data holder
* @is_panel_follower: Is panel follower enabled
@@ -244,8 +392,9 @@ struct himax_platform_data {
* @xfer_buf: Interrupt data buffer
* @xfer_rx_data: SPI Transfer receive data buffer
* @xfer_tx_data: SPI Transfer transmit data buffer
- * @himax_fw_data: Firmware data holder from flash
+ * @zf_update_cfg_buffer: Zero flash update configuration buffer
* @himax_irq: IRQ number
+ * @chip_max_dsram_size: Maximum size of DSRAM
* @spi_xfer_max_sz: Size of SPI controller max transfer size
* @xfer_buf_sz: Size of interrupt data buffer
* @irq_state: IRQ state
@@ -254,24 +403,30 @@ struct himax_platform_data {
* @probe_finish: Indicate the driver probe is finished
* @ic_boot_done: Indicate the IC boot is done
* @hid_probed: Indicate the HID device is probed
+ * @resume_succeeded: Indicate the resume is succeeded
+ * @firmware_name: Firmware name
* @touch_data_sz: Size of each interrupt data from IC
+ * @himax_fw: Firmware data holder from user space
* @dev: Device pointer
* @spi: SPI device pointer
* @hid: HID device pointer
* @reg_lock: Mutex lock for reg access
* @rw_lock: Mutex lock for read/write action
+ * @zf_update_lock: Mutex lock for zero-flash FW update
* @ic_data: IC information holder
* @pdata: Platform data holder
* @fw_info_table: Firmware information address table of firmware image
* @hid_desc: HID descriptor
* @hid_rd_data: HID report descriptor data
+ * @initial_work: Delayed work for TP initialization
*/
struct himax_ts_data {
u8 *xfer_buf;
u8 *xfer_rx_data;
u8 *xfer_tx_data;
- u8 *himax_fw_data;
+ u8 *zf_update_cfg_buffer;
s32 himax_irq;
+ u32 chip_max_dsram_size;
u32 spi_xfer_max_sz;
u32 xfer_buf_sz;
atomic_t irq_state;
@@ -281,7 +436,11 @@ struct himax_ts_data {
bool probe_finish;
bool ic_boot_done;
bool hid_probed;
+ bool resume_succeeded;
+ bool zf_update_flag;
+ char firmware_name[64];
int touch_data_sz;
+ const struct firmware *himax_fw;
struct device *dev;
struct spi_device *spi;
struct hid_device *hid;
@@ -289,10 +448,13 @@ struct himax_ts_data {
struct mutex reg_lock;
/* lock for bus read/write action */
struct mutex rw_lock;
+ /* lock for zero-flash FW update */
+ struct mutex zf_update_lock;
struct himax_ic_data ic_data;
struct himax_platform_data pdata;
struct himax_fw_address_table fw_info_table;
struct himax_hid_desc hid_desc;
struct himax_hid_rd_data hid_rd_data;
+ struct delayed_work initial_work;
};
#endif
--
2.34.1
^ permalink raw reply related
* [PATCH v4 0/4] Add a property to turn off the max touch controller if not used
From: Stefan Eichenberger @ 2024-04-17 9:05 UTC (permalink / raw)
To: nick, dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor+dt,
nicolas.ferre, alexandre.belloni, claudiu.beznea, linus.walleij
Cc: linux-input, devicetree, linux-arm-kernel, linux-kernel
Our hardware has a shared regulator that powers various peripherals such
as the display, touch, USB hub, etc. Since the Maxtouch controller
doesn't currently allow it to be turned off, this regulator has to stay
on when not used. This increases the overall power consumption. In order
to turn off the controller when the system does not use it, this series
adds a device tree property to the maxtouch driver that allows the
controller to be turned off completely and ensurs that it can resume
from the power off state.
Changes since v3:
- Move the power on part to mxt_start and the power off part to
mxt_stop. This allows to turn the touch controller off even when not
in use and not only when being suspended (Dmitry)
Changes since v2:
- Add Reviewed-by tags from Linus and Krzysztof to the dt-bindings patch
Changes since v1:
- Rename the property and change the description (Krzysztof, Linus,
Dmitry, Conor)
Stefan Eichenberger (4):
Input: atmel_mxt_ts - add power off and power on functions
Input: atmel_mxt_ts - move calls to register the input device to
separate function
dt-bindings: input: atmel,maxtouch: add poweroff-sleep property
Input: atmel_mxt_ts - add support for poweroff-sleep
.../bindings/input/atmel,maxtouch.yaml | 6 +
drivers/input/touchscreen/atmel_mxt_ts.c | 162 +++++++++++++-----
2 files changed, 124 insertions(+), 44 deletions(-)
--
2.40.1
^ permalink raw reply
* [PATCH v4 1/4] Input: atmel_mxt_ts - add power off and power on functions
From: Stefan Eichenberger @ 2024-04-17 9:05 UTC (permalink / raw)
To: nick, dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor+dt,
nicolas.ferre, alexandre.belloni, claudiu.beznea, linus.walleij
Cc: linux-input, devicetree, linux-arm-kernel, linux-kernel,
Stefan Eichenberger
In-Reply-To: <20240417090527.15357-1-eichest@gmail.com>
From: Stefan Eichenberger <stefan.eichenberger@toradex.com>
Add a separate function for power off and power on instead of calling
regulator_bulk_enable and regulator_bulk_disable directly.
Signed-off-by: Stefan Eichenberger <stefan.eichenberger@toradex.com>
---
drivers/input/touchscreen/atmel_mxt_ts.c | 59 +++++++++++++++---------
1 file changed, 37 insertions(+), 22 deletions(-)
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 542a31448c8f..52867ce3b9b6 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -1307,6 +1307,38 @@ static int mxt_soft_reset(struct mxt_data *data)
return 0;
}
+static int mxt_power_on(struct mxt_data *data)
+{
+ int error;
+
+ error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
+ data->regulators);
+ if (error) {
+ dev_err(&data->client->dev, "failed to enable regulators: %d\n",
+ error);
+ return error;
+ }
+
+ msleep(MXT_BACKUP_TIME);
+
+ if (data->reset_gpio) {
+ /* Wait a while and then de-assert the RESET GPIO line */
+ msleep(MXT_RESET_GPIO_TIME);
+ gpiod_set_value(data->reset_gpio, 0);
+ msleep(MXT_RESET_INVALID_CHG);
+ }
+
+ return 0;
+}
+
+static void mxt_power_off(struct mxt_data *data)
+{
+ if (data->reset_gpio)
+ gpiod_set_value(data->reset_gpio, 1);
+
+ regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators);
+}
+
static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
{
/*
@@ -3305,25 +3337,9 @@ static int mxt_probe(struct i2c_client *client)
return error;
}
- error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
- data->regulators);
- if (error) {
- dev_err(&client->dev, "failed to enable regulators: %d\n",
- error);
+ error = mxt_power_on(data);
+ if (error)
return error;
- }
- /*
- * The device takes 40ms to come up after power-on according
- * to the mXT224 datasheet, page 13.
- */
- msleep(MXT_BACKUP_TIME);
-
- if (data->reset_gpio) {
- /* Wait a while and then de-assert the RESET GPIO line */
- msleep(MXT_RESET_GPIO_TIME);
- gpiod_set_value(data->reset_gpio, 0);
- msleep(MXT_RESET_INVALID_CHG);
- }
/*
* Controllers like mXT1386 have a dedicated WAKE line that could be
@@ -3361,8 +3377,8 @@ static int mxt_probe(struct i2c_client *client)
mxt_free_input_device(data);
mxt_free_object_table(data);
err_disable_regulators:
- regulator_bulk_disable(ARRAY_SIZE(data->regulators),
- data->regulators);
+ mxt_power_off(data);
+
return error;
}
@@ -3374,8 +3390,7 @@ static void mxt_remove(struct i2c_client *client)
sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
mxt_free_input_device(data);
mxt_free_object_table(data);
- regulator_bulk_disable(ARRAY_SIZE(data->regulators),
- data->regulators);
+ mxt_power_off(data);
}
static int mxt_suspend(struct device *dev)
--
2.40.1
^ permalink raw reply related
* [PATCH v4 2/4] Input: atmel_mxt_ts - move calls to register the input device to separate function
From: Stefan Eichenberger @ 2024-04-17 9:05 UTC (permalink / raw)
To: nick, dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor+dt,
nicolas.ferre, alexandre.belloni, claudiu.beznea, linus.walleij
Cc: linux-input, devicetree, linux-arm-kernel, linux-kernel,
Stefan Eichenberger
In-Reply-To: <20240417090527.15357-1-eichest@gmail.com>
From: Stefan Eichenberger <stefan.eichenberger@toradex.com>
The calls to register the input device are moved to a separate function
so that we can call it without having to confiugre the device. This is
necessary if we want to power on the device only when it is opened.
Signed-off-by: Stefan Eichenberger <stefan.eichenberger@toradex.com>
---
drivers/input/touchscreen/atmel_mxt_ts.c | 34 +++++++++++++++++-------
1 file changed, 25 insertions(+), 9 deletions(-)
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 52867ce3b9b6..7c807d1f1f9b 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -2277,6 +2277,28 @@ static void mxt_config_cb(const struct firmware *cfg, void *ctx)
release_firmware(cfg);
}
+static void mxt_debug_init(struct mxt_data *data);
+
+static int mxt_device_register(struct mxt_data *data)
+{
+ int error;
+
+ /* If input device is not already registered */
+ if (!data->input_dev) {
+ if (data->multitouch) {
+ error = mxt_initialize_input_device(data);
+ if (error)
+ return error;
+ } else {
+ dev_warn(&data->client->dev, "No touch object detected\n");
+ }
+
+ mxt_debug_init(data);
+ }
+
+ return 0;
+}
+
static int mxt_initialize(struct mxt_data *data)
{
struct i2c_client *client = data->client;
@@ -2831,15 +2853,9 @@ static int mxt_configure_objects(struct mxt_data *data,
dev_warn(dev, "Error %d updating config\n", error);
}
- if (data->multitouch) {
- error = mxt_initialize_input_device(data);
- if (error)
- return error;
- } else {
- dev_warn(dev, "No touch object detected\n");
- }
-
- mxt_debug_init(data);
+ error = mxt_device_register(data);
+ if (error)
+ return error;
return 0;
}
--
2.40.1
^ permalink raw reply related
* [PATCH v4 3/4] dt-bindings: input: atmel,maxtouch: add poweroff-sleep property
From: Stefan Eichenberger @ 2024-04-17 9:05 UTC (permalink / raw)
To: nick, dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor+dt,
nicolas.ferre, alexandre.belloni, claudiu.beznea, linus.walleij
Cc: linux-input, devicetree, linux-arm-kernel, linux-kernel,
Stefan Eichenberger, Krzysztof Kozlowski
In-Reply-To: <20240417090527.15357-1-eichest@gmail.com>
From: Stefan Eichenberger <stefan.eichenberger@toradex.com>
Add a new property to indicate that the device should power off rather
than use deep sleep. Deep sleep is a feature of the controller that
expects the controller to remain powered in suspend. However, if a
display shares its regulator with the touch controller, we may want to
do a power off so that the display and touch controller do not use any
power.
Signed-off-by: Stefan Eichenberger <stefan.eichenberger@toradex.com>
Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
---
Documentation/devicetree/bindings/input/atmel,maxtouch.yaml | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/Documentation/devicetree/bindings/input/atmel,maxtouch.yaml b/Documentation/devicetree/bindings/input/atmel,maxtouch.yaml
index c40799355ed7..8de5f539b30e 100644
--- a/Documentation/devicetree/bindings/input/atmel,maxtouch.yaml
+++ b/Documentation/devicetree/bindings/input/atmel,maxtouch.yaml
@@ -87,6 +87,12 @@ properties:
- 2 # ATMEL_MXT_WAKEUP_GPIO
default: 0
+ atmel,poweroff-sleep:
+ description: |
+ Instead of using the deep sleep feature of the maXTouch controller,
+ poweroff the regulators.
+ type: boolean
+
wakeup-source:
type: boolean
--
2.40.1
^ permalink raw reply related
* [PATCH v4 4/4] Input: atmel_mxt_ts - add support for poweroff-sleep
From: Stefan Eichenberger @ 2024-04-17 9:05 UTC (permalink / raw)
To: nick, dmitry.torokhov, robh, krzysztof.kozlowski+dt, conor+dt,
nicolas.ferre, alexandre.belloni, claudiu.beznea, linus.walleij
Cc: linux-input, devicetree, linux-arm-kernel, linux-kernel,
Stefan Eichenberger
In-Reply-To: <20240417090527.15357-1-eichest@gmail.com>
From: Stefan Eichenberger <stefan.eichenberger@toradex.com>
Add support for poweroff-sleep to the Atmel maXTouch driver. This allows
us to power off the input device entirely and only power it on when it
is opened. This will also automatically power it off when we suspend the
system.
Signed-off-by: Stefan Eichenberger <stefan.eichenberger@toradex.com>
---
drivers/input/touchscreen/atmel_mxt_ts.c | 71 +++++++++++++++++++-----
1 file changed, 57 insertions(+), 14 deletions(-)
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 7c807d1f1f9b..f92808be3f5b 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -317,6 +317,7 @@ struct mxt_data {
struct gpio_desc *reset_gpio;
struct gpio_desc *wake_gpio;
bool use_retrigen_workaround;
+ bool poweroff_sleep;
/* Cached parameters from object table */
u16 T5_address;
@@ -2277,6 +2278,19 @@ static void mxt_config_cb(const struct firmware *cfg, void *ctx)
release_firmware(cfg);
}
+static int mxt_initialize_after_resume(struct mxt_data *data)
+{
+ const struct firmware *fw;
+
+ mxt_acquire_irq(data);
+
+ firmware_request_nowarn(&fw, MXT_CFG_NAME, &data->client->dev);
+
+ mxt_config_cb(fw, data);
+
+ return 0;
+}
+
static void mxt_debug_init(struct mxt_data *data);
static int mxt_device_register(struct mxt_data *data)
@@ -2341,17 +2355,23 @@ static int mxt_initialize(struct mxt_data *data)
if (error)
return error;
- error = mxt_acquire_irq(data);
- if (error)
- return error;
+ if (data->poweroff_sleep) {
+ error = mxt_device_register(data);
+ if (error)
+ return error;
+ } else {
+ error = mxt_acquire_irq(data);
+ if (error)
+ return error;
- error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
- &client->dev, GFP_KERNEL, data,
- mxt_config_cb);
- if (error) {
- dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
- error);
- return error;
+ error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
+ &client->dev, GFP_KERNEL, data,
+ mxt_config_cb);
+ if (error) {
+ dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
+ error);
+ return error;
+ }
}
return 0;
@@ -3089,6 +3109,9 @@ static ssize_t mxt_update_fw_store(struct device *dev,
struct mxt_data *data = dev_get_drvdata(dev);
int error;
+ if (data->poweroff_sleep && !data->in_bootloader)
+ mxt_power_on(data);
+
error = mxt_load_fw(dev, MXT_FW_NAME);
if (error) {
dev_err(dev, "The firmware update failed(%d)\n", error);
@@ -3101,6 +3124,9 @@ static ssize_t mxt_update_fw_store(struct device *dev,
return error;
}
+ if (data->poweroff_sleep && !data->in_bootloader)
+ mxt_power_off(data);
+
return count;
}
@@ -3123,7 +3149,12 @@ static const struct attribute_group mxt_attr_group = {
static void mxt_start(struct mxt_data *data)
{
- mxt_wakeup_toggle(data->client, true, false);
+ if (data->poweroff_sleep) {
+ mxt_power_on(data);
+ mxt_initialize_after_resume(data);
+ } else {
+ mxt_wakeup_toggle(data->client, true, false);
+ }
switch (data->suspend_mode) {
case MXT_SUSPEND_T9_CTRL:
@@ -3160,7 +3191,12 @@ static void mxt_stop(struct mxt_data *data)
break;
}
- mxt_wakeup_toggle(data->client, false, false);
+ if (data->poweroff_sleep) {
+ disable_irq(data->irq);
+ mxt_power_off(data);
+ } else {
+ mxt_wakeup_toggle(data->client, false, false);
+ }
}
static int mxt_input_open(struct input_dev *dev)
@@ -3357,6 +3393,8 @@ static int mxt_probe(struct i2c_client *client)
if (error)
return error;
+ data->poweroff_sleep = device_property_read_bool(&client->dev,
+ "atmel,poweroff-sleep");
/*
* Controllers like mXT1386 have a dedicated WAKE line that could be
* connected to a GPIO or to I2C SCL pin, or permanently asserted low.
@@ -3387,6 +3425,9 @@ static int mxt_probe(struct i2c_client *client)
goto err_free_object;
}
+ if (data->poweroff_sleep && !data->in_bootloader)
+ mxt_power_off(data);
+
return 0;
err_free_object:
@@ -3406,7 +3447,8 @@ static void mxt_remove(struct i2c_client *client)
sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
mxt_free_input_device(data);
mxt_free_object_table(data);
- mxt_power_off(data);
+ if (!data->poweroff_sleep)
+ mxt_power_off(data);
}
static int mxt_suspend(struct device *dev)
@@ -3439,7 +3481,8 @@ static int mxt_resume(struct device *dev)
if (!input_dev)
return 0;
- enable_irq(data->irq);
+ if (!data->poweroff_sleep)
+ enable_irq(data->irq);
mutex_lock(&input_dev->mutex);
--
2.40.1
^ permalink raw reply related
* RE: [PATCH v4 0/4] Add a property to turn off the max touch controller if not used
From: Joao Paulo Goncalves @ 2024-04-17 11:12 UTC (permalink / raw)
To: eichest
Cc: alexandre.belloni, claudiu.beznea, conor+dt, devicetree,
dmitry.torokhov, krzysztof.kozlowski+dt, linus.walleij,
linux-arm-kernel, linux-input, linux-kernel, nick, nicolas.ferre,
robh, Joao Paulo Goncalves
In-Reply-To: <20240417090527.15357-1-eichest@gmail.com>
> Our hardware has a shared regulator that powers various peripherals such
> as the display, touch, USB hub, etc. Since the Maxtouch controller
> doesn't currently allow it to be turned off, this regulator has to stay
> on when not used. This increases the overall power consumption. In order
> to turn off the controller when the system does not use it, this series
> adds a device tree property to the maxtouch driver that allows the
> controller to be turned off completely and ensurs that it can resume
> from the power off state.
>
> Changes since v3:
> - Move the power on part to mxt_start and the power off part to
> mxt_stop. This allows to turn the touch controller off even when not
> in use and not only when being suspended (Dmitry)
>
> Changes since v2:
> - Add Reviewed-by tags from Linus and Krzysztof to the dt-bindings patch
>
> Changes since v1:
> - Rename the property and change the description (Krzysztof, Linus,
> Dmitry, Conor)
>
> Stefan Eichenberger (4):
> Input: atmel_mxt_ts - add power off and power on functions
> Input: atmel_mxt_ts - move calls to register the input device to
> separate function
> dt-bindings: input: atmel,maxtouch: add poweroff-sleep property
> Input: atmel_mxt_ts - add support for poweroff-sleep
>
> .../bindings/input/atmel,maxtouch.yaml | 6 +
> drivers/input/touchscreen/atmel_mxt_ts.c | 162 +++++++++++++-----
> 2 files changed, 124 insertions(+), 44 deletions(-)
>
> --
> 2.40.1
>
Reviewed-by: Joao Paulo Goncalves <joao.goncalves@toradex.com>
Regards,
Joao Paulo
^ permalink raw reply
* Re: [PATCH 00/19] amba: store owner from modules with amba_driver_register()
From: Krzysztof Kozlowski @ 2024-04-17 13:29 UTC (permalink / raw)
To: Suzuki K Poulose, Russell King, Mike Leach, James Clark,
Alexander Shishkin, Maxime Coquelin, Alexandre Torgue,
Linus Walleij, Andi Shyti, Olivia Mackall, Herbert Xu, Vinod Koul,
Dmitry Torokhov, Miquel Raynal, Michal Simek, Eric Auger,
Alex Williamson, Greg Kroah-Hartman
Cc: linux-kernel, coresight, linux-arm-kernel, linux-stm32, linux-i2c,
linux-crypto, dmaengine, linux-input, kvm
In-Reply-To: <8a8a8e8b-8256-4d33-a39b-9e3cbc4ccff2@arm.com>
On 16/04/2024 12:41, Suzuki K Poulose wrote:
> + Greg
>
>
> Hi Krzysztof,
>
> On 30/03/2024 18:00, Krzysztof Kozlowski wrote:
>> On 30/03/2024 18:58, Krzysztof Kozlowski wrote:
>>>
>>> On Tue, 26 Mar 2024 21:23:30 +0100, Krzysztof Kozlowski wrote:
>>>> Merging
>>>> =======
>>>> All further patches depend on the first amba patch, therefore please ack
>>>> and this should go via one tree.
>>>>
>>>> Description
>>>> ===========
>>>> Modules registering driver with amba_driver_register() often forget to
>>>> set .owner field.
>>>>
>>>> [...]
>>>
>>> Applied, thanks!
>>>
>>> [01/19] amba: store owner from modules with amba_driver_register()
>>> (no commit info)
>>
>> Patchset applied here:
>> https://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux-dt.git/log/?h=for-v6.10/module-owner-amba
>
> How do you plan to push this ? Given this affects most of the drivers/,
> do you plan to send this to Greg ? We have changes in the coresight
> tree that would conflict with this "tag" ( I haven't merged them yet,
> but is in my local queue). I want to make sure we can avoid the
> conflicts. I am happy to merge this to my local tree and base the
> changes on this, if this is going in for v6.10 and all are in agreement.
I pushed it to arm-linux patches but it hasn't been picked up.
I propose you take entire set then.
Best regards,
Krzysztof
^ permalink raw reply
* Re: [PATCH 00/19] amba: store owner from modules with amba_driver_register()
From: Russell King (Oracle) @ 2024-04-17 13:50 UTC (permalink / raw)
To: Krzysztof Kozlowski
Cc: Suzuki K Poulose, Mike Leach, James Clark, Alexander Shishkin,
Maxime Coquelin, Alexandre Torgue, Linus Walleij, Andi Shyti,
Olivia Mackall, Herbert Xu, Vinod Koul, Dmitry Torokhov,
Miquel Raynal, Michal Simek, Eric Auger, Alex Williamson,
Greg Kroah-Hartman, linux-kernel, coresight, linux-arm-kernel,
linux-stm32, linux-i2c, linux-crypto, dmaengine, linux-input, kvm
In-Reply-To: <4e762eb1-864e-4bb5-ab5d-debeac19c8fa@linaro.org>
On Wed, Apr 17, 2024 at 03:29:26PM +0200, Krzysztof Kozlowski wrote:
> On 16/04/2024 12:41, Suzuki K Poulose wrote:
> > + Greg
> >
> >
> > Hi Krzysztof,
> >
> > On 30/03/2024 18:00, Krzysztof Kozlowski wrote:
> >> On 30/03/2024 18:58, Krzysztof Kozlowski wrote:
> >>>
> >>> On Tue, 26 Mar 2024 21:23:30 +0100, Krzysztof Kozlowski wrote:
> >>>> Merging
> >>>> =======
> >>>> All further patches depend on the first amba patch, therefore please ack
> >>>> and this should go via one tree.
> >>>>
> >>>> Description
> >>>> ===========
> >>>> Modules registering driver with amba_driver_register() often forget to
> >>>> set .owner field.
> >>>>
> >>>> [...]
> >>>
> >>> Applied, thanks!
> >>>
> >>> [01/19] amba: store owner from modules with amba_driver_register()
> >>> (no commit info)
> >>
> >> Patchset applied here:
> >> https://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux-dt.git/log/?h=for-v6.10/module-owner-amba
> >
> > How do you plan to push this ? Given this affects most of the drivers/,
> > do you plan to send this to Greg ? We have changes in the coresight
> > tree that would conflict with this "tag" ( I haven't merged them yet,
> > but is in my local queue). I want to make sure we can avoid the
> > conflicts. I am happy to merge this to my local tree and base the
> > changes on this, if this is going in for v6.10 and all are in agreement.
>
> I pushed it to arm-linux patches but it hasn't been picked up.
>
> I propose you take entire set then.
You are again being, IMHO, abrasive with your attitude. So far, every
interaction with you has been abrasive and bordering on abusive.
You haven't asked me whether I will take them. I will - just not at the
moment because
I HAVE MEDICAL APPOINTMENTS LAST WEEK AND THIS WEEK WHICH MEAN I AM
NOT SPENDING ALL MY TIME ON THE KERNEL.
Have some bloody patience rather than behaving in your standard
objectionable manner.
--
RMK's Patch system: https://www.armlinux.org.uk/developer/patches/
FTTP is here! 80Mbps down 10Mbps up. Decent connectivity at last!
^ permalink raw reply
* Re: [PATCH] HID: hid-steam: Add Deck IMU support
From: Max Maisel @ 2024-04-17 16:56 UTC (permalink / raw)
To: vi
Cc: benjamin.tissoires, jikos, linux-input, linux-kernel, mmm-1,
rodrigorivascosta
In-Reply-To: <0a92f4da-9517-4c12-a265-eb06f909f18b@endrift.com>
On Mon, 15. Apr 2024, Vicki Pfau wrote:
> Hi,
>
> On 4/12/24 4:42 AM, Jiri Kosina wrote:
>> On Sun, 7 Apr 2024, Max Maisel wrote:
>>
>>> The Deck's controller features an accelerometer and gyroscope which
>>> send their measurement values by default in the main HID input report.
>>> Expose both sensors to userspace through a separate evdev node as it
>>> is done by the hid-nintendo and hid-playstation drivers.
>>>
>>> Signed-off-by: Max Maisel <mmm-1@posteo.net>
>>
>> CCing Rodrigo and Vicki ... could you please take a look and Ack the patch
>> below from Max?
>>
>> Thanks.
>>
>>> ---
>>>
>>> This patch was tested on a Steam Deck running Arch Linux. With it,
>>> applications using latest SDL2/3 git libraries will pick up the sensors
>>> without hidraw access. This was tested against the antimicrox gamepad mapper.
>>>
>>> Measurement value scaling was tested by moving the deck and a dualsense
>>> controller simultaneously and comparing their reported values in
>>> userspace with SDL3's testcontroller tool.
>>>
>>> drivers/hid/hid-steam.c | 158 ++++++++++++++++++++++++++++++++++++++--
>>> 1 file changed, 150 insertions(+), 8 deletions(-)
>>>
>>> diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c
>>> index b08a5ab58528..af6e6c3b1356 100644
>>> --- a/drivers/hid/hid-steam.c
>>> +++ b/drivers/hid/hid-steam.c
>>> @@ -66,6 +66,12 @@ static LIST_HEAD(steam_devices);
>>> #define STEAM_DECK_TRIGGER_RESOLUTION 5461
>>> /* Joystick runs are about 5 mm and 32768 units */
>>> #define STEAM_DECK_JOYSTICK_RESOLUTION 6553
>>> +/* Accelerometer has 16 bit resolution and a range of +/- 2g */
>>> +#define STEAM_DECK_ACCEL_RES_PER_G 16384
>>> +#define STEAM_DECK_ACCEL_RANGE 32768
>>> +/* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */
>>> +#define STEAM_DECK_GYRO_RES_PER_DPS 16
>>> +#define STEAM_DECK_GYRO_RANGE 32000
>
> This value looks strange. How do you know it's not supposed to be 32768?
The "input-programming" documentation mentioned that the device must be able to
reach its min and max values so I subtracted a little bit from the 32768.
But with this in mind, the accelerometer max value looks wrong.
If you agree, I would change it to 32768 since the playstation and nintendo
IMU drivers use powers of two derived maximum values as well.
>>>
>>> #define STEAM_PAD_FUZZ 256
>>>
>>> @@ -288,6 +294,7 @@ struct steam_device {
>>> struct mutex report_mutex;
>>> unsigned long client_opened;
>>> struct input_dev __rcu *input;
>>> + struct input_dev __rcu *sensors;
>>> unsigned long quirks;
>>> struct work_struct work_connect;
>>> bool connected;
>>> @@ -302,6 +309,7 @@ struct steam_device {
>>> struct work_struct rumble_work;
>>> u16 rumble_left;
>>> u16 rumble_right;
>>> + unsigned int sensor_timestamp_us;
>>> };
>>>
>>> static int steam_recv_report(struct steam_device *steam,
>>> @@ -825,6 +833,74 @@ static int steam_input_register(struct steam_device *steam)
>>> return ret;
>>> }
>>>
>>> +static int steam_sensors_register(struct steam_device *steam)
>>> +{
>>> + struct hid_device *hdev = steam->hdev;
>>> + struct input_dev *sensors;
>>> + int ret;
>>> +
>>> + if (!(steam->quirks & STEAM_QUIRK_DECK))
>>> + return 0;
>>> +
>>> + rcu_read_lock();
>>> + sensors = rcu_dereference(steam->sensors);
>>> + rcu_read_unlock();
>>> + if (sensors) {
>>> + dbg_hid("%s: already connected\n", __func__);
>>> + return 0;
>>> + }
>>> +
>>> + sensors = input_allocate_device();
>>> + if (!sensors)
>>> + return -ENOMEM;
>>> +
>>> + input_set_drvdata(sensors, steam);
>>> + sensors->dev.parent = &hdev->dev;
>>> +
>>> + sensors->name = "Steam Deck Motion Sensors";
>>> + sensors->phys = hdev->phys;
>>> + sensors->uniq = steam->serial_no;
>>> + sensors->id.bustype = hdev->bus;
>>> + sensors->id.vendor = hdev->vendor;
>>> + sensors->id.product = hdev->product;
>>> + sensors->id.version = hdev->version;
>>> +
>>> + __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);
>>> + __set_bit(EV_MSC, sensors->evbit);
>>> + __set_bit(MSC_TIMESTAMP, sensors->mscbit);
>>> +
>>> + input_set_abs_params(sensors, ABS_X, -STEAM_DECK_ACCEL_RANGE,
>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>> + input_set_abs_params(sensors, ABS_Y, -STEAM_DECK_ACCEL_RANGE,
>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>> + input_set_abs_params(sensors, ABS_Z, -STEAM_DECK_ACCEL_RANGE,
>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>> + input_abs_set_res(sensors, ABS_X, STEAM_DECK_ACCEL_RES_PER_G);
>>> + input_abs_set_res(sensors, ABS_Y, STEAM_DECK_ACCEL_RES_PER_G);
>>> + input_abs_set_res(sensors, ABS_Z, STEAM_DECK_ACCEL_RES_PER_G);
>>> +
>>> + input_set_abs_params(sensors, ABS_RX, -STEAM_DECK_GYRO_RANGE,
>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>> + input_set_abs_params(sensors, ABS_RY, -STEAM_DECK_GYRO_RANGE,
>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>> + input_set_abs_params(sensors, ABS_RZ, -STEAM_DECK_GYRO_RANGE,
>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>> + input_abs_set_res(sensors, ABS_RX, STEAM_DECK_GYRO_RES_PER_DPS);
>>> + input_abs_set_res(sensors, ABS_RY, STEAM_DECK_GYRO_RES_PER_DPS);
>>> + input_abs_set_res(sensors, ABS_RZ, STEAM_DECK_GYRO_RES_PER_DPS);
>
> I seem to recall hearing that this data is not calibrated coming off of the device, and the actual calibration data is in Steam somewhere, but I'm not sure which data this applies to. The gravitation acceleration looked fine when testing, but I didn't have a dualsense handy to test the gyro with. Have you tested this on more than one device?
I tested it with a single Steam Deck and Dualsense controller and compared
the rotation values by eye in SDL's testcontroller tool while holding the
Deck and Dualsense in both hands. In this test the rotation data matched
well if compared by eye.
I repeated the test with a makeshift rotational plate and data-logging
and got an average absolute angular velocity of about 49 degree per second
for the Dualsense controller and 51 degree per second for the Steam Deck.
Hence, I think the values and their scaling are fine.
I'll remove my comment above about factory calibration in the next
patchset.
>
>>> +
>>> + ret = input_register_device(sensors);
>>> + if (ret)
>>> + goto sensors_register_fail;
>>> +
>>> + rcu_assign_pointer(steam->sensors, sensors);
>>> + return 0;
>>> +
>>> +sensors_register_fail:
>>> + input_free_device(sensors);
>>> + return ret;
>>> +}
>>> +
>>> static void steam_input_unregister(struct steam_device *steam)
>>> {
>>> struct input_dev *input;
>>> @@ -838,6 +914,24 @@ static void steam_input_unregister(struct steam_device *steam)
>>> input_unregister_device(input);
>>> }
>>>
>>> +static void steam_sensors_unregister(struct steam_device *steam)
>>> +{
>>> + struct input_dev *sensors;
>>> +
>>> + if (!(steam->quirks & STEAM_QUIRK_DECK))
>>> + return;
>>> +
>>> + rcu_read_lock();
>>> + sensors = rcu_dereference(steam->sensors);
>>> + rcu_read_unlock();
>>> +
>>> + if (!sensors)
>>> + return;
>>> + RCU_INIT_POINTER(steam->sensors, NULL);
>>> + synchronize_rcu();
>>> + input_unregister_device(sensors);
>>> +}
>>> +
>>> static void steam_battery_unregister(struct steam_device *steam)
>>> {
>>> struct power_supply *battery;
>>> @@ -890,18 +984,28 @@ static int steam_register(struct steam_device *steam)
>>> spin_lock_irqsave(&steam->lock, flags);
>>> client_opened = steam->client_opened;
>>> spin_unlock_irqrestore(&steam->lock, flags);
>>> +
>>> if (!client_opened) {
>>> steam_set_lizard_mode(steam, lizard_mode);
>>> ret = steam_input_register(steam);
>>> - } else
>>> - ret = 0;
>>> + if (ret != 0)
>>> + goto steam_register_input_fail;
>>> + ret = steam_sensors_register(steam);
>>> + if (ret != 0)
>>> + goto steam_register_sensors_fail;
>>> + }
>>> + return 0;
>>>
>>> +steam_register_sensors_fail:
>>> + steam_input_unregister(steam);
>>> +steam_register_input_fail:
>>> return ret;
>>> }
>>>
>>> static void steam_unregister(struct steam_device *steam)
>>> {
>>> steam_battery_unregister(steam);
>>> + steam_sensors_unregister(steam);
>>> steam_input_unregister(steam);
>>> if (steam->serial_no[0]) {
>>> hid_info(steam->hdev, "Steam Controller '%s' disconnected",
>>> @@ -1010,6 +1114,7 @@ static int steam_client_ll_open(struct hid_device *hdev)
>>> steam->client_opened++;
>>> spin_unlock_irqrestore(&steam->lock, flags);
>>>
>>> + steam_sensors_unregister(steam);
>>> steam_input_unregister(steam);
>>>
>>> return 0;
>>> @@ -1030,6 +1135,7 @@ static void steam_client_ll_close(struct hid_device *hdev)
>>> if (connected) {
>>> steam_set_lizard_mode(steam, lizard_mode);
>>> steam_input_register(steam);
>>> + steam_sensors_register(steam);
>>> }
>>> }
>>>
>>> @@ -1121,6 +1227,7 @@ static int steam_probe(struct hid_device *hdev,
>>> INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb);
>>> INIT_LIST_HEAD(&steam->list);
>>> INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb);
>>> + steam->sensor_timestamp_us = 0;
>>>
>>> /*
>>> * With the real steam controller interface, do not connect hidraw.
>>> @@ -1380,12 +1487,12 @@ static void steam_do_input_event(struct steam_device *steam,
>>> * 18-19 | s16 | ABS_HAT0Y | left-pad Y value
>>> * 20-21 | s16 | ABS_HAT1X | right-pad X value
>>> * 22-23 | s16 | ABS_HAT1Y | right-pad Y value
>>> - * 24-25 | s16 | -- | accelerometer X value
>>> - * 26-27 | s16 | -- | accelerometer Y value
>>> - * 28-29 | s16 | -- | accelerometer Z value
>>> - * 30-31 | s16 | -- | gyro X value
>>> - * 32-33 | s16 | -- | gyro Y value
>>> - * 34-35 | s16 | -- | gyro Z value
>>> + * 24-25 | s16 | IMU ABS_X | accelerometer X value
>>> + * 26-27 | s16 | IMU ABS_Z | accelerometer Y value
>>> + * 28-29 | s16 | IMU ABS_Y | accelerometer Z value
>>> + * 30-31 | s16 | IMU ABS_RX | gyro X value
>>> + * 32-33 | s16 | IMU ABS_RZ | gyro Y value
>>> + * 34-35 | s16 | IMU ABS_RY | gyro Z value
>>> * 36-37 | s16 | -- | quaternion W value
>>> * 38-39 | s16 | -- | quaternion X value
>>> * 40-41 | s16 | -- | quaternion Y value
>>> @@ -1546,6 +1653,32 @@ static void steam_do_deck_input_event(struct steam_device *steam,
>>> input_sync(input);
>>> }
>>>
>>> +static void steam_do_deck_sensors_event(struct steam_device *steam,
>>> + struct input_dev *sensors, u8 *data)
>>> +{
>>> + /*
>>> + * The deck input report is received every 4 ms on average,
>>> + * with a jitter of +/- 4 ms even though the USB descriptor claims
>>> + * that it uses 1 kHz.
>>> + * Since the HID report does not include a sensor timestamp,
>>> + * use a fixed increment here.
>>> + *
>>> + * The reported sensors data is factory calibrated by default so
>>> + * no extra logic for handling calibratrion is necessary.
>>> + */
>>> + steam->sensor_timestamp_us += 4000;
>>> + input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us);
>>> +
>>> + input_report_abs(sensors, ABS_X, steam_le16(data + 24));
>>> + input_report_abs(sensors, ABS_Z, -steam_le16(data + 26));
>>> + input_report_abs(sensors, ABS_Y, steam_le16(data + 28));
>>> + input_report_abs(sensors, ABS_RX, steam_le16(data + 30));
>>> + input_report_abs(sensors, ABS_RZ, -steam_le16(data + 32));
>>> + input_report_abs(sensors, ABS_RY, steam_le16(data + 34));
>>> +
>>> + input_sync(sensors);
>>> +}
>>> +
>>> /*
>>> * The size for this message payload is 11.
>>> * The known values are:
>>> @@ -1583,6 +1716,7 @@ static int steam_raw_event(struct hid_device *hdev,
>>> {
>>> struct steam_device *steam = hid_get_drvdata(hdev);
>>> struct input_dev *input;
>>> + struct input_dev *sensors;
>>> struct power_supply *battery;
>>>
>>> if (!steam)
>>> @@ -1629,6 +1763,14 @@ static int steam_raw_event(struct hid_device *hdev,
>>> if (likely(input))
>>> steam_do_deck_input_event(steam, input, data);
>>> rcu_read_unlock();
>>> +
>>> + if (steam->quirks & STEAM_QUIRK_DECK) {
>
> This report ID is only sent on the Steam Deck. Checking the quirk here is unnecessary, especially since it'll just be null and fail out if something weird happens and we get this report on a non-Deck device.
You're right, I'll change it.
>
>>> + rcu_read_lock();
>>> + sensors = rcu_dereference(steam->sensors);
>>> + if (likely(sensors))
>>> + steam_do_deck_sensors_event(steam, sensors, data);
>>> + rcu_read_unlock();
>>> + }
>>> break;
>>> case ID_CONTROLLER_WIRELESS:
>>> /*
>>>
>>> base-commit: 39cd87c4eb2b893354f3b850f916353f2658ae6f
>>> --
>>> 2.44.0
>>>
>>
>
> Implementation looks mostly fine. However, I had some discussion with people at Valve about this who said they'd like the IMU to be silenced when gamepad mode is disabled the same way the gamepad data is.
>
> Vicki
I'll add a check for gamepad_mode to the sensors event.
Thank you for your feedback.
Max
^ permalink raw reply
* Re: [PATCH 00/19] amba: store owner from modules with amba_driver_register()
From: Krzysztof Kozlowski @ 2024-04-17 17:10 UTC (permalink / raw)
To: Russell King (Oracle)
Cc: Suzuki K Poulose, Mike Leach, James Clark, Alexander Shishkin,
Maxime Coquelin, Alexandre Torgue, Linus Walleij, Andi Shyti,
Olivia Mackall, Herbert Xu, Vinod Koul, Dmitry Torokhov,
Miquel Raynal, Michal Simek, Eric Auger, Alex Williamson,
Greg Kroah-Hartman, linux-kernel, coresight, linux-arm-kernel,
linux-stm32, linux-i2c, linux-crypto, dmaengine, linux-input, kvm
In-Reply-To: <Zh/Tmarryr4TzHIA@shell.armlinux.org.uk>
On 17/04/2024 15:50, Russell King (Oracle) wrote:
> On Wed, Apr 17, 2024 at 03:29:26PM +0200, Krzysztof Kozlowski wrote:
>> On 16/04/2024 12:41, Suzuki K Poulose wrote:
>>> + Greg
>>>
>>>
>>> Hi Krzysztof,
>>>
>>> On 30/03/2024 18:00, Krzysztof Kozlowski wrote:
>>>> On 30/03/2024 18:58, Krzysztof Kozlowski wrote:
>>>>>
>>>>> On Tue, 26 Mar 2024 21:23:30 +0100, Krzysztof Kozlowski wrote:
>>>>>> Merging
>>>>>> =======
>>>>>> All further patches depend on the first amba patch, therefore please ack
>>>>>> and this should go via one tree.
>>>>>>
>>>>>> Description
>>>>>> ===========
>>>>>> Modules registering driver with amba_driver_register() often forget to
>>>>>> set .owner field.
>>>>>>
>>>>>> [...]
>>>>>
>>>>> Applied, thanks!
>>>>>
>>>>> [01/19] amba: store owner from modules with amba_driver_register()
>>>>> (no commit info)
>>>>
>>>> Patchset applied here:
>>>> https://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux-dt.git/log/?h=for-v6.10/module-owner-amba
>>>
>>> How do you plan to push this ? Given this affects most of the drivers/,
>>> do you plan to send this to Greg ? We have changes in the coresight
>>> tree that would conflict with this "tag" ( I haven't merged them yet,
>>> but is in my local queue). I want to make sure we can avoid the
>>> conflicts. I am happy to merge this to my local tree and base the
>>> changes on this, if this is going in for v6.10 and all are in agreement.
>>
>> I pushed it to arm-linux patches but it hasn't been picked up.
>>
>> I propose you take entire set then.
>
> You are again being, IMHO, abrasive with your attitude. So far, every
> interaction with you has been abrasive and bordering on abusive.
>
> You haven't asked me whether I will take them. I will - just not at the
> moment because
Thanks for confirming, I wanted to ping you because there was no feedback.
Can you provide stable tag for coresight tree?
Best regards,
Krzysztof
^ permalink raw reply
* Re: [PATCH v11 0/3] Add support for vibrator in multiple PMICs
From: Krzysztof Kozlowski @ 2024-04-17 19:09 UTC (permalink / raw)
To: quic_fenglinw, kernel, Andy Gross, Bjorn Andersson, Konrad Dybcio,
Dmitry Torokhov, Rob Herring, Krzysztof Kozlowski,
Dmitry Baryshkov
Cc: linux-arm-msm, linux-input, linux-kernel, devicetree
In-Reply-To: <20240416-pm8xxx-vibrator-new-design-v11-0-7b1c951e1515@quicinc.com>
On 16/04/2024 04:44, Fenglin Wu via B4 Relay wrote:
> Add SW support for the vibrator module inside PMI632, PM7250B, PM7325B, PM7550BA.
> It is very similar to the vibrator module inside PM8916 which is supported in
> pm8xxx-vib driver but just the drive amplitude is controlled with 2 registers,
> and the register base offset in each PMIC is different.
>
> Changes in v11:
> 1. Drop the 1st patch since it has been applied
> 2. Update to address review comments
Everything is an update. Such changelog is not really helping. Be specific.
Best regards,
Krzysztof
^ permalink raw reply
* Re: [PATCH v11 0/3] Add support for vibrator in multiple PMICs
From: Dmitry Torokhov @ 2024-04-17 22:29 UTC (permalink / raw)
To: quic_fenglinw
Cc: kernel, Andy Gross, Bjorn Andersson, Konrad Dybcio, Rob Herring,
Krzysztof Kozlowski, Dmitry Baryshkov, linux-arm-msm, linux-input,
linux-kernel, devicetree, Krzysztof Kozlowski
In-Reply-To: <20240416-pm8xxx-vibrator-new-design-v11-0-7b1c951e1515@quicinc.com>
On Tue, Apr 16, 2024 at 10:44:31AM +0800, Fenglin Wu via B4 Relay wrote:
> Add SW support for the vibrator module inside PMI632, PM7250B, PM7325B, PM7550BA.
> It is very similar to the vibrator module inside PM8916 which is supported in
> pm8xxx-vib driver but just the drive amplitude is controlled with 2 registers,
> and the register base offset in each PMIC is different.
Applied the lot, thank you.
--
Dmitry
^ permalink raw reply
* Re: [PATCH] HID: hid-steam: Add Deck IMU support
From: Vicki Pfau @ 2024-04-18 3:07 UTC (permalink / raw)
To: Max Maisel
Cc: benjamin.tissoires, jikos, linux-input, linux-kernel,
rodrigorivascosta
In-Reply-To: <20240417165641.12994-1-mmm-1@posteo.net>
On 4/17/24 9:56 AM, Max Maisel wrote:
> On Mon, 15. Apr 2024, Vicki Pfau wrote:
>> Hi,
>>
>> On 4/12/24 4:42 AM, Jiri Kosina wrote:
>>> On Sun, 7 Apr 2024, Max Maisel wrote:
>>>
>>>> The Deck's controller features an accelerometer and gyroscope which
>>>> send their measurement values by default in the main HID input report.
>>>> Expose both sensors to userspace through a separate evdev node as it
>>>> is done by the hid-nintendo and hid-playstation drivers.
>>>>
>>>> Signed-off-by: Max Maisel <mmm-1@posteo.net>
>>>
>>> CCing Rodrigo and Vicki ... could you please take a look and Ack the patch
>>> below from Max?
>>>
>>> Thanks.
>>>
>>>> ---
>>>>
>>>> This patch was tested on a Steam Deck running Arch Linux. With it,
>>>> applications using latest SDL2/3 git libraries will pick up the sensors
>>>> without hidraw access. This was tested against the antimicrox gamepad mapper.
>>>>
>>>> Measurement value scaling was tested by moving the deck and a dualsense
>>>> controller simultaneously and comparing their reported values in
>>>> userspace with SDL3's testcontroller tool.
>>>>
>>>> drivers/hid/hid-steam.c | 158 ++++++++++++++++++++++++++++++++++++++--
>>>> 1 file changed, 150 insertions(+), 8 deletions(-)
>>>>
>>>> diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c
>>>> index b08a5ab58528..af6e6c3b1356 100644
>>>> --- a/drivers/hid/hid-steam.c
>>>> +++ b/drivers/hid/hid-steam.c
>>>> @@ -66,6 +66,12 @@ static LIST_HEAD(steam_devices);
>>>> #define STEAM_DECK_TRIGGER_RESOLUTION 5461
>>>> /* Joystick runs are about 5 mm and 32768 units */
>>>> #define STEAM_DECK_JOYSTICK_RESOLUTION 6553
>>>> +/* Accelerometer has 16 bit resolution and a range of +/- 2g */
>>>> +#define STEAM_DECK_ACCEL_RES_PER_G 16384
>>>> +#define STEAM_DECK_ACCEL_RANGE 32768
>>>> +/* Gyroscope has 16 bit resolution and a range of +/- 2000 dps */
>>>> +#define STEAM_DECK_GYRO_RES_PER_DPS 16
>>>> +#define STEAM_DECK_GYRO_RANGE 32000
>>
>> This value looks strange. How do you know it's not supposed to be 32768?
>
> The "input-programming" documentation mentioned that the device must be able to
> reach its min and max values so I subtracted a little bit from the 32768.
> But with this in mind, the accelerometer max value looks wrong.
I'm pretty sure I was able to max out the accelerometer. It's not too difficult to move something at 20 m/s^2 for a short amount of time. I didn't log the data though, but in realtime I did see it getting quite close.
>
> If you agree, I would change it to 32768 since the playstation and nintendo
> IMU drivers use powers of two derived maximum values as well.
Yeah, I see no reason to arbitrarily restrict it when it probably can go to the full range.
>
>>>>
>>>> #define STEAM_PAD_FUZZ 256
>>>>
>>>> @@ -288,6 +294,7 @@ struct steam_device {
>>>> struct mutex report_mutex;
>>>> unsigned long client_opened;
>>>> struct input_dev __rcu *input;
>>>> + struct input_dev __rcu *sensors;
>>>> unsigned long quirks;
>>>> struct work_struct work_connect;
>>>> bool connected;
>>>> @@ -302,6 +309,7 @@ struct steam_device {
>>>> struct work_struct rumble_work;
>>>> u16 rumble_left;
>>>> u16 rumble_right;
>>>> + unsigned int sensor_timestamp_us;
>>>> };
>>>>
>>>> static int steam_recv_report(struct steam_device *steam,
>>>> @@ -825,6 +833,74 @@ static int steam_input_register(struct steam_device *steam)
>>>> return ret;
>>>> }
>>>>
>>>> +static int steam_sensors_register(struct steam_device *steam)
>>>> +{
>>>> + struct hid_device *hdev = steam->hdev;
>>>> + struct input_dev *sensors;
>>>> + int ret;
>>>> +
>>>> + if (!(steam->quirks & STEAM_QUIRK_DECK))
>>>> + return 0;
>>>> +
>>>> + rcu_read_lock();
>>>> + sensors = rcu_dereference(steam->sensors);
>>>> + rcu_read_unlock();
>>>> + if (sensors) {
>>>> + dbg_hid("%s: already connected\n", __func__);
>>>> + return 0;
>>>> + }
>>>> +
>>>> + sensors = input_allocate_device();
>>>> + if (!sensors)
>>>> + return -ENOMEM;
>>>> +
>>>> + input_set_drvdata(sensors, steam);
>>>> + sensors->dev.parent = &hdev->dev;
>>>> +
>>>> + sensors->name = "Steam Deck Motion Sensors";
>>>> + sensors->phys = hdev->phys;
>>>> + sensors->uniq = steam->serial_no;
>>>> + sensors->id.bustype = hdev->bus;
>>>> + sensors->id.vendor = hdev->vendor;
>>>> + sensors->id.product = hdev->product;
>>>> + sensors->id.version = hdev->version;
>>>> +
>>>> + __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);
>>>> + __set_bit(EV_MSC, sensors->evbit);
>>>> + __set_bit(MSC_TIMESTAMP, sensors->mscbit);
>>>> +
>>>> + input_set_abs_params(sensors, ABS_X, -STEAM_DECK_ACCEL_RANGE,
>>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>>> + input_set_abs_params(sensors, ABS_Y, -STEAM_DECK_ACCEL_RANGE,
>>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>>> + input_set_abs_params(sensors, ABS_Z, -STEAM_DECK_ACCEL_RANGE,
>>>> + STEAM_DECK_ACCEL_RANGE, 16, 0);
>>>> + input_abs_set_res(sensors, ABS_X, STEAM_DECK_ACCEL_RES_PER_G);
>>>> + input_abs_set_res(sensors, ABS_Y, STEAM_DECK_ACCEL_RES_PER_G);
>>>> + input_abs_set_res(sensors, ABS_Z, STEAM_DECK_ACCEL_RES_PER_G);
>>>> +
>>>> + input_set_abs_params(sensors, ABS_RX, -STEAM_DECK_GYRO_RANGE,
>>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>>> + input_set_abs_params(sensors, ABS_RY, -STEAM_DECK_GYRO_RANGE,
>>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>>> + input_set_abs_params(sensors, ABS_RZ, -STEAM_DECK_GYRO_RANGE,
>>>> + STEAM_DECK_GYRO_RANGE, 16, 0);
>>>> + input_abs_set_res(sensors, ABS_RX, STEAM_DECK_GYRO_RES_PER_DPS);
>>>> + input_abs_set_res(sensors, ABS_RY, STEAM_DECK_GYRO_RES_PER_DPS);
>>>> + input_abs_set_res(sensors, ABS_RZ, STEAM_DECK_GYRO_RES_PER_DPS);
>>
>> I seem to recall hearing that this data is not calibrated coming off of the device, and the actual calibration data is in Steam somewhere, but I'm not sure which data this applies to. The gravitation acceleration looked fine when testing, but I didn't have a dualsense handy to test the gyro with. Have you tested this on more than one device?
>
> I tested it with a single Steam Deck and Dualsense controller and compared
> the rotation values by eye in SDL's testcontroller tool while holding the
> Deck and Dualsense in both hands. In this test the rotation data matched
> well if compared by eye.
>
> I repeated the test with a makeshift rotational plate and data-logging
> and got an average absolute angular velocity of about 49 degree per second
> for the Dualsense controller and 51 degree per second for the Steam Deck.
> Hence, I think the values and their scaling are fine.
>
> I'll remove my comment above about factory calibration in the next
> patchset.
I logged some data that I gathered while swinging around a Steam Deck and Dualsense at the same time and found that once scaled they were only off by a little bit (by magnitude, because they axes weren't perfectly aligned when I collected the data), and not with a consistent scale. Graphing the data shows they're pretty close, so it seems fine.
>
>>
>>>> +
>>>> + ret = input_register_device(sensors);
>>>> + if (ret)
>>>> + goto sensors_register_fail;
>>>> +
>>>> + rcu_assign_pointer(steam->sensors, sensors);
>>>> + return 0;
>>>> +
>>>> +sensors_register_fail:
>>>> + input_free_device(sensors);
>>>> + return ret;
>>>> +}
>>>> +
>>>> static void steam_input_unregister(struct steam_device *steam)
>>>> {
>>>> struct input_dev *input;
>>>> @@ -838,6 +914,24 @@ static void steam_input_unregister(struct steam_device *steam)
>>>> input_unregister_device(input);
>>>> }
>>>>
>>>> +static void steam_sensors_unregister(struct steam_device *steam)
>>>> +{
>>>> + struct input_dev *sensors;
>>>> +
>>>> + if (!(steam->quirks & STEAM_QUIRK_DECK))
>>>> + return;
>>>> +
>>>> + rcu_read_lock();
>>>> + sensors = rcu_dereference(steam->sensors);
>>>> + rcu_read_unlock();
>>>> +
>>>> + if (!sensors)
>>>> + return;
>>>> + RCU_INIT_POINTER(steam->sensors, NULL);
>>>> + synchronize_rcu();
>>>> + input_unregister_device(sensors);
>>>> +}
>>>> +
>>>> static void steam_battery_unregister(struct steam_device *steam)
>>>> {
>>>> struct power_supply *battery;
>>>> @@ -890,18 +984,28 @@ static int steam_register(struct steam_device *steam)
>>>> spin_lock_irqsave(&steam->lock, flags);
>>>> client_opened = steam->client_opened;
>>>> spin_unlock_irqrestore(&steam->lock, flags);
>>>> +
>>>> if (!client_opened) {
>>>> steam_set_lizard_mode(steam, lizard_mode);
>>>> ret = steam_input_register(steam);
>>>> - } else
>>>> - ret = 0;
>>>> + if (ret != 0)
>>>> + goto steam_register_input_fail;
>>>> + ret = steam_sensors_register(steam);
>>>> + if (ret != 0)
>>>> + goto steam_register_sensors_fail;
>>>> + }
>>>> + return 0;
>>>>
>>>> +steam_register_sensors_fail:
>>>> + steam_input_unregister(steam);
>>>> +steam_register_input_fail:
>>>> return ret;
>>>> }
>>>>
>>>> static void steam_unregister(struct steam_device *steam)
>>>> {
>>>> steam_battery_unregister(steam);
>>>> + steam_sensors_unregister(steam);
>>>> steam_input_unregister(steam);
>>>> if (steam->serial_no[0]) {
>>>> hid_info(steam->hdev, "Steam Controller '%s' disconnected",
>>>> @@ -1010,6 +1114,7 @@ static int steam_client_ll_open(struct hid_device *hdev)
>>>> steam->client_opened++;
>>>> spin_unlock_irqrestore(&steam->lock, flags);
>>>>
>>>> + steam_sensors_unregister(steam);
>>>> steam_input_unregister(steam);
>>>>
>>>> return 0;
>>>> @@ -1030,6 +1135,7 @@ static void steam_client_ll_close(struct hid_device *hdev)
>>>> if (connected) {
>>>> steam_set_lizard_mode(steam, lizard_mode);
>>>> steam_input_register(steam);
>>>> + steam_sensors_register(steam);
>>>> }
>>>> }
>>>>
>>>> @@ -1121,6 +1227,7 @@ static int steam_probe(struct hid_device *hdev,
>>>> INIT_DELAYED_WORK(&steam->mode_switch, steam_mode_switch_cb);
>>>> INIT_LIST_HEAD(&steam->list);
>>>> INIT_WORK(&steam->rumble_work, steam_haptic_rumble_cb);
>>>> + steam->sensor_timestamp_us = 0;
>>>>
>>>> /*
>>>> * With the real steam controller interface, do not connect hidraw.
>>>> @@ -1380,12 +1487,12 @@ static void steam_do_input_event(struct steam_device *steam,
>>>> * 18-19 | s16 | ABS_HAT0Y | left-pad Y value
>>>> * 20-21 | s16 | ABS_HAT1X | right-pad X value
>>>> * 22-23 | s16 | ABS_HAT1Y | right-pad Y value
>>>> - * 24-25 | s16 | -- | accelerometer X value
>>>> - * 26-27 | s16 | -- | accelerometer Y value
>>>> - * 28-29 | s16 | -- | accelerometer Z value
>>>> - * 30-31 | s16 | -- | gyro X value
>>>> - * 32-33 | s16 | -- | gyro Y value
>>>> - * 34-35 | s16 | -- | gyro Z value
>>>> + * 24-25 | s16 | IMU ABS_X | accelerometer X value
>>>> + * 26-27 | s16 | IMU ABS_Z | accelerometer Y value
>>>> + * 28-29 | s16 | IMU ABS_Y | accelerometer Z value
>>>> + * 30-31 | s16 | IMU ABS_RX | gyro X value
>>>> + * 32-33 | s16 | IMU ABS_RZ | gyro Y value
>>>> + * 34-35 | s16 | IMU ABS_RY | gyro Z value
>>>> * 36-37 | s16 | -- | quaternion W value
>>>> * 38-39 | s16 | -- | quaternion X value
>>>> * 40-41 | s16 | -- | quaternion Y value
>>>> @@ -1546,6 +1653,32 @@ static void steam_do_deck_input_event(struct steam_device *steam,
>>>> input_sync(input);
>>>> }
>>>>
>>>> +static void steam_do_deck_sensors_event(struct steam_device *steam,
>>>> + struct input_dev *sensors, u8 *data)
>>>> +{
>>>> + /*
>>>> + * The deck input report is received every 4 ms on average,
>>>> + * with a jitter of +/- 4 ms even though the USB descriptor claims
>>>> + * that it uses 1 kHz.
>>>> + * Since the HID report does not include a sensor timestamp,
>>>> + * use a fixed increment here.
>>>> + *
>>>> + * The reported sensors data is factory calibrated by default so
>>>> + * no extra logic for handling calibratrion is necessary.
>>>> + */
>>>> + steam->sensor_timestamp_us += 4000;
>>>> + input_event(sensors, EV_MSC, MSC_TIMESTAMP, steam->sensor_timestamp_us);
>>>> +
>>>> + input_report_abs(sensors, ABS_X, steam_le16(data + 24));
>>>> + input_report_abs(sensors, ABS_Z, -steam_le16(data + 26));
>>>> + input_report_abs(sensors, ABS_Y, steam_le16(data + 28));
>>>> + input_report_abs(sensors, ABS_RX, steam_le16(data + 30));
>>>> + input_report_abs(sensors, ABS_RZ, -steam_le16(data + 32));
>>>> + input_report_abs(sensors, ABS_RY, steam_le16(data + 34));
>>>> +
>>>> + input_sync(sensors);
>>>> +}
>>>> +
>>>> /*
>>>> * The size for this message payload is 11.
>>>> * The known values are:
>>>> @@ -1583,6 +1716,7 @@ static int steam_raw_event(struct hid_device *hdev,
>>>> {
>>>> struct steam_device *steam = hid_get_drvdata(hdev);
>>>> struct input_dev *input;
>>>> + struct input_dev *sensors;
>>>> struct power_supply *battery;
>>>>
>>>> if (!steam)
>>>> @@ -1629,6 +1763,14 @@ static int steam_raw_event(struct hid_device *hdev,
>>>> if (likely(input))
>>>> steam_do_deck_input_event(steam, input, data);
>>>> rcu_read_unlock();
>>>> +
>>>> + if (steam->quirks & STEAM_QUIRK_DECK) {
>>
>> This report ID is only sent on the Steam Deck. Checking the quirk here is unnecessary, especially since it'll just be null and fail out if something weird happens and we get this report on a non-Deck device.
>
> You're right, I'll change it.
>
>>
>>>> + rcu_read_lock();
>>>> + sensors = rcu_dereference(steam->sensors);
>>>> + if (likely(sensors))
>>>> + steam_do_deck_sensors_event(steam, sensors, data);
>>>> + rcu_read_unlock();
>>>> + }
>>>> break;
>>>> case ID_CONTROLLER_WIRELESS:
>>>> /*
>>>>
>>>> base-commit: 39cd87c4eb2b893354f3b850f916353f2658ae6f
>>>> --
>>>> 2.44.0
>>>>
>>>
>>
>> Implementation looks mostly fine. However, I had some discussion with people at Valve about this who said they'd like the IMU to be silenced when gamepad mode is disabled the same way the gamepad data is.
>>
>> Vicki
>
> I'll add a check for gamepad_mode to the sensors event.
>
> Thank you for your feedback.
>
> Max
With those changes it'll probably be fine.
Vicki
^ permalink raw reply
* Re: [PATCH] Input: PS/2 - add support for Lenovo Xiaoxin keyboard
From: WangYuli @ 2024-04-18 8:16 UTC (permalink / raw)
To: Dmitry Torokhov
Cc: rrangel, shaoyang, helugang, linux-input, linux-kernel, huangbibo,
yesh25, bernhard.kaindl
In-Reply-To: <ZgXUZtEwHEF8Rs3i@google.com>
Hi,
On 2024/3/29 04:34, Dmitry Torokhov wrote:
> Could you please tell me more about the keyboard?
Link:
https://lore.kernel.org/lkml/20230514083336.3811-1-yesh25@mail2.sysu.edu.cn/T/
Link: https://gist.github.com/yescallop/5a97d010f226172fafab0933ce8ea8af
Those links above mentioned the same situation.
Lenovo has a batch of laptops shipped in 2021 with the same problem. And
the combined sales of these products are considerable.
> What ID does it use?
0x83.
> Majority of keyboards are using 0xab83, does your device forget to send
> 0xab by chance?
Unfortunalety, I'm afraid not.
>
> Thanks.
>
Thanks.
--
WangYuli
^ permalink raw reply
* Re: [PATCH] Input: PS/2 - add support for Lenovo Xiaoxin keyboard
From: Shang Ye @ 2024-04-18 8:58 UTC (permalink / raw)
To: WangYuli; +Cc: linux-input, dmitry.torokhov
In-Reply-To: <AA3FCBB9232F6C97+0e28ccd7-11cc-4047-866c-92069ddbb550@uniontech.com>
Hi,
On 2024/04/18 4:16 pm, WangYuli wrote:
> Hi,
>
> On 2024/3/29 04:34, Dmitry Torokhov wrote:
>> Could you please tell me more about the keyboard?
>
> Link:
> https://lore.kernel.org/lkml/20230514083336.3811-1-yesh25@mail2.sysu.edu.cn/T/
>
> Link: https://gist.github.com/yescallop/5a97d010f226172fafab0933ce8ea8af
>
> Those links above mentioned the same situation.
>
> Lenovo has a batch of laptops shipped in 2021 with the same problem. And
>
> the combined sales of these products are considerable.
>
>> What ID does it use?
> 0x83.
>> Majority of keyboards are using 0xab83, does your device forget to send
>> 0xab by chance?
> Unfortunalety, I'm afraid not.
>>
>> Thanks.
>>
> Thanks.
>
I'm pretty sure that the problem I encountered was already fixed by a
previous patch:
https://lore.kernel.org/r/20231115174625.7462-1-hdegoede@redhat.com
Could you please check if it is the case?
Regards,
Shang
^ permalink raw reply
* [dtor-input:next] BUILD SUCCESS 9e0631695eac16e0102b9961c3b750c987d24f7f
From: kernel test robot @ 2024-04-18 10:49 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: linux-input
tree/branch: https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
branch HEAD: 9e0631695eac16e0102b9961c3b750c987d24f7f input: pm8xxx-vibrator: add new SPMI vibrator support
elapsed time: 739m
configs tested: 102
configs skipped: 2
The following configs have been built successfully.
More configs may be tested in the coming days.
tested configs:
alpha allnoconfig gcc
alpha allyesconfig gcc
alpha defconfig gcc
arc allmodconfig gcc
arc allnoconfig gcc
arc allyesconfig gcc
arc defconfig gcc
arm allmodconfig gcc
arm allnoconfig clang
arm allyesconfig gcc
arm defconfig clang
arm64 allmodconfig clang
arm64 allnoconfig gcc
arm64 defconfig gcc
csky allmodconfig gcc
csky allnoconfig gcc
csky allyesconfig gcc
csky defconfig gcc
hexagon allmodconfig clang
hexagon allnoconfig clang
hexagon allyesconfig clang
hexagon defconfig clang
i386 allmodconfig gcc
i386 allnoconfig gcc
i386 allyesconfig gcc
i386 buildonly-randconfig-001-20240418 gcc
i386 buildonly-randconfig-002-20240418 gcc
i386 buildonly-randconfig-003-20240418 clang
i386 buildonly-randconfig-004-20240418 gcc
i386 buildonly-randconfig-005-20240418 clang
i386 buildonly-randconfig-006-20240418 clang
i386 defconfig clang
i386 randconfig-001-20240418 gcc
i386 randconfig-002-20240418 gcc
i386 randconfig-003-20240418 clang
i386 randconfig-004-20240418 gcc
i386 randconfig-005-20240418 gcc
i386 randconfig-006-20240418 gcc
i386 randconfig-011-20240418 clang
i386 randconfig-012-20240418 clang
i386 randconfig-013-20240418 gcc
i386 randconfig-014-20240418 gcc
i386 randconfig-015-20240418 gcc
i386 randconfig-016-20240418 clang
loongarch allmodconfig gcc
loongarch allnoconfig gcc
loongarch defconfig gcc
m68k allmodconfig gcc
m68k allnoconfig gcc
m68k allyesconfig gcc
m68k defconfig gcc
microblaze allmodconfig gcc
microblaze allnoconfig gcc
microblaze allyesconfig gcc
microblaze defconfig gcc
mips allnoconfig gcc
mips allyesconfig gcc
nios2 allmodconfig gcc
nios2 allnoconfig gcc
nios2 allyesconfig gcc
nios2 defconfig gcc
openrisc allnoconfig gcc
openrisc allyesconfig gcc
openrisc defconfig gcc
parisc allmodconfig gcc
parisc allnoconfig gcc
parisc allyesconfig gcc
parisc defconfig gcc
parisc64 defconfig gcc
powerpc allmodconfig gcc
powerpc allnoconfig gcc
powerpc allyesconfig clang
riscv allmodconfig clang
riscv allnoconfig gcc
riscv allyesconfig clang
riscv defconfig clang
riscv rv32_defconfig clang
s390 allmodconfig clang
s390 allnoconfig clang
s390 allyesconfig gcc
s390 defconfig clang
sh allmodconfig gcc
sh allnoconfig gcc
sh allyesconfig gcc
sh defconfig gcc
sparc allmodconfig gcc
sparc allnoconfig gcc
sparc defconfig gcc
sparc64 allmodconfig gcc
sparc64 allyesconfig gcc
sparc64 defconfig gcc
um allmodconfig clang
um allnoconfig clang
um allyesconfig gcc
um defconfig clang
um i386_defconfig gcc
um x86_64_defconfig clang
x86_64 allnoconfig clang
x86_64 allyesconfig clang
x86_64 defconfig gcc
x86_64 rhel-8.3-rust clang
xtensa allnoconfig gcc
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* Re: Re: [PATCH] HID: uclogic: Remove useless loop
From: Stefan Berzl @ 2024-04-18 13:31 UTC (permalink / raw)
To: Jiri Kosina; +Cc: linux-input, linux-kernel, Nikolai Kondrashov
In-Reply-To: <nycvar.YFH.7.76.2404121751250.5680@cbobk.fhfr.pm>
On 12/04/2024 17:52, Jiri Kosina wrote:
> On Mon, 1 Apr 2024, Stefan Berzl wrote:
>
>> The while in question does nothing except provide the possibility
>> to have an infinite loop in case the subreport id is actually the same
>> as the pen id.
>>
>> Signed-off-by: Stefan Berzl <stefanberzl@gmail.com>
>
> Let me CC Nicolai, the author of the code of question (8b013098be2c9).
I agree that Nicolai's opinion would be invaluable, but even without it,
the patch is trivially correct. If we have a subreport that matches the
packet, we change the report_id accordingly. If we then loop back to the
beginning, either the report_id is different or we are caught in an
infinite loop. None of these are hardware registers where the access
itself would matter.
>> ---
>> drivers/hid/hid-uclogic-core.c | 55 ++++++++++++++++------------------
>> 1 file changed, 25 insertions(+), 30 deletions(-)
>>
>> diff --git a/drivers/hid/hid-uclogic-core.c b/drivers/hid/hid-uclogic-core.c
>> index ad74cbc9a0aa..a56f4de216de 100644
>> --- a/drivers/hid/hid-uclogic-core.c
>> +++ b/drivers/hid/hid-uclogic-core.c
>> @@ -431,40 +431,35 @@ static int uclogic_raw_event(struct hid_device *hdev,
>> if (uclogic_exec_event_hook(params, data, size))
>> return 0;
>>
>> - while (true) {
>> - /* Tweak pen reports, if necessary */
>> - if ((report_id == params->pen.id) && (size >= 2)) {
>> - subreport_list_end =
>> - params->pen.subreport_list +
>> - ARRAY_SIZE(params->pen.subreport_list);
>> - /* Try to match a subreport */
>> - for (subreport = params->pen.subreport_list;
>> - subreport < subreport_list_end; subreport++) {
>> - if (subreport->value != 0 &&
>> - subreport->value == data[1]) {
>> - break;
>> - }
>> - }
>> - /* If a subreport matched */
>> - if (subreport < subreport_list_end) {
>> - /* Change to subreport ID, and restart */
>> - report_id = data[0] = subreport->id;
>> - continue;
>> - } else {
>> - return uclogic_raw_event_pen(drvdata, data, size);
>> + /* Tweak pen reports, if necessary */
>> + if ((report_id == params->pen.id) && (size >= 2)) {
>> + subreport_list_end =
>> + params->pen.subreport_list +
>> + ARRAY_SIZE(params->pen.subreport_list);
>> + /* Try to match a subreport */
>> + for (subreport = params->pen.subreport_list;
>> + subreport < subreport_list_end; subreport++) {
>> + if (subreport->value != 0 &&
>> + subreport->value == data[1]) {
>> + break;
>> }
>> }
>> -
>> - /* Tweak frame control reports, if necessary */
>> - for (i = 0; i < ARRAY_SIZE(params->frame_list); i++) {
>> - if (report_id == params->frame_list[i].id) {
>> - return uclogic_raw_event_frame(
>> - drvdata, ¶ms->frame_list[i],
>> - data, size);
>> - }
>> + /* If a subreport matched */
>> + if (subreport < subreport_list_end) {
>> + /* Change to subreport ID, and restart */
>> + report_id = data[0] = subreport->id;
>> + } else {
>> + return uclogic_raw_event_pen(drvdata, data, size);
>> }
>> + }
>>
>> - break;
>> + /* Tweak frame control reports, if necessary */
>> + for (i = 0; i < ARRAY_SIZE(params->frame_list); i++) {
>> + if (report_id == params->frame_list[i].id) {
>> + return uclogic_raw_event_frame(
>> + drvdata, ¶ms->frame_list[i],
>> + data, size);
>> + }
>> }
>>
>> return 0;
>> --
>> 2.43.0
>>
>
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox