// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>
 *
 * This module is not a complete tagger implementation. It only provides
 * primitives for taggers that rely on 802.1Q VLAN tags to use. The
 * dsa_8021q_netdev_ops is registered for API compliance and not used
 * directly by callers.
 */
#include <linux/if_bridge.h>
#include <linux/if_vlan.h>
#include <linux/dsa/8021q.h>

#include "dsa_priv.h"

/* Binary structure of the fake 12-bit VID field (when the TPID is
 * ETH_P_DSA_8021Q):
 *
 * | 11  | 10  |  9  |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0  |
 * +-----------+-----+-----------------+-----------+-----------------------+
 * |    DIR    | VBID|    SWITCH_ID    |   VBID    |          PORT         |
 * +-----------+-----+-----------------+-----------+-----------------------+
 *
 * DIR - VID[11:10]:
 *      Direction flags.
 *      * 1 (0b01) for RX VLAN,
 *      * 2 (0b10) for TX VLAN.
 *      These values make the special VIDs of 0, 1 and 4095 to be left
 *      unused by this coding scheme.
 *
 * SWITCH_ID - VID[8:6]:
 *      Index of switch within DSA tree. Must be between 0 and 7.
 *
 * VBID - { VID[9], VID[5:4] }:
 *      Virtual bridge ID. If between 1 and 7, packet targets the broadcast
 *      domain of a bridge. If transmitted as zero, packet targets a single
 *      port. Field only valid on transmit, must be ignored on receive.
 *
 * PORT - VID[3:0]:
 *      Index of switch port. Must be between 0 and 15.
 */

#define DSA_8021Q_DIR_SHIFT             10
#define DSA_8021Q_DIR_MASK              GENMASK(11, 10)
#define DSA_8021Q_DIR(x)                (((x) << DSA_8021Q_DIR_SHIFT) & \
                                                 DSA_8021Q_DIR_MASK)
#define DSA_8021Q_DIR_RX                DSA_8021Q_DIR(1)
#define DSA_8021Q_DIR_TX                DSA_8021Q_DIR(2)

#define DSA_8021Q_SWITCH_ID_SHIFT       6
#define DSA_8021Q_SWITCH_ID_MASK        GENMASK(8, 6)
#define DSA_8021Q_SWITCH_ID(x)          (((x) << DSA_8021Q_SWITCH_ID_SHIFT) & \
                                                 DSA_8021Q_SWITCH_ID_MASK)

#define DSA_8021Q_VBID_HI_SHIFT         9
#define DSA_8021Q_VBID_HI_MASK          GENMASK(9, 9)
#define DSA_8021Q_VBID_LO_SHIFT         4
#define DSA_8021Q_VBID_LO_MASK          GENMASK(5, 4)
#define DSA_8021Q_VBID_HI(x)            (((x) & GENMASK(2, 2)) >> 2)
#define DSA_8021Q_VBID_LO(x)            ((x) & GENMASK(1, 0))
#define DSA_8021Q_VBID(x)               \
                (((DSA_8021Q_VBID_LO(x) << DSA_8021Q_VBID_LO_SHIFT) & \
                  DSA_8021Q_VBID_LO_MASK) | \
                 ((DSA_8021Q_VBID_HI(x) << DSA_8021Q_VBID_HI_SHIFT) & \
                  DSA_8021Q_VBID_HI_MASK))

#define DSA_8021Q_PORT_SHIFT            0
#define DSA_8021Q_PORT_MASK             GENMASK(3, 0)
#define DSA_8021Q_PORT(x)               (((x) << DSA_8021Q_PORT_SHIFT) & \
                                                 DSA_8021Q_PORT_MASK)

u16 dsa_8021q_bridge_tx_fwd_offload_vid(int bridge_num)
{
        /* The VBID value of 0 is reserved for precise TX */
        return DSA_8021Q_DIR_TX | DSA_8021Q_VBID(bridge_num + 1);
}
EXPORT_SYMBOL_GPL(dsa_8021q_bridge_tx_fwd_offload_vid);

/* Returns the VID to be inserted into the frame from xmit for switch steering
 * instructions on egress. Encodes switch ID and port ID.
 */
u16 dsa_8021q_tx_vid(struct dsa_switch *ds, int port)
{
        return DSA_8021Q_DIR_TX | DSA_8021Q_SWITCH_ID(ds->index) |
               DSA_8021Q_PORT(port);
}
EXPORT_SYMBOL_GPL(dsa_8021q_tx_vid);

/* Returns the VID that will be installed as pvid for this switch port, sent as
 * tagged egress towards the CPU port and decoded by the rcv function.
 */
u16 dsa_8021q_rx_vid(struct dsa_switch *ds, int port)
{
        return DSA_8021Q_DIR_RX | DSA_8021Q_SWITCH_ID(ds->index) |
               DSA_8021Q_PORT(port);
}
EXPORT_SYMBOL_GPL(dsa_8021q_rx_vid);

/* Returns the decoded switch ID from the RX VID. */
int dsa_8021q_rx_switch_id(u16 vid)
{
        return (vid & DSA_8021Q_SWITCH_ID_MASK) >> DSA_8021Q_SWITCH_ID_SHIFT;
}
EXPORT_SYMBOL_GPL(dsa_8021q_rx_switch_id);

/* Returns the decoded port ID from the RX VID. */
int dsa_8021q_rx_source_port(u16 vid)
{
        return (vid & DSA_8021Q_PORT_MASK) >> DSA_8021Q_PORT_SHIFT;
}
EXPORT_SYMBOL_GPL(dsa_8021q_rx_source_port);

bool vid_is_dsa_8021q_rxvlan(u16 vid)
{
        return (vid & DSA_8021Q_DIR_MASK) == DSA_8021Q_DIR_RX;
}
EXPORT_SYMBOL_GPL(vid_is_dsa_8021q_rxvlan);

bool vid_is_dsa_8021q_txvlan(u16 vid)
{
        return (vid & DSA_8021Q_DIR_MASK) == DSA_8021Q_DIR_TX;
}
EXPORT_SYMBOL_GPL(vid_is_dsa_8021q_txvlan);

bool vid_is_dsa_8021q(u16 vid)
{
        return vid_is_dsa_8021q_rxvlan(vid) || vid_is_dsa_8021q_txvlan(vid);
}
EXPORT_SYMBOL_GPL(vid_is_dsa_8021q);

static struct dsa_tag_8021q_vlan *
dsa_tag_8021q_vlan_find(struct dsa_8021q_context *ctx, int port, u16 vid)
{
        struct dsa_tag_8021q_vlan *v;

        list_for_each_entry(v, &ctx->vlans, list)
                if (v->vid == vid && v->port == port)
                        return v;

        return NULL;
}

static int dsa_switch_do_tag_8021q_vlan_add(struct dsa_switch *ds, int port,
                                            u16 vid, u16 flags)
{
        struct dsa_8021q_context *ctx = ds->tag_8021q_ctx;
        struct dsa_port *dp = dsa_to_port(ds, port);
        struct dsa_tag_8021q_vlan *v;
        int err;

        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->tag_8021q_vlan_add(ds, port, vid, flags);

        v = dsa_tag_8021q_vlan_find(ctx, port, vid);
        if (v) {
                refcount_inc(&v->refcount);
                return 0;
        }

        v = kzalloc(sizeof(*v), GFP_KERNEL);
        if (!v)
                return -ENOMEM;

        err = ds->ops->tag_8021q_vlan_add(ds, port, vid, flags);
        if (err) {
                kfree(v);
                return err;
        }

        v->vid = vid;
        v->port = port;
        refcount_set(&v->refcount, 1);
        list_add_tail(&v->list, &ctx->vlans);

        return 0;
}

static int dsa_switch_do_tag_8021q_vlan_del(struct dsa_switch *ds, int port,
                                            u16 vid)
{
        struct dsa_8021q_context *ctx = ds->tag_8021q_ctx;
        struct dsa_port *dp = dsa_to_port(ds, port);
        struct dsa_tag_8021q_vlan *v;
        int err;

        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->tag_8021q_vlan_del(ds, port, vid);

        v = dsa_tag_8021q_vlan_find(ctx, port, vid);
        if (!v)
                return -ENOENT;

        if (!refcount_dec_and_test(&v->refcount))
                return 0;

        err = ds->ops->tag_8021q_vlan_del(ds, port, vid);
        if (err) {
                refcount_inc(&v->refcount);
                return err;
        }

        list_del(&v->list);
        kfree(v);

        return 0;
}

static bool
dsa_switch_tag_8021q_vlan_match(struct dsa_switch *ds, int port,
                                struct dsa_notifier_tag_8021q_vlan_info *info)
{
        if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
                return true;

        if (ds->dst->index == info->tree_index && ds->index == info->sw_index)
                return port == info->port;

        return false;
}

int dsa_switch_tag_8021q_vlan_add(struct dsa_switch *ds,
                                  struct dsa_notifier_tag_8021q_vlan_info *info)
{
        int port, err;

        /* Since we use dsa_broadcast(), there might be other switches in other
         * trees which don't support tag_8021q, so don't return an error.
         * Or they might even support tag_8021q but have not registered yet to
         * use it (maybe they use another tagger currently).
         */
        if (!ds->ops->tag_8021q_vlan_add || !ds->tag_8021q_ctx)
                return 0;

        for (port = 0; port < ds->num_ports; port++) {
                if (dsa_switch_tag_8021q_vlan_match(ds, port, info)) {
                        u16 flags = 0;

                        if (dsa_is_user_port(ds, port))
                                flags |= BRIDGE_VLAN_INFO_UNTAGGED;

                        if (vid_is_dsa_8021q_rxvlan(info->vid) &&
                            dsa_8021q_rx_switch_id(info->vid) == ds->index &&
                            dsa_8021q_rx_source_port(info->vid) == port)
                                flags |= BRIDGE_VLAN_INFO_PVID;

                        err = dsa_switch_do_tag_8021q_vlan_add(ds, port,
                                                               info->vid,
                                                               flags);
                        if (err)
                                return err;
                }
        }

        return 0;
}

int dsa_switch_tag_8021q_vlan_del(struct dsa_switch *ds,
                                  struct dsa_notifier_tag_8021q_vlan_info *info)
{
        int port, err;

        if (!ds->ops->tag_8021q_vlan_del || !ds->tag_8021q_ctx)
                return 0;

        for (port = 0; port < ds->num_ports; port++) {
                if (dsa_switch_tag_8021q_vlan_match(ds, port, info)) {
                        err = dsa_switch_do_tag_8021q_vlan_del(ds, port,
                                                               info->vid);
                        if (err)
                                return err;
                }
        }

        return 0;
}

/* RX VLAN tagging (left) and TX VLAN tagging (right) setup shown for a single
 * front-panel switch port (here swp0).
 *
 * Port identification through VLAN (802.1Q) tags has different requirements
 * for it to work effectively:
 *  - On RX (ingress from network): each front-panel port must have a pvid
 *    that uniquely identifies it, and the egress of this pvid must be tagged
 *    towards the CPU port, so that software can recover the source port based
 *    on the VID in the frame. But this would only work for standalone ports;
 *    if bridged, this VLAN setup would break autonomous forwarding and would
 *    force all switched traffic to pass through the CPU. So we must also make
 *    the other front-panel ports members of this VID we're adding, albeit
 *    we're not making it their PVID (they'll still have their own).
 *  - On TX (ingress from CPU and towards network) we are faced with a problem.
 *    If we were to tag traffic (from within DSA) with the port's pvid, all
 *    would be well, assuming the switch ports were standalone. Frames would
 *    have no choice but to be directed towards the correct front-panel port.
 *    But because we also want the RX VLAN to not break bridging, then
 *    inevitably that means that we have to give them a choice (of what
 *    front-panel port to go out on), and therefore we cannot steer traffic
 *    based on the RX VID. So what we do is simply install one more VID on the
 *    front-panel and CPU ports, and profit off of the fact that steering will
 *    work just by virtue of the fact that there is only one other port that's
 *    a member of the VID we're tagging the traffic with - the desired one.
 *
 * So at the end, each front-panel port will have one RX VID (also the PVID),
 * the RX VID of all other front-panel ports that are in the same bridge, and
 * one TX VID. Whereas the CPU port will have the RX and TX VIDs of all
 * front-panel ports, and on top of that, is also tagged-input and
 * tagged-output (VLAN trunk).
 *
 *               CPU port                               CPU port
 * +-------------+-----+-------------+    +-------------+-----+-------------+
 * |  RX VID     |     |             |    |  TX VID     |     |             |
 * |  of swp0    |     |             |    |  of swp0    |     |             |
 * |             +-----+             |    |             +-----+             |
 * |                ^ T              |    |                | Tagged         |
 * |                |                |    |                | ingress        |
 * |    +-------+---+---+-------+    |    |    +-----------+                |
 * |    |       |       |       |    |    |    | Untagged                   |
 * |    |     U v     U v     U v    |    |    v egress                     |
 * | +-----+ +-----+ +-----+ +-----+ |    | +-----+ +-----+ +-----+ +-----+ |
 * | |     | |     | |     | |     | |    | |     | |     | |     | |     | |
 * | |PVID | |     | |     | |     | |    | |     | |     | |     | |     | |
 * +-+-----+-+-----+-+-----+-+-----+-+    +-+-----+-+-----+-+-----+-+-----+-+
 *   swp0    swp1    swp2    swp3           swp0    swp1    swp2    swp3
 */
static bool dsa_tag_8021q_bridge_match(struct dsa_switch *ds, int port,
                                       struct dsa_notifier_bridge_info *info)
{
        struct dsa_port *dp = dsa_to_port(ds, port);

        /* Don't match on self */
        if (ds->dst->index == info->tree_index &&
            ds->index == info->sw_index &&
            port == info->port)
                return false;

        if (dsa_port_is_user(dp))
                return dp->bridge_dev == info->br;

        return false;
}

int dsa_tag_8021q_bridge_join(struct dsa_switch *ds,
                              struct dsa_notifier_bridge_info *info)
{
        struct dsa_switch *targeted_ds;
        struct dsa_port *targeted_dp;
        u16 targeted_rx_vid;
        int err, port;

        if (!ds->tag_8021q_ctx)
                return 0;

        targeted_ds = dsa_switch_find(info->tree_index, info->sw_index);
        targeted_dp = dsa_to_port(targeted_ds, info->port);
        targeted_rx_vid = dsa_8021q_rx_vid(targeted_ds, info->port);

        for (port = 0; port < ds->num_ports; port++) {
                struct dsa_port *dp = dsa_to_port(ds, port);
                u16 rx_vid = dsa_8021q_rx_vid(ds, port);

                if (!dsa_tag_8021q_bridge_match(ds, port, info))
                        continue;

                /* Install the RX VID of the targeted port in our VLAN table */
                err = dsa_port_tag_8021q_vlan_add(dp, targeted_rx_vid, true);
                if (err)
                        return err;

                /* Install our RX VID into the targeted port's VLAN table */
                err = dsa_port_tag_8021q_vlan_add(targeted_dp, rx_vid, true);
                if (err)
                        return err;
        }

        return 0;
}

int dsa_tag_8021q_bridge_leave(struct dsa_switch *ds,
                               struct dsa_notifier_bridge_info *info)
{
        struct dsa_switch *targeted_ds;
        struct dsa_port *targeted_dp;
        u16 targeted_rx_vid;
        int port;

        if (!ds->tag_8021q_ctx)
                return 0;

        targeted_ds = dsa_switch_find(info->tree_index, info->sw_index);
        targeted_dp = dsa_to_port(targeted_ds, info->port);
        targeted_rx_vid = dsa_8021q_rx_vid(targeted_ds, info->port);

        for (port = 0; port < ds->num_ports; port++) {
                struct dsa_port *dp = dsa_to_port(ds, port);
                u16 rx_vid = dsa_8021q_rx_vid(ds, port);

                if (!dsa_tag_8021q_bridge_match(ds, port, info))
                        continue;

                /* Remove the RX VID of the targeted port from our VLAN table */
                dsa_port_tag_8021q_vlan_del(dp, targeted_rx_vid, true);

                /* Remove our RX VID from the targeted port's VLAN table */
                dsa_port_tag_8021q_vlan_del(targeted_dp, rx_vid, true);
        }

        return 0;
}

int dsa_tag_8021q_bridge_tx_fwd_offload(struct dsa_switch *ds, int port,
                                        struct net_device *br,
                                        int bridge_num)
{
        u16 tx_vid = dsa_8021q_bridge_tx_fwd_offload_vid(bridge_num);

        return dsa_port_tag_8021q_vlan_add(dsa_to_port(ds, port), tx_vid,
                                           true);
}
EXPORT_SYMBOL_GPL(dsa_tag_8021q_bridge_tx_fwd_offload);

void dsa_tag_8021q_bridge_tx_fwd_unoffload(struct dsa_switch *ds, int port,
                                           struct net_device *br,
                                           int bridge_num)
{
        u16 tx_vid = dsa_8021q_bridge_tx_fwd_offload_vid(bridge_num);

        dsa_port_tag_8021q_vlan_del(dsa_to_port(ds, port), tx_vid, true);
}
EXPORT_SYMBOL_GPL(dsa_tag_8021q_bridge_tx_fwd_unoffload);

/* Set up a port's tag_8021q RX and TX VLAN for standalone mode operation */
static int dsa_tag_8021q_port_setup(struct dsa_switch *ds, int port)
{
        struct dsa_8021q_context *ctx = ds->tag_8021q_ctx;
        struct dsa_port *dp = dsa_to_port(ds, port);
        u16 rx_vid = dsa_8021q_rx_vid(ds, port);
        u16 tx_vid = dsa_8021q_tx_vid(ds, port);
        struct net_device *master;
        int err;

        /* The CPU port is implicitly configured by
         * configuring the front-panel ports
         */
        if (!dsa_port_is_user(dp))
                return 0;

        master = dp->cpu_dp->master;

        /* Add this user port's RX VID to the membership list of all others
         * (including itself). This is so that bridging will not be hindered.
         * L2 forwarding rules still take precedence when there are no VLAN
         * restrictions, so there are no concerns about leaking traffic.
         */
        err = dsa_port_tag_8021q_vlan_add(dp, rx_vid, false);
        if (err) {
                dev_err(ds->dev,
                        "Failed to apply RX VID %d to port %d: %pe\n",
                        rx_vid, port, ERR_PTR(err));
                return err;
        }

        /* Add @rx_vid to the master's RX filter. */
        vlan_vid_add(master, ctx->proto, rx_vid);

        /* Finally apply the TX VID on this port and on the CPU port */
        err = dsa_port_tag_8021q_vlan_add(dp, tx_vid, false);
        if (err) {
                dev_err(ds->dev,
                        "Failed to apply TX VID %d on port %d: %pe\n",
                        tx_vid, port, ERR_PTR(err));
                return err;
        }

        return err;
}

static void dsa_tag_8021q_port_teardown(struct dsa_switch *ds, int port)
{
        struct dsa_8021q_context *ctx = ds->tag_8021q_ctx;
        struct dsa_port *dp = dsa_to_port(ds, port);
        u16 rx_vid = dsa_8021q_rx_vid(ds, port);
        u16 tx_vid = dsa_8021q_tx_vid(ds, port);
        struct net_device *master;

        /* The CPU port is implicitly configured by
         * configuring the front-panel ports
         */
        if (!dsa_port_is_user(dp))
                return;

        master = dp->cpu_dp->master;

        dsa_port_tag_8021q_vlan_del(dp, rx_vid, false);

        vlan_vid_del(master, ctx->proto, rx_vid);

        dsa_port_tag_8021q_vlan_del(dp, tx_vid, false);
}

static int dsa_tag_8021q_setup(struct dsa_switch *ds)
{
        int err, port;

        ASSERT_RTNL();

        for (port = 0; port < ds->num_ports; port++) {
                err = dsa_tag_8021q_port_setup(ds, port);
                if (err < 0) {
                        dev_err(ds->dev,
                                "Failed to setup VLAN tagging for port %d: %pe\n",
                                port, ERR_PTR(err));
                        return err;
                }
        }

        return 0;
}

static void dsa_tag_8021q_teardown(struct dsa_switch *ds)
{
        int port;

        ASSERT_RTNL();

        for (port = 0; port < ds->num_ports; port++)
                dsa_tag_8021q_port_teardown(ds, port);
}

int dsa_tag_8021q_register(struct dsa_switch *ds, __be16 proto)
{
        struct dsa_8021q_context *ctx;

        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
        if (!ctx)
                return -ENOMEM;

        ctx->proto = proto;
        ctx->ds = ds;

        INIT_LIST_HEAD(&ctx->vlans);

        ds->tag_8021q_ctx = ctx;

        return dsa_tag_8021q_setup(ds);
}
EXPORT_SYMBOL_GPL(dsa_tag_8021q_register);

void dsa_tag_8021q_unregister(struct dsa_switch *ds)
{
        struct dsa_8021q_context *ctx = ds->tag_8021q_ctx;
        struct dsa_tag_8021q_vlan *v, *n;

        dsa_tag_8021q_teardown(ds);

        list_for_each_entry_safe(v, n, &ctx->vlans, list) {
                list_del(&v->list);
                kfree(v);
        }

        ds->tag_8021q_ctx = NULL;

        kfree(ctx);
}
EXPORT_SYMBOL_GPL(dsa_tag_8021q_unregister);

struct sk_buff *dsa_8021q_xmit(struct sk_buff *skb, struct net_device *netdev,
                               u16 tpid, u16 tci)
{
        /* skb->data points at skb_mac_header, which
         * is fine for vlan_insert_tag.
         */
        return vlan_insert_tag(skb, htons(tpid), tci);
}
EXPORT_SYMBOL_GPL(dsa_8021q_xmit);

void dsa_8021q_rcv(struct sk_buff *skb, int *source_port, int *switch_id)
{
        u16 vid, tci;

        skb_push_rcsum(skb, ETH_HLEN);
        if (skb_vlan_tag_present(skb)) {
                tci = skb_vlan_tag_get(skb);
                __vlan_hwaccel_clear_tag(skb);
        } else {
                __skb_vlan_pop(skb, &tci);
        }
        skb_pull_rcsum(skb, ETH_HLEN);

        vid = tci & VLAN_VID_MASK;

        *source_port = dsa_8021q_rx_source_port(vid);
        *switch_id = dsa_8021q_rx_switch_id(vid);
        skb->priority = (tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
}
EXPORT_SYMBOL_GPL(dsa_8021q_rcv);