mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-04-29 07:02:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'net-marvell-prestera-Add-Switchdev-driver-for-Prestera-family-ASIC-device-98DX3255-AC3x'

Browse Source 
Vadym Kochan says:

====================
net: marvell: prestera: Add Switchdev driver for Prestera family ASIC device 98DX3255 (AC3x)

Marvell Prestera 98DX3255 integrates up to 24 ports of 1GbE with 8
ports of 10GbE uplinks or 2 ports of 40Gbps stacking for a largely
wireless SMB deployment.

Prestera Switchdev is a firmware based driver that operates via PCI bus.  The
current implementation supports only boards designed for the Marvell Switchdev
solution and requires special firmware.

This driver implementation includes only L1, basic L2 support, and RX/TX.

The core Prestera switching logic is implemented in prestera_main.c, there is
an intermediate hw layer between core logic and firmware. It is
implemented in prestera_hw.c, the purpose of it is to encapsulate hw
related logic, in future there is a plan to support more devices with
different HW related configurations.

The following Switchdev features are supported:

    - VLAN-aware bridge offloading
    - VLAN-unaware bridge offloading
    - FDB offloading (learning, ageing)
    - Switchport configuration

The original firmware image is uploaded to the linux-firmware repository.

PATCH v9:
    1) Replace read_poll_timeout_atomic() by original 'do {} while()' loop
       because it works much better than read_poll_timeout_atomic()
       considering the TX rate. Also it fixes warning reported on v8.

    2) Use ENOENT instead of EEXIST when item is not found in few
       places - prestera_hw.c and prestera_rxtx.c

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices

PATCH v8:
    1) Put license in one line.

    2) Sort includes.

    3) Add missing comma for last enum member

    4) Return original error code from last called func
       in places where instead other error code was used.

    5) Add comma for last member in initialized struct in prestera_hw.c

    6) Do not initialize 'int err = 0' where it is not needed.

    7) Simplify device-tree "marvell,prestera" node parsing by removing not
       needed checking on 'np == NULL'.

    8) Use u32p_replace_bits() instead of open-coded ((word & ~mask) | val)

    9) Use dev_warn_ratelimited() instead of pr_warn_ratelimited to indicate the device
        instance in prestera_rxtx.c

    10) Simplify circular buffer list creation in prestera_sdma_{rx,tx}_init() by using
        do { } while (prev != tail) construction.

    11) Use MSEC_PER_SEC instead of hard-coded 1000.

    12) Use traditional error handling pattern:

       err = F();
       if (err)
           return err;

    13) Use ether_addr_copy() instead of memcpy() for mac FDB copying in prestera_hw.c

    14) Drop swdev->ageing_time member which is not used.

    15) Fix ageing macro to be in ms instead of seconds.

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices
	[2] net: marvell: prestera: Add PCI interface support
        [3] net: marvell: prestera: Add basic devlink support
	[4] net: marvell: prestera: Add ethtool interface support
	[5] net: marvell: prestera: Add Switchdev driver implementation

PATCH v7:
    1) Use ether_addr_copy() in prestera_main.c:prestera_port_set_mac_address()
       instead of memcpy().

    2) Removed not needed device's DMA address range check on
       dma_pool_alloc() in prestera_rxtx.c:prestera_sdma_buf_init(),
       this should be handled by dma_xxx() API considerig device's DMA mask.

    3) Removed not needed device's DMA address range check on
       dma_map_single() in prestera_rxtx.c:prestera_sdma_rx_skb_alloc(),
       this should be handled by dma_xxx() API considerig device's DMA mask.

    4) Add comment about port mac address limitation in the code where
       it is used and checked - prestera_main.c:

           - prestera_is_valid_mac_addr()
           - prestera_port_create()

    5) Add missing destroy_workqueue(swdev_wq) in prestera_switchdev.c:prestera_switchdev_init()
       on error path handling.

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices
        [5] net: marvell: prestera: Add Switchdev driver implementation

PATCH v6:
    1) Use rwlock to protect port list on create/delete stages. The list
       is mostly readable by fw event handler or packets receiver, but
       updated only on create/delete port which are performed on switch init/fini
       stages.

    2) Remove not needed variable initialization in prestera_dsa.c:prestera_dsa_parse()

    3) Get rid of bounce buffer used by tx handler in prestera_rxtx.c,
       the bounce buffer should be handled by dma_xxx API via swiotlb.

    4) Fix PRESTERA_SDMA_RX_DESC_PKT_LEN macro by using correct GENMASK(13, 0) in prestera_rxtx.c

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices

PATCH v5:
    0) add Co-developed tags for people who was involved in development.

    1) Make SPDX license as separate comment

    2) Change 'u8 *' -> 'void *', It allows to avoid not-needed u8* casting.

    3) Remove "," in terminated enum's.

    4) Use GENMASK(end, start) where it is applicable in.

    5) Remove not-needed 'u8 *' casting.

    6) Apply common error-check pattern

    7) Use ether_addr_copy instead of memcpy

    8) Use define for maximum MAC address range (255)

    9) Simplify prestera_port_state_set() in prestera_main.c by
       using separate if-blocks for state setting:

        if (is_up) {
        ...
        } else {
        ...
        }

      which makes logic more understandable.

    10) Simplify sdma tx wait logic when checking/updating tx_ring->burst.

    11) Remove not-needed packed & aligned attributes

    12) Use USEC_PER_MSEC as multiplier when converting ms -> usec on calling
        readl_poll_timeout.

    13) Simplified some error path handling by simple return error code in.

    14) Remove not-needed err assignment in.

    15) Use dev_err() in prestera_devlink_register(...).

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices
	[2] net: marvell: prestera: Add PCI interface support
        [3] net: marvell: prestera: Add basic devlink support
	[4] net: marvell: prestera: Add ethtool interface support
	[5] net: marvell: prestera: Add Switchdev driver implementation

PATCH v4:
    1) Use prestera_ prefix in netdev_ops variable.

    2) Kconfig: use 'default PRESTERA' build type for CONFIG_PRESTERA_PCI to be
       synced by default with prestera core module.

    3) Use memcpy_xxio helpers in prestera_pci.c for IO buffer copying.

    4) Generate fw image path via snprintf() instead of macroses.

    5) Use pcim_ helpers in prestera_pci.c which simplified the
       probe/remove logic.

    6) Removed not needed initializations of variables which are used in
       readl_poll_xxx() helpers.

    7) Fixed few grammar mistakes in patch[2] description.

    8) Export only prestera_ethtool_ops struct instead of each
       ethtool handler.

    9) Add check for prestera_dev_check() in switchdev event handling to
       make sure there is no wrong topology.

    Patches updated:
        [1] net: marvell: prestera: Add driver for Prestera family ASIC devices
	[2] net: marvell: prestera: Add PCI interface support
	[4] net: marvell: prestera: Add ethtool interface support
	[5] net: marvell: prestera: Add Switchdev driver implementation

PATCH v3:
    1) Simplify __be32 type casting in prestera_dsa.c

    2) Added per-patch changelog under "---" line.

PATCH v2:
    1) Use devlink_port_type_clear()

    2) Add _MS prefix to timeout defines.

    3) Remove not-needed packed attribute from the firmware ipc structs,
       also the firmware image needs to be uploaded too (will do it soon).

    4) Introduce prestera_hw_switch_fini(), to be mirrored with init and
       do simple validation if the event handlers are unregistered.

    5) Use kfree_rcu() for event handler unregistering.

    6) Get rid of rcu-list usage when dealing with ports, not needed for
       now.

    7) Little spelling corrections in the error/info messages.

    8) Make pci probe & remove logic mirrored.

    9) Get rid of ETH_FCS_LEN in headroom setting, not needed.

PATCH:
    1) Fixed W=1 warnings

    2) Renamed PCI driver name to be more generic "Prestera DX" because
       there will be more devices supported.

    3) Changed firmware image dir path: marvell/ -> mrvl/prestera/
       to be aligned with location in linux-firmware.git (if such
       will be accepted).

RFC v3:
    1) Fix prestera prefix in prestera_rxtx.c

    2) Protect concurrent access from multiple ports on multiple CPU system
       on tx path by spinlock in prestera_rxtx.c

    3) Try to get base mac address from device-tree, otherwise use a random generated one.

    4) Move ethtool interface support into separate prestera_ethtool.c file.

    5) Add basic devlink support and get rid of physical port naming ops.

    6) Add STP support in Switchdev driver.

    7) Removed MODULE_AUTHOR

    8) Renamed prestera.c -> prestera_main.c, and kernel module to
       prestera.ko

RFC v2:
    1) Use "pestera_" prefix in struct's and functions instead of mvsw_pr_

    2) Original series split into additional patches for Switchdev ethtool support.

    3) Use major and minor firmware version numbers in the firmware image filename.

    4) Removed not needed prints.

    5) Use iopoll API for waiting on register's value in prestera_pci.c

    6) Use standart approach for describing PCI ID matching section instead of using
       custom wrappers in prestera_pci.c

    7) Add RX/TX support in prestera_rxtx.c.

    8) Rewritten prestera_switchdev.c with following changes:
       - handle netdev events from prestera.c

       - use struct prestera_bridge for bridge objects, and get rid of
         struct prestera_bridge_device which may confuse.

       - use refcount_t

    9) Get rid of macro usage for sending fw requests in prestera_hw.c

    10) Add base_mac setting as module parameter. base_mac is required for
        generation default port's mac.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
2020-09-17 16:35:47 -07:00
parent 5114b33105 40acc05271
commit 3ce406bda0
20 changed files with 6335 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
Documentation/devicetree/bindings/net/marvell,prestera.txt
View File

@@ -45,3 +45,37 @@ dfx-server {
ranges = <0 MBUS_ID(0x08, 0x00) 0 0x100000>;
reg = <MBUS_ID(0x08, 0x00) 0 0x100000>;
};
Marvell Prestera SwitchDev bindings
-----------------------------------
Optional properties:
- compatible: must be "marvell,prestera"
- base-mac-provider: describes handle to node which provides base mac address,
might be a static base mac address or nvme cell provider.
Example:
eeprom_mac_addr: eeprom-mac-addr {
compatible = "eeprom,mac-addr-cell";
status = "okay";
nvmem = <&eeprom_at24>;
};
prestera {
compatible = "marvell,prestera";
status = "okay";
base-mac-provider = <&eeprom_mac_addr>;
};
The current implementation of Prestera Switchdev PCI interface driver requires
that BAR2 is assigned to 0xf6000000 as base address from the PCI IO range:
&cp0_pcie0 {
ranges = <0x81000000 0x0 0xfb000000 0x0 0xfb000000 0x0 0xf0000
0x82000000 0x0 0xf6000000 0x0 0xf6000000 0x0 0x2000000
0x82000000 0x0 0xf9000000 0x0 0xf9000000 0x0 0x100000>;
phys = <&cp0_comphy0 0>;
status = "okay";
};

1
drivers/net/ethernet/marvell/Kconfig
View File

@@ -178,5 +178,6 @@ config SKY2_DEBUG
source "drivers/net/ethernet/marvell/octeontx2/Kconfig"
source "drivers/net/ethernet/marvell/prestera/Kconfig"
endif # NET_VENDOR_MARVELL

1
drivers/net/ethernet/marvell/Makefile
View File

@@ -12,3 +12,4 @@ obj-$(CONFIG_PXA168_ETH) += pxa168_eth.o
obj-$(CONFIG_SKGE) += skge.o
obj-$(CONFIG_SKY2) += sky2.o
obj-y += octeontx2/
obj-y += prestera/

25
drivers/net/ethernet/marvell/prestera/Kconfig Normal file
View File

@@ -0,0 +1,25 @@
# SPDX-License-Identifier: GPL-2.0-only
#
# Marvell Prestera drivers configuration
#
config PRESTERA
tristate "Marvell Prestera Switch ASICs support"
depends on NET_SWITCHDEV && VLAN_8021Q
select NET_DEVLINK
help
This driver supports Marvell Prestera Switch ASICs family.
To compile this driver as a module, choose M here: the
module will be called prestera.
config PRESTERA_PCI
tristate "PCI interface driver for Marvell Prestera Switch ASICs family"
depends on PCI && HAS_IOMEM && PRESTERA
default PRESTERA
help
This is implementation of PCI interface support for Marvell Prestera
Switch ASICs family.
To compile this driver as a module, choose M here: the
module will be called prestera_pci.

7
drivers/net/ethernet/marvell/prestera/Makefile Normal file
View File

@@ -0,0 +1,7 @@
# SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_PRESTERA) += prestera.o
prestera-objs := prestera_main.o prestera_hw.o prestera_dsa.o \
prestera_rxtx.o prestera_devlink.o prestera_ethtool.o \
prestera_switchdev.o
obj-$(CONFIG_PRESTERA_PCI) += prestera_pci.o

206
drivers/net/ethernet/marvell/prestera/prestera.h Normal file
View File

@@ -0,0 +1,206 @@
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved. */
#ifndef _PRESTERA_H_
#define _PRESTERA_H_
#include <linux/notifier.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <net/devlink.h>
#include <uapi/linux/if_ether.h>
#define PRESTERA_DRV_NAME "prestera"
#define PRESTERA_DEFAULT_VID 1
struct prestera_fw_rev {
u16 maj;
u16 min;
u16 sub;
};
struct prestera_port_stats {
u64 good_octets_received;
u64 bad_octets_received;
u64 mac_trans_error;
u64 broadcast_frames_received;
u64 multicast_frames_received;
u64 frames_64_octets;
u64 frames_65_to_127_octets;
u64 frames_128_to_255_octets;
u64 frames_256_to_511_octets;
u64 frames_512_to_1023_octets;
u64 frames_1024_to_max_octets;
u64 excessive_collision;
u64 multicast_frames_sent;
u64 broadcast_frames_sent;
u64 fc_sent;
u64 fc_received;
u64 buffer_overrun;
u64 undersize;
u64 fragments;
u64 oversize;
u64 jabber;
u64 rx_error_frame_received;
u64 bad_crc;
u64 collisions;
u64 late_collision;
u64 unicast_frames_received;
u64 unicast_frames_sent;
u64 sent_multiple;
u64 sent_deferred;
u64 good_octets_sent;
};
struct prestera_port_caps {
u64 supp_link_modes;
u8 supp_fec;
u8 type;
u8 transceiver;
};
struct prestera_port {
struct net_device *dev;
struct prestera_switch *sw;
struct devlink_port dl_port;
u32 id;
u32 hw_id;
u32 dev_id;
u16 fp_id;
u16 pvid;
bool autoneg;
u64 adver_link_modes;
u8 adver_fec;
struct prestera_port_caps caps;
struct list_head list;
struct list_head vlans_list;
struct {
struct prestera_port_stats stats;
struct delayed_work caching_dw;
} cached_hw_stats;
};
struct prestera_device {
struct device *dev;
u8 __iomem *ctl_regs;
u8 __iomem *pp_regs;
struct prestera_fw_rev fw_rev;
void *priv;
/* called by device driver to handle received packets */
void (*recv_pkt)(struct prestera_device *dev);
/* called by device driver to pass event up to the higher layer */
int (*recv_msg)(struct prestera_device *dev, void *msg, size_t size);
/* called by higher layer to send request to the firmware */
int (*send_req)(struct prestera_device *dev, void *in_msg,
size_t in_size, void *out_msg, size_t out_size,
unsigned int wait);
};
enum prestera_event_type {
PRESTERA_EVENT_TYPE_UNSPEC,
PRESTERA_EVENT_TYPE_PORT,
PRESTERA_EVENT_TYPE_FDB,
PRESTERA_EVENT_TYPE_RXTX,
PRESTERA_EVENT_TYPE_MAX
};
enum prestera_rxtx_event_id {
PRESTERA_RXTX_EVENT_UNSPEC,
PRESTERA_RXTX_EVENT_RCV_PKT,
};
enum prestera_port_event_id {
PRESTERA_PORT_EVENT_UNSPEC,
PRESTERA_PORT_EVENT_STATE_CHANGED,
};
struct prestera_port_event {
u32 port_id;
union {
u32 oper_state;
} data;
};
enum prestera_fdb_event_id {
PRESTERA_FDB_EVENT_UNSPEC,
PRESTERA_FDB_EVENT_LEARNED,
PRESTERA_FDB_EVENT_AGED,
};
struct prestera_fdb_event {
u32 port_id;
u32 vid;
union {
u8 mac[ETH_ALEN];
} data;
};
struct prestera_event {
u16 id;
union {
struct prestera_port_event port_evt;
struct prestera_fdb_event fdb_evt;
};
};
struct prestera_switchdev;
struct prestera_rxtx;
struct prestera_switch {
struct prestera_device *dev;
struct prestera_switchdev *swdev;
struct prestera_rxtx *rxtx;
struct list_head event_handlers;
struct notifier_block netdev_nb;
char base_mac[ETH_ALEN];
struct list_head port_list;
rwlock_t port_list_lock;
u32 port_count;
u32 mtu_min;
u32 mtu_max;
u8 id;
};
struct prestera_rxtx_params {
bool use_sdma;
u32 map_addr;
};
#define prestera_dev(sw) ((sw)->dev->dev)
static inline void prestera_write(const struct prestera_switch *sw,
unsigned int reg, u32 val)
{
writel(val, sw->dev->pp_regs + reg);
}
static inline u32 prestera_read(const struct prestera_switch *sw,
unsigned int reg)
{
return readl(sw->dev->pp_regs + reg);
}
int prestera_device_register(struct prestera_device *dev);
void prestera_device_unregister(struct prestera_device *dev);
struct prestera_port *prestera_port_find_by_hwid(struct prestera_switch *sw,
u32 dev_id, u32 hw_id);
int prestera_port_autoneg_set(struct prestera_port *port, bool enable,
u64 adver_link_modes, u8 adver_fec);
struct prestera_port *prestera_find_port(struct prestera_switch *sw, u32 id);
struct prestera_port *prestera_port_dev_lower_find(struct net_device *dev);
int prestera_port_pvid_set(struct prestera_port *port, u16 vid);
bool prestera_netdev_check(const struct net_device *dev);
#endif /* _PRESTERA_H_ */

112
drivers/net/ethernet/marvell/prestera/prestera_devlink.c Normal file
View File

@@ -0,0 +1,112 @@
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
#include <net/devlink.h>
#include "prestera_devlink.h"
static int prestera_dl_info_get(struct devlink *dl,
struct devlink_info_req *req,
struct netlink_ext_ack *extack)
{
struct prestera_switch *sw = devlink_priv(dl);
char buf[16];
int err;
err = devlink_info_driver_name_put(req, PRESTERA_DRV_NAME);
if (err)
return err;
snprintf(buf, sizeof(buf), "%d.%d.%d",
sw->dev->fw_rev.maj,
sw->dev->fw_rev.min,
sw->dev->fw_rev.sub);
return devlink_info_version_running_put(req,
DEVLINK_INFO_VERSION_GENERIC_FW,
buf);
}
static const struct devlink_ops prestera_dl_ops = {
.info_get = prestera_dl_info_get,
};
struct prestera_switch *prestera_devlink_alloc(void)
{
struct devlink *dl;
dl = devlink_alloc(&prestera_dl_ops, sizeof(struct prestera_switch));
return devlink_priv(dl);
}
void prestera_devlink_free(struct prestera_switch *sw)
{
struct devlink *dl = priv_to_devlink(sw);
devlink_free(dl);
}
int prestera_devlink_register(struct prestera_switch *sw)
{
struct devlink *dl = priv_to_devlink(sw);
int err;
err = devlink_register(dl, sw->dev->dev);
if (err)
dev_err(prestera_dev(sw), "devlink_register failed: %d\n", err);
return err;
}
void prestera_devlink_unregister(struct prestera_switch *sw)
{
struct devlink *dl = priv_to_devlink(sw);
devlink_unregister(dl);
}
int prestera_devlink_port_register(struct prestera_port *port)
{
struct prestera_switch *sw = port->sw;
struct devlink *dl = priv_to_devlink(sw);
struct devlink_port_attrs attrs = {};
int err;
attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
attrs.phys.port_number = port->fp_id;
attrs.switch_id.id_len = sizeof(sw->id);
memcpy(attrs.switch_id.id, &sw->id, attrs.switch_id.id_len);
devlink_port_attrs_set(&port->dl_port, &attrs);
err = devlink_port_register(dl, &port->dl_port, port->fp_id);
if (err) {
dev_err(prestera_dev(sw), "devlink_port_register failed: %d\n", err);
return err;
}
return 0;
}
void prestera_devlink_port_unregister(struct prestera_port *port)
{
devlink_port_unregister(&port->dl_port);
}
void prestera_devlink_port_set(struct prestera_port *port)
{
devlink_port_type_eth_set(&port->dl_port, port->dev);
}
void prestera_devlink_port_clear(struct prestera_port *port)
{
devlink_port_type_clear(&port->dl_port);
}
struct devlink_port *prestera_devlink_get_port(struct net_device *dev)
{
struct prestera_port *port = netdev_priv(dev);
return &port->dl_port;
}

23
drivers/net/ethernet/marvell/prestera/prestera_devlink.h Normal file
View File

@@ -0,0 +1,23 @@
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved. */
#ifndef _PRESTERA_DEVLINK_H_
#define _PRESTERA_DEVLINK_H_
#include "prestera.h"
struct prestera_switch *prestera_devlink_alloc(void);
void prestera_devlink_free(struct prestera_switch *sw);
int prestera_devlink_register(struct prestera_switch *sw);
void prestera_devlink_unregister(struct prestera_switch *sw);
int prestera_devlink_port_register(struct prestera_port *port);
void prestera_devlink_port_unregister(struct prestera_port *port);
void prestera_devlink_port_set(struct prestera_port *port);
void prestera_devlink_port_clear(struct prestera_port *port);
struct devlink_port *prestera_devlink_get_port(struct net_device *dev);
#endif /* _PRESTERA_DEVLINK_H_ */

104
drivers/net/ethernet/marvell/prestera/prestera_dsa.c Normal file
View File

@@ -0,0 +1,104 @@
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2020 Marvell International Ltd. All rights reserved */
#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/errno.h>
#include <linux/string.h>
#include "prestera_dsa.h"
#define PRESTERA_DSA_W0_CMD GENMASK(31, 30)
#define PRESTERA_DSA_W0_IS_TAGGED BIT(29)
#define PRESTERA_DSA_W0_DEV_NUM GENMASK(28, 24)
#define PRESTERA_DSA_W0_PORT_NUM GENMASK(23, 19)
#define PRESTERA_DSA_W0_VPT GENMASK(15, 13)
#define PRESTERA_DSA_W0_EXT_BIT BIT(12)
#define PRESTERA_DSA_W0_VID GENMASK(11, 0)
#define PRESTERA_DSA_W1_EXT_BIT BIT(31)
#define PRESTERA_DSA_W1_CFI_BIT BIT(30)
#define PRESTERA_DSA_W1_PORT_NUM GENMASK(11, 10)
#define PRESTERA_DSA_W2_EXT_BIT BIT(31)
#define PRESTERA_DSA_W2_PORT_NUM BIT(20)
#define PRESTERA_DSA_W3_VID GENMASK(30, 27)
#define PRESTERA_DSA_W3_DST_EPORT GENMASK(23, 7)
#define PRESTERA_DSA_W3_DEV_NUM GENMASK(6, 0)
#define PRESTERA_DSA_VID GENMASK(15, 12)
#define PRESTERA_DSA_DEV_NUM GENMASK(11, 5)
int prestera_dsa_parse(struct prestera_dsa *dsa, const u8 *dsa_buf)
{
__be32 *dsa_words = (__be32 *)dsa_buf;
enum prestera_dsa_cmd cmd;
u32 words[4];
u32 field;
words[0] = ntohl(dsa_words[0]);
words[1] = ntohl(dsa_words[1]);
words[2] = ntohl(dsa_words[2]);
words[3] = ntohl(dsa_words[3]);
/* set the common parameters */
cmd = (enum prestera_dsa_cmd)FIELD_GET(PRESTERA_DSA_W0_CMD, words[0]);
/* only to CPU is supported */
if (unlikely(cmd != PRESTERA_DSA_CMD_TO_CPU))
return -EINVAL;
if (FIELD_GET(PRESTERA_DSA_W0_EXT_BIT, words[0]) == 0)
return -EINVAL;
if (FIELD_GET(PRESTERA_DSA_W1_EXT_BIT, words[1]) == 0)
return -EINVAL;
if (FIELD_GET(PRESTERA_DSA_W2_EXT_BIT, words[2]) == 0)
return -EINVAL;
field = FIELD_GET(PRESTERA_DSA_W3_VID, words[3]);
dsa->vlan.is_tagged = FIELD_GET(PRESTERA_DSA_W0_IS_TAGGED, words[0]);
dsa->vlan.cfi_bit = FIELD_GET(PRESTERA_DSA_W1_CFI_BIT, words[1]);
dsa->vlan.vpt = FIELD_GET(PRESTERA_DSA_W0_VPT, words[0]);
dsa->vlan.vid = FIELD_GET(PRESTERA_DSA_W0_VID, words[0]);
dsa->vlan.vid &= ~PRESTERA_DSA_VID;
dsa->vlan.vid |= FIELD_PREP(PRESTERA_DSA_VID, field);
field = FIELD_GET(PRESTERA_DSA_W3_DEV_NUM, words[3]);
dsa->hw_dev_num = FIELD_GET(PRESTERA_DSA_W0_DEV_NUM, words[0]);
dsa->hw_dev_num |= FIELD_PREP(PRESTERA_DSA_DEV_NUM, field);
dsa->port_num = (FIELD_GET(PRESTERA_DSA_W0_PORT_NUM, words[0]) << 0) |
(FIELD_GET(PRESTERA_DSA_W1_PORT_NUM, words[1]) << 5) |
(FIELD_GET(PRESTERA_DSA_W2_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 dev_num = dsa->hw_dev_num;
u32 words[4] = { 0 };
words[0] |= FIELD_PREP(PRESTERA_DSA_W0_CMD, PRESTERA_DSA_CMD_FROM_CPU);
words[0] |= FIELD_PREP(PRESTERA_DSA_W0_DEV_NUM, dev_num);
dev_num = FIELD_GET(PRESTERA_DSA_DEV_NUM, dev_num);
words[3] |= FIELD_PREP(PRESTERA_DSA_W3_DEV_NUM, dev_num);
words[3] |= FIELD_PREP(PRESTERA_DSA_W3_DST_EPORT, dsa->port_num);
words[0] |= FIELD_PREP(PRESTERA_DSA_W0_EXT_BIT, 1);
words[1] |= FIELD_PREP(PRESTERA_DSA_W1_EXT_BIT, 1);
words[2] |= FIELD_PREP(PRESTERA_DSA_W2_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;
}

35
drivers/net/ethernet/marvell/prestera/prestera_dsa.h Normal file
View File

@@ -0,0 +1,35 @@
/* 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 = 0,
/* DSA command is "From CPU" */
PRESTERA_DSA_CMD_FROM_CPU,
};
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_ */

780
drivers/net/ethernet/marvell/prestera/prestera_ethtool.c Normal file
View File

@@ -0,0 +1,780 @@
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
#include <linux/ethtool.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include "prestera_ethtool.h"
#include "prestera.h"
#include "prestera_hw.h"
#define PRESTERA_STATS_CNT \
(sizeof(struct prestera_port_stats) / sizeof(u64))
#define PRESTERA_STATS_IDX(name) \
(offsetof(struct prestera_port_stats, name) / sizeof(u64))
#define PRESTERA_STATS_FIELD(name) \
[PRESTERA_STATS_IDX(name)] = __stringify(name)
static const char driver_kind[] = "prestera";
static const struct prestera_link_mode {
enum ethtool_link_mode_bit_indices eth_mode;
u32 speed;
u64 pr_mask;
u8 duplex;
u8 port_type;
} port_link_modes[PRESTERA_LINK_MODE_MAX] = {
[PRESTERA_LINK_MODE_10baseT_Half] = {
.eth_mode = ETHTOOL_LINK_MODE_10baseT_Half_BIT,
.speed = 10,
.pr_mask = 1 << PRESTERA_LINK_MODE_10baseT_Half,
.duplex = PRESTERA_PORT_DUPLEX_HALF,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_10baseT_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_10baseT_Full_BIT,
.speed = 10,
.pr_mask = 1 << PRESTERA_LINK_MODE_10baseT_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_100baseT_Half] = {
.eth_mode = ETHTOOL_LINK_MODE_100baseT_Half_BIT,
.speed = 100,
.pr_mask = 1 << PRESTERA_LINK_MODE_100baseT_Half,
.duplex = PRESTERA_PORT_DUPLEX_HALF,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_100baseT_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_100baseT_Full_BIT,
.speed = 100,
.pr_mask = 1 << PRESTERA_LINK_MODE_100baseT_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_1000baseT_Half] = {
.eth_mode = ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
.speed = 1000,
.pr_mask = 1 << PRESTERA_LINK_MODE_1000baseT_Half,
.duplex = PRESTERA_PORT_DUPLEX_HALF,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_1000baseT_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
.speed = 1000,
.pr_mask = 1 << PRESTERA_LINK_MODE_1000baseT_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_1000baseX_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
.speed = 1000,
.pr_mask = 1 << PRESTERA_LINK_MODE_1000baseX_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_1000baseKX_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
.speed = 1000,
.pr_mask = 1 << PRESTERA_LINK_MODE_1000baseKX_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_2500baseX_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
.speed = 2500,
.pr_mask = 1 << PRESTERA_LINK_MODE_2500baseX_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
},
[PRESTERA_LINK_MODE_10GbaseKR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
.speed = 10000,
.pr_mask = 1 << PRESTERA_LINK_MODE_10GbaseKR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_10GbaseSR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
.speed = 10000,
.pr_mask = 1 << PRESTERA_LINK_MODE_10GbaseSR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_10GbaseLR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
.speed = 10000,
.pr_mask = 1 << PRESTERA_LINK_MODE_10GbaseLR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_20GbaseKR2_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT,
.speed = 20000,
.pr_mask = 1 << PRESTERA_LINK_MODE_20GbaseKR2_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_25GbaseCR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
.speed = 25000,
.pr_mask = 1 << PRESTERA_LINK_MODE_25GbaseCR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_DA,
},
[PRESTERA_LINK_MODE_25GbaseKR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
.speed = 25000,
.pr_mask = 1 << PRESTERA_LINK_MODE_25GbaseKR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_25GbaseSR_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
.speed = 25000,
.pr_mask = 1 << PRESTERA_LINK_MODE_25GbaseSR_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_40GbaseKR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
.speed = 40000,
.pr_mask = 1 << PRESTERA_LINK_MODE_40GbaseKR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_40GbaseCR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
.speed = 40000,
.pr_mask = 1 << PRESTERA_LINK_MODE_40GbaseCR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_DA,
},
[PRESTERA_LINK_MODE_40GbaseSR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
.speed = 40000,
.pr_mask = 1 << PRESTERA_LINK_MODE_40GbaseSR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_50GbaseCR2_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
.speed = 50000,
.pr_mask = 1 << PRESTERA_LINK_MODE_50GbaseCR2_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_DA,
},
[PRESTERA_LINK_MODE_50GbaseKR2_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
.speed = 50000,
.pr_mask = 1 << PRESTERA_LINK_MODE_50GbaseKR2_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_50GbaseSR2_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
.speed = 50000,
.pr_mask = 1 << PRESTERA_LINK_MODE_50GbaseSR2_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_100GbaseKR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
.speed = 100000,
.pr_mask = 1 << PRESTERA_LINK_MODE_100GbaseKR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_TP,
},
[PRESTERA_LINK_MODE_100GbaseSR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
.speed = 100000,
.pr_mask = 1 << PRESTERA_LINK_MODE_100GbaseSR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_FIBRE,
},
[PRESTERA_LINK_MODE_100GbaseCR4_Full] = {
.eth_mode = ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
.speed = 100000,
.pr_mask = 1 << PRESTERA_LINK_MODE_100GbaseCR4_Full,
.duplex = PRESTERA_PORT_DUPLEX_FULL,
.port_type = PRESTERA_PORT_TYPE_DA,
}
};
static const struct prestera_fec {
u32 eth_fec;
enum ethtool_link_mode_bit_indices eth_mode;
u8 pr_fec;
} port_fec_caps[PRESTERA_PORT_FEC_MAX] = {
[PRESTERA_PORT_FEC_OFF] = {
.eth_fec = ETHTOOL_FEC_OFF,
.eth_mode = ETHTOOL_LINK_MODE_FEC_NONE_BIT,
.pr_fec = 1 << PRESTERA_PORT_FEC_OFF,
},
[PRESTERA_PORT_FEC_BASER] = {
.eth_fec = ETHTOOL_FEC_BASER,
.eth_mode = ETHTOOL_LINK_MODE_FEC_BASER_BIT,
.pr_fec = 1 << PRESTERA_PORT_FEC_BASER,
},
[PRESTERA_PORT_FEC_RS] = {
.eth_fec = ETHTOOL_FEC_RS,
.eth_mode = ETHTOOL_LINK_MODE_FEC_RS_BIT,
.pr_fec = 1 << PRESTERA_PORT_FEC_RS,
}
};
static const struct prestera_port_type {
enum ethtool_link_mode_bit_indices eth_mode;
u8 eth_type;
} port_types[PRESTERA_PORT_TYPE_MAX] = {
[PRESTERA_PORT_TYPE_NONE] = {
.eth_mode = __ETHTOOL_LINK_MODE_MASK_NBITS,
.eth_type = PORT_NONE,
},
[PRESTERA_PORT_TYPE_TP] = {
.eth_mode = ETHTOOL_LINK_MODE_TP_BIT,
.eth_type = PORT_TP,
},
[PRESTERA_PORT_TYPE_AUI] = {
.eth_mode = ETHTOOL_LINK_MODE_AUI_BIT,
.eth_type = PORT_AUI,
},
[PRESTERA_PORT_TYPE_MII] = {
.eth_mode = ETHTOOL_LINK_MODE_MII_BIT,
.eth_type = PORT_MII,
},
[PRESTERA_PORT_TYPE_FIBRE] = {
.eth_mode = ETHTOOL_LINK_MODE_FIBRE_BIT,
.eth_type = PORT_FIBRE,
},
[PRESTERA_PORT_TYPE_BNC] = {
.eth_mode = ETHTOOL_LINK_MODE_BNC_BIT,
.eth_type = PORT_BNC,
},
[PRESTERA_PORT_TYPE_DA] = {
.eth_mode = ETHTOOL_LINK_MODE_TP_BIT,
.eth_type = PORT_TP,
},
[PRESTERA_PORT_TYPE_OTHER] = {
.eth_mode = __ETHTOOL_LINK_MODE_MASK_NBITS,
.eth_type = PORT_OTHER,
}
};
static const char prestera_cnt_name[PRESTERA_STATS_CNT][ETH_GSTRING_LEN] = {
PRESTERA_STATS_FIELD(good_octets_received),
PRESTERA_STATS_FIELD(bad_octets_received),
PRESTERA_STATS_FIELD(mac_trans_error),
PRESTERA_STATS_FIELD(broadcast_frames_received),
PRESTERA_STATS_FIELD(multicast_frames_received),
PRESTERA_STATS_FIELD(frames_64_octets),
PRESTERA_STATS_FIELD(frames_65_to_127_octets),
PRESTERA_STATS_FIELD(frames_128_to_255_octets),
PRESTERA_STATS_FIELD(frames_256_to_511_octets),
PRESTERA_STATS_FIELD(frames_512_to_1023_octets),
PRESTERA_STATS_FIELD(frames_1024_to_max_octets),
PRESTERA_STATS_FIELD(excessive_collision),
PRESTERA_STATS_FIELD(multicast_frames_sent),
PRESTERA_STATS_FIELD(broadcast_frames_sent),
PRESTERA_STATS_FIELD(fc_sent),
PRESTERA_STATS_FIELD(fc_received),
PRESTERA_STATS_FIELD(buffer_overrun),
PRESTERA_STATS_FIELD(undersize),
PRESTERA_STATS_FIELD(fragments),
PRESTERA_STATS_FIELD(oversize),
PRESTERA_STATS_FIELD(jabber),
PRESTERA_STATS_FIELD(rx_error_frame_received),
PRESTERA_STATS_FIELD(bad_crc),
PRESTERA_STATS_FIELD(collisions),
PRESTERA_STATS_FIELD(late_collision),
PRESTERA_STATS_FIELD(unicast_frames_received),
PRESTERA_STATS_FIELD(unicast_frames_sent),
PRESTERA_STATS_FIELD(sent_multiple),
PRESTERA_STATS_FIELD(sent_deferred),
PRESTERA_STATS_FIELD(good_octets_sent),
};
static void prestera_ethtool_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *drvinfo)
{
struct prestera_port *port = netdev_priv(dev);
struct prestera_switch *sw = port->sw;
strlcpy(drvinfo->driver, driver_kind, sizeof(drvinfo->driver));
strlcpy(drvinfo->bus_info, dev_name(prestera_dev(sw)),
sizeof(drvinfo->bus_info));
snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
"%d.%d.%d",
sw->dev->fw_rev.maj,
sw->dev->fw_rev.min,
sw->dev->fw_rev.sub);
}
static u8 prestera_port_type_get(struct prestera_port *port)
{
if (port->caps.type < PRESTERA_PORT_TYPE_MAX)
return port_types[port->caps.type].eth_type;
return PORT_OTHER;
}
static int prestera_port_type_set(const struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
u32 new_mode = PRESTERA_LINK_MODE_MAX;
u32 type, mode;
int err;
for (type = 0; type < PRESTERA_PORT_TYPE_MAX; type++) {
if (port_types[type].eth_type == ecmd->base.port &&
test_bit(port_types[type].eth_mode,
ecmd->link_modes.supported)) {
break;
}
}
if (type == port->caps.type)
return 0;
if (type != port->caps.type && ecmd->base.autoneg == AUTONEG_ENABLE)
return -EINVAL;
if (type == PRESTERA_PORT_TYPE_MAX)
return -EOPNOTSUPP;
for (mode = 0; mode < PRESTERA_LINK_MODE_MAX; mode++) {
if ((port_link_modes[mode].pr_mask &
port->caps.supp_link_modes) &&
type == port_link_modes[mode].port_type) {
new_mode = mode;
}
}
if (new_mode < PRESTERA_LINK_MODE_MAX)
err = prestera_hw_port_link_mode_set(port, new_mode);
else
err = -EINVAL;
if (err)
return err;
port->caps.type = type;
port->autoneg = false;
return 0;
}
static void prestera_modes_to_eth(unsigned long *eth_modes, u64 link_modes,
u8 fec, u8 type)
{
u32 mode;
for (mode = 0; mode < PRESTERA_LINK_MODE_MAX; mode++) {
if ((port_link_modes[mode].pr_mask & link_modes) == 0)
continue;
if (type != PRESTERA_PORT_TYPE_NONE &&
port_link_modes[mode].port_type != type)
continue;
__set_bit(port_link_modes[mode].eth_mode, eth_modes);
}
for (mode = 0; mode < PRESTERA_PORT_FEC_MAX; mode++) {
if ((port_fec_caps[mode].pr_fec & fec) == 0)
continue;
__set_bit(port_fec_caps[mode].eth_mode, eth_modes);
}
}
static void prestera_modes_from_eth(const unsigned long *eth_modes,
u64 *link_modes, u8 *fec, u8 type)
{
u64 adver_modes = 0;
u32 fec_modes = 0;
u32 mode;
for (mode = 0; mode < PRESTERA_LINK_MODE_MAX; mode++) {
if (!test_bit(port_link_modes[mode].eth_mode, eth_modes))
continue;
if (port_link_modes[mode].port_type != type)
continue;
adver_modes |= port_link_modes[mode].pr_mask;
}
for (mode = 0; mode < PRESTERA_PORT_FEC_MAX; mode++) {
if (!test_bit(port_fec_caps[mode].eth_mode, eth_modes))
continue;
fec_modes |= port_fec_caps[mode].pr_fec;
}
*link_modes = adver_modes;
*fec = fec_modes;
}
static void prestera_port_supp_types_get(struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
u32 mode;
u8 ptype;
for (mode = 0; mode < PRESTERA_LINK_MODE_MAX; mode++) {
if ((port_link_modes[mode].pr_mask &
port->caps.supp_link_modes) == 0)
continue;
ptype = port_link_modes[mode].port_type;
__set_bit(port_types[ptype].eth_mode,
ecmd->link_modes.supported);
}
}
static void prestera_port_remote_cap_get(struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
bool asym_pause;
bool pause;
u64 bitmap;
int err;
err = prestera_hw_port_remote_cap_get(port, &bitmap);
if (!err) {
prestera_modes_to_eth(ecmd->link_modes.lp_advertising,
bitmap, 0, PRESTERA_PORT_TYPE_NONE);
if (!bitmap_empty(ecmd->link_modes.lp_advertising,
__ETHTOOL_LINK_MODE_MASK_NBITS)) {
ethtool_link_ksettings_add_link_mode(ecmd,
lp_advertising,
Autoneg);
}
}
err = prestera_hw_port_remote_fc_get(port, &pause, &asym_pause);
if (err)
return;
if (pause)
ethtool_link_ksettings_add_link_mode(ecmd,
lp_advertising,
Pause);
if (asym_pause)
ethtool_link_ksettings_add_link_mode(ecmd,
lp_advertising,
Asym_Pause);
}
static void prestera_port_speed_get(struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
u32 speed;
int err;
err = prestera_hw_port_speed_get(port, &speed);
ecmd->base.speed = err ? SPEED_UNKNOWN : speed;
}
static void prestera_port_duplex_get(struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
u8 duplex;
int err;
err = prestera_hw_port_duplex_get(port, &duplex);
if (err) {
ecmd->base.duplex = DUPLEX_UNKNOWN;
return;
}
ecmd->base.duplex = duplex == PRESTERA_PORT_DUPLEX_FULL ?
DUPLEX_FULL : DUPLEX_HALF;
}
static int
prestera_ethtool_get_link_ksettings(struct net_device *dev,
struct ethtool_link_ksettings *ecmd)
{
struct prestera_port *port = netdev_priv(dev);
ethtool_link_ksettings_zero_link_mode(ecmd, supported);
ethtool_link_ksettings_zero_link_mode(ecmd, advertising);
ethtool_link_ksettings_zero_link_mode(ecmd, lp_advertising);
ecmd->base.autoneg = port->autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
if (port->caps.type == PRESTERA_PORT_TYPE_TP) {
ethtool_link_ksettings_add_link_mode(ecmd, supported, Autoneg);
if (netif_running(dev) &&
(port->autoneg ||
port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER))
ethtool_link_ksettings_add_link_mode(ecmd, advertising,
Autoneg);
}
prestera_modes_to_eth(ecmd->link_modes.supported,
port->caps.supp_link_modes,
port->caps.supp_fec,
port->caps.type);
prestera_port_supp_types_get(ecmd, port);
if (netif_carrier_ok(dev)) {
prestera_port_speed_get(ecmd, port);
prestera_port_duplex_get(ecmd, port);
} else {
ecmd->base.speed = SPEED_UNKNOWN;
ecmd->base.duplex = DUPLEX_UNKNOWN;
}
ecmd->base.port = prestera_port_type_get(port);
if (port->autoneg) {
if (netif_running(dev))
prestera_modes_to_eth(ecmd->link_modes.advertising,
port->adver_link_modes,
port->adver_fec,
port->caps.type);
if (netif_carrier_ok(dev) &&
port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER)
prestera_port_remote_cap_get(ecmd, port);
}
if (port->caps.type == PRESTERA_PORT_TYPE_TP &&
port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER)
prestera_hw_port_mdix_get(port, &ecmd->base.eth_tp_mdix,
&ecmd->base.eth_tp_mdix_ctrl);
return 0;
}
static int prestera_port_mdix_set(const struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
if (ecmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_INVALID &&
port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER &&
port->caps.type == PRESTERA_PORT_TYPE_TP)
return prestera_hw_port_mdix_set(port,
ecmd->base.eth_tp_mdix_ctrl);
return 0;
}
static int prestera_port_link_mode_set(struct prestera_port *port,
u32 speed, u8 duplex, u8 type)
{
u32 new_mode = PRESTERA_LINK_MODE_MAX;
u32 mode;
for (mode = 0; mode < PRESTERA_LINK_MODE_MAX; mode++) {
if (speed != port_link_modes[mode].speed)
continue;
if (duplex != port_link_modes[mode].duplex)
continue;
if (!(port_link_modes[mode].pr_mask &
port->caps.supp_link_modes))
continue;
if (type != port_link_modes[mode].port_type)
continue;
new_mode = mode;
break;
}
if (new_mode == PRESTERA_LINK_MODE_MAX)
return -EOPNOTSUPP;
return prestera_hw_port_link_mode_set(port, new_mode);
}
static int
prestera_port_speed_duplex_set(const struct ethtool_link_ksettings *ecmd,
struct prestera_port *port)
{
u32 curr_mode;
u8 duplex;
u32 speed;
int err;
err = prestera_hw_port_link_mode_get(port, &curr_mode);
if (err)
return err;
if (curr_mode >= PRESTERA_LINK_MODE_MAX)
return -EINVAL;
if (ecmd->base.duplex != DUPLEX_UNKNOWN)
duplex = ecmd->base.duplex == DUPLEX_FULL ?
PRESTERA_PORT_DUPLEX_FULL : PRESTERA_PORT_DUPLEX_HALF;
else
duplex = port_link_modes[curr_mode].duplex;
if (ecmd->base.speed != SPEED_UNKNOWN)
speed = ecmd->base.speed;
else
speed = port_link_modes[curr_mode].speed;
return prestera_port_link_mode_set(port, speed, duplex,
port->caps.type);
}
static int
prestera_ethtool_set_link_ksettings(struct net_device *dev,
const struct ethtool_link_ksettings *ecmd)
{
struct prestera_port *port = netdev_priv(dev);
u64 adver_modes;
u8 adver_fec;
int err;
err = prestera_port_type_set(ecmd, port);
if (err)
return err;
if (port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER) {
err = prestera_port_mdix_set(ecmd, port);
if (err)
return err;
}
prestera_modes_from_eth(ecmd->link_modes.advertising, &adver_modes,
&adver_fec, port->caps.type);
err = prestera_port_autoneg_set(port,
ecmd->base.autoneg == AUTONEG_ENABLE,
adver_modes, adver_fec);
if (err)
return err;
if (ecmd->base.autoneg == AUTONEG_DISABLE) {
err = prestera_port_speed_duplex_set(ecmd, port);
if (err)
return err;
}
return 0;
}
static int prestera_ethtool_get_fecparam(struct net_device *dev,
struct ethtool_fecparam *fecparam)
{
struct prestera_port *port = netdev_priv(dev);
u8 active;
u32 mode;
int err;
err = prestera_hw_port_fec_get(port, &active);
if (err)
return err;
fecparam->fec = 0;
for (mode = 0; mode < PRESTERA_PORT_FEC_MAX; mode++) {
if ((port_fec_caps[mode].pr_fec & port->caps.supp_fec) == 0)
continue;
fecparam->fec |= port_fec_caps[mode].eth_fec;
}
if (active < PRESTERA_PORT_FEC_MAX)
fecparam->active_fec = port_fec_caps[active].eth_fec;
else
fecparam->active_fec = ETHTOOL_FEC_AUTO;
return 0;
}
static int prestera_ethtool_set_fecparam(struct net_device *dev,
struct ethtool_fecparam *fecparam)
{
struct prestera_port *port = netdev_priv(dev);
u8 fec, active;
u32 mode;
int err;
if (port->autoneg) {
netdev_err(dev, "FEC set is not allowed while autoneg is on\n");
return -EINVAL;
}
err = prestera_hw_port_fec_get(port, &active);
if (err)
return err;
fec = PRESTERA_PORT_FEC_MAX;
for (mode = 0; mode < PRESTERA_PORT_FEC_MAX; mode++) {
if ((port_fec_caps[mode].eth_fec & fecparam->fec) &&
(port_fec_caps[mode].pr_fec & port->caps.supp_fec)) {
fec = mode;
break;
}
}
if (fec == active)
return 0;
if (fec == PRESTERA_PORT_FEC_MAX)
return -EOPNOTSUPP;
return prestera_hw_port_fec_set(port, fec);
}
static int prestera_ethtool_get_sset_count(struct net_device *dev, int sset)
{
switch (sset) {
case ETH_SS_STATS:
return PRESTERA_STATS_CNT;
default:
return -EOPNOTSUPP;
}
}
static void prestera_ethtool_get_strings(struct net_device *dev,
u32 stringset, u8 *data)
{
if (stringset != ETH_SS_STATS)
return;
memcpy(data, prestera_cnt_name, sizeof(prestera_cnt_name));
}
static void prestera_ethtool_get_stats(struct net_device *dev,
struct ethtool_stats *stats, u64 *data)
{
struct prestera_port *port = netdev_priv(dev);
struct prestera_port_stats *port_stats;
port_stats = &port->cached_hw_stats.stats;
memcpy(data, port_stats, sizeof(*port_stats));
}
static int prestera_ethtool_nway_reset(struct net_device *dev)
{
struct prestera_port *port = netdev_priv(dev);
if (netif_running(dev) &&
port->caps.transceiver == PRESTERA_PORT_TCVR_COPPER &&
port->caps.type == PRESTERA_PORT_TYPE_TP)
return prestera_hw_port_autoneg_restart(port);
return -EINVAL;
}
const struct ethtool_ops prestera_ethtool_ops = {
.get_drvinfo = prestera_ethtool_get_drvinfo,
.get_link_ksettings = prestera_ethtool_get_link_ksettings,
.set_link_ksettings = prestera_ethtool_set_link_ksettings,
.get_fecparam = prestera_ethtool_get_fecparam,
.set_fecparam = prestera_ethtool_set_fecparam,
.get_sset_count = prestera_ethtool_get_sset_count,
.get_strings = prestera_ethtool_get_strings,
.get_ethtool_stats = prestera_ethtool_get_stats,
.get_link = ethtool_op_get_link,
.nway_reset = prestera_ethtool_nway_reset
};

11
drivers/net/ethernet/marvell/prestera/prestera_ethtool.h Normal file
View File

@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved. */
#ifndef __PRESTERA_ETHTOOL_H_
#define __PRESTERA_ETHTOOL_H_
#include <linux/ethtool.h>
extern const struct ethtool_ops prestera_ethtool_ops;
#endif /* _PRESTERA_ETHTOOL_H_ */

1253
drivers/net/ethernet/marvell/prestera/prestera_hw.c Normal file
View File

File diff suppressed because it is too large Load Diff

182
drivers/net/ethernet/marvell/prestera/prestera_hw.h Normal file
View File

@@ -0,0 +1,182 @@
/* 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_accept_frm_type {
PRESTERA_ACCEPT_FRAME_TYPE_TAGGED,
PRESTERA_ACCEPT_FRAME_TYPE_UNTAGGED,
PRESTERA_ACCEPT_FRAME_TYPE_ALL,
};
enum prestera_fdb_flush_mode {
PRESTERA_FDB_FLUSH_MODE_DYNAMIC = BIT(0),
PRESTERA_FDB_FLUSH_MODE_STATIC = BIT(1),
PRESTERA_FDB_FLUSH_MODE_ALL = PRESTERA_FDB_FLUSH_MODE_DYNAMIC
| PRESTERA_FDB_FLUSH_MODE_STATIC,
};
enum {
PRESTERA_LINK_MODE_10baseT_Half,
PRESTERA_LINK_MODE_10baseT_Full,
PRESTERA_LINK_MODE_100baseT_Half,
PRESTERA_LINK_MODE_100baseT_Full,
PRESTERA_LINK_MODE_1000baseT_Half,
PRESTERA_LINK_MODE_1000baseT_Full,
PRESTERA_LINK_MODE_1000baseX_Full,
PRESTERA_LINK_MODE_1000baseKX_Full,
PRESTERA_LINK_MODE_2500baseX_Full,
PRESTERA_LINK_MODE_10GbaseKR_Full,
PRESTERA_LINK_MODE_10GbaseSR_Full,
PRESTERA_LINK_MODE_10GbaseLR_Full,
PRESTERA_LINK_MODE_20GbaseKR2_Full,
PRESTERA_LINK_MODE_25GbaseCR_Full,
PRESTERA_LINK_MODE_25GbaseKR_Full,
PRESTERA_LINK_MODE_25GbaseSR_Full,
PRESTERA_LINK_MODE_40GbaseKR4_Full,
PRESTERA_LINK_MODE_40GbaseCR4_Full,
PRESTERA_LINK_MODE_40GbaseSR4_Full,
PRESTERA_LINK_MODE_50GbaseCR2_Full,
PRESTERA_LINK_MODE_50GbaseKR2_Full,
PRESTERA_LINK_MODE_50GbaseSR2_Full,
PRESTERA_LINK_MODE_100GbaseKR4_Full,
PRESTERA_LINK_MODE_100GbaseSR4_Full,
PRESTERA_LINK_MODE_100GbaseCR4_Full,
PRESTERA_LINK_MODE_MAX
};
enum {
PRESTERA_PORT_TYPE_NONE,
PRESTERA_PORT_TYPE_TP,
PRESTERA_PORT_TYPE_AUI,
PRESTERA_PORT_TYPE_MII,
PRESTERA_PORT_TYPE_FIBRE,
PRESTERA_PORT_TYPE_BNC,
PRESTERA_PORT_TYPE_DA,
PRESTERA_PORT_TYPE_OTHER,
PRESTERA_PORT_TYPE_MAX
};
enum {
PRESTERA_PORT_TCVR_COPPER,
PRESTERA_PORT_TCVR_SFP,
PRESTERA_PORT_TCVR_MAX
};
enum {
PRESTERA_PORT_FEC_OFF,
PRESTERA_PORT_FEC_BASER,
PRESTERA_PORT_FEC_RS,
PRESTERA_PORT_FEC_MAX
};
enum {
PRESTERA_PORT_DUPLEX_HALF,
PRESTERA_PORT_DUPLEX_FULL,
};
enum {
PRESTERA_STP_DISABLED,
PRESTERA_STP_BLOCK_LISTEN,
PRESTERA_STP_LEARN,
PRESTERA_STP_FORWARD,
};
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);
void prestera_hw_switch_fini(struct prestera_switch *sw);
int prestera_hw_switch_ageing_set(struct prestera_switch *sw, u32 ageing_ms);
int prestera_hw_switch_mac_set(struct prestera_switch *sw, const char *mac);
/* Port API */
int prestera_hw_port_info_get(const struct prestera_port *port,
u32 *dev_id, u32 *hw_id, u16 *fp_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, const 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_remote_cap_get(const struct prestera_port *port,
u64 *link_mode_bitmap);
int prestera_hw_port_remote_fc_get(const struct prestera_port *port,
bool *pause, bool *asym_pause);
int prestera_hw_port_type_get(const struct prestera_port *port, u8 *type);
int prestera_hw_port_fec_get(const struct prestera_port *port, u8 *fec);
int prestera_hw_port_fec_set(const struct prestera_port *port, u8 fec);
int prestera_hw_port_autoneg_set(const struct prestera_port *port,
bool autoneg, u64 link_modes, u8 fec);
int prestera_hw_port_autoneg_restart(struct prestera_port *port);
int prestera_hw_port_duplex_get(const struct prestera_port *port, u8 *duplex);
int prestera_hw_port_stats_get(const struct prestera_port *port,
struct prestera_port_stats *stats);
int prestera_hw_port_link_mode_set(const struct prestera_port *port, u32 mode);
int prestera_hw_port_link_mode_get(const struct prestera_port *port, u32 *mode);
int prestera_hw_port_mdix_get(const struct prestera_port *port, u8 *status,
u8 *admin_mode);
int prestera_hw_port_mdix_set(const struct prestera_port *port, u8 mode);
int prestera_hw_port_speed_get(const struct prestera_port *port, u32 *speed);
int prestera_hw_port_learning_set(struct prestera_port *port, bool enable);
int prestera_hw_port_flood_set(struct prestera_port *port, bool flood);
int prestera_hw_port_accept_frm_type(struct prestera_port *port,
enum prestera_accept_frm_type type);
/* Vlan API */
int prestera_hw_vlan_create(struct prestera_switch *sw, u16 vid);
int prestera_hw_vlan_delete(struct prestera_switch *sw, u16 vid);
int prestera_hw_vlan_port_set(struct prestera_port *port, u16 vid,
bool is_member, bool untagged);
int prestera_hw_vlan_port_vid_set(struct prestera_port *port, u16 vid);
int prestera_hw_vlan_port_stp_set(struct prestera_port *port, u16 vid, u8 state);
/* FDB API */
int prestera_hw_fdb_add(struct prestera_port *port, const unsigned char *mac,
u16 vid, bool dynamic);
int prestera_hw_fdb_del(struct prestera_port *port, const unsigned char *mac,
u16 vid);
int prestera_hw_fdb_flush_port(struct prestera_port *port, u32 mode);
int prestera_hw_fdb_flush_vlan(struct prestera_switch *sw, u16 vid, u32 mode);
int prestera_hw_fdb_flush_port_vlan(struct prestera_port *port, u16 vid,
u32 mode);
/* Bridge API */
int prestera_hw_bridge_create(struct prestera_switch *sw, u16 *bridge_id);
int prestera_hw_bridge_delete(struct prestera_switch *sw, u16 bridge_id);
int prestera_hw_bridge_port_add(struct prestera_port *port, u16 bridge_id);
int prestera_hw_bridge_port_delete(struct prestera_port *port, u16 bridge_id);
/* 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_ */

663
drivers/net/ethernet/marvell/prestera/prestera_main.c Normal file
View File

@@ -0,0 +1,663 @@
// 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/jiffies.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/netdev_features.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include "prestera.h"
#include "prestera_hw.h"
#include "prestera_rxtx.h"
#include "prestera_devlink.h"
#include "prestera_ethtool.h"
#include "prestera_switchdev.h"
#define PRESTERA_MTU_DEFAULT 1536
#define PRESTERA_STATS_DELAY_MS 1000
#define PRESTERA_MAC_ADDR_NUM_MAX 255
static struct workqueue_struct *prestera_wq;
int prestera_port_pvid_set(struct prestera_port *port, u16 vid)
{
enum prestera_accept_frm_type frm_type;
int err;
frm_type = PRESTERA_ACCEPT_FRAME_TYPE_TAGGED;
if (vid) {
err = prestera_hw_vlan_port_vid_set(port, vid);
if (err)
return err;
frm_type = PRESTERA_ACCEPT_FRAME_TYPE_ALL;
}
err = prestera_hw_port_accept_frm_type(port, frm_type);
if (err && frm_type == PRESTERA_ACCEPT_FRAME_TYPE_ALL)
prestera_hw_vlan_port_vid_set(port, port->pvid);
port->pvid = vid;
return 0;
}
struct prestera_port *prestera_port_find_by_hwid(struct prestera_switch *sw,
u32 dev_id, u32 hw_id)
{
struct prestera_port *port = NULL;
read_lock(&sw->port_list_lock);
list_for_each_entry(port, &sw->port_list, list) {
if (port->dev_id == dev_id && port->hw_id == hw_id)
break;
}
read_unlock(&sw->port_list_lock);
return port;
}
struct prestera_port *prestera_find_port(struct prestera_switch *sw, u32 id)
{
struct prestera_port *port = NULL;
read_lock(&sw->port_list_lock);
list_for_each_entry(port, &sw->port_list, list) {
if (port->id == id)
break;
}
read_unlock(&sw->port_list_lock);
return port;
}
static int prestera_port_open(struct net_device *dev)
{
struct prestera_port *port = netdev_priv(dev);
int err;
err = prestera_hw_port_state_set(port, true);
if (err)
return err;
netif_start_queue(dev);
return 0;
}
static int prestera_port_close(struct net_device *dev)
{
struct prestera_port *port = netdev_priv(dev);
int err;
netif_stop_queue(dev);
err = prestera_hw_port_state_set(port, false);
if (err)
return err;
return 0;
}
static netdev_tx_t prestera_port_xmit(struct sk_buff *skb,
struct net_device *dev)
{
return prestera_rxtx_xmit(netdev_priv(dev), skb);
}
static int prestera_is_valid_mac_addr(struct prestera_port *port, u8 *addr)
{
if (!is_valid_ether_addr(addr))
return -EADDRNOTAVAIL;
/* firmware requires that port's MAC address contains first 5 bytes
* of the base MAC address
*/
if (memcmp(port->sw->base_mac, addr, ETH_ALEN - 1))
return -EINVAL;
return 0;
}
static int prestera_port_set_mac_address(struct net_device *dev, void *p)
{
struct prestera_port *port = netdev_priv(dev);
struct sockaddr *addr = p;
int err;
err = prestera_is_valid_mac_addr(port, addr->sa_data);
if (err)
return err;
err = prestera_hw_port_mac_set(port, addr->sa_data);
if (err)
return err;
ether_addr_copy(dev->dev_addr, addr->sa_data);
return 0;
}
static int prestera_port_change_mtu(struct net_device *dev, int mtu)
{
struct prestera_port *port = netdev_priv(dev);
int err;
err = prestera_hw_port_mtu_set(port, mtu);
if (err)
return err;
dev->mtu = mtu;
return 0;
}
static void prestera_port_get_stats64(struct net_device *dev,
struct rtnl_link_stats64 *stats)
{
struct prestera_port *port = netdev_priv(dev);
struct prestera_port_stats *port_stats = &port->cached_hw_stats.stats;
stats->rx_packets = port_stats->broadcast_frames_received +
port_stats->multicast_frames_received +
port_stats->unicast_frames_received;
stats->tx_packets = port_stats->broadcast_frames_sent +
port_stats->multicast_frames_sent +
port_stats->unicast_frames_sent;
stats->rx_bytes = port_stats->good_octets_received;
stats->tx_bytes = port_stats->good_octets_sent;
stats->rx_errors = port_stats->rx_error_frame_received;
stats->tx_errors = port_stats->mac_trans_error;
stats->rx_dropped = port_stats->buffer_overrun;
stats->tx_dropped = 0;
stats->multicast = port_stats->multicast_frames_received;
stats->collisions = port_stats->excessive_collision;
stats->rx_crc_errors = port_stats->bad_crc;
}
static void prestera_port_get_hw_stats(struct prestera_port *port)
{
prestera_hw_port_stats_get(port, &port->cached_hw_stats.stats);
}
static void prestera_port_stats_update(struct work_struct *work)
{
struct prestera_port *port =
container_of(work, struct prestera_port,
cached_hw_stats.caching_dw.work);
prestera_port_get_hw_stats(port);
queue_delayed_work(prestera_wq, &port->cached_hw_stats.caching_dw,
msecs_to_jiffies(PRESTERA_STATS_DELAY_MS));
}
static const struct net_device_ops prestera_netdev_ops = {
.ndo_open = prestera_port_open,
.ndo_stop = prestera_port_close,
.ndo_start_xmit = prestera_port_xmit,
.ndo_change_mtu = prestera_port_change_mtu,
.ndo_get_stats64 = prestera_port_get_stats64,
.ndo_set_mac_address = prestera_port_set_mac_address,
.ndo_get_devlink_port = prestera_devlink_get_port,
};
int prestera_port_autoneg_set(struct prestera_port *port, bool enable,
u64 adver_link_modes, u8 adver_fec)
{
bool refresh = false;
u64 link_modes;
int err;
u8 fec;
if (port->caps.type != PRESTERA_PORT_TYPE_TP)
return enable ? -EINVAL : 0;
if (!enable)
goto set_autoneg;
link_modes = port->caps.supp_link_modes & adver_link_modes;
fec = port->caps.supp_fec & adver_fec;
if (!link_modes && !fec)
return -EOPNOTSUPP;
if (link_modes && port->adver_link_modes != link_modes) {
port->adver_link_modes = link_modes;
refresh = true;
}
if (fec && port->adver_fec != fec) {
port->adver_fec = fec;
refresh = true;
}
set_autoneg:
if (port->autoneg == enable && !refresh)
return 0;
err = prestera_hw_port_autoneg_set(port, enable, port->adver_link_modes,
port->adver_fec);
if (err)
return err;
port->autoneg = enable;
return 0;
}
static void prestera_port_list_add(struct prestera_port *port)
{
write_lock(&port->sw->port_list_lock);
list_add(&port->list, &port->sw->port_list);
write_unlock(&port->sw->port_list_lock);
}
static void prestera_port_list_del(struct prestera_port *port)
{
write_lock(&port->sw->port_list_lock);
list_del(&port->list);
write_unlock(&port->sw->port_list_lock);
}
static int prestera_port_create(struct prestera_switch *sw, u32 id)
{
struct prestera_port *port;
struct net_device *dev;
int err;
dev = alloc_etherdev(sizeof(*port));
if (!dev)
return -ENOMEM;
port = netdev_priv(dev);
INIT_LIST_HEAD(&port->vlans_list);
port->pvid = PRESTERA_DEFAULT_VID;
port->dev = dev;
port->id = id;
port->sw = sw;
err = prestera_hw_port_info_get(port, &port->dev_id, &port->hw_id,
&port->fp_id);
if (err) {
dev_err(prestera_dev(sw), "Failed to get port(%u) info\n", id);
goto err_port_info_get;
}
err = prestera_devlink_port_register(port);
if (err)
goto err_dl_port_register;
dev->features |= NETIF_F_NETNS_LOCAL;
dev->netdev_ops = &prestera_netdev_ops;
dev->ethtool_ops = &prestera_ethtool_ops;
netif_carrier_off(dev);
dev->mtu = min_t(unsigned int, sw->mtu_max, PRESTERA_MTU_DEFAULT);
dev->min_mtu = sw->mtu_min;
dev->max_mtu = sw->mtu_max;
err = prestera_hw_port_mtu_set(port, dev->mtu);
if (err) {
dev_err(prestera_dev(sw), "Failed to set port(%u) mtu(%d)\n",
id, dev->mtu);
goto err_port_init;
}
if (port->fp_id >= PRESTERA_MAC_ADDR_NUM_MAX)
goto err_port_init;
/* firmware requires that port's MAC address consist of the first
* 5 bytes of the base MAC address
*/
memcpy(dev->dev_addr, sw->base_mac, dev->addr_len - 1);
dev->dev_addr[dev->addr_len - 1] = port->fp_id;
err = prestera_hw_port_mac_set(port, dev->dev_addr);
if (err) {
dev_err(prestera_dev(sw), "Failed to set port(%u) mac addr\n", id);
goto err_port_init;
}
err = prestera_hw_port_cap_get(port, &port->caps);
if (err) {
dev_err(prestera_dev(sw), "Failed to get port(%u) caps\n", id);
goto err_port_init;
}
port->adver_fec = BIT(PRESTERA_PORT_FEC_OFF);
prestera_port_autoneg_set(port, true, port->caps.supp_link_modes,
port->caps.supp_fec);
err = prestera_hw_port_state_set(port, false);
if (err) {
dev_err(prestera_dev(sw), "Failed to set port(%u) down\n", id);
goto err_port_init;
}
err = prestera_rxtx_port_init(port);
if (err)
goto err_port_init;
INIT_DELAYED_WORK(&port->cached_hw_stats.caching_dw,
&prestera_port_stats_update);
prestera_port_list_add(port);
err = register_netdev(dev);
if (err)
goto err_register_netdev;
prestera_devlink_port_set(port);
return 0;
err_register_netdev:
prestera_port_list_del(port);
err_port_init:
prestera_devlink_port_unregister(port);
err_dl_port_register:
err_port_info_get:
free_netdev(dev);
return err;
}
static void prestera_port_destroy(struct prestera_port *port)
{
struct net_device *dev = port->dev;
cancel_delayed_work_sync(&port->cached_hw_stats.caching_dw);
prestera_devlink_port_clear(port);
unregister_netdev(dev);
prestera_port_list_del(port);
prestera_devlink_port_unregister(port);
free_netdev(dev);
}
static void prestera_destroy_ports(struct prestera_switch *sw)
{
struct prestera_port *port, *tmp;
list_for_each_entry_safe(port, tmp, &sw->port_list, list)
prestera_port_destroy(port);
}
static int prestera_create_ports(struct prestera_switch *sw)
{
struct prestera_port *port, *tmp;
u32 port_idx;
int err;
for (port_idx = 0; port_idx < sw->port_count; port_idx++) {
err = prestera_port_create(sw, port_idx);
if (err)
goto err_port_create;
}
return 0;
err_port_create:
list_for_each_entry_safe(port, tmp, &sw->port_list, list)
prestera_port_destroy(port);
return err;
}
static void prestera_port_handle_event(struct prestera_switch *sw,
struct prestera_event *evt, void *arg)
{
struct delayed_work *caching_dw;
struct prestera_port *port;
port = prestera_find_port(sw, evt->port_evt.port_id);
if (!port || !port->dev)
return;
caching_dw = &port->cached_hw_stats.caching_dw;
if (evt->id == PRESTERA_PORT_EVENT_STATE_CHANGED) {
if (evt->port_evt.data.oper_state) {
netif_carrier_on(port->dev);
if (!delayed_work_pending(caching_dw))
queue_delayed_work(prestera_wq, caching_dw, 0);
} else {
netif_carrier_off(port->dev);
if (delayed_work_pending(caching_dw))
cancel_delayed_work(caching_dw);
}
}
}
static int prestera_event_handlers_register(struct prestera_switch *sw)
{
return prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_PORT,
prestera_port_handle_event,
NULL);
}
static void prestera_event_handlers_unregister(struct prestera_switch *sw)
{
prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_PORT,
prestera_port_handle_event);
}
static int prestera_switch_set_base_mac_addr(struct prestera_switch *sw)
{
struct device_node *base_mac_np;
struct device_node *np;
const char *base_mac;
np = of_find_compatible_node(NULL, NULL, "marvell,prestera");
base_mac_np = of_parse_phandle(np, "base-mac-provider", 0);
base_mac = of_get_mac_address(base_mac_np);
of_node_put(base_mac_np);
if (!IS_ERR(base_mac))
ether_addr_copy(sw->base_mac, base_mac);
if (!is_valid_ether_addr(sw->base_mac)) {
eth_random_addr(sw->base_mac);
dev_info(prestera_dev(sw), "using random base mac address\n");
}
return prestera_hw_switch_mac_set(sw, sw->base_mac);
}
bool prestera_netdev_check(const struct net_device *dev)
{
return dev->netdev_ops == &prestera_netdev_ops;
}
static int prestera_lower_dev_walk(struct net_device *dev, void *data)
{
struct prestera_port **pport = data;
if (prestera_netdev_check(dev)) {
*pport = netdev_priv(dev);
return 1;
}
return 0;
}
struct prestera_port *prestera_port_dev_lower_find(struct net_device *dev)
{
struct prestera_port *port = NULL;
if (prestera_netdev_check(dev))
return netdev_priv(dev);
netdev_walk_all_lower_dev(dev, prestera_lower_dev_walk, &port);
return port;
}
static int prestera_netdev_port_event(struct net_device *dev,
unsigned long event, void *ptr)
{
switch (event) {
case NETDEV_PRECHANGEUPPER:
case NETDEV_CHANGEUPPER:
return prestera_bridge_port_event(dev, event, ptr);
default:
return 0;
}
}
static int prestera_netdev_event_handler(struct notifier_block *nb,
unsigned long event, void *ptr)
{
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
int err = 0;
if (prestera_netdev_check(dev))
err = prestera_netdev_port_event(dev, event, ptr);
return notifier_from_errno(err);
}
static int prestera_netdev_event_handler_register(struct prestera_switch *sw)
{
sw->netdev_nb.notifier_call = prestera_netdev_event_handler;
return register_netdevice_notifier(&sw->netdev_nb);
}
static void prestera_netdev_event_handler_unregister(struct prestera_switch *sw)
{
unregister_netdevice_notifier(&sw->netdev_nb);
}
static int prestera_switch_init(struct prestera_switch *sw)
{
int err;
err = prestera_hw_switch_init(sw);
if (err) {
dev_err(prestera_dev(sw), "Failed to init Switch device\n");
return err;
}
rwlock_init(&sw->port_list_lock);
INIT_LIST_HEAD(&sw->port_list);
err = prestera_switch_set_base_mac_addr(sw);
if (err)
return err;
err = prestera_netdev_event_handler_register(sw);
if (err)
return err;
err = prestera_switchdev_init(sw);
if (err)
goto err_swdev_register;
err = prestera_rxtx_switch_init(sw);
if (err)
goto err_rxtx_register;
err = prestera_event_handlers_register(sw);
if (err)
goto err_handlers_register;
err = prestera_devlink_register(sw);
if (err)
goto err_dl_register;
err = prestera_create_ports(sw);
if (err)
goto err_ports_create;
return 0;
err_ports_create:
prestera_devlink_unregister(sw);
err_dl_register:
prestera_event_handlers_unregister(sw);
err_handlers_register:
prestera_rxtx_switch_fini(sw);
err_rxtx_register:
prestera_switchdev_fini(sw);
err_swdev_register:
prestera_netdev_event_handler_unregister(sw);
prestera_hw_switch_fini(sw);
return err;
}
static void prestera_switch_fini(struct prestera_switch *sw)
{
prestera_destroy_ports(sw);
prestera_devlink_unregister(sw);
prestera_event_handlers_unregister(sw);
prestera_rxtx_switch_fini(sw);
prestera_switchdev_fini(sw);
prestera_netdev_event_handler_unregister(sw);
prestera_hw_switch_fini(sw);
}
int prestera_device_register(struct prestera_device *dev)
{
struct prestera_switch *sw;
int err;
sw = prestera_devlink_alloc();
if (!sw)
return -ENOMEM;
dev->priv = sw;
sw->dev = dev;
err = prestera_switch_init(sw);
if (err) {
prestera_devlink_free(sw);
return err;
}
return 0;
}
EXPORT_SYMBOL(prestera_device_register);
void prestera_device_unregister(struct prestera_device *dev)
{
struct prestera_switch *sw = dev->priv;
prestera_switch_fini(sw);
prestera_devlink_free(sw);
}
EXPORT_SYMBOL(prestera_device_unregister);
static int __init prestera_module_init(void)
{
prestera_wq = alloc_workqueue("prestera", 0, 0);
if (!prestera_wq)
return -ENOMEM;
return 0;
}
static void __exit prestera_module_exit(void)
{
destroy_workqueue(prestera_wq);
}
module_init(prestera_module_init);
module_exit(prestera_module_exit);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Marvell Prestera switch driver");

769
drivers/net/ethernet/marvell/prestera/prestera_pci.c Normal file
View File

@@ -0,0 +1,769 @@
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
#include <linux/circ_buf.h>
#include <linux/device.h>
#include <linux/firmware.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include "prestera.h"
#define PRESTERA_MSG_MAX_SIZE 1500
#define PRESTERA_SUPP_FW_MAJ_VER 2
#define PRESTERA_SUPP_FW_MIN_VER 0
#define PRESTERA_FW_PATH_FMT "mrvl/prestera/mvsw_prestera_fw-v%u.%u.img"
#define PRESTERA_FW_HDR_MAGIC 0x351D9D06
#define PRESTERA_FW_DL_TIMEOUT_MS 50000
#define PRESTERA_FW_BLK_SZ 1024
#define PRESTERA_FW_VER_MAJ_MUL 1000000
#define PRESTERA_FW_VER_MIN_MUL 1000
#define PRESTERA_FW_VER_MAJ(v) ((v) / PRESTERA_FW_VER_MAJ_MUL)
#define PRESTERA_FW_VER_MIN(v) \
(((v) - (PRESTERA_FW_VER_MAJ(v) * PRESTERA_FW_VER_MAJ_MUL)) / \
PRESTERA_FW_VER_MIN_MUL)
#define PRESTERA_FW_VER_PATCH(v) \
((v) - (PRESTERA_FW_VER_MAJ(v) * PRESTERA_FW_VER_MAJ_MUL) - \
(PRESTERA_FW_VER_MIN(v) * PRESTERA_FW_VER_MIN_MUL))
enum prestera_pci_bar_t {
PRESTERA_PCI_BAR_FW = 2,
PRESTERA_PCI_BAR_PP = 4,
};
struct prestera_fw_header {
__be32 magic_number;
__be32 version_value;
u8 reserved[8];
};
struct prestera_ldr_regs {
u32 ldr_ready;
u32 pad1;
u32 ldr_img_size;
u32 ldr_ctl_flags;
u32 ldr_buf_offs;
u32 ldr_buf_size;
u32 ldr_buf_rd;
u32 pad2;
u32 ldr_buf_wr;
u32 ldr_status;
};
#define PRESTERA_LDR_REG_OFFSET(f) offsetof(struct prestera_ldr_regs, f)
#define PRESTERA_LDR_READY_MAGIC 0xf00dfeed
#define PRESTERA_LDR_STATUS_IMG_DL BIT(0)
#define PRESTERA_LDR_STATUS_START_FW BIT(1)
#define PRESTERA_LDR_STATUS_INVALID_IMG BIT(2)
#define PRESTERA_LDR_STATUS_NOMEM BIT(3)
#define PRESTERA_LDR_REG_BASE(fw) ((fw)->ldr_regs)
#define PRESTERA_LDR_REG_ADDR(fw, reg) (PRESTERA_LDR_REG_BASE(fw) + (reg))
/* fw loader registers */
#define PRESTERA_LDR_READY_REG PRESTERA_LDR_REG_OFFSET(ldr_ready)
#define PRESTERA_LDR_IMG_SIZE_REG PRESTERA_LDR_REG_OFFSET(ldr_img_size)
#define PRESTERA_LDR_CTL_REG PRESTERA_LDR_REG_OFFSET(ldr_ctl_flags)
#define PRESTERA_LDR_BUF_SIZE_REG PRESTERA_LDR_REG_OFFSET(ldr_buf_size)
#define PRESTERA_LDR_BUF_OFFS_REG PRESTERA_LDR_REG_OFFSET(ldr_buf_offs)
#define PRESTERA_LDR_BUF_RD_REG PRESTERA_LDR_REG_OFFSET(ldr_buf_rd)
#define PRESTERA_LDR_BUF_WR_REG PRESTERA_LDR_REG_OFFSET(ldr_buf_wr)
#define PRESTERA_LDR_STATUS_REG PRESTERA_LDR_REG_OFFSET(ldr_status)
#define PRESTERA_LDR_CTL_DL_START BIT(0)
#define PRESTERA_EVT_QNUM_MAX 4
struct prestera_fw_evtq_regs {
u32 rd_idx;
u32 pad1;
u32 wr_idx;
u32 pad2;
u32 offs;
u32 len;
};
struct prestera_fw_regs {
u32 fw_ready;
u32 pad;
u32 cmd_offs;
u32 cmd_len;
u32 evt_offs;
u32 evt_qnum;
u32 cmd_req_ctl;
u32 cmd_req_len;
u32 cmd_rcv_ctl;
u32 cmd_rcv_len;
u32 fw_status;
u32 rx_status;
struct prestera_fw_evtq_regs evtq_list[PRESTERA_EVT_QNUM_MAX];
};
#define PRESTERA_FW_REG_OFFSET(f) offsetof(struct prestera_fw_regs, f)
#define PRESTERA_FW_READY_MAGIC 0xcafebabe
/* fw registers */
#define PRESTERA_FW_READY_REG PRESTERA_FW_REG_OFFSET(fw_ready)
#define PRESTERA_CMD_BUF_OFFS_REG PRESTERA_FW_REG_OFFSET(cmd_offs)
#define PRESTERA_CMD_BUF_LEN_REG PRESTERA_FW_REG_OFFSET(cmd_len)
#define PRESTERA_EVT_BUF_OFFS_REG PRESTERA_FW_REG_OFFSET(evt_offs)
#define PRESTERA_EVT_QNUM_REG PRESTERA_FW_REG_OFFSET(evt_qnum)
#define PRESTERA_CMD_REQ_CTL_REG PRESTERA_FW_REG_OFFSET(cmd_req_ctl)
#define PRESTERA_CMD_REQ_LEN_REG PRESTERA_FW_REG_OFFSET(cmd_req_len)
#define PRESTERA_CMD_RCV_CTL_REG PRESTERA_FW_REG_OFFSET(cmd_rcv_ctl)
#define PRESTERA_CMD_RCV_LEN_REG PRESTERA_FW_REG_OFFSET(cmd_rcv_len)
#define PRESTERA_FW_STATUS_REG PRESTERA_FW_REG_OFFSET(fw_status)
#define PRESTERA_RX_STATUS_REG PRESTERA_FW_REG_OFFSET(rx_status)
/* PRESTERA_CMD_REQ_CTL_REG flags */
#define PRESTERA_CMD_F_REQ_SENT BIT(0)
#define PRESTERA_CMD_F_REPL_RCVD BIT(1)
/* PRESTERA_CMD_RCV_CTL_REG flags */
#define PRESTERA_CMD_F_REPL_SENT BIT(0)
#define PRESTERA_EVTQ_REG_OFFSET(q, f) \
(PRESTERA_FW_REG_OFFSET(evtq_list) + \
(q) * sizeof(struct prestera_fw_evtq_regs) + \
offsetof(struct prestera_fw_evtq_regs, f))
#define PRESTERA_EVTQ_RD_IDX_REG(q) PRESTERA_EVTQ_REG_OFFSET(q, rd_idx)
#define PRESTERA_EVTQ_WR_IDX_REG(q) PRESTERA_EVTQ_REG_OFFSET(q, wr_idx)
#define PRESTERA_EVTQ_OFFS_REG(q) PRESTERA_EVTQ_REG_OFFSET(q, offs)
#define PRESTERA_EVTQ_LEN_REG(q) PRESTERA_EVTQ_REG_OFFSET(q, len)
#define PRESTERA_FW_REG_BASE(fw) ((fw)->dev.ctl_regs)
#define PRESTERA_FW_REG_ADDR(fw, reg) PRESTERA_FW_REG_BASE((fw)) + (reg)
#define PRESTERA_FW_CMD_DEFAULT_WAIT_MS 30000
#define PRESTERA_FW_READY_WAIT_MS 20000
struct prestera_fw_evtq {
u8 __iomem *addr;
size_t len;
};
struct prestera_fw {
struct workqueue_struct *wq;
struct prestera_device dev;
u8 __iomem *ldr_regs;
u8 __iomem *ldr_ring_buf;
u32 ldr_buf_len;
u32 ldr_wr_idx;
struct mutex cmd_mtx; /* serialize access to dev->send_req */
size_t cmd_mbox_len;
u8 __iomem *cmd_mbox;
struct prestera_fw_evtq evt_queue[PRESTERA_EVT_QNUM_MAX];
u8 evt_qnum;
struct work_struct evt_work;
u8 __iomem *evt_buf;
u8 *evt_msg;
};
static int prestera_fw_load(struct prestera_fw *fw);
static void prestera_fw_write(struct prestera_fw *fw, u32 reg, u32 val)
{
writel(val, PRESTERA_FW_REG_ADDR(fw, reg));
}
static u32 prestera_fw_read(struct prestera_fw *fw, u32 reg)
{
return readl(PRESTERA_FW_REG_ADDR(fw, reg));
}
static u32 prestera_fw_evtq_len(struct prestera_fw *fw, u8 qid)
{
return fw->evt_queue[qid].len;
}
static u32 prestera_fw_evtq_avail(struct prestera_fw *fw, u8 qid)
{
u32 wr_idx = prestera_fw_read(fw, PRESTERA_EVTQ_WR_IDX_REG(qid));
u32 rd_idx = prestera_fw_read(fw, PRESTERA_EVTQ_RD_IDX_REG(qid));
return CIRC_CNT(wr_idx, rd_idx, prestera_fw_evtq_len(fw, qid));
}
static void prestera_fw_evtq_rd_set(struct prestera_fw *fw,
u8 qid, u32 idx)
{
u32 rd_idx = idx & (prestera_fw_evtq_len(fw, qid) - 1);
prestera_fw_write(fw, PRESTERA_EVTQ_RD_IDX_REG(qid), rd_idx);
}
static u8 __iomem *prestera_fw_evtq_buf(struct prestera_fw *fw, u8 qid)
{
return fw->evt_queue[qid].addr;
}
static u32 prestera_fw_evtq_read32(struct prestera_fw *fw, u8 qid)
{
u32 rd_idx = prestera_fw_read(fw, PRESTERA_EVTQ_RD_IDX_REG(qid));
u32 val;
val = readl(prestera_fw_evtq_buf(fw, qid) + rd_idx);
prestera_fw_evtq_rd_set(fw, qid, rd_idx + 4);
return val;
}
static ssize_t prestera_fw_evtq_read_buf(struct prestera_fw *fw,
u8 qid, void *buf, size_t len)
{
u32 idx = prestera_fw_read(fw, PRESTERA_EVTQ_RD_IDX_REG(qid));
u8 __iomem *evtq_addr = prestera_fw_evtq_buf(fw, qid);
u32 *buf32 = buf;
int i;
for (i = 0; i < len / 4; buf32++, i++) {
*buf32 = readl_relaxed(evtq_addr + idx);
idx = (idx + 4) & (prestera_fw_evtq_len(fw, qid) - 1);
}
prestera_fw_evtq_rd_set(fw, qid, idx);
return i;
}
static u8 prestera_fw_evtq_pick(struct prestera_fw *fw)
{
int qid;
for (qid = 0; qid < fw->evt_qnum; qid++) {
if (prestera_fw_evtq_avail(fw, qid) >= 4)
return qid;
}
return PRESTERA_EVT_QNUM_MAX;
}
static void prestera_fw_evt_work_fn(struct work_struct *work)
{
struct prestera_fw *fw;
void *msg;
u8 qid;
fw = container_of(work, struct prestera_fw, evt_work);
msg = fw->evt_msg;
while ((qid = prestera_fw_evtq_pick(fw)) < PRESTERA_EVT_QNUM_MAX) {
u32 idx;
u32 len;
len = prestera_fw_evtq_read32(fw, qid);
idx = prestera_fw_read(fw, PRESTERA_EVTQ_RD_IDX_REG(qid));
WARN_ON(prestera_fw_evtq_avail(fw, qid) < len);
if (WARN_ON(len > PRESTERA_MSG_MAX_SIZE)) {
prestera_fw_evtq_rd_set(fw, qid, idx + len);
continue;
}
prestera_fw_evtq_read_buf(fw, qid, msg, len);
if (fw->dev.recv_msg)
fw->dev.recv_msg(&fw->dev, msg, len);
}
}
static int prestera_fw_wait_reg32(struct prestera_fw *fw, u32 reg, u32 cmp,
unsigned int waitms)
{
u8 __iomem *addr = PRESTERA_FW_REG_ADDR(fw, reg);
u32 val;
return readl_poll_timeout(addr, val, cmp == val,
1 * USEC_PER_MSEC, waitms * USEC_PER_MSEC);
}
static int prestera_fw_cmd_send(struct prestera_fw *fw,
void *in_msg, size_t in_size,
void *out_msg, size_t out_size,
unsigned int waitms)
{
u32 ret_size;
int err;
if (!waitms)
waitms = PRESTERA_FW_CMD_DEFAULT_WAIT_MS;
if (ALIGN(in_size, 4) > fw->cmd_mbox_len)
return -EMSGSIZE;
/* wait for finish previous reply from FW */
err = prestera_fw_wait_reg32(fw, PRESTERA_CMD_RCV_CTL_REG, 0, 30);
if (err) {
dev_err(fw->dev.dev, "finish reply from FW is timed out\n");
return err;
}
prestera_fw_write(fw, PRESTERA_CMD_REQ_LEN_REG, in_size);
memcpy_toio(fw->cmd_mbox, in_msg, in_size);
prestera_fw_write(fw, PRESTERA_CMD_REQ_CTL_REG, PRESTERA_CMD_F_REQ_SENT);
/* wait for reply from FW */
err = prestera_fw_wait_reg32(fw, PRESTERA_CMD_RCV_CTL_REG,
PRESTERA_CMD_F_REPL_SENT, waitms);
if (err) {
dev_err(fw->dev.dev, "reply from FW is timed out\n");
goto cmd_exit;
}
ret_size = prestera_fw_read(fw, PRESTERA_CMD_RCV_LEN_REG);
if (ret_size > out_size) {
dev_err(fw->dev.dev, "ret_size (%u) > out_len(%zu)\n",
ret_size, out_size);
err = -EMSGSIZE;
goto cmd_exit;
}
memcpy_fromio(out_msg, fw->cmd_mbox + in_size, ret_size);
cmd_exit:
prestera_fw_write(fw, PRESTERA_CMD_REQ_CTL_REG, PRESTERA_CMD_F_REPL_RCVD);
return err;
}
static int prestera_fw_send_req(struct prestera_device *dev,
void *in_msg, size_t in_size, void *out_msg,
size_t out_size, unsigned int waitms)
{
struct prestera_fw *fw;
ssize_t ret;
fw = container_of(dev, struct prestera_fw, dev);
mutex_lock(&fw->cmd_mtx);
ret = prestera_fw_cmd_send(fw, in_msg, in_size, out_msg, out_size, waitms);
mutex_unlock(&fw->cmd_mtx);
return ret;
}
static int prestera_fw_init(struct prestera_fw *fw)
{
u8 __iomem *base;
int err;
u8 qid;
fw->dev.send_req = prestera_fw_send_req;
fw->ldr_regs = fw->dev.ctl_regs;
err = prestera_fw_load(fw);
if (err)
return err;
err = prestera_fw_wait_reg32(fw, PRESTERA_FW_READY_REG,
PRESTERA_FW_READY_MAGIC,
PRESTERA_FW_READY_WAIT_MS);
if (err) {
dev_err(fw->dev.dev, "FW failed to start\n");
return err;
}
base = fw->dev.ctl_regs;
fw->cmd_mbox = base + prestera_fw_read(fw, PRESTERA_CMD_BUF_OFFS_REG);
fw->cmd_mbox_len = prestera_fw_read(fw, PRESTERA_CMD_BUF_LEN_REG);
mutex_init(&fw->cmd_mtx);
fw->evt_buf = base + prestera_fw_read(fw, PRESTERA_EVT_BUF_OFFS_REG);
fw->evt_qnum = prestera_fw_read(fw, PRESTERA_EVT_QNUM_REG);
fw->evt_msg = kmalloc(PRESTERA_MSG_MAX_SIZE, GFP_KERNEL);
if (!fw->evt_msg)
return -ENOMEM;
for (qid = 0; qid < fw->evt_qnum; qid++) {
u32 offs = prestera_fw_read(fw, PRESTERA_EVTQ_OFFS_REG(qid));
struct prestera_fw_evtq *evtq = &fw->evt_queue[qid];
evtq->len = prestera_fw_read(fw, PRESTERA_EVTQ_LEN_REG(qid));
evtq->addr = fw->evt_buf + offs;
}
return 0;
}
static void prestera_fw_uninit(struct prestera_fw *fw)
{
kfree(fw->evt_msg);
}
static irqreturn_t prestera_pci_irq_handler(int irq, void *dev_id)
{
struct prestera_fw *fw = dev_id;
if (prestera_fw_read(fw, PRESTERA_RX_STATUS_REG)) {
prestera_fw_write(fw, PRESTERA_RX_STATUS_REG, 0);
if (fw->dev.recv_pkt)
fw->dev.recv_pkt(&fw->dev);
}
queue_work(fw->wq, &fw->evt_work);
return IRQ_HANDLED;
}
static void prestera_ldr_write(struct prestera_fw *fw, u32 reg, u32 val)
{
writel(val, PRESTERA_LDR_REG_ADDR(fw, reg));
}
static u32 prestera_ldr_read(struct prestera_fw *fw, u32 reg)
{
return readl(PRESTERA_LDR_REG_ADDR(fw, reg));
}
static int prestera_ldr_wait_reg32(struct prestera_fw *fw,
u32 reg, u32 cmp, unsigned int waitms)
{
u8 __iomem *addr = PRESTERA_LDR_REG_ADDR(fw, reg);
u32 val;
return readl_poll_timeout(addr, val, cmp == val,
10 * USEC_PER_MSEC, waitms * USEC_PER_MSEC);
}
static u32 prestera_ldr_wait_buf(struct prestera_fw *fw, size_t len)
{
u8 __iomem *addr = PRESTERA_LDR_REG_ADDR(fw, PRESTERA_LDR_BUF_RD_REG);
u32 buf_len = fw->ldr_buf_len;
u32 wr_idx = fw->ldr_wr_idx;
u32 rd_idx;
return readl_poll_timeout(addr, rd_idx,
CIRC_SPACE(wr_idx, rd_idx, buf_len) >= len,
1 * USEC_PER_MSEC, 100 * USEC_PER_MSEC);
}
static int prestera_ldr_wait_dl_finish(struct prestera_fw *fw)
{
u8 __iomem *addr = PRESTERA_LDR_REG_ADDR(fw, PRESTERA_LDR_STATUS_REG);
unsigned long mask = ~(PRESTERA_LDR_STATUS_IMG_DL);
u32 val;
int err;
err = readl_poll_timeout(addr, val, val & mask, 10 * USEC_PER_MSEC,
PRESTERA_FW_DL_TIMEOUT_MS * USEC_PER_MSEC);
if (err) {
dev_err(fw->dev.dev, "Timeout to load FW img [state=%d]",
prestera_ldr_read(fw, PRESTERA_LDR_STATUS_REG));
return err;
}
return 0;
}
static void prestera_ldr_wr_idx_move(struct prestera_fw *fw, unsigned int n)
{
fw->ldr_wr_idx = (fw->ldr_wr_idx + (n)) & (fw->ldr_buf_len - 1);
}
static void prestera_ldr_wr_idx_commit(struct prestera_fw *fw)
{
prestera_ldr_write(fw, PRESTERA_LDR_BUF_WR_REG, fw->ldr_wr_idx);
}
static u8 __iomem *prestera_ldr_wr_ptr(struct prestera_fw *fw)
{
return fw->ldr_ring_buf + fw->ldr_wr_idx;
}
static int prestera_ldr_send(struct prestera_fw *fw, const u8 *buf, size_t len)
{
int err;
int i;
err = prestera_ldr_wait_buf(fw, len);
if (err) {
dev_err(fw->dev.dev, "failed wait for sending firmware\n");
return err;
}
for (i = 0; i < len; i += 4) {
writel_relaxed(*(u32 *)(buf + i), prestera_ldr_wr_ptr(fw));
prestera_ldr_wr_idx_move(fw, 4);
}
prestera_ldr_wr_idx_commit(fw);
return 0;
}
static int prestera_ldr_fw_send(struct prestera_fw *fw,
const char *img, u32 fw_size)
{
u32 status;
u32 pos;
int err;
err = prestera_ldr_wait_reg32(fw, PRESTERA_LDR_STATUS_REG,
PRESTERA_LDR_STATUS_IMG_DL,
5 * MSEC_PER_SEC);
if (err) {
dev_err(fw->dev.dev, "Loader is not ready to load image\n");
return err;
}
for (pos = 0; pos < fw_size; pos += PRESTERA_FW_BLK_SZ) {
if (pos + PRESTERA_FW_BLK_SZ > fw_size)
break;
err = prestera_ldr_send(fw, img + pos, PRESTERA_FW_BLK_SZ);
if (err)
return err;
}
if (pos < fw_size) {
err = prestera_ldr_send(fw, img + pos, fw_size - pos);
if (err)
return err;
}
err = prestera_ldr_wait_dl_finish(fw);
if (err)
return err;
status = prestera_ldr_read(fw, PRESTERA_LDR_STATUS_REG);
switch (status) {
case PRESTERA_LDR_STATUS_INVALID_IMG:
dev_err(fw->dev.dev, "FW img has bad CRC\n");
return -EINVAL;
case PRESTERA_LDR_STATUS_NOMEM:
dev_err(fw->dev.dev, "Loader has no enough mem\n");
return -ENOMEM;
}
return 0;
}
static void prestera_fw_rev_parse(const struct prestera_fw_header *hdr,
struct prestera_fw_rev *rev)
{
u32 version = be32_to_cpu(hdr->version_value);
rev->maj = PRESTERA_FW_VER_MAJ(version);
rev->min = PRESTERA_FW_VER_MIN(version);
rev->sub = PRESTERA_FW_VER_PATCH(version);
}
static int prestera_fw_rev_check(struct prestera_fw *fw)
{
struct prestera_fw_rev *rev = &fw->dev.fw_rev;
u16 maj_supp = PRESTERA_SUPP_FW_MAJ_VER;
u16 min_supp = PRESTERA_SUPP_FW_MIN_VER;
if (rev->maj == maj_supp && rev->min >= min_supp)
return 0;
dev_err(fw->dev.dev, "Driver supports FW version only '%u.%u.x'",
PRESTERA_SUPP_FW_MAJ_VER, PRESTERA_SUPP_FW_MIN_VER);
return -EINVAL;
}
static int prestera_fw_hdr_parse(struct prestera_fw *fw,
const struct firmware *img)
{
struct prestera_fw_header *hdr = (struct prestera_fw_header *)img->data;
struct prestera_fw_rev *rev = &fw->dev.fw_rev;
u32 magic;
magic = be32_to_cpu(hdr->magic_number);
if (magic != PRESTERA_FW_HDR_MAGIC) {
dev_err(fw->dev.dev, "FW img hdr magic is invalid");
return -EINVAL;
}
prestera_fw_rev_parse(hdr, rev);
dev_info(fw->dev.dev, "FW version '%u.%u.%u'\n",
rev->maj, rev->min, rev->sub);
return prestera_fw_rev_check(fw);
}
static int prestera_fw_load(struct prestera_fw *fw)
{
size_t hlen = sizeof(struct prestera_fw_header);
const struct firmware *f;
char fw_path[128];
int err;
err = prestera_ldr_wait_reg32(fw, PRESTERA_LDR_READY_REG,
PRESTERA_LDR_READY_MAGIC,
5 * MSEC_PER_SEC);
if (err) {
dev_err(fw->dev.dev, "waiting for FW loader is timed out");
return err;
}
fw->ldr_ring_buf = fw->ldr_regs +
prestera_ldr_read(fw, PRESTERA_LDR_BUF_OFFS_REG);
fw->ldr_buf_len =
prestera_ldr_read(fw, PRESTERA_LDR_BUF_SIZE_REG);
fw->ldr_wr_idx = 0;
snprintf(fw_path, sizeof(fw_path), PRESTERA_FW_PATH_FMT,
PRESTERA_SUPP_FW_MAJ_VER, PRESTERA_SUPP_FW_MIN_VER);
err = request_firmware_direct(&f, fw_path, fw->dev.dev);
if (err) {
dev_err(fw->dev.dev, "failed to request firmware file\n");
return err;
}
err = prestera_fw_hdr_parse(fw, f);
if (err) {
dev_err(fw->dev.dev, "FW image header is invalid\n");
goto out_release;
}
prestera_ldr_write(fw, PRESTERA_LDR_IMG_SIZE_REG, f->size - hlen);
prestera_ldr_write(fw, PRESTERA_LDR_CTL_REG, PRESTERA_LDR_CTL_DL_START);
dev_info(fw->dev.dev, "Loading %s ...", fw_path);
err = prestera_ldr_fw_send(fw, f->data + hlen, f->size - hlen);
out_release:
release_firmware(f);
return err;
}
static int prestera_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
const char *driver_name = pdev->driver->name;
struct prestera_fw *fw;
int err;
err = pcim_enable_device(pdev);
if (err)
return err;
err = pcim_iomap_regions(pdev, BIT(PRESTERA_PCI_BAR_FW) |
BIT(PRESTERA_PCI_BAR_PP),
pci_name(pdev));
if (err)
return err;
if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(30))) {
dev_err(&pdev->dev, "fail to set DMA mask\n");
goto err_dma_mask;
}
pci_set_master(pdev);
fw = devm_kzalloc(&pdev->dev, sizeof(*fw), GFP_KERNEL);
if (!fw) {
err = -ENOMEM;
goto err_pci_dev_alloc;
}
fw->dev.ctl_regs = pcim_iomap_table(pdev)[PRESTERA_PCI_BAR_FW];
fw->dev.pp_regs = pcim_iomap_table(pdev)[PRESTERA_PCI_BAR_PP];
fw->dev.dev = &pdev->dev;
pci_set_drvdata(pdev, fw);
err = prestera_fw_init(fw);
if (err)
goto err_prestera_fw_init;
dev_info(fw->dev.dev, "Prestera FW is ready\n");
fw->wq = alloc_workqueue("prestera_fw_wq", WQ_HIGHPRI, 1);
if (!fw->wq)
goto err_wq_alloc;
INIT_WORK(&fw->evt_work, prestera_fw_evt_work_fn);
err = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
if (err < 0) {
dev_err(&pdev->dev, "MSI IRQ init failed\n");
goto err_irq_alloc;
}
err = request_irq(pci_irq_vector(pdev, 0), prestera_pci_irq_handler,
0, driver_name, fw);
if (err) {
dev_err(&pdev->dev, "fail to request IRQ\n");
goto err_request_irq;
}
err = prestera_device_register(&fw->dev);
if (err)
goto err_prestera_dev_register;
return 0;
err_prestera_dev_register:
free_irq(pci_irq_vector(pdev, 0), fw);
err_request_irq:
pci_free_irq_vectors(pdev);
err_irq_alloc:
destroy_workqueue(fw->wq);
err_wq_alloc:
prestera_fw_uninit(fw);
err_prestera_fw_init:
err_pci_dev_alloc:
err_dma_mask:
return err;
}
static void prestera_pci_remove(struct pci_dev *pdev)
{
struct prestera_fw *fw = pci_get_drvdata(pdev);
prestera_device_unregister(&fw->dev);
free_irq(pci_irq_vector(pdev, 0), fw);
pci_free_irq_vectors(pdev);
destroy_workqueue(fw->wq);
prestera_fw_uninit(fw);
}
static const struct pci_device_id prestera_pci_devices[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0xC804) },
{ }
};
MODULE_DEVICE_TABLE(pci, prestera_pci_devices);
static struct pci_driver prestera_pci_driver = {
.name = "Prestera DX",
.id_table = prestera_pci_devices,
.probe = prestera_pci_probe,
.remove = prestera_pci_remove,
};
module_pci_driver(prestera_pci_driver);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Marvell Prestera switch PCI interface");

820
drivers/net/ethernet/marvell/prestera/prestera_rxtx.c Normal file
View File

@@ -0,0 +1,820 @@
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
#include <linux/bitfield.h>
#include <linux/dmapool.h>
#include <linux/etherdevice.h>
#include <linux/if_vlan.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include "prestera_dsa.h"
#include "prestera.h"
#include "prestera_hw.h"
#include "prestera_rxtx.h"
#define PRESTERA_SDMA_WAIT_MUL 10
struct prestera_sdma_desc {
__le32 word1;
__le32 word2;
__le32 buff;
__le32 next;
} __packed __aligned(16);
#define PRESTERA_SDMA_BUFF_SIZE_MAX 1544
#define PRESTERA_SDMA_RX_DESC_PKT_LEN(desc) \
((le32_to_cpu((desc)->word2) >> 16) & GENMASK(13, 0))
#define PRESTERA_SDMA_RX_DESC_OWNER(desc) \
((le32_to_cpu((desc)->word1) & BIT(31)) >> 31)
#define PRESTERA_SDMA_RX_DESC_IS_RCVD(desc) \
(PRESTERA_SDMA_RX_DESC_OWNER(desc) == PRESTERA_SDMA_RX_DESC_CPU_OWN)
#define PRESTERA_SDMA_RX_DESC_CPU_OWN 0
#define PRESTERA_SDMA_RX_DESC_DMA_OWN 1
#define PRESTERA_SDMA_RX_QUEUE_NUM 8
#define PRESTERA_SDMA_RX_DESC_PER_Q 1000
#define PRESTERA_SDMA_TX_DESC_PER_Q 1000
#define PRESTERA_SDMA_TX_MAX_BURST 64
#define PRESTERA_SDMA_TX_DESC_OWNER(desc) \
((le32_to_cpu((desc)->word1) & BIT(31)) >> 31)
#define PRESTERA_SDMA_TX_DESC_CPU_OWN 0
#define PRESTERA_SDMA_TX_DESC_DMA_OWN 1U
#define PRESTERA_SDMA_TX_DESC_IS_SENT(desc) \
(PRESTERA_SDMA_TX_DESC_OWNER(desc) == PRESTERA_SDMA_TX_DESC_CPU_OWN)
#define PRESTERA_SDMA_TX_DESC_LAST BIT(20)
#define PRESTERA_SDMA_TX_DESC_FIRST BIT(21)
#define PRESTERA_SDMA_TX_DESC_CALC_CRC BIT(12)
#define PRESTERA_SDMA_TX_DESC_SINGLE \
(PRESTERA_SDMA_TX_DESC_FIRST | PRESTERA_SDMA_TX_DESC_LAST)
#define PRESTERA_SDMA_TX_DESC_INIT \
(PRESTERA_SDMA_TX_DESC_SINGLE | PRESTERA_SDMA_TX_DESC_CALC_CRC)
#define PRESTERA_SDMA_RX_INTR_MASK_REG 0x2814
#define PRESTERA_SDMA_RX_QUEUE_STATUS_REG 0x2680
#define PRESTERA_SDMA_RX_QUEUE_DESC_REG(n) (0x260C + (n) * 16)
#define PRESTERA_SDMA_TX_QUEUE_DESC_REG 0x26C0
#define PRESTERA_SDMA_TX_QUEUE_START_REG 0x2868
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[PRESTERA_SDMA_RX_QUEUE_NUM];
struct prestera_tx_ring tx_ring;
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;
/* protect SDMA with concurrrent access from multiple CPUs */
spinlock_t tx_lock;
};
struct prestera_rxtx {
struct prestera_sdma sdma;
};
static int prestera_sdma_buf_init(struct prestera_sdma *sdma,
struct prestera_sdma_buf *buf)
{
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;
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_init(struct prestera_sdma *sdma,
struct prestera_sdma_desc *desc,
dma_addr_t buf)
{
u32 word = le32_to_cpu(desc->word2);
u32p_replace_bits(&word, PRESTERA_SDMA_BUFF_SIZE_MAX, GENMASK(15, 0));
desc->word2 = cpu_to_le32(word);
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(PRESTERA_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 (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_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 prestera_sdma *sdma,
struct sk_buff *skb)
{
const struct prestera_port *port;
struct prestera_dsa dsa;
u32 hw_port, dev_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;
dev_id = dsa.hw_dev_num;
hw_port = dsa.port_num;
port = prestera_port_find_by_hwid(sdma->sw, dev_id, hw_port);
if (unlikely(!port)) {
dev_warn_ratelimited(prestera_dev(sdma->sw), "received pkt for non-existent port(%u, %u)\n",
dev_id, hw_port);
return -ENOENT;
}
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_next_rx_buf_idx(int buf_idx)
{
return (buf_idx + 1) % PRESTERA_SDMA_RX_DESC_PER_Q;
}
static int prestera_sdma_rx_poll(struct napi_struct *napi, int budget)
{
int qnum = PRESTERA_SDMA_RX_QUEUE_NUM;
unsigned int rxq_done_map = 0;
struct prestera_sdma *sdma;
struct list_head rx_list;
unsigned int qmask;
int pkts_done = 0;
int q;
qnum = PRESTERA_SDMA_RX_QUEUE_NUM;
qmask = GENMASK(qnum - 1, 0);
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 < qnum && pkts_done < budget; q++) {
struct prestera_rx_ring *ring = &sdma->rx_ring[q];
struct prestera_sdma_desc *desc;
struct prestera_sdma_buf *buf;
int buf_idx = ring->next_rx;
struct sk_buff *skb;
buf = &ring->bufs[buf_idx];
desc = buf->desc;
if (PRESTERA_SDMA_RX_DESC_IS_RCVD(desc)) {
rxq_done_map &= ~BIT(q);
} else {
rxq_done_map |= BIT(q);
continue;
}
pkts_done++;
__skb_trim(buf->skb, PRESTERA_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(sdma, skb)))
goto rx_next_buf;
list_add_tail(&skb->list, &rx_list);
rx_next_buf:
ring->next_rx = prestera_sdma_next_rx_buf_idx(buf_idx);
}
}
if (pkts_done < budget && napi_complete_done(napi, pkts_done))
prestera_write(sdma->sw, PRESTERA_SDMA_RX_INTR_MASK_REG,
GENMASK(9, 2));
netif_receive_skb_list(&rx_list);
return pkts_done;
}
static void prestera_sdma_rx_fini(struct prestera_sdma *sdma)
{
int qnum = PRESTERA_SDMA_RX_QUEUE_NUM;
int q, b;
/* disable all rx queues */
prestera_write(sdma->sw, PRESTERA_SDMA_RX_QUEUE_STATUS_REG,
GENMASK(15, 8));
for (q = 0; q < qnum; q++) {
struct prestera_rx_ring *ring = &sdma->rx_ring[q];
if (!ring->bufs)
break;
for (b = 0; b < PRESTERA_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 bnum = PRESTERA_SDMA_RX_DESC_PER_Q;
int qnum = PRESTERA_SDMA_RX_QUEUE_NUM;
int err;
int q;
/* disable all rx queues */
prestera_write(sdma->sw, PRESTERA_SDMA_RX_QUEUE_STATUS_REG,
GENMASK(15, 8));
for (q = 0; q < qnum; q++) {
struct prestera_sdma_buf *head, *tail, *next, *prev;
struct prestera_rx_ring *ring = &sdma->rx_ring[q];
ring->bufs = kmalloc_array(bnum, sizeof(*head), GFP_KERNEL);
if (!ring->bufs)
return -ENOMEM;
ring->next_rx = 0;
tail = &ring->bufs[bnum - 1];
head = &ring->bufs[0];
next = head;
prev = next;
do {
err = prestera_sdma_buf_init(sdma, next);
if (err)
return err;
err = prestera_sdma_rx_skb_alloc(sdma, next);
if (err)
return err;
prestera_sdma_rx_desc_init(sdma, next->desc,
next->buf_dma);
prestera_sdma_rx_desc_set_next(sdma, prev->desc,
next->desc_dma);
prev = next;
next++;
} while (prev != tail);
/* join tail with head to make a circular list */
prestera_sdma_rx_desc_set_next(sdma, tail->desc, head->desc_dma);
prestera_write(sdma->sw, PRESTERA_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, PRESTERA_SDMA_RX_QUEUE_STATUS_REG,
GENMASK(7, 0));
return 0;
}
static void prestera_sdma_tx_desc_init(struct prestera_sdma *sdma,
struct prestera_sdma_desc *desc)
{
desc->word1 = cpu_to_le32(PRESTERA_SDMA_TX_DESC_INIT);
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);
u32p_replace_bits(&word, len + ETH_FCS_LEN, GENMASK(30, 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 |= PRESTERA_SDMA_TX_DESC_DMA_OWN << 31;
/* 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;
dma_addr_t dma;
dma = dma_map_single(dma_dev, skb->data, skb->len, DMA_TO_DEVICE);
if (dma_mapping_error(dma_dev, dma))
return -ENOMEM;
buf->buf_dma = dma;
buf->skb = skb;
return 0;
}
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)
{
int bnum = PRESTERA_SDMA_TX_DESC_PER_Q;
struct prestera_tx_ring *tx_ring;
struct prestera_sdma *sdma;
int b;
sdma = container_of(work, struct prestera_sdma, tx_work);
tx_ring = &sdma->tx_ring;
for (b = 0; b < bnum; b++) {
struct prestera_sdma_buf *buf = &tx_ring->bufs[b];
if (!buf->is_used)
continue;
if (!PRESTERA_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_sdma_buf *head, *tail, *next, *prev;
struct prestera_tx_ring *tx_ring = &sdma->tx_ring;
int bnum = PRESTERA_SDMA_TX_DESC_PER_Q;
int err;
INIT_WORK(&sdma->tx_work, prestera_sdma_tx_recycle_work_fn);
spin_lock_init(&sdma->tx_lock);
tx_ring->bufs = kmalloc_array(bnum, sizeof(*head), GFP_KERNEL);
if (!tx_ring->bufs)
return -ENOMEM;
tail = &tx_ring->bufs[bnum - 1];
head = &tx_ring->bufs[0];
next = head;
prev = next;
tx_ring->max_burst = PRESTERA_SDMA_TX_MAX_BURST;
tx_ring->burst = tx_ring->max_burst;
tx_ring->next_tx = 0;
do {
err = prestera_sdma_buf_init(sdma, next);
if (err)
return err;
next->is_used = false;
prestera_sdma_tx_desc_init(sdma, next->desc);
prestera_sdma_tx_desc_set_next(sdma, prev->desc,
next->desc_dma);
prev = next;
next++;
} while (prev != tail);
/* join tail with head to make a circular list */
prestera_sdma_tx_desc_set_next(sdma, tail->desc, head->desc_dma);
/* make sure descriptors are written */
wmb();
prestera_write(sdma->sw, PRESTERA_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 bnum = PRESTERA_SDMA_TX_DESC_PER_Q;
int b;
cancel_work_sync(&sdma->tx_work);
if (!ring->bufs)
return;
for (b = 0; b < bnum; 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, PRESTERA_SDMA_RX_INTR_MASK_REG, 0);
napi_schedule(&sdma->rx_napi);
}
static 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;
}
static void prestera_sdma_switch_fini(struct prestera_switch *sw)
{
struct prestera_sdma *sdma = &sw->rxtx->sdma;
napi_disable(&sdma->rx_napi);
netif_napi_del(&sdma->rx_napi);
prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_RXTX,
prestera_rxtx_handle_event);
prestera_sdma_tx_fini(sdma);
prestera_sdma_rx_fini(sdma);
dma_pool_destroy(sdma->desc_pool);
}
static bool prestera_sdma_is_ready(struct prestera_sdma *sdma)
{
return !(prestera_read(sdma->sw, PRESTERA_SDMA_TX_QUEUE_START_REG) & 1);
}
static int prestera_sdma_tx_wait(struct prestera_sdma *sdma,
struct prestera_tx_ring *tx_ring)
{
int tx_wait_num = PRESTERA_SDMA_WAIT_MUL * tx_ring->max_burst;
do {
if (prestera_sdma_is_ready(sdma))
return 0;
udelay(1);
} while (--tx_wait_num);
return -EBUSY;
}
static void prestera_sdma_tx_start(struct prestera_sdma *sdma)
{
prestera_write(sdma->sw, PRESTERA_SDMA_TX_QUEUE_START_REG, 1);
schedule_work(&sdma->tx_work);
}
static netdev_tx_t prestera_sdma_xmit(struct prestera_sdma *sdma,
struct sk_buff *skb)
{
struct device *dma_dev = sdma->sw->dev->dev;
struct net_device *dev = skb->dev;
struct prestera_tx_ring *tx_ring;
struct prestera_sdma_buf *buf;
int err;
spin_lock(&sdma->tx_lock);
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;
}
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--;
} else {
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) % PRESTERA_SDMA_TX_DESC_PER_Q;
prestera_sdma_tx_desc_xmit(buf->desc);
buf->is_used = true;
prestera_sdma_tx_start(sdma);
goto tx_done;
drop_skb_unmap:
prestera_sdma_tx_buf_unmap(sdma, buf);
drop_skb:
dev_consume_skb_any(skb);
drop_skb_nofree:
dev->stats.tx_dropped++;
tx_done:
spin_unlock(&sdma->tx_lock);
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;
return 0;
}
netdev_tx_t prestera_rxtx_xmit(struct prestera_port *port, struct sk_buff *skb)
{
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);
}

19
drivers/net/ethernet/marvell/prestera/prestera_rxtx.h Normal file
View File

@@ -0,0 +1,19 @@
/* 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>
struct prestera_switch;
struct prestera_port;
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_ */

1277
drivers/net/ethernet/marvell/prestera/prestera_switchdev.c Normal file
View File

File diff suppressed because it is too large Load Diff

13
drivers/net/ethernet/marvell/prestera/prestera_switchdev.h Normal file
View File

@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved. */
#ifndef _PRESTERA_SWITCHDEV_H_
#define _PRESTERA_SWITCHDEV_H_
int prestera_switchdev_init(struct prestera_switch *sw);
void prestera_switchdev_fini(struct prestera_switch *sw);
int prestera_bridge_port_event(struct net_device *dev, unsigned long event,
void *ptr);
#endif /* _PRESTERA_SWITCHDEV_H_ */