Linux-Serial Archive on lore.kernel.org
 help / color / Atom feed
* [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver
@ 2020-07-22 10:27 Mateusz Holenko
  2020-07-22 10:27 ` [PATCH v9 1/5] dt-bindings: vendor: add vendor prefix for LiteX Mateusz Holenko
                   ` (4 more replies)
  0 siblings, 5 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:27 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

This patchset introduces support for LiteX SoC Controller
and LiteUART - serial device from LiteX SoC builder
(https://github.com/enjoy-digital/litex).

In the following patchset I will add
a new mor1kx-based (OpenRISC) platform that
uses this device.

Later I plan to extend this platform by
adding support for more devices from LiteX suite.

Changes in v9:
    - fixed the `reg` node notation in the DT example
    - added exporting of the `litex_set_reg`/`litex_get_reg` symbols

Changes in v8:
    - fixed help messages in LiteUART's KConfig
    - removed dependency between LiteUART and LiteX SoC drivers
    - removed `litex_check_accessors()` helper function
    - added crashing (BUG) on the failed LiteX CSR access test

Changes in v7:
    - added missing include directive in UART's driver

Changes in v6:
    - changed accessors in SoC Controller's driver
    - reworked UART driver

Changes in v5:
    - added Reviewed-by tag
    - removed custom accessors from SoC Controller's driver
    - fixed error checking in SoC Controller's driver

Changes in v4:
    - fixed copyright headers
    - fixed SoC Controller's yaml 
    - simplified SoC Controller's driver

Changes in v3:
    - added Acked-by and Reviewed-by tags
    - introduced LiteX SoC Controller driver
    - removed endianness detection (handled now by LiteX SoC Controller driver)
    - modified litex.h header
    - DTS aliases for LiteUART made optional
    - renamed SERIAL_LITEUART_NR_PORTS to SERIAL_LITEUART_MAX_PORTS
    - changed PORT_LITEUART from 122 to 123

Changes in v2:
    - binding description rewritten to a yaml schema file
    - added litex.h header with common register access functions

Filip Kokosinski (3):
  dt-bindings: vendor: add vendor prefix for LiteX
  dt-bindings: serial: document LiteUART bindings
  drivers/tty/serial: add LiteUART driver

Pawel Czarnecki (2):
  dt-bindings: soc: document LiteX SoC Controller bindings
  drivers/soc/litex: add LiteX SoC Controller driver

 .../bindings/serial/litex,liteuart.yaml       |  38 ++
 .../soc/litex/litex,soc-controller.yaml       |  39 ++
 .../devicetree/bindings/vendor-prefixes.yaml  |   2 +
 MAINTAINERS                                   |   9 +
 drivers/soc/Kconfig                           |   1 +
 drivers/soc/Makefile                          |   1 +
 drivers/soc/litex/Kconfig                     |  15 +
 drivers/soc/litex/Makefile                    |   3 +
 drivers/soc/litex/litex_soc_ctrl.c            | 194 +++++++++
 drivers/tty/serial/Kconfig                    |  32 ++
 drivers/tty/serial/Makefile                   |   1 +
 drivers/tty/serial/liteuart.c                 | 402 ++++++++++++++++++
 include/linux/litex.h                         |  24 ++
 13 files changed, 761 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/serial/litex,liteuart.yaml
 create mode 100644 Documentation/devicetree/bindings/soc/litex/litex,soc-controller.yaml
 create mode 100644 drivers/soc/litex/Kconfig
 create mode 100644 drivers/soc/litex/Makefile
 create mode 100644 drivers/soc/litex/litex_soc_ctrl.c
 create mode 100644 drivers/tty/serial/liteuart.c
 create mode 100644 include/linux/litex.h

-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* [PATCH v9 1/5] dt-bindings: vendor: add vendor prefix for LiteX
  2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
@ 2020-07-22 10:27 ` Mateusz Holenko
  2020-07-22 10:27 ` [PATCH v9 2/5] dt-bindings: soc: document LiteX SoC Controller bindings Mateusz Holenko
                   ` (3 subsequent siblings)
  4 siblings, 0 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:27 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

From: Filip Kokosinski <fkokosinski@antmicro.com>

Add vendor prefix for LiteX SoC builder.

Signed-off-by: Filip Kokosinski <fkokosinski@antmicro.com>
Signed-off-by: Mateusz Holenko <mholenko@antmicro.com>
Acked-by: Rob Herring <robh@kernel.org>
---

Notes:
    No changes in v9.

    No changes in v8.

    No changes in v7.

    No changes in v6.

    No changes in v5.

    No changes in v4.

    Changes in v3:
    - added Acked-by tag
    
    No changes in v2.

 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 d3891386d671..9aae6c56d7a3 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.yaml
+++ b/Documentation/devicetree/bindings/vendor-prefixes.yaml
@@ -571,6 +571,8 @@ patternProperties:
     description: Linux-specific binding
   "^linx,.*":
     description: Linx Technologies
+  "^litex,.*":
+    description: LiteX SoC builder
   "^lltc,.*":
     description: Linear Technology Corporation
   "^logicpd,.*":
-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* [PATCH v9 2/5] dt-bindings: soc: document LiteX SoC Controller bindings
  2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
  2020-07-22 10:27 ` [PATCH v9 1/5] dt-bindings: vendor: add vendor prefix for LiteX Mateusz Holenko
@ 2020-07-22 10:27 ` Mateusz Holenko
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:27 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

From: Pawel Czarnecki <pczarnecki@internships.antmicro.com>

Add documentation for LiteX SoC Controller bindings.

Signed-off-by: Pawel Czarnecki <pczarnecki@internships.antmicro.com>
Signed-off-by: Mateusz Holenko <mholenko@antmicro.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---

Notes:
    Changes in v9:
        - fixed the `reg` node notation in the DT example

    No changes in v8.

    No changes in v7.

    Changes in v6:
        - fixed license header

    Changes in v5:
        - added reviewed-by tag
    
    Changes in v4:
        - changes compatible to "litex,soc-controller"
        - fixed yaml's header
        - removed unnecessary sections from yaml
        - fixed indentation in yaml
    
    This commit has been introduced in v3 of the patchset.

 .../soc/litex/litex,soc-controller.yaml       | 39 +++++++++++++++++++
 MAINTAINERS                                   |  6 +++
 2 files changed, 45 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/soc/litex/litex,soc-controller.yaml

diff --git a/Documentation/devicetree/bindings/soc/litex/litex,soc-controller.yaml b/Documentation/devicetree/bindings/soc/litex/litex,soc-controller.yaml
new file mode 100644
index 000000000000..53121c1fbe4d
--- /dev/null
+++ b/Documentation/devicetree/bindings/soc/litex/litex,soc-controller.yaml
@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
+# Copyright 2020 Antmicro <www.antmicro.com>
+%YAML 1.2
+---
+$id: "http://devicetree.org/schemas/soc/litex/litex,soc-controller.yaml#"
+$schema: "http://devicetree.org/meta-schemas/core.yaml#"
+
+title: LiteX SoC Controller driver
+
+description: |
+  This is the SoC Controller driver for the LiteX SoC Builder.
+  It's purpose is to verify LiteX CSR (Control&Status Register) access
+  operations and provide function for other drivers to read/write CSRs
+  and to check if those accessors are ready to use.
+
+maintainers:
+  - Karol Gugala <kgugala@antmicro.com>
+  - Mateusz Holenko <mholenko@antmicro.com>
+
+properties:
+  compatible:
+    const: litex,soc-controller
+
+  reg:
+    maxItems: 1
+
+required:
+  - compatible
+  - reg
+
+examples:
+  - |
+    soc_ctrl0: soc-controller@f0000000 {
+        compatible = "litex,soc-controller";
+        reg = <0xf0000000 0xC>;
+        status = "okay";
+    };
+
+...
diff --git a/MAINTAINERS b/MAINTAINERS
index 7b58ca29cc80..39be98db7418 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9835,6 +9835,12 @@ L:	kunit-dev@googlegroups.com
 S:	Maintained
 F:	lib/list-test.c
 
+LITEX PLATFORM
+M:	Karol Gugala <kgugala@antmicro.com>
+M:	Mateusz Holenko <mholenko@antmicro.com>
+S:	Maintained
+F:	Documentation/devicetree/bindings/*/litex,*.yaml
+
 LIVE PATCHING
 M:	Josh Poimboeuf <jpoimboe@redhat.com>
 M:	Jiri Kosina <jikos@kernel.org>
-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
  2020-07-22 10:27 ` [PATCH v9 1/5] dt-bindings: vendor: add vendor prefix for LiteX Mateusz Holenko
  2020-07-22 10:27 ` [PATCH v9 2/5] dt-bindings: soc: document LiteX SoC Controller bindings Mateusz Holenko
@ 2020-07-22 10:28 ` Mateusz Holenko
  2020-07-25 10:29   ` kernel test robot
                     ` (3 more replies)
  2020-07-22 10:28 ` [PATCH v9 4/5] dt-bindings: serial: document LiteUART bindings Mateusz Holenko
  2020-07-22 10:28 ` [PATCH v9 5/5] drivers/tty/serial: add LiteUART driver Mateusz Holenko
  4 siblings, 4 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:28 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

From: Pawel Czarnecki <pczarnecki@internships.antmicro.com>

This commit adds driver for the FPGA-based LiteX SoC
Controller from LiteX SoC builder.

Co-developed-by: Mateusz Holenko <mholenko@antmicro.com>
Signed-off-by: Mateusz Holenko <mholenko@antmicro.com>
Signed-off-by: Pawel Czarnecki <pczarnecki@internships.antmicro.com>
---

Notes:
    Changes in v9:
    - added exporting of the `litex_set_reg`/`litex_get_reg` symbols

    Changes in v8:
    - removed `litex_check_accessors()` helper function
    - added crashing (BUG) on the failed LiteX CSR access test

    No changes in v7.

    Changes in v6:
    - added dependency on OF || COMPILE_TEST
    - used le32_to_cpu(readl(addr)) instead of __raw_readl
      and writel(cpu_to_le32(value), addr) instead of __raw_writel
      to take advantage of memory barriers provided by readl/writel

    Changes in v5:
    - removed helper accessors and used __raw_readl/__raw_writel instead
    - fixed checking for errors in litex_soc_ctrl_probe

    Changes in v4:
    - fixed indent in Kconfig's help section
    - fixed copyright header
    - changed compatible to "litex,soc-controller"
    - simplified litex_soc_ctrl_probe
    - removed unnecessary litex_soc_ctrl_remove
   
    This commit has been introduced in v3 of the patchset.
    
    It includes a simplified version of common 'litex.h'
    header introduced in v2 of the patchset.

 MAINTAINERS                        |   2 +
 drivers/soc/Kconfig                |   1 +
 drivers/soc/Makefile               |   1 +
 drivers/soc/litex/Kconfig          |  15 +++
 drivers/soc/litex/Makefile         |   3 +
 drivers/soc/litex/litex_soc_ctrl.c | 194 +++++++++++++++++++++++++++++
 include/linux/litex.h              |  24 ++++
 7 files changed, 240 insertions(+)
 create mode 100644 drivers/soc/litex/Kconfig
 create mode 100644 drivers/soc/litex/Makefile
 create mode 100644 drivers/soc/litex/litex_soc_ctrl.c
 create mode 100644 include/linux/litex.h

diff --git a/MAINTAINERS b/MAINTAINERS
index 39be98db7418..4d70a1b22a87 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9840,6 +9840,8 @@ M:	Karol Gugala <kgugala@antmicro.com>
 M:	Mateusz Holenko <mholenko@antmicro.com>
 S:	Maintained
 F:	Documentation/devicetree/bindings/*/litex,*.yaml
+F:	drivers/soc/litex/litex_soc_ctrl.c
+F:	include/linux/litex.h
 
 LIVE PATCHING
 M:	Josh Poimboeuf <jpoimboe@redhat.com>
diff --git a/drivers/soc/Kconfig b/drivers/soc/Kconfig
index 425ab6f7e375..d097d070f579 100644
--- a/drivers/soc/Kconfig
+++ b/drivers/soc/Kconfig
@@ -9,6 +9,7 @@ source "drivers/soc/bcm/Kconfig"
 source "drivers/soc/fsl/Kconfig"
 source "drivers/soc/imx/Kconfig"
 source "drivers/soc/ixp4xx/Kconfig"
+source "drivers/soc/litex/Kconfig"
 source "drivers/soc/mediatek/Kconfig"
 source "drivers/soc/qcom/Kconfig"
 source "drivers/soc/renesas/Kconfig"
diff --git a/drivers/soc/Makefile b/drivers/soc/Makefile
index 36452bed86ef..0b16108823ef 100644
--- a/drivers/soc/Makefile
+++ b/drivers/soc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_ARCH_GEMINI)	+= gemini/
 obj-y				+= imx/
 obj-$(CONFIG_ARCH_IXP4XX)	+= ixp4xx/
 obj-$(CONFIG_SOC_XWAY)		+= lantiq/
+obj-$(CONFIG_LITEX_SOC_CONTROLLER) += litex/
 obj-y				+= mediatek/
 obj-y				+= amlogic/
 obj-y				+= qcom/
diff --git a/drivers/soc/litex/Kconfig b/drivers/soc/litex/Kconfig
new file mode 100644
index 000000000000..c974ec3846bc
--- /dev/null
+++ b/drivers/soc/litex/Kconfig
@@ -0,0 +1,15 @@
+# SPDX-License_Identifier: GPL-2.0
+
+menu "Enable LiteX SoC Builder specific drivers"
+
+config LITEX_SOC_CONTROLLER
+	tristate "Enable LiteX SoC Controller driver"
+	depends on OF || COMPILE_TEST
+	help
+	  This option enables the SoC Controller Driver which verifies
+	  LiteX CSR access and provides common litex_get_reg/litex_set_reg
+	  accessors.
+	  All drivers that use functions from litex.h must depend on
+	  LITEX_SOC_CONTROLLER.
+
+endmenu
diff --git a/drivers/soc/litex/Makefile b/drivers/soc/litex/Makefile
new file mode 100644
index 000000000000..98ff7325b1c0
--- /dev/null
+++ b/drivers/soc/litex/Makefile
@@ -0,0 +1,3 @@
+# SPDX-License_Identifier: GPL-2.0
+
+obj-$(CONFIG_LITEX_SOC_CONTROLLER)	+= litex_soc_ctrl.o
diff --git a/drivers/soc/litex/litex_soc_ctrl.c b/drivers/soc/litex/litex_soc_ctrl.c
new file mode 100644
index 000000000000..08330c9872b0
--- /dev/null
+++ b/drivers/soc/litex/litex_soc_ctrl.c
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * LiteX SoC Controller Driver
+ *
+ * Copyright (C) 2020 Antmicro <www.antmicro.com>
+ *
+ */
+
+#include <linux/litex.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/printk.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+
+/*
+ * The parameters below are true for LiteX SoC
+ * configured for 8-bit CSR Bus, 32-bit aligned.
+ *
+ * Supporting other configurations will require
+ * extending the logic in this header.
+ */
+#define LITEX_REG_SIZE             0x4
+#define LITEX_SUBREG_SIZE          0x1
+#define LITEX_SUBREG_SIZE_BIT      (LITEX_SUBREG_SIZE * 8)
+
+static DEFINE_SPINLOCK(csr_lock);
+
+/*
+ * LiteX SoC Generator, depending on the configuration,
+ * can split a single logical CSR (Control & Status Register)
+ * into a series of consecutive physical registers.
+ *
+ * For example, in the configuration with 8-bit CSR Bus,
+ * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
+ * logical CSR will be generated as four 32-bit physical registers,
+ * each one containing one byte of meaningful data.
+ *
+ * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
+ *
+ * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
+ * the logic of writing to/reading from the LiteX CSR in a single
+ * place that can be then reused by all LiteX drivers.
+ */
+void litex_set_reg(void __iomem *reg, unsigned long reg_size,
+		    unsigned long val)
+{
+	unsigned long shifted_data, shift, i;
+	unsigned long flags;
+
+	spin_lock_irqsave(&csr_lock, flags);
+
+	for (i = 0; i < reg_size; ++i) {
+		shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
+		shifted_data = val >> shift;
+
+		writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
+	}
+
+	spin_unlock_irqrestore(&csr_lock, flags);
+}
+EXPORT_SYMBOL_GPL(litex_set_reg);
+
+unsigned long litex_get_reg(void __iomem *reg, unsigned long reg_size)
+{
+	unsigned long shifted_data, shift, i;
+	unsigned long result = 0;
+	unsigned long flags;
+
+	spin_lock_irqsave(&csr_lock, flags);
+
+	for (i = 0; i < reg_size; ++i) {
+		shifted_data = le32_to_cpu(readl(reg + (LITEX_REG_SIZE * i)));
+
+		shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
+		result |= (shifted_data << shift);
+	}
+
+	spin_unlock_irqrestore(&csr_lock, flags);
+
+	return result;
+}
+EXPORT_SYMBOL_GPL(litex_get_reg);
+
+#define SCRATCH_REG_OFF         0x04
+#define SCRATCH_REG_SIZE        4
+#define SCRATCH_REG_VALUE       0x12345678
+#define SCRATCH_TEST_VALUE      0xdeadbeef
+
+/*
+ * Check LiteX CSR read/write access
+ *
+ * This function reads and writes a scratch register in order
+ * to verify if CSR access works.
+ *
+ * In case any problems are detected, the driver should panic.
+ *
+ * Access to the LiteX CSR is, by design, done in CPU native
+ * endianness. The driver should not dynamically configure
+ * access functions when the endianness mismatch is detected.
+ * Such situation indicates problems in the soft SoC design
+ * and should be solved at the LiteX generator level,
+ * not in the software.
+ */
+static int litex_check_csr_access(void __iomem *reg_addr)
+{
+	unsigned long reg;
+
+	reg = litex_get_reg(reg_addr + SCRATCH_REG_OFF, SCRATCH_REG_SIZE);
+
+	if (reg != SCRATCH_REG_VALUE) {
+		panic("Scratch register read error! Expected: 0x%x but got: 0x%lx",
+			SCRATCH_REG_VALUE, reg);
+		return -EINVAL;
+	}
+
+	litex_set_reg(reg_addr + SCRATCH_REG_OFF,
+		SCRATCH_REG_SIZE, SCRATCH_TEST_VALUE);
+	reg = litex_get_reg(reg_addr + SCRATCH_REG_OFF, SCRATCH_REG_SIZE);
+
+	if (reg != SCRATCH_TEST_VALUE) {
+		panic("Scratch register write error! Expected: 0x%x but got: 0x%lx",
+			SCRATCH_TEST_VALUE, reg);
+		return -EINVAL;
+	}
+
+	/* restore original value of the SCRATCH register */
+	litex_set_reg(reg_addr + SCRATCH_REG_OFF,
+		SCRATCH_REG_SIZE, SCRATCH_REG_VALUE);
+
+	/* Set flag for other drivers */
+	pr_info("LiteX SoC Controller driver initialized");
+
+	return 0;
+}
+
+struct litex_soc_ctrl_device {
+	void __iomem *base;
+};
+
+static const struct of_device_id litex_soc_ctrl_of_match[] = {
+	{.compatible = "litex,soc-controller"},
+	{},
+};
+
+MODULE_DEVICE_TABLE(of, litex_soc_ctrl_of_match);
+
+static int litex_soc_ctrl_probe(struct platform_device *pdev)
+{
+	int result;
+	struct device *dev;
+	struct device_node *node;
+	struct litex_soc_ctrl_device *soc_ctrl_dev;
+
+	dev = &pdev->dev;
+	node = dev->of_node;
+	if (!node)
+		return -ENODEV;
+
+	soc_ctrl_dev = devm_kzalloc(dev, sizeof(*soc_ctrl_dev), GFP_KERNEL);
+	if (!soc_ctrl_dev)
+		return -ENOMEM;
+
+	soc_ctrl_dev->base = devm_platform_ioremap_resource(pdev, 0);
+	if (IS_ERR(soc_ctrl_dev->base))
+		return PTR_ERR(soc_ctrl_dev->base);
+
+	result = litex_check_csr_access(soc_ctrl_dev->base);
+	if (result) {
+		// LiteX CSRs access is broken which means that
+		// none of LiteX drivers will most probably
+		// operate correctly
+		BUG();
+	}
+
+	return 0;
+}
+
+static struct platform_driver litex_soc_ctrl_driver = {
+	.driver = {
+		.name = "litex-soc-controller",
+		.of_match_table = of_match_ptr(litex_soc_ctrl_of_match)
+	},
+	.probe = litex_soc_ctrl_probe,
+};
+
+module_platform_driver(litex_soc_ctrl_driver);
+MODULE_DESCRIPTION("LiteX SoC Controller driver");
+MODULE_AUTHOR("Antmicro <www.antmicro.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/include/linux/litex.h b/include/linux/litex.h
new file mode 100644
index 000000000000..72061018c172
--- /dev/null
+++ b/include/linux/litex.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Common LiteX header providing
+ * helper functions for accessing CSRs.
+ *
+ * Implementation of the functions is provided by
+ * the LiteX SoC Controller driver.
+ *
+ * Copyright (C) 2019-2020 Antmicro <www.antmicro.com>
+ */
+
+#ifndef _LINUX_LITEX_H
+#define _LINUX_LITEX_H
+
+#include <linux/io.h>
+#include <linux/types.h>
+#include <linux/compiler_types.h>
+
+void litex_set_reg(void __iomem *reg, unsigned long reg_sz, unsigned long val);
+
+unsigned long litex_get_reg(void __iomem *reg, unsigned long reg_sz);
+
+
+#endif /* _LINUX_LITEX_H */
-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* [PATCH v9 4/5] dt-bindings: serial: document LiteUART bindings
  2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
                   ` (2 preceding siblings ...)
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
@ 2020-07-22 10:28 ` Mateusz Holenko
  2020-07-22 10:28 ` [PATCH v9 5/5] drivers/tty/serial: add LiteUART driver Mateusz Holenko
  4 siblings, 0 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:28 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

From: Filip Kokosinski <fkokosinski@antmicro.com>

Add documentation for LiteUART devicetree bindings.

Signed-off-by: Filip Kokosinski <fkokosinski@antmicro.com>
Signed-off-by: Mateusz Holenko <mholenko@antmicro.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---

Notes:
    No changes in v9.

    No changes in v8.

    No changes in v7.

    Changes in v6:
    - fixed license header

    No changes in v5.

    No changes in v4.

    Changes in v3:
    - added Reviewed-by tag
    - patch number changed from 3 to 4
    - removed changes in MAINTAINERS file (moved to patch #2)
    
    Changes in v2:
    - binding description rewritten to a yaml schema file
    - added interrupt line
    - fixed unit address
    - patch number changed from 2 to 3

 .../bindings/serial/litex,liteuart.yaml       | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/serial/litex,liteuart.yaml

diff --git a/Documentation/devicetree/bindings/serial/litex,liteuart.yaml b/Documentation/devicetree/bindings/serial/litex,liteuart.yaml
new file mode 100644
index 000000000000..69acb222bb57
--- /dev/null
+++ b/Documentation/devicetree/bindings/serial/litex,liteuart.yaml
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
+
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/serial/litex,liteuart.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: LiteUART serial controller
+
+maintainers:
+  - Karol Gugala <kgugala@antmicro.com>
+  - Mateusz Holenko <mholenko@antmicro.com>
+
+description: |
+  LiteUART serial controller is a part of LiteX FPGA SoC builder. It supports
+  multiple CPU architectures, currently including e.g. OpenRISC and RISC-V.
+
+properties:
+  compatible:
+    const: litex,liteuart
+
+  reg:
+    maxItems: 1
+
+  interrupts:
+    maxItems: 1
+
+required:
+  - compatible
+  - reg
+
+examples:
+  - |
+    uart0: serial@e0001800 {
+      compatible = "litex,liteuart";
+      reg = <0xe0001800 0x100>;
+      interrupts = <2>;
+    };
-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* [PATCH v9 5/5] drivers/tty/serial: add LiteUART driver
  2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
                   ` (3 preceding siblings ...)
  2020-07-22 10:28 ` [PATCH v9 4/5] dt-bindings: serial: document LiteUART bindings Mateusz Holenko
@ 2020-07-22 10:28 ` Mateusz Holenko
  4 siblings, 0 replies; 12+ messages in thread
From: Mateusz Holenko @ 2020-07-22 10:28 UTC (permalink / raw)
  To: Rob Herring, Mark Rutland, Greg Kroah-Hartman, Jiri Slaby,
	devicetree, linux-serial
  Cc: Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab, David S. Miller, Paul E. McKenney,
	Filip Kokosinski, Pawel Czarnecki, Joel Stanley,
	Jonathan Cameron, Maxime Ripard, Shawn Guo, Heiko Stuebner,
	Sam Ravnborg, Icenowy Zheng, Laurent Pinchart, linux-kernel,
	Gabriel L. Somlo

From: Filip Kokosinski <fkokosinski@antmicro.com>

This commit adds driver for the FPGA-based LiteUART serial controller
from LiteX SoC builder.

The current implementation supports LiteUART configured
for 32 bit data width and 8 bit CSR bus width.

It does not support IRQ.

Signed-off-by: Filip Kokosinski <fkokosinski@antmicro.com>
Signed-off-by: Mateusz Holenko <mholenko@antmicro.com>
---

Notes:
    No changes in v9.

    Changes in v8:
    - fixed help messages in LiteUART's KConfig
    - removed dependency between LiteUART and LiteX SoC drivers

    Changed in v7:
    - added missing include directive

    Changes in v6:
    - LiteUART ports now stored in xArray
    - removed PORT_LITEUART
    - fixed formatting
    - removed some unnecessary defines

    No changes in v5.

    Changes in v4:
    - fixed copyright header
    - removed a wrong dependency on UARTLITE from Kconfig
    - added a dependency on LITEX_SOC_CONTROLLER to LITEUART in Kconfig

    Changes in v3:
    - aliases made optional
    - used litex_get_reg/litex_set_reg functions instead of macros
    - SERIAL_LITEUART_NR_PORTS renamed to SERIAL_LITEUART_MAX_PORTS
    - PORT_LITEUART changed from 122 to 123
    - added dependency on LITEX_SOC_CONTROLLER
    - patch number changed from 4 to 5

    No changes in v2.

 MAINTAINERS                   |   1 +
 drivers/tty/serial/Kconfig    |  32 +++
 drivers/tty/serial/Makefile   |   1 +
 drivers/tty/serial/liteuart.c | 402 ++++++++++++++++++++++++++++++++++
 4 files changed, 436 insertions(+)
 create mode 100644 drivers/tty/serial/liteuart.c

diff --git a/MAINTAINERS b/MAINTAINERS
index 4d70a1b22a87..1387cefc63ce 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9841,6 +9841,7 @@ M:	Mateusz Holenko <mholenko@antmicro.com>
 S:	Maintained
 F:	Documentation/devicetree/bindings/*/litex,*.yaml
 F:	drivers/soc/litex/litex_soc_ctrl.c
+F:	drivers/tty/serial/liteuart.c
 F:	include/linux/litex.h
 
 LIVE PATCHING
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index adf9e80e7dc9..17aaf0afb27a 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -1562,6 +1562,38 @@ config SERIAL_MILBEAUT_USIO_CONSOLE
 	  receives all kernel messages and warnings and which allows logins in
 	  single user mode).
 
+config SERIAL_LITEUART
+	tristate "LiteUART serial port support"
+	depends on HAS_IOMEM
+	depends on OF || COMPILE_TEST
+	depends on LITEX_SOC_CONTROLLER
+	select SERIAL_CORE
+	help
+	  This driver is for the FPGA-based LiteUART serial controller from LiteX
+	  SoC builder.
+
+	  Say 'Y' or 'M' here if you wish to use the LiteUART serial controller.
+	  Otherwise, say 'N'.
+
+config SERIAL_LITEUART_MAX_PORTS
+	int "Maximum number of LiteUART ports"
+	depends on SERIAL_LITEUART
+	default "1"
+	help
+	  Set this to the maximum number of serial ports you want the driver
+	  to support.
+
+config SERIAL_LITEUART_CONSOLE
+	bool "LiteUART serial port console support"
+	depends on SERIAL_LITEUART=y
+	select SERIAL_CORE_CONSOLE
+	help
+	  Say 'Y' or 'M' here if you wish to use the FPGA-based LiteUART serial
+	  controller from LiteX SoC builder as the system console
+	  (the system console is the device which receives all kernel messages
+	  and warnings and which allows logins in single user mode).
+	  Otherwise, say 'N'.
+
 endmenu
 
 config SERIAL_MCTRL_GPIO
diff --git a/drivers/tty/serial/Makefile b/drivers/tty/serial/Makefile
index d056ee6cca33..9f8ba419ff3b 100644
--- a/drivers/tty/serial/Makefile
+++ b/drivers/tty/serial/Makefile
@@ -89,6 +89,7 @@ obj-$(CONFIG_SERIAL_OWL)	+= owl-uart.o
 obj-$(CONFIG_SERIAL_RDA)	+= rda-uart.o
 obj-$(CONFIG_SERIAL_MILBEAUT_USIO) += milbeaut_usio.o
 obj-$(CONFIG_SERIAL_SIFIVE)	+= sifive.o
+obj-$(CONFIG_SERIAL_LITEUART) += liteuart.o
 
 # GPIOLIB helpers for modem control lines
 obj-$(CONFIG_SERIAL_MCTRL_GPIO)	+= serial_mctrl_gpio.o
diff --git a/drivers/tty/serial/liteuart.c b/drivers/tty/serial/liteuart.c
new file mode 100644
index 000000000000..b087e6a32106
--- /dev/null
+++ b/drivers/tty/serial/liteuart.c
@@ -0,0 +1,402 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * LiteUART serial controller (LiteX) Driver
+ *
+ * Copyright (C) 2019-2020 Antmicro <www.antmicro.com>
+ */
+
+#include <linux/console.h>
+#include <linux/litex.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/tty_flip.h>
+#include <linux/xarray.h>
+
+/*
+ * CSRs definitions (base address offsets + width)
+ *
+ * The definitions below are true for LiteX SoC configured for 8-bit CSR Bus,
+ * 32-bit aligned.
+ *
+ * Supporting other configurations might require new definitions or a more
+ * generic way of indexing the LiteX CSRs.
+ *
+ * For more details on how CSRs are defined and handled in LiteX, see comments
+ * in the LiteX SoC Driver: drivers/soc/litex/litex_soc_ctrl.c
+ */
+#define OFF_RXTX	0x00
+#define OFF_TXFULL	0x04
+#define OFF_RXEMPTY	0x08
+#define OFF_EV_STATUS	0x0c
+#define OFF_EV_PENDING	0x10
+#define OFF_EV_ENABLE	0x14
+
+/* events */
+#define EV_TX		0x1
+#define EV_RX		0x2
+
+struct liteuart_port {
+	struct uart_port port;
+	struct timer_list timer;
+};
+
+#define to_liteuart_port(port)	container_of(port, struct liteuart_port, port)
+
+static DEFINE_XARRAY_FLAGS(liteuart_array, XA_FLAGS_ALLOC);
+
+#ifdef CONFIG_SERIAL_LITEUART_CONSOLE
+static struct console liteuart_console;
+#endif
+
+static struct uart_driver liteuart_driver = {
+	.owner = THIS_MODULE,
+	.driver_name = "liteuart",
+	.dev_name = "ttyLXU",
+	.major = 0,
+	.minor = 0,
+	.nr = CONFIG_SERIAL_LITEUART_MAX_PORTS,
+#ifdef CONFIG_SERIAL_LITEUART_CONSOLE
+	.cons = &liteuart_console,
+#endif
+};
+
+static void liteuart_timer(struct timer_list *t)
+{
+	struct liteuart_port *uart = from_timer(uart, t, timer);
+	struct uart_port *port = &uart->port;
+	unsigned char __iomem *membase = port->membase;
+	unsigned int flg = TTY_NORMAL;
+	int ch;
+	unsigned long status;
+
+	while ((status = !litex_get_reg(membase + OFF_RXEMPTY, 1)) == 1) {
+		ch = litex_get_reg(membase + OFF_RXTX, 1);
+		port->icount.rx++;
+
+		/* necessary for RXEMPTY to refresh its value */
+		litex_set_reg(membase + OFF_EV_PENDING, 1, EV_TX | EV_RX);
+
+		/* no overflow bits in status */
+		if (!(uart_handle_sysrq_char(port, ch)))
+			uart_insert_char(port, status, 0, ch, flg);
+
+		tty_flip_buffer_push(&port->state->port);
+	}
+
+	mod_timer(&uart->timer, jiffies + uart_poll_timeout(port));
+}
+
+static void liteuart_putchar(struct uart_port *port, int ch)
+{
+	while (litex_get_reg(port->membase + OFF_TXFULL, 1))
+		cpu_relax();
+
+	litex_set_reg(port->membase + OFF_RXTX, 1, ch);
+}
+
+static unsigned int liteuart_tx_empty(struct uart_port *port)
+{
+	/* not really tx empty, just checking if tx is not full */
+	if (!litex_get_reg(port->membase + OFF_TXFULL, 1))
+		return TIOCSER_TEMT;
+
+	return 0;
+}
+
+static void liteuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+	/* modem control register is not present in LiteUART */
+}
+
+static unsigned int liteuart_get_mctrl(struct uart_port *port)
+{
+	return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+}
+
+static void liteuart_stop_tx(struct uart_port *port)
+{
+}
+
+static void liteuart_start_tx(struct uart_port *port)
+{
+	struct circ_buf *xmit = &port->state->xmit;
+	unsigned char ch;
+
+	if (unlikely(port->x_char)) {
+		litex_set_reg(port->membase + OFF_RXTX, 1, port->x_char);
+		port->icount.tx++;
+		port->x_char = 0;
+	} else if (!uart_circ_empty(xmit)) {
+		while (xmit->head != xmit->tail) {
+			ch = xmit->buf[xmit->tail];
+			xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+			port->icount.tx++;
+			liteuart_putchar(port, ch);
+		}
+	}
+
+	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+		uart_write_wakeup(port);
+}
+
+static void liteuart_stop_rx(struct uart_port *port)
+{
+	struct liteuart_port *uart = to_liteuart_port(port);
+
+	/* just delete timer */
+	del_timer(&uart->timer);
+}
+
+static void liteuart_break_ctl(struct uart_port *port, int break_state)
+{
+	/* LiteUART doesn't support sending break signal */
+}
+
+static int liteuart_startup(struct uart_port *port)
+{
+	struct liteuart_port *uart = to_liteuart_port(port);
+
+	/* disable events */
+	litex_set_reg(port->membase + OFF_EV_ENABLE, 1, 0);
+
+	/* prepare timer for polling */
+	timer_setup(&uart->timer, liteuart_timer, 0);
+	mod_timer(&uart->timer, jiffies + uart_poll_timeout(port));
+
+	return 0;
+}
+
+static void liteuart_shutdown(struct uart_port *port)
+{
+}
+
+static void liteuart_set_termios(struct uart_port *port, struct ktermios *new,
+				 struct ktermios *old)
+{
+	unsigned int baud;
+	unsigned long flags;
+
+	spin_lock_irqsave(&port->lock, flags);
+
+	/* update baudrate */
+	baud = uart_get_baud_rate(port, new, old, 0, 460800);
+	uart_update_timeout(port, new->c_cflag, baud);
+
+	spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static const char *liteuart_type(struct uart_port *port)
+{
+	return "liteuart";
+}
+
+static void liteuart_release_port(struct uart_port *port)
+{
+}
+
+static int liteuart_request_port(struct uart_port *port)
+{
+	return 0;
+}
+
+static void liteuart_config_port(struct uart_port *port, int flags)
+{
+	/*
+	 * Driver core for serial ports forces a non-zero value for port type.
+	 * Write an arbitrary value here to accommodate the serial core driver,
+	 * as ID part of UAPI is redundant.
+	 */
+	port->type = 1;
+}
+
+static int liteuart_verify_port(struct uart_port *port,
+				struct serial_struct *ser)
+{
+	if (port->type != PORT_UNKNOWN && ser->type != 1)
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct uart_ops liteuart_ops = {
+	.tx_empty	= liteuart_tx_empty,
+	.set_mctrl	= liteuart_set_mctrl,
+	.get_mctrl	= liteuart_get_mctrl,
+	.stop_tx	= liteuart_stop_tx,
+	.start_tx	= liteuart_start_tx,
+	.stop_rx	= liteuart_stop_rx,
+	.break_ctl	= liteuart_break_ctl,
+	.startup	= liteuart_startup,
+	.shutdown	= liteuart_shutdown,
+	.set_termios	= liteuart_set_termios,
+	.type		= liteuart_type,
+	.release_port	= liteuart_release_port,
+	.request_port	= liteuart_request_port,
+	.config_port	= liteuart_config_port,
+	.verify_port	= liteuart_verify_port,
+};
+
+static int liteuart_probe(struct platform_device *pdev)
+{
+	struct device_node *np = pdev->dev.of_node;
+	struct liteuart_port *uart;
+	struct uart_port *port;
+	struct xa_limit limit;
+	int dev_id, ret;
+
+	/* no device tree */
+	if (!np)
+		return -ENODEV;
+
+	/* look for aliases; auto-enumerate for free index if not found */
+	dev_id = of_alias_get_id(np, "serial");
+	if (dev_id < 0)
+		limit = XA_LIMIT(0, CONFIG_SERIAL_LITEUART_MAX_PORTS);
+	else
+		limit = XA_LIMIT(dev_id, dev_id);
+
+	uart = kzalloc(sizeof(struct liteuart_port), GFP_KERNEL);
+	if (!uart)
+		return -ENOMEM;
+
+	ret = xa_alloc(&liteuart_array, &dev_id, uart, limit, GFP_KERNEL);
+	if (ret)
+		return ret;
+
+	port = &uart->port;
+
+	/* get membase */
+	port->membase = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
+	if (!port->membase)
+		return -ENXIO;
+
+	/* values not from device tree */
+	port->dev = &pdev->dev;
+	port->iotype = UPIO_MEM;
+	port->flags = UPF_BOOT_AUTOCONF;
+	port->ops = &liteuart_ops;
+	port->regshift = 2;
+	port->fifosize = 16;
+	port->iobase = 1;
+	port->type = PORT_UNKNOWN;
+	port->line = dev_id;
+	spin_lock_init(&port->lock);
+
+	return uart_add_one_port(&liteuart_driver, &uart->port);
+}
+
+static int liteuart_remove(struct platform_device *pdev)
+{
+	return 0;
+}
+
+static const struct of_device_id liteuart_of_match[] = {
+	{ .compatible = "litex,liteuart" },
+	{}
+};
+MODULE_DEVICE_TABLE(of, liteuart_of_match);
+
+static struct platform_driver liteuart_platform_driver = {
+	.probe = liteuart_probe,
+	.remove = liteuart_remove,
+	.driver = {
+		.name = "liteuart",
+		.of_match_table = liteuart_of_match,
+	},
+};
+
+#ifdef CONFIG_SERIAL_LITEUART_CONSOLE
+
+static void liteuart_console_write(struct console *co, const char *s,
+	unsigned int count)
+{
+	struct liteuart_port *uart;
+	struct uart_port *port;
+	unsigned long flags;
+
+	uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
+	port = &uart->port;
+
+	spin_lock_irqsave(&port->lock, flags);
+	uart_console_write(port, s, count, liteuart_putchar);
+	spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static int liteuart_console_setup(struct console *co, char *options)
+{
+	struct liteuart_port *uart;
+	struct uart_port *port;
+	int baud = 115200;
+	int bits = 8;
+	int parity = 'n';
+	int flow = 'n';
+
+	uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
+	if (!uart)
+		return -ENODEV;
+
+	port = &uart->port;
+	if (!port->membase)
+		return -ENODEV;
+
+	if (options)
+		uart_parse_options(options, &baud, &parity, &bits, &flow);
+
+	return uart_set_options(port, co, baud, parity, bits, flow);
+}
+
+static struct console liteuart_console = {
+	.name = "liteuart",
+	.write = liteuart_console_write,
+	.device = uart_console_device,
+	.setup = liteuart_console_setup,
+	.flags = CON_PRINTBUFFER,
+	.index = -1,
+	.data = &liteuart_driver,
+};
+
+static int __init liteuart_console_init(void)
+{
+	register_console(&liteuart_console);
+
+	return 0;
+}
+console_initcall(liteuart_console_init);
+#endif /* CONFIG_SERIAL_LITEUART_CONSOLE */
+
+static int __init liteuart_init(void)
+{
+	int res;
+
+	res = uart_register_driver(&liteuart_driver);
+	if (res)
+		return res;
+
+	res = platform_driver_register(&liteuart_platform_driver);
+	if (res) {
+		uart_unregister_driver(&liteuart_driver);
+		return res;
+	}
+
+	return 0;
+}
+
+static void __exit liteuart_exit(void)
+{
+	platform_driver_unregister(&liteuart_platform_driver);
+	uart_unregister_driver(&liteuart_driver);
+}
+
+module_init(liteuart_init);
+module_exit(liteuart_exit);
+
+MODULE_AUTHOR("Antmicro <www.antmicro.com>");
+MODULE_DESCRIPTION("LiteUART serial driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform: liteuart");
-- 
2.25.1


^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
@ 2020-07-25 10:29   ` kernel test robot
  2020-07-25 21:14     ` Stafford Horne
  2020-07-26 18:36   ` kernel test robot
                     ` (2 subsequent siblings)
  3 siblings, 1 reply; 12+ messages in thread
From: kernel test robot @ 2020-07-25 10:29 UTC (permalink / raw)
  To: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial
  Cc: kbuild-all, Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab


[-- Attachment #1: Type: text/plain, Size: 5896 bytes --]

Hi Mateusz,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on robh/for-next]
[also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8-rc6 next-20200724]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: openrisc-randconfig-s032-20200725 (attached as .config)
compiler: or1k-linux-gcc (GCC) 9.3.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # apt-get install sparse
        # sparse version: v0.6.2-93-g4c6cbe55-dirty
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=openrisc 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>


sparse warnings: (new ones prefixed by >>)

>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     expected unsigned int [usertype] value
>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     got restricted __le32 [usertype]
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c: note: in included file (through arch/openrisc/include/asm/io.h, include/linux/io.h, include/linux/litex.h):
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:225:22: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
   include/asm-generic/io.h:225:22: sparse:     expected unsigned int [usertype] value
   include/asm-generic/io.h:225:22: sparse:     got restricted __le32 [usertype]
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
   include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32

vim +61 drivers/soc/litex/litex_soc_ctrl.c

    32	
    33	/*
    34	 * LiteX SoC Generator, depending on the configuration,
    35	 * can split a single logical CSR (Control & Status Register)
    36	 * into a series of consecutive physical registers.
    37	 *
    38	 * For example, in the configuration with 8-bit CSR Bus,
    39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
    40	 * logical CSR will be generated as four 32-bit physical registers,
    41	 * each one containing one byte of meaningful data.
    42	 *
    43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
    44	 *
    45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
    46	 * the logic of writing to/reading from the LiteX CSR in a single
    47	 * place that can be then reused by all LiteX drivers.
    48	 */
    49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
    50			    unsigned long val)
    51	{
    52		unsigned long shifted_data, shift, i;
    53		unsigned long flags;
    54	
    55		spin_lock_irqsave(&csr_lock, flags);
    56	
    57		for (i = 0; i < reg_size; ++i) {
    58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
    59			shifted_data = val >> shift;
    60	
  > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
    62		}
    63	
    64		spin_unlock_irqrestore(&csr_lock, flags);
    65	}
    66	EXPORT_SYMBOL_GPL(litex_set_reg);
    67	
    68	unsigned long litex_get_reg(void __iomem *reg, unsigned long reg_size)
    69	{
    70		unsigned long shifted_data, shift, i;
    71		unsigned long result = 0;
    72		unsigned long flags;
    73	
    74		spin_lock_irqsave(&csr_lock, flags);
    75	
    76		for (i = 0; i < reg_size; ++i) {
  > 77			shifted_data = le32_to_cpu(readl(reg + (LITEX_REG_SIZE * i)));
    78	
    79			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
    80			result |= (shifted_data << shift);
    81		}
    82	
    83		spin_unlock_irqrestore(&csr_lock, flags);
    84	
    85		return result;
    86	}
    87	EXPORT_SYMBOL_GPL(litex_get_reg);
    88	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 24994 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-25 10:29   ` kernel test robot
@ 2020-07-25 21:14     ` Stafford Horne
  2020-07-26 23:36       ` Stafford Horne
  0 siblings, 1 reply; 12+ messages in thread
From: Stafford Horne @ 2020-07-25 21:14 UTC (permalink / raw)
  To: kernel test robot
  Cc: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial, kbuild-all, Karol Gugala,
	Mauro Carvalho Chehab

On Sat, Jul 25, 2020 at 06:29:51PM +0800, kernel test robot wrote:
> Hi Mateusz,
> 
> Thank you for the patch! Perhaps something to improve:
> 
> [auto build test WARNING on robh/for-next]
> [also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8-rc6 next-20200724]
> [If your patch is applied to the wrong git tree, kindly drop us a note.
> And when submitting patch, we suggest to use '--base' as documented in
> https://git-scm.com/docs/git-format-patch]
> 
> url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
> base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
> config: openrisc-randconfig-s032-20200725 (attached as .config)
> compiler: or1k-linux-gcc (GCC) 9.3.0
> reproduce:
>         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>         chmod +x ~/bin/make.cross
>         # apt-get install sparse
>         # sparse version: v0.6.2-93-g4c6cbe55-dirty
>         # save the attached .config to linux build tree
>         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=openrisc 

Note, this is OpenRISC

> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
> 
> 
> sparse warnings: (new ones prefixed by >>)
> 
> >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
> >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     expected unsigned int [usertype] value
> >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     got restricted __le32 [usertype]
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
>    drivers/soc/litex/litex_soc_ctrl.c: note: in included file (through arch/openrisc/include/asm/io.h, include/linux/io.h, include/linux/litex.h):

I think this is something I need to fix up in the openrisc io.h header.

It seems the sparse annotations are messed up.  Working on it...

-Stafford

>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:225:22: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
>    include/asm-generic/io.h:225:22: sparse:     expected unsigned int [usertype] value
>    include/asm-generic/io.h:225:22: sparse:     got restricted __le32 [usertype]
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
>    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> 
> vim +61 drivers/soc/litex/litex_soc_ctrl.c
> 
>     32	
>     33	/*
>     34	 * LiteX SoC Generator, depending on the configuration,
>     35	 * can split a single logical CSR (Control & Status Register)
>     36	 * into a series of consecutive physical registers.
>     37	 *
>     38	 * For example, in the configuration with 8-bit CSR Bus,
>     39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
>     40	 * logical CSR will be generated as four 32-bit physical registers,
>     41	 * each one containing one byte of meaningful data.
>     42	 *
>     43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
>     44	 *
>     45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
>     46	 * the logic of writing to/reading from the LiteX CSR in a single
>     47	 * place that can be then reused by all LiteX drivers.
>     48	 */
>     49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
>     50			    unsigned long val)
>     51	{
>     52		unsigned long shifted_data, shift, i;
>     53		unsigned long flags;
>     54	
>     55		spin_lock_irqsave(&csr_lock, flags);
>     56	
>     57		for (i = 0; i < reg_size; ++i) {
>     58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
>     59			shifted_data = val >> shift;
>     60	
>   > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
>     62		}
>     63	
>     64		spin_unlock_irqrestore(&csr_lock, flags);
>     65	}
>     66	EXPORT_SYMBOL_GPL(litex_set_reg);
>     67	
>     68	unsigned long litex_get_reg(void __iomem *reg, unsigned long reg_size)
>     69	{
>     70		unsigned long shifted_data, shift, i;
>     71		unsigned long result = 0;
>     72		unsigned long flags;
>     73	
>     74		spin_lock_irqsave(&csr_lock, flags);
>     75	
>     76		for (i = 0; i < reg_size; ++i) {
>   > 77			shifted_data = le32_to_cpu(readl(reg + (LITEX_REG_SIZE * i)));
>     78	
>     79			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
>     80			result |= (shifted_data << shift);
>     81		}
>     82	
>     83		spin_unlock_irqrestore(&csr_lock, flags);
>     84	
>     85		return result;
>     86	}
>     87	EXPORT_SYMBOL_GPL(litex_get_reg);
>     88	
> 
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org



^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
  2020-07-25 10:29   ` kernel test robot
@ 2020-07-26 18:36   ` kernel test robot
  2020-07-28  5:48   ` kernel test robot
  2020-08-03  5:26   ` kernel test robot
  3 siblings, 0 replies; 12+ messages in thread
From: kernel test robot @ 2020-07-26 18:36 UTC (permalink / raw)
  To: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial
  Cc: kbuild-all, Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab


[-- Attachment #1: Type: text/plain, Size: 4238 bytes --]

Hi Mateusz,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on robh/for-next]
[also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8-rc6 next-20200724]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: arc-randconfig-s032-20200726 (attached as .config)
compiler: arc-elf-gcc (GCC) 9.3.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # apt-get install sparse
        # sparse version: v0.6.2-93-g4c6cbe55-dirty
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=arc 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>


sparse warnings: (new ones prefixed by >>)

>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: cast from restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] val @@     got restricted __le32 [usertype] @@
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse:     expected unsigned int [usertype] val
   drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse:     got restricted __le32 [usertype]
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: cast from restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: cast from restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: cast from restricted __le32
>> drivers/soc/litex/litex_soc_ctrl.c:61:17: sparse: sparse: cast from restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32

vim +61 drivers/soc/litex/litex_soc_ctrl.c

    32	
    33	/*
    34	 * LiteX SoC Generator, depending on the configuration,
    35	 * can split a single logical CSR (Control & Status Register)
    36	 * into a series of consecutive physical registers.
    37	 *
    38	 * For example, in the configuration with 8-bit CSR Bus,
    39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
    40	 * logical CSR will be generated as four 32-bit physical registers,
    41	 * each one containing one byte of meaningful data.
    42	 *
    43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
    44	 *
    45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
    46	 * the logic of writing to/reading from the LiteX CSR in a single
    47	 * place that can be then reused by all LiteX drivers.
    48	 */
    49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
    50			    unsigned long val)
    51	{
    52		unsigned long shifted_data, shift, i;
    53		unsigned long flags;
    54	
    55		spin_lock_irqsave(&csr_lock, flags);
    56	
    57		for (i = 0; i < reg_size; ++i) {
    58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
    59			shifted_data = val >> shift;
    60	
  > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
    62		}
    63	
    64		spin_unlock_irqrestore(&csr_lock, flags);
    65	}
    66	EXPORT_SYMBOL_GPL(litex_set_reg);
    67	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 32064 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-25 21:14     ` Stafford Horne
@ 2020-07-26 23:36       ` Stafford Horne
  0 siblings, 0 replies; 12+ messages in thread
From: Stafford Horne @ 2020-07-26 23:36 UTC (permalink / raw)
  To: kernel test robot
  Cc: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial, kbuild-all, Karol Gugala,
	Mauro Carvalho Chehab

Hi Mateusz,

There may be a problem here, see below.

On Sun, Jul 26, 2020 at 06:14:16AM +0900, Stafford Horne wrote:
> On Sat, Jul 25, 2020 at 06:29:51PM +0800, kernel test robot wrote:
> > Hi Mateusz,
> > 
> > Thank you for the patch! Perhaps something to improve:
> > 
> > [auto build test WARNING on robh/for-next]
> > [also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8-rc6 next-20200724]
> > [If your patch is applied to the wrong git tree, kindly drop us a note.
> > And when submitting patch, we suggest to use '--base' as documented in
> > https://git-scm.com/docs/git-format-patch]
> > 
> > url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
> > base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
> > config: openrisc-randconfig-s032-20200725 (attached as .config)
> > compiler: or1k-linux-gcc (GCC) 9.3.0
> > reproduce:
> >         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
> >         chmod +x ~/bin/make.cross
> >         # apt-get install sparse
> >         # sparse version: v0.6.2-93-g4c6cbe55-dirty
> >         # save the attached .config to linux build tree
> >         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=openrisc 
> 
> Note, this is OpenRISC
> 
> > If you fix the issue, kindly add following tag as appropriate
> > Reported-by: kernel test robot <lkp@intel.com>
> > 
> > 
> > sparse warnings: (new ones prefixed by >>)
> > 
> > >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
> > >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     expected unsigned int [usertype] value
> > >> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     got restricted __le32 [usertype]
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> > >> drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
> >    drivers/soc/litex/litex_soc_ctrl.c: note: in included file (through arch/openrisc/include/asm/io.h, include/linux/io.h, include/linux/litex.h):
> 
> I think this is something I need to fix up in the openrisc io.h header.

There are issues with the openrisc io.h header, but after closer inspection the
new warnings above do not seem to be related to this.  See more notes below.

> It seems the sparse annotations are messed up.  Working on it...
> 
> -Stafford
> 
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:225:22: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] value @@     got restricted __le32 [usertype] @@
> >    include/asm-generic/io.h:225:22: sparse:     expected unsigned int [usertype] value
> >    include/asm-generic/io.h:225:22: sparse:     got restricted __le32 [usertype]
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> >    include/asm-generic/io.h:179:15: sparse: sparse: cast to restricted __le32
> > 
> > vim +61 drivers/soc/litex/litex_soc_ctrl.c
> > 
> >     32	
> >     33	/*
> >     34	 * LiteX SoC Generator, depending on the configuration,
> >     35	 * can split a single logical CSR (Control & Status Register)
> >     36	 * into a series of consecutive physical registers.
> >     37	 *
> >     38	 * For example, in the configuration with 8-bit CSR Bus,
> >     39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
> >     40	 * logical CSR will be generated as four 32-bit physical registers,
> >     41	 * each one containing one byte of meaningful data.
> >     42	 *
> >     43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
> >     44	 *
> >     45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
> >     46	 * the logic of writing to/reading from the LiteX CSR in a single
> >     47	 * place that can be then reused by all LiteX drivers.
> >     48	 */
> >     49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
> >     50			    unsigned long val)
> >     51	{
> >     52		unsigned long shifted_data, shift, i;
> >     53		unsigned long flags;
> >     54	
> >     55		spin_lock_irqsave(&csr_lock, flags);
> >     56	
> >     57		for (i = 0; i < reg_size; ++i) {
> >     58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
> >     59			shifted_data = val >> shift;
> >     60	
> >   > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));

writel is defined to expect cpu endian u32 and it will internally convert it to
le32.  There shouldbe no need for cpu_to_le32.  This is from asm-generic/io.h
used by openrisc:

   #ifndef writel
   #define writel writel
   static inline void writel(u32 value, volatile void __iomem *addr)
   {
   	__io_bw();
   	__raw_writel(__cpu_to_le32(value), addr);
   	__io_aw();
   }
   #endif

The call to cpu_to_le32() is what is causing the sparse warnings above.

> >     62		}
> >     63	
> >     64		spin_unlock_irqrestore(&csr_lock, flags);
> >     65	}
> >     66	EXPORT_SYMBOL_GPL(litex_set_reg);
> >     67	
> >     68	unsigned long litex_get_reg(void __iomem *reg, unsigned long reg_size)
> >     69	{
> >     70		unsigned long shifted_data, shift, i;
> >     71		unsigned long result = 0;
> >     72		unsigned long flags;
> >     73	
> >     74		spin_lock_irqsave(&csr_lock, flags);
> >     75	
> >     76		for (i = 0; i < reg_size; ++i) {
> >   > 77			shifted_data = le32_to_cpu(readl(reg + (LITEX_REG_SIZE * i)));

Same issue here, readl is already returning cpu endian u32.  No need to convert it
to cpu.

    #ifndef readl
    #define readl readl
    static inline u32 readl(const volatile void __iomem *addr)
    {
    	u32 val;

    	__io_br();
    	val = __le32_to_cpu((__le32 __force) __raw_readl(addr));
    	__io_ar(val);
    	return val;
    }
    #endif

Note, of LE machines like riscv the le32_to_cpu and le32_to_cpu will be no-ops
so this will not cause issues.  But likely this is broken on OpenRISC.  I have
not run these drivers for a while.

-Stafford

> >     78	
> >     79			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
> >     80			result |= (shifted_data << shift);
> >     81		}
> >     82	
> >     83		spin_unlock_irqrestore(&csr_lock, flags);
> >     84	
> >     85		return result;
> >     86	}
> >     87	EXPORT_SYMBOL_GPL(litex_get_reg);
> >     88	
> > 
> > ---
> > 0-DAY CI Kernel Test Service, Intel Corporation
> > https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
> 
> 

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
  2020-07-25 10:29   ` kernel test robot
  2020-07-26 18:36   ` kernel test robot
@ 2020-07-28  5:48   ` kernel test robot
  2020-08-03  5:26   ` kernel test robot
  3 siblings, 0 replies; 12+ messages in thread
From: kernel test robot @ 2020-07-28  5:48 UTC (permalink / raw)
  To: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial
  Cc: kbuild-all, Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab


[-- Attachment #1: Type: text/plain, Size: 3803 bytes --]

Hi Mateusz,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on robh/for-next]
[also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8-rc7 next-20200727]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: sparc64-randconfig-s031-20200728 (attached as .config)
compiler: sparc64-linux-gcc (GCC) 9.3.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # apt-get install sparse
        # sparse version: v0.6.2-94-geb6779f6-dirty
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=sparc64 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>


sparse warnings: (new ones prefixed by >>)

>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int [usertype] l @@     got restricted __le32 [usertype] @@
>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     expected unsigned int [usertype] l
   drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     got restricted __le32 [usertype]
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32

vim +61 drivers/soc/litex/litex_soc_ctrl.c

    32	
    33	/*
    34	 * LiteX SoC Generator, depending on the configuration,
    35	 * can split a single logical CSR (Control & Status Register)
    36	 * into a series of consecutive physical registers.
    37	 *
    38	 * For example, in the configuration with 8-bit CSR Bus,
    39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
    40	 * logical CSR will be generated as four 32-bit physical registers,
    41	 * each one containing one byte of meaningful data.
    42	 *
    43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
    44	 *
    45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
    46	 * the logic of writing to/reading from the LiteX CSR in a single
    47	 * place that can be then reused by all LiteX drivers.
    48	 */
    49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
    50			    unsigned long val)
    51	{
    52		unsigned long shifted_data, shift, i;
    53		unsigned long flags;
    54	
    55		spin_lock_irqsave(&csr_lock, flags);
    56	
    57		for (i = 0; i < reg_size; ++i) {
    58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
    59			shifted_data = val >> shift;
    60	
  > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
    62		}
    63	
    64		spin_unlock_irqrestore(&csr_lock, flags);
    65	}
    66	EXPORT_SYMBOL_GPL(litex_set_reg);
    67	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 26460 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread

* Re: [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver
  2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
                     ` (2 preceding siblings ...)
  2020-07-28  5:48   ` kernel test robot
@ 2020-08-03  5:26   ` kernel test robot
  3 siblings, 0 replies; 12+ messages in thread
From: kernel test robot @ 2020-08-03  5:26 UTC (permalink / raw)
  To: Mateusz Holenko, Rob Herring, Mark Rutland, Greg Kroah-Hartman,
	Jiri Slaby, devicetree, linux-serial
  Cc: kbuild-all, Stafford Horne, Karol Gugala, Mateusz Holenko,
	Mauro Carvalho Chehab


[-- Attachment #1: Type: text/plain, Size: 3147 bytes --]

Hi Mateusz,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on robh/for-next]
[also build test WARNING on tty/tty-testing usb/usb-testing staging/staging-testing driver-core/driver-core-testing linus/master v5.8 next-20200731]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Mateusz-Holenko/LiteX-SoC-controller-and-LiteUART-serial-driver/20200722-183024
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: i386-randconfig-s032-20200803 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-14) 9.3.0
reproduce:
        # apt-get install sparse
        # sparse version: v0.6.2-117-g8c7aee71-dirty
        # save the attached .config to linux build tree
        make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=i386 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>


sparse warnings: (new ones prefixed by >>)

>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse: sparse: incorrect type in argument 1 (different base types) @@     expected unsigned int val @@     got restricted __le32 [usertype] @@
>> drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     expected unsigned int val
   drivers/soc/litex/litex_soc_ctrl.c:61:24: sparse:     got restricted __le32 [usertype]
   drivers/soc/litex/litex_soc_ctrl.c:77:32: sparse: sparse: cast to restricted __le32

vim +61 drivers/soc/litex/litex_soc_ctrl.c

    32	
    33	/*
    34	 * LiteX SoC Generator, depending on the configuration,
    35	 * can split a single logical CSR (Control & Status Register)
    36	 * into a series of consecutive physical registers.
    37	 *
    38	 * For example, in the configuration with 8-bit CSR Bus,
    39	 * 32-bit aligned (the default one for 32-bit CPUs) a 32-bit
    40	 * logical CSR will be generated as four 32-bit physical registers,
    41	 * each one containing one byte of meaningful data.
    42	 *
    43	 * For details see: https://github.com/enjoy-digital/litex/wiki/CSR-Bus
    44	 *
    45	 * The purpose of `litex_set_reg`/`litex_get_reg` is to implement
    46	 * the logic of writing to/reading from the LiteX CSR in a single
    47	 * place that can be then reused by all LiteX drivers.
    48	 */
    49	void litex_set_reg(void __iomem *reg, unsigned long reg_size,
    50			    unsigned long val)
    51	{
    52		unsigned long shifted_data, shift, i;
    53		unsigned long flags;
    54	
    55		spin_lock_irqsave(&csr_lock, flags);
    56	
    57		for (i = 0; i < reg_size; ++i) {
    58			shift = ((reg_size - i - 1) * LITEX_SUBREG_SIZE_BIT);
    59			shifted_data = val >> shift;
    60	
  > 61			writel(cpu_to_le32(shifted_data), reg + (LITEX_REG_SIZE * i));
    62		}
    63	
    64		spin_unlock_irqrestore(&csr_lock, flags);
    65	}
    66	EXPORT_SYMBOL_GPL(litex_set_reg);
    67	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 34356 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread

end of thread, back to index

Thread overview: 12+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-07-22 10:27 [PATCH v9 0/5] LiteX SoC controller and LiteUART serial driver Mateusz Holenko
2020-07-22 10:27 ` [PATCH v9 1/5] dt-bindings: vendor: add vendor prefix for LiteX Mateusz Holenko
2020-07-22 10:27 ` [PATCH v9 2/5] dt-bindings: soc: document LiteX SoC Controller bindings Mateusz Holenko
2020-07-22 10:28 ` [PATCH v9 3/5] drivers/soc/litex: add LiteX SoC Controller driver Mateusz Holenko
2020-07-25 10:29   ` kernel test robot
2020-07-25 21:14     ` Stafford Horne
2020-07-26 23:36       ` Stafford Horne
2020-07-26 18:36   ` kernel test robot
2020-07-28  5:48   ` kernel test robot
2020-08-03  5:26   ` kernel test robot
2020-07-22 10:28 ` [PATCH v9 4/5] dt-bindings: serial: document LiteUART bindings Mateusz Holenko
2020-07-22 10:28 ` [PATCH v9 5/5] drivers/tty/serial: add LiteUART driver Mateusz Holenko

Linux-Serial Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-serial/0 linux-serial/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-serial linux-serial/ https://lore.kernel.org/linux-serial \
		linux-serial@vger.kernel.org
	public-inbox-index linux-serial

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-serial


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git