| Message ID | 20210922105202.12134-6-xiaoliang.yang_1@nxp.com (mailing list archive) |
|---|---|
| State | Superseded |
| Delegated to: | Netdev Maintainers |
| Headers | show |
| Series | net: dsa: felix: psfp support on vsc9959 | expand |
| Context | Check | Description |
|---|---|---|
| netdev/cover_letter | success | Link |
| netdev/fixes_present | success | Link |
| netdev/patch_count | success | Link |
| netdev/tree_selection | success | Clearly marked for net-next |
| netdev/subject_prefix | success | Link |
| netdev/cc_maintainers | success | CCed 10 of 10 maintainers |
| netdev/source_inline | success | Was 0 now: 0 |
| netdev/verify_signedoff | success | Link |
| netdev/module_param | success | Was 0 now: 0 |
| netdev/build_32bit | success | Errors and warnings before: 0 this patch: 0 |
| netdev/kdoc | success | Errors and warnings before: 0 this patch: 0 |
| netdev/verify_fixes | success | Link |
| netdev/checkpatch | warning | WARNING: line length of 81 exceeds 80 columns WARNING: line length of 84 exceeds 80 columns WARNING: line length of 85 exceeds 80 columns WARNING: line length of 87 exceeds 80 columns WARNING: line length of 89 exceeds 80 columns |
| netdev/build_allmodconfig_warn | success | Errors and warnings before: 0 this patch: 0 |
| netdev/header_inline | success | Link |
Hello Xiaoliang, On Wed, Sep 22, 2021 at 06:51:59PM +0800, Xiaoliang Yang wrote: > +static int vsc9959_mact_stream_set(struct ocelot *ocelot, > + struct felix_stream *stream, > + struct netlink_ext_ack *extack) > +{ > + struct ocelot_mact_entry entry; > + u32 row, col, reg, dst_idx; > + u8 type; > + int ret; > + > + /* Stream identification desn't support to add a stream with non > + * existent MAC (The MAC entry has not been learned in MAC table). > + */ > + ret = ocelot_mact_lookup(ocelot, stream->dmac, stream->vid, &row, &col); > + if (ret) { > + if (extack) > + NL_SET_ERR_MSG_MOD(extack, "Stream is not learned in MAC table"); > + return -EOPNOTSUPP; > + } > + > + ocelot_rmw(ocelot, > + (stream->sfid_valid ? ANA_TABLES_STREAMDATA_SFID_VALID : 0) | > + ANA_TABLES_STREAMDATA_SFID(stream->sfid), > + ANA_TABLES_STREAMDATA_SFID_VALID | > + ANA_TABLES_STREAMDATA_SFID_M, > + ANA_TABLES_STREAMDATA); > + > + reg = ocelot_read(ocelot, ANA_TABLES_MACACCESS); > + dst_idx = (reg & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3; > + type = ANA_TABLES_MACACCESS_ENTRYTYPE_X(reg); > + > + reg = ocelot_read(ocelot, ANA_TABLES_STREAMDATA); > + if ((ANA_TABLES_STREAMDATA_SFID_VALID | > + ANA_TABLES_STREAMDATA_SSID_VALID) & reg) { > + entry.type = (type ? type : ENTRYTYPE_LOCKED); > + stream->rsv_type = type; > + } else { > + entry.type = stream->rsv_type; > + } > + > + ether_addr_copy(entry.mac, stream->dmac); > + entry.vid = stream->vid; > + > + ocelot_mact_write(ocelot, dst_idx, &entry, row, col); > + > + return 0; > +} > +static int vsc9959_stream_table_add(struct ocelot *ocelot, > + struct list_head *stream_list, > + struct felix_stream *stream, > + struct netlink_ext_ack *extack) > +{ > + struct felix_stream *stream_entry; > + int ret; > + > + stream_entry = kzalloc(sizeof(*stream_entry), GFP_KERNEL); > + if (!stream_entry) > + return -ENOMEM; > + > + memcpy(stream_entry, stream, sizeof(*stream_entry)); > + > + ret = vsc9959_mact_stream_set(ocelot, stream_entry, extack); > + if (ret) { > + kfree(stream_entry); > + return ret; > + } > + > + list_add_tail(&stream_entry->list, stream_list); > + > + return 0; > +} Remember this discussion we had a while ago? | Let's take the function below. | | static void ocelot_prove_mac_table_entries_can_move(struct ocelot *ocelot) | { | unsigned char mac1[ETH_ALEN] = {0x00, 0x04, 0x9f, 0x63, 0x35, 0xea}; | unsigned char mac2[ETH_ALEN] = {0x00, 0x04, 0x9f, 0x63, 0x35, 0xeb}; | int row, bucket, arbitrary_pgid = 4; | int vid1 = 102; | int vid2 = 103; | int err; | | err = ocelot_mact_learn(ocelot, arbitrary_pgid, mac1, vid1, | ENTRYTYPE_LOCKED); | if (err) | return; | | err = ocelot_mact_lookup(ocelot, mac1, vid1, &row, &bucket); | if (err) | return; | | dev_info(ocelot->dev, | "Address 1 (mac %pM vid %d) is in MAC table row %d bucket %d\n", | mac1, vid1, row, bucket); | | err = ocelot_mact_learn(ocelot, arbitrary_pgid, mac2, vid2, | ENTRYTYPE_LOCKED); | if (err) | return; | | err = ocelot_mact_lookup(ocelot, mac2, vid2, &row, &bucket); | if (err) | return; | | dev_info(ocelot->dev, | "Address 2 (mac %pM vid %d) is in MAC table row %d bucket %d\n", | mac2, vid2, row, bucket); | | err = ocelot_mact_lookup(ocelot, mac1, vid1, &row, &bucket); | if (err) | return; | | dev_info(ocelot->dev, | "Address 1 (mac %pM vid %d) is in MAC table row %d bucket %d\n", | mac1, vid1, row, bucket); | } | | What will it print? | | Address 1 (mac 00:04:9f:63:35:ea vid 102) is in MAC table row 917 bucket 0 | Address 2 (mac 00:04:9f:63:35:eb vid 103) is in MAC table row 917 bucket 0 | Address 1 (mac 00:04:9f:63:35:ea vid 102) is in MAC table row 917 bucket 1 | | What does this mean? | | The ROW portion of a FDB entry's position within the MAC table is | statically determined using an 11-bit hash derived from the {DMAC, VID} | key. Within a row, there can be up to 4 buckets, each bucket holding 1 | MAC table entry. | | But when the hashes of 2 addresses collide and they end up in the same | row (as in the above example, with address 1 = "mac 00:04:9f:63:35:ea | vid 102" and address 2 = "mac 00:04:9f:63:35:eb vid 103"), things don't | happen quite as you might expect. Namely, the second address appears to | be installed by the switch at the same row and bucket as the first | address. So is the first address overwritten? No, it has been moved by | the switch, automatically, to bucket 1. So if the autonomous and concurrent learning of one MAC address might move existing MAC table entries from a row to the right, then who guarantees exactly that the {row, col} for which you are setting up the SFID is the {row, col} that belongs to the {stream->dmac, stream->vid} you have searched for? Microchip people, do we need to temporarily disable hardware address learning on all ports, and take a lock with the FDB add and delete operations to ensure they are serialized?
Hi Vladimir, On Wed, Sep 22, 2021 at 12:47:59 +0000, Vladimir Oltean wrote: > > +static int vsc9959_mact_stream_set(struct ocelot *ocelot, > > + struct felix_stream *stream, > > + struct netlink_ext_ack *extack) { > > + struct ocelot_mact_entry entry; > > + u32 row, col, reg, dst_idx; > > + u8 type; > > + int ret; > > + > > + /* Stream identification desn't support to add a stream with non > > + * existent MAC (The MAC entry has not been learned in MAC table). > > + */ > > + ret = ocelot_mact_lookup(ocelot, stream->dmac, stream->vid, &row, > &col); > > + if (ret) { > > + if (extack) > > + NL_SET_ERR_MSG_MOD(extack, "Stream is not learned in MAC > table"); > > + return -EOPNOTSUPP; > > + } > > + > > + ocelot_rmw(ocelot, > > + (stream->sfid_valid ? ANA_TABLES_STREAMDATA_SFID_VALID : 0) > | > > + ANA_TABLES_STREAMDATA_SFID(stream->sfid), > > + ANA_TABLES_STREAMDATA_SFID_VALID | > > + ANA_TABLES_STREAMDATA_SFID_M, > > + ANA_TABLES_STREAMDATA); > > + > > + reg = ocelot_read(ocelot, ANA_TABLES_MACACCESS); > > + dst_idx = (reg & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3; > > + type = ANA_TABLES_MACACCESS_ENTRYTYPE_X(reg); > > + > > + reg = ocelot_read(ocelot, ANA_TABLES_STREAMDATA); > > + if ((ANA_TABLES_STREAMDATA_SFID_VALID | > > + ANA_TABLES_STREAMDATA_SSID_VALID) & reg) { > > + entry.type = (type ? type : ENTRYTYPE_LOCKED); > > + stream->rsv_type = type; > > + } else { > > + entry.type = stream->rsv_type; > > + } > > + > > + ether_addr_copy(entry.mac, stream->dmac); > > + entry.vid = stream->vid; > > + > > + ocelot_mact_write(ocelot, dst_idx, &entry, row, col); > > + > > + return 0; > > +} > > > +static int vsc9959_stream_table_add(struct ocelot *ocelot, > > + struct list_head *stream_list, > > + struct felix_stream *stream, > > + struct netlink_ext_ack *extack) { > > + struct felix_stream *stream_entry; > > + int ret; > > + > > + stream_entry = kzalloc(sizeof(*stream_entry), GFP_KERNEL); > > + if (!stream_entry) > > + return -ENOMEM; > > + > > + memcpy(stream_entry, stream, sizeof(*stream_entry)); > > + > > + ret = vsc9959_mact_stream_set(ocelot, stream_entry, extack); > > + if (ret) { > > + kfree(stream_entry); > > + return ret; > > + } > > + > > + list_add_tail(&stream_entry->list, stream_list); > > + > > + return 0; > > +} > > Remember this discussion we had a while ago? > > | Let's take the function below. > | > | static void ocelot_prove_mac_table_entries_can_move(struct ocelot > | *ocelot) { > | unsigned char mac1[ETH_ALEN] = {0x00, 0x04, 0x9f, 0x63, 0x35, 0xea}; > | unsigned char mac2[ETH_ALEN] = {0x00, 0x04, 0x9f, 0x63, 0x35, 0xeb}; > | int row, bucket, arbitrary_pgid = 4; > | int vid1 = 102; > | int vid2 = 103; > | int err; > | > | err = ocelot_mact_learn(ocelot, arbitrary_pgid, mac1, vid1, > | ENTRYTYPE_LOCKED); > | if (err) > | return; > | > | err = ocelot_mact_lookup(ocelot, mac1, vid1, &row, &bucket); > | if (err) > | return; > | > | dev_info(ocelot->dev, > | "Address 1 (mac %pM vid %d) is in MAC table row %d > bucket %d\n", > | mac1, vid1, row, bucket); > | > | err = ocelot_mact_learn(ocelot, arbitrary_pgid, mac2, vid2, > | ENTRYTYPE_LOCKED); > | if (err) > | return; > | > | err = ocelot_mact_lookup(ocelot, mac2, vid2, &row, &bucket); > | if (err) > | return; > | > | dev_info(ocelot->dev, > | "Address 2 (mac %pM vid %d) is in MAC table row %d > bucket %d\n", > | mac2, vid2, row, bucket); > | > | err = ocelot_mact_lookup(ocelot, mac1, vid1, &row, &bucket); > | if (err) > | return; > | > | dev_info(ocelot->dev, > | "Address 1 (mac %pM vid %d) is in MAC table row %d > bucket %d\n", > | mac1, vid1, row, bucket); > | } > | > | What will it print? > | > | Address 1 (mac 00:04:9f:63:35:ea vid 102) is in MAC table row 917 > | bucket 0 Address 2 (mac 00:04:9f:63:35:eb vid 103) is in MAC table row > | 917 bucket 0 Address 1 (mac 00:04:9f:63:35:ea vid 102) is in MAC table > | row 917 bucket 1 > | > | What does this mean? > | > | The ROW portion of a FDB entry's position within the MAC table is > | statically determined using an 11-bit hash derived from the {DMAC, > | VID} key. Within a row, there can be up to 4 buckets, each bucket > | holding 1 MAC table entry. > | > | But when the hashes of 2 addresses collide and they end up in the same > | row (as in the above example, with address 1 = "mac 00:04:9f:63:35:ea > | vid 102" and address 2 = "mac 00:04:9f:63:35:eb vid 103"), things > | don't happen quite as you might expect. Namely, the second address > | appears to be installed by the switch at the same row and bucket as > | the first address. So is the first address overwritten? No, it has > | been moved by the switch, automatically, to bucket 1. > > So if the autonomous and concurrent learning of one MAC address might > move existing MAC table entries from a row to the right, then who guarantees > exactly that the {row, col} for which you are setting up the SFID is the {row, col} > that belongs to the {stream->dmac, stream->vid} you have searched for? > > Microchip people, do we need to temporarily disable hardware address > learning on all ports, and take a lock with the FDB add and delete operations > to ensure they are serialized? Maybe we need to use ocelot_mact_learn() instead of ocelot_mact_write() after setting SFID in StreamData. I think this can avoid writing a wrong entry. Regards, Xiaoliang
On Thu, Sep 23, 2021 at 02:30:16AM +0000, Xiaoliang Yang wrote: > Maybe we need to use ocelot_mact_learn() instead of > ocelot_mact_write() after setting SFID in StreamData. I think this can > avoid writing a wrong entry. So you're thinking of introducing a new ocelot_mact_learn_with_streamdata(), that writes the SFID and SSID of the STREAMDATA too, instead of editing them in-place for an existing MAC table entry, and then issuing a LEARN MAC Table command which would hopefully transfer the entire data structure to the MAC table? Have you tried that? In the documentation for the LEARN MAC Table command, I see: Purpose: Insert/learn new entry in MAC table. Position given by (MAC, VID) Use: Configure MAC and VID of the new entry in MACHDATA and MACLDATA. Configure remaining entry fields in MACACCESS. The location in the MAC table is calculated based on (MAC, VID). I just hope it will transfer the STREAMDATA too, it doesn't explicitly say that it will... And assuming it does, will the LEARN command overwrite an existing static FDB entry which has the same MAC DA and VLAN ID, but not SFID? I haven't tried that either.
Hi Vladimir, On Thu, Sep 23, 2021 at 15:45:16 +0000, Vladimir Oltean wrote: > > Maybe we need to use ocelot_mact_learn() instead of > > ocelot_mact_write() after setting SFID in StreamData. I think this can > > avoid writing a wrong entry. > > So you're thinking of introducing a new ocelot_mact_learn_with_streamdata(), > that writes the SFID and SSID of the STREAMDATA too, instead of editing them > in-place for an existing MAC table entry, and then issuing a LEARN MAC Table > command which would hopefully transfer the entire data structure to the MAC > table? > > Have you tried that? Yes, I have tried. I mean writes SFID of STREAMDATA in vsc9959_mact_stream_set() first, then calls ocelot_mact_learn() function to write VID, mac and STREAMDATA in MAC table. We don't need to introduce a new function. Once we call ocelot_mact_learn() function, STREAMDATA will be stored in the learned entry. > > In the documentation for the LEARN MAC Table command, I see: > > Purpose: Insert/learn new entry in MAC table. Position given by (MAC, VID) > > Use: Configure MAC and VID of the new entry in MACHDATA and MACLDATA. > Configure remaining entry fields in MACACCESS. The location in the MAC > table is calculated based on (MAC, VID). > > I just hope it will transfer the STREAMDATA too, it doesn't explicitly say that it > will... > > And assuming it does, will the LEARN command overwrite an existing static > FDB entry which has the same MAC DA and VLAN ID, but not SFID? > I haven't tried that either. I tried the case that when MAC table index has changed, STREAMDATA will keep move with VID and MAC. The entry { STREAMDATA , VID, MAC} also can overwrite a static exist entry. I think we can do like this.
On Thu, Sep 23, 2021 at 11:23:45AM +0000, Xiaoliang Yang wrote: > Hi Vladimir, > > On Thu, Sep 23, 2021 at 15:45:16 +0000, Vladimir Oltean wrote: > > > Maybe we need to use ocelot_mact_learn() instead of > > > ocelot_mact_write() after setting SFID in StreamData. I think this can > > > avoid writing a wrong entry. > > > > So you're thinking of introducing a new ocelot_mact_learn_with_streamdata(), > > that writes the SFID and SSID of the STREAMDATA too, instead of editing them > > in-place for an existing MAC table entry, and then issuing a LEARN MAC Table > > command which would hopefully transfer the entire data structure to the MAC > > table? > > > > Have you tried that? > > Yes, I have tried. I mean writes SFID of STREAMDATA in > vsc9959_mact_stream_set() first, then calls ocelot_mact_learn() > function to write VID, mac and STREAMDATA in MAC table. We don't need > to introduce a new function. Once we call ocelot_mact_learn() > function, STREAMDATA will be stored in the learned entry. > > > > > In the documentation for the LEARN MAC Table command, I see: > > > > Purpose: Insert/learn new entry in MAC table. Position given by (MAC, VID) > > > > Use: Configure MAC and VID of the new entry in MACHDATA and MACLDATA. > > Configure remaining entry fields in MACACCESS. The location in the MAC > > table is calculated based on (MAC, VID). > > > > I just hope it will transfer the STREAMDATA too, it doesn't explicitly say that it > > will... > > > > And assuming it does, will the LEARN command overwrite an existing static > > FDB entry which has the same MAC DA and VLAN ID, but not SFID? > > I haven't tried that either. > > I tried the case that when MAC table index has changed, STREAMDATA > will keep move with VID and MAC. The entry { STREAMDATA , VID, MAC} > also can overwrite a static exist entry. I think we can do like this. Ok, so maybe we should do that? Even though I must say I don't really like the idea of partially writing MAC table entry data from the vsc9959 driver, and partially from ocelot_mact_learn. I also have this patch pending: https://patchwork.kernel.org/project/netdevbpf/patch/20210824114049.3814660-4-vladimir.oltean@nxp.com/ and concurrency will be an absolute mess. The ocelot->mact_lock will need to be taken _before_ we start writing the STREAMDATA, so this variant of ocelot_mact_learn will still have to stay somewhere in the ocelot library, and be organized something like this: __ocelot_mact_learn() { do what ocelot_mact_learn() currently does } ocelot_mact_learn() { mutex_lock(&ocelot->mact_lock); __ocelot_mact_learn(); mutex_unlock(&ocelot->mact_lock); } ocelot_mact_learn_streamdata() { mutex_lock(&ocelot->mact_lock); write_streamdata(); __ocelot_mact_learn(); mutex_unlock(&ocelot->mact_lock); } otherwise I would need to introduce avoidable refactoring in the driver. In fact, could you please pick up that mact_lock patch? Even if the rtnl_mutex was not dropped yet, the extra lock should not hurt anyone.
diff --git a/drivers/net/dsa/ocelot/felix_vsc9959.c b/drivers/net/dsa/ocelot/felix_vsc9959.c index f966a253d1c7..52d10aab93b2 100644 --- a/drivers/net/dsa/ocelot/felix_vsc9959.c +++ b/drivers/net/dsa/ocelot/felix_vsc9959.c @@ -5,6 +5,7 @@ #include <linux/fsl/enetc_mdio.h> #include <soc/mscc/ocelot_qsys.h> #include <soc/mscc/ocelot_vcap.h> +#include <soc/mscc/ocelot_ana.h> #include <soc/mscc/ocelot_ptp.h> #include <soc/mscc/ocelot_sys.h> #include <soc/mscc/ocelot.h> @@ -292,7 +293,7 @@ static const u32 vsc9959_sys_regmap[] = { REG_RESERVED(SYS_MMGT_FAST), REG_RESERVED(SYS_EVENTS_DIF), REG_RESERVED(SYS_EVENTS_CORE), - REG_RESERVED(SYS_CNT), + REG(SYS_CNT, 0x000000), REG(SYS_PTP_STATUS, 0x000f14), REG(SYS_PTP_TXSTAMP, 0x000f18), REG(SYS_PTP_NXT, 0x000f1c), @@ -1022,15 +1023,6 @@ static void vsc9959_wm_stat(u32 val, u32 *inuse, u32 *maxuse) *maxuse = val & GENMASK(11, 0); } -static const struct ocelot_ops vsc9959_ops = { - .reset = vsc9959_reset, - .wm_enc = vsc9959_wm_enc, - .wm_dec = vsc9959_wm_dec, - .wm_stat = vsc9959_wm_stat, - .port_to_netdev = felix_port_to_netdev, - .netdev_to_port = felix_netdev_to_port, -}; - static int vsc9959_mdio_bus_alloc(struct ocelot *ocelot) { struct felix *felix = ocelot_to_felix(ocelot); @@ -1346,6 +1338,448 @@ static int vsc9959_port_setup_tc(struct dsa_switch *ds, int port, } } +#define VSC9959_PSFP_SFID_MAX 175 +#define VSC9959_PSFP_GATE_ID_MAX 183 +#define VSC9959_PSFP_POLICER_MAX 383 + +struct felix_stream { + struct list_head list; + unsigned long id; + u8 dmac[ETH_ALEN]; + u16 vid; + s8 prio; + u8 sfid_valid; + u32 sfid; + u8 rsv_type; +}; + +struct felix_stream_filter { + struct list_head list; + refcount_t refcount; + u32 index; + u8 enable; + u8 sg_valid; + u32 sgid; + u8 fm_valid; + u32 fmid; + u8 prio_valid; + u8 prio; + u32 maxsdu; +}; + +struct felix_stream_filter_counters { + u32 match; + u32 not_pass_gate; + u32 not_pass_sdu; + u32 red; +}; + +static int vsc9959_stream_identify(struct flow_cls_offload *f, + struct felix_stream *stream) +{ + struct flow_rule *rule = flow_cls_offload_flow_rule(f); + struct flow_dissector *dissector = rule->match.dissector; + + if (dissector->used_keys & + ~(BIT(FLOW_DISSECTOR_KEY_CONTROL) | + BIT(FLOW_DISSECTOR_KEY_BASIC) | + BIT(FLOW_DISSECTOR_KEY_VLAN) | + BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS))) + return -EOPNOTSUPP; + + if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) { + struct flow_match_eth_addrs match; + + flow_rule_match_eth_addrs(rule, &match); + ether_addr_copy(stream->dmac, match.key->dst); + if (!is_zero_ether_addr(match.mask->src)) + return -EOPNOTSUPP; + } else { + return -EOPNOTSUPP; + } + + if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN)) { + struct flow_match_vlan match; + + flow_rule_match_vlan(rule, &match); + if (match.mask->vlan_priority) + stream->prio = match.key->vlan_priority; + else + stream->prio = -1; + + if (!match.mask->vlan_id) + return -EOPNOTSUPP; + stream->vid = match.key->vlan_id; + } else { + return -EOPNOTSUPP; + } + + stream->id = f->cookie; + + return 0; +} + +static int vsc9959_mact_stream_set(struct ocelot *ocelot, + struct felix_stream *stream, + struct netlink_ext_ack *extack) +{ + struct ocelot_mact_entry entry; + u32 row, col, reg, dst_idx; + u8 type; + int ret; + + /* Stream identification desn't support to add a stream with non + * existent MAC (The MAC entry has not been learned in MAC table). + */ + ret = ocelot_mact_lookup(ocelot, stream->dmac, stream->vid, &row, &col); + if (ret) { + if (extack) + NL_SET_ERR_MSG_MOD(extack, "Stream is not learned in MAC table"); + return -EOPNOTSUPP; + } + + ocelot_rmw(ocelot, + (stream->sfid_valid ? ANA_TABLES_STREAMDATA_SFID_VALID : 0) | + ANA_TABLES_STREAMDATA_SFID(stream->sfid), + ANA_TABLES_STREAMDATA_SFID_VALID | + ANA_TABLES_STREAMDATA_SFID_M, + ANA_TABLES_STREAMDATA); + + reg = ocelot_read(ocelot, ANA_TABLES_MACACCESS); + dst_idx = (reg & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3; + type = ANA_TABLES_MACACCESS_ENTRYTYPE_X(reg); + + reg = ocelot_read(ocelot, ANA_TABLES_STREAMDATA); + if ((ANA_TABLES_STREAMDATA_SFID_VALID | + ANA_TABLES_STREAMDATA_SSID_VALID) & reg) { + entry.type = (type ? type : ENTRYTYPE_LOCKED); + stream->rsv_type = type; + } else { + entry.type = stream->rsv_type; + } + + ether_addr_copy(entry.mac, stream->dmac); + entry.vid = stream->vid; + + ocelot_mact_write(ocelot, dst_idx, &entry, row, col); + + return 0; +} + +static struct felix_stream * +vsc9959_stream_table_lookup(struct list_head *stream_list, + struct felix_stream *stream) +{ + struct felix_stream *tmp; + + list_for_each_entry(tmp, stream_list, list) + if (ether_addr_equal(tmp->dmac, stream->dmac) && + tmp->vid == stream->vid) + return tmp; + + return NULL; +} + +static int vsc9959_stream_table_add(struct ocelot *ocelot, + struct list_head *stream_list, + struct felix_stream *stream, + struct netlink_ext_ack *extack) +{ + struct felix_stream *stream_entry; + int ret; + + stream_entry = kzalloc(sizeof(*stream_entry), GFP_KERNEL); + if (!stream_entry) + return -ENOMEM; + + memcpy(stream_entry, stream, sizeof(*stream_entry)); + + ret = vsc9959_mact_stream_set(ocelot, stream_entry, extack); + if (ret) { + kfree(stream_entry); + return ret; + } + + list_add_tail(&stream_entry->list, stream_list); + + return 0; +} + +static struct felix_stream * +vsc9959_stream_table_get(struct list_head *stream_list, unsigned long id) +{ + struct felix_stream *tmp; + + list_for_each_entry(tmp, stream_list, list) + if (tmp->id == id) + return tmp; + + return NULL; +} + +static void vsc9959_stream_table_del(struct ocelot *ocelot, + struct felix_stream *stream) +{ + vsc9959_mact_stream_set(ocelot, stream, NULL); + + list_del(&stream->list); + kfree(stream); +} + +static u32 vsc9959_sfi_access_status(struct ocelot *ocelot) +{ + return ocelot_read(ocelot, ANA_TABLES_SFIDACCESS); +} + +static int vsc9959_psfp_sfi_set(struct ocelot *ocelot, + struct felix_stream_filter *sfi) +{ + u32 val; + + if (sfi->index > VSC9959_PSFP_SFID_MAX) + return -EINVAL; + + if (!sfi->enable) { + ocelot_write(ocelot, ANA_TABLES_SFIDTIDX_SFID_INDEX(sfi->index), + ANA_TABLES_SFIDTIDX); + + val = ANA_TABLES_SFIDACCESS_SFID_TBL_CMD(SFIDACCESS_CMD_WRITE); + ocelot_write(ocelot, val, ANA_TABLES_SFIDACCESS); + + return readx_poll_timeout(vsc9959_sfi_access_status, ocelot, val, + (!ANA_TABLES_SFIDACCESS_SFID_TBL_CMD(val)), + 10, 100000); + } + + if (sfi->sgid > VSC9959_PSFP_GATE_ID_MAX || + sfi->fmid > VSC9959_PSFP_POLICER_MAX) + return -EINVAL; + + ocelot_write(ocelot, + (sfi->sg_valid ? ANA_TABLES_SFIDTIDX_SGID_VALID : 0) | + ANA_TABLES_SFIDTIDX_SGID(sfi->sgid) | + (sfi->fm_valid ? ANA_TABLES_SFIDTIDX_POL_ENA : 0) | + ANA_TABLES_SFIDTIDX_POL_IDX(sfi->fmid) | + ANA_TABLES_SFIDTIDX_SFID_INDEX(sfi->index), + ANA_TABLES_SFIDTIDX); + + ocelot_write(ocelot, + (sfi->prio_valid ? ANA_TABLES_SFIDACCESS_IGR_PRIO_MATCH_ENA : 0) | + ANA_TABLES_SFIDACCESS_IGR_PRIO(sfi->prio) | + ANA_TABLES_SFIDACCESS_MAX_SDU_LEN(sfi->maxsdu) | + ANA_TABLES_SFIDACCESS_SFID_TBL_CMD(SFIDACCESS_CMD_WRITE), + ANA_TABLES_SFIDACCESS); + + return readx_poll_timeout(vsc9959_sfi_access_status, ocelot, val, + (!ANA_TABLES_SFIDACCESS_SFID_TBL_CMD(val)), + 10, 100000); +} + +static int vsc9959_psfp_sfi_table_add(struct ocelot *ocelot, + struct felix_stream_filter *sfi) +{ + struct felix_stream_filter *sfi_entry, *tmp; + struct list_head *pos, *q, *last; + struct ocelot_psfp_list *psfp; + u32 insert = 0; + int ret; + + psfp = &ocelot->psfp; + last = &psfp->sfi_list; + + list_for_each_safe(pos, q, &psfp->sfi_list) { + tmp = list_entry(pos, struct felix_stream_filter, list); + if (sfi->sg_valid == tmp->sg_valid && + sfi->fm_valid == tmp->fm_valid && + tmp->sgid == sfi->sgid && + tmp->fmid == sfi->fmid) { + sfi->index = tmp->index; + refcount_inc(&tmp->refcount); + return 0; + } + /* Make sure that the index is increasing in order. */ + if (tmp->index == insert) { + last = pos; + insert++; + } + } + sfi->index = insert; + + sfi_entry = kzalloc(sizeof(*sfi_entry), GFP_KERNEL); + if (!sfi_entry) + return -ENOMEM; + + memcpy(sfi_entry, sfi, sizeof(*sfi_entry)); + refcount_set(&sfi_entry->refcount, 1); + + ret = vsc9959_psfp_sfi_set(ocelot, sfi_entry); + if (ret) { + kfree(sfi_entry); + return ret; + } + + list_add(&sfi_entry->list, last); + + return 0; +} + +static void vsc9959_psfp_sfi_table_del(struct ocelot *ocelot, u32 index) +{ + struct felix_stream_filter *tmp, *n; + struct ocelot_psfp_list *psfp; + u8 z; + + psfp = &ocelot->psfp; + + list_for_each_entry_safe(tmp, n, &psfp->sfi_list, list) + if (tmp->index == index) { + z = refcount_dec_and_test(&tmp->refcount); + if (z) { + tmp->enable = 0; + vsc9959_psfp_sfi_set(ocelot, tmp); + list_del(&tmp->list); + kfree(tmp); + } + break; + } +} + +static void vsc9959_psfp_counters_get(struct ocelot *ocelot, u32 index, + struct felix_stream_filter_counters *counters) +{ + ocelot_rmw(ocelot, SYS_STAT_CFG_STAT_VIEW(index), + SYS_STAT_CFG_STAT_VIEW_M, + SYS_STAT_CFG); + + counters->match = ocelot_read_gix(ocelot, SYS_CNT, 0x200); + counters->not_pass_gate = ocelot_read_gix(ocelot, SYS_CNT, 0x201); + counters->not_pass_sdu = ocelot_read_gix(ocelot, SYS_CNT, 0x202); + counters->red = ocelot_read_gix(ocelot, SYS_CNT, 0x203); + + /* Clear the PSFP counter. */ + ocelot_write(ocelot, + SYS_STAT_CFG_STAT_VIEW(index) | + SYS_STAT_CFG_STAT_CLEAR_SHOT(0x10), + SYS_STAT_CFG); +} + +static int vsc9959_psfp_filter_add(struct ocelot *ocelot, + struct flow_cls_offload *f) +{ + struct netlink_ext_ack *extack = f->common.extack; + struct felix_stream_filter sfi = {0}; + const struct flow_action_entry *a; + struct felix_stream *stream_entry; + struct felix_stream stream = {0}; + struct ocelot_psfp_list *psfp; + int ret, i; + + psfp = &ocelot->psfp; + + ret = vsc9959_stream_identify(f, &stream); + if (ret) { + NL_SET_ERR_MSG_MOD(extack, "Only can match on VID, PCP, and dest MAC"); + return ret; + } + + flow_action_for_each(i, a, &f->rule->action) { + switch (a->id) { + case FLOW_ACTION_GATE: + case FLOW_ACTION_POLICE: + default: + return -EOPNOTSUPP; + } + } + + /* Check if stream is set. */ + stream_entry = vsc9959_stream_table_lookup(&psfp->stream_list, &stream); + if (stream_entry) { + NL_SET_ERR_MSG_MOD(extack, "This stream is already added"); + return -EEXIST; + } + + sfi.prio_valid = (stream.prio < 0 ? 0 : 1); + sfi.prio = (sfi.prio_valid ? stream.prio : 0); + sfi.enable = 1; + + ret = vsc9959_psfp_sfi_table_add(ocelot, &sfi); + if (ret) + return ret; + + stream.sfid = sfi.index; + stream.sfid_valid = 1; + ret = vsc9959_stream_table_add(ocelot, &psfp->stream_list, + &stream, extack); + if (ret) + vsc9959_psfp_sfi_table_del(ocelot, stream.sfid); + + return ret; +} + +static int vsc9959_psfp_filter_del(struct ocelot *ocelot, + struct flow_cls_offload *f) +{ + struct ocelot_psfp_list *psfp; + struct felix_stream *stream; + + psfp = &ocelot->psfp; + + stream = vsc9959_stream_table_get(&psfp->stream_list, f->cookie); + if (!stream) + return -ENOMEM; + + vsc9959_psfp_sfi_table_del(ocelot, stream->sfid); + + stream->sfid_valid = 0; + vsc9959_stream_table_del(ocelot, stream); + + return 0; +} + +static int vsc9959_psfp_stats_get(struct ocelot *ocelot, + struct flow_cls_offload *f, + struct flow_stats *stats) +{ + struct felix_stream_filter_counters counters; + struct ocelot_psfp_list *psfp; + struct felix_stream *stream; + + psfp = &ocelot->psfp; + stream = vsc9959_stream_table_get(&psfp->stream_list, f->cookie); + if (!stream) + return -ENOMEM; + + vsc9959_psfp_counters_get(ocelot, stream->sfid, &counters); + + stats->pkts = counters.match; + stats->drops = counters.not_pass_gate + counters.not_pass_sdu + + counters.red; + + return 0; +} + +static void vsc9959_psfp_init(struct ocelot *ocelot) +{ + struct ocelot_psfp_list *psfp = &ocelot->psfp; + + INIT_LIST_HEAD(&psfp->stream_list); + INIT_LIST_HEAD(&psfp->sfi_list); + INIT_LIST_HEAD(&psfp->sgi_list); +} + +static const struct ocelot_ops vsc9959_ops = { + .reset = vsc9959_reset, + .wm_enc = vsc9959_wm_enc, + .wm_dec = vsc9959_wm_dec, + .wm_stat = vsc9959_wm_stat, + .port_to_netdev = felix_port_to_netdev, + .netdev_to_port = felix_netdev_to_port, + .psfp_init = vsc9959_psfp_init, + .psfp_filter_add = vsc9959_psfp_filter_add, + .psfp_filter_del = vsc9959_psfp_filter_del, + .psfp_stats_get = vsc9959_psfp_stats_get, +}; + static const struct felix_info felix_info_vsc9959 = { .target_io_res = vsc9959_target_io_res, .port_io_res = vsc9959_port_io_res, diff --git a/include/soc/mscc/ocelot.h b/include/soc/mscc/ocelot.h index 096c38c65157..a611f9cd5935 100644 --- a/include/soc/mscc/ocelot.h +++ b/include/soc/mscc/ocelot.h @@ -582,6 +582,12 @@ struct ocelot_vlan { u16 vid; }; +struct ocelot_psfp_list { + struct list_head stream_list; + struct list_head sfi_list; + struct list_head sgi_list; +}; + enum ocelot_sb { OCELOT_SB_BUF, OCELOT_SB_REF, @@ -673,6 +679,8 @@ struct ocelot { struct ocelot_vcap_block block[3]; struct vcap_props *vcap; + struct ocelot_psfp_list psfp; + /* Workqueue to check statistics for overflow with its lock */ struct mutex stats_lock; u64 *stats; diff --git a/include/soc/mscc/ocelot_ana.h b/include/soc/mscc/ocelot_ana.h index 1669481d9779..67e0ae05a5ab 100644 --- a/include/soc/mscc/ocelot_ana.h +++ b/include/soc/mscc/ocelot_ana.h @@ -227,6 +227,11 @@ #define ANA_TABLES_SFIDACCESS_SFID_TBL_CMD(x) ((x) & GENMASK(1, 0)) #define ANA_TABLES_SFIDACCESS_SFID_TBL_CMD_M GENMASK(1, 0) +#define SFIDACCESS_CMD_IDLE 0 +#define SFIDACCESS_CMD_READ 1 +#define SFIDACCESS_CMD_WRITE 2 +#define SFIDACCESS_CMD_INIT 3 + #define ANA_TABLES_SFIDTIDX_SGID_VALID BIT(26) #define ANA_TABLES_SFIDTIDX_SGID(x) (((x) << 18) & GENMASK(25, 18)) #define ANA_TABLES_SFIDTIDX_SGID_M GENMASK(25, 18) @@ -255,6 +260,11 @@ #define ANA_SG_CONFIG_REG_3_INIT_IPS(x) (((x) << 21) & GENMASK(24, 21)) #define ANA_SG_CONFIG_REG_3_INIT_IPS_M GENMASK(24, 21) #define ANA_SG_CONFIG_REG_3_INIT_IPS_X(x) (((x) & GENMASK(24, 21)) >> 21) +#define ANA_SG_CONFIG_REG_3_IPV_VALID BIT(24) +#define ANA_SG_CONFIG_REG_3_IPV_INVALID(x) (((x) << 24) & GENMASK(24, 24)) +#define ANA_SG_CONFIG_REG_3_INIT_IPV(x) (((x) << 21) & GENMASK(23, 21)) +#define ANA_SG_CONFIG_REG_3_INIT_IPV_M GENMASK(23, 21) +#define ANA_SG_CONFIG_REG_3_INIT_IPV_X(x) (((x) & GENMASK(23, 21)) >> 21) #define ANA_SG_CONFIG_REG_3_INIT_GATE_STATE BIT(25) #define ANA_SG_GCL_GS_CONFIG_RSZ 0x4
VSC9959 supports Per-Stream Filtering and Policing(PSFP) that complies with the IEEE 802.1Qci standard. The stream is identified by Null stream identification(DMAC and VLAN ID) defined in IEEE802.1CB. For PSFP, four tables need to be set up: stream table, stream filter table, stream gate table, and flow meter table. Identify the stream by parsing the tc flower keys and add it to the stream table. The stream filter table is automatically maintained, and its index is determined by SGID(flow gate index) and FMID(flow meter index). Signed-off-by: Xiaoliang Yang <xiaoliang.yang_1@nxp.com> --- drivers/net/dsa/ocelot/felix_vsc9959.c | 454 ++++++++++++++++++++++++- include/soc/mscc/ocelot.h | 8 + include/soc/mscc/ocelot_ana.h | 10 + 3 files changed, 462 insertions(+), 10 deletions(-)