* [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller
@ 2026-11-20 8:08 zelong dong
2026-11-20 8:08 ` [PATCH 1/3] dt-bindings: net: can: add Amlogic A9 CAN controller zelong dong
` (4 more replies)
0 siblings, 5 replies; 6+ messages in thread
From: zelong dong @ 2026-11-20 8:08 UTC (permalink / raw)
To: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Marc Kleine-Budde, Vincent Mailhol
Cc: linux-kernel, linux-amlogic, linux-arm-kernel, devicetree,
linux-can, Zelong Dong
From: Zelong Dong <zelong.dong@amlogic.com>
This series adds support for the CAN-FD controller found on the
Amlogic A9 SoC family.
The controller supports classic CAN and CAN-FD. The
driver uses the generic RX offload infrastructure with hardware
timestamps, reports bus errors through the CAN berr counter, and
implements suspend/resume support.
Zelong Dong (3):
dt-bindings: net: can: add Amlogic A9 CAN controller
can: amlogic: add driver for Amlogic A9 CAN-FD controller
arm64: dts: amlogic: a9: add CAN controller node
.../bindings/net/can/amlogic,a9-can.yaml | 65 ++
.../dts/amlogic/amlogic-a9-a311y3-by401.dts | 7 +
arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi | 25 +
drivers/net/can/Kconfig | 1 +
drivers/net/can/Makefile | 1 +
drivers/net/can/amlogic/Kconfig | 9 +
drivers/net/can/amlogic/Makefile | 3 +
drivers/net/can/amlogic/amlogic_can.c | 864 ++++++++++++++++++
drivers/net/can/amlogic/amlogic_can.h | 367 ++++++++
9 files changed, 1342 insertions(+)
create mode 100644 Documentation/devicetree/bindings/net/can/amlogic,a9-can.yaml
create mode 100644 drivers/net/can/amlogic/Kconfig
create mode 100644 drivers/net/can/amlogic/Makefile
create mode 100644 drivers/net/can/amlogic/amlogic_can.c
create mode 100644 drivers/net/can/amlogic/amlogic_can.h
--
2.47.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/3] dt-bindings: net: can: add Amlogic A9 CAN controller
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
@ 2026-11-20 8:08 ` zelong dong
2026-11-20 8:08 ` [PATCH 2/3] can: amlogic: add driver for Amlogic A9 CAN-FD controller zelong dong
` (3 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: zelong dong @ 2026-11-20 8:08 UTC (permalink / raw)
To: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Marc Kleine-Budde, Vincent Mailhol
Cc: linux-kernel, linux-amlogic, linux-arm-kernel, devicetree,
linux-can, Zelong Dong
From: Zelong Dong <zelong.dong@amlogic.com>
Add device tree bindings for the CAN-FD controller found on the
Amlogic A9 SoC family.
Signed-off-by: Zelong Dong <zelong.dong@amlogic.com>
---
.../bindings/net/can/amlogic,a9-can.yaml | 65 +++++++++++++++++++
1 file changed, 65 insertions(+)
create mode 100644 Documentation/devicetree/bindings/net/can/amlogic,a9-can.yaml
diff --git a/Documentation/devicetree/bindings/net/can/amlogic,a9-can.yaml b/Documentation/devicetree/bindings/net/can/amlogic,a9-can.yaml
new file mode 100644
index 000000000000..dd4ad6147f2e
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/can/amlogic,a9-can.yaml
@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+# # Copyright (C) 2026 Amlogic, Inc. All rights reserved
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/net/can/amlogic,a9-can.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Amlogic A9 SoC CANBus Controller
+
+maintainers:
+ - Zelong Dong <zelong.dong@amlogic.com>
+
+properties:
+ compatible:
+ const: amlogic,a9-can
+
+ reg:
+ maxItems: 1
+
+ interrupts:
+ maxItems: 1
+
+ clocks:
+ items:
+ - description: CAN protocol engine clock
+ - description: CAN filter clock
+
+ clock-names:
+ items:
+ - const: can_pe
+ - const: can_filter
+
+ power-domains:
+ maxItems: 1
+
+required:
+ - compatible
+ - reg
+ - interrupts
+ - clocks
+ - clock-names
+
+allOf:
+ - $ref: can-controller.yaml#
+
+unevaluatedProperties: false
+
+examples:
+ - |
+ #include <dt-bindings/interrupt-controller/arm-gic.h>
+
+ bus {
+ #address-cells = <2>;
+ #size-cells = <2>;
+
+ can@3a8000 {
+ compatible = "amlogic,a9-can";
+ reg = <0x0 0x3a8000 0x0 0x383c>;
+ interrupts = <GIC_SPI 82 IRQ_TYPE_EDGE_RISING>;
+ clocks = <&clkc_periphs 0>,
+ <&clkc_periphs 1>;
+ clock-names = "can_pe", "can_filter";
+ power-domains = <&pwrc 2>;
+ };
+ };
--
2.47.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 2/3] can: amlogic: add driver for Amlogic A9 CAN-FD controller
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
2026-11-20 8:08 ` [PATCH 1/3] dt-bindings: net: can: add Amlogic A9 CAN controller zelong dong
@ 2026-11-20 8:08 ` zelong dong
2026-11-20 8:08 ` [PATCH 3/3] arm64: dts: amlogic: a9: add CAN controller node zelong dong
` (2 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: zelong dong @ 2026-11-20 8:08 UTC (permalink / raw)
To: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Marc Kleine-Budde, Vincent Mailhol
Cc: linux-kernel, linux-amlogic, linux-arm-kernel, devicetree,
linux-can, Zelong Dong
From: Zelong Dong <zelong.dong@amlogic.com>
Add a driver for the CAN-FD controller found on the Amlogic A9 SoC
family. The controller supports both classic CAN and CAN-FD.
The driver uses the generic RX offload infrastructure with hardware
timestamps, reports bus errors through the CAN berr counter, and
implements suspend/resume support.
Signed-off-by: Zelong Dong <zelong.dong@amlogic.com>
---
drivers/net/can/Kconfig | 1 +
drivers/net/can/Makefile | 1 +
drivers/net/can/amlogic/Kconfig | 9 +
drivers/net/can/amlogic/Makefile | 3 +
drivers/net/can/amlogic/amlogic_can.c | 864 ++++++++++++++++++++++++++
drivers/net/can/amlogic/amlogic_can.h | 367 +++++++++++
6 files changed, 1245 insertions(+)
create mode 100644 drivers/net/can/amlogic/Kconfig
create mode 100644 drivers/net/can/amlogic/Makefile
create mode 100644 drivers/net/can/amlogic/amlogic_can.c
create mode 100644 drivers/net/can/amlogic/amlogic_can.h
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index a8fad6fe5302..fbd7523f38a4 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -257,6 +257,7 @@ source "drivers/net/can/sja1000/Kconfig"
source "drivers/net/can/softing/Kconfig"
source "drivers/net/can/spi/Kconfig"
source "drivers/net/can/usb/Kconfig"
+source "drivers/net/can/amlogic/Kconfig"
endif #CAN_NETLINK
diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
index 4010d17f8583..a5cec506bab4 100644
--- a/drivers/net/can/Makefile
+++ b/drivers/net/can/Makefile
@@ -35,5 +35,6 @@ obj-$(CONFIG_CAN_SUN4I) += sun4i_can.o
obj-$(CONFIG_CAN_TI_HECC) += ti_hecc.o
obj-$(CONFIG_CAN_VIRTIO_CAN) += virtio_can.o
obj-$(CONFIG_CAN_XILINXCAN) += xilinx_can.o
+obj-$(CONFIG_CAN_AMLOGIC) += amlogic/
subdir-ccflags-$(CONFIG_CAN_DEBUG_DEVICES) += -DDEBUG
diff --git a/drivers/net/can/amlogic/Kconfig b/drivers/net/can/amlogic/Kconfig
new file mode 100644
index 000000000000..52e5298061f1
--- /dev/null
+++ b/drivers/net/can/amlogic/Kconfig
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR MIT)
+
+config CAN_AMLOGIC
+ tristate "Amlogic CANBUS Controller"
+ select CAN_RX_OFFLOAD
+ default n
+ help
+ Say Y here if you want to use Amlogic CANBUS Controller.
+
diff --git a/drivers/net/can/amlogic/Makefile b/drivers/net/can/amlogic/Makefile
new file mode 100644
index 000000000000..20a0b33b3098
--- /dev/null
+++ b/drivers/net/can/amlogic/Makefile
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR MIT)
+
+obj-$(CONFIG_CAN_AMLOGIC) += amlogic_can.o
diff --git a/drivers/net/can/amlogic/amlogic_can.c b/drivers/net/can/amlogic/amlogic_can.c
new file mode 100644
index 000000000000..261544721e72
--- /dev/null
+++ b/drivers/net/can/amlogic/amlogic_can.c
@@ -0,0 +1,864 @@
+// SPDX-License-Identifier: (GPL-2.0-only OR MIT)
+/*
+ * Copyright (C) 2026 Amlogic, Inc. All rights reserved
+ */
+#include <linux/bitfield.h>
+#include <linux/can.h>
+#include <linux/can/dev.h>
+#include <linux/can/error.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/property.h>
+#include <linux/regmap.h>
+#include <linux/pinctrl/consumer.h>
+
+#include "amlogic_can.h"
+
+static const struct regmap_config aml_can_regmap_config = {
+ .name = "amlogic_can",
+ .reg_bits = 32,
+ .val_bits = 32,
+ .reg_stride = 4,
+ .max_register = 0x3838,
+};
+
+static const struct can_bittiming_const aml_can_fd_bittiming_const = {
+ .name = "amlogic_fd",
+ .tseg1_min = 2,
+ .tseg1_max = 96,
+ .tseg2_min = 2,
+ .tseg2_max = 32,
+ .sjw_max = 16,
+ .brp_min = 1,
+ .brp_max = 1024,
+ .brp_inc = 1,
+};
+
+static const struct can_bittiming_const aml_can_fd_data_bittiming_const = {
+ .name = "amlogic_fd_data",
+ .tseg1_min = 2,
+ .tseg1_max = 39,
+ .tseg2_min = 2,
+ .tseg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 1024,
+ .brp_inc = 1,
+};
+
+static int aml_can_flag_wait(struct aml_can_priv *priv, u32 addr, u32 flag,
+ u32 flag_val, int timeout_us)
+{
+ int timeout = timeout_us / 10;
+ u32 val;
+
+ do {
+ usleep_range(10, 15);
+ regmap_read(priv->reg, addr, &val);
+ } while (timeout-- && ((val & flag) != flag_val));
+
+ if (timeout < 0)
+ return -ETIMEDOUT;
+ return 0;
+}
+
+static inline int aml_can_low_power_mode_wait(struct aml_can_priv *priv,
+ bool enter)
+{
+ /* wait to enter/exit low power mode ack */
+ return aml_can_flag_wait(priv, CAN_MCR, CAN_MCR_LPMACK,
+ enter ? CAN_MCR_LPMACK : 0, 250);
+}
+
+static int aml_can_module_enable(struct aml_can_priv *priv, bool enable)
+{
+ regmap_update_bits(priv->reg, CAN_MCR, CAN_MCR_MDIS,
+ enable ? 0 : CAN_MCR_MDIS);
+
+ return aml_can_low_power_mode_wait(priv, !enable);
+}
+
+static int aml_can_freeze_mode_enable(struct aml_can_priv *priv, bool enable)
+{
+ unsigned int timeout = 250;
+ u32 bitrate = priv->can.bittiming.bitrate;
+
+ if (enable) {
+ if (bitrate)
+ timeout = 1000 * 1000 / bitrate * 10;
+
+ regmap_update_bits(priv->reg, CAN_MCR, CAN_MCR_FRZ,
+ CAN_MCR_FRZ);
+ }
+
+ regmap_update_bits(priv->reg, CAN_MCR, CAN_MCR_HALT,
+ enable ? CAN_MCR_HALT : 0);
+
+ /* wait to enter/exit freeze mode flag */
+ return aml_can_flag_wait(priv, CAN_MCR, CAN_MCR_FRZACK,
+ enable ? CAN_MCR_FRZACK : 0, timeout);
+}
+
+static void aml_can_interrupts_enable(struct aml_can_priv *priv, bool enable)
+{
+ regmap_update_bits(priv->reg, CAN_CTRL1, CAN_CTRL1_ERR_ALL,
+ enable ? CAN_CTRL1_ERR_ALL : 0);
+ regmap_write(priv->reg, CAN_IMASK1, enable ? BIT(0) : 0);
+ regmap_write(priv->reg, CAN_IMASK2, enable ? BIT(0) : 0);
+}
+
+static inline int aml_can_soft_reset(struct aml_can_priv *priv)
+{
+ regmap_update_bits(priv->reg, CAN_MCR, CAN_MCR_SOFTRST,
+ CAN_MCR_SOFTRST);
+
+ /* wait to enter/exit freeze mode flag */
+ return aml_can_flag_wait(priv, CAN_MCR, CAN_MCR_SOFTRST, 0, 250);
+}
+
+static void aml_can_set_bittiming_ctrl(struct aml_can_priv *priv)
+{
+ struct can_bittiming *bt = &priv->can.bittiming;
+ struct can_bittiming *dbt = &priv->can.fd.data_bittiming;
+ u32 val;
+
+ if (!(priv->can.ctrlmode_supported & CAN_CTRLMODE_FD)) {
+ val = FIELD_PREP(CAN_CTRL1_PRESDIV, bt->brp - 1) |
+ FIELD_PREP(CAN_CTRL1_RJW, bt->sjw - 1) |
+ FIELD_PREP(CAN_CTRL1_PSEG1, bt->phase_seg1 - 1) |
+ FIELD_PREP(CAN_CTRL1_PSEG2, bt->phase_seg2 - 1) |
+ FIELD_PREP(CAN_CTRL1_PROPSEG, bt->prop_seg - 1);
+
+ regmap_update_bits(priv->reg, CAN_CTRL1, CAN_CTRL1_CBT, val);
+
+ return;
+ }
+
+ if (bt->phase_seg1 > 0x20) {
+ bt->prop_seg += (bt->phase_seg1 - 0x20);
+ bt->phase_seg1 = 0x20;
+ }
+
+ val = FIELD_PREP(CAN_CBT_EPRESDIV, bt->brp - 1) |
+ FIELD_PREP(CAN_CBT_ERJW, bt->sjw - 1) |
+ FIELD_PREP(CAN_CBT_EPSEG1, bt->phase_seg1 - 1) |
+ FIELD_PREP(CAN_CBT_EPSEG2, bt->phase_seg2 - 1) |
+ FIELD_PREP(CAN_CBT_EPROPSEG, bt->prop_seg - 1);
+
+ regmap_update_bits(priv->reg, CAN_CBT, CAN_CBT_CBT | CAN_CBT_BTF,
+ val | CAN_CBT_BTF);
+
+ if (dbt->phase_seg1 > 0x8) {
+ dbt->prop_seg += (dbt->phase_seg1 - 0x8);
+ dbt->phase_seg1 = 0x8;
+ }
+
+ val = FIELD_PREP(CAN_FDCBT_FPRESDIV, dbt->brp - 1) |
+ FIELD_PREP(CAN_FDCBT_FRJW, dbt->sjw - 1) |
+ FIELD_PREP(CAN_FDCBT_FPSEG1, dbt->phase_seg1 - 1) |
+ FIELD_PREP(CAN_FDCBT_FPSEG2, dbt->phase_seg2 - 1) |
+ FIELD_PREP(CAN_FDCBT_FPROPSEG, dbt->prop_seg);
+
+ regmap_update_bits(priv->reg, CAN_FDCBT, CAN_FDCBT_CBT, val);
+
+ val = CAN_FDCTRL_TDCEN | CAN_FDCTRL_FDRATE |
+ FIELD_PREP(CAN_FDCTRL_MBDSR3, CAN_FDCTRL_MBDSR_64) |
+ FIELD_PREP(CAN_FDCTRL_MBDSR2, CAN_FDCTRL_MBDSR_64) |
+ FIELD_PREP(CAN_FDCTRL_MBDSR1, CAN_FDCTRL_MBDSR_64) |
+ FIELD_PREP(CAN_FDCTRL_MBDSR0, CAN_FDCTRL_MBDSR_64) |
+ FIELD_PREP(CAN_FDCTRL_TDCOFF, ((dbt->phase_seg1 - 1) +
+ dbt->prop_seg + 2) *
+ ((dbt->brp - 1) + 1));
+ regmap_update_bits(priv->reg, CAN_FDCTRL, CAN_FDCTRL_TDCEN |
+ CAN_FDCTRL_FDRATE | CAN_FDCTRL_TDCOFF |
+ CAN_FDCTRL_MBDSR3 | CAN_FDCTRL_MBDSR2 |
+ CAN_FDCTRL_MBDSR1 | CAN_FDCTRL_MBDSR0, val);
+}
+
+static void aml_can_top_init(struct aml_can_priv *priv)
+{
+ u32 val;
+
+ val = CAN_TMTIK_CFG_TS_HIGH | CAN_TMTIK_CFG_TS_LOW |
+ FIELD_PREP(CAN_TMTIK_CFG_TICK_VALUE, 10);
+
+ regmap_update_bits(priv->reg, CAN_TMTIK_CFG,
+ val | CAN_TMTIK_CFG_TICK_VALUE, val);
+
+ val = CAN_TOP_CTRL_GLITCH_FILTER_EN |
+ FIELD_PREP(CAN_TOP_CTRL_GLITCH_FILTER_SEL, 2);
+
+ regmap_update_bits(priv->reg, CAN_TOP_CTRL,
+ val | CAN_TOP_CTRL_GLITCH_FILTER_SEL, val);
+}
+
+static void aml_can_ram_init(struct aml_can_priv *priv)
+{
+ int i, j;
+
+ for (i = 0; i < AML_CAN_MB_NUM; i++)
+ for (j = 0; j < 0x10; j += 4)
+ regmap_write(priv->reg, CAN_MB + i * 0x10 + j, 0);
+
+ for (i = 0; i < AML_CAN_MB_NUM; i++)
+ regmap_write(priv->reg, CAN_RXIMR(i), 0);
+
+ for (i = 0; i < AML_CAN_MB_NUM; i++)
+ regmap_write(priv->reg, CAN_HR_TIME_STAMP(i), 0);
+
+ for (i = 0; i < AML_CAN_ERX_FIFO_NUM; i++)
+ for (j = 0; j < 20; j++)
+ regmap_write(priv->reg,
+ CAN_ENHANCE_RX_FIFO(j) + i * 0x50, 0);
+
+ for (i = 0; i < AML_CAN_MB_NUM; i++)
+ regmap_write(priv->reg, CAN_ERFFEL(i), 0);
+
+ regmap_write(priv->reg, CAN_RXMGMASK, 0);
+ regmap_write(priv->reg, CAN_RX14MASK, 0);
+ regmap_write(priv->reg, CAN_RX15MASK, 0);
+ regmap_write(priv->reg, CAN_RXFGMASK, 0);
+
+ for (i = 0xa80; i < 0xa98; i += 4)
+ regmap_write(priv->reg, i, 0);
+ for (i = 0xab0; i < 0xae0; i += 4)
+ regmap_write(priv->reg, i, 0);
+ for (i = 0xc20; i <= 0xc24; i += 4)
+ regmap_write(priv->reg, i, 0);
+ for (i = 0xf28; i < 0x1000; i += 4)
+ regmap_write(priv->reg, i, 0);
+}
+
+static int aml_can_chip_start(struct aml_can_priv *priv)
+{
+ int ret;
+ u32 val;
+
+ ret = aml_can_module_enable(priv, true);
+ if (ret)
+ return ret;
+
+ ret = aml_can_soft_reset(priv);
+ if (ret)
+ goto err_chip_start;
+
+ ret = aml_can_freeze_mode_enable(priv, true);
+ if (ret)
+ goto err_chip_start;
+
+ val = CAN_MCR_WRNEN | CAN_MCR_WAKSRC | CAN_MCR_IRMQ |
+ CAN_MCR_SRXDIS | CAN_MCR_AEN | CAN_MCR_FDEN |
+ FIELD_PREP(CAN_MCR_IDAM, 2) | FIELD_PREP(CAN_MCR_MAXMB, 1);
+
+ regmap_update_bits(priv->reg, CAN_MCR,
+ val | CAN_MCR_IDAM | CAN_MCR_MAXMB, val);
+
+ val = CAN_CTRL1_BOFFREC | CAN_CTRL1_LBUF | CAN_CTRL1_ERR_STATE |
+ CAN_CTRL1_ERRMSK;
+
+ regmap_update_bits(priv->reg, CAN_CTRL1, val, val);
+
+ val = CAN_CTRL2_ERRMSK_FAST | CAN_CTRL2_ECRWRE | CAN_CTRL2_WRMFRZ |
+ FIELD_PREP(CAN_CTRL2_RFFN, 11) | CAN_CTRL2_RRS;
+
+ if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO))
+ val |= CAN_CTRL2_ISOCANFDEN;
+
+ regmap_update_bits(priv->reg, CAN_CTRL2, val | CAN_CTRL2_RFFN, val);
+
+ aml_can_ram_init(priv);
+ aml_can_set_bittiming_ctrl(priv);
+
+ val = CAN_ERFCR_ERFEN |
+ FIELD_PREP(CAN_ERFCR_NEXIF, 2) | FIELD_PREP(CAN_ERFCR_NFE, 2) |
+ FIELD_PREP(CAN_ERFCR_ERFWM, AML_CAN_WATERMARK - 1);
+
+ regmap_update_bits(priv->reg, CAN_ERFCR, val | CAN_ERFCR_CFG, val);
+
+ val = CAN_ERFIER_ERFDAIE | CAN_ERFIER_ERFOVFIE | CAN_ERFIER_ERFWMIIE;
+
+ regmap_update_bits(priv->reg, CAN_ERFIER, val, val);
+
+ val = CAN_ERFSR_ERFUFW | CAN_ERFSR_ERFOVF | CAN_ERFSR_ERFWMI |
+ CAN_ERFSR_ERFDA | CAN_ERFSR_ERFCLR;
+
+ regmap_update_bits(priv->reg, CAN_ERFSR, val, val);
+
+ ret = aml_can_freeze_mode_enable(priv, false);
+ if (ret)
+ goto err_chip_start;
+
+ priv->can.state = CAN_STATE_ERROR_ACTIVE;
+
+ return 0;
+
+err_chip_start:
+ aml_can_module_enable(priv, false);
+ return ret;
+}
+
+static int aml_can_chip_stop(struct aml_can_priv *priv)
+{
+ int ret;
+
+ ret = aml_can_freeze_mode_enable(priv, true);
+ if (ret)
+ return ret;
+
+ ret = aml_can_module_enable(priv, false);
+ if (ret)
+ goto err_chip_stop;
+
+ priv->can.state = CAN_STATE_STOPPED;
+
+ return 0;
+
+err_chip_stop:
+ aml_can_freeze_mode_enable(priv, false);
+
+ return ret;
+}
+
+static void aml_can_report_state(struct aml_can_priv *priv, u32 state)
+{
+ struct sk_buff *skb;
+ struct can_frame *cf;
+ enum can_state new_state;
+ int ret;
+
+ switch (state & CAN_ESR1_FLTCONF) {
+ case CAN_ESR1_FLTCONF_ACTIVE:
+ if ((state & CAN_ESR1_TXWRN) || (state & CAN_ESR1_RXWRN))
+ new_state = CAN_STATE_ERROR_WARNING;
+ else
+ new_state = CAN_STATE_ERROR_ACTIVE;
+ break;
+ case CAN_ESR1_FLTCONF_PASSIVE:
+ new_state = CAN_STATE_ERROR_PASSIVE;
+ break;
+ default: //CAN_ESR1_FLTCONF_BUSOFF
+ new_state = CAN_STATE_BUS_OFF;
+ break;
+ }
+
+ if (likely(new_state == priv->can.state))
+ return;
+
+ dev_err(priv->dev, "can state change %d\n", new_state);
+
+ skb = alloc_can_err_skb(priv->ndev, &cf);
+ if (unlikely(!skb))
+ return;
+
+ can_change_state(priv->ndev, cf, new_state, new_state);
+
+ if (unlikely(new_state == CAN_STATE_BUS_OFF))
+ can_bus_off(priv->ndev);
+
+ ret = can_rx_offload_queue_tail(&priv->offload, skb);
+ if (ret)
+ priv->ndev->stats.rx_fifo_errors++;
+}
+
+static void aml_can_report_error(struct aml_can_priv *priv, u32 state)
+{
+ struct sk_buff *skb;
+ struct can_frame *cf;
+ bool rx_errors = false, tx_errors = false;
+ int ret;
+
+ skb = alloc_can_err_skb(priv->ndev, &cf);
+ if (unlikely(!skb))
+ return;
+
+ cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
+
+ if (state & CAN_ESR1_BIT1ERR) {
+ cf->data[2] |= CAN_ERR_PROT_BIT1;
+ tx_errors = true;
+ }
+ if (state & CAN_ESR1_BIT0ERR) {
+ cf->data[2] |= CAN_ERR_PROT_BIT0;
+ tx_errors = true;
+ }
+ if (state & CAN_ESR1_ACKERR) {
+ cf->can_id |= CAN_ERR_ACK;
+ cf->data[3] = CAN_ERR_PROT_LOC_ACK;
+ tx_errors = true;
+ }
+ if (state & CAN_ESR1_CRCERR) {
+ cf->data[2] |= CAN_ERR_PROT_BIT;
+ cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
+ rx_errors = true;
+ }
+ if (state & CAN_ESR1_FRMERR) {
+ cf->data[2] |= CAN_ERR_PROT_FORM;
+ rx_errors = true;
+ }
+ if (state & CAN_ESR1_STFERR) {
+ cf->data[2] |= CAN_ERR_PROT_STUFF;
+ rx_errors = true;
+ }
+
+ priv->can.can_stats.bus_error++;
+ if (rx_errors)
+ priv->ndev->stats.rx_errors++;
+ if (tx_errors)
+ priv->ndev->stats.tx_errors++;
+
+ ret = can_rx_offload_queue_tail(&priv->offload, skb);
+ if (ret)
+ priv->ndev->stats.rx_fifo_errors++;
+
+ dev_err(priv->dev, "canbus err 0x%x\n", state);
+}
+
+static irqreturn_t aml_can_irq(int irq, void *dev_id)
+{
+ struct aml_can_priv *priv = dev_id;
+ struct net_device_stats *stats = &priv->ndev->stats;
+ u32 val;
+
+ regmap_read(priv->reg, CAN_IFLAG1, &val);
+
+ if (val & CAN_IFLAG_MB(0)) {
+ regmap_write(priv->reg, CAN_IFLAG1, CAN_IFLAG_MB(0));
+
+ val = regmap_read(priv->reg, CAN_MB, &val);
+
+ stats->tx_bytes +=
+ can_rx_offload_get_echo_skb_queue_timestamp(&priv->offload, 0,
+ val << 16, NULL);
+ stats->tx_packets++;
+
+ netif_wake_queue(priv->ndev);
+ }
+
+ regmap_read(priv->reg, CAN_ERFSR, &val);
+ if (val & CAN_ERFSR_ERFDA)
+ can_rx_offload_irq_offload_fifo(&priv->offload);
+ if (val & CAN_ERFSR_ERFOVF) {
+ regmap_write(priv->reg, CAN_ERFSR, CAN_ERFSR_ERFOVF);
+
+ stats->rx_over_errors++;
+ stats->rx_errors++;
+ }
+
+ regmap_read(priv->reg, CAN_ESR1, &val);
+
+ if (val & CAN_ESR1_STA_INT) {
+ aml_can_report_state(priv, val & CAN_ESR1_ERR_STATE);
+ regmap_write(priv->reg, CAN_ESR1, CAN_ESR1_STA_INT);
+ }
+ if (val & CAN_ESR1_ERRINT) {
+ aml_can_report_error(priv, val & CAN_ESR1_ERR_BUS);
+ regmap_write(priv->reg, CAN_ESR1, CAN_ESR1_ERRINT);
+ }
+ if (val & CAN_ESR1_ERROVR)
+ regmap_write(priv->reg, CAN_ESR1, CAN_ESR1_ERROVR);
+
+ can_rx_offload_irq_finish(&priv->offload);
+
+ return IRQ_HANDLED;
+}
+
+static struct sk_buff *aml_can_mailbox_read(struct can_rx_offload *offload,
+ unsigned int n, u32 *timestamp,
+ bool drop)
+{
+ struct aml_can_priv *priv = container_of(offload,
+ struct aml_can_priv, offload);
+ struct sk_buff *skb = NULL;
+ struct canfd_frame *cfd;
+ u32 i, reg_ctrl, reg_id, val;
+
+ regmap_read(priv->reg, CAN_ERFSR, &val);
+ if (!(val & CAN_ERFSR_ERFDA))
+ return NULL;
+
+ if (unlikely(drop)) {
+ regmap_write(priv->reg, CAN_ERFSR, CAN_ERFSR_ERFDA);
+ return ERR_PTR(-ENOBUFS);
+ }
+
+ regmap_read(priv->reg, CAN_ENHANCE_RX_FIFO(0), ®_ctrl);
+ if (reg_ctrl & CAN_MB_CNT_EDL)
+ skb = alloc_canfd_skb(offload->dev, &cfd);
+ else
+ skb = alloc_can_skb(offload->dev, (struct can_frame **)&cfd);
+
+ if (unlikely(!skb))
+ return ERR_PTR(-ENOMEM);
+
+ *timestamp = reg_ctrl << 16;
+
+ regmap_read(priv->reg, CAN_ENHANCE_RX_FIFO(1), ®_id);
+ if (reg_ctrl & CAN_MB_CNT_IDE)
+ cfd->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG;
+ else
+ cfd->can_id = (reg_id >> 18) & CAN_SFF_MASK;
+
+ if (reg_ctrl & CAN_MB_CNT_EDL) {
+ cfd->len = can_fd_dlc2len((reg_ctrl >> 16) & 0xf);
+
+ if (reg_ctrl & CAN_MB_CNT_BRS)
+ cfd->flags |= CANFD_BRS;
+ } else {
+ cfd->len = can_cc_dlc2len((reg_ctrl >> 16) & 0xf);
+
+ if (reg_ctrl & CAN_MB_CNT_RTR)
+ cfd->can_id |= CAN_RTR_FLAG;
+ }
+
+ if (reg_ctrl & CAN_MB_CNT_ESI)
+ cfd->flags |= CANFD_ESI;
+
+ for (i = 0; i < cfd->len; i += sizeof(u32)) {
+ regmap_read(priv->reg, CAN_ENHANCE_RX_FIFO(2) + i, &val);
+ __be32 data = cpu_to_be32(val);
+ *(__be32 *)(cfd->data + i) = data;
+ }
+
+ regmap_write(priv->reg, CAN_ERFSR, CAN_ERFSR_ERFDA);
+
+ return skb;
+}
+
+static int aml_can_open(struct net_device *dev)
+{
+ struct aml_can_priv *priv = netdev_priv(dev);
+ int ret;
+
+ ret = open_candev(dev);
+ if (ret)
+ return ret;
+
+ priv->offload.mailbox_read = aml_can_mailbox_read;
+
+ ret = can_rx_offload_add_fifo(dev, &priv->offload,
+ AML_CAN_NAPI_WEIGHT);
+ if (ret)
+ goto err_open_offload;
+
+ aml_can_top_init(priv);
+
+ ret = aml_can_chip_start(priv);
+ if (ret)
+ goto err_open_start;
+
+ can_rx_offload_enable(&priv->offload);
+
+ aml_can_interrupts_enable(priv, 1);
+
+ netif_start_queue(dev);
+
+ return 0;
+
+err_open_start:
+ can_rx_offload_del(&priv->offload);
+err_open_offload:
+ close_candev(dev);
+ return ret;
+}
+
+static int aml_can_close(struct net_device *dev)
+{
+ struct aml_can_priv *priv = netdev_priv(dev);
+
+ netif_stop_queue(dev);
+ aml_can_interrupts_enable(priv, 0);
+
+ can_rx_offload_disable(&priv->offload);
+
+ aml_can_chip_stop(priv);
+
+ can_rx_offload_del(&priv->offload);
+ close_candev(dev);
+
+ return 0;
+}
+
+static netdev_tx_t aml_can_start_xmit(struct sk_buff *skb,
+ struct net_device *dev)
+{
+ const struct aml_can_priv *priv = netdev_priv(dev);
+ struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
+ u32 can_id;
+ u32 data;
+ u32 ctrl = CAN_MB_CODE_TX_DATA | ((can_fd_len2dlc(cfd->len)) << 16);
+ int i;
+
+ if (can_dev_dropped_skb(dev, skb))
+ return NETDEV_TX_OK;
+
+ netif_stop_queue(dev);
+
+ if (cfd->can_id & CAN_EFF_FLAG) {
+ can_id = cfd->can_id & CAN_EFF_MASK;
+ ctrl |= CAN_MB_CNT_IDE | CAN_MB_CNT_SRR;
+ } else {
+ can_id = (cfd->can_id & CAN_SFF_MASK) << 18;
+ }
+
+ if (cfd->can_id & CAN_RTR_FLAG)
+ ctrl |= CAN_MB_CNT_RTR;
+
+ if (can_is_canfd_skb(skb)) {
+ ctrl |= CAN_MB_CNT_EDL;
+
+ if (cfd->flags & CANFD_BRS)
+ ctrl |= CAN_MB_CNT_BRS;
+ }
+
+ for (i = 0; i < cfd->len; i += sizeof(u32)) {
+ data = be32_to_cpup((__be32 *)&cfd->data[i]);
+ regmap_write(priv->reg, CAN_MB + 0x8 + i, data);
+ }
+
+ can_put_echo_skb(skb, dev, 0, 0);
+
+ regmap_write(priv->reg, CAN_MB + 0x4, can_id);
+ regmap_write(priv->reg, CAN_MB, ctrl);
+
+ return NETDEV_TX_OK;
+}
+
+static const struct net_device_ops aml_can_netdev_ops = {
+ .ndo_open = aml_can_open,
+ .ndo_stop = aml_can_close,
+ .ndo_start_xmit = aml_can_start_xmit,
+};
+
+static int aml_can_set_mode(struct net_device *dev, enum can_mode mode)
+{
+ struct aml_can_priv *priv = netdev_priv(dev);
+ int ret;
+
+ switch (mode) {
+ case CAN_MODE_START:
+ ret = aml_can_chip_start(priv);
+ if (ret)
+ return ret;
+
+ aml_can_interrupts_enable(priv, true);
+
+ netif_wake_queue(dev);
+ break;
+
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ return 0;
+}
+
+static int aml_can_get_berr_counter(const struct net_device *dev,
+ struct can_berr_counter *bec)
+{
+ const struct aml_can_priv *priv = netdev_priv(dev);
+ u32 val;
+
+ regmap_read(priv->reg, CAN_ECR, &val);
+
+ bec->txerr = FIELD_GET(CAN_MCR_TXERRCNT, val);
+ bec->rxerr = FIELD_GET(CAN_MCR_RXERRCNT, val);
+
+ return 0;
+}
+
+static int aml_can_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct net_device *net;
+ void __iomem *res_start;
+ struct resource *res_mem;
+ struct aml_can_priv *priv;
+ struct clk *clk_pe, *clk_filter;
+ struct regmap *reg;
+ int irq, ret;
+
+ res_start = devm_platform_get_and_ioremap_resource(pdev, 0, &res_mem);
+ if (IS_ERR(res_start))
+ return PTR_ERR(res_start);
+
+ reg = devm_regmap_init_mmio(dev, res_start, &aml_can_regmap_config);
+ if (IS_ERR(reg))
+ return PTR_ERR(reg);
+
+ clk_pe = devm_clk_get(dev, "can_pe");
+ if (IS_ERR(clk_pe))
+ return dev_err_probe(dev, PTR_ERR(clk_pe),
+ "Failed to get can_pe clock\n");
+
+ clk_filter = devm_clk_get(dev, "can_filter");
+ if (IS_ERR(clk_filter))
+ return dev_err_probe(dev, PTR_ERR(clk_filter),
+ "Failed to get can_filter clock\n");
+
+ ret = clk_set_rate(clk_pe, AML_CAN_PE_CLK_RATE);
+ if (ret)
+ dev_err(dev, "Failed to set can_pe rate: %d\n", ret);
+
+ ret = clk_set_rate(clk_filter, AML_CAN_PE_CLK_RATE);
+ if (ret)
+ dev_err(dev, "Failed to set can_filter rate: %d\n", ret);
+
+ ret = clk_prepare_enable(clk_pe);
+ if (ret)
+ return dev_err_probe(dev, PTR_ERR(clk_pe),
+ "Failed to enable can_pe clock\n");
+
+ ret = clk_prepare_enable(clk_filter);
+ if (ret)
+ return dev_err_probe(dev, PTR_ERR(clk_filter),
+ "Failed to enable can_filter clock\n");
+
+ irq = platform_get_irq(pdev, 0);
+ if (irq < 0)
+ return dev_err_probe(dev, irq, "Failed to get irq\n");
+
+ net = alloc_candev(sizeof(struct aml_can_priv), 1);
+ if (!net)
+ return -ENOMEM;
+
+ SET_NETDEV_DEV(net, dev);
+ platform_set_drvdata(pdev, net);
+
+ net->irq = irq;
+ net->flags |= IFF_ECHO;
+ net->netdev_ops = &aml_can_netdev_ops;
+
+ priv = netdev_priv(net);
+ priv->dev = dev;
+ priv->reg = reg;
+ priv->ndev = net;
+ priv->clk_pe = clk_pe;
+ priv->clk_filter = clk_filter;
+ priv->can.clock.freq = clk_get_rate(priv->clk_pe);
+ priv->can.do_set_mode = aml_can_set_mode;
+ priv->can.do_get_berr_counter = aml_can_get_berr_counter;
+ priv->can.ctrlmode_supported = CAN_CTRLMODE_FD |
+ CAN_CTRLMODE_BERR_REPORTING |
+ CAN_CTRLMODE_FD_NON_ISO;
+ priv->can.bittiming_const = &aml_can_fd_bittiming_const;
+ priv->can.fd.data_bittiming_const = &aml_can_fd_data_bittiming_const;
+
+ ret = register_candev(net);
+ if (ret) {
+ dev_err(dev, "Failed to register candev %d\n", ret);
+ goto err_register_candev;
+ }
+
+ ret = devm_request_irq(dev, irq, aml_can_irq, 0, "amlogic_can", priv);
+ if (ret) {
+ dev_err(dev, "failed to request irq %d\n", ret);
+ goto err_request_irq;
+ }
+
+ dev_info(dev, "amlogic can initialized (clk %d)\n",
+ priv->can.clock.freq);
+
+ return 0;
+
+err_request_irq:
+ unregister_candev(net);
+err_register_candev:
+ free_candev(net);
+
+ return ret;
+}
+
+static void aml_can_remove(struct platform_device *pdev)
+{
+ struct net_device *net = platform_get_drvdata(pdev);
+ struct aml_can_priv *priv = netdev_priv(net);
+
+ disable_irq(net->irq);
+ unregister_candev(net);
+ clk_disable_unprepare(priv->clk_filter);
+ clk_disable_unprepare(priv->clk_pe);
+ free_candev(net);
+}
+
+static int aml_can_suspend(struct device *device)
+{
+ struct net_device *net = dev_get_drvdata(device);
+ struct aml_can_priv *priv = netdev_priv(net);
+ int ret;
+
+ if (!netif_running(net))
+ return 0;
+
+ ret = aml_can_chip_stop(priv);
+ if (ret)
+ return ret;
+
+ aml_can_interrupts_enable(priv, 0);
+
+ pinctrl_pm_select_sleep_state(device);
+
+ netif_stop_queue(net);
+ netif_device_detach(net);
+
+ priv->can.state = CAN_STATE_SLEEPING;
+
+ return 0;
+}
+
+static int aml_can_resume(struct device *device)
+{
+ struct net_device *net = dev_get_drvdata(device);
+ struct aml_can_priv *priv = netdev_priv(net);
+ int ret;
+
+ if (!netif_running(net))
+ return 0;
+
+ netif_device_attach(net);
+ netif_start_queue(net);
+
+ pinctrl_pm_select_default_state(device);
+
+ ret = aml_can_chip_start(priv);
+ if (ret)
+ return ret;
+
+ aml_can_interrupts_enable(priv, 1);
+
+ priv->can.state = CAN_STATE_ERROR_ACTIVE;
+
+ return 0;
+}
+
+static const struct of_device_id aml_can_of_match[] = {
+ { .compatible = "amlogic,a9-can", },
+ { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, aml_can_of_match);
+
+static const struct dev_pm_ops aml_can_pm_ops = {
+ SET_SYSTEM_SLEEP_PM_OPS(aml_can_suspend, aml_can_resume)
+};
+
+static struct platform_driver aml_can_driver = {
+ .driver = {
+ .name = "amlogic_can",
+ .pm = &aml_can_pm_ops,
+ .of_match_table = aml_can_of_match,
+ },
+ .probe = aml_can_probe,
+ .remove = aml_can_remove,
+};
+
+module_platform_driver(aml_can_driver);
+
+MODULE_AUTHOR("Zelong Dong <zelong.dong@amlogic.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("CAN port driver for Amlogic CAN Controller");
diff --git a/drivers/net/can/amlogic/amlogic_can.h b/drivers/net/can/amlogic/amlogic_can.h
new file mode 100644
index 000000000000..15c86f3c001e
--- /dev/null
+++ b/drivers/net/can/amlogic/amlogic_can.h
@@ -0,0 +1,367 @@
+/* SPDX-License-Identifier: (GPL-2.0-only OR MIT) */
+/*
+ * Copyright (C) 2026 Amlogic, Inc. All rights reserved
+ */
+
+#ifndef _AMLOGIC_CAN_H
+
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/dmapool.h>
+#include <linux/can/dev.h>
+#include <linux/clk.h>
+#include <linux/can/rx-offload.h>
+#include <linux/netdevice.h>
+#include <linux/regmap.h>
+
+#define CAN_MCR 0x00
+#define CAN_CTRL1 0x04
+#define CAN_TIMER 0x08
+ /* 0x0C */
+#define CAN_RXMGMASK 0x10
+#define CAN_RX14MASK 0x14
+#define CAN_RX15MASK 0x18
+#define CAN_ECR 0x1C
+#define CAN_ESR1 0x20
+#define CAN_IMASK2 0x24
+#define CAN_IMASK1 0x28
+#define CAN_IFLAG2 0x2C
+#define CAN_IFLAG1 0x30
+#define CAN_CTRL2 0x34
+#define CAN_ESR2 0x38
+ /* 0x3C - 0x40 */
+#define CAN_CRCR 0x44
+#define CAN_RXFGMASK 0x48
+#define CAN_RXFIR 0x4C
+#define CAN_CBT 0x50
+ /* 0x54 - 0x64 */
+#define CAN_IMASK4 0x68
+#define CAN_IMASK3 0x6C
+#define CAN_IFLAG4 0x70
+#define CAN_IFLAG3 0x74
+ /* 0x78 - 0x7C */
+#define CAN_MB 0x80 /* 0x80 - 0x87c */
+#define CAN_RXIMR(n) (0x880 + 0x4 * (n)) /* 0x880 - 0xA7C */
+ /* 0xA80 - 0xADC */
+#define CAN_MECR 0xAE0
+#define CAN_ERRIAR 0xAE4
+#define CAN_ERRIDPR 0xAE8
+#define CAN_ERRIPPR 0xAEC
+#define CAN_RERRAR 0xAF0
+#define CAN_RERRDR 0xAF4
+#define CAN_RERRSYNR 0xAF8
+#define CAN_ERRSR 0xAFC
+#define CAN_CTRL1_PN 0xB00
+#define CAN_CTRL2_PN 0xB04
+#define CAN_WU_MTC 0xB08
+#define CAN_FLT_ID1 0xB0C
+#define CAN_FLT_DLC 0xB10
+#define CAN_PL1_LO 0xB14
+#define CAN_PL1_HI 0xB18
+#define CAN_FLT_ID2_IDMASK 0xB1C
+#define CAN_PL2_PLMASK_LO 0xB20
+#define CAN_PL2_PLMASK_HI 0xB24
+ /* 0xB28 - 0xB3C */
+/* CAN_WMB_CS 0xB40 - 0xB7C */
+#define CAN_WMB_CS(n) (0xB40 + 0x10 * (n))
+#define CAN_WMB_ID(n) (0xB44 + 0x10 * (n))
+#define CAN_WMB_D03(n) (0xB48 + 0x10 * (n))
+#define CAN_WMB_D47(n) (0xB4C + 0x10 * (n))
+ /* 0xB80 - 0xBEC */
+#define CAN_EPRS 0xBF0
+#define CAN_ENCBT 0xBF4
+#define CAN_EDCBT 0xBF8
+#define CAN_ETDC 0xBFC
+#define CAN_FDCTRL 0xC00
+#define CAN_FDCBT 0xC04
+#define CAN_FDCRC 0xC08
+#define CAN_ERFCR 0xC0C
+#define CAN_ERFIER 0xC10
+#define CAN_ERFSR 0xC14
+ /* 0xC18 - 0xC2C */
+#define CAN_HR_TIME_STAMP(n) (0xC30 + 0x4 * (n)) /* 0xC30 - 0xE2C */
+ /* 0xE30 - 0xFFC */
+#define CAN_ENHANCE_MB 0x1000 /* 0x1000 - 0x17FC */
+ /* 0x1800 - 0x1FFC */
+#define CAN_ENHANCE_RX_FIFO(n) (0x2000 + 0x4 * (n)) /* 0x2000 - 0x204C */
+ /* 0x2050 - 0x2FFC */
+#define CAN_ERFFEL(n) (0x3000 + 0x4 * (n)) /* 0x3000 - 0x31FC */
+ /* 0x3200 - 0x37FC */
+#define CAN_VERSION 0x3800
+#define CAN_TOP_CTRL 0x3804
+#define CAN_DMA_CFG 0x3808
+#define CAN_TMTIK_CFG 0x380C
+#define CAN_TWRAP_INT_CLR 0x3810
+ /* 0x3814 - 0x3818 */
+#define CAN_TIMESTAMP 0x381C
+#define CAN_WARN_INT_STS 0x3820
+#define CAN_MB_INT_STS0 0x3824
+#define CAN_MB_INT_STS1 0x3828
+#define CAN_MB_INT_STS2 0x382C
+#define CAN_MB_INT_STS3 0x3830
+#define CAN_STS_REG 0x3834
+#define CAN_ECC_ERR_ADDR 0x3838
+
+/* CAN_MCR */
+#define CAN_MCR_MDIS BIT(31)
+#define CAN_MCR_FRZ BIT(30)
+#define CAN_MCR_RFEN BIT(29)
+#define CAN_MCR_HALT BIT(28)
+#define CAN_MCR_NOTRDY BIT(27)
+#define CAN_MCR_WAKMSK BIT(26)
+#define CAN_MCR_SOFTRST BIT(25)
+#define CAN_MCR_FRZACK BIT(24)
+#define CAN_MCR_SLFWAK BIT(22)
+#define CAN_MCR_WRNEN BIT(21)
+#define CAN_MCR_LPMACK BIT(20)
+#define CAN_MCR_WAKSRC BIT(19)
+#define CAN_MCR_DOZE BIT(18)
+#define CAN_MCR_SRXDIS BIT(17)
+#define CAN_MCR_IRMQ BIT(16)
+#define CAN_MCR_DMA BIT(15)
+#define CAN_MCR_PNET_EN BIT(14)
+#define CAN_MCR_LPRIOEN BIT(13)
+#define CAN_MCR_AEN BIT(12)
+#define CAN_MCR_FDEN BIT(11)
+#define CAN_MCR_IDAM GENMASK(9, 8)
+#define CAN_MCR_MAXMB GENMASK(6, 0)
+
+/* CAN_CTRL1 */
+#define CAN_CTRL1_PRESDIV GENMASK(31, 24)
+#define CAN_CTRL1_RJW GENMASK(23, 22)
+#define CAN_CTRL1_PSEG1 GENMASK(21, 19)
+#define CAN_CTRL1_PSEG2 GENMASK(18, 16)
+#define CAN_CTRL1_BOFFMSK BIT(15)
+#define CAN_CTRL1_ERRMSK BIT(14)
+#define CAN_CTRL1_CLKSRC BIT(13)
+#define CAN_CTRL1_LPB BIT(12)
+#define CAN_CTRL1_TWRNMSK BIT(11)
+#define CAN_CTRL1_RWRNMSK BIT(10)
+#define CAN_CTRL1_SMP BIT(7)
+#define CAN_CTRL1_BOFFREC BIT(6)
+#define CAN_CTRL1_TSYN BIT(5)
+#define CAN_CTRL1_LBUF BIT(4)
+#define CAN_CTRL1_LOM BIT(3)
+#define CAN_CTRL1_PROPSEG GENMASK(2, 0)
+#define CAN_CTRL1_ERR_BUS (CAN_CTRL1_ERRMSK)
+#define CAN_CTRL1_ERR_STATE (CAN_CTRL1_TWRNMSK | \
+ CAN_CTRL1_RWRNMSK | \
+ CAN_CTRL1_BOFFMSK)
+#define CAN_CTRL1_ERR_ALL (CAN_CTRL1_ERR_BUS | CAN_CTRL1_ERR_STATE)
+#define CAN_CTRL1_CBT (CAN_CTRL1_PRESDIV | CAN_CTRL1_RJW | \
+ CAN_CTRL1_PSEG1 | CAN_CTRL1_PSEG2 | \
+ CAN_CTRL1_PROPSEG)
+
+/* CAN_CTRL2 */
+#define CAN_CTRL2_ERRMSK_FAST BIT(31)
+#define CAN_CTRL2_BOFFDONEMSK BIT(30)
+#define CAN_CTRL2_ECRWRE BIT(29)
+#define CAN_CTRL2_WRMFRZ BIT(28)
+#define CAN_CTRL2_RFFN GENMASK(27, 24)
+#define CAN_CTRL2_TASD GENMASK(23, 19)
+#define CAN_CTRL2_MRP BIT(18)
+#define CAN_CTRL2_RRS BIT(17)
+#define CAN_CTRL2_EACEN BIT(16)
+#define CAN_CTRL2_TIMER_SRC BIT(15)
+#define CAN_CTRL2_PREXCEN BIT(14)
+#define CAN_CTRL2_BTE BIT(13)
+#define CAN_CTRL2_ISOCANFDEN BIT(12)
+#define CAN_CTRL2_EDFLTDIS BIT(11)
+#define CAN_CTRL2_MBTSBASE GENMASK(9, 8)
+#define CAN_CTRL2_TSTAMPCAP GENMASK(7, 6)
+
+/* CAN_MECR */
+#define CAN_MCR_RXERRCNT GENMASK(15, 8)
+#define CAN_MCR_TXERRCNT GENMASK(7, 0)
+
+/* CAN_MECR */
+#define CAN_MECR_ECRWRDIS BIT(31)
+#define CAN_MECR_HANCEI_MSK BIT(19)
+#define CAN_MECR_FANCEI_MSK BIT(18)
+#define CAN_MECR_CEI_MSK BIT(16)
+#define CAN_MECR_HAERRIE BIT(15)
+#define CAN_MECR_FAERRIE BIT(14)
+#define CAN_MECR_EXTERRIE BIT(13)
+#define CAN_MECR_RERRDIS BIT(9)
+#define CAN_MECR_ECCDIS BIT(8)
+#define CAN_MECR_NCEFAFRZ BIT(7)
+
+/* CAN_ESR1 */
+#define CAN_ESR1_BIT1ERR_FAST BIT(31)
+#define CAN_ESR1_BIT0ERR_FAST BIT(30)
+#define CAN_ESR1_CRCERR_FAST BIT(28)
+#define CAN_ESR1_FRMERR_FAST BIT(27)
+#define CAN_ESR1_STFERR_FAST BIT(26)
+#define CAN_ESR1_ERROVR BIT(21)
+#define CAN_ESR1_ERRINT_FAST BIT(20)
+#define CAN_ESR1_BOFFDONEINT BIT(19)
+#define CAN_ESR1_SYNCH BIT(18)
+#define CAN_ESR1_TWRNINT BIT(17)
+#define CAN_ESR1_RWRNINT BIT(16)
+#define CAN_ESR1_BIT1ERR BIT(15)
+#define CAN_ESR1_BIT0ERR BIT(14)
+#define CAN_ESR1_ACKERR BIT(13)
+#define CAN_ESR1_CRCERR BIT(12)
+#define CAN_ESR1_FRMERR BIT(11)
+#define CAN_ESR1_STFERR BIT(10)
+#define CAN_ESR1_TXWRN BIT(9)
+#define CAN_ESR1_RXWRN BIT(8)
+#define CAN_ESR1_IDLE BIT(7)
+#define CAN_ESR1_TX BIT(6)
+#define CAN_ESR1_FLTCONF GENMASK(5, 4)
+#define CAN_ESR1_RX BIT(3)
+#define CAN_ESR1_BOFFINT BIT(2)
+#define CAN_ESR1_ERRINT BIT(1)
+#define CAN_ESR1_WAKINT BIT(0)
+
+#define CAN_ESR1_FLTCONF_ACTIVE 0x0
+#define CAN_ESR1_FLTCONF_PASSIVE 0x1
+//#define CAN_ESR1_FLTCONF_BUSOFF
+
+#define CAN_ESR1_ERR_BUS \
+ (CAN_ESR1_BIT1ERR | CAN_ESR1_BIT0ERR | \
+ CAN_ESR1_ACKERR | CAN_ESR1_CRCERR | \
+ CAN_ESR1_FRMERR | CAN_ESR1_STFERR)
+#define CAN_ESR1_STA_INT \
+ (CAN_ESR1_TWRNINT | CAN_ESR1_RWRNINT | CAN_ESR1_BOFFINT)
+#define CAN_ESR1_ERR_STATE \
+ (CAN_ESR1_TXWRN | CAN_ESR1_RXWRN | CAN_ESR1_FLTCONF)
+
+/* CAN_ESR2 */
+#define CAN_ESR2_TWAINT BIT(31)
+#define CAN_ESR2_LPTM GENMASK(22, 16)
+#define CAN_ESR2_TWAMSK BIT(15)
+#define CAN_ESR2_VPS BIT(14)
+#define CAN_ESR2_IMB BIT(13)
+
+/* CAN_CBT */
+#define CAN_CBT_BTF BIT(31)
+#define CAN_CBT_EPRESDIV GENMASK(30, 21)
+#define CAN_CBT_ERJW GENMASK(20, 16)
+#define CAN_CBT_EPROPSEG GENMASK(15, 10)
+#define CAN_CBT_EPSEG1 GENMASK(9, 5)
+#define CAN_CBT_EPSEG2 GENMASK(4, 0)
+#define CAN_CBT_CBT (CAN_CBT_EPRESDIV | CAN_CBT_ERJW | \
+ CAN_CBT_EPSEG1 | CAN_CBT_EPSEG2 | \
+ CAN_CBT_EPROPSEG)
+
+/* CAN_FDCTRL */
+#define CAN_FDCTRL_FDRATE BIT(31)
+#define CAN_FDCTRL_MBDSR3 GENMASK(26, 25)
+#define CAN_FDCTRL_MBDSR2 GENMASK(23, 22)
+#define CAN_FDCTRL_MBDSR1 GENMASK(20, 19)
+#define CAN_FDCTRL_MBDSR0 GENMASK(17, 16)
+#define CAN_FDCTRL_MBDSR_8 0x0
+#define CAN_FDCTRL_MBDSR_16 0x1
+#define CAN_FDCTRL_MBDSR_32 0x2
+#define CAN_FDCTRL_MBDSR_64 0x3
+#define CAN_FDCTRL_TDCEN BIT(15)
+#define CAN_FDCTRL_TDCFAIL BIT(14)
+#define CAN_FDCTRL_TDCOFF GENMASK(12, 8)
+#define CAN_FDCTRL_TDCVAL GENMASK(5, 0)
+
+/* CAN_FDCBT */
+#define CAN_FDCBT_FPRESDIV GENMASK(29, 20)
+#define CAN_FDCBT_FRJW GENMASK(18, 16)
+#define CAN_FDCBT_FPROPSEG GENMASK(14, 10)
+#define CAN_FDCBT_FPSEG1 GENMASK(7, 5)
+#define CAN_FDCBT_FPSEG2 GENMASK(2, 0)
+#define CAN_FDCBT_CBT (CAN_FDCBT_FPRESDIV | CAN_FDCBT_FRJW | \
+ CAN_FDCBT_FPSEG1 | CAN_FDCBT_FPSEG2 | \
+ CAN_FDCBT_FPROPSEG)
+
+#define CAN_ERFCR_ERFEN BIT(31)
+#define CAN_ERFCR_DMALW GENMASK(30, 26)
+#define CAN_ERFCR_NEXIF GENMASK(22, 16)
+#define CAN_ERFCR_NFE GENMASK(13, 8)
+#define CAN_ERFCR_ERFWM GENMASK(4, 0)
+#define CAN_ERFCR_CFG (CAN_ERFCR_NEXIF | \
+ CAN_ERFCR_NFE | CAN_ERFCR_ERFWM)
+
+#define CAN_ERFIER_ERFUFWIE BIT(31)
+#define CAN_ERFIER_ERFOVFIE BIT(30)
+#define CAN_ERFIER_ERFWMIIE BIT(29)
+#define CAN_ERFIER_ERFDAIE BIT(28)
+
+#define CAN_ERFSR_ERFUFW BIT(31)
+#define CAN_ERFSR_ERFOVF BIT(30)
+#define CAN_ERFSR_ERFWMI BIT(29)
+#define CAN_ERFSR_ERFDA BIT(28)
+#define CAN_ERFSR_ERFCLR BIT(27)
+#define CAN_ERFSR_ERFE BIT(17)
+#define CAN_ERFSR_ERFF BIT(16)
+#define CAN_ERFSR_ERFEL GENMASK(5, 0)
+
+/* CAN_IFLAG1 */
+#define CAN_IFLAG_MB(x) BIT(x)
+#define CAN_IFLAG_RX_FIFO_OVERFLOW BIT(7)
+#define CAN_IFLAG_RX_FIFO_WARN BIT(6)
+#define CAN_IFLAG_RX_FIFO_AVAILABLE BIT(5)
+
+/* CAN message buffers */
+#define CAN_MB_CODE GENMASK(27, 24)
+#define CAN_MB_CODE_RX_BUSY_BIT FIELD_PREP(CAN_MB_CODE, 0x1)
+#define CAN_MB_CODE_RX_INACTIVE FIELD_PREP(CAN_MB_CODE, 0x0)
+#define CAN_MB_CODE_RX_EMPTY FIELD_PREP(CAN_MB_CODE, 0x4)
+#define CAN_MB_CODE_RX_FULL FIELD_PREP(CAN_MB_CODE, 0x2)
+#define CAN_MB_CODE_RX_OVERRUN FIELD_PREP(CAN_MB_CODE, 0x6)
+#define CAN_MB_CODE_RX_RANSWER FIELD_PREP(CAN_MB_CODE, 0xa)
+#define CAN_MB_CODE_TX_INACTIVE FIELD_PREP(CAN_MB_CODE, 0x8)
+#define CAN_MB_CODE_TX_ABORT FIELD_PREP(CAN_MB_CODE, 0x9)
+#define CAN_MB_CODE_TX_DATA FIELD_PREP(CAN_MB_CODE, 0xc)
+#define CAN_MB_CODE_TX_TANSWER FIELD_PREP(CAN_MB_CODE, 0xe)
+
+#define CAN_MB_CNT_EDL BIT(31)
+#define CAN_MB_CNT_BRS BIT(30)
+#define CAN_MB_CNT_ESI BIT(29)
+#define CAN_MB_CNT_SRR BIT(22)
+#define CAN_MB_CNT_IDE BIT(21)
+#define CAN_MB_CNT_RTR BIT(20)
+#define CAN_MB_CNT_LENGTH GENMASK(19, 16)
+#define CAN_MB_CNT_TIMESTAMP GENMASK(15, 0)
+
+#define CAN_TOP_CTRL_GLITCH_FILTER_SEL GENMASK(19, 17)
+#define CAN_TOP_CTRL_GLITCH_FILTER_EN BIT(16)
+
+#define CAN_DMA_CFG_SINGLE_MBOX_LEN GENMASK(29, 24)
+#define CAN_DMA_CFG_ERF_WM GENMASK(20, 16)
+#define CAN_DMA_CFG_ERF_LW GENMASK(12, 8)
+#define CAN_DMA_CFG_ERF_EN BIT(0)
+
+#define CAN_TMTIK_CFG_TS_HIGH BIT(18)
+#define CAN_TMTIK_CFG_TS_LOW BIT(17)
+#define CAN_TMTIK_CFG_TICK_VALUE GENMASK(16, 0)
+
+#define AML_CAN_TIMEOUT_US 250
+#define AML_CAN_MB_NUM 128
+#define AML_CAN_ERX_FIFO_NUM 32
+
+#define AML_CAN_PE_CLK_RATE 80000000
+#define AML_CAN_WATERMARK 4
+#define AML_CAN_DMALW 19
+#define AML_CAN_DMALW2SIZE (AML_CAN_DMALW * 0x4)
+#define AML_CAN_DMA_BUF_LEN (AML_CAN_WATERMARK * AML_CAN_DMALW2SIZE)
+
+#define AML_CAN_NAPI_WEIGHT (8 + 2)
+
+struct aml_can_dma {
+ struct dma_chan *rx_chan;
+ dma_addr_t dma_buf;
+ u32 *buf;
+ unsigned int dma_len;
+};
+
+struct aml_can_priv {
+ struct can_priv can;
+ struct can_rx_offload offload;
+ struct device *dev;
+ struct net_device *ndev;
+
+ struct regmap *reg;
+ struct aml_can_dma can_dma;
+
+ struct clk *clk_pe;
+ struct clk *clk_filter;
+};
+
+#endif
--
2.47.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 3/3] arm64: dts: amlogic: a9: add CAN controller node
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
2026-11-20 8:08 ` [PATCH 1/3] dt-bindings: net: can: add Amlogic A9 CAN controller zelong dong
2026-11-20 8:08 ` [PATCH 2/3] can: amlogic: add driver for Amlogic A9 CAN-FD controller zelong dong
@ 2026-11-20 8:08 ` zelong dong
2026-11-20 8:22 ` [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller Marc Kleine-Budde
2026-11-20 8:40 ` Marc Kleine-Budde
4 siblings, 0 replies; 6+ messages in thread
From: zelong dong @ 2026-11-20 8:08 UTC (permalink / raw)
To: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Marc Kleine-Budde, Vincent Mailhol
Cc: linux-kernel, linux-amlogic, linux-arm-kernel, devicetree,
linux-can, Zelong Dong
From: Zelong Dong <zelong.dong@amlogic.com>
Add the CAN controller node and its pinmux states to the Amlogic A9
SoC device tree. Enable the controller on the A311Y3 BY401 board.
Signed-off-by: Zelong Dong <zelong.dong@amlogic.com>
---
.../dts/amlogic/amlogic-a9-a311y3-by401.dts | 7 ++++++
arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi | 25 +++++++++++++++++++
2 files changed, 32 insertions(+)
diff --git a/arch/arm64/boot/dts/amlogic/amlogic-a9-a311y3-by401.dts b/arch/arm64/boot/dts/amlogic/amlogic-a9-a311y3-by401.dts
index 503e38a29ce6..dffcdd4c35d0 100644
--- a/arch/arm64/boot/dts/amlogic/amlogic-a9-a311y3-by401.dts
+++ b/arch/arm64/boot/dts/amlogic/amlogic-a9-a311y3-by401.dts
@@ -136,3 +136,10 @@ &spisg_e {
pinctrl-names = "default";
pinctrl-0 = <&spisg_e_pins_z>;
};
+
+&canbus {
+ pinctrl-0 = <&can0_pins>;
+ pinctrl-1 = <&can0_pins_sleep>;
+ pinctrl-names = "default", "sleep";
+ status = "okay";
+};
diff --git a/arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi b/arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi
index 509dd1c37a5d..7c3734c4d23f 100644
--- a/arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi
+++ b/arch/arm64/boot/dts/amlogic/amlogic-a9.dtsi
@@ -605,6 +605,20 @@ spisg_e_pins_z: group-spisg-e-pins {
drive-strength-microamp = <3000>;
};
};
+
+ func-can0 {
+ can0_pins: group-can0-pins {
+ pinmux = <AML_PINMUX(AMLOGIC_GPIO_A, 18, 3)>,
+ <AML_PINMUX(AMLOGIC_GPIO_A, 19, 3)>;
+ bias-disable;
+ };
+
+ can0_pins_sleep: group-can0-pins-sleep {
+ pinmux = <AML_PINMUX(AMLOGIC_GPIO_A, 18, 0)>,
+ <AML_PINMUX(AMLOGIC_GPIO_A, 19, 0)>;
+ input-enable;
+ };
+ };
};
spisg_e: spi@50100 {
@@ -677,6 +691,17 @@ i2c8: i2c@3a4800 {
clocks = <&clkc_periphs CLKID_SYS_I2C_M_I>;
status = "disabled";
};
+
+ canbus: can@3a8000 {
+ compatible = "amlogic,a9-can";
+ reg = <0x0 0x3a8000 0x0 0x383c>;
+ interrupts = <GIC_SPI 82 IRQ_TYPE_EDGE_RISING>;
+ clocks = <&clkc_periphs CLKID_CAN0_PE>,
+ <&clkc_periphs CLKID_CAN0_FILTER>;
+ clock-names = "can_pe", "can_filter";
+ power-domains = <&pwrc PWRC_A9_CAN0_ID>;
+ status = "disabled";
+ };
};
gic: interrupt-controller@ff800000 {
--
2.47.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
` (2 preceding siblings ...)
2026-11-20 8:08 ` [PATCH 3/3] arm64: dts: amlogic: a9: add CAN controller node zelong dong
@ 2026-11-20 8:22 ` Marc Kleine-Budde
2026-11-20 8:40 ` Marc Kleine-Budde
4 siblings, 0 replies; 6+ messages in thread
From: Marc Kleine-Budde @ 2026-11-20 8:22 UTC (permalink / raw)
To: zelong dong
Cc: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Vincent Mailhol, linux-kernel, linux-amlogic,
linux-arm-kernel, devicetree, linux-can
[-- Attachment #1: Type: text/plain, Size: 915 bytes --]
On 20.11.2026 16:08:17, zelong dong wrote:
> From: Zelong Dong <zelong.dong@amlogic.com>
>
> This series adds support for the CAN-FD controller found on the
> Amlogic A9 SoC family.
>
> The controller supports classic CAN and CAN-FD. The
> driver uses the generic RX offload infrastructure with hardware
> timestamps, reports bus errors through the CAN berr counter, and
> implements suspend/resume support.
Have you had a look at the flexcan driver? The register layout of the IP
core (and parts of your driver) looks like they were heavily inspired by
it.
Can you summarize why you require a separate driver?
regards,
Marc
--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung Nürnberg | Phone: +49-5121-206917-129 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-9 |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
` (3 preceding siblings ...)
2026-11-20 8:22 ` [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller Marc Kleine-Budde
@ 2026-11-20 8:40 ` Marc Kleine-Budde
4 siblings, 0 replies; 6+ messages in thread
From: Marc Kleine-Budde @ 2026-11-20 8:40 UTC (permalink / raw)
To: zelong dong
Cc: Neil Armstrong, Kevin Hilman, Rob Herring, Martin Blumenstingl,
Jerome Brunet, Vincent Mailhol, linux-kernel, linux-amlogic,
linux-arm-kernel, devicetree, linux-can
[-- Attachment #1: Type: text/plain, Size: 757 bytes --]
On 20.11.2026 16:08:17, zelong dong wrote:
> From: Zelong Dong <zelong.dong@amlogic.com>
>
> This series adds support for the CAN-FD controller found on the
> Amlogic A9 SoC family.
>
> The controller supports classic CAN and CAN-FD. The
> driver uses the generic RX offload infrastructure with hardware
> timestamps, reports bus errors through the CAN berr counter, and
> implements suspend/resume support.
Please base your driver on current net-next/main.
regards,
Marc
--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung Nürnberg | Phone: +49-5121-206917-129 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-9 |
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2026-11-20 8:40 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-20 8:08 [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller zelong dong
2026-11-20 8:08 ` [PATCH 1/3] dt-bindings: net: can: add Amlogic A9 CAN controller zelong dong
2026-11-20 8:08 ` [PATCH 2/3] can: amlogic: add driver for Amlogic A9 CAN-FD controller zelong dong
2026-11-20 8:08 ` [PATCH 3/3] arm64: dts: amlogic: a9: add CAN controller node zelong dong
2026-11-20 8:22 ` [PATCH 0/3] can: amlogic: add support for Amlogic A9 CAN-FD controller Marc Kleine-Budde
2026-11-20 8:40 ` Marc Kleine-Budde
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®