firmware: Add support for Qualcomm UEFI Secure Application
Subsystems (3)
v6 cover firmware: Add support for Qualcomm UEFI Secure Application
This series adds basic support for the QSEECOM interface used to communicate with secure applications running in the TrustZone on certain Qualcomm devices. In addition to that, it also provides a driver for "uefisecapp", the secure application managing access to UEFI variables on such platforms.
For a more detailed description, see the blurb of v1.
Previous versions:
- V5: https://lore.kernel.org/lkml/[email protected]/t/
- V4: https://lore.kernel.org/lkml/[email protected]/t/
- V3: https://lore.kernel.org/lkml/[email protected]/t/
- V2: https://lore.kernel.org/lkml/[email protected]/
- V1: https://lore.kernel.org/lkml/[email protected]/
Changes in v5:
- Small code fixes (e.g., missing 'static inline', missing includes, removal of unnecessary functions, improvements and fixes for documentation and comments). No larger or structural changes.
Changes in v5:
- Re-introduce a dedicated platform device for managing QSEECOM client devices. The device is now added via qcom_scm.c instead of the device tree (as has been done in v3).
- Replace ucs2_strlcpy() with ucs2_strscpy()
- Drop "firmware: qcom_scm: Clear scm pointer on probe failure" and sort out probe-related issue.
- Clean up comments in qcom_qseecom_uefisecapp.c
Changes in v4:
- Integrate the QSEECOM interface into qcom_scm.c instead of instantiating a custom device and requiring device-tree bindings for it. With that, drop the respective patches exporting SCM call functions from qcom_scm.c and the DT bindings.
- Restructure management of DMA memory and move DMA mapping entirely into the app_send() command, removing the need for DMA handling in app client drivers.
- Add support for EFI's query_variable_info() call.
- Move UCS-2 string helpers to lib/ucs2_string.c (introduces patch 1).
- Add fix for related cleanup-issue in qcom_scm.c (introduces patch 2).
(Refer to individual patches for more details.)
Changes in v3:
- Fix doc comment in qcom_scm.c
- Rebase on top of latest changes to qcom_scm.
Changes in v2:
- Bind the qseecom interface to a device.
- Establish a device link between the new qseecom device and the SCM device to ensure proper PM and remove ordering.
- Remove the compatible for uefisecapp. Instead, introduce a compatible for the qseecom device. This directly reflects ACPI tables and the QCOM0476 device described therein, which is responsible for the secure app / qseecom interface (i.e., the same purpose).
Client devices representing apps handled by the kernel (such as uefisecapp) are now directly instantiated by the qseecom driver, based on the respective platform-specific compatible.
- Rename the base name (qctree -> qseecom) to allow differentiation between old (qseecom) and new (smcinvoke) interfaces to the trusted execution environment. This directly reflects downstream naming by Qualcomm.
Maximilian Luz (3):
lib/ucs2_string: Add UCS-2 strscpy function
firmware: qcom_scm: Add support for Qualcomm Secure Execution
Environment SCM interface
firmware: Add support for Qualcomm UEFI Secure Application
MAINTAINERS | 12 + drivers/firmware/Kconfig | 32 + drivers/firmware/Makefile | 2 + drivers/firmware/qcom_qseecom.c | 120 +++ drivers/firmware/qcom_qseecom_uefisecapp.c | 871 +++++++++++++++++++++ drivers/firmware/qcom_scm.c | 394 ++++++++++ include/linux/firmware/qcom/qcom_qseecom.h | 46 ++ include/linux/firmware/qcom/qcom_scm.h | 22 + include/linux/ucs2_string.h | 1 + lib/ucs2_string.c | 52 ++ 10 files changed, 1552 insertions(+) create mode 100644 drivers/firmware/qcom_qseecom.c create mode 100644 drivers/firmware/qcom_qseecom_uefisecapp.c create mode 100644 include/linux/firmware/qcom/qcom_qseecom.h
Signature · 1 line
2.42.0
PATCH v6 1/3 lib/ucs2_string: Add UCS-2 strscpy function
Add a ucs2_strscpy() function for UCS-2 strings. The behavior is equivalent to the standard strscpy() function, just for 16-bit character UCS-2 strings.
---
Changes in v6:
- Add function documentation
- Clarify that we're copying/working in terms of characters, not bytes
- Change size warning to be INT_MAX bytes, not INT_MAX characters
Changes in v5:
- Add ucs2_strscpy() instead of ucs2_strlcpy()
Patch introduced in v4.
--- include/linux/ucs2_string.h | 1 + lib/ucs2_string.c | 52 +++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+)
include/linux/ucs2_string.h +1 -0
@@ -10,6 +10,7 @@ typedef u16 ucs2_char_t;unsigned long ucs2_strnlen (const ucs2_char_t *s,size_t maxlength);unsigned long ucs2_strlen (const ucs2_char_t *s);unsigned long ucs2_strsize (const ucs2_char_t *data,unsigned long maxlength); +ssize_t ucs2_strscpy (ucs2_char_t *dst,const ucs2_char_t *src,size_t count);int ucs2_strncmp (const ucs2_char_t *a,const ucs2_char_t *b,size_t len);unsigned long ucs2_utf8size (const ucs2_char_t *src);
lib/ucs2_string.c +52 -0
58 lines not on this page · raw message
Signature · 1 line
2.42.0
PATCH v6 2/3 firmware: qcom_scm: Add support for Qualcomm Secure Execution Environment SCM interface
In reply to Maximilian LuzAdd support for SCM calls to Secure OS and the Secure Execution Environment (SEE) residing in the TrustZone (TZ) via the QSEECOM interface. This allows communication with Secure/TZ applications, for example 'uefisecapp' managing access to UEFI variables.
For better separation, make qcom_scm spin up a dedicated child (platform) device in case QSEECOM support has been detected. The corresponding driver for this device is then responsible for managing any QSEECOM clients. Specifically, this driver attempts to automatically detect known and supported applications, creating a client (auxiliary) device for each one. The respective client/auxiliary driver is then responsible for managing and communicating with the application.
While this patch introduces only a very basic interface without the more advanced features (such as re-entrant and blocking SCM calls and listeners/callbacks), this is enough to talk to the aforementioned 'uefisecapp'.
---
Changes in v6:
- Add missing slab.h and module.h includes
- Remove unneeded driver and module remove functions
- Fix header function definitions by adding missing 'static inline'
- Change 'depends on QCOM_SCM' to 'depends on QCOM_SCM=y'. It normally should be built in on any Qualcomm platform, but it technically could be =m (e.g. in random config testing), which would cause problems.
- Small formatting changes
Changes in v5:
- Add a dedicated platform device and corresponding for managing the QSEECOM clients. Unlike before, this device is now instantiated by qcom_scm.c if it detects QSEECOM support.
Changes in v4:
- Remove instantiation of dedicated QSEECOM device and load the driver via qcom_scm instead. In particular:
- Add a list of tested devices to ensure that we don't run into any issues with the currently unimplemented re-entrant calls.
- Use the QSEECOM version to check for general availability of the interface.
- Attempt to automatically detect available QSEECOM applications (and instantiate respective clients) based on a fixed list.
- Use auxiliary bus and devices for clients instead of MFD.
- Restructure DMA allocations: Use dma_map_single() directly inside qcom_scm_qseecom_app_send() instead of requiring clients to allocate DMA memory themselves.
Changes in v3:
- Rebase ontop of latest qcom_scm changes (qcom_scm.h moved).
- Move qcom_qseecom.h in accordance with qcom_scm.
Changes in v2:
- Bind the interface to a device.
- Establish a device link to the SCM device to ensure proper ordering.
- Register client apps as child devices instead of requiring them to be specified in the device tree.
- Rename (qctree -> qseecom) to allow differentiation between old (qseecom) and new (smcinvoke) interfaces to the trusted execution environment.
--- MAINTAINERS | 6 + drivers/firmware/Kconfig | 16 + drivers/firmware/Makefile | 1 + drivers/firmware/qcom_qseecom.c | 118 ++++++ drivers/firmware/qcom_scm.c | 394 +++++++++++++++++++++ include/linux/firmware/qcom/qcom_qseecom.h | 46 +++ include/linux/firmware/qcom/qcom_scm.h | 22 ++ 7 files changed, 603 insertions(+) create mode 100644 drivers/firmware/qcom_qseecom.c create mode 100644 include/linux/firmware/qcom/qcom_qseecom.h
MAINTAINERS +6 -0
@@ -17645,6 +17645,12 @@ S: Maintained F: Documentation/devicetree/bindings/mtd/qcom,nandc.yaml F: drivers/mtd/nand/raw/qcom_nandc.c +QUALCOMM QSEECOM DRIVER +M: Maximilian Luz <[email protected]> +L: [email protected] +S: Maintained +F: drivers/firmware/qcom_qseecom.c + QUALCOMM RMNET DRIVER M: Subash Abhinov Kasiviswanathan <[email protected]> M: Sean Tranchetti <[email protected]>
drivers/firmware/Kconfig +16 -0
@@ -226,6 +226,22 @@ config QCOM_SCM_DOWNLOAD_MODE_DEFAULT Say Y here to enable "download mode" by default. +config QCOM_QSEECOM + bool "Qualcomm QSEECOM interface driver" + depends on QCOM_SCM=y + help + Various Qualcomm SoCs have a Secure Execution Environment (SEE) running + in the Trust Zone. This module provides an interface to that via the + QSEECOM mechanism, using SCM calls. + + The QSEECOM interface allows, among other things, access to applications + running in the SEE. An example of such an application is 'uefisecapp', + which is required to access UEFI variables on certain systems. If + selected, the interface will also attempt to detect and register client + devices for supported applications. + + Select Y here to enable the QSEECOM interface driver. + config SYSFB bool select BOOT_VESA_SUPPORT
drivers/firmware/Makefile +1 -0
@@ -20,6 +20,7 @@ obj-$(CONFIG_RASPBERRYPI_FIRMWARE) += raspberrypi.o obj-$(CONFIG_FW_CFG_SYSFS) += qemu_fw_cfg.o obj-$(CONFIG_QCOM_SCM) += qcom-scm.o qcom-scm-objs += qcom_scm.o qcom_scm-smc.o qcom_scm-legacy.o +obj-$(CONFIG_QCOM_QSEECOM) += qcom_qseecom.o obj-$(CONFIG_SYSFB) += sysfb.o obj-$(CONFIG_SYSFB_SIMPLEFB) += sysfb_simplefb.o obj-$(CONFIG_TI_SCI_PROTOCOL) += ti_sci.o
drivers/firmware/qcom_qseecom.c new file +118 -0
118 lines not on this page · raw message
drivers/firmware/qcom_scm.c +394 -0
412 lines not on this page · raw message
include/linux/firmware/qcom/qcom_qseecom.h new file +46 -0
46 lines not on this page · raw message
include/linux/firmware/qcom/qcom_scm.h +22 -0
@@ -122,4 +122,26 @@ extern int qcom_scm_lmh_dcvsh(u32 payload_fn, u32 payload_reg, u32 payload_val,extern int qcom_scm_lmh_profile_change (u32 profile_id);extern bool qcom_scm_lmh_dcvsh_available (void ); +#ifdef CONFIG_QCOM_QSEECOM + +int qcom_scm_qseecom_app_get_id (const char *app_name,u32 *app_id); +int qcom_scm_qseecom_app_send (u32 app_id,void *req,size_t req_size,void *rsp, +size_t rsp_size); + +#else /* CONFIG_QCOM_QSEECOM */ + +static inline int qcom_scm_qseecom_app_get_id (const char *app_name,u32 *app_id) +{ +return -EINVAL ; +} + +static inline int qcom_scm_qseecom_app_send (u32 app_id,void *req, +size_t req_size,void *rsp, +size_t rsp_size) +{ +return -EINVAL ; +} + +#endif /* CONFIG_QCOM_QSEECOM */ +#endif
Signature · 1 line
2.42.0
PATCH v6 3/3 firmware: Add support for Qualcomm UEFI Secure Application
In reply to Maximilian LuzOn platforms using the Qualcomm UEFI Secure Application (uefisecapp), EFI variables cannot be accessed via the standard interface in EFI runtime mode. The respective functions return EFI_UNSUPPORTED. On these platforms, we instead need to talk to uefisecapp. This commit provides support for this and registers the respective efivars operations to access EFI variables from the kernel.
Communication with uefisecapp follows the Qualcomm QSEECOM / Secure OS conventions via the respective SCM call interface. This is also the reason why variable access works normally while boot services are active. During this time, said SCM interface is managed by the boot services. When calling ExitBootServices(), the ownership is transferred to the kernel. Therefore, UEFI must not use that interface itself (as multiple parties accessing this interface at the same time may lead to complications) and cannot access variables for us.
---
Changes in v6:
- Remove unnecessary 'depends on QCOM_SCM' in KConfig
- Add missing documentation for guid_offset parameter in struct qsee_rsp_uefi_get_next_variable.
Changes in v5:
- Clean up some comments inside functions and remove simple ones.
Changes in v4:
- Adapt to changes in DMA allocation in patch 3.
- Rework alignment: Use native alignment of types instead of a general 8 byte alignment. While the windows driver uses 8 byte alignment for GUIDs, the native (4 byte) alignment seems to work fine here.
- Add a helper macro for determining size and layout of request and response buffers, taking care of proper alignment.
- Implement support for EFI's query_variable_info() call, which is now supported by the kernel (and expected by efivarfs).
- Move UCS-2 string helpers to lib/ucs2_string.c
Changes in v3:
- No functional changes.
Changes in v2:
- Rename (qctree -> qseecom) to allow differentiation between old (qseecom) and new (smcinvoke) interfaces to the trusted execution environment.
--- MAINTAINERS | 6 + drivers/firmware/Kconfig | 16 + drivers/firmware/Makefile | 1 + drivers/firmware/qcom_qseecom.c | 4 +- drivers/firmware/qcom_qseecom_uefisecapp.c | 871 +++++++++++++++++++++ 5 files changed, 897 insertions(+), 1 deletion(-) create mode 100644 drivers/firmware/qcom_qseecom_uefisecapp.c
MAINTAINERS +6 -0
@@ -17651,6 +17651,12 @@ L: [email protected] S: Maintained F: drivers/firmware/qcom_qseecom.c +QUALCOMM QSEECOM UEFISECAPP DRIVER +M: Maximilian Luz <[email protected]> +L: [email protected] +S: Maintained +F: drivers/firmware/qcom_qseecom_uefisecapp.c + QUALCOMM RMNET DRIVER M: Subash Abhinov Kasiviswanathan <[email protected]> M: Sean Tranchetti <[email protected]>
drivers/firmware/Kconfig +16 -0
@@ -242,6 +242,22 @@ config QCOM_QSEECOM Select Y here to enable the QSEECOM interface driver. +config QCOM_QSEECOM_UEFISECAPP + bool "Qualcomm SEE UEFI Secure App client driver" + depends on QCOM_QSEECOM + depends on EFI + help + Various Qualcomm SoCs do not allow direct access to EFI variables. + Instead, these need to be accessed via the UEFI Secure Application + (uefisecapp), residing in the Secure Execution Environment (SEE). + + This module provides a client driver for uefisecapp, installing efivar + operations to allow the kernel accessing EFI variables, and via that also + provide user-space with access to EFI variables via efivarfs. + + Select Y here to provide access to EFI variables on the aforementioned + platforms. + config SYSFB bool select BOOT_VESA_SUPPORT
drivers/firmware/Makefile +1 -0
@@ -21,6 +21,7 @@ obj-$(CONFIG_FW_CFG_SYSFS) += qemu_fw_cfg.o obj-$(CONFIG_QCOM_SCM) += qcom-scm.o qcom-scm-objs += qcom_scm.o qcom_scm-smc.o qcom_scm-legacy.o obj-$(CONFIG_QCOM_QSEECOM) += qcom_qseecom.o +obj-$(CONFIG_QCOM_QSEECOM_UEFISECAPP) += qcom_qseecom_uefisecapp.o obj-$(CONFIG_SYSFB) += sysfb.o obj-$(CONFIG_SYSFB_SIMPLEFB) += sysfb_simplefb.o obj-$(CONFIG_TI_SCI_PROTOCOL) += ti_sci.o
drivers/firmware/qcom_qseecom.c +3 -1
@@ -83,7 +83,9 @@ static int qseecom_client_register(struct platform_device *qseecom_dev,* assuming the app has already been loaded (usually by firmware bootloaders) * and its ID can be queried successfully. */ -static const struct qseecom_app_desc qcom_qseecom_apps[] = {}; +static const struct qseecom_app_desc qcom_qseecom_apps[] = { + {"qcom.tz.uefisecapp" ,"uefisecapp" }, +};static int qcom_qseecom_probe (struct platform_device *qseecom_dev) {
drivers/firmware/qcom_qseecom_uefisecapp.c new file +871 -0
871 lines not on this page · raw message
Signature · 1 line
2.42.0
drivers/firmware/Kconfig config QCOM_QSEECOM · line 246
Quoted 3 lines · Maximilian Luz
drivers/firmware/Kconfig +2
-0+config QCOM_QSEECOM_UEFISECAPP + bool "Qualcomm SEE UEFI Secure App client driver"
Why not "tristate"? This driver can be a loadable module, right?
Quoted 3 lines
drivers/firmware/Kconfig +3
-0+ depends on QCOM_QSEECOM + depends on EFI + help
Signature · 1 line
---Trilok Soni
Quoted 6 lines · Trilok Soni
drivers/firmware/Kconfig config QCOM_QSEECOM · line 246
Quoted 3 lines · Maximilian Luz
drivers/firmware/Kconfig +2
-0+config QCOM_QSEECOM_UEFISECAPP + bool "Qualcomm SEE UEFI Secure App client driver"Why not "tristate"? This driver can be a loadable module, right?
As I understand, modular efivars have still not been fully sorted out in the kernel. For example, userspace could try and mount efivarfs before the module has been loaded and by that erroneously determine that the system doesn't support efivars. So requiring it to be built in for now is more of a workaround (which has been suggested by Johan Hovold).
There is no technical limitation in this part of the code itself, so enabling it (and QCOM_QSEECOM for that matter) to be built as module should be fairly straightforward once that's been sorted out.
Quoted 5 lines
Quoted 3 lines
drivers/firmware/Kconfig +3
-0+ depends on QCOM_QSEECOM + depends on EFI + help
Quoted 13 lines · Maximilian Luz
Quoted 5 lines · Trilok Soni
Quoted 2 lines · Maximilian Luz
+config
QCOM_QSEECOM_UEFISECAPP
+ bool "Qualcomm SEE UEFI Secure App client driver"Why not "tristate"? This driver can be a loadable module, right?
As I understand, modular efivars have still not been fully sorted out in the kernel. For example, userspace could try and mount efivarfs before the module has been loaded and by that erroneously determine that the system doesn't support efivars. So requiring it to be built in for now is more of a workaround (which has been suggested by Johan Hovold).
Quoted 3 lines
There is no technical limitation in this part of the code itself, so enabling it (and
QCOM_QSEECOMfor that matter) to be built as module should be fairly straightforward once that's been sorted out.
If not this application I would atleast like the QSEECOM driver to be a loadable module due to GKI (Generic Kernel Image) needs. Can we mark QSEECOM as "tristate" please? If not then there is a problem which we are not solving right now as you are documenting above and just moving it it for future and downstream vendors will keep having their additional changes to make it fit for loadable module needs.
Signature · 1 line
---Trilok Soni
Quoted 14 lines · Trilok Soni
Quoted 13 lines · Maximilian Luz
Quoted 5 lines · Trilok Soni
Quoted 2 lines · Maximilian Luz
+config
QCOM_QSEECOM_UEFISECAPP
+ bool "Qualcomm SEE UEFI Secure App client driver"Why not "tristate"? This driver can be a loadable module, right?
As I understand, modular efivars have still not been fully sorted out in the kernel. For example, userspace could try and mount efivarfs before the module has been loaded and by that erroneously determine that the system doesn't support efivars. So requiring it to be built in for now is more of a workaround (which has been suggested by Johan Hovold).
Quoted 5 lines
Quoted 3 lines
There is no technical limitation in this part of the code itself, so enabling it (and
QCOM_QSEECOMfor that matter) to be built as module should be fairly straightforward once that's been sorted out.If not this application I would atleast like the QSEECOM driver to be a loadable module due to GKI (Generic Kernel Image) needs. Can we mark QSEECOM as "tristate" please? If not then there is a problem which we are not solving right now as you are documenting above and just moving it it for future and downstream vendors will keep having their additional changes to make it fit for loadable module needs.
Could you elaborate a bit on why/how switching to a tristate would help here? I'm afraid I don't quite follow. Do you mean that this would make it easier for downstream vendors to patch the module as opposed to create their own new thing? IMHO if they already need to patch it they can just as well modify it to be buildable as a module.
Generally I'm not opposed to have both loadable as modules, but I don't quite see the point as it would not be usable as such in upstream at the moment (at least not reliably, so to avoid those headaches I think it's better to just stick to bool for now).
Regards,
Max
Quoted 27 lines · Maximilian Luz
Quoted 14 lines · Trilok Soni
Quoted 13 lines · Maximilian Luz
Quoted 5 lines · Trilok Soni
Quoted 2 lines · Maximilian Luz
+config
QCOM_QSEECOM_UEFISECAPP
+ bool "Qualcomm SEE UEFI Secure App client driver"Why not "tristate"? This driver can be a loadable module, right?
As I understand, modular efivars have still not been fully sorted out in the kernel. For example, userspace could try and mount efivarfs before the module has been loaded and by that erroneously determine that the system doesn't support efivars. So requiring it to be built in for now is more of a workaround (which has been suggested by Johan Hovold).
Quoted 5 lines
Quoted 3 lines
There is no technical limitation in this part of the code itself, so enabling it (and
QCOM_QSEECOMfor that matter) to be built as module should be fairly straightforward once that's been sorted out.If not this application I would atleast like the QSEECOM driver to be a loadable module due to GKI (Generic Kernel Image) needs. Can we mark QSEECOM as "tristate" please? If not then there is a problem which we are not solving right now as you are documenting above and just moving it it for future and downstream vendors will keep having their additional changes to make it fit for loadable module needs.
Could you elaborate a bit on why/how switching to a tristate would help here? I'm afraid I don't quite follow. Do you mean that this would make it easier for downstream vendors to patch the module as opposed to create their own new thing? IMHO if they already need to patch it they can just as well modify it to be buildable as a module.
Quoted 4 lines
Generally I'm not opposed to have both loadable as modules, but I don't quite see the point as it would not be usable as such in upstream at the moment (at least not reliably, so to avoid those headaches I think it's better to just stick to bool for now).
I just want to be clear that it is not about downstream patches. That is not the intention. Not having the tristate the shows the real problem somewhere in the framework. It means such drivers won't be much usable without hacks on the configuration like GKI - so problem needs to be solved at upstream someday.
Quoted 3 lines
Regards,
Max
Signature · 1 line
---Trilok Soni
Bjorn Andersson
maintainerQuoted 13 lines · Maximilian Luz
Quoted 5 lines · Trilok Soni
drivers/firmware/Kconfig config QCOM_QSEECOM · line 246
Quoted 2 lines · Maximilian Luz
drivers/firmware/Kconfig +2
-0+config QCOM_QSEECOM_UEFISECAPP + bool "Qualcomm SEE UEFI Secure App client driver"Why not "tristate"? This driver can be a loadable module, right?
As I understand, modular efivars have still not been fully sorted out in the kernel. For example, userspace could try and mount efivarfs before the module has been loaded and by that erroneously determine that the system doesn't support efivars. So requiring it to be built in for now is more of a workaround (which has been suggested by Johan Hovold).
Quoted 4 lines
There is no technical limitation in this part of the code itself, so enabling it (and
QCOM_QSEECOMfor that matter) to be built as module should be fairly straightforward once that's been sorted out.
Afaict without resolving the efivars issue this is boolean in practice anyways. As such, I intend to pick this for v6.7, and we can transition to modular support incrementally from here.
Many thanks for sticking to the effort, Maximilian.
Regards,
Bjorn
Quoted 9 lines · Maximilian Luz
This series adds basic support for the QSEECOM interface used to communicate with secure applications running in the TrustZone on certain Qualcomm devices. In addition to that, it also provides a driver for "uefisecapp", the secure application managing access to UEFI variables on such platforms.
For a more detailed description, see the blurb of v1.
[...]
Applied, thanks!
[1/3] lib/ucs2_string: Add UCS-2 strscpy function
commit: e4c89f9380017b6b2e63836e2de1af8eb4535384
[2/3] firmware: qcom_scm: Add support for Qualcomm Secure Execution Environment SCM interface
commit: 00b1248606ba3979ccae30ed11df8cdc1a84245a
[3/3] firmware: Add support for Qualcomm UEFI Secure Application
commit: 759e7a2b62eb3ef3c93ffeb5cca788a09627d7d9Best regards,
Signature · 1 line
Bjorn Andersson <[email protected]>