[...]
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_dsa.c
>b/drivers/net/ethernet/marvell/prestera/prestera_dsa.c
>new file mode 100644
>index 000000000000..c4f7d9f6edcb
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_dsa.c
>@@ -0,0 +1,134 @@
>+// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+/* Copyright (c) 2020 Marvell International Ltd. All rights reserved */
>+
>+#include "prestera_dsa.h"
>+
>+#include <linux/string.h>
>+#include <linux/bitops.h>
>+#include <linux/bitfield.h>
>+#include <linux/errno.h>
>+
>+#define W0_MASK_IS_TAGGED BIT(29)
>+
>+/* TrgDev[4:0] = {Word0[28:24]} */
>+#define W0_MASK_HW_DEV_NUM GENMASK(28, 24)
>+
>+/* SrcPort/TrgPort extended to 8b
>+ * SrcPort/TrgPort[7:0] = {Word2[20], Word1[11:10], Word0[23:19]}
>+ */
>+#define W0_MASK_IFACE_PORT_NUM GENMASK(23, 19)
>+
>+/* bits 30:31 - TagCommand 1 = FROM_CPU */
>+#define W0_MASK_DSA_CMD GENMASK(31, 30)
>+
>+/* bits 13:15 -- UP */
>+#define W0_MASK_VPT GENMASK(15, 13)
>+
>+#define W0_MASK_EXT_BIT BIT(12)
>+
>+/* bits 0:11 -- VID */
>+#define W0_MASK_VID GENMASK(11, 0)
>+
>+/* SrcPort/TrgPort extended to 8b
>+ * SrcPort/TrgPort[7:0] = {Word2[20], Word1[11:10], Word0[23:19]}
>+ */
>+#define W1_MASK_IFACE_PORT_NUM GENMASK(11, 10)
>+
>+#define W1_MASK_EXT_BIT BIT(31)
>+#define W1_MASK_CFI_BIT BIT(30)
>+
>+/* SrcPort/TrgPort extended to 8b
>+ * SrcPort/TrgPort[7:0] = {Word2[20], Word1[11:10], Word0[23:19]}
>+ */
>+#define W2_MASK_IFACE_PORT_NUM BIT(20)
>+
>+#define W2_MASK_EXT_BIT BIT(31)
>+
>+/* trgHwDev and trgPort
>+ * TrgDev[11:5] = {Word3[6:0]}
>+ */
>+#define W3_MASK_HW_DEV_NUM GENMASK(6, 0)
>+
>+/* VID 16b [15:0] = {Word3[30:27], Word0[11:0]} */
>+#define W3_MASK_VID GENMASK(30, 27)
>+
>+/* TRGePort[16:0] = {Word3[23:7]} */
>+#define W3_MASK_DST_EPORT GENMASK(23, 7)
>+
>+#define DEV_NUM_MASK GENMASK(11, 5)
>+#define VID_MASK GENMASK(15, 12)
Looks like you forgot to add the "prestera" prefix here.
>+
>+int prestera_dsa_parse(struct prestera_dsa *dsa, const u8 *dsa_buf)
>+{
>+ u32 *dsa_words = (u32 *)dsa_buf;
>+ enum prestera_dsa_cmd cmd;
>+ u32 words[4] = { 0 };
>+ u32 field;
>+
>+ words[0] = ntohl((__force __be32)dsa_words[0]);
>+ words[1] = ntohl((__force __be32)dsa_words[1]);
>+ words[2] = ntohl((__force __be32)dsa_words[2]);
>+ words[3] = ntohl((__force __be32)dsa_words[3]);
>+
>+ /* set the common parameters */
>+ cmd = (enum prestera_dsa_cmd)FIELD_GET(W0_MASK_DSA_CMD, words[0]);
>+
>+ /* only to CPU is supported */
>+ if (unlikely(cmd != PRESTERA_DSA_CMD_TO_CPU_E))
>+ return -EINVAL;
>+
>+ if (FIELD_GET(W0_MASK_EXT_BIT, words[0]) == 0)
>+ return -EINVAL;
>+ if (FIELD_GET(W1_MASK_EXT_BIT, words[1]) == 0)
>+ return -EINVAL;
>+ if (FIELD_GET(W2_MASK_EXT_BIT, words[2]) == 0)
>+ return -EINVAL;
>+
>+ field = FIELD_GET(W3_MASK_VID, words[3]);
>+
>+ dsa->vlan.is_tagged = (bool)FIELD_GET(W0_MASK_IS_TAGGED, words[0]);
>+ dsa->vlan.cfi_bit = (u8)FIELD_GET(W1_MASK_CFI_BIT, words[1]);
>+ dsa->vlan.vpt = (u8)FIELD_GET(W0_MASK_VPT, words[0]);
>+ dsa->vlan.vid = (u16)FIELD_GET(W0_MASK_VID, words[0]);
>+ dsa->vlan.vid &= ~VID_MASK;
>+ dsa->vlan.vid |= FIELD_PREP(VID_MASK, field);
>+
>+ field = FIELD_GET(W3_MASK_HW_DEV_NUM, words[3]);
>+
>+ dsa->hw_dev_num = FIELD_GET(W0_MASK_HW_DEV_NUM, words[0]);
>+ dsa->hw_dev_num &= W3_MASK_HW_DEV_NUM;
>+ dsa->hw_dev_num |= FIELD_PREP(DEV_NUM_MASK, field);
>+
>+ dsa->port_num = (FIELD_GET(W0_MASK_IFACE_PORT_NUM, words[0]) << 0) |
>+ (FIELD_GET(W1_MASK_IFACE_PORT_NUM, words[1]) << 5) |
>+ (FIELD_GET(W2_MASK_IFACE_PORT_NUM, words[2]) << 7);
>+ return 0;
>+}
>+
>+int prestera_dsa_build(const struct prestera_dsa *dsa, u8 *dsa_buf)
>+{
>+ __be32 *dsa_words = (__be32 *)dsa_buf;
>+ u32 words[4] = { 0 };
>+
>+ if (dsa->hw_dev_num >= BIT(12))
>+ return -EINVAL;
>+ if (dsa->port_num >= BIT(17))
>+ return -EINVAL;
>+
>+ words[0] |= FIELD_PREP(W0_MASK_DSA_CMD, PRESTERA_DSA_CMD_FROM_CPU_E);
>+
>+ words[0] |= FIELD_PREP(W0_MASK_HW_DEV_NUM, dsa->hw_dev_num);
>+ words[3] |= FIELD_PREP(W3_MASK_HW_DEV_NUM, (dsa->hw_dev_num >> 5));
>+ words[3] |= FIELD_PREP(W3_MASK_DST_EPORT, dsa->port_num);
>+
>+ words[0] |= FIELD_PREP(W0_MASK_EXT_BIT, 1);
>+ words[1] |= FIELD_PREP(W1_MASK_EXT_BIT, 1);
>+ words[2] |= FIELD_PREP(W2_MASK_EXT_BIT, 1);
>+
>+ dsa_words[0] = htonl(words[0]);
>+ dsa_words[1] = htonl(words[1]);
>+ dsa_words[2] = htonl(words[2]);
>+ dsa_words[3] = htonl(words[3]);
>+
>+ return 0;
>+}
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_dsa.h
>b/drivers/net/ethernet/marvell/prestera/prestera_dsa.h
>new file mode 100644
>index 000000000000..34cb260f1a74
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_dsa.h
>@@ -0,0 +1,37 @@
>+/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+ *
>+ * Copyright (c) 2020 Marvell International Ltd. All rights reserved.
>+ *
>+ */
>+#ifndef __PRESTERA_DSA_H_
>+#define __PRESTERA_DSA_H_
>+
>+#include <linux/types.h>
>+
>+#define PRESTERA_DSA_HLEN 16
>+
>+enum prestera_dsa_cmd {
>+ /* DSA command is "To CPU" */
>+ PRESTERA_DSA_CMD_TO_CPU_E = 0,
>+
>+ /* DSA command is "FROM CPU" */
>+ PRESTERA_DSA_CMD_FROM_CPU_E,
>+};
>+
>+struct prestera_dsa_vlan {
>+ u16 vid;
>+ u8 vpt;
>+ u8 cfi_bit;
>+ bool is_tagged;
>+};
>+
>+struct prestera_dsa {
>+ struct prestera_dsa_vlan vlan;
>+ u32 hw_dev_num;
>+ u32 port_num;
>+};
>+
>+int prestera_dsa_parse(struct prestera_dsa *dsa, const u8 *dsa_buf);
>+int prestera_dsa_build(const struct prestera_dsa *dsa, u8 *dsa_buf);
>+
>+#endif /* _PRESTERA_DSA_H_ */
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_hw.c
>b/drivers/net/ethernet/marvell/prestera/prestera_hw.c
>new file mode 100644
>index 000000000000..b4626cf288b6
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_hw.c
>@@ -0,0 +1,614 @@
>+// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
>+
>+#include <linux/etherdevice.h>
>+#include <linux/ethtool.h>
>+#include <linux/netdevice.h>
>+#include <linux/list.h>
>+
>+#include "prestera.h"
>+#include "prestera_hw.h"
>+
>+#define PRESTERA_SWITCH_INIT_TIMEOUT 30000000 /* 30sec */
>+#define PRESTERA_MIN_MTU 64
>+
>+enum prestera_cmd_type_t {
>+ PRESTERA_CMD_TYPE_SWITCH_INIT = 0x1,
>+ PRESTERA_CMD_TYPE_SWITCH_ATTR_SET = 0x2,
>+
>+ PRESTERA_CMD_TYPE_PORT_ATTR_SET = 0x100,
>+ PRESTERA_CMD_TYPE_PORT_ATTR_GET = 0x101,
>+ PRESTERA_CMD_TYPE_PORT_INFO_GET = 0x110,
>+
>+ PRESTERA_CMD_TYPE_RXTX_INIT = 0x800,
>+ PRESTERA_CMD_TYPE_RXTX_PORT_INIT = 0x801,
>+
>+ PRESTERA_CMD_TYPE_ACK = 0x10000,
>+ PRESTERA_CMD_TYPE_MAX
>+};
>+
>+enum {
>+ PRESTERA_CMD_PORT_ATTR_ADMIN_STATE = 1,
>+ PRESTERA_CMD_PORT_ATTR_MTU = 3,
>+ PRESTERA_CMD_PORT_ATTR_MAC = 4,
>+ PRESTERA_CMD_PORT_ATTR_CAPABILITY = 9,
>+ PRESTERA_CMD_PORT_ATTR_AUTONEG = 15,
>+ PRESTERA_CMD_PORT_ATTR_STATS = 17,
>+};
>+
>+enum {
>+ PRESTERA_CMD_SWITCH_ATTR_MAC = 1,
>+};
>+
>+enum {
>+ PRESTERA_CMD_ACK_OK,
>+ PRESTERA_CMD_ACK_FAILED,
>+
>+ PRESTERA_CMD_ACK_MAX
>+};
>+
>+enum {
>+ PRESTERA_PORT_GOOD_OCTETS_RCV_CNT,
>+ PRESTERA_PORT_BAD_OCTETS_RCV_CNT,
>+ PRESTERA_PORT_MAC_TRANSMIT_ERR_CNT,
>+ PRESTERA_PORT_BRDC_PKTS_RCV_CNT,
>+ PRESTERA_PORT_MC_PKTS_RCV_CNT,
>+ PRESTERA_PORT_PKTS_64L_CNT,
>+ PRESTERA_PORT_PKTS_65TO127L_CNT,
>+ PRESTERA_PORT_PKTS_128TO255L_CNT,
>+ PRESTERA_PORT_PKTS_256TO511L_CNT,
>+ PRESTERA_PORT_PKTS_512TO1023L_CNT,
>+ PRESTERA_PORT_PKTS_1024TOMAXL_CNT,
>+ PRESTERA_PORT_EXCESSIVE_COLLISIONS_CNT,
>+ PRESTERA_PORT_MC_PKTS_SENT_CNT,
>+ PRESTERA_PORT_BRDC_PKTS_SENT_CNT,
>+ PRESTERA_PORT_FC_SENT_CNT,
>+ PRESTERA_PORT_GOOD_FC_RCV_CNT,
>+ PRESTERA_PORT_DROP_EVENTS_CNT,
>+ PRESTERA_PORT_UNDERSIZE_PKTS_CNT,
>+ PRESTERA_PORT_FRAGMENTS_PKTS_CNT,
>+ PRESTERA_PORT_OVERSIZE_PKTS_CNT,
>+ PRESTERA_PORT_JABBER_PKTS_CNT,
>+ PRESTERA_PORT_MAC_RCV_ERROR_CNT,
>+ PRESTERA_PORT_BAD_CRC_CNT,
>+ PRESTERA_PORT_COLLISIONS_CNT,
>+ PRESTERA_PORT_LATE_COLLISIONS_CNT,
>+ PRESTERA_PORT_GOOD_UC_PKTS_RCV_CNT,
>+ PRESTERA_PORT_GOOD_UC_PKTS_SENT_CNT,
>+ PRESTERA_PORT_MULTIPLE_PKTS_SENT_CNT,
>+ PRESTERA_PORT_DEFERRED_PKTS_SENT_CNT,
>+ PRESTERA_PORT_PKTS_1024TO1518L_CNT,
>+ PRESTERA_PORT_PKTS_1519TOMAXL_CNT,
>+ PRESTERA_PORT_GOOD_OCTETS_SENT_CNT,
>+
>+ PRESTERA_PORT_CNT_MAX,
>+};
>+
>+struct prestera_fw_event_handler {
>+ struct list_head list;
>+ enum prestera_event_type type;
>+ prestera_event_cb_t func;
>+ void *arg;
>+};
>+
>+struct prestera_msg_cmd {
>+ u32 type;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_ret {
>+ struct prestera_msg_cmd cmd;
>+ u32 status;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_common_req {
>+ struct prestera_msg_cmd cmd;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_common_resp {
>+ struct prestera_msg_ret ret;
>+} __packed __aligned(4);
>+
>+union prestera_msg_switch_param {
>+ u8 mac[ETH_ALEN];
>+};
>+
>+struct prestera_msg_switch_attr_req {
>+ struct prestera_msg_cmd cmd;
>+ u32 attr;
>+ union prestera_msg_switch_param param;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_switch_init_resp {
>+ struct prestera_msg_ret ret;
>+ u32 port_count;
>+ u32 mtu_max;
>+ u8 switch_id;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_port_autoneg_param {
>+ u64 link_mode;
>+ u8 enable;
>+ u8 fec;
>+};
>+
>+struct prestera_msg_port_cap_param {
>+ u64 link_mode;
>+ u8 type;
>+ u8 fec;
>+ u8 transceiver;
>+};
>+
>+union prestera_msg_port_param {
>+ u8 admin_state;
>+ u8 oper_state;
>+ u32 mtu;
>+ u8 mac[ETH_ALEN];
>+ struct prestera_msg_port_autoneg_param autoneg;
>+ struct prestera_msg_port_cap_param cap;
>+};
>+
>+struct prestera_msg_port_attr_req {
>+ struct prestera_msg_cmd cmd;
>+ u32 attr;
>+ u32 port;
>+ u32 dev;
>+ union prestera_msg_port_param param;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_port_attr_resp {
>+ struct prestera_msg_ret ret;
>+ union prestera_msg_port_param param;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_port_stats_resp {
>+ struct prestera_msg_ret ret;
>+ u64 stats[PRESTERA_PORT_CNT_MAX];
>+} __packed __aligned(4);
>+
>+struct prestera_msg_port_info_req {
>+ struct prestera_msg_cmd cmd;
>+ u32 port;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_port_info_resp {
>+ struct prestera_msg_ret ret;
>+ u32 hw_id;
>+ u32 dev_id;
>+ u16 fp_id;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_rxtx_req {
>+ struct prestera_msg_cmd cmd;
>+ u8 use_sdma;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_rxtx_resp {
>+ struct prestera_msg_ret ret;
>+ u32 map_addr;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_rxtx_port_req {
>+ struct prestera_msg_cmd cmd;
>+ u32 port;
>+ u32 dev;
>+} __packed __aligned(4);
>+
>+struct prestera_msg_event {
>+ u16 type;
>+ u16 id;
>+} __packed __aligned(4);
>+
>+union prestera_msg_event_port_param {
>+ u32 oper_state;
>+};
>+
>+struct prestera_msg_event_port {
>+ struct prestera_msg_event id;
>+ u32 port_id;
>+ union prestera_msg_event_port_param param;
>+} __packed __aligned(4);
>+
>+static int __prestera_cmd_ret(struct prestera_switch *sw,
>+ enum prestera_cmd_type_t type,
>+ struct prestera_msg_cmd *cmd, size_t clen,
>+ struct prestera_msg_ret *ret, size_t rlen,
>+ int wait)
>+{
>+ struct prestera_device *dev = sw->dev;
>+ int err;
>+
>+ cmd->type = type;
>+
>+ err = dev->send_req(dev, (u8 *)cmd, clen, (u8 *)ret, rlen, wait);
>+ if (err)
>+ return err;
>+
>+ if (ret->cmd.type != PRESTERA_CMD_TYPE_ACK)
>+ return -EBADE;
>+ if (ret->status != PRESTERA_CMD_ACK_OK)
>+ return -EINVAL;
>+
>+ return 0;
>+}
>+
>+static int prestera_cmd_ret(struct prestera_switch *sw,
>+ enum prestera_cmd_type_t type,
>+ struct prestera_msg_cmd *cmd, size_t clen,
>+ struct prestera_msg_ret *ret, size_t rlen)
>+{
>+ return __prestera_cmd_ret(sw, type, cmd, clen, ret, rlen, 0);
>+}
>+
>+static int prestera_cmd_ret_wait(struct prestera_switch *sw,
>+ enum prestera_cmd_type_t type,
>+ struct prestera_msg_cmd *cmd, size_t clen,
>+ struct prestera_msg_ret *ret, size_t rlen,
>+ int wait)
>+{
>+ return __prestera_cmd_ret(sw, type, cmd, clen, ret, rlen, wait);
>+}
>+
>+static int prestera_cmd(struct prestera_switch *sw,
>+ enum prestera_cmd_type_t type,
>+ struct prestera_msg_cmd *cmd, size_t clen)
>+{
>+ struct prestera_msg_common_resp resp;
>+
>+ return prestera_cmd_ret(sw, type, cmd, clen, &resp.ret, sizeof(resp));
>+}
>+
>+static int prestera_fw_parse_port_evt(u8 *msg, struct prestera_event *evt)
>+{
>+ struct prestera_msg_event_port *hw_evt;
>+
>+ hw_evt = (struct prestera_msg_event_port *)msg;
>+
>+ evt->port_evt.port_id = hw_evt->port_id;
>+
>+ if (evt->id == PRESTERA_PORT_EVENT_STATE_CHANGED)
>+ evt->port_evt.data.oper_state = hw_evt->param.oper_state;
>+ else
>+ return -EINVAL;
>+
>+ return 0;
>+}
>+
>+static struct prestera_fw_evt_parser {
>+ int (*func)(u8 *msg, struct prestera_event *evt);
>+} fw_event_parsers[PRESTERA_EVENT_TYPE_MAX] = {
>+ [PRESTERA_EVENT_TYPE_PORT] = {.func = prestera_fw_parse_port_evt},
>+};
>+
>+static struct prestera_fw_event_handler *
>+__find_event_handler(const struct prestera_switch *sw,
>+ enum prestera_event_type type)
>+{
>+ struct prestera_fw_event_handler *eh;
>+
>+ list_for_each_entry_rcu(eh, &sw->event_handlers, list) {
>+ if (eh->type == type)
>+ return eh;
>+ }
>+
>+ return NULL;
>+}
>+
>+static int prestera_find_event_handler(const struct prestera_switch *sw,
>+ enum prestera_event_type type,
>+ struct prestera_fw_event_handler *eh)
>+{
>+ struct prestera_fw_event_handler *tmp;
>+ int err = 0;
>+
>+ rcu_read_lock();
>+ tmp = __find_event_handler(sw, type);
>+ if (tmp)
>+ *eh = *tmp;
>+ else
>+ err = -EEXIST;
>+ rcu_read_unlock();
>+
>+ return err;
>+}
>+
>+static int prestera_evt_recv(struct prestera_device *dev, u8 *buf, size_t
>size)
>+{
>+ struct prestera_msg_event *msg = (struct prestera_msg_event *)buf;
>+ struct prestera_switch *sw = dev->priv;
>+ struct prestera_fw_event_handler eh;
>+ struct prestera_event evt;
>+ int err;
>+
>+ if (msg->type >= PRESTERA_EVENT_TYPE_MAX)
>+ return -EINVAL;
>+
>+ err = prestera_find_event_handler(sw, msg->type, &eh);
>+
>+ if (err || !fw_event_parsers[msg->type].func)
>+ return 0;
>+
>+ evt.id = msg->id;
>+
>+ err = fw_event_parsers[msg->type].func(buf, &evt);
>+ if (!err)
>+ eh.func(sw, &evt, eh.arg);
>+
>+ return err;
>+}
>+
>+static void prestera_pkt_recv(struct prestera_device *dev)
>+{
>+ struct prestera_switch *sw = dev->priv;
>+ struct prestera_fw_event_handler eh;
>+ struct prestera_event ev;
>+ int err;
>+
>+ ev.id = PRESTERA_RXTX_EVENT_RCV_PKT;
>+
>+ err = prestera_find_event_handler(sw, PRESTERA_EVENT_TYPE_RXTX, &eh);
>+ if (err)
>+ return;
>+
>+ eh.func(sw, &ev, eh.arg);
>+}
>+
>+int prestera_hw_port_info_get(const struct prestera_port *port,
>+ u16 *fp_id, u32 *hw_id, u32 *dev_id)
>+{
>+ struct prestera_msg_port_info_resp resp;
>+ struct prestera_msg_port_info_req req = {
>+ .port = port->id
>+ };
>+ int err;
>+
>+ err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_INFO_GET,
>+ &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
>+ if (err)
>+ return err;
>+
>+ *hw_id = resp.hw_id;
>+ *dev_id = resp.dev_id;
>+ *fp_id = resp.fp_id;
>+
>+ return 0;
>+}
>+
>+int prestera_hw_switch_mac_set(struct prestera_switch *sw, char *mac)
>+{
>+ struct prestera_msg_switch_attr_req req = {
>+ .attr = PRESTERA_CMD_SWITCH_ATTR_MAC,
>+ };
>+
>+ memcpy(req.param.mac, mac, sizeof(req.param.mac));
>+
>+ return prestera_cmd(sw, PRESTERA_CMD_TYPE_SWITCH_ATTR_SET,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_switch_init(struct prestera_switch *sw)
>+{
>+ struct prestera_msg_switch_init_resp resp;
>+ struct prestera_msg_common_req req;
>+ int err;
>+
>+ INIT_LIST_HEAD(&sw->event_handlers);
>+
>+ err = prestera_cmd_ret_wait(sw, PRESTERA_CMD_TYPE_SWITCH_INIT,
>+ &req.cmd, sizeof(req),
>+ &resp.ret, sizeof(resp),
>+ PRESTERA_SWITCH_INIT_TIMEOUT);
>+ if (err)
>+ return err;
>+
>+ sw->id = resp.switch_id;
>+ sw->port_count = resp.port_count;
>+ sw->mtu_min = PRESTERA_MIN_MTU;
>+ sw->mtu_max = resp.mtu_max;
>+ sw->dev->recv_msg = prestera_evt_recv;
>+ sw->dev->recv_pkt = prestera_pkt_recv;
>+
>+ return 0;
>+}
>+
>+int prestera_hw_port_state_set(const struct prestera_port *port,
>+ bool admin_state)
>+{
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_ADMIN_STATE,
>+ .port = port->hw_id,
>+ .dev = port->dev_id,
>+ .param = {.admin_state = admin_state}
>+ };
>+
>+ return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_port_mtu_set(const struct prestera_port *port, u32 mtu)
>+{
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_MTU,
>+ .port = port->hw_id,
>+ .dev = port->dev_id,
>+ .param = {.mtu = mtu}
>+ };
>+
>+ return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_port_mac_set(const struct prestera_port *port, char *mac)
>+{
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_MAC,
>+ .port = port->hw_id,
>+ .dev = port->dev_id
>+ };
>+ memcpy(&req.param.mac, mac, sizeof(req.param.mac));
>+
>+ return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_port_cap_get(const struct prestera_port *port,
>+ struct prestera_port_caps *caps)
>+{
>+ struct prestera_msg_port_attr_resp resp;
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_CAPABILITY,
>+ .port = port->hw_id,
>+ .dev = port->dev_id
>+ };
>+ int err;
>+
>+ err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
>+ &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
>+ if (err)
>+ return err;
>+
>+ caps->supp_link_modes = resp.param.cap.link_mode;
>+ caps->supp_fec = resp.param.cap.fec;
>+ caps->type = resp.param.cap.type;
>+ caps->transceiver = resp.param.cap.transceiver;
>+
>+ return err;
>+}
>+
>+int prestera_hw_port_autoneg_set(const struct prestera_port *port,
>+ bool autoneg, u64 link_modes, u8 fec)
>+{
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_AUTONEG,
>+ .port = port->hw_id,
>+ .dev = port->dev_id,
>+ .param = {.autoneg = {.link_mode = link_modes,
>+ .enable = autoneg,
>+ .fec = fec}
>+ }
>+ };
>+
>+ return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_port_stats_get(const struct prestera_port *port,
>+ struct prestera_port_stats *st)
>+{
>+ struct prestera_msg_port_stats_resp resp;
>+ struct prestera_msg_port_attr_req req = {
>+ .attr = PRESTERA_CMD_PORT_ATTR_STATS,
>+ .port = port->hw_id,
>+ .dev = port->dev_id
>+ };
>+ u64 *hw = resp.stats;
>+ int err;
>+
>+ err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
>+ &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
>+ if (err)
>+ return err;
>+
>+ st->good_octets_received = hw[PRESTERA_PORT_GOOD_OCTETS_RCV_CNT];
>+ st->bad_octets_received = hw[PRESTERA_PORT_BAD_OCTETS_RCV_CNT];
>+ st->mac_trans_error = hw[PRESTERA_PORT_MAC_TRANSMIT_ERR_CNT];
>+ st->broadcast_frames_received = hw[PRESTERA_PORT_BRDC_PKTS_RCV_CNT];
>+ st->multicast_frames_received = hw[PRESTERA_PORT_MC_PKTS_RCV_CNT];
>+ st->frames_64_octets = hw[PRESTERA_PORT_PKTS_64L_CNT];
>+ st->frames_65_to_127_octets = hw[PRESTERA_PORT_PKTS_65TO127L_CNT];
>+ st->frames_128_to_255_octets = hw[PRESTERA_PORT_PKTS_128TO255L_CNT];
>+ st->frames_256_to_511_octets = hw[PRESTERA_PORT_PKTS_256TO511L_CNT];
>+ st->frames_512_to_1023_octets = hw[PRESTERA_PORT_PKTS_512TO1023L_CNT];
>+ st->frames_1024_to_max_octets = hw[PRESTERA_PORT_PKTS_1024TOMAXL_CNT];
>+ st->excessive_collision = hw[PRESTERA_PORT_EXCESSIVE_COLLISIONS_CNT];
>+ st->multicast_frames_sent = hw[PRESTERA_PORT_MC_PKTS_SENT_CNT];
>+ st->broadcast_frames_sent = hw[PRESTERA_PORT_BRDC_PKTS_SENT_CNT];
>+ st->fc_sent = hw[PRESTERA_PORT_FC_SENT_CNT];
>+ st->fc_received = hw[PRESTERA_PORT_GOOD_FC_RCV_CNT];
>+ st->buffer_overrun = hw[PRESTERA_PORT_DROP_EVENTS_CNT];
>+ st->undersize = hw[PRESTERA_PORT_UNDERSIZE_PKTS_CNT];
>+ st->fragments = hw[PRESTERA_PORT_FRAGMENTS_PKTS_CNT];
>+ st->oversize = hw[PRESTERA_PORT_OVERSIZE_PKTS_CNT];
>+ st->jabber = hw[PRESTERA_PORT_JABBER_PKTS_CNT];
>+ st->rx_error_frame_received = hw[PRESTERA_PORT_MAC_RCV_ERROR_CNT];
>+ st->bad_crc = hw[PRESTERA_PORT_BAD_CRC_CNT];
>+ st->collisions = hw[PRESTERA_PORT_COLLISIONS_CNT];
>+ st->late_collision = hw[PRESTERA_PORT_LATE_COLLISIONS_CNT];
>+ st->unicast_frames_received = hw[PRESTERA_PORT_GOOD_UC_PKTS_RCV_CNT];
>+ st->unicast_frames_sent = hw[PRESTERA_PORT_GOOD_UC_PKTS_SENT_CNT];
>+ st->sent_multiple = hw[PRESTERA_PORT_MULTIPLE_PKTS_SENT_CNT];
>+ st->sent_deferred = hw[PRESTERA_PORT_DEFERRED_PKTS_SENT_CNT];
>+ st->frames_1024_to_1518_octets = hw[PRESTERA_PORT_PKTS_1024TO1518L_CNT];
>+ st->frames_1519_to_max_octets = hw[PRESTERA_PORT_PKTS_1519TOMAXL_CNT];
>+ st->good_octets_sent = hw[PRESTERA_PORT_GOOD_OCTETS_SENT_CNT];
>+
>+ return 0;
>+}
>+
>+int prestera_hw_rxtx_init(struct prestera_switch *sw,
>+ struct prestera_rxtx_params *params)
>+{
>+ struct prestera_msg_rxtx_resp resp;
>+ struct prestera_msg_rxtx_req req;
>+ int err;
>+
>+ req.use_sdma = params->use_sdma;
>+
>+ err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_RXTX_INIT,
>+ &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
>+ if (err)
>+ return err;
>+
>+ params->map_addr = resp.map_addr;
>+ return 0;
>+}
>+
>+int prestera_hw_rxtx_port_init(struct prestera_port *port)
>+{
>+ struct prestera_msg_rxtx_port_req req = {
>+ .port = port->hw_id,
>+ .dev = port->dev_id,
>+ };
>+
>+ return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_RXTX_PORT_INIT,
>+ &req.cmd, sizeof(req));
>+}
>+
>+int prestera_hw_event_handler_register(struct prestera_switch *sw,
>+ enum prestera_event_type type,
>+ prestera_event_cb_t fn,
>+ void *arg)
>+{
>+ struct prestera_fw_event_handler *eh;
>+
>+ eh = __find_event_handler(sw, type);
>+ if (eh)
>+ return -EEXIST;
>+ eh = kmalloc(sizeof(*eh), GFP_KERNEL);
>+ if (!eh)
>+ return -ENOMEM;
>+
>+ eh->type = type;
>+ eh->func = fn;
>+ eh->arg = arg;
>+
>+ INIT_LIST_HEAD(&eh->list);
>+
>+ list_add_rcu(&eh->list, &sw->event_handlers);
>+
>+ return 0;
>+}
>+
>+void prestera_hw_event_handler_unregister(struct prestera_switch *sw,
>+ enum prestera_event_type type,
>+ prestera_event_cb_t fn)
>+{
>+ struct prestera_fw_event_handler *eh;
>+
>+ eh = __find_event_handler(sw, type);
>+ if (!eh)
>+ return;
>+
>+ list_del_rcu(&eh->list);
>+ synchronize_rcu();
>+ kfree(eh);
>+}
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_hw.h
>b/drivers/net/ethernet/marvell/prestera/prestera_hw.h
>new file mode 100644
>index 000000000000..acb0e31d6684
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_hw.h
>@@ -0,0 +1,71 @@
>+/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+ *
>+ * Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved.
>+ *
>+ */
>+
>+#ifndef _PRESTERA_HW_H_
>+#define _PRESTERA_HW_H_
>+
>+#include <linux/types.h>
>+
>+enum {
>+ PRESTERA_PORT_TYPE_NONE,
>+ PRESTERA_PORT_TYPE_TP,
>+
>+ PRESTERA_PORT_TYPE_MAX,
>+};
>+
>+enum {
>+ PRESTERA_PORT_FEC_OFF,
>+
>+ PRESTERA_PORT_FEC_MAX,
>+};
>+
>+struct prestera_switch;
>+struct prestera_port;
>+struct prestera_port_stats;
>+struct prestera_port_caps;
>+enum prestera_event_type;
>+struct prestera_event;
>+
>+typedef void (*prestera_event_cb_t)
>+ (struct prestera_switch *sw, struct prestera_event *evt, void *arg);
>+
>+struct prestera_rxtx_params;
>+
>+/* Switch API */
>+int prestera_hw_switch_init(struct prestera_switch *sw);
>+int prestera_hw_switch_mac_set(struct prestera_switch *sw, char *mac);
>+
>+/* Port API */
>+int prestera_hw_port_info_get(const struct prestera_port *port,
>+ u16 *fp_id, u32 *hw_id, u32 *dev_id);
>+int prestera_hw_port_state_set(const struct prestera_port *port,
>+ bool admin_state);
>+int prestera_hw_port_mtu_set(const struct prestera_port *port, u32 mtu);
>+int prestera_hw_port_mtu_get(const struct prestera_port *port, u32 *mtu);
>+int prestera_hw_port_mac_set(const struct prestera_port *port, char *mac);
>+int prestera_hw_port_mac_get(const struct prestera_port *port, char *mac);
>+int prestera_hw_port_cap_get(const struct prestera_port *port,
>+ struct prestera_port_caps *caps);
>+int prestera_hw_port_autoneg_set(const struct prestera_port *port,
>+ bool autoneg, u64 link_modes, u8 fec);
>+int prestera_hw_port_stats_get(const struct prestera_port *port,
>+ struct prestera_port_stats *stats);
>+
>+/* Event handlers */
>+int prestera_hw_event_handler_register(struct prestera_switch *sw,
>+ enum prestera_event_type type,
>+ prestera_event_cb_t fn,
>+ void *arg);
>+void prestera_hw_event_handler_unregister(struct prestera_switch *sw,
>+ enum prestera_event_type type,
>+ prestera_event_cb_t fn);
>+
>+/* RX/TX */
>+int prestera_hw_rxtx_init(struct prestera_switch *sw,
>+ struct prestera_rxtx_params *params);
>+int prestera_hw_rxtx_port_init(struct prestera_port *port);
>+
>+#endif /* _PRESTERA_HW_H_ */
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_rxtx.c
>b/drivers/net/ethernet/marvell/prestera/prestera_rxtx.c
>new file mode 100644
>index 000000000000..556941d97d4d
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_rxtx.c
>@@ -0,0 +1,825 @@
>+// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
>+
>+#include <linux/platform_device.h>
>+#include <linux/of.h>
>+#include <linux/of_address.h>
>+#include <linux/of_device.h>
>+#include <linux/dmapool.h>
>+#include <linux/netdevice.h>
>+#include <linux/etherdevice.h>
>+#include <linux/if_vlan.h>
>+
>+#include "prestera.h"
>+#include "prestera_hw.h"
>+#include "prestera_dsa.h"
>+
>+struct prestera_sdma_desc {
>+ __le32 word1;
>+ __le32 word2;
>+ __le32 buff;
>+ __le32 next;
>+} __packed __aligned(16);
>+
>+#define SDMA_BUFF_SIZE_MAX 1544
>+
>+#define SDMA_RX_DESC_PKT_LEN(desc) \
>+ ((le32_to_cpu((desc)->word2) >> 16) & 0x3FFF)
>+
>+#define SDMA_RX_DESC_OWNER(desc) \
>+ ((le32_to_cpu((desc)->word1) & BIT(31)) >> 31)
>+
>+#define SDMA_RX_DESC_CPU_OWN 0
>+#define SDMA_RX_DESC_DMA_OWN 1
>+
>+#define SDMA_RX_QUEUE_NUM 8
>+
>+#define SDMA_RX_DESC_PER_Q 1000
>+
>+#define SDMA_TX_DESC_PER_Q 1000
>+#define SDMA_TX_MAX_BURST 64
>+
>+#define SDMA_TX_DESC_OWNER(desc) \
>+ ((le32_to_cpu((desc)->word1) & BIT(31)) >> 31)
>+
>+#define SDMA_TX_DESC_CPU_OWN 0
>+#define SDMA_TX_DESC_DMA_OWN 1
>+
>+#define SDMA_TX_DESC_IS_SENT(desc) \
>+ (SDMA_TX_DESC_OWNER(desc) == SDMA_TX_DESC_CPU_OWN)
>+
>+#define SDMA_TX_DESC_LAST BIT(20)
>+#define SDMA_TX_DESC_FIRST BIT(21)
>+#define SDMA_TX_DESC_SINGLE (SDMA_TX_DESC_FIRST | SDMA_TX_DESC_LAST)
>+#define SDMA_TX_DESC_CALC_CRC BIT(12)
>+
>+#define SDMA_RX_INTR_MASK_REG 0x2814
>+#define SDMA_RX_QUEUE_STATUS_REG 0x2680
>+#define SDMA_RX_QUEUE_DESC_REG(n) (0x260C + (n) * 16)
>+
>+#define SDMA_TX_QUEUE_DESC_REG 0x26C0
>+#define SDMA_TX_QUEUE_START_REG 0x2868
You forgot to prefix these.
>+
>+struct prestera_sdma_buf {
>+ struct prestera_sdma_desc *desc;
>+ dma_addr_t desc_dma;
>+ struct sk_buff *skb;
>+ dma_addr_t buf_dma;
>+ bool is_used;
>+};
>+
>+struct prestera_rx_ring {
>+ struct prestera_sdma_buf *bufs;
>+ int next_rx;
>+};
>+
>+struct prestera_tx_ring {
>+ struct prestera_sdma_buf *bufs;
>+ int next_tx;
>+ int max_burst;
>+ int burst;
>+};
>+
>+struct prestera_sdma {
>+ struct prestera_rx_ring rx_ring[SDMA_RX_QUEUE_NUM];
>+ struct prestera_tx_ring tx_ring;
>+ const struct prestera_switch *sw;
>+ struct dma_pool *desc_pool;
>+ struct work_struct tx_work;
>+ struct napi_struct rx_napi;
>+ struct net_device napi_dev;
>+ u32 map_addr;
>+ u64 dma_mask;
>+};
>+
>+struct prestera_rxtx {
>+ struct prestera_sdma sdma;
>+};
>+
>+static int prestera_sdma_buf_init(struct prestera_sdma *sdma,
>+ struct prestera_sdma_buf *buf)
>+{
>+ struct device *dma_dev = sdma->sw->dev->dev;
>+ struct prestera_sdma_desc *desc;
>+ dma_addr_t dma;
>+
>+ desc = dma_pool_alloc(sdma->desc_pool, GFP_DMA | GFP_KERNEL, &dma);
>+ if (!desc)
>+ return -ENOMEM;
>+
>+ if (dma + sizeof(struct prestera_sdma_desc) > sdma->dma_mask) {
>+ dev_err(dma_dev, "failed to alloc desc\n");
>+ dma_pool_free(sdma->desc_pool, desc, dma);
>+ return -ENOMEM;
>+ }
>+
>+ buf->buf_dma = DMA_MAPPING_ERROR;
>+ buf->desc_dma = dma;
>+ buf->desc = desc;
>+ buf->skb = NULL;
>+
>+ return 0;
>+}
>+
>+static u32 prestera_sdma_map(struct prestera_sdma *sdma, dma_addr_t pa)
>+{
>+ return sdma->map_addr + pa;
>+}
>+
>+static void prestera_sdma_rx_desc_set_len(struct prestera_sdma_desc *desc,
>+ size_t val)
>+{
>+ u32 word = le32_to_cpu(desc->word2);
>+
>+ word = (word & ~GENMASK(15, 0)) | val;
>+ desc->word2 = cpu_to_le32(word);
>+}
>+
>+static void prestera_sdma_rx_desc_init(struct prestera_sdma *sdma,
>+ struct prestera_sdma_desc *desc,
>+ dma_addr_t buf)
>+{
>+ prestera_sdma_rx_desc_set_len(desc, SDMA_BUFF_SIZE_MAX);
>+ desc->buff = cpu_to_le32(prestera_sdma_map(sdma, buf));
>+
>+ /* make sure buffer is set before reset the descriptor */
>+ wmb();
>+
>+ desc->word1 = cpu_to_le32(0xA0000000);
>+}
>+
>+static void prestera_sdma_rx_desc_set_next(struct prestera_sdma *sdma,
>+ struct prestera_sdma_desc *desc,
>+ dma_addr_t next)
>+{
>+ desc->next = cpu_to_le32(prestera_sdma_map(sdma, next));
>+}
>+
>+static int prestera_sdma_rx_skb_alloc(struct prestera_sdma *sdma,
>+ struct prestera_sdma_buf *buf)
>+{
>+ struct device *dev = sdma->sw->dev->dev;
>+ struct sk_buff *skb;
>+ dma_addr_t dma;
>+
>+ skb = alloc_skb(SDMA_BUFF_SIZE_MAX, GFP_DMA | GFP_ATOMIC);
>+ if (!skb)
>+ return -ENOMEM;
>+
>+ dma = dma_map_single(dev, skb->data, skb->len, DMA_FROM_DEVICE);
>+
>+ if (dma_mapping_error(dev, dma))
>+ goto err_dma_map;
>+ if (dma + skb->len > sdma->dma_mask)
>+ goto err_dma_range;
>+
>+ if (buf->skb)
>+ dma_unmap_single(dev, buf->buf_dma, buf->skb->len,
>+ DMA_FROM_DEVICE);
>+
>+ buf->buf_dma = dma;
>+ buf->skb = skb;
>+ return 0;
>+
>+err_dma_range:
>+ dma_unmap_single(dev, dma, skb->len, DMA_FROM_DEVICE);
>+err_dma_map:
>+ kfree_skb(skb);
>+
>+ return -ENOMEM;
>+}
>+
>+static struct sk_buff *prestera_sdma_rx_skb_get(struct prestera_sdma *sdma,
>+ struct prestera_sdma_buf *buf)
>+{
>+ dma_addr_t buf_dma = buf->buf_dma;
>+ struct sk_buff *skb = buf->skb;
>+ u32 len = skb->len;
>+ int err;
>+
>+ err = prestera_sdma_rx_skb_alloc(sdma, buf);
>+ if (err) {
>+ buf->buf_dma = buf_dma;
>+ buf->skb = skb;
>+
>+ skb = alloc_skb(skb->len, GFP_ATOMIC);
>+ if (skb) {
>+ skb_put(skb, len);
>+ skb_copy_from_linear_data(buf->skb, skb->data, len);
>+ }
>+ }
>+
>+ prestera_sdma_rx_desc_init(sdma, buf->desc, buf->buf_dma);
>+
>+ return skb;
>+}
>+
>+static int prestera_rxtx_process_skb(struct sk_buff *skb)
>+{
>+ const struct prestera_port *port;
>+ struct prestera_dsa dsa;
>+ u32 hw_port, hw_id;
>+ int err;
>+
>+ skb_pull(skb, ETH_HLEN);
>+
>+ /* ethertype field is part of the dsa header */
>+ err = prestera_dsa_parse(&dsa, skb->data - ETH_TLEN);
>+ if (err)
>+ return err;
>+
>+ hw_port = dsa.port_num;
>+ hw_id = dsa.hw_dev_num;
>+
>+ port = prestera_port_find_by_hwid(hw_id, hw_port);
>+ if (unlikely(!port)) {
>+ pr_warn_ratelimited("prestera: received pkt for non-existent
>port(%u, %u)\n",
>+ hw_id, hw_port);
>+ return -EEXIST;
>+ }
>+
>+ if (unlikely(!pskb_may_pull(skb, PRESTERA_DSA_HLEN)))
>+ return -EINVAL;
>+
>+ /* remove DSA tag and update checksum */
>+ skb_pull_rcsum(skb, PRESTERA_DSA_HLEN);
>+
>+ memmove(skb->data - ETH_HLEN, skb->data - ETH_HLEN - PRESTERA_DSA_HLEN,
>+ ETH_ALEN * 2);
>+
>+ skb_push(skb, ETH_HLEN);
>+
>+ skb->protocol = eth_type_trans(skb, port->dev);
>+
>+ if (dsa.vlan.is_tagged) {
>+ u16 tci = dsa.vlan.vid & VLAN_VID_MASK;
>+
>+ tci |= dsa.vlan.vpt << VLAN_PRIO_SHIFT;
>+ if (dsa.vlan.cfi_bit)
>+ tci |= VLAN_CFI_MASK;
>+
>+ __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tci);
>+ }
>+
>+ return 0;
>+}
>+
>+static int prestera_sdma_rx_poll(struct napi_struct *napi, int budget)
>+{
>+ unsigned int qmask = GENMASK(SDMA_RX_QUEUE_NUM - 1, 0);
>+ struct prestera_sdma *sdma;
>+ unsigned int rxq_done_map = 0;
>+ struct list_head rx_list;
>+ int pkts_done = 0;
>+ int q;
>+
>+ INIT_LIST_HEAD(&rx_list);
>+
>+ sdma = container_of(napi, struct prestera_sdma, rx_napi);
>+
>+ while (pkts_done < budget && rxq_done_map != qmask) {
>+ for (q = 0; q < SDMA_RX_QUEUE_NUM && pkts_done < budget; q++) {
>+ struct prestera_rx_ring *ring = &sdma->rx_ring[q];
>+ int buf_idx = ring->next_rx;
>+ struct prestera_sdma_desc *desc;
>+ struct prestera_sdma_buf *buf;
>+ struct sk_buff *skb;
>+
>+ buf = &ring->bufs[buf_idx];
>+ desc = buf->desc;
>+
>+ if (SDMA_RX_DESC_OWNER(desc) != SDMA_RX_DESC_CPU_OWN) {
>+ rxq_done_map |= BIT(q);
>+ continue;
>+ } else {
>+ rxq_done_map &= ~BIT(q);
>+ }
>+
>+ pkts_done++;
>+
>+ __skb_trim(buf->skb, SDMA_RX_DESC_PKT_LEN(desc));
>+
>+ skb = prestera_sdma_rx_skb_get(sdma, buf);
>+ if (!skb)
>+ goto rx_next_buf;
>+
>+ if (unlikely(prestera_rxtx_process_skb(skb)))
>+ goto rx_next_buf;
>+
>+ list_add_tail(&skb->list, &rx_list);
>+rx_next_buf:
>+ ring->next_rx = (buf_idx + 1) % SDMA_RX_DESC_PER_Q;
>+ }
>+ }
>+
>+ if (pkts_done < budget && napi_complete_done(napi, pkts_done))
>+ prestera_write(sdma->sw, SDMA_RX_INTR_MASK_REG, 0xff << 2);
>+
>+ netif_receive_skb_list(&rx_list);
>+
>+ return pkts_done;
>+}
>+
>+static void prestera_sdma_rx_fini(struct prestera_sdma *sdma)
>+{
>+ int q, b;
>+
>+ /* disable all rx queues */
>+ prestera_write(sdma->sw, SDMA_RX_QUEUE_STATUS_REG, 0xff00);
>+
>+ for (q = 0; q < SDMA_RX_QUEUE_NUM; q++) {
>+ struct prestera_rx_ring *ring = &sdma->rx_ring[q];
>+
>+ if (!ring->bufs)
>+ break;
>+
>+ for (b = 0; b < SDMA_RX_DESC_PER_Q; b++) {
>+ struct prestera_sdma_buf *buf = &ring->bufs[b];
>+
>+ if (buf->desc_dma)
>+ dma_pool_free(sdma->desc_pool, buf->desc,
>+ buf->desc_dma);
>+
>+ if (!buf->skb)
>+ continue;
>+
>+ if (buf->buf_dma != DMA_MAPPING_ERROR)
>+ dma_unmap_single(sdma->sw->dev->dev,
>+ buf->buf_dma, buf->skb->len,
>+ DMA_FROM_DEVICE);
>+ kfree_skb(buf->skb);
>+ }
>+ }
>+}
>+
>+static int prestera_sdma_rx_init(struct prestera_sdma *sdma)
>+{
>+ int q, b;
>+ int err;
>+
>+ /* disable all rx queues */
>+ prestera_write(sdma->sw, SDMA_RX_QUEUE_STATUS_REG, 0xff00);
>+
>+ for (q = 0; q < SDMA_RX_QUEUE_NUM; q++) {
>+ struct prestera_rx_ring *ring = &sdma->rx_ring[q];
>+ struct prestera_sdma_buf *head;
>+
>+ ring->bufs = kmalloc_array(SDMA_RX_DESC_PER_Q, sizeof(*head),
>+ GFP_KERNEL);
>+ if (!ring->bufs)
>+ return -ENOMEM;
>+
>+ head = &ring->bufs[0];
>+ ring->next_rx = 0;
>+
>+ for (b = 0; b < SDMA_RX_DESC_PER_Q; b++) {
>+ struct prestera_sdma_buf *buf = &ring->bufs[b];
>+
>+ err = prestera_sdma_buf_init(sdma, buf);
>+ if (err)
>+ return err;
>+
>+ err = prestera_sdma_rx_skb_alloc(sdma, buf);
>+ if (err)
>+ return err;
>+
>+ prestera_sdma_rx_desc_init(sdma, buf->desc,
>+ buf->buf_dma);
>+
>+ if (b == 0)
>+ continue;
>+
>+ prestera_sdma_rx_desc_set_next(sdma,
>+ ring->bufs[b - 1].desc,
>+ buf->desc_dma);
>+
>+ if (b == SDMA_RX_DESC_PER_Q - 1)
>+ prestera_sdma_rx_desc_set_next(sdma, buf->desc,
>+ head->desc_dma);
>+ }
>+
>+ prestera_write(sdma->sw, SDMA_RX_QUEUE_DESC_REG(q),
>+ prestera_sdma_map(sdma, head->desc_dma));
>+ }
>+
>+ /* make sure all rx descs are filled before enabling all rx queues */
>+ wmb();
>+
>+ prestera_write(sdma->sw, SDMA_RX_QUEUE_STATUS_REG, 0xff);
>+
>+ return 0;
>+}
>+
>+static void prestera_sdma_tx_desc_init(struct prestera_sdma *sdma,
>+ struct prestera_sdma_desc *desc)
>+{
>+ desc->word1 = cpu_to_le32(SDMA_TX_DESC_SINGLE | SDMA_TX_DESC_CALC_CRC);
>+ desc->word2 = 0;
>+}
>+
>+static void prestera_sdma_tx_desc_set_next(struct prestera_sdma *sdma,
>+ struct prestera_sdma_desc *desc,
>+ dma_addr_t next)
>+{
>+ desc->next = cpu_to_le32(prestera_sdma_map(sdma, next));
>+}
>+
>+static void prestera_sdma_tx_desc_set_buf(struct prestera_sdma *sdma,
>+ struct prestera_sdma_desc *desc,
>+ dma_addr_t buf, size_t len)
>+{
>+ u32 word = le32_to_cpu(desc->word2);
>+
>+ word = (word & ~GENMASK(30, 16)) | ((len + ETH_FCS_LEN) << 16);
>+
>+ desc->buff = cpu_to_le32(prestera_sdma_map(sdma, buf));
>+ desc->word2 = cpu_to_le32(word);
>+}
>+
>+static void prestera_sdma_tx_desc_xmit(struct prestera_sdma_desc *desc)
>+{
>+ u32 word = le32_to_cpu(desc->word1);
>+
>+ word |= (SDMA_TX_DESC_DMA_OWN << 31);
Drop the ()s here.
>+
>+ /* make sure everything is written before enable xmit */
>+ wmb();
>+
>+ desc->word1 = cpu_to_le32(word);
>+}
>+
>+static int prestera_sdma_tx_buf_map(struct prestera_sdma *sdma,
>+ struct prestera_sdma_buf *buf,
>+ struct sk_buff *skb)
>+{
>+ struct device *dma_dev = sdma->sw->dev->dev;
>+ struct sk_buff *new_skb;
>+ size_t len = skb->len;
>+ dma_addr_t dma;
>+
>+ dma = dma_map_single(dma_dev, skb->data, len, DMA_TO_DEVICE);
>+ if (!dma_mapping_error(dma_dev, dma) && dma + len <= sdma->dma_mask) {
>+ buf->buf_dma = dma;
>+ buf->skb = skb;
>+ return 0;
>+ }
>+
>+ if (!dma_mapping_error(dma_dev, dma))
>+ dma_unmap_single(dma_dev, dma, len, DMA_TO_DEVICE);
>+
>+ new_skb = alloc_skb(len, GFP_ATOMIC | GFP_DMA);
>+ if (!new_skb)
>+ goto err_alloc_skb;
>+
>+ dma = dma_map_single(dma_dev, new_skb->data, len, DMA_TO_DEVICE);
>+ if (dma_mapping_error(dma_dev, dma))
>+ goto err_dma_map;
>+ if (dma + len > sdma->dma_mask)
>+ goto err_dma_range;
>+
>+ skb_copy_from_linear_data(skb, skb_put(new_skb, len), len);
>+
>+ dev_consume_skb_any(skb);
>+
>+ buf->skb = new_skb;
>+ buf->buf_dma = dma;
>+
>+ return 0;
>+
>+err_dma_range:
>+ dma_unmap_single(dma_dev, dma, len, DMA_TO_DEVICE);
>+err_dma_map:
>+ dev_kfree_skb(new_skb);
>+err_alloc_skb:
>+ dev_kfree_skb(skb);
>+
>+ return -ENOMEM;
>+}
>+
>+static void prestera_sdma_tx_buf_unmap(struct prestera_sdma *sdma,
>+ struct prestera_sdma_buf *buf)
>+{
>+ struct device *dma_dev = sdma->sw->dev->dev;
>+
>+ dma_unmap_single(dma_dev, buf->buf_dma, buf->skb->len, DMA_TO_DEVICE);
>+}
>+
>+static void prestera_sdma_tx_recycle_work_fn(struct work_struct *work)
>+{
>+ struct prestera_tx_ring *tx_ring;
>+ struct prestera_sdma *sdma;
>+ struct device *dma_dev;
>+ int b;
>+
>+ sdma = container_of(work, struct prestera_sdma, tx_work);
>+
>+ dma_dev = sdma->sw->dev->dev;
>+ tx_ring = &sdma->tx_ring;
>+
>+ for (b = 0; b < SDMA_TX_DESC_PER_Q; b++) {
>+ struct prestera_sdma_buf *buf = &tx_ring->bufs[b];
>+
>+ if (!buf->is_used)
>+ continue;
>+
>+ if (!SDMA_TX_DESC_IS_SENT(buf->desc))
>+ continue;
>+
>+ prestera_sdma_tx_buf_unmap(sdma, buf);
>+ dev_consume_skb_any(buf->skb);
>+ buf->skb = NULL;
>+
>+ /* make sure everything is cleaned up */
>+ wmb();
>+
>+ buf->is_used = false;
>+ }
>+}
>+
>+static int prestera_sdma_tx_init(struct prestera_sdma *sdma)
>+{
>+ struct prestera_tx_ring *tx_ring = &sdma->tx_ring;
>+ struct prestera_sdma_buf *head;
>+ int err;
>+ int b;
>+
>+ INIT_WORK(&sdma->tx_work, prestera_sdma_tx_recycle_work_fn);
>+
>+ tx_ring->bufs = kmalloc_array(SDMA_TX_DESC_PER_Q, sizeof(*head),
>+ GFP_KERNEL);
>+ if (!tx_ring->bufs)
>+ return -ENOMEM;
>+
>+ head = &tx_ring->bufs[0];
>+
>+ tx_ring->max_burst = SDMA_TX_MAX_BURST;
>+ tx_ring->burst = tx_ring->max_burst;
>+ tx_ring->next_tx = 0;
>+
>+ for (b = 0; b < SDMA_TX_DESC_PER_Q; b++) {
>+ struct prestera_sdma_buf *buf = &tx_ring->bufs[b];
>+
>+ err = prestera_sdma_buf_init(sdma, buf);
>+ if (err)
>+ return err;
>+
>+ prestera_sdma_tx_desc_init(sdma, buf->desc);
>+
>+ buf->is_used = false;
>+
>+ if (b == 0)
>+ continue;
>+
>+ prestera_sdma_tx_desc_set_next(sdma, tx_ring->bufs[b - 1].desc,
>+ buf->desc_dma);
>+
>+ if (b == SDMA_TX_DESC_PER_Q - 1)
>+ prestera_sdma_tx_desc_set_next(sdma, buf->desc,
>+ head->desc_dma);
>+ }
>+
>+ /* make sure descriptors are written */
>+ wmb();
>+
>+ prestera_write(sdma->sw, SDMA_TX_QUEUE_DESC_REG,
>+ prestera_sdma_map(sdma, head->desc_dma));
>+
>+ return 0;
>+}
>+
>+static void prestera_sdma_tx_fini(struct prestera_sdma *sdma)
>+{
>+ struct prestera_tx_ring *ring = &sdma->tx_ring;
>+ int b;
>+
>+ cancel_work_sync(&sdma->tx_work);
>+
>+ if (!ring->bufs)
>+ return;
>+
>+ for (b = 0; b < SDMA_TX_DESC_PER_Q; b++) {
>+ struct prestera_sdma_buf *buf = &ring->bufs[b];
>+
>+ if (buf->desc)
>+ dma_pool_free(sdma->desc_pool, buf->desc,
>+ buf->desc_dma);
>+
>+ if (!buf->skb)
>+ continue;
>+
>+ dma_unmap_single(sdma->sw->dev->dev, buf->buf_dma,
>+ buf->skb->len, DMA_TO_DEVICE);
>+
>+ dev_consume_skb_any(buf->skb);
>+ }
>+}
>+
>+static void prestera_rxtx_handle_event(struct prestera_switch *sw,
>+ struct prestera_event *evt,
>+ void *arg)
>+{
>+ struct prestera_sdma *sdma = arg;
>+
>+ if (evt->id != PRESTERA_RXTX_EVENT_RCV_PKT)
>+ return;
>+
>+ prestera_write(sdma->sw, SDMA_RX_INTR_MASK_REG, 0);
>+ napi_schedule(&sdma->rx_napi);
>+}
>+
>+int prestera_sdma_switch_init(struct prestera_switch *sw)
>+{
>+ struct prestera_sdma *sdma = &sw->rxtx->sdma;
>+ struct device *dev = sw->dev->dev;
>+ struct prestera_rxtx_params p;
>+ int err;
>+
>+ p.use_sdma = true;
>+
>+ err = prestera_hw_rxtx_init(sw, &p);
>+ if (err) {
>+ dev_err(dev, "failed to init rxtx by hw\n");
>+ return err;
>+ }
>+
>+ sdma->dma_mask = dma_get_mask(dev);
>+ sdma->map_addr = p.map_addr;
>+ sdma->sw = sw;
>+
>+ sdma->desc_pool = dma_pool_create("desc_pool", dev,
>+ sizeof(struct prestera_sdma_desc),
>+ 16, 0);
>+ if (!sdma->desc_pool)
>+ return -ENOMEM;
>+
>+ err = prestera_sdma_rx_init(sdma);
>+ if (err) {
>+ dev_err(dev, "failed to init rx ring\n");
>+ goto err_rx_init;
>+ }
>+
>+ err = prestera_sdma_tx_init(sdma);
>+ if (err) {
>+ dev_err(dev, "failed to init tx ring\n");
>+ goto err_tx_init;
>+ }
>+
>+ err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_RXTX,
>+ prestera_rxtx_handle_event,
>+ sdma);
>+ if (err)
>+ goto err_evt_register;
>+
>+ init_dummy_netdev(&sdma->napi_dev);
>+
>+ netif_napi_add(&sdma->napi_dev, &sdma->rx_napi, prestera_sdma_rx_poll,
>64);
>+ napi_enable(&sdma->rx_napi);
>+
>+ return 0;
>+
>+err_evt_register:
>+err_tx_init:
>+ prestera_sdma_tx_fini(sdma);
>+err_rx_init:
>+ prestera_sdma_rx_fini(sdma);
>+
>+ dma_pool_destroy(sdma->desc_pool);
>+ return err;
>+}
>+
>+void prestera_sdma_switch_fini(struct prestera_switch *sw)
>+{
>+ struct prestera_sdma *sdma = &sw->rxtx->sdma;
>+
>+ prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_RXTX,
>+ prestera_rxtx_handle_event);
>+ napi_disable(&sdma->rx_napi);
>+ netif_napi_del(&sdma->rx_napi);
>+ prestera_sdma_rx_fini(sdma);
>+ prestera_sdma_tx_fini(sdma);
>+ dma_pool_destroy(sdma->desc_pool);
>+}
>+
>+static int prestera_sdma_tx_wait(struct prestera_sdma *sdma,
>+ struct prestera_tx_ring *tx_ring)
>+{
>+ int tx_retry_num = 10 * tx_ring->max_burst;
>+
>+ while (--tx_retry_num) {
>+ if (!(prestera_read(sdma->sw, SDMA_TX_QUEUE_START_REG) & 1))
>+ return 0;
>+
>+ udelay(1);
>+ }
>+
>+ return -EBUSY;
>+}
>+
>+static void prestera_sdma_tx_start(struct prestera_sdma *sdma)
>+{
>+ prestera_write(sdma->sw, SDMA_TX_QUEUE_START_REG, 1);
>+ schedule_work(&sdma->tx_work);
>+}
>+
>+netdev_tx_t prestera_sdma_xmit(struct prestera_sdma *sdma, struct sk_buff
>*skb)
>+{
>+ struct device *dma_dev = sdma->sw->dev->dev;
>+ struct prestera_tx_ring *tx_ring;
>+ struct net_device *dev = skb->dev;
>+ struct prestera_sdma_buf *buf;
>+ int err;
>+
>+ tx_ring = &sdma->tx_ring;
>+
>+ buf = &tx_ring->bufs[tx_ring->next_tx];
>+ if (buf->is_used) {
>+ schedule_work(&sdma->tx_work);
>+ goto drop_skb;
>+ }
What is preventing 2 CPUs to get here and work with the same buf?
>+
>+ if (unlikely(eth_skb_pad(skb)))
>+ goto drop_skb_nofree;
>+
>+ err = prestera_sdma_tx_buf_map(sdma, buf, skb);
>+ if (err)
>+ goto drop_skb;
>+
>+ prestera_sdma_tx_desc_set_buf(sdma, buf->desc, buf->buf_dma, skb->len);
>+
>+ dma_sync_single_for_device(dma_dev, buf->buf_dma, skb->len,
>+ DMA_TO_DEVICE);
>+
>+ if (!tx_ring->burst--) {
>+ tx_ring->burst = tx_ring->max_burst;
>+
>+ err = prestera_sdma_tx_wait(sdma, tx_ring);
>+ if (err)
>+ goto drop_skb_unmap;
>+ }
>+
>+ tx_ring->next_tx = (tx_ring->next_tx + 1) % SDMA_TX_DESC_PER_Q;
>+ prestera_sdma_tx_desc_xmit(buf->desc);
>+ buf->is_used = true;
>+
>+ prestera_sdma_tx_start(sdma);
>+
>+ return NETDEV_TX_OK;
>+
>+drop_skb_unmap:
>+ prestera_sdma_tx_buf_unmap(sdma, buf);
>+drop_skb:
>+ dev_consume_skb_any(skb);
>+drop_skb_nofree:
>+ dev->stats.tx_dropped++;
>+ return NETDEV_TX_OK;
>+}
>+
>+int prestera_rxtx_switch_init(struct prestera_switch *sw)
>+{
>+ struct prestera_rxtx *rxtx;
>+
>+ rxtx = kzalloc(sizeof(*rxtx), GFP_KERNEL);
>+ if (!rxtx)
>+ return -ENOMEM;
>+
>+ sw->rxtx = rxtx;
>+
>+ return prestera_sdma_switch_init(sw);
>+}
>+
>+void prestera_rxtx_switch_fini(struct prestera_switch *sw)
>+{
>+ prestera_sdma_switch_fini(sw);
>+ kfree(sw->rxtx);
>+}
>+
>+int prestera_rxtx_port_init(struct prestera_port *port)
>+{
>+ int err;
>+
>+ err = prestera_hw_rxtx_port_init(port);
>+ if (err)
>+ return err;
>+
>+ port->dev->needed_headroom = PRESTERA_DSA_HLEN + ETH_FCS_LEN;
>+ return 0;
>+}
>+
>+netdev_tx_t prestera_rxtx_xmit(struct prestera_port *port, struct sk_buff
>*skb)
Why this has "rx" in the name??
>+{
>+ struct prestera_dsa dsa;
>+
>+ dsa.hw_dev_num = port->dev_id;
>+ dsa.port_num = port->hw_id;
>+
>+ if (skb_cow_head(skb, PRESTERA_DSA_HLEN) < 0)
>+ return NET_XMIT_DROP;
>+
>+ skb_push(skb, PRESTERA_DSA_HLEN);
>+ memmove(skb->data, skb->data + PRESTERA_DSA_HLEN, 2 * ETH_ALEN);
>+
>+ if (prestera_dsa_build(&dsa, skb->data + 2 * ETH_ALEN) != 0)
>+ return NET_XMIT_DROP;
>+
>+ return prestera_sdma_xmit(&port->sw->rxtx->sdma, skb);
>+}
>diff --git a/drivers/net/ethernet/marvell/prestera/prestera_rxtx.h
>b/drivers/net/ethernet/marvell/prestera/prestera_rxtx.h
>new file mode 100644
>index 000000000000..bbbadfa5accf
>--- /dev/null
>+++ b/drivers/net/ethernet/marvell/prestera/prestera_rxtx.h
>@@ -0,0 +1,21 @@
>+/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
>+ *
>+ * Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved.
>+ *
>+ */
>+
>+#ifndef _PRESTERA_RXTX_H_
>+#define _PRESTERA_RXTX_H_
>+
>+#include <linux/netdevice.h>
>+
>+#include "prestera.h"
>+
>+int prestera_rxtx_switch_init(struct prestera_switch *sw);
>+void prestera_rxtx_switch_fini(struct prestera_switch *sw);
>+
>+int prestera_rxtx_port_init(struct prestera_port *port);
>+
>+netdev_tx_t prestera_rxtx_xmit(struct prestera_port *port, struct sk_buff
>*skb);
>+
>+#endif /* _PRESTERA_RXTX_H_ */
>--
>2.17.1
>
