[PATCH 0/5] Input: Add support for TouchNetix aXiom touchscreen

[PATCH 0/5] Input: Add support for TouchNetix aXiom touchscreen

[Marco Felsch]

Hi,

This adds the initial support for the TouchNetix aXiom touchcontroller
family.

This series is the successor of [1] (many thanks to Bootlin) but I
started from a fresh v1 since I had to rework the driver completely.

The following features are added:
 - I2C communication
 - Input event handling
 - Touchcontroller firmware (AXFW or ALC) updates
 - Touchcontroller config (TH2CFGBIN) updates

[1] https://lore.kernel.org/all/20240703142520.207066-1-kamel.bouhara@bootlin.com

Regards,
  Marco

---
Kamel Bouhara (2):
      dt-bindings: vendor-prefixes: Add TouchNetix AS
      dt-bindings: input: Add TouchNetix axiom touchscreen

Marco Felsch (3):
      firmware_loader: expand firmware error codes with skip error
      firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP
      Input: Add TouchNetix aXiom I2C Touchscreen support

 .../input/touchscreen/touchnetix,ax54a.yaml        |   62 +
 .../devicetree/bindings/vendor-prefixes.yaml       |    2 +
 drivers/base/firmware_loader/sysfs_upload.c        |    5 +
 drivers/input/touchscreen/Kconfig                  |   15 +
 drivers/input/touchscreen/Makefile                 |    1 +
 drivers/input/touchscreen/touchnetix_axiom.c       | 2764 ++++++++++++++++++++
 include/linux/firmware.h                           |    2 +
 lib/test_firmware.c                                |    1 +
 8 files changed, 2852 insertions(+)
---
base-commit: 9852d85ec9d492ebef56dc5f229416c925758edc
change-id: 20240704-v6-10-topic-touchscreen-axiom-105761e81011

Best regards,
-- 
Marco Felsch <m.felsch@pengutronix.de>

[PATCH 1/5] firmware_loader: expand firmware error codes with skip error

[Marco Felsch]

Add FW_UPLOAD_ERR_SKIP to allow drivers to inform the firmware_loader
framework that the update is not required. This can be the case if the
user provided firmware matches the current running firmware.

Sync lib/test_firmware.c file accordingly.

Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
---
 drivers/base/firmware_loader/sysfs_upload.c | 1 +
 include/linux/firmware.h                    | 2 ++
 lib/test_firmware.c                         | 1 +
 3 files changed, 4 insertions(+)

diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
index 829270067d16..b3cbe5b156e3 100644
--- a/drivers/base/firmware_loader/sysfs_upload.c
+++ b/drivers/base/firmware_loader/sysfs_upload.c
@@ -28,6 +28,7 @@ static const char * const fw_upload_err_str[] = {
 	[FW_UPLOAD_ERR_RW_ERROR]     = "read-write-error",
 	[FW_UPLOAD_ERR_WEAROUT]	     = "flash-wearout",
 	[FW_UPLOAD_ERR_FW_INVALID]   = "firmware-invalid",
+	[FW_UPLOAD_ERR_SKIP]         = "skip",
 };
 
 static const char *fw_upload_progress(struct device *dev,
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index aae1b85ffc10..46d2192b733a 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -29,6 +29,7 @@ struct firmware {
  * @FW_UPLOAD_ERR_RW_ERROR: read or write to HW failed, see kernel log
  * @FW_UPLOAD_ERR_WEAROUT: FLASH device is approaching wear-out, wait & retry
  * @FW_UPLOAD_ERR_FW_INVALID: invalid firmware file
+ * @FW_UPLOAD_ERR_SKIP: firmware is already up to date, skip update
  * @FW_UPLOAD_ERR_MAX: Maximum error code marker
  */
 enum fw_upload_err {
@@ -41,6 +42,7 @@ enum fw_upload_err {
 	FW_UPLOAD_ERR_RW_ERROR,
 	FW_UPLOAD_ERR_WEAROUT,
 	FW_UPLOAD_ERR_FW_INVALID,
+	FW_UPLOAD_ERR_SKIP,
 	FW_UPLOAD_ERR_MAX
 };
 
diff --git a/lib/test_firmware.c b/lib/test_firmware.c
index bcb32cbff188..6715eac10c6b 100644
--- a/lib/test_firmware.c
+++ b/lib/test_firmware.c
@@ -1133,6 +1133,7 @@ static const char * const fw_upload_err_str[] = {
 	[FW_UPLOAD_ERR_RW_ERROR]     = "read-write-error",
 	[FW_UPLOAD_ERR_WEAROUT]	     = "flash-wearout",
 	[FW_UPLOAD_ERR_FW_INVALID]   = "firmware-invalid",
+	[FW_UPLOAD_ERR_SKIP]         = "skip",
 };
 
 static void upload_err_inject_error(struct test_firmware_upload *tst,

-- 
2.39.5

[PATCH 2/5] firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP

[Marco Felsch]

It's no error if a driver indicates that the firmware is already
up-to-date and the update can be skipped.

Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
---
 drivers/base/firmware_loader/sysfs_upload.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
index b3cbe5b156e3..44f3d8fa5e64 100644
--- a/drivers/base/firmware_loader/sysfs_upload.c
+++ b/drivers/base/firmware_loader/sysfs_upload.c
@@ -174,6 +174,10 @@ static void fw_upload_main(struct work_struct *work)
 	fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
 	ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
 	if (ret != FW_UPLOAD_ERR_NONE) {
+		if (ret == FW_UPLOAD_ERR_SKIP) {
+			dev_info(fw_dev, "firmware already up-to-date, skip update\n");
+			ret = FW_UPLOAD_ERR_NONE;
+		}
 		fw_upload_set_error(fwlp, ret);
 		goto putdev_exit;
 	}

-- 
2.39.5

Re: [PATCH 2/5] firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP

[Russ Weight]

On Tue, Nov 19, 2024 at 11:33:51PM +0100, Marco Felsch wrote:
> It's no error if a driver indicates that the firmware is already
> up-to-date and the update can be skipped.
> 
> Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
> ---
>  drivers/base/firmware_loader/sysfs_upload.c | 4 ++++
>  1 file changed, 4 insertions(+)
> 
> diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
> index b3cbe5b156e3..44f3d8fa5e64 100644
> --- a/drivers/base/firmware_loader/sysfs_upload.c
> +++ b/drivers/base/firmware_loader/sysfs_upload.c
> @@ -174,6 +174,10 @@ static void fw_upload_main(struct work_struct *work)
>  	fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
>  	ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
>  	if (ret != FW_UPLOAD_ERR_NONE) {
> +		if (ret == FW_UPLOAD_ERR_SKIP) {
> +			dev_info(fw_dev, "firmware already up-to-date, skip update\n");
> +			ret = FW_UPLOAD_ERR_NONE;
> +		}

If you change the error-code from FW_UPLOAD_ERR_SKIP to
FW_UPLOAD_ERR_NONE, then the "skip" string provided in the previous
patch will never be seen. There are currently no other instances where
an error code requires special-case modifications to the fw_upload
code and I don't think it is necessary to add it here.

The dev_info() message above can be provided by the device driver
that is using this API.

I think you can either:

(1) allow "skip" to be treated as an error. The update didn't happen...

-or-

(2) The prepare function could detect the situation and set
    a flag in the same device driver. Your write function could
    set *written to the full data size and return without writing
    anything. Your poll_complete handler could also return
    FW_UPLOAD_ERR_NONE. Then you don't need to add FW_UPLOAD_ERR_SKIP
    at all. You would get the info message from the device driver
    and fw_upload would exit without an error.

Thanks,
- Russ

>  		fw_upload_set_error(fwlp, ret);
>  		goto putdev_exit;
>  	}
> 
> -- 
> 2.39.5
> 

Re: [PATCH 2/5] firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP

[Marco Felsch]

Hi,

On 24-11-20, Russ Weight wrote:
> On Tue, Nov 19, 2024 at 11:33:51PM +0100, Marco Felsch wrote:
> > It's no error if a driver indicates that the firmware is already
> > up-to-date and the update can be skipped.
> > 
> > Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
> > ---
> >  drivers/base/firmware_loader/sysfs_upload.c | 4 ++++
> >  1 file changed, 4 insertions(+)
> > 
> > diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
> > index b3cbe5b156e3..44f3d8fa5e64 100644
> > --- a/drivers/base/firmware_loader/sysfs_upload.c
> > +++ b/drivers/base/firmware_loader/sysfs_upload.c
> > @@ -174,6 +174,10 @@ static void fw_upload_main(struct work_struct *work)
> >  	fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
> >  	ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
> >  	if (ret != FW_UPLOAD_ERR_NONE) {
> > +		if (ret == FW_UPLOAD_ERR_SKIP) {
> > +			dev_info(fw_dev, "firmware already up-to-date, skip update\n");
> > +			ret = FW_UPLOAD_ERR_NONE;
> > +		}
> 
> If you change the error-code from FW_UPLOAD_ERR_SKIP to
> FW_UPLOAD_ERR_NONE, then the "skip" string provided in the previous
> patch will never be seen. There are currently no other instances where

Do we really need to set it? As explained within the commit message,
it's no error if FW_UPLOAD_ERR_SKIP is returned. The previous patch just
added all pieces which may be required later on.

> an error code requires special-case modifications to the fw_upload
> code and I don't think it is necessary to add it here.

Because at the moment no one is checking it except for the gb-beagleplay
driver. This driver prints a dev_warn() string and returns a failure.
Now the userspace needs some heuristic by parsing dmesg to check the
reason. This is rather complex and very error prone as the sting can be
changed in the future.

Therefore I added the support to have a simple error code which can be
returned by a driver. I'm open to return "skip" as error instead of
casting it to none. Both is fine for me since both allow the userspace
to easily check if the error is a 'real' error or if the fw-update was
just skipped due to already-up-to-date.

I wouldn't say that this is a special case, it is very common but no one
is performing a fw-version check. Therefore I added this to the common
code, to make it easier for driver devs.

> The dev_info() message above can be provided by the device driver
> that is using this API.
> 
> I think you can either:
> 
> (1) allow "skip" to be treated as an error. The update didn't happen...

Please see above.

> -or-
> 
> (2) The prepare function could detect the situation and set
>     a flag in the same device driver. Your write function could
>     set *written to the full data size and return without writing
>     anything. Your poll_complete handler could also return
>     FW_UPLOAD_ERR_NONE. Then you don't need to add FW_UPLOAD_ERR_SKIP
>     at all. You would get the info message from the device driver
>     and fw_upload would exit without an error.

Please see above. I don't think that this is special case and why making
the life hard for driver devs instead of having a well known fw
behaviour?

Regards,
  Marco

> 
> Thanks,
> - Russ
> 
> >  		fw_upload_set_error(fwlp, ret);
> >  		goto putdev_exit;
> >  	}
> > 
> > -- 
> > 2.39.5
> > 
> 

Re: [PATCH 2/5] firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP

[Russ Weight]

On Wed, Nov 20, 2024 at 06:30:37PM +0100, Marco Felsch wrote:
> Hi,
> 
> On 24-11-20, Russ Weight wrote:
> > On Tue, Nov 19, 2024 at 11:33:51PM +0100, Marco Felsch wrote:
> > > It's no error if a driver indicates that the firmware is already
> > > up-to-date and the update can be skipped.
> > > 
> > > Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
> > > ---
> > >  drivers/base/firmware_loader/sysfs_upload.c | 4 ++++
> > >  1 file changed, 4 insertions(+)
> > > 
> > > diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
> > > index b3cbe5b156e3..44f3d8fa5e64 100644
> > > --- a/drivers/base/firmware_loader/sysfs_upload.c
> > > +++ b/drivers/base/firmware_loader/sysfs_upload.c
> > > @@ -174,6 +174,10 @@ static void fw_upload_main(struct work_struct *work)
> > >  	fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
> > >  	ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
> > >  	if (ret != FW_UPLOAD_ERR_NONE) {
> > > +		if (ret == FW_UPLOAD_ERR_SKIP) {
> > > +			dev_info(fw_dev, "firmware already up-to-date, skip update\n");
> > > +			ret = FW_UPLOAD_ERR_NONE;
> > > +		}
> > 
> > If you change the error-code from FW_UPLOAD_ERR_SKIP to
> > FW_UPLOAD_ERR_NONE, then the "skip" string provided in the previous
> > patch will never be seen. There are currently no other instances where
> 
> Do we really need to set it? As explained within the commit message,
> it's no error if FW_UPLOAD_ERR_SKIP is returned. The previous patch just
> added all pieces which may be required later on.
> 
> > an error code requires special-case modifications to the fw_upload
> > code and I don't think it is necessary to add it here.
> 
> Because at the moment no one is checking it except for the gb-beagleplay
> driver. This driver prints a dev_warn() string and returns a failure.
> Now the userspace needs some heuristic by parsing dmesg to check the
> reason. This is rather complex and very error prone as the sting can be
> changed in the future.
> 
> Therefore I added the support to have a simple error code which can be
> returned by a driver. I'm open to return "skip" as error instead of
> casting it to none. Both is fine for me since both allow the userspace
> to easily check if the error is a 'real' error or if the fw-update was
> just skipped due to already-up-to-date.

Are you saying that you intend for the user-space code to see "skip"?
Because in the current implementation, I don't think the user-space
code would see "skip". If you ultimately return FW_UPLOAD_ERR_NONE,
then cat'ing the error file should result in an empty file.

> 
> I wouldn't say that this is a special case, it is very common but no one
> is performing a fw-version check. Therefore I added this to the common
> code, to make it easier for driver devs.

By "special case" I meant to say that this is the first time this
core code has had to know about any error codes other than
FW_UPLOAD_ERR_NONE - and the first time that an error type alters
the code flow.

I understand that other drivers may also want to abort if the
firmware being loaded is a duplicate.

> 
> > The dev_info() message above can be provided by the device driver
> > that is using this API.
> > 
> > I think you can either:
> > 
> > (1) allow "skip" to be treated as an error. The update didn't happen...
> 
> Please see above.
> 
> > -or-
> > 
> > (2) The prepare function could detect the situation and set
> >     a flag in the same device driver. Your write function could
> >     set *written to the full data size and return without writing
> >     anything. Your poll_complete handler could also return
> >     FW_UPLOAD_ERR_NONE. Then you don't need to add FW_UPLOAD_ERR_SKIP
> >     at all. You would get the info message from the device driver
> >     and fw_upload would exit without an error.
> 
> Please see above. I don't think that this is special case and why making
> the life hard for driver devs instead of having a well known fw
> behaviour?

If you are not opposed to treating it as an error, then all you need
to add are the error code and the string to go with it.

Instead of FW_UPLOAD_ERR_SKIP -> "skip", how about
FW_UPLOAD_ERR_DUPLICATE -> "duplicate_firmware"?

Thanks,
- Russ

> 
> Regards,
>   Marco
> 
> > 
> > Thanks,
> > - Russ
> > 
> > >  		fw_upload_set_error(fwlp, ret);
> > >  		goto putdev_exit;
> > >  	}
> > > 
> > > -- 
> > > 2.39.5
> > > 
> > 

Re: [PATCH 2/5] firmware_loader: add support to handle FW_UPLOAD_ERR_SKIP

[Marco Felsch]

On 24-11-20, Russ Weight wrote:
> 
> On Wed, Nov 20, 2024 at 06:30:37PM +0100, Marco Felsch wrote:
> > Hi,
> > 
> > On 24-11-20, Russ Weight wrote:
> > > On Tue, Nov 19, 2024 at 11:33:51PM +0100, Marco Felsch wrote:
> > > > It's no error if a driver indicates that the firmware is already
> > > > up-to-date and the update can be skipped.
> > > > 
> > > > Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
> > > > ---
> > > >  drivers/base/firmware_loader/sysfs_upload.c | 4 ++++
> > > >  1 file changed, 4 insertions(+)
> > > > 
> > > > diff --git a/drivers/base/firmware_loader/sysfs_upload.c b/drivers/base/firmware_loader/sysfs_upload.c
> > > > index b3cbe5b156e3..44f3d8fa5e64 100644
> > > > --- a/drivers/base/firmware_loader/sysfs_upload.c
> > > > +++ b/drivers/base/firmware_loader/sysfs_upload.c
> > > > @@ -174,6 +174,10 @@ static void fw_upload_main(struct work_struct *work)
> > > >  	fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
> > > >  	ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
> > > >  	if (ret != FW_UPLOAD_ERR_NONE) {
> > > > +		if (ret == FW_UPLOAD_ERR_SKIP) {
> > > > +			dev_info(fw_dev, "firmware already up-to-date, skip update\n");
> > > > +			ret = FW_UPLOAD_ERR_NONE;
> > > > +		}
> > > 
> > > If you change the error-code from FW_UPLOAD_ERR_SKIP to
> > > FW_UPLOAD_ERR_NONE, then the "skip" string provided in the previous
> > > patch will never be seen. There are currently no other instances where
> > 
> > Do we really need to set it? As explained within the commit message,
> > it's no error if FW_UPLOAD_ERR_SKIP is returned. The previous patch just
> > added all pieces which may be required later on.
> > 
> > > an error code requires special-case modifications to the fw_upload
> > > code and I don't think it is necessary to add it here.
> > 
> > Because at the moment no one is checking it except for the gb-beagleplay
> > driver. This driver prints a dev_warn() string and returns a failure.
> > Now the userspace needs some heuristic by parsing dmesg to check the
> > reason. This is rather complex and very error prone as the sting can be
> > changed in the future.
> > 
> > Therefore I added the support to have a simple error code which can be
> > returned by a driver. I'm open to return "skip" as error instead of
> > casting it to none. Both is fine for me since both allow the userspace
> > to easily check if the error is a 'real' error or if the fw-update was
> > just skipped due to already-up-to-date.
> 
> Are you saying that you intend for the user-space code to see "skip"?
> Because in the current implementation, I don't think the user-space
> code would see "skip". If you ultimately return FW_UPLOAD_ERR_NONE,
> then cat'ing the error file should result in an empty file.

I know.

> > I wouldn't say that this is a special case, it is very common but no one
> > is performing a fw-version check. Therefore I added this to the common
> > code, to make it easier for driver devs.
> 
> By "special case" I meant to say that this is the first time this
> core code has had to know about any error codes other than
> FW_UPLOAD_ERR_NONE - and the first time that an error type alters
> the code flow.
> 
> I understand that other drivers may also want to abort if the
> firmware being loaded is a duplicate.

:)

> > > The dev_info() message above can be provided by the device driver
> > > that is using this API.
> > > 
> > > I think you can either:
> > > 
> > > (1) allow "skip" to be treated as an error. The update didn't happen...
> > 
> > Please see above.
> > 
> > > -or-
> > > 
> > > (2) The prepare function could detect the situation and set
> > >     a flag in the same device driver. Your write function could
> > >     set *written to the full data size and return without writing
> > >     anything. Your poll_complete handler could also return
> > >     FW_UPLOAD_ERR_NONE. Then you don't need to add FW_UPLOAD_ERR_SKIP
> > >     at all. You would get the info message from the device driver
> > >     and fw_upload would exit without an error.
> > 
> > Please see above. I don't think that this is special case and why making
> > the life hard for driver devs instead of having a well known fw
> > behaviour?
> 
> If you are not opposed to treating it as an error, then all you need
> to add are the error code and the string to go with it.

Yep this works for me.

> Instead of FW_UPLOAD_ERR_SKIP -> "skip", how about
> FW_UPLOAD_ERR_DUPLICATE -> "duplicate_firmware"?

Fine by me :) I can use this if no one else comes up with a better idea
for the string.

Regards,
  Marco

[PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Marco Felsch]

From: Kamel Bouhara <kamel.bouhara@bootlin.com>

Add vendor prefix for TouchNetix AS (https://www.touchnetix.com/products/).

Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
---
 Documentation/devicetree/bindings/vendor-prefixes.yaml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Documentation/devicetree/bindings/vendor-prefixes.yaml b/Documentation/devicetree/bindings/vendor-prefixes.yaml
index b320a39de7fe..c40170c0c387 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.yaml
+++ b/Documentation/devicetree/bindings/vendor-prefixes.yaml
@@ -1515,6 +1515,8 @@ patternProperties:
     description: Toradex AG
   "^toshiba,.*":
     description: Toshiba Corporation
+  "^touchnetix,.*":
+    description: TouchNetix AS
   "^toumaz,.*":
     description: Toumaz
   "^tpk,.*":

-- 
2.39.5

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Krzysztof Kozlowski]

On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
> From: Kamel Bouhara <kamel.bouhara@bootlin.com>
> 
> Add vendor prefix for TouchNetix AS (https://www.touchnetix.com/products/).
> 
> Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
> Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
> Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>

I think this did not happen (only Ack).

Best regards,
Krzysztof

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Marco Felsch]

On 24-11-20, Krzysztof Kozlowski wrote:
> On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
> > From: Kamel Bouhara <kamel.bouhara@bootlin.com>
> > 
> > Add vendor prefix for TouchNetix AS (https://www.touchnetix.com/products/).
> > 
> > Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
> > Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
> > Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
> 
> I think this did not happen (only Ack).

Huh.. I used b4 to retrieve the latest Bootlin version. According [1] it
was already present :/ I can drop it if you want.

[1] https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/

Regards,
  Marco

> 
> Best regards,
> Krzysztof
> 
> 

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Krzysztof Kozlowski]

On 20/11/2024 09:15, Marco Felsch wrote:
> On 24-11-20, Krzysztof Kozlowski wrote:
>> On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
>>> From: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>>
>>> Add vendor prefix for TouchNetix AS (https://www.touchnetix.com/products/).
>>>
>>> Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>> Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>> Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>
>> I think this did not happen (only Ack).
> 
> Huh.. I used b4 to retrieve the latest Bootlin version. According [1] it
> was already present :/ I can drop it if you want.
> 
> [1] https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
> 
Hm? This points to entirely different patch!

Best regards,
Krzysztof

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Kamel BOUHARA]

Le 2024-11-21 08:47, Krzysztof Kozlowski a écrit :
> On 20/11/2024 09:15, Marco Felsch wrote:
>> On 24-11-20, Krzysztof Kozlowski wrote:
>>> On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
>>>> From: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>>> 
>>>> Add vendor prefix for TouchNetix AS 
>>>> (https://www.touchnetix.com/products/).
>>>> 
>>>> Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>>> Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>>> Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>> 
>>> I think this did not happen (only Ack).
>> 
>> Huh.. I used b4 to retrieve the latest Bootlin version. According [1] 
>> it
>> was already present :/ I can drop it if you want.
>> 
>> [1] 
>> https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
>> 
> Hm? This points to entirely different patch!
> 

Hello Marco,

I think the last review from Krzystof is on v7 [1] ?

[1]: 
https://lore.kernel.org/linux-kernel/821ce1d4-bc15-4764-bbe0-315c57e8536e@linaro.org/

Regards,
--
Kamel Bouhara, Bootlin
Embedded Linux and kernel engineering
https://bootlin.com

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Marco Felsch]

On 24-11-21, Kamel BOUHARA wrote:
> Le 2024-11-21 08:47, Krzysztof Kozlowski a écrit :
> > On 20/11/2024 09:15, Marco Felsch wrote:
> > > On 24-11-20, Krzysztof Kozlowski wrote:
> > > > On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
> > > > > From: Kamel Bouhara <kamel.bouhara@bootlin.com>
> > > > > 
> > > > > Add vendor prefix for TouchNetix AS
> > > > > (https://www.touchnetix.com/products/).
> > > > > 
> > > > > Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
> > > > > Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
> > > > > Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
> > > > 
> > > > I think this did not happen (only Ack).
> > > 
> > > Huh.. I used b4 to retrieve the latest Bootlin version. According
> > > [1] it
> > > was already present :/ I can drop it if you want.
> > > 
> > > [1] https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
> > > 
> > Hm? This points to entirely different patch!
> > 
> 
> Hello Marco,
> 
> I think the last review from Krzystof is on v7 [1] ?
> 
> [1]: https://lore.kernel.org/linux-kernel/821ce1d4-bc15-4764-bbe0-315c57e8536e@linaro.org/

Yeah Krzysztof is right, I pointed to the wrong patch, but still I
didn't added the reviewed-by tag but b4 did. I ran it again and here it
is:

$ b4 am https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
Grabbing thread from lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/t.mbox.gz
Analyzing 9 messages in the thread
Looking for additional code-review trailers on lore.kernel.org
Analyzing 137 code-review messages
Checking attestation on all messages, may take a moment...
---
  ✓ [PATCH v16 1/3] dt-bindings: vendor-prefixes: Add TouchNetix AS
    + Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> (✗ DKIM/linaro.org)
  ✓ [PATCH v16 2/3] dt-bindings: input: Add TouchNetix axiom touchscreen
  ✓ [PATCH v16 3/3] Input: Add TouchNetix axiom i2c touchscreen driver
  ---
  ✓ Signed: DKIM/bootlin.com
---
Total patches: 3

Krzysztof I'm sorry, shall I drop it from the next version?

Regards,
  Marco

Re: [PATCH 3/5] dt-bindings: vendor-prefixes: Add TouchNetix AS

[Krzysztof Kozlowski]

On 21/11/2024 09:45, Marco Felsch wrote:
> On 24-11-21, Kamel BOUHARA wrote:
>> Le 2024-11-21 08:47, Krzysztof Kozlowski a écrit :
>>> On 20/11/2024 09:15, Marco Felsch wrote:
>>>> On 24-11-20, Krzysztof Kozlowski wrote:
>>>>> On Tue, Nov 19, 2024 at 11:33:52PM +0100, Marco Felsch wrote:
>>>>>> From: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>>>>>
>>>>>> Add vendor prefix for TouchNetix AS
>>>>>> (https://www.touchnetix.com/products/).
>>>>>>
>>>>>> Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
>>>>>> Acked-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>>>>> Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
>>>>>
>>>>> I think this did not happen (only Ack).
>>>>
>>>> Huh.. I used b4 to retrieve the latest Bootlin version. According
>>>> [1] it
>>>> was already present :/ I can drop it if you want.
>>>>
>>>> [1] https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
>>>>
>>> Hm? This points to entirely different patch!
>>>
>>
>> Hello Marco,
>>
>> I think the last review from Krzystof is on v7 [1] ?
>>
>> [1]: https://lore.kernel.org/linux-kernel/821ce1d4-bc15-4764-bbe0-315c57e8536e@linaro.org/
> 
> Yeah Krzysztof is right, I pointed to the wrong patch, but still I
> didn't added the reviewed-by tag but b4 did. I ran it again and here it
> is:


I know, it happens sometimes. I also experienced it.

> 
> $ b4 am https://lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/
> Grabbing thread from lore.kernel.org/all/20240703142520.207066-3-kamel.bouhara@bootlin.com/t.mbox.gz
> Analyzing 9 messages in the thread
> Looking for additional code-review trailers on lore.kernel.org
> Analyzing 137 code-review messages
> Checking attestation on all messages, may take a moment...
> ---
>   ✓ [PATCH v16 1/3] dt-bindings: vendor-prefixes: Add TouchNetix AS
>     + Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> (✗ DKIM/linaro.org)
>   ✓ [PATCH v16 2/3] dt-bindings: input: Add TouchNetix axiom touchscreen
>   ✓ [PATCH v16 3/3] Input: Add TouchNetix axiom i2c touchscreen driver
>   ---
>   ✓ Signed: DKIM/bootlin.com
> ---
> Total patches: 3
> 
> Krzysztof I'm sorry, shall I drop it from the next version?

Yeah, please drop from this patch and keep only Ack here.

Best regards,
Krzysztof

[PATCH 4/5] dt-bindings: input: Add TouchNetix axiom touchscreen

[Marco Felsch]

From: Kamel Bouhara <kamel.bouhara@bootlin.com>

Add the TouchNetix axiom I2C touchscreen device tree bindings
documentation.

Signed-off-by: Kamel Bouhara <kamel.bouhara@bootlin.com>
Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
[m.felsch@pengutronix.de: add myself to the maintainers]
[m.felsch@pengutronix.de: add 2nd i2c address]
Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
---
 .../input/touchscreen/touchnetix,ax54a.yaml        | 62 ++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.yaml b/Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.yaml
new file mode 100644
index 000000000000..3ffe6e533dfe
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.yaml
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/input/touchscreen/touchnetix,ax54a.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: TouchNetix Axiom series touchscreen controller
+
+maintainers:
+  - Marco Felsch <kernel@pengutronix.de>
+
+allOf:
+  - $ref: /schemas/input/touchscreen/touchscreen.yaml#
+  - $ref: /schemas/input/input.yaml#
+
+properties:
+  compatible:
+    const: touchnetix,ax54a
+
+  reg:
+    enum: [ 0x66, 0x67 ]
+
+  interrupts:
+    maxItems: 1
+
+  reset-gpios:
+    maxItems: 1
+
+  vdda-supply:
+    description: Analog power supply regulator on VDDA pin
+
+  vddi-supply:
+    description: I/O power supply regulator on VDDI pin
+
+required:
+  - compatible
+  - reg
+  - vdda-supply
+  - vddi-supply
+
+unevaluatedProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/gpio/gpio.h>
+    #include <dt-bindings/interrupt-controller/arm-gic.h>
+    i2c {
+      #address-cells = <1>;
+      #size-cells = <0>;
+
+      touchscreen@66 {
+        compatible = "touchnetix,ax54a";
+        reg = <0x66>;
+        interrupt-parent = <&gpio2>;
+        interrupts = <2 IRQ_TYPE_EDGE_FALLING>;
+        reset-gpios = <&gpio1 1 GPIO_ACTIVE_HIGH>;
+        vdda-supply = <&vdda_reg>;
+        vddi-supply = <&vddi_reg>;
+        poll-interval = <20>;
+      };
+    };
+...

-- 
2.39.5

[PATCH 5/5] Input: Add TouchNetix aXiom I2C Touchscreen support

[Marco Felsch]

This adds the initial support for the TouchNetix AX54A touchcontroller
which is part of TouchNetix's aXiom family of touchscreen controllers.

The TouchNetix aXiom family provides two physical interfaces: SPI and
I2C. This patch covers only the I2C interface. Apart the input event
handling the driver support firmware updates too. One firmware interface
is to handle the touchcontroller firmware (AXFW and ALC supported)
update the other is to handle the touchcontroller configuration
(TH2CFGBIN) update.

Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
---
 drivers/input/touchscreen/Kconfig            |   15 +
 drivers/input/touchscreen/Makefile           |    1 +
 drivers/input/touchscreen/touchnetix_axiom.c | 2764 ++++++++++++++++++++++++++
 3 files changed, 2780 insertions(+)

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 1ac26fc2e3eb..654d38abd692 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -792,6 +792,21 @@ config TOUCHSCREEN_MIGOR
 	  To compile this driver as a module, choose M here: the
 	  module will be called migor_ts.
 
+config TOUCHSCREEN_TOUCHNETIX_AXIOM
+	tristate "TouchNetix aXiom based touchscreen controllers"
+	depends on I2C
+	select CRC16
+	select CRC32
+	select REGMAP_I2C
+	help
+	  Say Y here if you have a axiom touchscreen connected to
+	  your system.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called touchnetix_axiom.
+
 config TOUCHSCREEN_TOUCHRIGHT
 	tristate "Touchright serial touchscreen"
 	select SERIO
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 82bc837ca01e..e6b829720168 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -87,6 +87,7 @@ obj-$(CONFIG_TOUCHSCREEN_SUR40)		+= sur40.o
 obj-$(CONFIG_TOUCHSCREEN_SURFACE3_SPI)	+= surface3_spi.o
 obj-$(CONFIG_TOUCHSCREEN_TI_AM335X_TSC)	+= ti_am335x_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)	+= touchit213.o
+obj-$(CONFIG_TOUCHSCREEN_TOUCHNETIX_AXIOM)	+= touchnetix_axiom.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)	+= touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)	+= touchwin.o
 obj-$(CONFIG_TOUCHSCREEN_TS4800)	+= ts4800-ts.o
diff --git a/drivers/input/touchscreen/touchnetix_axiom.c b/drivers/input/touchscreen/touchnetix_axiom.c
new file mode 100644
index 000000000000..52495edf38b6
--- /dev/null
+++ b/drivers/input/touchscreen/touchnetix_axiom.c
@@ -0,0 +1,2764 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * TouchNetix aXiom Touchscreen Driver
+ *
+ * Copyright (C) 2024 Pengutronix
+ *
+ * Marco Felsch <kernel@pengutronix.de>
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bits.h>
+#include <linux/completion.h>
+#include <linux/crc16.h>
+#include <linux/crc32.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/firmware.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/pm_runtime.h>
+#include <linux/property.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+#include <linux/time.h>
+#include <linux/unaligned.h>
+
+/*
+ * Short introduction for developers:
+ *  The programming manual is written based on u(sages):
+ *   - Max. 0xff usages possible
+ *   - A usage is a group of registers (0x00 ... 0xff)
+ *   - The usage base address must be discovered (FW dependent)
+ *   - Partial RW usage access is allowed
+ *   - Each usage has a revision (FW dependent)
+ *   - Only u31 is always at address 0x0 (used for discovery)
+ *
+ *  E.x. Reading register 0x01 for usage u03 with baseaddr 0x20 results in the
+ *  following physical 16bit I2C address: 0x2001.
+ *
+ * Note the datasheet specifies the usage numbers in hex and the internal
+ * offsets in decimal. Keep it that way to make it more developer friendly.
+ */
+#define AXIOM_U01				0x01
+#define AXIOM_U01_REV1_REPORTTYPE_REG		0
+#define   AXIOM_U01_REV1_REPORTTYPE_HELLO	0
+#define   AXIOM_U01_REV1_REPORTTYPE_HEARTBEAT	1
+#define   AXIOM_U01_REV1_REPORTTYPE_OPCOMPLETE	3
+
+#define AXIOM_U02					0x02
+#define AXIOM_U02_REV1_COMMAND_REG			0
+#define   AXIOM_U02_REV1_CMD_HARDRESET			0x0001
+#define   AXIOM_U02_REV1_CMD_SOFTRESET			0x0002
+#define   AXIOM_U02_REV1_CMD_STOP			0x0005
+#define   AXIOM_U02_REV1_CMD_SAVEVLTLCFG2NVM		0x0007
+#define   AXIOM_U02_REV1_PARAM1_SAVEVLTLCFG2NVM		0xb10c
+#define   AXIOM_U02_REV1_PARAM2_SAVEVLTLCFG2NVM		0xc0de
+#define   AXIOM_U02_REV1_CMD_HANDSHAKENVM		0x0008
+#define   AXIOM_U02_REV1_CMD_COMPUTECRCS		0x0009
+#define   AXIOM_U02_REV1_CMD_FILLCONFIG			0x000a
+#define   AXIOM_U02_REV1_PARAM0_FILLCONFIG		0x5555
+#define   AXIOM_U02_REV1_PARAM1_FILLCONFIG		0xaaaa
+#define   AXIOM_U02_REV1_PARAM2_FILLCONFIG_ZERO		0xa55a
+#define   AXIOM_U02_REV1_CMD_ENTERBOOTLOADER		0x000b
+#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY1	0x5555
+#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY2	0xaaaa
+#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY3	0xa55a
+#define   AXIOM_U02_REV1_RESP_SUCCESS			0x0000
+
+struct axiom_u02_rev1_system_manager_msg {
+	union {
+		__le16 command;
+		__le16 response;
+	};
+	__le16 parameters[3];
+};
+
+#define AXIOM_U04				0x04
+#define   AXIOM_U04_REV1_SIZE_BYTES		128
+
+#define AXIOM_U05				0x05	/* CDU */
+
+#define AXIOM_U22				0x22	/* CDU */
+
+#define AXIOM_U31				0x31
+#define AXIOM_U31_REV1_PAGE0			0x0000
+#define AXIOM_U31_REV1_DEVICE_ID_LOW_REG	(AXIOM_U31_REV1_PAGE0 + 0)
+#define AXIOM_U31_REV1_DEVICE_ID_HIGH_REG	(AXIOM_U31_REV1_PAGE0 + 1)
+#define   AXIOM_U31_REV1_MODE_MASK		BIT(7)
+#define   AXIOM_U31_REV1_MODE_BLP		1
+#define   AXIOM_U31_REV1_DEVICE_ID_HIGH_MASK	GENMASK(6, 0)
+#define AXIOM_U31_REV1_RUNTIME_FW_MIN_REG	(AXIOM_U31_REV1_PAGE0 + 2)
+#define AXIOM_U31_REV1_RUNTIME_FW_MAJ_REG	(AXIOM_U31_REV1_PAGE0 + 3)
+#define AXIOM_U31_REV1_RUNTIME_FW_STATUS_REG	(AXIOM_U31_REV1_PAGE0 + 4)
+#define   AXIOM_U31_REV1_RUNTIME_FW_STATUS	BIT(7)
+#define AXIOM_U31_REV1_JEDEC_ID_LOW_REG		(AXIOM_U31_REV1_PAGE0 + 8)
+#define AXIOM_U31_REV1_JEDEC_ID_HIGH_REG	(AXIOM_U31_REV1_PAGE0 + 9)
+#define AXIOM_U31_REV1_NUM_USAGES_REG		(AXIOM_U31_REV1_PAGE0 + 10)
+#define AXIOM_U31_REV1_RUNTIME_FW_RC_REG	(AXIOM_U31_REV1_PAGE0 + 11)
+#define   AXIOM_U31_REV1_RUNTIME_FW_RC_MASK	GENMASK(7, 4)
+#define   AXIOM_U31_REV1_SILICON_REV_MASK	GENMASK(3, 0)
+
+#define AXIOM_U31_REV1_PAGE1			0x0100
+#define   AXIOM_U31_REV1_OFFSET_TYPE_MASK	BIT(7)
+#define   AXIOM_U31_REV1_MAX_OFFSET_MASK	GENMASK(6, 0)
+
+#define AXIOM_U32				0x32
+
+struct axiom_u31_usage_table_entry {
+	u8 usage_num;
+	u8 start_page;
+	u8 num_pages;
+	u8 max_offset;
+	u8 uifrevision;
+	u8 reserved;
+} __packed;
+
+#define AXIOM_U33				0x33
+
+struct axiom_u33_rev2 {
+	__le32 runtime_crc;
+	__le32 runtime_nvm_crc;
+	__le32 bootloader_crc;
+	__le32 nvltlusageconfig_crc;
+	__le32 vltusageconfig_crc;
+	__le32 u22_sequencedata_crc;
+	__le32 u43_hotspots_crc;
+	__le32 u93_profiles_crc;
+	__le32 u94_deltascalemap_crc;
+	__le32 runtimehash_crc;
+};
+
+#define AXIOM_U34				0x34
+#define   AXIOM_U34_REV1_OVERFLOW_MASK		BIT(7)
+#define   AXIOM_U34_REV1_REPORTLENGTH_MASK	GENMASK(6, 0)
+#define   AXIOM_U34_REV1_PREAMBLE_BYTES		2
+#define   AXIOM_U34_REV1_POSTAMBLE_BYTES	4
+
+#define AXIOM_U36				0x36
+
+#define AXIOM_U41				0x41
+#define AXIOM_U41_REV2_TARGETSTATUS_REG		0
+#define AXIOM_U41_REV2_X_REG(id)		((4 * (id)) + 2)
+#define AXIOM_U41_REV2_Y_REG(id)		((4 * (id)) + 4)
+#define AXIOM_U41_REV2_Z_REG(id)		((id) + 42)
+
+#define AXIOM_U42				0x42
+#define AXIOM_U42_REV1_REPORT_ID_CONTAINS(id)	((id) + 2)
+#define   AXIOM_U42_REV1_REPORT_ID_TOUCH	1	/* Touch, Proximity, Hover */
+
+#define AXIOM_U43				0x43	/* CDU */
+
+#define AXIOM_U64					0x64
+#define   AXIOM_U64_REV2_ENABLECDSPROCESSING_REG	0
+#define   AXIOM_U64_REV2_ENABLECDSPROCESSING_MASK	BIT(0)
+
+#define AXIOM_U77				0x77	/* CDU */
+#define AXIOM_U82				0x82
+#define AXIOM_U93				0x93	/* CDU */
+#define AXIOM_U94				0x94	/* CDU */
+
+/*
+ * Axiom CDU usage structure copied from downstream CDU_Common.py. Downstream
+ * doesn't mention any revision. According downstream all CDU register windows
+ * are 56 byte wide (8 byte header + 48 byte data).
+ */
+#define AXIOM_CDU_CMD_STORE			0x0002
+#define AXIOM_CDU_CMD_COMMIT			0x0003
+#define AXIOM_CDU_PARAM0_COMMIT			0xb10c
+#define AXIOM_CDU_PARAM1_COMMIT			0xc0de
+
+#define AXIOM_CDU_RESP_SUCCESS			0x0000
+#define AXIOM_CDU_MAX_DATA_BYTES		48
+
+struct axiom_cdu_usage {
+	union {
+		__le16 command;
+		__le16 response;
+	};
+	__le16 parameters[3];
+	u8 data[AXIOM_CDU_MAX_DATA_BYTES];
+};
+
+/*
+ * u01 for the bootloader protocol (BLP)
+ *
+ * Values taken from Bootloader.py [1] which had a comment that documentation
+ * values are out dated. The BLP does not have different versions according the
+ * documentation python helper.
+ *
+ * [1] https://github.com/TouchNetix/axiom_pylib
+ */
+#define AXIOM_U01_BLP_COMMAND_REG		0x0100
+#define   AXIOM_U01_BLP_COMMAND_RESET		BIT(1)
+#define AXIOM_U01_BLP_SATUS_REG			0x0100
+#define   AXIOM_U01_BLP_STATUS_BUSY		BIT(0)
+#define AXIOM_U01_BLP_FIFO_REG			0x0102
+#define   AXIOM_U01_BLP_FIFO_CHK_SIZE_BYTES	255
+
+#define AXIOM_PROX_LEVEL			-128
+#define AXIOM_STARTUP_TIME_MS			110
+
+#define AXIOM_USAGE_BASEADDR_MASK		GENMASK(15, 8)
+#define AXIOM_MAX_USAGES			256	/* u00 - uFF */
+/*
+ * The devices have a 16bit ADC but Touchnetix used the lower two bits for other
+ * information.
+ */
+#define AXIOM_MAX_XY				(65535 - 3)
+#define AXIOM_DEFAULT_POLL_INTERVAL_MS		10
+#define AXIOM_PAGE_BYTE_LEN			256
+#define AXIOM_MAX_XFERLEN			0x7fff
+#define AXIOM_MAX_TOUCHSLOTS			10
+#define AXIOM_MAX_TOUCHSLOTS_MASK		GENMASK(9, 0)
+
+/* aXiom firmware (.axfw) */
+#define AXIOM_FW_AXFW_SIGNATURE			"AXFW"
+#define AXIOM_FW_AXFW_FILE_FMT_VER		0x0200
+
+struct axiom_fw_axfw_hdr {
+	u8 signature[4];
+	__le32 file_crc32;
+	__le16 file_format_ver;
+	__le16 device_id;
+	u8 variant;
+	u8 minor_ver;
+	u8 major_ver;
+	u8 rc_ver;
+	u8 status;
+	__le16 silicon_ver;
+	u8 silicon_rev;
+	__le32 fw_crc32;
+} __packed;
+
+struct axiom_fw_axfw_chunk_hdr {
+	u8 internal[6]; /* no description */
+	__be16 payload_length;
+};
+
+/* aXiom config (.th2cfgbin) */
+#define AXIOM_FW_CFG_SIGNATURE			0x20071969
+
+struct axiom_fw_cfg_hdr {
+	__be32 signature;
+	__le16 file_format_ver;
+	__le16 tcp_file_rev_major;
+	__le16 tcp_file_rev_minor;
+	__le16 tcp_file_rev_patch;
+	u8 tcp_version;
+} __packed;
+
+struct axiom_fw_cfg_chunk_hdr {
+	u8 usage_num;
+	u8 usage_rev;
+	u8 reserved;
+	__le16 usage_length;
+} __packed;
+
+struct axiom_fw_cfg_chunk {
+	u8 usage_num;
+	u8 usage_rev;
+	u16 usage_length;
+	const u8 *usage_content;
+};
+
+enum axiom_fw_type {
+	AXIOM_FW_AXFW,
+	AXIOM_FW_CFG,
+	AXIOM_FW_NUM
+};
+
+enum axiom_crc_type {
+	AXIOM_CRC_CUR,
+	AXIOM_CRC_NEW,
+	AXIOM_CRC_NUM
+};
+
+struct axiom_data;
+
+struct axiom_usage_info {
+	unsigned char usage_num;	/* uXX number (XX in hex) */
+	unsigned char rev_num;		/* rev.X (X in dec) */
+	bool is_cdu;
+	bool is_ro;
+
+	/* Optional hooks */
+	int (*process_report)(struct axiom_data *ts, const u8 *buf, size_t bufsize);
+};
+
+enum axiom_runmode {
+	AXIOM_DISCOVERY_MODE,
+	AXIOM_TCP_MODE,
+	AXIOM_TCP_CFG_UPDATE_MODE,
+	AXIOM_BLP_PRE_MODE,
+	AXIOM_BLP_MODE,
+};
+
+struct axiom_data {
+	struct input_dev *input;
+	struct device *dev;
+
+	struct gpio_desc *reset_gpio;
+	struct regulator_bulk_data supplies[2];
+	unsigned int num_supplies;
+
+	struct regmap *regmap;
+	struct touchscreen_properties prop;
+	bool irq_setup_done;
+	u32 poll_interval;
+
+	enum axiom_runmode mode;
+	/*
+	 * Two completion types to support firmware updates
+	 * in irq and poll mode.
+	 */
+	struct axiom_completion {
+		struct completion completion;
+		bool poll_done;
+	} nvm_write, boot_complete;
+
+	/* Lock to protect both firmware interfaces */
+	struct mutex fwupdate_lock;
+	struct axiom_firmware {
+		/* Lock to protect cancel */
+		struct mutex lock;
+		bool cancel;
+		struct fw_upload *fwl;
+	} fw[AXIOM_FW_NUM];
+
+	unsigned int fw_major;
+	unsigned int fw_minor;
+	unsigned int fw_rc;
+	unsigned int fw_status;
+	u16 device_id;
+	u16 jedec_id;
+	u8 silicon_rev;
+
+	/* CRCs we need to check during a config update */
+	struct axiom_crc {
+		u32 runtime;
+		u32 vltusageconfig;
+		u32 nvltlusageconfig;
+		u32 u22_sequencedata;
+		u32 u43_hotspots;
+		u32 u93_profiles;
+		u32 u94_deltascalemap;
+	} crc[AXIOM_CRC_NUM];
+
+	bool cds_enabled;
+	unsigned long enabled_slots;
+	unsigned int num_slots;
+
+	unsigned int max_report_byte_len;
+	struct axiom_usage_table_entry {
+		bool populated;
+		unsigned int baseaddr;
+		unsigned int size_bytes;
+		const struct axiom_usage_info *info;
+	} usage_table[AXIOM_MAX_USAGES];
+};
+
+static int axiom_u01_rev1_process_report(struct axiom_data *ts, const u8 *buf,
+					 size_t bufsize);
+static int axiom_u34_rev1_process_report(struct axiom_data *ts, const u8 *_buf,
+					 size_t bufsize);
+static int axiom_u41_rev2_process_report(struct axiom_data *ts, const u8 *buf,
+					 size_t bufsize);
+
+#define AXIOM_USAGE(num, rev)		\
+	{				\
+		.usage_num = num,	\
+		.rev_num = rev,		\
+	}
+
+#define AXIOM_RO_USAGE(num, rev)	\
+	{				\
+		.usage_num = num,	\
+		.rev_num = rev,		\
+		.is_ro = true,		\
+	}
+
+#define AXIOM_CDU_USAGE(num, rev)	\
+	{				\
+		.usage_num = num,	\
+		.rev_num = rev,		\
+		.is_cdu = true,		\
+	}
+
+#define AXIOM_REPORT_USAGE(num, rev, func)	\
+	{					\
+		.usage_num = num,		\
+		.rev_num = rev,			\
+		.process_report = func,		\
+	}
+
+/*
+ * All usages used by driver must be added to this list to ensure the
+ * correct communictation with the devices. The list can contain multiple
+ * entries of the same usage to handle different usage revisions.
+ *
+ * Note: During a th2cfgbin update the driver may use usages not listed here.
+ * Therefore the th2cfgbin update compares the current running FW again the
+ * th2cfgbin targets FW.
+ */
+static const struct axiom_usage_info driver_required_usages[] = {
+	AXIOM_REPORT_USAGE(AXIOM_U01, 1, axiom_u01_rev1_process_report),
+	AXIOM_USAGE(AXIOM_U02, 1),
+	AXIOM_USAGE(AXIOM_U02, 2),
+	AXIOM_USAGE(AXIOM_U04, 1),
+	AXIOM_CDU_USAGE(AXIOM_U05, 1),
+	AXIOM_CDU_USAGE(AXIOM_U22, 1),
+	AXIOM_RO_USAGE(AXIOM_U31, 1),
+	AXIOM_RO_USAGE(AXIOM_U32, 1),
+	AXIOM_RO_USAGE(AXIOM_U33, 2),
+	AXIOM_RO_USAGE(AXIOM_U36, 1),
+	AXIOM_REPORT_USAGE(AXIOM_U34, 1, axiom_u34_rev1_process_report),
+	AXIOM_REPORT_USAGE(AXIOM_U41, 2, axiom_u41_rev2_process_report),
+	AXIOM_USAGE(AXIOM_U42, 1),
+	AXIOM_CDU_USAGE(AXIOM_U43, 1),
+	AXIOM_USAGE(AXIOM_U64, 2),
+	AXIOM_CDU_USAGE(AXIOM_U77, 1),
+	AXIOM_RO_USAGE(AXIOM_U82, 1),
+	AXIOM_CDU_USAGE(AXIOM_U93, 1),
+	AXIOM_CDU_USAGE(AXIOM_U94, 1),
+	{ /* sentinel */ }
+};
+
+/************************ Common helpers **************************************/
+
+static void axiom_set_runmode(struct axiom_data *ts, enum axiom_runmode mode)
+{
+	ts->mode = mode;
+}
+
+static enum axiom_runmode axiom_get_runmode(struct axiom_data *ts)
+{
+	return ts->mode;
+}
+
+static const char *axiom_runmode_to_string(struct axiom_data *ts)
+{
+	switch (ts->mode) {
+	case AXIOM_DISCOVERY_MODE:	return "discovery";
+	case AXIOM_TCP_MODE:		return "tcp";
+	case AXIOM_TCP_CFG_UPDATE_MODE:	return "th2cfg-update";
+	case AXIOM_BLP_PRE_MODE:	return "bootloader-pre";
+	case AXIOM_BLP_MODE:		return "bootlaoder";
+	default:			return "unknown";
+	}
+}
+
+static bool axiom_skip_usage_check(struct axiom_data *ts)
+{
+	switch (ts->mode) {
+	case AXIOM_TCP_CFG_UPDATE_MODE:
+	case AXIOM_DISCOVERY_MODE:
+	case AXIOM_BLP_MODE:
+		return true;
+	case AXIOM_BLP_PRE_MODE:
+	case AXIOM_TCP_MODE:
+	default:
+		return false;
+	}
+}
+
+static unsigned int
+axiom_usage_baseaddr(struct axiom_data *ts, unsigned char usage_num)
+{
+	return ts->usage_table[usage_num].baseaddr;
+}
+
+static unsigned int
+axiom_usage_size(struct axiom_data *ts, unsigned char usage_num)
+{
+	return ts->usage_table[usage_num].size_bytes;
+}
+
+static int
+axiom_usage_rev(struct axiom_data *ts, unsigned char usage_num)
+{
+	struct axiom_usage_table_entry *entry = &ts->usage_table[usage_num];
+
+	if (!entry->info)
+		return -EINVAL;
+
+	return entry->info->rev_num;
+}
+
+static bool
+axiom_usage_entry_is_report(struct axiom_u31_usage_table_entry *entry)
+{
+	return entry->num_pages == 0;
+}
+
+static unsigned int
+axiom_get_usage_size_bytes(struct axiom_u31_usage_table_entry *entry)
+{
+	unsigned char max_offset;
+
+	max_offset = FIELD_GET(AXIOM_U31_REV1_MAX_OFFSET_MASK,
+			       entry->max_offset) + 1;
+	max_offset *= 2;
+
+	if (axiom_usage_entry_is_report(entry))
+		return max_offset;
+
+	if (FIELD_GET(AXIOM_U31_REV1_OFFSET_TYPE_MASK, entry->max_offset))
+		return (entry->num_pages - 1) * AXIOM_PAGE_BYTE_LEN + max_offset;
+
+	return max_offset;
+}
+
+static void axiom_dump_usage_entry(struct device *dev,
+				   struct axiom_u31_usage_table_entry *entry)
+{
+	unsigned int page_len, total_len;
+
+	total_len = axiom_get_usage_size_bytes(entry);
+
+	if (total_len > AXIOM_PAGE_BYTE_LEN)
+		page_len = AXIOM_PAGE_BYTE_LEN;
+	else
+		page_len = total_len;
+
+	if (axiom_usage_entry_is_report(entry))
+		dev_dbg(dev,
+			"u%02X rev.%d total-len:%u [REPORT]\n",
+			entry->usage_num, entry->uifrevision, total_len);
+	else
+		dev_dbg(dev,
+			"u%02X rev.%d first-page:%#02x page-len:%u num-pages:%u total-len:%u\n",
+			entry->usage_num, entry->uifrevision, entry->start_page, page_len,
+			entry->num_pages, total_len);
+}
+
+static const struct axiom_usage_info *
+axiom_get_usage_info(struct axiom_u31_usage_table_entry *query)
+{
+	const struct axiom_usage_info *info = driver_required_usages;
+	bool required = false;
+	bool found = false;
+
+	for (; info->usage_num; info++) {
+		/* Skip all usages not used by the driver */
+		if (query->usage_num != info->usage_num)
+			continue;
+
+		/* The usage is used so we need to mark it as required */
+		required = true;
+
+		/* Continue with the next usage if the revision doesn't match */
+		if (query->uifrevision != info->rev_num)
+			continue;
+
+		found = true;
+		break;
+	}
+
+	if (required && !found)
+		return ERR_PTR(-EINVAL);
+
+	return found ? info : NULL;
+}
+
+static bool axiom_usage_supported(struct axiom_data *ts, unsigned int baseaddr)
+{
+	struct axiom_usage_table_entry *entry;
+	unsigned int i;
+
+	if (axiom_skip_usage_check(ts))
+		return true;
+
+	dev_dbg(ts->dev, "Checking support for baseaddr: %#x\n", baseaddr);
+
+	for (i = 0; i < ARRAY_SIZE(ts->usage_table); i++) {
+		entry = &ts->usage_table[i];
+
+		if (!entry->populated)
+			continue;
+
+		if (entry->baseaddr != baseaddr)
+			continue;
+
+		break;
+	}
+
+	if (i == ARRAY_SIZE(ts->usage_table)) {
+		dev_warn(ts->dev, "Usage not found\n");
+		return false;
+	}
+
+	if (!entry->info)
+		WARN(1, "Unsupported usage u%x used, driver bug!", i);
+
+	return !!entry->info;
+}
+
+static void axiom_poll(struct input_dev *input);
+
+static unsigned long
+axiom_wait_for_completion_timeout(struct axiom_data *ts, struct axiom_completion *x,
+				  long timeout)
+{
+	struct i2c_client *client = to_i2c_client(ts->dev);
+	unsigned long poll_timeout;
+
+	if (client->irq)
+		return wait_for_completion_timeout(&x->completion, timeout);
+
+	/*
+	 * Only firmware update cases do wait for completion. Since they require
+	 * the input device to be closed, the poller is not running. So we need
+	 * to do the polling manually.
+	 */
+	poll_timeout = timeout / 10;
+
+	/*
+	 * Very basic and not very accurate but it does the job because there
+	 * are no known timeout constraints.
+	 */
+	do {
+		axiom_poll(ts->input);
+		fsleep(jiffies_to_usecs(poll_timeout));
+		if (x->poll_done)
+			break;
+		timeout -= poll_timeout;
+	} while (timeout > 0);
+
+	x->poll_done = false;
+
+	return timeout > 0 ? timeout : 0;
+}
+
+static void axiom_complete(struct axiom_data *ts, struct axiom_completion *x)
+{
+	struct i2c_client *client = to_i2c_client(ts->dev);
+
+	if (client->irq)
+		complete(&x->completion);
+	else
+		x->poll_done = true;
+}
+
+/*************************** Usage handling ***********************************/
+/*
+ * Wrapper functions to handle the usage access. Wrappers are used to add
+ * different revision handling later on more easily.
+ */
+static int axiom_u02_wait_idle(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	unsigned int reg;
+	int ret, _ret;
+	u16 cmd;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U02);
+	reg += AXIOM_U02_REV1_COMMAND_REG;
+
+	/*
+	 * Missing regmap_raw_read_poll_timeout for now. RESP_SUCCESS means that
+	 * the last command successfully completed and the device is idle.
+	 */
+	ret = read_poll_timeout(regmap_raw_read, _ret,
+				_ret || cmd == AXIOM_U02_REV1_RESP_SUCCESS,
+				10 * USEC_PER_MSEC, 1 * USEC_PER_SEC, false,
+				ts->regmap, reg, &cmd, 2);
+	if (ret)
+		dev_err(ts->dev, "Poll u02 timedout with: %#x\n", cmd);
+
+	return ret;
+}
+
+static int
+axiom_u02_send_msg(struct axiom_data *ts,
+		   const struct axiom_u02_rev1_system_manager_msg *msg,
+		   bool validate_response)
+{
+	struct device *dev = ts->dev;
+	unsigned int reg;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U02);
+	reg += AXIOM_U02_REV1_COMMAND_REG;
+
+	ret = regmap_raw_write(ts->regmap, reg, msg, sizeof(*msg));
+	if (ret)
+		return ret;
+
+	if (!validate_response)
+		return 0;
+
+	return axiom_u02_wait_idle(ts);
+}
+
+static int
+axiom_u02_rev1_send_single_cmd(struct axiom_data *ts, u16 cmd)
+{
+	struct axiom_u02_rev1_system_manager_msg msg = {
+		.command = cpu_to_le16(cmd)
+	};
+
+	return axiom_u02_send_msg(ts, &msg, true);
+}
+
+static int axiom_u02_handshakenvm(struct axiom_data *ts)
+{
+	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_HANDSHAKENVM);
+}
+
+static int axiom_u02_computecrc(struct axiom_data *ts)
+{
+	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_COMPUTECRCS);
+}
+
+static int axiom_u02_stop(struct axiom_data *ts)
+{
+	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_STOP);
+}
+
+static int axiom_u02_save_config(struct axiom_data *ts)
+{
+	struct axiom_u02_rev1_system_manager_msg msg;
+	struct device *dev = ts->dev;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_SAVEVLTLCFG2NVM);
+	msg.parameters[0] = 0; /* Don't care */
+	msg.parameters[1] = cpu_to_le16(AXIOM_U02_REV1_PARAM1_SAVEVLTLCFG2NVM);
+	msg.parameters[2] = cpu_to_le16(AXIOM_U02_REV1_PARAM2_SAVEVLTLCFG2NVM);
+
+	ret = axiom_u02_send_msg(ts, &msg, false);
+	if (ret)
+		return ret;
+
+	/* Downstream axcfg.py waits for 2sec without checking U01 response */
+	ret = axiom_wait_for_completion_timeout(ts, &ts->nvm_write,
+					msecs_to_jiffies(2 * MSEC_PER_SEC));
+	if (!ret)
+		dev_err(ts->dev, "Error save volatile config timedout\n");
+
+	return ret ? 0 : -ETIMEDOUT;
+}
+
+static int axiom_u02_swreset(struct axiom_data *ts)
+{
+	struct axiom_u02_rev1_system_manager_msg msg = { };
+	struct device *dev = ts->dev;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_SOFTRESET);
+	ret = axiom_u02_send_msg(ts, &msg, false);
+	if (ret)
+		return ret;
+
+	/*
+	 * Downstream axcfg.py waits for 1sec without checking U01 hello. Tests
+	 * showed that waiting for the hello message isn't enough therefore we
+	 * need both to make it robuster.
+	 */
+	ret = axiom_wait_for_completion_timeout(ts, &ts->boot_complete,
+					msecs_to_jiffies(1 * MSEC_PER_SEC));
+	if (!ret)
+		dev_err(ts->dev, "Error swreset timedout\n");
+
+	fsleep(USEC_PER_SEC);
+
+	return ret ? 0 : -ETIMEDOUT;
+}
+
+static int axiom_u02_fillconfig(struct axiom_data *ts)
+{
+	struct axiom_u02_rev1_system_manager_msg msg;
+	struct device *dev = ts->dev;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_FILLCONFIG);
+	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_FILLCONFIG);
+	msg.parameters[1] = cpu_to_le16(AXIOM_U02_REV1_PARAM1_FILLCONFIG);
+	msg.parameters[2] = cpu_to_le16(AXIOM_U02_REV1_PARAM2_FILLCONFIG_ZERO);
+
+	return axiom_u02_send_msg(ts, &msg, true);
+}
+
+static int axiom_u02_enter_bootloader(struct axiom_data *ts)
+{
+	struct axiom_u02_rev1_system_manager_msg msg = { };
+	struct device *dev = ts->dev;
+	unsigned int val;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
+	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
+		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
+		return -EINVAL;
+	}
+
+	/*
+	 * Enter the bootloader mode requires 3 consecutive messages so we can't
+	 * check for the response.
+	 */
+	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_ENTERBOOTLOADER);
+	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY1);
+	ret = axiom_u02_send_msg(ts, &msg, false);
+	if (ret) {
+		dev_err(dev, "Failed to send bootloader-key1: %d\n", ret);
+		return ret;
+	}
+
+	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY2);
+	ret = axiom_u02_send_msg(ts, &msg, false);
+	if (ret) {
+		dev_err(dev, "Failed to send bootloader-key2: %d\n", ret);
+		return ret;
+	}
+
+	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY3);
+	ret = axiom_u02_send_msg(ts, &msg, false);
+	if (ret) {
+		dev_err(dev, "Failed to send bootloader-key3: %d\n", ret);
+		return ret;
+	}
+
+	/* Sleep before the first read to give the device time */
+	fsleep(250 * USEC_PER_MSEC);
+
+	/* Wait till the device reports it is in bootloader mode */
+	return regmap_read_poll_timeout(ts->regmap,
+			AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, val,
+			FIELD_GET(AXIOM_U31_REV1_MODE_MASK, val) ==
+			AXIOM_U31_REV1_MODE_BLP, 250 * USEC_PER_MSEC,
+			USEC_PER_SEC);
+}
+
+static int axiom_u04_get(struct axiom_data *ts, u8 **_buf)
+{
+	u8 buf[AXIOM_U04_REV1_SIZE_BYTES];
+	struct device *dev = ts->dev;
+	unsigned int reg;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U04) != 1) {
+		dev_err(dev, "Only u04 rev.1 is supported at the moment\n");
+		return -EINVAL;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U04);
+	ret = regmap_raw_read(ts->regmap, reg, buf, sizeof(buf));
+	if (ret)
+		return ret;
+
+	*_buf = kmemdup(buf, sizeof(buf), GFP_KERNEL);
+
+	return sizeof(buf);
+}
+
+static int axiom_u04_set(struct axiom_data *ts, u8 *buf, unsigned int bufsize)
+{
+	struct device *dev = ts->dev;
+	unsigned int reg;
+
+	if (axiom_usage_rev(ts, AXIOM_U04) != 1) {
+		dev_err(dev, "Only u04 rev.1 is supported at the moment\n");
+		return -EINVAL;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U04);
+	return regmap_raw_write(ts->regmap, reg, buf, bufsize);
+}
+
+/*
+ * U31 revision must be always rev.1 else the whole self discovery mechanism
+ * fall apart.
+ */
+static int axiom_u31_parse_device_info(struct axiom_data *ts)
+{
+	struct regmap *regmap = ts->regmap;
+	unsigned int id_low, id_high, val;
+	int ret;
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, &id_high);
+	if (ret)
+		return ret;
+	id_high = FIELD_GET(AXIOM_U31_REV1_DEVICE_ID_HIGH_MASK, id_high);
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_LOW_REG, &id_low);
+	if (ret)
+		return ret;
+	ts->device_id = id_high << 8 | id_low;
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_MAJ_REG, &val);
+	if (ret)
+		return ret;
+	ts->fw_major = val;
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_MIN_REG, &val);
+	if (ret)
+		return ret;
+	ts->fw_minor = val;
+
+	/* All other fields are not allowed to be read in BLP mode */
+	if (axiom_get_runmode(ts) == AXIOM_BLP_MODE)
+		return 0;
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_RC_REG, &val);
+	if (ret)
+		return ret;
+	ts->fw_rc = FIELD_GET(AXIOM_U31_REV1_RUNTIME_FW_RC_MASK, val);
+	ts->silicon_rev = FIELD_GET(AXIOM_U31_REV1_SILICON_REV_MASK, val);
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_STATUS_REG, &val);
+	if (ret)
+		return ret;
+	ts->fw_status = FIELD_GET(AXIOM_U31_REV1_RUNTIME_FW_STATUS, val);
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_JEDEC_ID_HIGH_REG, &val);
+	if (ret)
+		return ret;
+	ts->jedec_id = val << 8;
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_JEDEC_ID_LOW_REG, &val);
+	if (ret)
+		return ret;
+	ts->jedec_id |= val;
+
+	return 0;
+}
+
+static int axiom_u33_read(struct axiom_data *ts, struct axiom_crc *crc);
+
+static int axiom_u31_device_discover(struct axiom_data *ts)
+{
+	struct axiom_u31_usage_table_entry *u31_usage_table __free(kfree) = NULL;
+	struct axiom_u31_usage_table_entry *entry;
+	struct regmap *regmap = ts->regmap;
+	unsigned int mode, num_usages;
+	struct device *dev = ts->dev;
+	unsigned int i;
+	int ret;
+
+	axiom_set_runmode(ts, AXIOM_DISCOVERY_MODE);
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, &mode);
+	if (ret) {
+		dev_err(dev, "Failed to read MODE\n");
+		return ret;
+	}
+
+	/* Abort if the device is in bootloader protocol mode */
+	mode = FIELD_GET(AXIOM_U31_REV1_MODE_MASK, mode);
+	if (mode == AXIOM_U31_REV1_MODE_BLP)
+		axiom_set_runmode(ts, AXIOM_BLP_MODE);
+
+	/* Since we are not in bootloader mode we can parse the device info */
+	ret = axiom_u31_parse_device_info(ts);
+	if (ret) {
+		dev_err(dev, "Failed to parse device info\n");
+		return ret;
+	}
+
+	/* All other fields are not allowed to be read in BLP mode */
+	if (axiom_get_runmode(ts) == AXIOM_BLP_MODE) {
+		dev_info(dev, "Device in Bootloader mode, firmware upload required\n");
+		return -EACCES;
+	}
+
+	ret = regmap_read(regmap, AXIOM_U31_REV1_NUM_USAGES_REG, &num_usages);
+	if (ret) {
+		dev_err(dev, "Failed to read NUM_USAGES\n");
+		return ret;
+	}
+
+	u31_usage_table = kcalloc(num_usages, sizeof(*u31_usage_table),
+				  GFP_KERNEL);
+	if (!u31_usage_table)
+		return -ENOMEM;
+
+	ret = regmap_raw_read(regmap, AXIOM_U31_REV1_PAGE1, u31_usage_table,
+			      array_size(num_usages, sizeof(*u31_usage_table)));
+	if (ret) {
+		dev_err(dev, "Failed to read NUM_USAGES\n");
+		return ret;
+	}
+
+	/*
+	 * axiom_u31_device_discover() is call after fw update too, so ensure
+	 * that the usage_table is cleared.
+	 */
+	memset(ts->usage_table, 0, sizeof(ts->usage_table));
+
+	for (i = 0, entry = u31_usage_table; i < num_usages; i++, entry++) {
+		unsigned char idx = entry->usage_num;
+		const struct axiom_usage_info *info;
+		unsigned int size_bytes;
+
+		axiom_dump_usage_entry(dev, entry);
+
+		/*
+		 * Verify that the driver used usages are supported. Don't abort
+		 * yet if a usage isn't supported to allow the user to dump the
+		 * actual usage table.
+		 */
+		info = axiom_get_usage_info(entry);
+		if (IS_ERR(info)) {
+			dev_info(dev, "Required usage u%02x isn't supported for rev.%u\n",
+				 entry->usage_num, entry->uifrevision);
+			ret = -EACCES;
+		}
+
+		size_bytes = axiom_get_usage_size_bytes(entry);
+
+		ts->usage_table[idx].baseaddr = entry->start_page << 8;
+		ts->usage_table[idx].size_bytes = size_bytes;
+		ts->usage_table[idx].populated = true;
+		ts->usage_table[idx].info = info;
+
+		if (axiom_usage_entry_is_report(entry) &&
+		    ts->max_report_byte_len < size_bytes)
+			ts->max_report_byte_len = size_bytes;
+	}
+
+	if (ret)
+		return ret;
+
+	/* From now on we are in TCP mode to include usage revision checks */
+	axiom_set_runmode(ts, AXIOM_TCP_MODE);
+
+	return axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
+}
+
+static int axiom_u33_read(struct axiom_data *ts, struct axiom_crc *crc)
+{
+	struct device *dev = ts->dev;
+	struct axiom_u33_rev2 val;
+	unsigned int reg;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U33) != 2) {
+		dev_err(dev, "Only u33 rev.2 is supported at the moment\n");
+		return -EINVAL;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U33);
+	ret = regmap_raw_read(ts->regmap, reg, &val, sizeof(val));
+	if (ret) {
+		dev_err(dev, "Failed to read u33\n");
+		return ret;
+	}
+
+	crc->runtime = le32_to_cpu(val.runtime_crc);
+	crc->vltusageconfig = le32_to_cpu(val.vltusageconfig_crc);
+	crc->nvltlusageconfig = le32_to_cpu(val.nvltlusageconfig_crc);
+	crc->u22_sequencedata = le32_to_cpu(val.u22_sequencedata_crc);
+	crc->u43_hotspots = le32_to_cpu(val.u43_hotspots_crc);
+	crc->u93_profiles = le32_to_cpu(val.u93_profiles_crc);
+	crc->u94_deltascalemap = le32_to_cpu(val.u94_deltascalemap_crc);
+
+	return 0;
+}
+
+static void axiom_u42_get_touchslots(struct axiom_data *ts)
+{
+	u8 *buf __free(kfree) = NULL;
+	struct device *dev = ts->dev;
+	unsigned int bufsize;
+	unsigned int reg;
+	int ret, i;
+
+	if (axiom_usage_rev(ts, AXIOM_U42) != 1) {
+		dev_warn(dev, "Unsupported u42 revision, use default value\n");
+		goto fallback;
+	}
+
+	bufsize = axiom_usage_size(ts, AXIOM_U42);
+	buf = kzalloc(bufsize, GFP_KERNEL);
+	if (!buf) {
+		dev_warn(dev, "Failed to alloc u42 read buffer, use default value\n");
+		goto fallback;
+	}
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U42);
+	ret = regmap_raw_read(ts->regmap, reg, buf, bufsize);
+	if (ret) {
+		dev_warn(dev, "Failed to read u42, use default value\n");
+		goto fallback;
+	}
+
+	for (i = 0; i < AXIOM_MAX_TOUCHSLOTS; i++) {
+		bool touch_enabled;
+
+		touch_enabled = buf[AXIOM_U42_REV1_REPORT_ID_CONTAINS(i)] ==
+				AXIOM_U42_REV1_REPORT_ID_TOUCH;
+		if (touch_enabled) {
+			ts->enabled_slots |= BIT(i);
+			ts->num_slots++;
+		}
+	}
+
+	return;
+
+fallback:
+	ts->enabled_slots = AXIOM_MAX_TOUCHSLOTS_MASK;
+	ts->num_slots = AXIOM_MAX_TOUCHSLOTS;
+}
+
+static void axiom_u64_cds_enabled(struct axiom_data *ts)
+{
+	unsigned int reg, val;
+	int ret;
+
+	if (axiom_usage_rev(ts, AXIOM_U64) != 2)
+		goto fallback_out;
+
+	reg = axiom_usage_baseaddr(ts, AXIOM_U64);
+	reg += AXIOM_U64_REV2_ENABLECDSPROCESSING_REG;
+
+	ret = regmap_read(ts->regmap, reg, &val);
+	if (ret)
+		goto fallback_out;
+
+	val = FIELD_GET(AXIOM_U64_REV2_ENABLECDSPROCESSING_MASK, val);
+	ts->cds_enabled = val ? true : false;
+
+	return;
+
+fallback_out:
+	ts->cds_enabled = false;
+}
+
+static int axiom_cdu_wait_idle(struct axiom_data *ts, u8 cdu_usage_num)
+{
+	unsigned int reg;
+	int ret, _ret;
+	u16 cmd;
+
+	reg = axiom_usage_baseaddr(ts, cdu_usage_num);
+
+	/*
+	 * Missing regmap_raw_read_poll_timeout for now. RESP_SUCCESS means that
+	 * the last command successfully completed and the device is idle.
+	 */
+	ret = read_poll_timeout(regmap_raw_read, _ret,
+				_ret || cmd == AXIOM_CDU_RESP_SUCCESS,
+				10 * USEC_PER_MSEC, 1 * USEC_PER_SEC, false,
+				ts->regmap, reg, &cmd, 2);
+	if (ret)
+		dev_err(ts->dev, "Poll CDU u%x timedout with: %#x\n",
+			cdu_usage_num, cmd);
+
+	return ret;
+}
+
+/*********************** Report usage handling ********************************/
+
+static int axiom_process_report(struct axiom_data *ts, unsigned char usage_num,
+				const u8 *buf, size_t buflen)
+{
+	struct axiom_usage_table_entry *entry = &ts->usage_table[usage_num];
+
+	/* Skip processing if not in TCP mode */
+	if ((axiom_get_runmode(ts) != AXIOM_TCP_MODE) &&
+	    (axiom_get_runmode(ts) != AXIOM_TCP_CFG_UPDATE_MODE))
+		return 0;
+
+	/* May happen if an unsupported usage was requested */
+	if (!entry) {
+		dev_info(ts->dev, "Unsupported usage U%x request\n", usage_num);
+		return 0;
+	}
+
+	/* Supported report usages need to have a process_report hook */
+	if (!entry->info || !entry->info->process_report)
+		return -EINVAL;
+
+	return entry->info->process_report(ts, buf, buflen);
+}
+
+/* Make use of datasheet method 1 - single transfer read */
+static int
+axiom_u34_rev1_process_report(struct axiom_data *ts, const u8 *_buf, size_t bufsize)
+{
+	unsigned int reg = axiom_usage_baseaddr(ts, AXIOM_U34);
+	struct regmap *regmap = ts->regmap;
+	u8 buf[AXIOM_PAGE_BYTE_LEN] = { };
+	struct device *dev = ts->dev;
+	unsigned char report_usage;
+	u16 crc_report, crc_calc;
+	unsigned int len;
+	u8 *payload;
+	int ret;
+
+	ret = regmap_raw_read(regmap, reg, buf, ts->max_report_byte_len);
+	if (ret)
+		return ret;
+
+	/* TODO: Add overflow statistics */
+
+	/* REPORTLENGTH is in uint16 */
+	len = FIELD_GET(AXIOM_U34_REV1_REPORTLENGTH_MASK, buf[0]);
+	len *= 2;
+
+	/*
+	 * Downstream ignores zero length reports, extend the check to validate
+	 * the upper bound too.
+	 */
+	if (len == 0 || len > AXIOM_PAGE_BYTE_LEN) {
+		dev_dbg_ratelimited(dev, "Invalid report length: %u\n", len);
+		return -EINVAL;
+	}
+
+	/*
+	 * The CRC16 value can be queried at the last two bytes of the report.
+	 * The value itself is covering the complete report excluding the CRC16
+	 * value at the end.
+	 */
+	crc_report = get_unaligned_le16(&buf[len - 2]);
+	crc_calc = crc16(0, buf, (len - 2));
+
+	if (crc_calc != crc_report) {
+		dev_err_ratelimited(dev, "CRC16 mismatch!\n");
+		return -EINVAL;
+	}
+
+	report_usage = buf[1];
+	payload = &buf[AXIOM_U34_REV1_PREAMBLE_BYTES];
+	len -= AXIOM_U34_REV1_PREAMBLE_BYTES - AXIOM_U34_REV1_POSTAMBLE_BYTES;
+
+	switch (report_usage) {
+	case AXIOM_U01:
+	case AXIOM_U41:
+		return axiom_process_report(ts, report_usage, payload, len);
+	default:
+		dev_dbg(dev, "Unsupported report u%02X received\n",
+			report_usage);
+	}
+
+	return 0;
+}
+
+static void
+axiom_u41_rev2_decode_target(const u8 *buf, u8 id, u16 *x, u16 *y, s8 *z)
+{
+	u16 val;
+
+	val = get_unaligned_le16(&buf[AXIOM_U41_REV2_X_REG(id)]);
+	val &= AXIOM_MAX_XY;
+	*x = val;
+
+	val = get_unaligned_le16(&buf[AXIOM_U41_REV2_Y_REG(id)]);
+	val &= AXIOM_MAX_XY;
+	*y = val;
+
+	*z = buf[AXIOM_U41_REV2_Z_REG(id)];
+}
+
+static int
+axiom_u41_rev2_process_report(struct axiom_data *ts, const u8 *buf, size_t bufsize)
+{
+	struct input_dev *input = ts->input;
+	unsigned char id;
+	u16 targets;
+
+	/*
+	 * The input registration can be postponed but the touchscreen FW is
+	 * sending u41 reports regardless.
+	 */
+	if (!input)
+		return 0;
+
+	targets = get_unaligned_le16(&buf[AXIOM_U41_REV2_TARGETSTATUS_REG]);
+
+	for_each_set_bit(id, &ts->enabled_slots, AXIOM_MAX_TOUCHSLOTS) {
+		bool present;
+		u16 x, y;
+		s8 z;
+
+		axiom_u41_rev2_decode_target(buf, id, &x, &y, &z);
+
+		present = targets & BIT(id);
+		/* Ignore possible jitters */
+		if (z == AXIOM_PROX_LEVEL)
+			present = false;
+
+		dev_dbg(ts->dev, "id:%u x:%u y:%u z:%d present:%u",
+			id, x, y, z, present);
+
+		input_mt_slot(input, id);
+		if (input_mt_report_slot_state(input, MT_TOOL_FINGER, present))
+			touchscreen_report_pos(input, &ts->prop, x, y, true);
+
+		if (!present)
+			continue;
+
+		input_report_abs(input, ABS_MT_DISTANCE, z < 0 ? -z : 0);
+		if (ts->cds_enabled)
+			input_report_abs(input, ABS_MT_PRESSURE, z >= 0 ? z : 0);
+	}
+
+	input_sync(input);
+
+	return 0;
+}
+
+static int
+axiom_u01_rev1_process_report(struct axiom_data *ts, const u8 *buf, size_t bufsize)
+{
+	switch (buf[AXIOM_U01_REV1_REPORTTYPE_REG]) {
+	case AXIOM_U01_REV1_REPORTTYPE_HELLO:
+		dev_dbg(ts->dev, "u01 HELLO received\n");
+		axiom_complete(ts, &ts->boot_complete);
+		return 0;
+	case AXIOM_U01_REV1_REPORTTYPE_HEARTBEAT:
+		dev_dbg_ratelimited(ts->dev, "u01 HEARTBEAT received\n");
+		return 0;
+	case AXIOM_U01_REV1_REPORTTYPE_OPCOMPLETE:
+		dev_dbg(ts->dev, "u01 OPCOMPLETE received\n");
+		axiom_u02_handshakenvm(ts);
+		axiom_complete(ts, &ts->nvm_write);
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+/**************************** Regmap handling *********************************/
+
+#define AXIOM_CMD_HDR_DIR_MASK	BIT(15)
+#define   AXIOM_CMD_HDR_READ	1
+#define	  AXIOM_CMD_HDR_WRITE	0
+#define AXIOM_CMD_HDR_LEN_MASK	GENMASK(14, 0)
+
+struct axiom_cmd_header {
+	__le16 target_address;
+	__le16 xferlen;
+};
+
+/* Custom regmap read/write handling is required due to the aXiom protocol */
+static int axiom_regmap_read(void *context, const void *reg_buf, size_t reg_size,
+			     void *val_buf, size_t val_size)
+{
+	struct device *dev = context;
+	struct i2c_client *i2c = to_i2c_client(dev);
+	struct axiom_data *ts = i2c_get_clientdata(i2c);
+	struct axiom_cmd_header hdr;
+	u16 xferlen, addr, baseaddr;
+	struct i2c_msg xfer[2];
+	int ret;
+
+	if (val_size > AXIOM_MAX_XFERLEN) {
+		dev_err(ts->dev, "Exceed max xferlen: %zu > %u\n",
+			val_size, AXIOM_MAX_XFERLEN);
+		return -EINVAL;
+	}
+
+	addr = *((u16 *)reg_buf);
+	hdr.target_address = cpu_to_le16(addr);
+	xferlen = FIELD_PREP(AXIOM_CMD_HDR_DIR_MASK, AXIOM_CMD_HDR_READ) |
+		  FIELD_PREP(AXIOM_CMD_HDR_LEN_MASK, val_size);
+	hdr.xferlen = cpu_to_le16(xferlen);
+
+	/* Verify that usage including the usage rev is supported */
+	baseaddr = addr & AXIOM_USAGE_BASEADDR_MASK;
+	if (!axiom_usage_supported(ts, baseaddr))
+		return -EINVAL;
+
+	xfer[0].addr = i2c->addr;
+	xfer[0].flags = 0;
+	xfer[0].len = sizeof(hdr);
+	xfer[0].buf = (u8 *)&hdr;
+
+	xfer[1].addr = i2c->addr;
+	xfer[1].flags = I2C_M_RD;
+	xfer[1].len = val_size;
+	xfer[1].buf = val_buf;
+
+	ret = i2c_transfer(i2c->adapter, xfer, 2);
+	if (ret == 2)
+		return 0;
+	else if (ret < 0)
+		return ret;
+	else
+		return -EIO;
+}
+
+static int axiom_regmap_write(void *context, const void *data, size_t count)
+{
+	struct device *dev = context;
+	struct i2c_client *i2c = to_i2c_client(dev);
+	struct axiom_data *ts = i2c_get_clientdata(i2c);
+	char *buf __free(kfree) = NULL;
+	struct axiom_cmd_header hdr;
+	u16 xferlen, addr, baseaddr;
+	size_t val_size, msg_size;
+	int ret;
+
+	val_size = count - sizeof(addr);
+	if (val_size > AXIOM_MAX_XFERLEN) {
+		dev_err(ts->dev, "Exceed max xferlen: %zu > %u\n",
+			val_size, AXIOM_MAX_XFERLEN);
+		return -EINVAL;
+	}
+
+	addr = *((u16 *)data);
+	hdr.target_address = cpu_to_le16(addr);
+	xferlen = FIELD_PREP(AXIOM_CMD_HDR_DIR_MASK, AXIOM_CMD_HDR_WRITE) |
+		  FIELD_PREP(AXIOM_CMD_HDR_LEN_MASK, val_size);
+	hdr.xferlen = cpu_to_le16(xferlen);
+
+	/* Verify that usage including the usage rev is supported */
+	baseaddr = addr & AXIOM_USAGE_BASEADDR_MASK;
+	if (!axiom_usage_supported(ts, baseaddr))
+		return -EINVAL;
+
+	msg_size = sizeof(hdr) + val_size;
+	buf = kzalloc(msg_size, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	memcpy(buf, &hdr, sizeof(hdr));
+	memcpy(&buf[sizeof(hdr)], &((char *)data)[2], val_size);
+
+	ret = i2c_master_send(i2c, buf, msg_size);
+
+	return ret == msg_size ? 0 : ret;
+}
+
+static const struct regmap_config axiom_i2c_regmap_config = {
+	.reg_bits = 16,
+	.val_bits = 8,
+	.read = axiom_regmap_read,
+	.write = axiom_regmap_write,
+};
+
+/************************ FW update handling **********************************/
+
+static int axiom_update_input_dev(struct axiom_data *ts);
+
+static enum fw_upload_err
+axiom_axfw_fw_prepare(struct fw_upload *fw_upload, const u8 *data, u32 size)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
+	u8 major_ver, minor_ver, rc_ver, status;
+	u32 fw_file_crc32, crc32_calc;
+	struct device *dev = ts->dev;
+	unsigned int signature_len;
+	enum fw_upload_err ret;
+	u16 fw_file_format_ver;
+	u16 fw_file_device_id;
+
+	mutex_lock(&afw->lock);
+	afw->cancel = false;
+	mutex_unlock(&afw->lock);
+
+	mutex_lock(&ts->fwupdate_lock);
+
+	if (size < sizeof(struct axiom_fw_axfw_hdr)) {
+		dev_err(dev, "Invalid AXFW file size\n");
+		ret = FW_UPLOAD_ERR_INVALID_SIZE;
+		goto out;
+	}
+
+	signature_len = strlen(AXIOM_FW_AXFW_SIGNATURE);
+	if (strncmp(data, AXIOM_FW_AXFW_SIGNATURE, signature_len)) {
+		/*
+		 * AXFW has a header which can be used to perform validations,
+		 * ALC don't. Therefore the AXFW format is preferred.
+		 */
+		dev_warn(dev, "No AXFW signature, assume ALC firmware\n");
+		ret = FW_UPLOAD_ERR_NONE;
+		goto out;
+	}
+
+	fw_file_crc32 = get_unaligned_le32(&data[signature_len]);
+	crc32_calc = crc32(~0, &data[8], size - 8) ^ 0xffffffff;
+	if (fw_file_crc32 != crc32_calc) {
+		dev_err(dev, "AXFW CRC32 doesn't match (fw:%#x calc:%#x)\n",
+			fw_file_crc32, crc32_calc);
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	data += signature_len + sizeof(fw_file_crc32);
+	fw_file_format_ver = get_unaligned_le16(data);
+	if (fw_file_format_ver != AXIOM_FW_AXFW_FILE_FMT_VER) {
+		dev_err(dev, "Invalid AXFW file format version: %04x",
+			fw_file_format_ver);
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	data += sizeof(fw_file_format_ver);
+	fw_file_device_id = get_unaligned_le16(data);
+	if (fw_file_device_id != ts->device_id) {
+		dev_err(dev, "Invalid AXFW target device (fw:%#04x dev:%#04x)\n",
+			fw_file_device_id, ts->device_id);
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	/*
+	 * This can happen if:
+	 *  * the device came up in bootloader mode, or
+	 *  * downloading the firmware failed in between, or
+	 *  * the following usage discovery failed.
+	 *
+	 *  All cases are crcitical and we need to use any firmware to
+	 *  bring the device back into a working state which is supported by the
+	 *  host.
+	 */
+	if (axiom_get_runmode(ts) != AXIOM_TCP_MODE)
+		return FW_UPLOAD_ERR_NONE;
+
+	data += sizeof(fw_file_device_id);
+	/* Skip variant */
+	minor_ver = *++data;
+	major_ver = *++data;
+	rc_ver = *++data;
+	status = *++data;
+
+	if (major_ver == ts->fw_major && minor_ver == ts->fw_minor &&
+	    rc_ver == ts->fw_rc && status == ts->fw_status) {
+		ret = FW_UPLOAD_ERR_SKIP;
+		goto out;
+	}
+
+	dev_info(dev, "Detected AXFW %02u.%02u.%02u (%s)\n",
+		 major_ver, minor_ver, rc_ver,
+		 status ? "production" : "engineering");
+
+	mutex_lock(&afw->lock);
+	ret = afw->cancel ? FW_UPLOAD_ERR_CANCELED : FW_UPLOAD_ERR_NONE;
+	mutex_unlock(&afw->lock);
+
+out:
+	/*
+	 * In FW_UPLOAD_ERR_NONE case the complete handler will release the
+	 * lock.
+	 */
+	if (ret != FW_UPLOAD_ERR_NONE)
+		mutex_unlock(&ts->fwupdate_lock);
+
+	return ret;
+}
+
+static int axiom_enter_bootloader_mode(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	int ret;
+
+	axiom_set_runmode(ts, AXIOM_BLP_PRE_MODE);
+
+	ret = axiom_u02_wait_idle(ts);
+	if (ret)
+		goto err_out;
+
+	ret = axiom_u02_enter_bootloader(ts);
+	if (ret) {
+		dev_err(dev, "Failed to enter bootloader mode\n");
+		goto err_out;
+	}
+
+	axiom_set_runmode(ts, AXIOM_BLP_MODE);
+
+	return 0;
+
+err_out:
+	axiom_set_runmode(ts, AXIOM_TCP_MODE);
+
+	return ret;
+}
+
+static int axoim_blp_wait_ready(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	unsigned int reg;
+	int tmp, ret;
+	u8 buf[4];
+
+	reg = AXIOM_U01_BLP_SATUS_REG;
+
+	/* BLP busy poll requires to read 4 bytes! */
+	ret = read_poll_timeout(regmap_raw_read, tmp,
+				tmp || !(buf[2] & AXIOM_U01_BLP_STATUS_BUSY),
+				10 * USEC_PER_MSEC, 5 * USEC_PER_SEC, false,
+				ts->regmap, reg, &buf, 4);
+	if (ret)
+		dev_err(dev, "Bootloader wait processing packets failed %d\n", ret);
+
+	return ret;
+}
+
+static int
+axiom_blp_write_chunk(struct axiom_data *ts, const u8 *data, u16 length)
+{
+	unsigned int chunk_size = AXIOM_U01_BLP_FIFO_CHK_SIZE_BYTES;
+	unsigned int reg = AXIOM_U01_BLP_FIFO_REG;
+	struct device *dev = ts->dev;
+	unsigned int pos = 0;
+	int ret;
+
+	ret = axoim_blp_wait_ready(ts);
+	if (ret)
+		return ret;
+
+	/*
+	 * TODO: Downstream does this chunk transfers. Verify if this is
+	 * required if one fw-chunk <= AXIOM_MAX_XFERLEN
+	 */
+	while (pos < length) {
+		u16 len;
+
+		len = chunk_size;
+		if ((pos + chunk_size) > length)
+			len = length - pos;
+
+		ret = regmap_raw_write(ts->regmap, reg, &data[pos], len);
+		if (ret) {
+			dev_err(dev, "Bootloader download AXFW chunk failed %d\n", ret);
+			return ret;
+		}
+
+		pos += len;
+		ret = axoim_blp_wait_ready(ts);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int axiom_blp_reset(struct axiom_data *ts)
+{
+	__le16 reset_cmd = cpu_to_le16(AXIOM_U01_BLP_COMMAND_RESET);
+	unsigned int reg = AXIOM_U01_BLP_COMMAND_REG;
+	struct device *dev = ts->dev;
+	unsigned int attempts = 20;
+	unsigned int mode;
+	int ret;
+
+	ret = axoim_blp_wait_ready(ts);
+	if (ret)
+		return ret;
+
+	/*
+	 * For some reason this write fail with -ENXIO. Skip checking the return
+	 * code (which is also done by the downstream axfw.py tool and poll u31
+	 * instead.
+	 */
+	regmap_raw_write(ts->regmap, reg, &reset_cmd, sizeof(reset_cmd));
+
+	do {
+		ret = regmap_read(ts->regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG,
+				  &mode);
+		if (!ret)
+			break;
+
+		fsleep(250 * USEC_PER_MSEC);
+	} while (attempts--);
+
+	if (ret) {
+		dev_err(dev, "Failed to read MODE after BLP reset: %d\n", ret);
+		return ret;
+	}
+
+	mode = FIELD_GET(AXIOM_U31_REV1_MODE_MASK, mode);
+	if (mode == AXIOM_U31_REV1_MODE_BLP) {
+		dev_err(dev, "Device still in BLP mode, abort\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static void axiom_lock_input_device(struct axiom_data *ts)
+{
+	if (!ts->input)
+		return;
+
+	mutex_lock(&ts->input->mutex);
+}
+
+static void axiom_unlock_input_device(struct axiom_data *ts)
+{
+	if (!ts->input)
+		return;
+
+	mutex_unlock(&ts->input->mutex);
+}
+
+static void axiom_unregister_input_dev(struct axiom_data *ts)
+{
+	if (ts->input)
+		input_unregister_device(ts->input);
+
+	ts->input = NULL;
+}
+
+static enum fw_upload_err
+axiom_axfw_fw_write(struct fw_upload *fw_upload, const u8 *data, u32 offset,
+		    u32 size, u32 *written)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
+	struct device *dev = ts->dev;
+	bool cancel;
+	int ret;
+
+	/* Done before cancel check due to cleanup based put */
+	ret = pm_runtime_resume_and_get(ts->dev);
+	if (ret)
+		return FW_UPLOAD_ERR_HW_ERROR;
+
+	mutex_lock(&afw->lock);
+	cancel = afw->cancel;
+	mutex_unlock(&afw->lock);
+
+	if (cancel)
+		return FW_UPLOAD_ERR_CANCELED;
+
+	axiom_lock_input_device(ts);
+
+	if (ts->input && input_device_enabled(ts->input)) {
+		dev_err(dev, "Input device not idle, abort AXFW/ALC update\n");
+		goto err;
+	}
+
+	if (!strncmp(data, AXIOM_FW_AXFW_SIGNATURE,
+		     strlen(AXIOM_FW_AXFW_SIGNATURE))) {
+		/* Set the pointer to the first fw chunk */
+		data += sizeof(struct axiom_fw_axfw_hdr);
+		size -= sizeof(struct axiom_fw_axfw_hdr);
+		*written += sizeof(struct axiom_fw_axfw_hdr);
+	}
+
+	if (axiom_enter_bootloader_mode(ts))
+		goto err;
+
+	while (size) {
+		u16 chunk_len, len;
+
+		chunk_len = get_unaligned_be16(&data[6]);
+		len = chunk_len + sizeof(struct axiom_fw_axfw_chunk_hdr);
+
+		/*
+		 * The bootlaoder FW can handle the complete chunk incl. the
+		 * header.
+		 */
+		ret = axiom_blp_write_chunk(ts, data, len);
+		if (ret)
+			goto err;
+
+		size -= len;
+		*written += len;
+		data += len;
+	}
+
+	ret = axiom_blp_reset(ts);
+	if (ret)
+		dev_warn(dev, "BLP reset failed\n");
+
+	ret = axiom_u31_device_discover(ts);
+	if (ret) {
+		/*
+		 * This is critical and we need to avoid that the user-space can
+		 * still use the input-dev.
+		 */
+		axiom_unlock_input_device(ts);
+		axiom_unregister_input_dev(ts);
+		dev_err(dev, "Device discovery failed after AXFW/ALC firmware update\n");
+		goto err;
+	}
+
+	/* Unlock before the input device gets unregistered */
+	axiom_unlock_input_device(ts);
+
+	ret = axiom_update_input_dev(ts);
+	if (ret) {
+		dev_err(dev, "Input device update failed after AXFW/ALC firmware update\n");
+		return FW_UPLOAD_ERR_HW_ERROR;
+	}
+
+	dev_info(dev, "AXFW update successful\n");
+
+	return FW_UPLOAD_ERR_NONE;
+
+err:
+	axiom_unlock_input_device(ts);
+	return FW_UPLOAD_ERR_HW_ERROR;
+}
+
+static enum fw_upload_err axiom_fw_poll_complete(struct fw_upload *fw_upload)
+{
+	return FW_UPLOAD_ERR_NONE;
+}
+
+static void axiom_axfw_fw_cancel(struct fw_upload *fw_upload)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
+
+	mutex_lock(&afw->lock);
+	afw->cancel = true;
+	mutex_unlock(&afw->lock);
+}
+
+static void axiom_axfw_fw_cleanup(struct fw_upload *fw_upload)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+
+	mutex_unlock(&ts->fwupdate_lock);
+	pm_runtime_mark_last_busy(ts->dev);
+	pm_runtime_put_sync_autosuspend(ts->dev);
+}
+
+static const struct fw_upload_ops axiom_axfw_fw_upload_ops = {
+	.prepare = axiom_axfw_fw_prepare,
+	.write = axiom_axfw_fw_write,
+	.poll_complete = axiom_fw_poll_complete,
+	.cancel = axiom_axfw_fw_cancel,
+	.cleanup = axiom_axfw_fw_cleanup,
+};
+
+static int
+axiom_set_new_crcs(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *cfg)
+{
+	struct axiom_crc *crc = &ts->crc[AXIOM_CRC_NEW];
+	const u32 *u33_data = (const u32 *)cfg->usage_content;
+
+	if (cfg->usage_rev != 2) {
+		dev_err(ts->dev, "The driver doesn't support u33 revision %u\n",
+			cfg->usage_rev);
+		return -EINVAL;
+	}
+
+	crc->runtime = get_unaligned_le32(u33_data);
+	crc->nvltlusageconfig = get_unaligned_le32(&u33_data[3]);
+	crc->vltusageconfig = get_unaligned_le32(&u33_data[4]);
+	crc->u22_sequencedata = get_unaligned_le32(&u33_data[5]);
+	crc->u43_hotspots = get_unaligned_le32(&u33_data[6]);
+	crc->u93_profiles = get_unaligned_le32(&u33_data[7]);
+	crc->u94_deltascalemap = get_unaligned_le32(&u33_data[8]);
+
+	return 0;
+}
+
+static unsigned int
+axiom_cfg_fw_prepare_chunk(struct axiom_fw_cfg_chunk *chunk, const u8 *data)
+{
+	chunk->usage_num = data[0];
+	chunk->usage_rev = data[1];
+	chunk->usage_length = get_unaligned_le16(&data[3]);
+	chunk->usage_content = &data[5];
+
+	return chunk->usage_length + sizeof(struct axiom_fw_cfg_chunk_hdr);
+}
+
+static bool axiom_cfg_fw_update_required(struct axiom_data *ts)
+{
+	struct axiom_crc *cur, *new;
+
+	cur = &ts->crc[AXIOM_CRC_CUR];
+	new = &ts->crc[AXIOM_CRC_NEW];
+
+	if (cur->nvltlusageconfig != new->nvltlusageconfig ||
+	    cur->u22_sequencedata != new->u22_sequencedata ||
+	    cur->u43_hotspots != new->u43_hotspots ||
+	    cur->u93_profiles != new->u93_profiles ||
+	    cur->u94_deltascalemap != new->u94_deltascalemap)
+		return true;
+
+	return false;
+}
+
+static enum fw_upload_err
+axiom_cfg_fw_prepare(struct fw_upload *fw_upload, const u8 *data, u32 size)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
+	u32 cur_runtime_crc, fw_runtime_crc;
+	struct axiom_fw_cfg_chunk chunk;
+	struct device *dev = ts->dev;
+	enum fw_upload_err ret;
+	u32 signature;
+
+	mutex_lock(&afw->lock);
+	afw->cancel = false;
+	mutex_unlock(&afw->lock);
+
+	mutex_lock(&ts->fwupdate_lock);
+
+	if (axiom_get_runmode(ts) != AXIOM_TCP_MODE) {
+		dev_err(dev, "Device not in TCP mode, abort TH2CFG update\n");
+		ret = FW_UPLOAD_ERR_HW_ERROR;
+		goto out;
+	}
+
+	if (size < sizeof(struct axiom_fw_cfg_hdr)) {
+		dev_err(dev, "Invalid TH2CFG file size\n");
+		ret = FW_UPLOAD_ERR_INVALID_SIZE;
+		goto out;
+	}
+
+	signature = get_unaligned_be32(data);
+	if (signature != AXIOM_FW_CFG_SIGNATURE) {
+		dev_err(dev, "Invalid TH2CFG signature\n");
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	/* Skip to the first fw chunk */
+	data += sizeof(struct axiom_fw_cfg_hdr);
+	size -= sizeof(struct axiom_fw_cfg_hdr);
+
+	/*
+	 * Search for u33 which contains the CRC information and perform only
+	 * the runtime-crc check.
+	 */
+	while (size) {
+		unsigned int chunk_len;
+
+		chunk_len = axiom_cfg_fw_prepare_chunk(&chunk, data);
+		if (chunk.usage_num == AXIOM_U33)
+			break;
+
+		data += chunk_len;
+		size -= chunk_len;
+	}
+
+	if (size == 0) {
+		dev_err(dev, "Failed to find the u33 entry in TH2CFG\n");
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	ret = axiom_set_new_crcs(ts, &chunk);
+	if (ret) {
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	/*
+	 * Nothing to do if the CRCs are the same. TODO: Must be extended once
+	 * the CDU update is added.
+	 */
+	if (!axiom_cfg_fw_update_required(ts)) {
+		ret = FW_UPLOAD_ERR_SKIP;
+		goto out;
+	}
+
+	cur_runtime_crc = ts->crc[AXIOM_CRC_CUR].runtime;
+	fw_runtime_crc = ts->crc[AXIOM_CRC_NEW].runtime;
+	if (cur_runtime_crc != fw_runtime_crc) {
+		dev_err(dev, "TH2CFG and device runtime CRC doesn't match: %#x != %#x\n",
+			fw_runtime_crc, cur_runtime_crc);
+		ret = FW_UPLOAD_ERR_FW_INVALID;
+		goto out;
+	}
+
+	mutex_lock(&afw->lock);
+	ret = afw->cancel ? FW_UPLOAD_ERR_CANCELED : FW_UPLOAD_ERR_NONE;
+	mutex_unlock(&afw->lock);
+
+out:
+	/*
+	 * In FW_UPLOAD_ERR_NONE case the complete handler will release the
+	 * lock.
+	 */
+	if (ret != FW_UPLOAD_ERR_NONE)
+		mutex_unlock(&ts->fwupdate_lock);
+
+	return ret;
+}
+
+static int axiom_zero_volatile_mem(struct axiom_data *ts)
+{
+	int ret, size;
+	u8 *buf;
+
+	/* Zero out the volatile memory except for the user content in u04 */
+	ret = axiom_u04_get(ts, &buf);
+	if (ret < 0)
+		return ret;
+	size = ret;
+
+	ret = axiom_u02_fillconfig(ts);
+	if (ret)
+		goto out;
+
+	ret = axiom_u04_set(ts, buf, size);
+out:
+	kfree(buf);
+	return ret;
+}
+
+static bool
+axiom_skip_cfg_chunk(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
+{
+	u8 usage_num = chunk->usage_num;
+
+	if (!ts->usage_table[usage_num].populated) {
+		dev_warn(ts->dev, "Unknown usage chunk for u%#x\n", usage_num);
+		return true;
+	}
+
+	/* Skip read-only usages */
+	if (ts->usage_table[usage_num].info &&
+	    ts->usage_table[usage_num].info->is_ro)
+		return true;
+
+	return false;
+}
+
+static int
+axiom_write_cdu_usage(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
+{
+	struct axiom_cdu_usage cdu = { };
+	struct device *dev = ts->dev;
+	unsigned int remaining;
+	unsigned int reg;
+	unsigned int pos;
+	int ret;
+
+	pos = 0;
+	remaining = chunk->usage_length;
+	cdu.command = cpu_to_le16(AXIOM_CDU_CMD_STORE);
+	reg = axiom_usage_baseaddr(ts, chunk->usage_num);
+
+	while (remaining) {
+		unsigned int size;
+
+		cdu.parameters[1] = cpu_to_le16(pos);
+
+		size = remaining;
+		if (size > AXIOM_CDU_MAX_DATA_BYTES)
+			size = AXIOM_CDU_MAX_DATA_BYTES;
+
+		memset(cdu.data, 0, sizeof(cdu.data));
+		memcpy(cdu.data, &chunk->usage_content[pos], size);
+
+		ret = regmap_raw_write(ts->regmap, reg, &cdu, sizeof(cdu));
+		if (ret) {
+			dev_err(dev, "Failed to write CDU u%x\n",
+				chunk->usage_num);
+			return ret;
+		}
+
+		ret = axiom_cdu_wait_idle(ts, chunk->usage_num);
+		if (ret) {
+			dev_err(dev, "CDU write wait-idle failed\n");
+			return ret;
+		}
+
+		remaining -= size;
+		pos += size;
+	}
+
+	/*
+	 * TODO: Check if we really need to send 48 zero bytes of data like
+	 * downstream does.
+	 */
+	memset(&cdu, 0, sizeof(cdu));
+	cdu.command = cpu_to_le16(AXIOM_CDU_CMD_COMMIT);
+	cdu.parameters[0] = cpu_to_le16(AXIOM_CDU_PARAM0_COMMIT);
+	cdu.parameters[1] = cpu_to_le16(AXIOM_CDU_PARAM1_COMMIT);
+
+	ret = regmap_raw_write(ts->regmap, reg, &cdu, sizeof(cdu));
+	if (ret) {
+		dev_err(dev, "Failed to commit CDU u%x to NVM\n",
+			chunk->usage_num);
+		return ret;
+	}
+
+	ret = axiom_wait_for_completion_timeout(ts, &ts->nvm_write,
+					msecs_to_jiffies(5 * MSEC_PER_SEC));
+	if (!ret) {
+		dev_err(ts->dev, "Error CDU u%x commit timedout\n",
+			chunk->usage_num);
+		return -ETIMEDOUT;
+	}
+
+	return axiom_cdu_wait_idle(ts, chunk->usage_num);
+}
+
+static int
+axiom_write_cfg_chunk(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
+{
+	unsigned int reg;
+	int ret;
+
+	if (ts->usage_table[chunk->usage_num].info &&
+	    ts->usage_table[chunk->usage_num].info->is_cdu) {
+		ret = axiom_write_cdu_usage(ts, chunk);
+		if (ret)
+			return ret;
+		goto out;
+	}
+
+	reg = axiom_usage_baseaddr(ts, chunk->usage_num);
+	ret = regmap_raw_write(ts->regmap, reg, chunk->usage_content, chunk->usage_length);
+	if (ret)
+		return ret;
+
+out:
+	return axiom_u02_wait_idle(ts);
+}
+
+static int axiom_verify_volatile_mem(struct axiom_data *ts)
+{
+	int ret;
+
+	ret = axiom_u02_computecrc(ts);
+	if (ret)
+		return ret;
+
+	/* Query the new CRCs after they are re-computed */
+	ret = axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
+	if (ret)
+		return ret;
+
+	return ts->crc[AXIOM_CRC_CUR].vltusageconfig ==
+	       ts->crc[AXIOM_CRC_NEW].vltusageconfig ? 0 : -EINVAL;
+}
+
+static int axiom_verify_crcs(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	struct axiom_crc *cur, *new;
+
+	cur = &ts->crc[AXIOM_CRC_CUR];
+	new = &ts->crc[AXIOM_CRC_NEW];
+
+	if (new->vltusageconfig != cur->vltusageconfig) {
+		dev_err(dev, "VLTUSAGECONFIG CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->vltusageconfig, new->vltusageconfig);
+		return -EINVAL;
+	} else if (new->nvltlusageconfig != cur->nvltlusageconfig) {
+		dev_err(dev, "NVLTUSAGECONFIG CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->nvltlusageconfig, new->nvltlusageconfig);
+		return -EINVAL;
+	} else if (new->u22_sequencedata != cur->u22_sequencedata) {
+		dev_err(dev, "U22_SEQUENCEDATA CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->u22_sequencedata, new->u22_sequencedata);
+		return -EINVAL;
+	} else if (new->u43_hotspots != cur->u43_hotspots) {
+		dev_err(dev, "U43_HOTSPOTS CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->u43_hotspots, new->u43_hotspots);
+		return -EINVAL;
+	} else if (new->u93_profiles != cur->u93_profiles) {
+		dev_err(dev, "U93_PROFILES CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->u93_profiles, new->u93_profiles);
+		return -EINVAL;
+	} else if (new->u94_deltascalemap != cur->u94_deltascalemap) {
+		dev_err(dev, "U94_DELTASCALEMAP CRC32 mismatch (dev:%#x != fw:%#x)\n",
+			cur->u94_deltascalemap, new->u94_deltascalemap);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static enum fw_upload_err
+axiom_cfg_fw_write(struct fw_upload *fw_upload, const u8 *data, u32 offset,
+		   u32 size, u32 *written)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
+	struct device *dev = ts->dev;
+	bool cancel;
+	int ret;
+
+	/* Done before cancel check due to cleanup based put */
+	ret = pm_runtime_resume_and_get(ts->dev);
+	if (ret)
+		return FW_UPLOAD_ERR_HW_ERROR;
+
+	mutex_lock(&afw->lock);
+	cancel = afw->cancel;
+	mutex_unlock(&afw->lock);
+
+	if (cancel)
+		return FW_UPLOAD_ERR_CANCELED;
+
+	axiom_lock_input_device(ts);
+
+	if (ts->input && input_device_enabled(ts->input)) {
+		dev_err(dev, "Input device not idle, abort TH2CFG update\n");
+		axiom_unlock_input_device(ts);
+		return FW_UPLOAD_ERR_HW_ERROR;
+	}
+
+	ret = axiom_u02_stop(ts);
+	if (ret)
+		goto err_swreset;
+
+	ret = axiom_zero_volatile_mem(ts);
+	if (ret)
+		goto err_swreset;
+
+	/* Skip to the first fw chunk */
+	data += sizeof(struct axiom_fw_cfg_hdr);
+	size -= sizeof(struct axiom_fw_cfg_hdr);
+	*written += sizeof(struct axiom_fw_cfg_hdr);
+
+	axiom_set_runmode(ts, AXIOM_TCP_CFG_UPDATE_MODE);
+
+	while (size) {
+		struct axiom_fw_cfg_chunk chunk;
+		unsigned int chunk_len;
+
+		chunk_len = axiom_cfg_fw_prepare_chunk(&chunk, data);
+		if (axiom_skip_cfg_chunk(ts, &chunk)) {
+			dev_dbg(dev, "Skip TH2CFG usage u%x\n", chunk.usage_num);
+			goto next_chunk;
+		}
+
+		ret = axiom_write_cfg_chunk(ts, &chunk);
+		if (ret) {
+			axiom_set_runmode(ts, AXIOM_TCP_MODE);
+			goto err_swreset;
+		}
+
+next_chunk:
+		data += chunk_len;
+		size -= chunk_len;
+		*written += chunk_len;
+	}
+
+	axiom_set_runmode(ts, AXIOM_TCP_MODE);
+
+	/* Ensure that the chunks are written correctly */
+	ret = axiom_verify_volatile_mem(ts);
+	if (ret) {
+		dev_err(dev, "Failed to verify written config, abort\n");
+		goto err_swreset;
+	}
+
+	ret = axiom_u02_save_config(ts);
+	if (ret)
+		goto err_swreset;
+
+	/*
+	 * TODO: Check if u02 start would be sufficient to load the new config
+	 * values
+	 */
+	ret = axiom_u02_swreset(ts);
+	if (ret) {
+		dev_err(dev, "Soft reset failed\n");
+		goto err_unlock;
+	}
+
+	ret = axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
+	if (ret)
+		goto err_unlock;
+
+	if (axiom_verify_crcs(ts))
+		goto err_unlock;
+
+	/* Unlock before the input device gets unregistered */
+	axiom_unlock_input_device(ts);
+
+	ret = axiom_update_input_dev(ts);
+	if (ret) {
+		dev_err(dev, "Input device update failed after TH2CFG firmware update\n");
+		goto err_out;
+	}
+
+	dev_info(dev, "TH2CFG update successful\n");
+
+	return FW_UPLOAD_ERR_NONE;
+
+err_swreset:
+	axiom_u02_swreset(ts);
+err_unlock:
+	axiom_unlock_input_device(ts);
+err_out:
+	return ret == -ETIMEDOUT ? FW_UPLOAD_ERR_TIMEOUT : FW_UPLOAD_ERR_HW_ERROR;
+}
+
+static void axiom_cfg_fw_cancel(struct fw_upload *fw_upload)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
+
+	mutex_lock(&afw->lock);
+	afw->cancel = true;
+	mutex_unlock(&afw->lock);
+}
+
+static void axiom_cfg_fw_cleanup(struct fw_upload *fw_upload)
+{
+	struct axiom_data *ts = fw_upload->dd_handle;
+
+	mutex_unlock(&ts->fwupdate_lock);
+	pm_runtime_mark_last_busy(ts->dev);
+	pm_runtime_put_sync_autosuspend(ts->dev);
+}
+
+static const struct fw_upload_ops axiom_cfg_fw_upload_ops = {
+	.prepare = axiom_cfg_fw_prepare,
+	.write = axiom_cfg_fw_write,
+	.poll_complete = axiom_fw_poll_complete,
+	.cancel = axiom_cfg_fw_cancel,
+	.cleanup = axiom_cfg_fw_cleanup,
+};
+
+static void axiom_remove_axfw_fwl_action(void *data)
+{
+	struct axiom_data *ts = data;
+
+	firmware_upload_unregister(ts->fw[AXIOM_FW_AXFW].fwl);
+}
+
+static void axiom_remove_cfg_fwl_action(void *data)
+{
+	struct axiom_data *ts = data;
+
+	firmware_upload_unregister(ts->fw[AXIOM_FW_CFG].fwl);
+}
+
+static int axiom_register_fwl(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	struct fw_upload *fwl;
+	char *fw_name;
+	int ret;
+
+	if (!IS_ENABLED(CONFIG_FW_UPLOAD)) {
+		dev_dbg(dev, "axfw and th2cfgbin update disabled\n");
+		return 0;
+	}
+
+	mutex_init(&ts->fw[AXIOM_FW_AXFW].lock);
+	fw_name = kasprintf(GFP_KERNEL, "i2c:%s.axfw", dev_name(dev));
+	fwl = firmware_upload_register(THIS_MODULE, ts->dev, fw_name,
+				       &axiom_axfw_fw_upload_ops, ts);
+	kfree(fw_name);
+	if (IS_ERR(fwl))
+		return dev_err_probe(dev, PTR_ERR(fwl),
+				     "Failed to register firmware upload\n");
+
+	ret = devm_add_action_or_reset(dev, axiom_remove_axfw_fwl_action, ts);
+	if (ret)
+		return ret;
+
+	ts->fw[AXIOM_FW_AXFW].fwl = fwl;
+
+	mutex_init(&ts->fw[AXIOM_FW_CFG].lock);
+	fw_name = kasprintf(GFP_KERNEL, "i2c:%s.th2cfgbin", dev_name(dev));
+	fwl = firmware_upload_register(THIS_MODULE, ts->dev, fw_name,
+				       &axiom_cfg_fw_upload_ops, ts);
+	kfree(fw_name);
+	if (IS_ERR(fwl))
+		return dev_err_probe(dev, PTR_ERR(fwl),
+				     "Failed to register cfg firmware upload\n");
+
+	ret = devm_add_action_or_reset(dev, axiom_remove_cfg_fwl_action, ts);
+	if (ret)
+		return ret;
+
+	ts->fw[AXIOM_FW_CFG].fwl = fwl;
+
+	return 0;
+}
+
+/************************* Device handlig *************************************/
+
+#define AXIOM_SIMPLE_FW_DEVICE_ATTR(attr)					\
+	static ssize_t								\
+	fw_ ## attr ## _show(struct device *dev,				\
+			     struct device_attribute *_attr, char *buf)		\
+	{									\
+		struct i2c_client *i2c = to_i2c_client(dev);			\
+		struct axiom_data *ts = i2c_get_clientdata(i2c);		\
+										\
+		return sprintf(buf, "%u\n", ts->fw_##attr);			\
+	}									\
+	static DEVICE_ATTR_RO(fw_##attr)
+
+AXIOM_SIMPLE_FW_DEVICE_ATTR(major);
+AXIOM_SIMPLE_FW_DEVICE_ATTR(minor);
+AXIOM_SIMPLE_FW_DEVICE_ATTR(rc);
+
+static ssize_t fw_status_show(struct device *dev,
+			      struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *i2c = to_i2c_client(dev);
+	struct axiom_data *ts = i2c_get_clientdata(i2c);
+	const char *val;
+
+	if (ts->fw_status)
+		val = "production";
+	else
+		val = "engineering";
+
+	return sprintf(buf, "%s\n", val);
+}
+static DEVICE_ATTR_RO(fw_status);
+
+static ssize_t device_id_show(struct device *dev,
+			      struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *i2c = to_i2c_client(dev);
+	struct axiom_data *ts = i2c_get_clientdata(i2c);
+
+	return sprintf(buf, "%u\n", ts->device_id);
+}
+static DEVICE_ATTR_RO(device_id);
+
+static ssize_t device_state_show(struct device *dev,
+				 struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *i2c = to_i2c_client(dev);
+	struct axiom_data *ts = i2c_get_clientdata(i2c);
+
+	return sprintf(buf, "%s\n", axiom_runmode_to_string(ts));
+}
+static DEVICE_ATTR_RO(device_state);
+
+static struct attribute *axiom_attrs[] = {
+	&dev_attr_fw_major.attr,
+	&dev_attr_fw_minor.attr,
+	&dev_attr_fw_rc.attr,
+	&dev_attr_fw_status.attr,
+	&dev_attr_device_id.attr,
+	&dev_attr_device_state.attr,
+	NULL
+};
+ATTRIBUTE_GROUPS(axiom);
+
+static void axiom_poll(struct input_dev *input)
+{
+	struct axiom_data *ts = input_get_drvdata(input);
+
+	axiom_process_report(ts, AXIOM_U34, NULL, 0);
+}
+
+static irqreturn_t axiom_irq(int irq, void *dev_id)
+{
+	struct axiom_data *ts = dev_id;
+
+	axiom_process_report(ts, AXIOM_U34, NULL, 0);
+
+	return IRQ_HANDLED;
+}
+
+static int axiom_input_open(struct input_dev *dev)
+{
+	struct axiom_data *ts = input_get_drvdata(dev);
+
+	return pm_runtime_resume_and_get(ts->dev);
+}
+
+static void axiom_input_close(struct input_dev *dev)
+{
+	struct axiom_data *ts = input_get_drvdata(dev);
+
+	pm_runtime_mark_last_busy(ts->dev);
+	pm_runtime_put_sync_autosuspend(ts->dev);
+}
+
+static int axiom_register_input_dev(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct input_dev *input;
+	int ret;
+
+	input = input_allocate_device();
+	if (!input) {
+		dev_err(dev, "Failed to allocate input driver data\n");
+		return -ENOMEM;
+	}
+
+	input->dev.parent = dev;
+	input->name = "TouchNetix aXiom Touchscreen";
+	input->id.bustype = BUS_I2C;
+	input->id.vendor = ts->jedec_id;
+	input->id.product = ts->device_id;
+	input->id.version = ts->silicon_rev;
+	input->open = axiom_input_open;
+	input->close = axiom_input_close;
+
+	axiom_u64_cds_enabled(ts);
+	input_set_abs_params(input, ABS_MT_POSITION_X, 0, AXIOM_MAX_XY - 1, 0, 0);
+	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, AXIOM_MAX_XY - 1, 0, 0);
+	input_set_abs_params(input, ABS_MT_DISTANCE, 0, 127, 0, 0);
+	if (ts->cds_enabled)
+		input_set_abs_params(input, ABS_MT_PRESSURE, 0, 127, 0, 0);
+
+	touchscreen_parse_properties(input, true, &ts->prop);
+
+	axiom_u42_get_touchslots(ts);
+	ret = input_mt_init_slots(input, ts->num_slots, INPUT_MT_DIRECT);
+	if (ret) {
+		input_free_device(input);
+		dev_err(dev, "Failed to init mt slots\n");
+		return ret;
+	}
+
+	/*
+	 * Ensure that the IRQ setup is done only once since the handler belong
+	 * to the i2c-dev whereas the input-poller belong to the input-dev. The
+	 * input-dev can get unregistered during a firmware update to reflect
+	 * the new firmware state. Therefore the input-poller setup must be done
+	 * always.
+	 */
+	if (!ts->irq_setup_done && client->irq) {
+		ret = devm_request_threaded_irq(dev, client->irq, NULL, axiom_irq,
+						IRQF_ONESHOT, dev_name(dev), ts);
+		if (ret) {
+			dev_err(dev, "Failed to request IRQ\n");
+			return ret;
+		}
+		ts->irq_setup_done = true;
+	} else {
+		ret = input_setup_polling(input, axiom_poll);
+		if (ret) {
+			input_free_device(input);
+			dev_err(dev, "Setup polling mode failed\n");
+			return ret;
+		}
+
+		input_set_poll_interval(input, ts->poll_interval);
+	}
+
+	input_set_drvdata(input, ts);
+	ts->input = input;
+
+	ret = input_register_device(input);
+	if (ret) {
+		input_free_device(input);
+		ts->input = NULL;
+		dev_err(dev, "Failed to register input device\n");
+	};
+
+	return ret;
+}
+
+static int axiom_update_input_dev(struct axiom_data *ts)
+{
+	axiom_unregister_input_dev(ts);
+
+	return axiom_register_input_dev(ts);
+}
+
+static int axiom_parse_firmware(struct axiom_data *ts)
+{
+	struct device *dev = ts->dev;
+	struct gpio_desc *gpio;
+	int ret;
+
+	ts->supplies[0].supply = "vddi";
+	ts->supplies[1].supply = "vdda";
+	ts->num_supplies = ARRAY_SIZE(ts->supplies);
+
+	ret = devm_regulator_bulk_get(dev, ts->num_supplies, ts->supplies);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "Failed to get power supplies\n");
+
+	gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+	if (IS_ERR(gpio))
+		return dev_err_probe(dev, PTR_ERR(gpio),
+				     "Failed to get reset GPIO\n");
+	ts->reset_gpio = gpio;
+
+	ts->poll_interval = AXIOM_DEFAULT_POLL_INTERVAL_MS;
+	device_property_read_u32(dev, "poll-interval", &ts->poll_interval);
+
+	return 0;
+}
+
+static int axiom_power_device(struct axiom_data *ts, unsigned int enable)
+{
+	struct device *dev = ts->dev;
+	int ret;
+
+	if (!enable) {
+		regulator_bulk_disable(ts->num_supplies, ts->supplies);
+		return 0;
+	}
+
+	ret = regulator_bulk_enable(ts->num_supplies, ts->supplies);
+	if (ret) {
+		dev_err(dev, "Failed to enable power supplies\n");
+		return ret;
+	}
+
+	gpiod_set_value_cansleep(ts->reset_gpio, 1);
+	fsleep(2000);
+	gpiod_set_value_cansleep(ts->reset_gpio, 0);
+
+	fsleep(AXIOM_STARTUP_TIME_MS);
+
+	return 0;
+}
+
+static int axiom_i2c_probe(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+	struct axiom_data *ts;
+	int ret;
+
+	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
+	if (!ts)
+		return dev_err_probe(dev, -ENOMEM,
+				     "Failed to allocate driver data\n");
+
+	ts->regmap = devm_regmap_init_i2c(client, &axiom_i2c_regmap_config);
+	if (IS_ERR(ts->regmap))
+		return dev_err_probe(dev, PTR_ERR(ts->regmap),
+				     "Failed to initialize regmap\n");
+
+	i2c_set_clientdata(client, ts);
+	ts->dev = dev;
+
+	init_completion(&ts->boot_complete.completion);
+	init_completion(&ts->nvm_write.completion);
+	mutex_init(&ts->fwupdate_lock);
+
+	ret = axiom_register_fwl(ts);
+	if (ret)
+		return ret;
+
+	ret = axiom_parse_firmware(ts);
+	if (ret)
+		return ret;
+
+	ret = axiom_power_device(ts, 1);
+	if (ret)
+		return dev_err_probe(dev, ret, "Failed to power-on device\n");
+
+	pm_runtime_set_autosuspend_delay(dev, 10 * MSEC_PER_SEC);
+	pm_runtime_use_autosuspend(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_get_noresume(dev);
+	ret = devm_pm_runtime_enable(dev);
+	if (ret)
+		return dev_err_probe(dev, ret, "Failed to enable pm-runtime\n");
+
+	ret = axiom_u31_device_discover(ts);
+	/*
+	 * Register the device to allow FW updates in case that the current FW
+	 * doesn't support the required driver usages or if the device is in
+	 * bootloader mode.
+	 */
+	if (ret && ret == -EACCES && IS_ENABLED(CONFIG_FW_UPLOAD)) {
+		dev_warn(dev, "Device discovery failed, wait for user fw update\n");
+		pm_runtime_mark_last_busy(dev);
+		pm_runtime_put_sync_autosuspend(dev);
+		return 0;
+	} else if (ret) {
+		pm_runtime_put_sync(dev);
+		return dev_err_probe(dev, ret, "Device discovery failed\n");
+	}
+
+	ret = axiom_register_input_dev(ts);
+	pm_runtime_mark_last_busy(dev);
+	pm_runtime_put_sync_autosuspend(dev);
+	if (ret)
+		return dev_err_probe(dev, ret, "Failed to finish setup\n");
+
+	return 0;
+}
+
+static void axiom_i2c_remove(struct i2c_client *client)
+{
+	struct axiom_data *ts = i2c_get_clientdata(client);
+
+	axiom_unregister_input_dev(ts);
+}
+
+static int axiom_runtime_suspend(struct device *dev)
+{
+	struct axiom_data *ts = dev_get_drvdata(dev);
+	struct i2c_client *client = to_i2c_client(dev);
+
+	if (client->irq && ts->irq_setup_done)
+		disable_irq(client->irq);
+
+	return axiom_power_device(ts, 0);
+}
+
+static int axiom_runtime_resume(struct device *dev)
+{
+	struct axiom_data *ts = dev_get_drvdata(dev);
+	struct i2c_client *client = to_i2c_client(dev);
+	int ret;
+
+	ret = axiom_power_device(ts, 1);
+	if (ret)
+		return ret;
+
+	if (client->irq && ts->irq_setup_done)
+		enable_irq(client->irq);
+
+	return 0;
+}
+
+static DEFINE_RUNTIME_DEV_PM_OPS(axiom_pm_ops, axiom_runtime_suspend,
+				 axiom_runtime_resume, NULL);
+
+static const struct i2c_device_id axiom_i2c_id_table[] = {
+	{ "ax54a" },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, axiom_i2c_id_table);
+
+static const struct of_device_id axiom_of_match[] = {
+	{ .compatible = "touchnetix,ax54a", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, axiom_of_match);
+
+static struct i2c_driver axiom_i2c_driver = {
+	.driver = {
+		   .name = KBUILD_MODNAME,
+		   .dev_groups = axiom_groups,
+		   .pm = pm_ptr(&axiom_pm_ops),
+		   .of_match_table = axiom_of_match,
+	},
+	.id_table = axiom_i2c_id_table,
+	.probe = axiom_i2c_probe,
+	.remove = axiom_i2c_remove,
+};
+module_i2c_driver(axiom_i2c_driver);
+
+MODULE_DESCRIPTION("TouchNetix aXiom touchscreen I2C bus driver");
+MODULE_LICENSE("GPL");

-- 
2.39.5

Re: [PATCH 5/5] Input: Add TouchNetix aXiom I2C Touchscreen support

[Marco Felsch]

Hi,

gentle ping after the rc1 tag was released :)

Regards,
  Marco

On 24-11-19, Marco Felsch wrote:
> This adds the initial support for the TouchNetix AX54A touchcontroller
> which is part of TouchNetix's aXiom family of touchscreen controllers.
> 
> The TouchNetix aXiom family provides two physical interfaces: SPI and
> I2C. This patch covers only the I2C interface. Apart the input event
> handling the driver support firmware updates too. One firmware interface
> is to handle the touchcontroller firmware (AXFW and ALC supported)
> update the other is to handle the touchcontroller configuration
> (TH2CFGBIN) update.
> 
> Signed-off-by: Marco Felsch <m.felsch@pengutronix.de>
> ---
>  drivers/input/touchscreen/Kconfig            |   15 +
>  drivers/input/touchscreen/Makefile           |    1 +
>  drivers/input/touchscreen/touchnetix_axiom.c | 2764 ++++++++++++++++++++++++++
>  3 files changed, 2780 insertions(+)
> 
> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> index 1ac26fc2e3eb..654d38abd692 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -792,6 +792,21 @@ config TOUCHSCREEN_MIGOR
>  	  To compile this driver as a module, choose M here: the
>  	  module will be called migor_ts.
>  
> +config TOUCHSCREEN_TOUCHNETIX_AXIOM
> +	tristate "TouchNetix aXiom based touchscreen controllers"
> +	depends on I2C
> +	select CRC16
> +	select CRC32
> +	select REGMAP_I2C
> +	help
> +	  Say Y here if you have a axiom touchscreen connected to
> +	  your system.
> +
> +	  If unsure, say N.
> +
> +	  To compile this driver as a module, choose M here: the
> +	  module will be called touchnetix_axiom.
> +
>  config TOUCHSCREEN_TOUCHRIGHT
>  	tristate "Touchright serial touchscreen"
>  	select SERIO
> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> index 82bc837ca01e..e6b829720168 100644
> --- a/drivers/input/touchscreen/Makefile
> +++ b/drivers/input/touchscreen/Makefile
> @@ -87,6 +87,7 @@ obj-$(CONFIG_TOUCHSCREEN_SUR40)		+= sur40.o
>  obj-$(CONFIG_TOUCHSCREEN_SURFACE3_SPI)	+= surface3_spi.o
>  obj-$(CONFIG_TOUCHSCREEN_TI_AM335X_TSC)	+= ti_am335x_tsc.o
>  obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)	+= touchit213.o
> +obj-$(CONFIG_TOUCHSCREEN_TOUCHNETIX_AXIOM)	+= touchnetix_axiom.o
>  obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)	+= touchright.o
>  obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)	+= touchwin.o
>  obj-$(CONFIG_TOUCHSCREEN_TS4800)	+= ts4800-ts.o
> diff --git a/drivers/input/touchscreen/touchnetix_axiom.c b/drivers/input/touchscreen/touchnetix_axiom.c
> new file mode 100644
> index 000000000000..52495edf38b6
> --- /dev/null
> +++ b/drivers/input/touchscreen/touchnetix_axiom.c
> @@ -0,0 +1,2764 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * TouchNetix aXiom Touchscreen Driver
> + *
> + * Copyright (C) 2024 Pengutronix
> + *
> + * Marco Felsch <kernel@pengutronix.de>
> + */
> +
> +#include <linux/bitfield.h>
> +#include <linux/bits.h>
> +#include <linux/completion.h>
> +#include <linux/crc16.h>
> +#include <linux/crc32.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/firmware.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/input.h>
> +#include <linux/input/mt.h>
> +#include <linux/input/touchscreen.h>
> +#include <linux/interrupt.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/mod_devicetable.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/property.h>
> +#include <linux/regmap.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/time.h>
> +#include <linux/unaligned.h>
> +
> +/*
> + * Short introduction for developers:
> + *  The programming manual is written based on u(sages):
> + *   - Max. 0xff usages possible
> + *   - A usage is a group of registers (0x00 ... 0xff)
> + *   - The usage base address must be discovered (FW dependent)
> + *   - Partial RW usage access is allowed
> + *   - Each usage has a revision (FW dependent)
> + *   - Only u31 is always at address 0x0 (used for discovery)
> + *
> + *  E.x. Reading register 0x01 for usage u03 with baseaddr 0x20 results in the
> + *  following physical 16bit I2C address: 0x2001.
> + *
> + * Note the datasheet specifies the usage numbers in hex and the internal
> + * offsets in decimal. Keep it that way to make it more developer friendly.
> + */
> +#define AXIOM_U01				0x01
> +#define AXIOM_U01_REV1_REPORTTYPE_REG		0
> +#define   AXIOM_U01_REV1_REPORTTYPE_HELLO	0
> +#define   AXIOM_U01_REV1_REPORTTYPE_HEARTBEAT	1
> +#define   AXIOM_U01_REV1_REPORTTYPE_OPCOMPLETE	3
> +
> +#define AXIOM_U02					0x02
> +#define AXIOM_U02_REV1_COMMAND_REG			0
> +#define   AXIOM_U02_REV1_CMD_HARDRESET			0x0001
> +#define   AXIOM_U02_REV1_CMD_SOFTRESET			0x0002
> +#define   AXIOM_U02_REV1_CMD_STOP			0x0005
> +#define   AXIOM_U02_REV1_CMD_SAVEVLTLCFG2NVM		0x0007
> +#define   AXIOM_U02_REV1_PARAM1_SAVEVLTLCFG2NVM		0xb10c
> +#define   AXIOM_U02_REV1_PARAM2_SAVEVLTLCFG2NVM		0xc0de
> +#define   AXIOM_U02_REV1_CMD_HANDSHAKENVM		0x0008
> +#define   AXIOM_U02_REV1_CMD_COMPUTECRCS		0x0009
> +#define   AXIOM_U02_REV1_CMD_FILLCONFIG			0x000a
> +#define   AXIOM_U02_REV1_PARAM0_FILLCONFIG		0x5555
> +#define   AXIOM_U02_REV1_PARAM1_FILLCONFIG		0xaaaa
> +#define   AXIOM_U02_REV1_PARAM2_FILLCONFIG_ZERO		0xa55a
> +#define   AXIOM_U02_REV1_CMD_ENTERBOOTLOADER		0x000b
> +#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY1	0x5555
> +#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY2	0xaaaa
> +#define   AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY3	0xa55a
> +#define   AXIOM_U02_REV1_RESP_SUCCESS			0x0000
> +
> +struct axiom_u02_rev1_system_manager_msg {
> +	union {
> +		__le16 command;
> +		__le16 response;
> +	};
> +	__le16 parameters[3];
> +};
> +
> +#define AXIOM_U04				0x04
> +#define   AXIOM_U04_REV1_SIZE_BYTES		128
> +
> +#define AXIOM_U05				0x05	/* CDU */
> +
> +#define AXIOM_U22				0x22	/* CDU */
> +
> +#define AXIOM_U31				0x31
> +#define AXIOM_U31_REV1_PAGE0			0x0000
> +#define AXIOM_U31_REV1_DEVICE_ID_LOW_REG	(AXIOM_U31_REV1_PAGE0 + 0)
> +#define AXIOM_U31_REV1_DEVICE_ID_HIGH_REG	(AXIOM_U31_REV1_PAGE0 + 1)
> +#define   AXIOM_U31_REV1_MODE_MASK		BIT(7)
> +#define   AXIOM_U31_REV1_MODE_BLP		1
> +#define   AXIOM_U31_REV1_DEVICE_ID_HIGH_MASK	GENMASK(6, 0)
> +#define AXIOM_U31_REV1_RUNTIME_FW_MIN_REG	(AXIOM_U31_REV1_PAGE0 + 2)
> +#define AXIOM_U31_REV1_RUNTIME_FW_MAJ_REG	(AXIOM_U31_REV1_PAGE0 + 3)
> +#define AXIOM_U31_REV1_RUNTIME_FW_STATUS_REG	(AXIOM_U31_REV1_PAGE0 + 4)
> +#define   AXIOM_U31_REV1_RUNTIME_FW_STATUS	BIT(7)
> +#define AXIOM_U31_REV1_JEDEC_ID_LOW_REG		(AXIOM_U31_REV1_PAGE0 + 8)
> +#define AXIOM_U31_REV1_JEDEC_ID_HIGH_REG	(AXIOM_U31_REV1_PAGE0 + 9)
> +#define AXIOM_U31_REV1_NUM_USAGES_REG		(AXIOM_U31_REV1_PAGE0 + 10)
> +#define AXIOM_U31_REV1_RUNTIME_FW_RC_REG	(AXIOM_U31_REV1_PAGE0 + 11)
> +#define   AXIOM_U31_REV1_RUNTIME_FW_RC_MASK	GENMASK(7, 4)
> +#define   AXIOM_U31_REV1_SILICON_REV_MASK	GENMASK(3, 0)
> +
> +#define AXIOM_U31_REV1_PAGE1			0x0100
> +#define   AXIOM_U31_REV1_OFFSET_TYPE_MASK	BIT(7)
> +#define   AXIOM_U31_REV1_MAX_OFFSET_MASK	GENMASK(6, 0)
> +
> +#define AXIOM_U32				0x32
> +
> +struct axiom_u31_usage_table_entry {
> +	u8 usage_num;
> +	u8 start_page;
> +	u8 num_pages;
> +	u8 max_offset;
> +	u8 uifrevision;
> +	u8 reserved;
> +} __packed;
> +
> +#define AXIOM_U33				0x33
> +
> +struct axiom_u33_rev2 {
> +	__le32 runtime_crc;
> +	__le32 runtime_nvm_crc;
> +	__le32 bootloader_crc;
> +	__le32 nvltlusageconfig_crc;
> +	__le32 vltusageconfig_crc;
> +	__le32 u22_sequencedata_crc;
> +	__le32 u43_hotspots_crc;
> +	__le32 u93_profiles_crc;
> +	__le32 u94_deltascalemap_crc;
> +	__le32 runtimehash_crc;
> +};
> +
> +#define AXIOM_U34				0x34
> +#define   AXIOM_U34_REV1_OVERFLOW_MASK		BIT(7)
> +#define   AXIOM_U34_REV1_REPORTLENGTH_MASK	GENMASK(6, 0)
> +#define   AXIOM_U34_REV1_PREAMBLE_BYTES		2
> +#define   AXIOM_U34_REV1_POSTAMBLE_BYTES	4
> +
> +#define AXIOM_U36				0x36
> +
> +#define AXIOM_U41				0x41
> +#define AXIOM_U41_REV2_TARGETSTATUS_REG		0
> +#define AXIOM_U41_REV2_X_REG(id)		((4 * (id)) + 2)
> +#define AXIOM_U41_REV2_Y_REG(id)		((4 * (id)) + 4)
> +#define AXIOM_U41_REV2_Z_REG(id)		((id) + 42)
> +
> +#define AXIOM_U42				0x42
> +#define AXIOM_U42_REV1_REPORT_ID_CONTAINS(id)	((id) + 2)
> +#define   AXIOM_U42_REV1_REPORT_ID_TOUCH	1	/* Touch, Proximity, Hover */
> +
> +#define AXIOM_U43				0x43	/* CDU */
> +
> +#define AXIOM_U64					0x64
> +#define   AXIOM_U64_REV2_ENABLECDSPROCESSING_REG	0
> +#define   AXIOM_U64_REV2_ENABLECDSPROCESSING_MASK	BIT(0)
> +
> +#define AXIOM_U77				0x77	/* CDU */
> +#define AXIOM_U82				0x82
> +#define AXIOM_U93				0x93	/* CDU */
> +#define AXIOM_U94				0x94	/* CDU */
> +
> +/*
> + * Axiom CDU usage structure copied from downstream CDU_Common.py. Downstream
> + * doesn't mention any revision. According downstream all CDU register windows
> + * are 56 byte wide (8 byte header + 48 byte data).
> + */
> +#define AXIOM_CDU_CMD_STORE			0x0002
> +#define AXIOM_CDU_CMD_COMMIT			0x0003
> +#define AXIOM_CDU_PARAM0_COMMIT			0xb10c
> +#define AXIOM_CDU_PARAM1_COMMIT			0xc0de
> +
> +#define AXIOM_CDU_RESP_SUCCESS			0x0000
> +#define AXIOM_CDU_MAX_DATA_BYTES		48
> +
> +struct axiom_cdu_usage {
> +	union {
> +		__le16 command;
> +		__le16 response;
> +	};
> +	__le16 parameters[3];
> +	u8 data[AXIOM_CDU_MAX_DATA_BYTES];
> +};
> +
> +/*
> + * u01 for the bootloader protocol (BLP)
> + *
> + * Values taken from Bootloader.py [1] which had a comment that documentation
> + * values are out dated. The BLP does not have different versions according the
> + * documentation python helper.
> + *
> + * [1] https://github.com/TouchNetix/axiom_pylib
> + */
> +#define AXIOM_U01_BLP_COMMAND_REG		0x0100
> +#define   AXIOM_U01_BLP_COMMAND_RESET		BIT(1)
> +#define AXIOM_U01_BLP_SATUS_REG			0x0100
> +#define   AXIOM_U01_BLP_STATUS_BUSY		BIT(0)
> +#define AXIOM_U01_BLP_FIFO_REG			0x0102
> +#define   AXIOM_U01_BLP_FIFO_CHK_SIZE_BYTES	255
> +
> +#define AXIOM_PROX_LEVEL			-128
> +#define AXIOM_STARTUP_TIME_MS			110
> +
> +#define AXIOM_USAGE_BASEADDR_MASK		GENMASK(15, 8)
> +#define AXIOM_MAX_USAGES			256	/* u00 - uFF */
> +/*
> + * The devices have a 16bit ADC but Touchnetix used the lower two bits for other
> + * information.
> + */
> +#define AXIOM_MAX_XY				(65535 - 3)
> +#define AXIOM_DEFAULT_POLL_INTERVAL_MS		10
> +#define AXIOM_PAGE_BYTE_LEN			256
> +#define AXIOM_MAX_XFERLEN			0x7fff
> +#define AXIOM_MAX_TOUCHSLOTS			10
> +#define AXIOM_MAX_TOUCHSLOTS_MASK		GENMASK(9, 0)
> +
> +/* aXiom firmware (.axfw) */
> +#define AXIOM_FW_AXFW_SIGNATURE			"AXFW"
> +#define AXIOM_FW_AXFW_FILE_FMT_VER		0x0200
> +
> +struct axiom_fw_axfw_hdr {
> +	u8 signature[4];
> +	__le32 file_crc32;
> +	__le16 file_format_ver;
> +	__le16 device_id;
> +	u8 variant;
> +	u8 minor_ver;
> +	u8 major_ver;
> +	u8 rc_ver;
> +	u8 status;
> +	__le16 silicon_ver;
> +	u8 silicon_rev;
> +	__le32 fw_crc32;
> +} __packed;
> +
> +struct axiom_fw_axfw_chunk_hdr {
> +	u8 internal[6]; /* no description */
> +	__be16 payload_length;
> +};
> +
> +/* aXiom config (.th2cfgbin) */
> +#define AXIOM_FW_CFG_SIGNATURE			0x20071969
> +
> +struct axiom_fw_cfg_hdr {
> +	__be32 signature;
> +	__le16 file_format_ver;
> +	__le16 tcp_file_rev_major;
> +	__le16 tcp_file_rev_minor;
> +	__le16 tcp_file_rev_patch;
> +	u8 tcp_version;
> +} __packed;
> +
> +struct axiom_fw_cfg_chunk_hdr {
> +	u8 usage_num;
> +	u8 usage_rev;
> +	u8 reserved;
> +	__le16 usage_length;
> +} __packed;
> +
> +struct axiom_fw_cfg_chunk {
> +	u8 usage_num;
> +	u8 usage_rev;
> +	u16 usage_length;
> +	const u8 *usage_content;
> +};
> +
> +enum axiom_fw_type {
> +	AXIOM_FW_AXFW,
> +	AXIOM_FW_CFG,
> +	AXIOM_FW_NUM
> +};
> +
> +enum axiom_crc_type {
> +	AXIOM_CRC_CUR,
> +	AXIOM_CRC_NEW,
> +	AXIOM_CRC_NUM
> +};
> +
> +struct axiom_data;
> +
> +struct axiom_usage_info {
> +	unsigned char usage_num;	/* uXX number (XX in hex) */
> +	unsigned char rev_num;		/* rev.X (X in dec) */
> +	bool is_cdu;
> +	bool is_ro;
> +
> +	/* Optional hooks */
> +	int (*process_report)(struct axiom_data *ts, const u8 *buf, size_t bufsize);
> +};
> +
> +enum axiom_runmode {
> +	AXIOM_DISCOVERY_MODE,
> +	AXIOM_TCP_MODE,
> +	AXIOM_TCP_CFG_UPDATE_MODE,
> +	AXIOM_BLP_PRE_MODE,
> +	AXIOM_BLP_MODE,
> +};
> +
> +struct axiom_data {
> +	struct input_dev *input;
> +	struct device *dev;
> +
> +	struct gpio_desc *reset_gpio;
> +	struct regulator_bulk_data supplies[2];
> +	unsigned int num_supplies;
> +
> +	struct regmap *regmap;
> +	struct touchscreen_properties prop;
> +	bool irq_setup_done;
> +	u32 poll_interval;
> +
> +	enum axiom_runmode mode;
> +	/*
> +	 * Two completion types to support firmware updates
> +	 * in irq and poll mode.
> +	 */
> +	struct axiom_completion {
> +		struct completion completion;
> +		bool poll_done;
> +	} nvm_write, boot_complete;
> +
> +	/* Lock to protect both firmware interfaces */
> +	struct mutex fwupdate_lock;
> +	struct axiom_firmware {
> +		/* Lock to protect cancel */
> +		struct mutex lock;
> +		bool cancel;
> +		struct fw_upload *fwl;
> +	} fw[AXIOM_FW_NUM];
> +
> +	unsigned int fw_major;
> +	unsigned int fw_minor;
> +	unsigned int fw_rc;
> +	unsigned int fw_status;
> +	u16 device_id;
> +	u16 jedec_id;
> +	u8 silicon_rev;
> +
> +	/* CRCs we need to check during a config update */
> +	struct axiom_crc {
> +		u32 runtime;
> +		u32 vltusageconfig;
> +		u32 nvltlusageconfig;
> +		u32 u22_sequencedata;
> +		u32 u43_hotspots;
> +		u32 u93_profiles;
> +		u32 u94_deltascalemap;
> +	} crc[AXIOM_CRC_NUM];
> +
> +	bool cds_enabled;
> +	unsigned long enabled_slots;
> +	unsigned int num_slots;
> +
> +	unsigned int max_report_byte_len;
> +	struct axiom_usage_table_entry {
> +		bool populated;
> +		unsigned int baseaddr;
> +		unsigned int size_bytes;
> +		const struct axiom_usage_info *info;
> +	} usage_table[AXIOM_MAX_USAGES];
> +};
> +
> +static int axiom_u01_rev1_process_report(struct axiom_data *ts, const u8 *buf,
> +					 size_t bufsize);
> +static int axiom_u34_rev1_process_report(struct axiom_data *ts, const u8 *_buf,
> +					 size_t bufsize);
> +static int axiom_u41_rev2_process_report(struct axiom_data *ts, const u8 *buf,
> +					 size_t bufsize);
> +
> +#define AXIOM_USAGE(num, rev)		\
> +	{				\
> +		.usage_num = num,	\
> +		.rev_num = rev,		\
> +	}
> +
> +#define AXIOM_RO_USAGE(num, rev)	\
> +	{				\
> +		.usage_num = num,	\
> +		.rev_num = rev,		\
> +		.is_ro = true,		\
> +	}
> +
> +#define AXIOM_CDU_USAGE(num, rev)	\
> +	{				\
> +		.usage_num = num,	\
> +		.rev_num = rev,		\
> +		.is_cdu = true,		\
> +	}
> +
> +#define AXIOM_REPORT_USAGE(num, rev, func)	\
> +	{					\
> +		.usage_num = num,		\
> +		.rev_num = rev,			\
> +		.process_report = func,		\
> +	}
> +
> +/*
> + * All usages used by driver must be added to this list to ensure the
> + * correct communictation with the devices. The list can contain multiple
> + * entries of the same usage to handle different usage revisions.
> + *
> + * Note: During a th2cfgbin update the driver may use usages not listed here.
> + * Therefore the th2cfgbin update compares the current running FW again the
> + * th2cfgbin targets FW.
> + */
> +static const struct axiom_usage_info driver_required_usages[] = {
> +	AXIOM_REPORT_USAGE(AXIOM_U01, 1, axiom_u01_rev1_process_report),
> +	AXIOM_USAGE(AXIOM_U02, 1),
> +	AXIOM_USAGE(AXIOM_U02, 2),
> +	AXIOM_USAGE(AXIOM_U04, 1),
> +	AXIOM_CDU_USAGE(AXIOM_U05, 1),
> +	AXIOM_CDU_USAGE(AXIOM_U22, 1),
> +	AXIOM_RO_USAGE(AXIOM_U31, 1),
> +	AXIOM_RO_USAGE(AXIOM_U32, 1),
> +	AXIOM_RO_USAGE(AXIOM_U33, 2),
> +	AXIOM_RO_USAGE(AXIOM_U36, 1),
> +	AXIOM_REPORT_USAGE(AXIOM_U34, 1, axiom_u34_rev1_process_report),
> +	AXIOM_REPORT_USAGE(AXIOM_U41, 2, axiom_u41_rev2_process_report),
> +	AXIOM_USAGE(AXIOM_U42, 1),
> +	AXIOM_CDU_USAGE(AXIOM_U43, 1),
> +	AXIOM_USAGE(AXIOM_U64, 2),
> +	AXIOM_CDU_USAGE(AXIOM_U77, 1),
> +	AXIOM_RO_USAGE(AXIOM_U82, 1),
> +	AXIOM_CDU_USAGE(AXIOM_U93, 1),
> +	AXIOM_CDU_USAGE(AXIOM_U94, 1),
> +	{ /* sentinel */ }
> +};
> +
> +/************************ Common helpers **************************************/
> +
> +static void axiom_set_runmode(struct axiom_data *ts, enum axiom_runmode mode)
> +{
> +	ts->mode = mode;
> +}
> +
> +static enum axiom_runmode axiom_get_runmode(struct axiom_data *ts)
> +{
> +	return ts->mode;
> +}
> +
> +static const char *axiom_runmode_to_string(struct axiom_data *ts)
> +{
> +	switch (ts->mode) {
> +	case AXIOM_DISCOVERY_MODE:	return "discovery";
> +	case AXIOM_TCP_MODE:		return "tcp";
> +	case AXIOM_TCP_CFG_UPDATE_MODE:	return "th2cfg-update";
> +	case AXIOM_BLP_PRE_MODE:	return "bootloader-pre";
> +	case AXIOM_BLP_MODE:		return "bootlaoder";
> +	default:			return "unknown";
> +	}
> +}
> +
> +static bool axiom_skip_usage_check(struct axiom_data *ts)
> +{
> +	switch (ts->mode) {
> +	case AXIOM_TCP_CFG_UPDATE_MODE:
> +	case AXIOM_DISCOVERY_MODE:
> +	case AXIOM_BLP_MODE:
> +		return true;
> +	case AXIOM_BLP_PRE_MODE:
> +	case AXIOM_TCP_MODE:
> +	default:
> +		return false;
> +	}
> +}
> +
> +static unsigned int
> +axiom_usage_baseaddr(struct axiom_data *ts, unsigned char usage_num)
> +{
> +	return ts->usage_table[usage_num].baseaddr;
> +}
> +
> +static unsigned int
> +axiom_usage_size(struct axiom_data *ts, unsigned char usage_num)
> +{
> +	return ts->usage_table[usage_num].size_bytes;
> +}
> +
> +static int
> +axiom_usage_rev(struct axiom_data *ts, unsigned char usage_num)
> +{
> +	struct axiom_usage_table_entry *entry = &ts->usage_table[usage_num];
> +
> +	if (!entry->info)
> +		return -EINVAL;
> +
> +	return entry->info->rev_num;
> +}
> +
> +static bool
> +axiom_usage_entry_is_report(struct axiom_u31_usage_table_entry *entry)
> +{
> +	return entry->num_pages == 0;
> +}
> +
> +static unsigned int
> +axiom_get_usage_size_bytes(struct axiom_u31_usage_table_entry *entry)
> +{
> +	unsigned char max_offset;
> +
> +	max_offset = FIELD_GET(AXIOM_U31_REV1_MAX_OFFSET_MASK,
> +			       entry->max_offset) + 1;
> +	max_offset *= 2;
> +
> +	if (axiom_usage_entry_is_report(entry))
> +		return max_offset;
> +
> +	if (FIELD_GET(AXIOM_U31_REV1_OFFSET_TYPE_MASK, entry->max_offset))
> +		return (entry->num_pages - 1) * AXIOM_PAGE_BYTE_LEN + max_offset;
> +
> +	return max_offset;
> +}
> +
> +static void axiom_dump_usage_entry(struct device *dev,
> +				   struct axiom_u31_usage_table_entry *entry)
> +{
> +	unsigned int page_len, total_len;
> +
> +	total_len = axiom_get_usage_size_bytes(entry);
> +
> +	if (total_len > AXIOM_PAGE_BYTE_LEN)
> +		page_len = AXIOM_PAGE_BYTE_LEN;
> +	else
> +		page_len = total_len;
> +
> +	if (axiom_usage_entry_is_report(entry))
> +		dev_dbg(dev,
> +			"u%02X rev.%d total-len:%u [REPORT]\n",
> +			entry->usage_num, entry->uifrevision, total_len);
> +	else
> +		dev_dbg(dev,
> +			"u%02X rev.%d first-page:%#02x page-len:%u num-pages:%u total-len:%u\n",
> +			entry->usage_num, entry->uifrevision, entry->start_page, page_len,
> +			entry->num_pages, total_len);
> +}
> +
> +static const struct axiom_usage_info *
> +axiom_get_usage_info(struct axiom_u31_usage_table_entry *query)
> +{
> +	const struct axiom_usage_info *info = driver_required_usages;
> +	bool required = false;
> +	bool found = false;
> +
> +	for (; info->usage_num; info++) {
> +		/* Skip all usages not used by the driver */
> +		if (query->usage_num != info->usage_num)
> +			continue;
> +
> +		/* The usage is used so we need to mark it as required */
> +		required = true;
> +
> +		/* Continue with the next usage if the revision doesn't match */
> +		if (query->uifrevision != info->rev_num)
> +			continue;
> +
> +		found = true;
> +		break;
> +	}
> +
> +	if (required && !found)
> +		return ERR_PTR(-EINVAL);
> +
> +	return found ? info : NULL;
> +}
> +
> +static bool axiom_usage_supported(struct axiom_data *ts, unsigned int baseaddr)
> +{
> +	struct axiom_usage_table_entry *entry;
> +	unsigned int i;
> +
> +	if (axiom_skip_usage_check(ts))
> +		return true;
> +
> +	dev_dbg(ts->dev, "Checking support for baseaddr: %#x\n", baseaddr);
> +
> +	for (i = 0; i < ARRAY_SIZE(ts->usage_table); i++) {
> +		entry = &ts->usage_table[i];
> +
> +		if (!entry->populated)
> +			continue;
> +
> +		if (entry->baseaddr != baseaddr)
> +			continue;
> +
> +		break;
> +	}
> +
> +	if (i == ARRAY_SIZE(ts->usage_table)) {
> +		dev_warn(ts->dev, "Usage not found\n");
> +		return false;
> +	}
> +
> +	if (!entry->info)
> +		WARN(1, "Unsupported usage u%x used, driver bug!", i);
> +
> +	return !!entry->info;
> +}
> +
> +static void axiom_poll(struct input_dev *input);
> +
> +static unsigned long
> +axiom_wait_for_completion_timeout(struct axiom_data *ts, struct axiom_completion *x,
> +				  long timeout)
> +{
> +	struct i2c_client *client = to_i2c_client(ts->dev);
> +	unsigned long poll_timeout;
> +
> +	if (client->irq)
> +		return wait_for_completion_timeout(&x->completion, timeout);
> +
> +	/*
> +	 * Only firmware update cases do wait for completion. Since they require
> +	 * the input device to be closed, the poller is not running. So we need
> +	 * to do the polling manually.
> +	 */
> +	poll_timeout = timeout / 10;
> +
> +	/*
> +	 * Very basic and not very accurate but it does the job because there
> +	 * are no known timeout constraints.
> +	 */
> +	do {
> +		axiom_poll(ts->input);
> +		fsleep(jiffies_to_usecs(poll_timeout));
> +		if (x->poll_done)
> +			break;
> +		timeout -= poll_timeout;
> +	} while (timeout > 0);
> +
> +	x->poll_done = false;
> +
> +	return timeout > 0 ? timeout : 0;
> +}
> +
> +static void axiom_complete(struct axiom_data *ts, struct axiom_completion *x)
> +{
> +	struct i2c_client *client = to_i2c_client(ts->dev);
> +
> +	if (client->irq)
> +		complete(&x->completion);
> +	else
> +		x->poll_done = true;
> +}
> +
> +/*************************** Usage handling ***********************************/
> +/*
> + * Wrapper functions to handle the usage access. Wrappers are used to add
> + * different revision handling later on more easily.
> + */
> +static int axiom_u02_wait_idle(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	unsigned int reg;
> +	int ret, _ret;
> +	u16 cmd;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U02);
> +	reg += AXIOM_U02_REV1_COMMAND_REG;
> +
> +	/*
> +	 * Missing regmap_raw_read_poll_timeout for now. RESP_SUCCESS means that
> +	 * the last command successfully completed and the device is idle.
> +	 */
> +	ret = read_poll_timeout(regmap_raw_read, _ret,
> +				_ret || cmd == AXIOM_U02_REV1_RESP_SUCCESS,
> +				10 * USEC_PER_MSEC, 1 * USEC_PER_SEC, false,
> +				ts->regmap, reg, &cmd, 2);
> +	if (ret)
> +		dev_err(ts->dev, "Poll u02 timedout with: %#x\n", cmd);
> +
> +	return ret;
> +}
> +
> +static int
> +axiom_u02_send_msg(struct axiom_data *ts,
> +		   const struct axiom_u02_rev1_system_manager_msg *msg,
> +		   bool validate_response)
> +{
> +	struct device *dev = ts->dev;
> +	unsigned int reg;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U02);
> +	reg += AXIOM_U02_REV1_COMMAND_REG;
> +
> +	ret = regmap_raw_write(ts->regmap, reg, msg, sizeof(*msg));
> +	if (ret)
> +		return ret;
> +
> +	if (!validate_response)
> +		return 0;
> +
> +	return axiom_u02_wait_idle(ts);
> +}
> +
> +static int
> +axiom_u02_rev1_send_single_cmd(struct axiom_data *ts, u16 cmd)
> +{
> +	struct axiom_u02_rev1_system_manager_msg msg = {
> +		.command = cpu_to_le16(cmd)
> +	};
> +
> +	return axiom_u02_send_msg(ts, &msg, true);
> +}
> +
> +static int axiom_u02_handshakenvm(struct axiom_data *ts)
> +{
> +	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_HANDSHAKENVM);
> +}
> +
> +static int axiom_u02_computecrc(struct axiom_data *ts)
> +{
> +	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_COMPUTECRCS);
> +}
> +
> +static int axiom_u02_stop(struct axiom_data *ts)
> +{
> +	return axiom_u02_rev1_send_single_cmd(ts, AXIOM_U02_REV1_CMD_STOP);
> +}
> +
> +static int axiom_u02_save_config(struct axiom_data *ts)
> +{
> +	struct axiom_u02_rev1_system_manager_msg msg;
> +	struct device *dev = ts->dev;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_SAVEVLTLCFG2NVM);
> +	msg.parameters[0] = 0; /* Don't care */
> +	msg.parameters[1] = cpu_to_le16(AXIOM_U02_REV1_PARAM1_SAVEVLTLCFG2NVM);
> +	msg.parameters[2] = cpu_to_le16(AXIOM_U02_REV1_PARAM2_SAVEVLTLCFG2NVM);
> +
> +	ret = axiom_u02_send_msg(ts, &msg, false);
> +	if (ret)
> +		return ret;
> +
> +	/* Downstream axcfg.py waits for 2sec without checking U01 response */
> +	ret = axiom_wait_for_completion_timeout(ts, &ts->nvm_write,
> +					msecs_to_jiffies(2 * MSEC_PER_SEC));
> +	if (!ret)
> +		dev_err(ts->dev, "Error save volatile config timedout\n");
> +
> +	return ret ? 0 : -ETIMEDOUT;
> +}
> +
> +static int axiom_u02_swreset(struct axiom_data *ts)
> +{
> +	struct axiom_u02_rev1_system_manager_msg msg = { };
> +	struct device *dev = ts->dev;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_SOFTRESET);
> +	ret = axiom_u02_send_msg(ts, &msg, false);
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * Downstream axcfg.py waits for 1sec without checking U01 hello. Tests
> +	 * showed that waiting for the hello message isn't enough therefore we
> +	 * need both to make it robuster.
> +	 */
> +	ret = axiom_wait_for_completion_timeout(ts, &ts->boot_complete,
> +					msecs_to_jiffies(1 * MSEC_PER_SEC));
> +	if (!ret)
> +		dev_err(ts->dev, "Error swreset timedout\n");
> +
> +	fsleep(USEC_PER_SEC);
> +
> +	return ret ? 0 : -ETIMEDOUT;
> +}
> +
> +static int axiom_u02_fillconfig(struct axiom_data *ts)
> +{
> +	struct axiom_u02_rev1_system_manager_msg msg;
> +	struct device *dev = ts->dev;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_FILLCONFIG);
> +	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_FILLCONFIG);
> +	msg.parameters[1] = cpu_to_le16(AXIOM_U02_REV1_PARAM1_FILLCONFIG);
> +	msg.parameters[2] = cpu_to_le16(AXIOM_U02_REV1_PARAM2_FILLCONFIG_ZERO);
> +
> +	return axiom_u02_send_msg(ts, &msg, true);
> +}
> +
> +static int axiom_u02_enter_bootloader(struct axiom_data *ts)
> +{
> +	struct axiom_u02_rev1_system_manager_msg msg = { };
> +	struct device *dev = ts->dev;
> +	unsigned int val;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U02) != 1 &&
> +	    axiom_usage_rev(ts, AXIOM_U02) != 2) {
> +		dev_err(dev, "Only u02 rev.1 and rev.2 are supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * Enter the bootloader mode requires 3 consecutive messages so we can't
> +	 * check for the response.
> +	 */
> +	msg.command = cpu_to_le16(AXIOM_U02_REV1_CMD_ENTERBOOTLOADER);
> +	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY1);
> +	ret = axiom_u02_send_msg(ts, &msg, false);
> +	if (ret) {
> +		dev_err(dev, "Failed to send bootloader-key1: %d\n", ret);
> +		return ret;
> +	}
> +
> +	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY2);
> +	ret = axiom_u02_send_msg(ts, &msg, false);
> +	if (ret) {
> +		dev_err(dev, "Failed to send bootloader-key2: %d\n", ret);
> +		return ret;
> +	}
> +
> +	msg.parameters[0] = cpu_to_le16(AXIOM_U02_REV1_PARAM0_ENTERBOOLOADER_KEY3);
> +	ret = axiom_u02_send_msg(ts, &msg, false);
> +	if (ret) {
> +		dev_err(dev, "Failed to send bootloader-key3: %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* Sleep before the first read to give the device time */
> +	fsleep(250 * USEC_PER_MSEC);
> +
> +	/* Wait till the device reports it is in bootloader mode */
> +	return regmap_read_poll_timeout(ts->regmap,
> +			AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, val,
> +			FIELD_GET(AXIOM_U31_REV1_MODE_MASK, val) ==
> +			AXIOM_U31_REV1_MODE_BLP, 250 * USEC_PER_MSEC,
> +			USEC_PER_SEC);
> +}
> +
> +static int axiom_u04_get(struct axiom_data *ts, u8 **_buf)
> +{
> +	u8 buf[AXIOM_U04_REV1_SIZE_BYTES];
> +	struct device *dev = ts->dev;
> +	unsigned int reg;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U04) != 1) {
> +		dev_err(dev, "Only u04 rev.1 is supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U04);
> +	ret = regmap_raw_read(ts->regmap, reg, buf, sizeof(buf));
> +	if (ret)
> +		return ret;
> +
> +	*_buf = kmemdup(buf, sizeof(buf), GFP_KERNEL);
> +
> +	return sizeof(buf);
> +}
> +
> +static int axiom_u04_set(struct axiom_data *ts, u8 *buf, unsigned int bufsize)
> +{
> +	struct device *dev = ts->dev;
> +	unsigned int reg;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U04) != 1) {
> +		dev_err(dev, "Only u04 rev.1 is supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U04);
> +	return regmap_raw_write(ts->regmap, reg, buf, bufsize);
> +}
> +
> +/*
> + * U31 revision must be always rev.1 else the whole self discovery mechanism
> + * fall apart.
> + */
> +static int axiom_u31_parse_device_info(struct axiom_data *ts)
> +{
> +	struct regmap *regmap = ts->regmap;
> +	unsigned int id_low, id_high, val;
> +	int ret;
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, &id_high);
> +	if (ret)
> +		return ret;
> +	id_high = FIELD_GET(AXIOM_U31_REV1_DEVICE_ID_HIGH_MASK, id_high);
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_LOW_REG, &id_low);
> +	if (ret)
> +		return ret;
> +	ts->device_id = id_high << 8 | id_low;
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_MAJ_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->fw_major = val;
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_MIN_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->fw_minor = val;
> +
> +	/* All other fields are not allowed to be read in BLP mode */
> +	if (axiom_get_runmode(ts) == AXIOM_BLP_MODE)
> +		return 0;
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_RC_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->fw_rc = FIELD_GET(AXIOM_U31_REV1_RUNTIME_FW_RC_MASK, val);
> +	ts->silicon_rev = FIELD_GET(AXIOM_U31_REV1_SILICON_REV_MASK, val);
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_RUNTIME_FW_STATUS_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->fw_status = FIELD_GET(AXIOM_U31_REV1_RUNTIME_FW_STATUS, val);
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_JEDEC_ID_HIGH_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->jedec_id = val << 8;
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_JEDEC_ID_LOW_REG, &val);
> +	if (ret)
> +		return ret;
> +	ts->jedec_id |= val;
> +
> +	return 0;
> +}
> +
> +static int axiom_u33_read(struct axiom_data *ts, struct axiom_crc *crc);
> +
> +static int axiom_u31_device_discover(struct axiom_data *ts)
> +{
> +	struct axiom_u31_usage_table_entry *u31_usage_table __free(kfree) = NULL;
> +	struct axiom_u31_usage_table_entry *entry;
> +	struct regmap *regmap = ts->regmap;
> +	unsigned int mode, num_usages;
> +	struct device *dev = ts->dev;
> +	unsigned int i;
> +	int ret;
> +
> +	axiom_set_runmode(ts, AXIOM_DISCOVERY_MODE);
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG, &mode);
> +	if (ret) {
> +		dev_err(dev, "Failed to read MODE\n");
> +		return ret;
> +	}
> +
> +	/* Abort if the device is in bootloader protocol mode */
> +	mode = FIELD_GET(AXIOM_U31_REV1_MODE_MASK, mode);
> +	if (mode == AXIOM_U31_REV1_MODE_BLP)
> +		axiom_set_runmode(ts, AXIOM_BLP_MODE);
> +
> +	/* Since we are not in bootloader mode we can parse the device info */
> +	ret = axiom_u31_parse_device_info(ts);
> +	if (ret) {
> +		dev_err(dev, "Failed to parse device info\n");
> +		return ret;
> +	}
> +
> +	/* All other fields are not allowed to be read in BLP mode */
> +	if (axiom_get_runmode(ts) == AXIOM_BLP_MODE) {
> +		dev_info(dev, "Device in Bootloader mode, firmware upload required\n");
> +		return -EACCES;
> +	}
> +
> +	ret = regmap_read(regmap, AXIOM_U31_REV1_NUM_USAGES_REG, &num_usages);
> +	if (ret) {
> +		dev_err(dev, "Failed to read NUM_USAGES\n");
> +		return ret;
> +	}
> +
> +	u31_usage_table = kcalloc(num_usages, sizeof(*u31_usage_table),
> +				  GFP_KERNEL);
> +	if (!u31_usage_table)
> +		return -ENOMEM;
> +
> +	ret = regmap_raw_read(regmap, AXIOM_U31_REV1_PAGE1, u31_usage_table,
> +			      array_size(num_usages, sizeof(*u31_usage_table)));
> +	if (ret) {
> +		dev_err(dev, "Failed to read NUM_USAGES\n");
> +		return ret;
> +	}
> +
> +	/*
> +	 * axiom_u31_device_discover() is call after fw update too, so ensure
> +	 * that the usage_table is cleared.
> +	 */
> +	memset(ts->usage_table, 0, sizeof(ts->usage_table));
> +
> +	for (i = 0, entry = u31_usage_table; i < num_usages; i++, entry++) {
> +		unsigned char idx = entry->usage_num;
> +		const struct axiom_usage_info *info;
> +		unsigned int size_bytes;
> +
> +		axiom_dump_usage_entry(dev, entry);
> +
> +		/*
> +		 * Verify that the driver used usages are supported. Don't abort
> +		 * yet if a usage isn't supported to allow the user to dump the
> +		 * actual usage table.
> +		 */
> +		info = axiom_get_usage_info(entry);
> +		if (IS_ERR(info)) {
> +			dev_info(dev, "Required usage u%02x isn't supported for rev.%u\n",
> +				 entry->usage_num, entry->uifrevision);
> +			ret = -EACCES;
> +		}
> +
> +		size_bytes = axiom_get_usage_size_bytes(entry);
> +
> +		ts->usage_table[idx].baseaddr = entry->start_page << 8;
> +		ts->usage_table[idx].size_bytes = size_bytes;
> +		ts->usage_table[idx].populated = true;
> +		ts->usage_table[idx].info = info;
> +
> +		if (axiom_usage_entry_is_report(entry) &&
> +		    ts->max_report_byte_len < size_bytes)
> +			ts->max_report_byte_len = size_bytes;
> +	}
> +
> +	if (ret)
> +		return ret;
> +
> +	/* From now on we are in TCP mode to include usage revision checks */
> +	axiom_set_runmode(ts, AXIOM_TCP_MODE);
> +
> +	return axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
> +}
> +
> +static int axiom_u33_read(struct axiom_data *ts, struct axiom_crc *crc)
> +{
> +	struct device *dev = ts->dev;
> +	struct axiom_u33_rev2 val;
> +	unsigned int reg;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U33) != 2) {
> +		dev_err(dev, "Only u33 rev.2 is supported at the moment\n");
> +		return -EINVAL;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U33);
> +	ret = regmap_raw_read(ts->regmap, reg, &val, sizeof(val));
> +	if (ret) {
> +		dev_err(dev, "Failed to read u33\n");
> +		return ret;
> +	}
> +
> +	crc->runtime = le32_to_cpu(val.runtime_crc);
> +	crc->vltusageconfig = le32_to_cpu(val.vltusageconfig_crc);
> +	crc->nvltlusageconfig = le32_to_cpu(val.nvltlusageconfig_crc);
> +	crc->u22_sequencedata = le32_to_cpu(val.u22_sequencedata_crc);
> +	crc->u43_hotspots = le32_to_cpu(val.u43_hotspots_crc);
> +	crc->u93_profiles = le32_to_cpu(val.u93_profiles_crc);
> +	crc->u94_deltascalemap = le32_to_cpu(val.u94_deltascalemap_crc);
> +
> +	return 0;
> +}
> +
> +static void axiom_u42_get_touchslots(struct axiom_data *ts)
> +{
> +	u8 *buf __free(kfree) = NULL;
> +	struct device *dev = ts->dev;
> +	unsigned int bufsize;
> +	unsigned int reg;
> +	int ret, i;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U42) != 1) {
> +		dev_warn(dev, "Unsupported u42 revision, use default value\n");
> +		goto fallback;
> +	}
> +
> +	bufsize = axiom_usage_size(ts, AXIOM_U42);
> +	buf = kzalloc(bufsize, GFP_KERNEL);
> +	if (!buf) {
> +		dev_warn(dev, "Failed to alloc u42 read buffer, use default value\n");
> +		goto fallback;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U42);
> +	ret = regmap_raw_read(ts->regmap, reg, buf, bufsize);
> +	if (ret) {
> +		dev_warn(dev, "Failed to read u42, use default value\n");
> +		goto fallback;
> +	}
> +
> +	for (i = 0; i < AXIOM_MAX_TOUCHSLOTS; i++) {
> +		bool touch_enabled;
> +
> +		touch_enabled = buf[AXIOM_U42_REV1_REPORT_ID_CONTAINS(i)] ==
> +				AXIOM_U42_REV1_REPORT_ID_TOUCH;
> +		if (touch_enabled) {
> +			ts->enabled_slots |= BIT(i);
> +			ts->num_slots++;
> +		}
> +	}
> +
> +	return;
> +
> +fallback:
> +	ts->enabled_slots = AXIOM_MAX_TOUCHSLOTS_MASK;
> +	ts->num_slots = AXIOM_MAX_TOUCHSLOTS;
> +}
> +
> +static void axiom_u64_cds_enabled(struct axiom_data *ts)
> +{
> +	unsigned int reg, val;
> +	int ret;
> +
> +	if (axiom_usage_rev(ts, AXIOM_U64) != 2)
> +		goto fallback_out;
> +
> +	reg = axiom_usage_baseaddr(ts, AXIOM_U64);
> +	reg += AXIOM_U64_REV2_ENABLECDSPROCESSING_REG;
> +
> +	ret = regmap_read(ts->regmap, reg, &val);
> +	if (ret)
> +		goto fallback_out;
> +
> +	val = FIELD_GET(AXIOM_U64_REV2_ENABLECDSPROCESSING_MASK, val);
> +	ts->cds_enabled = val ? true : false;
> +
> +	return;
> +
> +fallback_out:
> +	ts->cds_enabled = false;
> +}
> +
> +static int axiom_cdu_wait_idle(struct axiom_data *ts, u8 cdu_usage_num)
> +{
> +	unsigned int reg;
> +	int ret, _ret;
> +	u16 cmd;
> +
> +	reg = axiom_usage_baseaddr(ts, cdu_usage_num);
> +
> +	/*
> +	 * Missing regmap_raw_read_poll_timeout for now. RESP_SUCCESS means that
> +	 * the last command successfully completed and the device is idle.
> +	 */
> +	ret = read_poll_timeout(regmap_raw_read, _ret,
> +				_ret || cmd == AXIOM_CDU_RESP_SUCCESS,
> +				10 * USEC_PER_MSEC, 1 * USEC_PER_SEC, false,
> +				ts->regmap, reg, &cmd, 2);
> +	if (ret)
> +		dev_err(ts->dev, "Poll CDU u%x timedout with: %#x\n",
> +			cdu_usage_num, cmd);
> +
> +	return ret;
> +}
> +
> +/*********************** Report usage handling ********************************/
> +
> +static int axiom_process_report(struct axiom_data *ts, unsigned char usage_num,
> +				const u8 *buf, size_t buflen)
> +{
> +	struct axiom_usage_table_entry *entry = &ts->usage_table[usage_num];
> +
> +	/* Skip processing if not in TCP mode */
> +	if ((axiom_get_runmode(ts) != AXIOM_TCP_MODE) &&
> +	    (axiom_get_runmode(ts) != AXIOM_TCP_CFG_UPDATE_MODE))
> +		return 0;
> +
> +	/* May happen if an unsupported usage was requested */
> +	if (!entry) {
> +		dev_info(ts->dev, "Unsupported usage U%x request\n", usage_num);
> +		return 0;
> +	}
> +
> +	/* Supported report usages need to have a process_report hook */
> +	if (!entry->info || !entry->info->process_report)
> +		return -EINVAL;
> +
> +	return entry->info->process_report(ts, buf, buflen);
> +}
> +
> +/* Make use of datasheet method 1 - single transfer read */
> +static int
> +axiom_u34_rev1_process_report(struct axiom_data *ts, const u8 *_buf, size_t bufsize)
> +{
> +	unsigned int reg = axiom_usage_baseaddr(ts, AXIOM_U34);
> +	struct regmap *regmap = ts->regmap;
> +	u8 buf[AXIOM_PAGE_BYTE_LEN] = { };
> +	struct device *dev = ts->dev;
> +	unsigned char report_usage;
> +	u16 crc_report, crc_calc;
> +	unsigned int len;
> +	u8 *payload;
> +	int ret;
> +
> +	ret = regmap_raw_read(regmap, reg, buf, ts->max_report_byte_len);
> +	if (ret)
> +		return ret;
> +
> +	/* TODO: Add overflow statistics */
> +
> +	/* REPORTLENGTH is in uint16 */
> +	len = FIELD_GET(AXIOM_U34_REV1_REPORTLENGTH_MASK, buf[0]);
> +	len *= 2;
> +
> +	/*
> +	 * Downstream ignores zero length reports, extend the check to validate
> +	 * the upper bound too.
> +	 */
> +	if (len == 0 || len > AXIOM_PAGE_BYTE_LEN) {
> +		dev_dbg_ratelimited(dev, "Invalid report length: %u\n", len);
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * The CRC16 value can be queried at the last two bytes of the report.
> +	 * The value itself is covering the complete report excluding the CRC16
> +	 * value at the end.
> +	 */
> +	crc_report = get_unaligned_le16(&buf[len - 2]);
> +	crc_calc = crc16(0, buf, (len - 2));
> +
> +	if (crc_calc != crc_report) {
> +		dev_err_ratelimited(dev, "CRC16 mismatch!\n");
> +		return -EINVAL;
> +	}
> +
> +	report_usage = buf[1];
> +	payload = &buf[AXIOM_U34_REV1_PREAMBLE_BYTES];
> +	len -= AXIOM_U34_REV1_PREAMBLE_BYTES - AXIOM_U34_REV1_POSTAMBLE_BYTES;
> +
> +	switch (report_usage) {
> +	case AXIOM_U01:
> +	case AXIOM_U41:
> +		return axiom_process_report(ts, report_usage, payload, len);
> +	default:
> +		dev_dbg(dev, "Unsupported report u%02X received\n",
> +			report_usage);
> +	}
> +
> +	return 0;
> +}
> +
> +static void
> +axiom_u41_rev2_decode_target(const u8 *buf, u8 id, u16 *x, u16 *y, s8 *z)
> +{
> +	u16 val;
> +
> +	val = get_unaligned_le16(&buf[AXIOM_U41_REV2_X_REG(id)]);
> +	val &= AXIOM_MAX_XY;
> +	*x = val;
> +
> +	val = get_unaligned_le16(&buf[AXIOM_U41_REV2_Y_REG(id)]);
> +	val &= AXIOM_MAX_XY;
> +	*y = val;
> +
> +	*z = buf[AXIOM_U41_REV2_Z_REG(id)];
> +}
> +
> +static int
> +axiom_u41_rev2_process_report(struct axiom_data *ts, const u8 *buf, size_t bufsize)
> +{
> +	struct input_dev *input = ts->input;
> +	unsigned char id;
> +	u16 targets;
> +
> +	/*
> +	 * The input registration can be postponed but the touchscreen FW is
> +	 * sending u41 reports regardless.
> +	 */
> +	if (!input)
> +		return 0;
> +
> +	targets = get_unaligned_le16(&buf[AXIOM_U41_REV2_TARGETSTATUS_REG]);
> +
> +	for_each_set_bit(id, &ts->enabled_slots, AXIOM_MAX_TOUCHSLOTS) {
> +		bool present;
> +		u16 x, y;
> +		s8 z;
> +
> +		axiom_u41_rev2_decode_target(buf, id, &x, &y, &z);
> +
> +		present = targets & BIT(id);
> +		/* Ignore possible jitters */
> +		if (z == AXIOM_PROX_LEVEL)
> +			present = false;
> +
> +		dev_dbg(ts->dev, "id:%u x:%u y:%u z:%d present:%u",
> +			id, x, y, z, present);
> +
> +		input_mt_slot(input, id);
> +		if (input_mt_report_slot_state(input, MT_TOOL_FINGER, present))
> +			touchscreen_report_pos(input, &ts->prop, x, y, true);
> +
> +		if (!present)
> +			continue;
> +
> +		input_report_abs(input, ABS_MT_DISTANCE, z < 0 ? -z : 0);
> +		if (ts->cds_enabled)
> +			input_report_abs(input, ABS_MT_PRESSURE, z >= 0 ? z : 0);
> +	}
> +
> +	input_sync(input);
> +
> +	return 0;
> +}
> +
> +static int
> +axiom_u01_rev1_process_report(struct axiom_data *ts, const u8 *buf, size_t bufsize)
> +{
> +	switch (buf[AXIOM_U01_REV1_REPORTTYPE_REG]) {
> +	case AXIOM_U01_REV1_REPORTTYPE_HELLO:
> +		dev_dbg(ts->dev, "u01 HELLO received\n");
> +		axiom_complete(ts, &ts->boot_complete);
> +		return 0;
> +	case AXIOM_U01_REV1_REPORTTYPE_HEARTBEAT:
> +		dev_dbg_ratelimited(ts->dev, "u01 HEARTBEAT received\n");
> +		return 0;
> +	case AXIOM_U01_REV1_REPORTTYPE_OPCOMPLETE:
> +		dev_dbg(ts->dev, "u01 OPCOMPLETE received\n");
> +		axiom_u02_handshakenvm(ts);
> +		axiom_complete(ts, &ts->nvm_write);
> +		return 0;
> +	default:
> +		return -EINVAL;
> +	}
> +}
> +
> +/**************************** Regmap handling *********************************/
> +
> +#define AXIOM_CMD_HDR_DIR_MASK	BIT(15)
> +#define   AXIOM_CMD_HDR_READ	1
> +#define	  AXIOM_CMD_HDR_WRITE	0
> +#define AXIOM_CMD_HDR_LEN_MASK	GENMASK(14, 0)
> +
> +struct axiom_cmd_header {
> +	__le16 target_address;
> +	__le16 xferlen;
> +};
> +
> +/* Custom regmap read/write handling is required due to the aXiom protocol */
> +static int axiom_regmap_read(void *context, const void *reg_buf, size_t reg_size,
> +			     void *val_buf, size_t val_size)
> +{
> +	struct device *dev = context;
> +	struct i2c_client *i2c = to_i2c_client(dev);
> +	struct axiom_data *ts = i2c_get_clientdata(i2c);
> +	struct axiom_cmd_header hdr;
> +	u16 xferlen, addr, baseaddr;
> +	struct i2c_msg xfer[2];
> +	int ret;
> +
> +	if (val_size > AXIOM_MAX_XFERLEN) {
> +		dev_err(ts->dev, "Exceed max xferlen: %zu > %u\n",
> +			val_size, AXIOM_MAX_XFERLEN);
> +		return -EINVAL;
> +	}
> +
> +	addr = *((u16 *)reg_buf);
> +	hdr.target_address = cpu_to_le16(addr);
> +	xferlen = FIELD_PREP(AXIOM_CMD_HDR_DIR_MASK, AXIOM_CMD_HDR_READ) |
> +		  FIELD_PREP(AXIOM_CMD_HDR_LEN_MASK, val_size);
> +	hdr.xferlen = cpu_to_le16(xferlen);
> +
> +	/* Verify that usage including the usage rev is supported */
> +	baseaddr = addr & AXIOM_USAGE_BASEADDR_MASK;
> +	if (!axiom_usage_supported(ts, baseaddr))
> +		return -EINVAL;
> +
> +	xfer[0].addr = i2c->addr;
> +	xfer[0].flags = 0;
> +	xfer[0].len = sizeof(hdr);
> +	xfer[0].buf = (u8 *)&hdr;
> +
> +	xfer[1].addr = i2c->addr;
> +	xfer[1].flags = I2C_M_RD;
> +	xfer[1].len = val_size;
> +	xfer[1].buf = val_buf;
> +
> +	ret = i2c_transfer(i2c->adapter, xfer, 2);
> +	if (ret == 2)
> +		return 0;
> +	else if (ret < 0)
> +		return ret;
> +	else
> +		return -EIO;
> +}
> +
> +static int axiom_regmap_write(void *context, const void *data, size_t count)
> +{
> +	struct device *dev = context;
> +	struct i2c_client *i2c = to_i2c_client(dev);
> +	struct axiom_data *ts = i2c_get_clientdata(i2c);
> +	char *buf __free(kfree) = NULL;
> +	struct axiom_cmd_header hdr;
> +	u16 xferlen, addr, baseaddr;
> +	size_t val_size, msg_size;
> +	int ret;
> +
> +	val_size = count - sizeof(addr);
> +	if (val_size > AXIOM_MAX_XFERLEN) {
> +		dev_err(ts->dev, "Exceed max xferlen: %zu > %u\n",
> +			val_size, AXIOM_MAX_XFERLEN);
> +		return -EINVAL;
> +	}
> +
> +	addr = *((u16 *)data);
> +	hdr.target_address = cpu_to_le16(addr);
> +	xferlen = FIELD_PREP(AXIOM_CMD_HDR_DIR_MASK, AXIOM_CMD_HDR_WRITE) |
> +		  FIELD_PREP(AXIOM_CMD_HDR_LEN_MASK, val_size);
> +	hdr.xferlen = cpu_to_le16(xferlen);
> +
> +	/* Verify that usage including the usage rev is supported */
> +	baseaddr = addr & AXIOM_USAGE_BASEADDR_MASK;
> +	if (!axiom_usage_supported(ts, baseaddr))
> +		return -EINVAL;
> +
> +	msg_size = sizeof(hdr) + val_size;
> +	buf = kzalloc(msg_size, GFP_KERNEL);
> +	if (!buf)
> +		return -ENOMEM;
> +
> +	memcpy(buf, &hdr, sizeof(hdr));
> +	memcpy(&buf[sizeof(hdr)], &((char *)data)[2], val_size);
> +
> +	ret = i2c_master_send(i2c, buf, msg_size);
> +
> +	return ret == msg_size ? 0 : ret;
> +}
> +
> +static const struct regmap_config axiom_i2c_regmap_config = {
> +	.reg_bits = 16,
> +	.val_bits = 8,
> +	.read = axiom_regmap_read,
> +	.write = axiom_regmap_write,
> +};
> +
> +/************************ FW update handling **********************************/
> +
> +static int axiom_update_input_dev(struct axiom_data *ts);
> +
> +static enum fw_upload_err
> +axiom_axfw_fw_prepare(struct fw_upload *fw_upload, const u8 *data, u32 size)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
> +	u8 major_ver, minor_ver, rc_ver, status;
> +	u32 fw_file_crc32, crc32_calc;
> +	struct device *dev = ts->dev;
> +	unsigned int signature_len;
> +	enum fw_upload_err ret;
> +	u16 fw_file_format_ver;
> +	u16 fw_file_device_id;
> +
> +	mutex_lock(&afw->lock);
> +	afw->cancel = false;
> +	mutex_unlock(&afw->lock);
> +
> +	mutex_lock(&ts->fwupdate_lock);
> +
> +	if (size < sizeof(struct axiom_fw_axfw_hdr)) {
> +		dev_err(dev, "Invalid AXFW file size\n");
> +		ret = FW_UPLOAD_ERR_INVALID_SIZE;
> +		goto out;
> +	}
> +
> +	signature_len = strlen(AXIOM_FW_AXFW_SIGNATURE);
> +	if (strncmp(data, AXIOM_FW_AXFW_SIGNATURE, signature_len)) {
> +		/*
> +		 * AXFW has a header which can be used to perform validations,
> +		 * ALC don't. Therefore the AXFW format is preferred.
> +		 */
> +		dev_warn(dev, "No AXFW signature, assume ALC firmware\n");
> +		ret = FW_UPLOAD_ERR_NONE;
> +		goto out;
> +	}
> +
> +	fw_file_crc32 = get_unaligned_le32(&data[signature_len]);
> +	crc32_calc = crc32(~0, &data[8], size - 8) ^ 0xffffffff;
> +	if (fw_file_crc32 != crc32_calc) {
> +		dev_err(dev, "AXFW CRC32 doesn't match (fw:%#x calc:%#x)\n",
> +			fw_file_crc32, crc32_calc);
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	data += signature_len + sizeof(fw_file_crc32);
> +	fw_file_format_ver = get_unaligned_le16(data);
> +	if (fw_file_format_ver != AXIOM_FW_AXFW_FILE_FMT_VER) {
> +		dev_err(dev, "Invalid AXFW file format version: %04x",
> +			fw_file_format_ver);
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	data += sizeof(fw_file_format_ver);
> +	fw_file_device_id = get_unaligned_le16(data);
> +	if (fw_file_device_id != ts->device_id) {
> +		dev_err(dev, "Invalid AXFW target device (fw:%#04x dev:%#04x)\n",
> +			fw_file_device_id, ts->device_id);
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	/*
> +	 * This can happen if:
> +	 *  * the device came up in bootloader mode, or
> +	 *  * downloading the firmware failed in between, or
> +	 *  * the following usage discovery failed.
> +	 *
> +	 *  All cases are crcitical and we need to use any firmware to
> +	 *  bring the device back into a working state which is supported by the
> +	 *  host.
> +	 */
> +	if (axiom_get_runmode(ts) != AXIOM_TCP_MODE)
> +		return FW_UPLOAD_ERR_NONE;
> +
> +	data += sizeof(fw_file_device_id);
> +	/* Skip variant */
> +	minor_ver = *++data;
> +	major_ver = *++data;
> +	rc_ver = *++data;
> +	status = *++data;
> +
> +	if (major_ver == ts->fw_major && minor_ver == ts->fw_minor &&
> +	    rc_ver == ts->fw_rc && status == ts->fw_status) {
> +		ret = FW_UPLOAD_ERR_SKIP;
> +		goto out;
> +	}
> +
> +	dev_info(dev, "Detected AXFW %02u.%02u.%02u (%s)\n",
> +		 major_ver, minor_ver, rc_ver,
> +		 status ? "production" : "engineering");
> +
> +	mutex_lock(&afw->lock);
> +	ret = afw->cancel ? FW_UPLOAD_ERR_CANCELED : FW_UPLOAD_ERR_NONE;
> +	mutex_unlock(&afw->lock);
> +
> +out:
> +	/*
> +	 * In FW_UPLOAD_ERR_NONE case the complete handler will release the
> +	 * lock.
> +	 */
> +	if (ret != FW_UPLOAD_ERR_NONE)
> +		mutex_unlock(&ts->fwupdate_lock);
> +
> +	return ret;
> +}
> +
> +static int axiom_enter_bootloader_mode(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	int ret;
> +
> +	axiom_set_runmode(ts, AXIOM_BLP_PRE_MODE);
> +
> +	ret = axiom_u02_wait_idle(ts);
> +	if (ret)
> +		goto err_out;
> +
> +	ret = axiom_u02_enter_bootloader(ts);
> +	if (ret) {
> +		dev_err(dev, "Failed to enter bootloader mode\n");
> +		goto err_out;
> +	}
> +
> +	axiom_set_runmode(ts, AXIOM_BLP_MODE);
> +
> +	return 0;
> +
> +err_out:
> +	axiom_set_runmode(ts, AXIOM_TCP_MODE);
> +
> +	return ret;
> +}
> +
> +static int axoim_blp_wait_ready(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	unsigned int reg;
> +	int tmp, ret;
> +	u8 buf[4];
> +
> +	reg = AXIOM_U01_BLP_SATUS_REG;
> +
> +	/* BLP busy poll requires to read 4 bytes! */
> +	ret = read_poll_timeout(regmap_raw_read, tmp,
> +				tmp || !(buf[2] & AXIOM_U01_BLP_STATUS_BUSY),
> +				10 * USEC_PER_MSEC, 5 * USEC_PER_SEC, false,
> +				ts->regmap, reg, &buf, 4);
> +	if (ret)
> +		dev_err(dev, "Bootloader wait processing packets failed %d\n", ret);
> +
> +	return ret;
> +}
> +
> +static int
> +axiom_blp_write_chunk(struct axiom_data *ts, const u8 *data, u16 length)
> +{
> +	unsigned int chunk_size = AXIOM_U01_BLP_FIFO_CHK_SIZE_BYTES;
> +	unsigned int reg = AXIOM_U01_BLP_FIFO_REG;
> +	struct device *dev = ts->dev;
> +	unsigned int pos = 0;
> +	int ret;
> +
> +	ret = axoim_blp_wait_ready(ts);
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * TODO: Downstream does this chunk transfers. Verify if this is
> +	 * required if one fw-chunk <= AXIOM_MAX_XFERLEN
> +	 */
> +	while (pos < length) {
> +		u16 len;
> +
> +		len = chunk_size;
> +		if ((pos + chunk_size) > length)
> +			len = length - pos;
> +
> +		ret = regmap_raw_write(ts->regmap, reg, &data[pos], len);
> +		if (ret) {
> +			dev_err(dev, "Bootloader download AXFW chunk failed %d\n", ret);
> +			return ret;
> +		}
> +
> +		pos += len;
> +		ret = axoim_blp_wait_ready(ts);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int axiom_blp_reset(struct axiom_data *ts)
> +{
> +	__le16 reset_cmd = cpu_to_le16(AXIOM_U01_BLP_COMMAND_RESET);
> +	unsigned int reg = AXIOM_U01_BLP_COMMAND_REG;
> +	struct device *dev = ts->dev;
> +	unsigned int attempts = 20;
> +	unsigned int mode;
> +	int ret;
> +
> +	ret = axoim_blp_wait_ready(ts);
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * For some reason this write fail with -ENXIO. Skip checking the return
> +	 * code (which is also done by the downstream axfw.py tool and poll u31
> +	 * instead.
> +	 */
> +	regmap_raw_write(ts->regmap, reg, &reset_cmd, sizeof(reset_cmd));
> +
> +	do {
> +		ret = regmap_read(ts->regmap, AXIOM_U31_REV1_DEVICE_ID_HIGH_REG,
> +				  &mode);
> +		if (!ret)
> +			break;
> +
> +		fsleep(250 * USEC_PER_MSEC);
> +	} while (attempts--);
> +
> +	if (ret) {
> +		dev_err(dev, "Failed to read MODE after BLP reset: %d\n", ret);
> +		return ret;
> +	}
> +
> +	mode = FIELD_GET(AXIOM_U31_REV1_MODE_MASK, mode);
> +	if (mode == AXIOM_U31_REV1_MODE_BLP) {
> +		dev_err(dev, "Device still in BLP mode, abort\n");
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static void axiom_lock_input_device(struct axiom_data *ts)
> +{
> +	if (!ts->input)
> +		return;
> +
> +	mutex_lock(&ts->input->mutex);
> +}
> +
> +static void axiom_unlock_input_device(struct axiom_data *ts)
> +{
> +	if (!ts->input)
> +		return;
> +
> +	mutex_unlock(&ts->input->mutex);
> +}
> +
> +static void axiom_unregister_input_dev(struct axiom_data *ts)
> +{
> +	if (ts->input)
> +		input_unregister_device(ts->input);
> +
> +	ts->input = NULL;
> +}
> +
> +static enum fw_upload_err
> +axiom_axfw_fw_write(struct fw_upload *fw_upload, const u8 *data, u32 offset,
> +		    u32 size, u32 *written)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
> +	struct device *dev = ts->dev;
> +	bool cancel;
> +	int ret;
> +
> +	/* Done before cancel check due to cleanup based put */
> +	ret = pm_runtime_resume_and_get(ts->dev);
> +	if (ret)
> +		return FW_UPLOAD_ERR_HW_ERROR;
> +
> +	mutex_lock(&afw->lock);
> +	cancel = afw->cancel;
> +	mutex_unlock(&afw->lock);
> +
> +	if (cancel)
> +		return FW_UPLOAD_ERR_CANCELED;
> +
> +	axiom_lock_input_device(ts);
> +
> +	if (ts->input && input_device_enabled(ts->input)) {
> +		dev_err(dev, "Input device not idle, abort AXFW/ALC update\n");
> +		goto err;
> +	}
> +
> +	if (!strncmp(data, AXIOM_FW_AXFW_SIGNATURE,
> +		     strlen(AXIOM_FW_AXFW_SIGNATURE))) {
> +		/* Set the pointer to the first fw chunk */
> +		data += sizeof(struct axiom_fw_axfw_hdr);
> +		size -= sizeof(struct axiom_fw_axfw_hdr);
> +		*written += sizeof(struct axiom_fw_axfw_hdr);
> +	}
> +
> +	if (axiom_enter_bootloader_mode(ts))
> +		goto err;
> +
> +	while (size) {
> +		u16 chunk_len, len;
> +
> +		chunk_len = get_unaligned_be16(&data[6]);
> +		len = chunk_len + sizeof(struct axiom_fw_axfw_chunk_hdr);
> +
> +		/*
> +		 * The bootlaoder FW can handle the complete chunk incl. the
> +		 * header.
> +		 */
> +		ret = axiom_blp_write_chunk(ts, data, len);
> +		if (ret)
> +			goto err;
> +
> +		size -= len;
> +		*written += len;
> +		data += len;
> +	}
> +
> +	ret = axiom_blp_reset(ts);
> +	if (ret)
> +		dev_warn(dev, "BLP reset failed\n");
> +
> +	ret = axiom_u31_device_discover(ts);
> +	if (ret) {
> +		/*
> +		 * This is critical and we need to avoid that the user-space can
> +		 * still use the input-dev.
> +		 */
> +		axiom_unlock_input_device(ts);
> +		axiom_unregister_input_dev(ts);
> +		dev_err(dev, "Device discovery failed after AXFW/ALC firmware update\n");
> +		goto err;
> +	}
> +
> +	/* Unlock before the input device gets unregistered */
> +	axiom_unlock_input_device(ts);
> +
> +	ret = axiom_update_input_dev(ts);
> +	if (ret) {
> +		dev_err(dev, "Input device update failed after AXFW/ALC firmware update\n");
> +		return FW_UPLOAD_ERR_HW_ERROR;
> +	}
> +
> +	dev_info(dev, "AXFW update successful\n");
> +
> +	return FW_UPLOAD_ERR_NONE;
> +
> +err:
> +	axiom_unlock_input_device(ts);
> +	return FW_UPLOAD_ERR_HW_ERROR;
> +}
> +
> +static enum fw_upload_err axiom_fw_poll_complete(struct fw_upload *fw_upload)
> +{
> +	return FW_UPLOAD_ERR_NONE;
> +}
> +
> +static void axiom_axfw_fw_cancel(struct fw_upload *fw_upload)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_AXFW];
> +
> +	mutex_lock(&afw->lock);
> +	afw->cancel = true;
> +	mutex_unlock(&afw->lock);
> +}
> +
> +static void axiom_axfw_fw_cleanup(struct fw_upload *fw_upload)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +
> +	mutex_unlock(&ts->fwupdate_lock);
> +	pm_runtime_mark_last_busy(ts->dev);
> +	pm_runtime_put_sync_autosuspend(ts->dev);
> +}
> +
> +static const struct fw_upload_ops axiom_axfw_fw_upload_ops = {
> +	.prepare = axiom_axfw_fw_prepare,
> +	.write = axiom_axfw_fw_write,
> +	.poll_complete = axiom_fw_poll_complete,
> +	.cancel = axiom_axfw_fw_cancel,
> +	.cleanup = axiom_axfw_fw_cleanup,
> +};
> +
> +static int
> +axiom_set_new_crcs(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *cfg)
> +{
> +	struct axiom_crc *crc = &ts->crc[AXIOM_CRC_NEW];
> +	const u32 *u33_data = (const u32 *)cfg->usage_content;
> +
> +	if (cfg->usage_rev != 2) {
> +		dev_err(ts->dev, "The driver doesn't support u33 revision %u\n",
> +			cfg->usage_rev);
> +		return -EINVAL;
> +	}
> +
> +	crc->runtime = get_unaligned_le32(u33_data);
> +	crc->nvltlusageconfig = get_unaligned_le32(&u33_data[3]);
> +	crc->vltusageconfig = get_unaligned_le32(&u33_data[4]);
> +	crc->u22_sequencedata = get_unaligned_le32(&u33_data[5]);
> +	crc->u43_hotspots = get_unaligned_le32(&u33_data[6]);
> +	crc->u93_profiles = get_unaligned_le32(&u33_data[7]);
> +	crc->u94_deltascalemap = get_unaligned_le32(&u33_data[8]);
> +
> +	return 0;
> +}
> +
> +static unsigned int
> +axiom_cfg_fw_prepare_chunk(struct axiom_fw_cfg_chunk *chunk, const u8 *data)
> +{
> +	chunk->usage_num = data[0];
> +	chunk->usage_rev = data[1];
> +	chunk->usage_length = get_unaligned_le16(&data[3]);
> +	chunk->usage_content = &data[5];
> +
> +	return chunk->usage_length + sizeof(struct axiom_fw_cfg_chunk_hdr);
> +}
> +
> +static bool axiom_cfg_fw_update_required(struct axiom_data *ts)
> +{
> +	struct axiom_crc *cur, *new;
> +
> +	cur = &ts->crc[AXIOM_CRC_CUR];
> +	new = &ts->crc[AXIOM_CRC_NEW];
> +
> +	if (cur->nvltlusageconfig != new->nvltlusageconfig ||
> +	    cur->u22_sequencedata != new->u22_sequencedata ||
> +	    cur->u43_hotspots != new->u43_hotspots ||
> +	    cur->u93_profiles != new->u93_profiles ||
> +	    cur->u94_deltascalemap != new->u94_deltascalemap)
> +		return true;
> +
> +	return false;
> +}
> +
> +static enum fw_upload_err
> +axiom_cfg_fw_prepare(struct fw_upload *fw_upload, const u8 *data, u32 size)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
> +	u32 cur_runtime_crc, fw_runtime_crc;
> +	struct axiom_fw_cfg_chunk chunk;
> +	struct device *dev = ts->dev;
> +	enum fw_upload_err ret;
> +	u32 signature;
> +
> +	mutex_lock(&afw->lock);
> +	afw->cancel = false;
> +	mutex_unlock(&afw->lock);
> +
> +	mutex_lock(&ts->fwupdate_lock);
> +
> +	if (axiom_get_runmode(ts) != AXIOM_TCP_MODE) {
> +		dev_err(dev, "Device not in TCP mode, abort TH2CFG update\n");
> +		ret = FW_UPLOAD_ERR_HW_ERROR;
> +		goto out;
> +	}
> +
> +	if (size < sizeof(struct axiom_fw_cfg_hdr)) {
> +		dev_err(dev, "Invalid TH2CFG file size\n");
> +		ret = FW_UPLOAD_ERR_INVALID_SIZE;
> +		goto out;
> +	}
> +
> +	signature = get_unaligned_be32(data);
> +	if (signature != AXIOM_FW_CFG_SIGNATURE) {
> +		dev_err(dev, "Invalid TH2CFG signature\n");
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	/* Skip to the first fw chunk */
> +	data += sizeof(struct axiom_fw_cfg_hdr);
> +	size -= sizeof(struct axiom_fw_cfg_hdr);
> +
> +	/*
> +	 * Search for u33 which contains the CRC information and perform only
> +	 * the runtime-crc check.
> +	 */
> +	while (size) {
> +		unsigned int chunk_len;
> +
> +		chunk_len = axiom_cfg_fw_prepare_chunk(&chunk, data);
> +		if (chunk.usage_num == AXIOM_U33)
> +			break;
> +
> +		data += chunk_len;
> +		size -= chunk_len;
> +	}
> +
> +	if (size == 0) {
> +		dev_err(dev, "Failed to find the u33 entry in TH2CFG\n");
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	ret = axiom_set_new_crcs(ts, &chunk);
> +	if (ret) {
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	/*
> +	 * Nothing to do if the CRCs are the same. TODO: Must be extended once
> +	 * the CDU update is added.
> +	 */
> +	if (!axiom_cfg_fw_update_required(ts)) {
> +		ret = FW_UPLOAD_ERR_SKIP;
> +		goto out;
> +	}
> +
> +	cur_runtime_crc = ts->crc[AXIOM_CRC_CUR].runtime;
> +	fw_runtime_crc = ts->crc[AXIOM_CRC_NEW].runtime;
> +	if (cur_runtime_crc != fw_runtime_crc) {
> +		dev_err(dev, "TH2CFG and device runtime CRC doesn't match: %#x != %#x\n",
> +			fw_runtime_crc, cur_runtime_crc);
> +		ret = FW_UPLOAD_ERR_FW_INVALID;
> +		goto out;
> +	}
> +
> +	mutex_lock(&afw->lock);
> +	ret = afw->cancel ? FW_UPLOAD_ERR_CANCELED : FW_UPLOAD_ERR_NONE;
> +	mutex_unlock(&afw->lock);
> +
> +out:
> +	/*
> +	 * In FW_UPLOAD_ERR_NONE case the complete handler will release the
> +	 * lock.
> +	 */
> +	if (ret != FW_UPLOAD_ERR_NONE)
> +		mutex_unlock(&ts->fwupdate_lock);
> +
> +	return ret;
> +}
> +
> +static int axiom_zero_volatile_mem(struct axiom_data *ts)
> +{
> +	int ret, size;
> +	u8 *buf;
> +
> +	/* Zero out the volatile memory except for the user content in u04 */
> +	ret = axiom_u04_get(ts, &buf);
> +	if (ret < 0)
> +		return ret;
> +	size = ret;
> +
> +	ret = axiom_u02_fillconfig(ts);
> +	if (ret)
> +		goto out;
> +
> +	ret = axiom_u04_set(ts, buf, size);
> +out:
> +	kfree(buf);
> +	return ret;
> +}
> +
> +static bool
> +axiom_skip_cfg_chunk(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
> +{
> +	u8 usage_num = chunk->usage_num;
> +
> +	if (!ts->usage_table[usage_num].populated) {
> +		dev_warn(ts->dev, "Unknown usage chunk for u%#x\n", usage_num);
> +		return true;
> +	}
> +
> +	/* Skip read-only usages */
> +	if (ts->usage_table[usage_num].info &&
> +	    ts->usage_table[usage_num].info->is_ro)
> +		return true;
> +
> +	return false;
> +}
> +
> +static int
> +axiom_write_cdu_usage(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
> +{
> +	struct axiom_cdu_usage cdu = { };
> +	struct device *dev = ts->dev;
> +	unsigned int remaining;
> +	unsigned int reg;
> +	unsigned int pos;
> +	int ret;
> +
> +	pos = 0;
> +	remaining = chunk->usage_length;
> +	cdu.command = cpu_to_le16(AXIOM_CDU_CMD_STORE);
> +	reg = axiom_usage_baseaddr(ts, chunk->usage_num);
> +
> +	while (remaining) {
> +		unsigned int size;
> +
> +		cdu.parameters[1] = cpu_to_le16(pos);
> +
> +		size = remaining;
> +		if (size > AXIOM_CDU_MAX_DATA_BYTES)
> +			size = AXIOM_CDU_MAX_DATA_BYTES;
> +
> +		memset(cdu.data, 0, sizeof(cdu.data));
> +		memcpy(cdu.data, &chunk->usage_content[pos], size);
> +
> +		ret = regmap_raw_write(ts->regmap, reg, &cdu, sizeof(cdu));
> +		if (ret) {
> +			dev_err(dev, "Failed to write CDU u%x\n",
> +				chunk->usage_num);
> +			return ret;
> +		}
> +
> +		ret = axiom_cdu_wait_idle(ts, chunk->usage_num);
> +		if (ret) {
> +			dev_err(dev, "CDU write wait-idle failed\n");
> +			return ret;
> +		}
> +
> +		remaining -= size;
> +		pos += size;
> +	}
> +
> +	/*
> +	 * TODO: Check if we really need to send 48 zero bytes of data like
> +	 * downstream does.
> +	 */
> +	memset(&cdu, 0, sizeof(cdu));
> +	cdu.command = cpu_to_le16(AXIOM_CDU_CMD_COMMIT);
> +	cdu.parameters[0] = cpu_to_le16(AXIOM_CDU_PARAM0_COMMIT);
> +	cdu.parameters[1] = cpu_to_le16(AXIOM_CDU_PARAM1_COMMIT);
> +
> +	ret = regmap_raw_write(ts->regmap, reg, &cdu, sizeof(cdu));
> +	if (ret) {
> +		dev_err(dev, "Failed to commit CDU u%x to NVM\n",
> +			chunk->usage_num);
> +		return ret;
> +	}
> +
> +	ret = axiom_wait_for_completion_timeout(ts, &ts->nvm_write,
> +					msecs_to_jiffies(5 * MSEC_PER_SEC));
> +	if (!ret) {
> +		dev_err(ts->dev, "Error CDU u%x commit timedout\n",
> +			chunk->usage_num);
> +		return -ETIMEDOUT;
> +	}
> +
> +	return axiom_cdu_wait_idle(ts, chunk->usage_num);
> +}
> +
> +static int
> +axiom_write_cfg_chunk(struct axiom_data *ts, const struct axiom_fw_cfg_chunk *chunk)
> +{
> +	unsigned int reg;
> +	int ret;
> +
> +	if (ts->usage_table[chunk->usage_num].info &&
> +	    ts->usage_table[chunk->usage_num].info->is_cdu) {
> +		ret = axiom_write_cdu_usage(ts, chunk);
> +		if (ret)
> +			return ret;
> +		goto out;
> +	}
> +
> +	reg = axiom_usage_baseaddr(ts, chunk->usage_num);
> +	ret = regmap_raw_write(ts->regmap, reg, chunk->usage_content, chunk->usage_length);
> +	if (ret)
> +		return ret;
> +
> +out:
> +	return axiom_u02_wait_idle(ts);
> +}
> +
> +static int axiom_verify_volatile_mem(struct axiom_data *ts)
> +{
> +	int ret;
> +
> +	ret = axiom_u02_computecrc(ts);
> +	if (ret)
> +		return ret;
> +
> +	/* Query the new CRCs after they are re-computed */
> +	ret = axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
> +	if (ret)
> +		return ret;
> +
> +	return ts->crc[AXIOM_CRC_CUR].vltusageconfig ==
> +	       ts->crc[AXIOM_CRC_NEW].vltusageconfig ? 0 : -EINVAL;
> +}
> +
> +static int axiom_verify_crcs(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	struct axiom_crc *cur, *new;
> +
> +	cur = &ts->crc[AXIOM_CRC_CUR];
> +	new = &ts->crc[AXIOM_CRC_NEW];
> +
> +	if (new->vltusageconfig != cur->vltusageconfig) {
> +		dev_err(dev, "VLTUSAGECONFIG CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->vltusageconfig, new->vltusageconfig);
> +		return -EINVAL;
> +	} else if (new->nvltlusageconfig != cur->nvltlusageconfig) {
> +		dev_err(dev, "NVLTUSAGECONFIG CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->nvltlusageconfig, new->nvltlusageconfig);
> +		return -EINVAL;
> +	} else if (new->u22_sequencedata != cur->u22_sequencedata) {
> +		dev_err(dev, "U22_SEQUENCEDATA CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->u22_sequencedata, new->u22_sequencedata);
> +		return -EINVAL;
> +	} else if (new->u43_hotspots != cur->u43_hotspots) {
> +		dev_err(dev, "U43_HOTSPOTS CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->u43_hotspots, new->u43_hotspots);
> +		return -EINVAL;
> +	} else if (new->u93_profiles != cur->u93_profiles) {
> +		dev_err(dev, "U93_PROFILES CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->u93_profiles, new->u93_profiles);
> +		return -EINVAL;
> +	} else if (new->u94_deltascalemap != cur->u94_deltascalemap) {
> +		dev_err(dev, "U94_DELTASCALEMAP CRC32 mismatch (dev:%#x != fw:%#x)\n",
> +			cur->u94_deltascalemap, new->u94_deltascalemap);
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static enum fw_upload_err
> +axiom_cfg_fw_write(struct fw_upload *fw_upload, const u8 *data, u32 offset,
> +		   u32 size, u32 *written)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
> +	struct device *dev = ts->dev;
> +	bool cancel;
> +	int ret;
> +
> +	/* Done before cancel check due to cleanup based put */
> +	ret = pm_runtime_resume_and_get(ts->dev);
> +	if (ret)
> +		return FW_UPLOAD_ERR_HW_ERROR;
> +
> +	mutex_lock(&afw->lock);
> +	cancel = afw->cancel;
> +	mutex_unlock(&afw->lock);
> +
> +	if (cancel)
> +		return FW_UPLOAD_ERR_CANCELED;
> +
> +	axiom_lock_input_device(ts);
> +
> +	if (ts->input && input_device_enabled(ts->input)) {
> +		dev_err(dev, "Input device not idle, abort TH2CFG update\n");
> +		axiom_unlock_input_device(ts);
> +		return FW_UPLOAD_ERR_HW_ERROR;
> +	}
> +
> +	ret = axiom_u02_stop(ts);
> +	if (ret)
> +		goto err_swreset;
> +
> +	ret = axiom_zero_volatile_mem(ts);
> +	if (ret)
> +		goto err_swreset;
> +
> +	/* Skip to the first fw chunk */
> +	data += sizeof(struct axiom_fw_cfg_hdr);
> +	size -= sizeof(struct axiom_fw_cfg_hdr);
> +	*written += sizeof(struct axiom_fw_cfg_hdr);
> +
> +	axiom_set_runmode(ts, AXIOM_TCP_CFG_UPDATE_MODE);
> +
> +	while (size) {
> +		struct axiom_fw_cfg_chunk chunk;
> +		unsigned int chunk_len;
> +
> +		chunk_len = axiom_cfg_fw_prepare_chunk(&chunk, data);
> +		if (axiom_skip_cfg_chunk(ts, &chunk)) {
> +			dev_dbg(dev, "Skip TH2CFG usage u%x\n", chunk.usage_num);
> +			goto next_chunk;
> +		}
> +
> +		ret = axiom_write_cfg_chunk(ts, &chunk);
> +		if (ret) {
> +			axiom_set_runmode(ts, AXIOM_TCP_MODE);
> +			goto err_swreset;
> +		}
> +
> +next_chunk:
> +		data += chunk_len;
> +		size -= chunk_len;
> +		*written += chunk_len;
> +	}
> +
> +	axiom_set_runmode(ts, AXIOM_TCP_MODE);
> +
> +	/* Ensure that the chunks are written correctly */
> +	ret = axiom_verify_volatile_mem(ts);
> +	if (ret) {
> +		dev_err(dev, "Failed to verify written config, abort\n");
> +		goto err_swreset;
> +	}
> +
> +	ret = axiom_u02_save_config(ts);
> +	if (ret)
> +		goto err_swreset;
> +
> +	/*
> +	 * TODO: Check if u02 start would be sufficient to load the new config
> +	 * values
> +	 */
> +	ret = axiom_u02_swreset(ts);
> +	if (ret) {
> +		dev_err(dev, "Soft reset failed\n");
> +		goto err_unlock;
> +	}
> +
> +	ret = axiom_u33_read(ts, &ts->crc[AXIOM_CRC_CUR]);
> +	if (ret)
> +		goto err_unlock;
> +
> +	if (axiom_verify_crcs(ts))
> +		goto err_unlock;
> +
> +	/* Unlock before the input device gets unregistered */
> +	axiom_unlock_input_device(ts);
> +
> +	ret = axiom_update_input_dev(ts);
> +	if (ret) {
> +		dev_err(dev, "Input device update failed after TH2CFG firmware update\n");
> +		goto err_out;
> +	}
> +
> +	dev_info(dev, "TH2CFG update successful\n");
> +
> +	return FW_UPLOAD_ERR_NONE;
> +
> +err_swreset:
> +	axiom_u02_swreset(ts);
> +err_unlock:
> +	axiom_unlock_input_device(ts);
> +err_out:
> +	return ret == -ETIMEDOUT ? FW_UPLOAD_ERR_TIMEOUT : FW_UPLOAD_ERR_HW_ERROR;
> +}
> +
> +static void axiom_cfg_fw_cancel(struct fw_upload *fw_upload)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +	struct axiom_firmware *afw = &ts->fw[AXIOM_FW_CFG];
> +
> +	mutex_lock(&afw->lock);
> +	afw->cancel = true;
> +	mutex_unlock(&afw->lock);
> +}
> +
> +static void axiom_cfg_fw_cleanup(struct fw_upload *fw_upload)
> +{
> +	struct axiom_data *ts = fw_upload->dd_handle;
> +
> +	mutex_unlock(&ts->fwupdate_lock);
> +	pm_runtime_mark_last_busy(ts->dev);
> +	pm_runtime_put_sync_autosuspend(ts->dev);
> +}
> +
> +static const struct fw_upload_ops axiom_cfg_fw_upload_ops = {
> +	.prepare = axiom_cfg_fw_prepare,
> +	.write = axiom_cfg_fw_write,
> +	.poll_complete = axiom_fw_poll_complete,
> +	.cancel = axiom_cfg_fw_cancel,
> +	.cleanup = axiom_cfg_fw_cleanup,
> +};
> +
> +static void axiom_remove_axfw_fwl_action(void *data)
> +{
> +	struct axiom_data *ts = data;
> +
> +	firmware_upload_unregister(ts->fw[AXIOM_FW_AXFW].fwl);
> +}
> +
> +static void axiom_remove_cfg_fwl_action(void *data)
> +{
> +	struct axiom_data *ts = data;
> +
> +	firmware_upload_unregister(ts->fw[AXIOM_FW_CFG].fwl);
> +}
> +
> +static int axiom_register_fwl(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	struct fw_upload *fwl;
> +	char *fw_name;
> +	int ret;
> +
> +	if (!IS_ENABLED(CONFIG_FW_UPLOAD)) {
> +		dev_dbg(dev, "axfw and th2cfgbin update disabled\n");
> +		return 0;
> +	}
> +
> +	mutex_init(&ts->fw[AXIOM_FW_AXFW].lock);
> +	fw_name = kasprintf(GFP_KERNEL, "i2c:%s.axfw", dev_name(dev));
> +	fwl = firmware_upload_register(THIS_MODULE, ts->dev, fw_name,
> +				       &axiom_axfw_fw_upload_ops, ts);
> +	kfree(fw_name);
> +	if (IS_ERR(fwl))
> +		return dev_err_probe(dev, PTR_ERR(fwl),
> +				     "Failed to register firmware upload\n");
> +
> +	ret = devm_add_action_or_reset(dev, axiom_remove_axfw_fwl_action, ts);
> +	if (ret)
> +		return ret;
> +
> +	ts->fw[AXIOM_FW_AXFW].fwl = fwl;
> +
> +	mutex_init(&ts->fw[AXIOM_FW_CFG].lock);
> +	fw_name = kasprintf(GFP_KERNEL, "i2c:%s.th2cfgbin", dev_name(dev));
> +	fwl = firmware_upload_register(THIS_MODULE, ts->dev, fw_name,
> +				       &axiom_cfg_fw_upload_ops, ts);
> +	kfree(fw_name);
> +	if (IS_ERR(fwl))
> +		return dev_err_probe(dev, PTR_ERR(fwl),
> +				     "Failed to register cfg firmware upload\n");
> +
> +	ret = devm_add_action_or_reset(dev, axiom_remove_cfg_fwl_action, ts);
> +	if (ret)
> +		return ret;
> +
> +	ts->fw[AXIOM_FW_CFG].fwl = fwl;
> +
> +	return 0;
> +}
> +
> +/************************* Device handlig *************************************/
> +
> +#define AXIOM_SIMPLE_FW_DEVICE_ATTR(attr)					\
> +	static ssize_t								\
> +	fw_ ## attr ## _show(struct device *dev,				\
> +			     struct device_attribute *_attr, char *buf)		\
> +	{									\
> +		struct i2c_client *i2c = to_i2c_client(dev);			\
> +		struct axiom_data *ts = i2c_get_clientdata(i2c);		\
> +										\
> +		return sprintf(buf, "%u\n", ts->fw_##attr);			\
> +	}									\
> +	static DEVICE_ATTR_RO(fw_##attr)
> +
> +AXIOM_SIMPLE_FW_DEVICE_ATTR(major);
> +AXIOM_SIMPLE_FW_DEVICE_ATTR(minor);
> +AXIOM_SIMPLE_FW_DEVICE_ATTR(rc);
> +
> +static ssize_t fw_status_show(struct device *dev,
> +			      struct device_attribute *attr, char *buf)
> +{
> +	struct i2c_client *i2c = to_i2c_client(dev);
> +	struct axiom_data *ts = i2c_get_clientdata(i2c);
> +	const char *val;
> +
> +	if (ts->fw_status)
> +		val = "production";
> +	else
> +		val = "engineering";
> +
> +	return sprintf(buf, "%s\n", val);
> +}
> +static DEVICE_ATTR_RO(fw_status);
> +
> +static ssize_t device_id_show(struct device *dev,
> +			      struct device_attribute *attr, char *buf)
> +{
> +	struct i2c_client *i2c = to_i2c_client(dev);
> +	struct axiom_data *ts = i2c_get_clientdata(i2c);
> +
> +	return sprintf(buf, "%u\n", ts->device_id);
> +}
> +static DEVICE_ATTR_RO(device_id);
> +
> +static ssize_t device_state_show(struct device *dev,
> +				 struct device_attribute *attr, char *buf)
> +{
> +	struct i2c_client *i2c = to_i2c_client(dev);
> +	struct axiom_data *ts = i2c_get_clientdata(i2c);
> +
> +	return sprintf(buf, "%s\n", axiom_runmode_to_string(ts));
> +}
> +static DEVICE_ATTR_RO(device_state);
> +
> +static struct attribute *axiom_attrs[] = {
> +	&dev_attr_fw_major.attr,
> +	&dev_attr_fw_minor.attr,
> +	&dev_attr_fw_rc.attr,
> +	&dev_attr_fw_status.attr,
> +	&dev_attr_device_id.attr,
> +	&dev_attr_device_state.attr,
> +	NULL
> +};
> +ATTRIBUTE_GROUPS(axiom);
> +
> +static void axiom_poll(struct input_dev *input)
> +{
> +	struct axiom_data *ts = input_get_drvdata(input);
> +
> +	axiom_process_report(ts, AXIOM_U34, NULL, 0);
> +}
> +
> +static irqreturn_t axiom_irq(int irq, void *dev_id)
> +{
> +	struct axiom_data *ts = dev_id;
> +
> +	axiom_process_report(ts, AXIOM_U34, NULL, 0);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int axiom_input_open(struct input_dev *dev)
> +{
> +	struct axiom_data *ts = input_get_drvdata(dev);
> +
> +	return pm_runtime_resume_and_get(ts->dev);
> +}
> +
> +static void axiom_input_close(struct input_dev *dev)
> +{
> +	struct axiom_data *ts = input_get_drvdata(dev);
> +
> +	pm_runtime_mark_last_busy(ts->dev);
> +	pm_runtime_put_sync_autosuspend(ts->dev);
> +}
> +
> +static int axiom_register_input_dev(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	struct i2c_client *client = to_i2c_client(dev);
> +	struct input_dev *input;
> +	int ret;
> +
> +	input = input_allocate_device();
> +	if (!input) {
> +		dev_err(dev, "Failed to allocate input driver data\n");
> +		return -ENOMEM;
> +	}
> +
> +	input->dev.parent = dev;
> +	input->name = "TouchNetix aXiom Touchscreen";
> +	input->id.bustype = BUS_I2C;
> +	input->id.vendor = ts->jedec_id;
> +	input->id.product = ts->device_id;
> +	input->id.version = ts->silicon_rev;
> +	input->open = axiom_input_open;
> +	input->close = axiom_input_close;
> +
> +	axiom_u64_cds_enabled(ts);
> +	input_set_abs_params(input, ABS_MT_POSITION_X, 0, AXIOM_MAX_XY - 1, 0, 0);
> +	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, AXIOM_MAX_XY - 1, 0, 0);
> +	input_set_abs_params(input, ABS_MT_DISTANCE, 0, 127, 0, 0);
> +	if (ts->cds_enabled)
> +		input_set_abs_params(input, ABS_MT_PRESSURE, 0, 127, 0, 0);
> +
> +	touchscreen_parse_properties(input, true, &ts->prop);
> +
> +	axiom_u42_get_touchslots(ts);
> +	ret = input_mt_init_slots(input, ts->num_slots, INPUT_MT_DIRECT);
> +	if (ret) {
> +		input_free_device(input);
> +		dev_err(dev, "Failed to init mt slots\n");
> +		return ret;
> +	}
> +
> +	/*
> +	 * Ensure that the IRQ setup is done only once since the handler belong
> +	 * to the i2c-dev whereas the input-poller belong to the input-dev. The
> +	 * input-dev can get unregistered during a firmware update to reflect
> +	 * the new firmware state. Therefore the input-poller setup must be done
> +	 * always.
> +	 */
> +	if (!ts->irq_setup_done && client->irq) {
> +		ret = devm_request_threaded_irq(dev, client->irq, NULL, axiom_irq,
> +						IRQF_ONESHOT, dev_name(dev), ts);
> +		if (ret) {
> +			dev_err(dev, "Failed to request IRQ\n");
> +			return ret;
> +		}
> +		ts->irq_setup_done = true;
> +	} else {
> +		ret = input_setup_polling(input, axiom_poll);
> +		if (ret) {
> +			input_free_device(input);
> +			dev_err(dev, "Setup polling mode failed\n");
> +			return ret;
> +		}
> +
> +		input_set_poll_interval(input, ts->poll_interval);
> +	}
> +
> +	input_set_drvdata(input, ts);
> +	ts->input = input;
> +
> +	ret = input_register_device(input);
> +	if (ret) {
> +		input_free_device(input);
> +		ts->input = NULL;
> +		dev_err(dev, "Failed to register input device\n");
> +	};
> +
> +	return ret;
> +}
> +
> +static int axiom_update_input_dev(struct axiom_data *ts)
> +{
> +	axiom_unregister_input_dev(ts);
> +
> +	return axiom_register_input_dev(ts);
> +}
> +
> +static int axiom_parse_firmware(struct axiom_data *ts)
> +{
> +	struct device *dev = ts->dev;
> +	struct gpio_desc *gpio;
> +	int ret;
> +
> +	ts->supplies[0].supply = "vddi";
> +	ts->supplies[1].supply = "vdda";
> +	ts->num_supplies = ARRAY_SIZE(ts->supplies);
> +
> +	ret = devm_regulator_bulk_get(dev, ts->num_supplies, ts->supplies);
> +	if (ret)
> +		return dev_err_probe(dev, ret,
> +				     "Failed to get power supplies\n");
> +
> +	gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
> +	if (IS_ERR(gpio))
> +		return dev_err_probe(dev, PTR_ERR(gpio),
> +				     "Failed to get reset GPIO\n");
> +	ts->reset_gpio = gpio;
> +
> +	ts->poll_interval = AXIOM_DEFAULT_POLL_INTERVAL_MS;
> +	device_property_read_u32(dev, "poll-interval", &ts->poll_interval);
> +
> +	return 0;
> +}
> +
> +static int axiom_power_device(struct axiom_data *ts, unsigned int enable)
> +{
> +	struct device *dev = ts->dev;
> +	int ret;
> +
> +	if (!enable) {
> +		regulator_bulk_disable(ts->num_supplies, ts->supplies);
> +		return 0;
> +	}
> +
> +	ret = regulator_bulk_enable(ts->num_supplies, ts->supplies);
> +	if (ret) {
> +		dev_err(dev, "Failed to enable power supplies\n");
> +		return ret;
> +	}
> +
> +	gpiod_set_value_cansleep(ts->reset_gpio, 1);
> +	fsleep(2000);
> +	gpiod_set_value_cansleep(ts->reset_gpio, 0);
> +
> +	fsleep(AXIOM_STARTUP_TIME_MS);
> +
> +	return 0;
> +}
> +
> +static int axiom_i2c_probe(struct i2c_client *client)
> +{
> +	struct device *dev = &client->dev;
> +	struct axiom_data *ts;
> +	int ret;
> +
> +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> +	if (!ts)
> +		return dev_err_probe(dev, -ENOMEM,
> +				     "Failed to allocate driver data\n");
> +
> +	ts->regmap = devm_regmap_init_i2c(client, &axiom_i2c_regmap_config);
> +	if (IS_ERR(ts->regmap))
> +		return dev_err_probe(dev, PTR_ERR(ts->regmap),
> +				     "Failed to initialize regmap\n");
> +
> +	i2c_set_clientdata(client, ts);
> +	ts->dev = dev;
> +
> +	init_completion(&ts->boot_complete.completion);
> +	init_completion(&ts->nvm_write.completion);
> +	mutex_init(&ts->fwupdate_lock);
> +
> +	ret = axiom_register_fwl(ts);
> +	if (ret)
> +		return ret;
> +
> +	ret = axiom_parse_firmware(ts);
> +	if (ret)
> +		return ret;
> +
> +	ret = axiom_power_device(ts, 1);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to power-on device\n");
> +
> +	pm_runtime_set_autosuspend_delay(dev, 10 * MSEC_PER_SEC);
> +	pm_runtime_use_autosuspend(dev);
> +	pm_runtime_set_active(dev);
> +	pm_runtime_get_noresume(dev);
> +	ret = devm_pm_runtime_enable(dev);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to enable pm-runtime\n");
> +
> +	ret = axiom_u31_device_discover(ts);
> +	/*
> +	 * Register the device to allow FW updates in case that the current FW
> +	 * doesn't support the required driver usages or if the device is in
> +	 * bootloader mode.
> +	 */
> +	if (ret && ret == -EACCES && IS_ENABLED(CONFIG_FW_UPLOAD)) {
> +		dev_warn(dev, "Device discovery failed, wait for user fw update\n");
> +		pm_runtime_mark_last_busy(dev);
> +		pm_runtime_put_sync_autosuspend(dev);
> +		return 0;
> +	} else if (ret) {
> +		pm_runtime_put_sync(dev);
> +		return dev_err_probe(dev, ret, "Device discovery failed\n");
> +	}
> +
> +	ret = axiom_register_input_dev(ts);
> +	pm_runtime_mark_last_busy(dev);
> +	pm_runtime_put_sync_autosuspend(dev);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to finish setup\n");
> +
> +	return 0;
> +}
> +
> +static void axiom_i2c_remove(struct i2c_client *client)
> +{
> +	struct axiom_data *ts = i2c_get_clientdata(client);
> +
> +	axiom_unregister_input_dev(ts);
> +}
> +
> +static int axiom_runtime_suspend(struct device *dev)
> +{
> +	struct axiom_data *ts = dev_get_drvdata(dev);
> +	struct i2c_client *client = to_i2c_client(dev);
> +
> +	if (client->irq && ts->irq_setup_done)
> +		disable_irq(client->irq);
> +
> +	return axiom_power_device(ts, 0);
> +}
> +
> +static int axiom_runtime_resume(struct device *dev)
> +{
> +	struct axiom_data *ts = dev_get_drvdata(dev);
> +	struct i2c_client *client = to_i2c_client(dev);
> +	int ret;
> +
> +	ret = axiom_power_device(ts, 1);
> +	if (ret)
> +		return ret;
> +
> +	if (client->irq && ts->irq_setup_done)
> +		enable_irq(client->irq);
> +
> +	return 0;
> +}
> +
> +static DEFINE_RUNTIME_DEV_PM_OPS(axiom_pm_ops, axiom_runtime_suspend,
> +				 axiom_runtime_resume, NULL);
> +
> +static const struct i2c_device_id axiom_i2c_id_table[] = {
> +	{ "ax54a" },
> +	{ },
> +};
> +MODULE_DEVICE_TABLE(i2c, axiom_i2c_id_table);
> +
> +static const struct of_device_id axiom_of_match[] = {
> +	{ .compatible = "touchnetix,ax54a", },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, axiom_of_match);
> +
> +static struct i2c_driver axiom_i2c_driver = {
> +	.driver = {
> +		   .name = KBUILD_MODNAME,
> +		   .dev_groups = axiom_groups,
> +		   .pm = pm_ptr(&axiom_pm_ops),
> +		   .of_match_table = axiom_of_match,
> +	},
> +	.id_table = axiom_i2c_id_table,
> +	.probe = axiom_i2c_probe,
> +	.remove = axiom_i2c_remove,
> +};
> +module_i2c_driver(axiom_i2c_driver);
> +
> +MODULE_DESCRIPTION("TouchNetix aXiom touchscreen I2C bus driver");
> +MODULE_LICENSE("GPL");
> 
> -- 
> 2.39.5
> 
> 

Re: [PATCH 5/5] Input: Add TouchNetix aXiom I2C Touchscreen support

[Greg Kroah-Hartman]

On Mon, Dec 02, 2024 at 10:44:34AM +0100, Marco Felsch wrote:
> Hi,
> 
> gentle ping after the rc1 tag was released :)


Where is the Documentation/ABI/ entries for your custom sysfs files this
driver is creating?  That's required, right?

thanks,

greg k-h

Re: [PATCH 5/5] Input: Add TouchNetix aXiom I2C Touchscreen support

[Marco Felsch]

On 24-12-02, Greg Kroah-Hartman wrote:
> On Mon, Dec 02, 2024 at 10:44:34AM +0100, Marco Felsch wrote:
> > Hi,
> > 
> > gentle ping after the rc1 tag was released :)
> 
> 
> Where is the Documentation/ABI/ entries for your custom sysfs files this
> driver is creating?  That's required, right?

Good point! I forgot them :/ I will add them in my v2, thank you.

Now the last feedback I'm waiting for is the one for the actual
driver :)

Regards,
  Marco

> 
> thanks,
> 
> greg k-h
> 

Re: [PATCH 0/5] Input: Add support for TouchNetix aXiom touchscreen

[Kamel BOUHARA]

Le 2024-11-19 23:33, Marco Felsch a écrit :
> Hi,
> 

Hi Marco,

> This adds the initial support for the TouchNetix aXiom touchcontroller
> family.
> 
> This series is the successor of [1] (many thanks to Bootlin) but I
> started from a fresh v1 since I had to rework the driver completely.
> 

Thanks for taking over and I honestly think it's good idea to completely
start it from scratch, I should have done it as well.

Greetings,
--
Kamel Bouhara, Bootlin
Embedded Linux and kernel engineering
https://bootlin.com