| Message ID | 20210831034536.17497-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 |
On Tue, Aug 31, 2021 at 11:45:33AM +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; > + 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). > + */ Who will add the MAC entry to the MAC table in this design? The user? > + 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_STREAMDATA); > + reg &= (ANA_TABLES_STREAMDATA_SFID_VALID | ANA_TABLES_STREAMDATA_SSID_VALID); > + entry.type = (reg ? ENTRYTYPE_LOCKED : ENTRYTYPE_NORMAL); So if the STREAMDATA entry for this SFID was valid, you mark the MAC table entry as static, otherwise you mark it as ageable? Why? > + ether_addr_copy(entry.mac, stream->dmac); > + entry.vid = stream->vid; > + > + reg = ocelot_read(ocelot, ANA_TABLES_MACACCESS); > + dst_idx = (reg & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3; > + > + 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, extack); > + if (ret) { > + kfree(stream_entry); > + return ret; > + } > + > + list_add_tail(&stream_entry->list, stream_list); > + > + return 0; > +} > + > +static bool 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 true; > + > + return false; > +} > + > +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 struct felix_stream_filter * > +vsc9959_psfp_sfi_table_get(struct list_head *sfi_list, u32 index) This function needs to be introduced in the patch where it is used, otherwise: https://patchwork.hopto.org/static/nipa/539543/12466413/build_32bit/stderr > +{ > + struct felix_stream_filter *tmp; > + > + list_for_each_entry(tmp, sfi_list, list) > + if (tmp->index == index) > + return tmp; > + > + return NULL; > +}
Hi Vladimir, On Tue, Aug 31, 2021 at 15:55:26AM +0800, 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; > > + 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). > > + */ > > Who will add the MAC entry to the MAC table in this design? The user? Yes, The MAC entry is always learned by hardware, user also can add it by using "bridge fdb add". > > > + 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_STREAMDATA); > > + reg &= (ANA_TABLES_STREAMDATA_SFID_VALID | > ANA_TABLES_STREAMDATA_SSID_VALID); > > + entry.type = (reg ? ENTRYTYPE_LOCKED : ENTRYTYPE_NORMAL); > > So if the STREAMDATA entry for this SFID was valid, you mark the MAC table > entry as static, otherwise you mark it as ageable? Why? If the MAC entry is learned by hardware, it's marked as ageable. When setting the PSFP filter on this stream, it needs to be set to static. For example, if the MAC table entry is not set to static, when link is down for a period of time, the MAC entry will be forgotten, and SFID information will be lost. After disable PSFP filter on the stream, there is no need to keep the MAC entry static, setting the type back to ageable can cope with network topology changes.
On Tue, Aug 31, 2021 at 08:41:36AM +0000, Xiaoliang Yang wrote: > Hi Vladimir, > > On Tue, Aug 31, 2021 at 15:55:26AM +0800, 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; > > > + 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). > > > + */ > > > > Who will add the MAC entry to the MAC table in this design? The user? > > Yes, The MAC entry is always learned by hardware, user also can add it > by using "bridge fdb add". > > > So if the STREAMDATA entry for this SFID was valid, you mark the MAC table > > entry as static, otherwise you mark it as ageable? Why? > > If the MAC entry is learned by hardware, it's marked as ageable. When > setting the PSFP filter on this stream, it needs to be set to static. > For example, if the MAC table entry is not set to static, when link is > down for a period of time, the MAC entry will be forgotten, and SFID > information will be lost. > After disable PSFP filter on the stream, there is no need to keep the > MAC entry static, setting the type back to ageable can cope with > network topology changes. > So if the MAC table entry is ageable, will the TSN stream disappear from hardware even though it is still present in tc? I think in previous versions you were automatically installing a static MAC table entry when one was not present (either it was absent, or the entry was dynamically learned). Why did that change?
On Tue, Aug 31, 2021 at 11:46:10AM +0300, Vladimir Oltean wrote: > On Tue, Aug 31, 2021 at 08:41:36AM +0000, Xiaoliang Yang wrote: > > Hi Vladimir, > > > > On Tue, Aug 31, 2021 at 15:55:26AM +0800, 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; > > > > + 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). > > > > + */ > > > > > > Who will add the MAC entry to the MAC table in this design? The user? > > > > Yes, The MAC entry is always learned by hardware, user also can add it > > by using "bridge fdb add". > > > > > So if the STREAMDATA entry for this SFID was valid, you mark the MAC table > > > entry as static, otherwise you mark it as ageable? Why? > > > > If the MAC entry is learned by hardware, it's marked as ageable. When > > setting the PSFP filter on this stream, it needs to be set to static. > > For example, if the MAC table entry is not set to static, when link is > > down for a period of time, the MAC entry will be forgotten, and SFID > > information will be lost. > > After disable PSFP filter on the stream, there is no need to keep the > > MAC entry static, setting the type back to ageable can cope with > > network topology changes. > > > > So if the MAC table entry is ageable, will the TSN stream disappear from > hardware even though it is still present in tc? Ah, ok, I was missing the context of the larger change. vsc9959_psfp_filter_del sets stream->sfid_valid = 0, then calls vsc9959_stream_table_del which calls the common vsc9959_mact_stream_set. > I think in previous versions you were automatically installing a static > MAC table entry when one was not present (either it was absent, or the > entry was dynamically learned). Why did that change? This question remains though.
On Tue, Aug 31, 2021 at 16:46:13AM +0800, 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; > > > > + 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). > > > > + */ > > > > > > Who will add the MAC entry to the MAC table in this design? The user? > > > > Yes, The MAC entry is always learned by hardware, user also can add it > > by using "bridge fdb add". > > > > > So if the STREAMDATA entry for this SFID was valid, you mark the MAC > > > table entry as static, otherwise you mark it as ageable? Why? > > > > If the MAC entry is learned by hardware, it's marked as ageable. When > > setting the PSFP filter on this stream, it needs to be set to static. > > For example, if the MAC table entry is not set to static, when link is > > down for a period of time, the MAC entry will be forgotten, and SFID > > information will be lost. > > After disable PSFP filter on the stream, there is no need to keep the > > MAC entry static, setting the type back to ageable can cope with > > network topology changes. > > > > So if the MAC table entry is ageable, will the TSN stream disappear from > hardware even though it is still present in tc? Yes, PSFP filter information on the stream will be lost in hardware. > > I think in previous versions you were automatically installing a static MAC table > entry when one was not present (either it was absent, or the entry was > dynamically learned). Why did that change? The PSFP gate and police action are set on ingress port, and " tc-filter" has no parameter to set the forward port for the filtered stream. And I also think that adding a FDB mac entry in tc-filter command is not good.
On Tue, Aug 31, 2021 at 08:59:57AM +0000, Xiaoliang Yang wrote: > > I think in previous versions you were automatically installing a static MAC table > > entry when one was not present (either it was absent, or the entry was > > dynamically learned). Why did that change? > > The PSFP gate and police action are set on ingress port, and " > tc-filter" has no parameter to set the forward port for the filtered > stream. And I also think that adding a FDB mac entry in tc-filter > command is not good. Fair enough, but if that's what you want, we'll need to think a lot harder about how this needs to be modeled. Would you not have to protect against a 'bridge fdb del' erasing your MAC table entry after you've set up the TSN stream on it? Right now, DSA does not even call the driver's .port_fdb_del method from atomic context, just from deferred work context. So even if you wanted to complain and say "cannot remove FDB entry until SFID stops pointing at it", that would not be possible with today's code structure. And what would you do if the bridge wants to delete the FDB entry irrevocably, like when the user wants to delete the bridge in its entirety? You would still remain with filters in tc which are not backed by any MAC table entry. Hmm.. Either the TSN standards for PSFP and FRER are meant to be implemented within the bridge driver itself, and not as part of tc, or the Microchip implementation is very weird for wiring them into the bridge MAC table. Microchip people, any comments?
On Tue, Aug 31, 2021 at 12:07:54PM +0300, Vladimir Oltean wrote: > On Tue, Aug 31, 2021 at 08:59:57AM +0000, Xiaoliang Yang wrote: > > > I think in previous versions you were automatically installing a static MAC table > > > entry when one was not present (either it was absent, or the entry was > > > dynamically learned). Why did that change? > > > > The PSFP gate and police action are set on ingress port, and " > > tc-filter" has no parameter to set the forward port for the filtered > > stream. And I also think that adding a FDB mac entry in tc-filter > > command is not good. > > Fair enough, but if that's what you want, we'll need to think a lot > harder about how this needs to be modeled. > > Would you not have to protect against a 'bridge fdb del' erasing your > MAC table entry after you've set up the TSN stream on it? > > Right now, DSA does not even call the driver's .port_fdb_del method from > atomic context, just from deferred work context. So even if you wanted > to complain and say "cannot remove FDB entry until SFID stops pointing > at it", that would not be possible with today's code structure. > > And what would you do if the bridge wants to delete the FDB entry > irrevocably, like when the user wants to delete the bridge in its > entirety? You would still remain with filters in tc which are not backed > by any MAC table entry. > > Hmm.. > Either the TSN standards for PSFP and FRER are meant to be implemented > within the bridge driver itself, and not as part of tc, or the Microchip > implementation is very weird for wiring them into the bridge MAC table. > > Microchip people, any comments? In sja1105's implementation of PSFP (which is not standard-compliant as it is based on TTEthernet, but makes more sense anyway), the Virtual Links (SFIDs here) are not based on the FDB table, but match only on the given source port. They behave much more like ACL entries. The way I've modeled them in Linux was to force the user to offload multiple actions for the same tc-filter, both a redirect action and a police/gate action. https://www.kernel.org/doc/html/latest/networking/dsa/sja1105.html#time-based-ingress-policing I'm not saying this helps you, I'm just saying maybe the Microchip implementation is strange, but then again, I might be looking the wrong way at it.
On Tue, Aug 31, 2021 at 17:18:00PM +0300, Vladimir Oltean wrote: > > > > I think in previous versions you were automatically installing a > > > > static MAC table entry when one was not present (either it was > > > > absent, or the entry was dynamically learned). Why did that change? > > > > > > The PSFP gate and police action are set on ingress port, and " > > > tc-filter" has no parameter to set the forward port for the filtered > > > stream. And I also think that adding a FDB mac entry in tc-filter > > > command is not good. > > > > Fair enough, but if that's what you want, we'll need to think a lot > > harder about how this needs to be modeled. > > > > Would you not have to protect against a 'bridge fdb del' erasing your > > MAC table entry after you've set up the TSN stream on it? > > > > Right now, DSA does not even call the driver's .port_fdb_del method > > from atomic context, just from deferred work context. So even if you > > wanted to complain and say "cannot remove FDB entry until SFID stops > > pointing at it", that would not be possible with today's code structure. > > > > And what would you do if the bridge wants to delete the FDB entry > > irrevocably, like when the user wants to delete the bridge in its > > entirety? You would still remain with filters in tc which are not > > backed by any MAC table entry. > > > > Hmm.. > > Either the TSN standards for PSFP and FRER are meant to be implemented > > within the bridge driver itself, and not as part of tc, or the > > Microchip implementation is very weird for wiring them into the bridge MAC > table. > > > > Microchip people, any comments? > > In sja1105's implementation of PSFP (which is not standard-compliant as it is > based on TTEthernet, but makes more sense anyway), the Virtual Links (SFIDs > here) are not based on the FDB table, but match only on the given source port. > They behave much more like ACL entries. > The way I've modeled them in Linux was to force the user to offload multiple > actions for the same tc-filter, both a redirect action and a police/gate action. > https://www.kernel.org/doc/html/latest/networking/dsa/sja1105.html#time-b > ased-ingress-policing > > I'm not saying this helps you, I'm just saying maybe the Microchip > implementation is strange, but then again, I might be looking the wrong way > at it. Yes, Using redirect action can give PSFP filter a forward port to add MAC table entry. But it also has the issue that when using "bridge fdb del" to delete the MAC entry will cause the tc-filter rule not working.
On Tue, Aug 31, 2021 at 09:59:11AM +0000, Xiaoliang Yang wrote: > On Tue, Aug 31, 2021 at 17:18:00PM +0300, Vladimir Oltean wrote: > > > > > I think in previous versions you were automatically installing a > > > > > static MAC table entry when one was not present (either it was > > > > > absent, or the entry was dynamically learned). Why did that change? > > > > > > > > The PSFP gate and police action are set on ingress port, and " > > > > tc-filter" has no parameter to set the forward port for the filtered > > > > stream. And I also think that adding a FDB mac entry in tc-filter > > > > command is not good. > > > > > > Fair enough, but if that's what you want, we'll need to think a lot > > > harder about how this needs to be modeled. > > > > > > Would you not have to protect against a 'bridge fdb del' erasing your > > > MAC table entry after you've set up the TSN stream on it? > > > > > > Right now, DSA does not even call the driver's .port_fdb_del method > > > from atomic context, just from deferred work context. So even if you > > > wanted to complain and say "cannot remove FDB entry until SFID stops > > > pointing at it", that would not be possible with today's code structure. > > > > > > And what would you do if the bridge wants to delete the FDB entry > > > irrevocably, like when the user wants to delete the bridge in its > > > entirety? You would still remain with filters in tc which are not > > > backed by any MAC table entry. > > > > > > Hmm.. > > > Either the TSN standards for PSFP and FRER are meant to be implemented > > > within the bridge driver itself, and not as part of tc, or the > > > Microchip implementation is very weird for wiring them into the bridge MAC > > table. > > > > > > Microchip people, any comments? > > > > In sja1105's implementation of PSFP (which is not standard-compliant as it is > > based on TTEthernet, but makes more sense anyway), the Virtual Links (SFIDs > > here) are not based on the FDB table, but match only on the given source port. > > They behave much more like ACL entries. > > The way I've modeled them in Linux was to force the user to offload multiple > > actions for the same tc-filter, both a redirect action and a police/gate action. > > https://www.kernel.org/doc/html/latest/networking/dsa/sja1105.html#time-b > > ased-ingress-policing > > > > I'm not saying this helps you, I'm just saying maybe the Microchip > > implementation is strange, but then again, I might be looking the wrong way > > at it. > > Yes, Using redirect action can give PSFP filter a forward port to add > MAC table entry. But it also has the issue that when using "bridge fdb > del" to delete the MAC entry will cause the tc-filter rule not > working. We need to define the expected behavior. As far as the 802.1Q-2018 spec is concerned, there is no logical dependency between the FDB lookup and the PSFP streams. But there seems to be no explicit text that forbids it either, though. If you install a tc-redirect rule and offload it as a bridge FDB entry, it needs to behave like a tc-redirect rule and not a bridge FDB entry. So it only needs to match on the intended source port. I don't believe that is possible. If it is, let's do that. To me, putting PSFP inside the bridge driver is completely outside of the question. There is no evidence that it belongs there, and there are switch implementations from other vendors where the FDB lookup process is completely independent from the Qci stream identification process. Anyway, this strategy of combining the two could only work for the NULL stream identifiers in the first place (MAC DA + VLAN ID), not for the others (IP Stream identification etc etc). So what remains, if nothing else is possible, is to require the user to manage the bridge FDB entries, and make sure that the kernel side is sane, and does not remain with broken data structures. That is going to be a PITA both for the user and for the kernel side, because we are going to make the tc-flower filters effectively depend upon the bridge state. Let's wait for some feedback from Microchip engineers, how they envisioned this to be integrated with operating systems.
On Tue, Aug 31, 2021 at 18:49:53PM +0300, Vladimir Oltean wrote > On Tue, Aug 31, 2021 at 09:59:11AM +0000, Xiaoliang Yang wrote: > > On Tue, Aug 31, 2021 at 17:18:00PM +0300, Vladimir Oltean wrote: > > > > > > I think in previous versions you were automatically installing > > > > > > a static MAC table entry when one was not present (either it > > > > > > was absent, or the entry was dynamically learned). Why did that > change? > > > > > > > > > > The PSFP gate and police action are set on ingress port, and " > > > > > tc-filter" has no parameter to set the forward port for the > > > > > filtered stream. And I also think that adding a FDB mac entry in > > > > > tc-filter command is not good. > > > > > > > > Fair enough, but if that's what you want, we'll need to think a > > > > lot harder about how this needs to be modeled. > > > > > > > > Would you not have to protect against a 'bridge fdb del' erasing > > > > your MAC table entry after you've set up the TSN stream on it? > > > > > > > > Right now, DSA does not even call the driver's .port_fdb_del > > > > method from atomic context, just from deferred work context. So > > > > even if you wanted to complain and say "cannot remove FDB entry > > > > until SFID stops pointing at it", that would not be possible with today's > code structure. > > > > > > > > And what would you do if the bridge wants to delete the FDB entry > > > > irrevocably, like when the user wants to delete the bridge in its > > > > entirety? You would still remain with filters in tc which are not > > > > backed by any MAC table entry. > > > > > > > > Hmm.. > > > > Either the TSN standards for PSFP and FRER are meant to be > > > > implemented within the bridge driver itself, and not as part of > > > > tc, or the Microchip implementation is very weird for wiring them > > > > into the bridge MAC > > > table. > > > > > > > > Microchip people, any comments? > > > > > > In sja1105's implementation of PSFP (which is not standard-compliant > > > as it is based on TTEthernet, but makes more sense anyway), the > > > Virtual Links (SFIDs > > > here) are not based on the FDB table, but match only on the given source > port. > > > They behave much more like ACL entries. > > > The way I've modeled them in Linux was to force the user to offload > > > multiple actions for the same tc-filter, both a redirect action and a > police/gate action. > > > https://www.kernel.org/doc/html/latest/networking/dsa/sja1105.html#t > > > ime-b > > > ased-ingress-policing > > > > > > I'm not saying this helps you, I'm just saying maybe the Microchip > > > implementation is strange, but then again, I might be looking the > > > wrong way at it. > > > > Yes, Using redirect action can give PSFP filter a forward port to add > > MAC table entry. But it also has the issue that when using "bridge fdb > > del" to delete the MAC entry will cause the tc-filter rule not > > working. > > We need to define the expected behavior. > > As far as the 802.1Q-2018 spec is concerned, there is no logical dependency > between the FDB lookup and the PSFP streams. But there seems to be no > explicit text that forbids it either, though. > > If you install a tc-redirect rule and offload it as a bridge FDB entry, it needs to > behave like a tc-redirect rule and not a bridge FDB entry. > So it only needs to match on the intended source port. I don't believe that is > possible. If it is, let's do that. > > To me, putting PSFP inside the bridge driver is completely outside of the > question. There is no evidence that it belongs there, and there are switch > implementations from other vendors where the FDB lookup process is > completely independent from the Qci stream identification process. > Anyway, this strategy of combining the two could only work for the NULL > stream identifiers in the first place (MAC DA + VLAN ID), not for the others (IP > Stream identification etc etc). > > So what remains, if nothing else is possible, is to require the user to manage > the bridge FDB entries, and make sure that the kernel side is sane, and does > not remain with broken data structures. That is going to be a PITA both for the > user and for the kernel side, because we are going to make the tc-flower filters > effectively depend upon the bridge state. > > Let's wait for some feedback from Microchip engineers, how they envisioned > this to be integrated with operating systems. Yes, Since the PSFP hardware module relies on the MAC table, this requires the User to manage bridge FDB entries to ensure PSFP works. Only set PSFP on the existing MAC table entries to ensure consistency. Any comments from Microchip engineers?
On Tue, 2021-08-31 at 10:49 +0000, Vladimir Oltean wrote: > On Tue, Aug 31, 2021 at 09:59:11AM +0000, Xiaoliang Yang wrote: > > On Tue, Aug 31, 2021 at 17:18:00PM +0300, Vladimir Oltean wrote: > > > > > > I think in previous versions you were automatically > > > > > > installing a > > > > > > static MAC table entry when one was not present (either it > > > > > > was > > > > > > absent, or the entry was dynamically learned). Why did that > > > > > > change? > > > > > > > > > > The PSFP gate and police action are set on ingress port, and > > > > > " > > > > > tc-filter" has no parameter to set the forward port for the > > > > > filtered > > > > > stream. And I also think that adding a FDB mac entry in tc- > > > > > filter > > > > > command is not good. > > > > > > > > Fair enough, but if that's what you want, we'll need to think a > > > > lot > > > > harder about how this needs to be modeled. > > > > > > > > Would you not have to protect against a 'bridge fdb del' > > > > erasing your > > > > MAC table entry after you've set up the TSN stream on it? > > > > > > > > Right now, DSA does not even call the driver's .port_fdb_del > > > > method > > > > from atomic context, just from deferred work context. So even > > > > if you > > > > wanted to complain and say "cannot remove FDB entry until SFID > > > > stops > > > > pointing at it", that would not be possible with today's code > > > > structure. > > > > > > > > And what would you do if the bridge wants to delete the FDB > > > > entry > > > > irrevocably, like when the user wants to delete the bridge in > > > > its > > > > entirety? You would still remain with filters in tc which are > > > > not > > > > backed by any MAC table entry. > > > > > > > > Hmm.. > > > > Either the TSN standards for PSFP and FRER are meant to be > > > > implemented > > > > within the bridge driver itself, and not as part of tc, or the > > > > Microchip implementation is very weird for wiring them into the > > > > bridge MAC > > > table. > > > > Microchip people, any comments? > > > > > > In sja1105's implementation of PSFP (which is not standard- > > > compliant as it is > > > based on TTEthernet, but makes more sense anyway), the Virtual > > > Links (SFIDs > > > here) are not based on the FDB table, but match only on the given > > > source port. > > > They behave much more like ACL entries. > > > The way I've modeled them in Linux was to force the user to > > > offload multiple > > > actions for the same tc-filter, both a redirect action and a > > > police/gate action. > > > https://www.kernel.org/doc/html/latest/networking/dsa/sja1105.html#time-b > > > ased-ingress-policing > > > > > > I'm not saying this helps you, I'm just saying maybe the > > > Microchip > > > implementation is strange, but then again, I might be looking the > > > wrong way > > > at it. > > > > Yes, Using redirect action can give PSFP filter a forward port to > > add > > MAC table entry. But it also has the issue that when using "bridge > > fdb > > del" to delete the MAC entry will cause the tc-filter rule not > > working. > > We need to define the expected behavior. > > As far as the 802.1Q-2018 spec is concerned, there is no logical > dependency between the FDB lookup and the PSFP streams. But there > seems > to be no explicit text that forbids it either, though. > > If you install a tc-redirect rule and offload it as a bridge FDB > entry, > it needs to behave like a tc-redirect rule and not a bridge FDB > entry. > So it only needs to match on the intended source port. I don't > believe > that is possible. If it is, let's do that. > > To me, putting PSFP inside the bridge driver is completely outside of > the question. There is no evidence that it belongs there, and there > are > switch implementations from other vendors where the FDB lookup > process > is completely independent from the Qci stream identification process. > Anyway, this strategy of combining the two could only work for the > NULL > stream identifiers in the first place (MAC DA + VLAN ID), not for the > others (IP Stream identification etc etc). > > So what remains, if nothing else is possible, is to require the user > to > manage the bridge FDB entries, and make sure that the kernel side is > sane, and does not remain with broken data structures. That is going > to > be a PITA both for the user and for the kernel side, because we are > going to make the tc-flower filters effectively depend upon the > bridge > state. > > Let's wait for some feedback from Microchip engineers, how they > envisioned this to be integrated with operating systems. We at Microchip agrees that it is a difficult task to map the PSFP implementation in Felix to the “tc flower” filter command, but please remember that Ocelot and its derivatives were designed long before the 802.1Qci standard was ratified and also before anyone has considered how to control it in Linux. We think that the best approach is to require the user to manage bridge FDB entries manually as suggested by Xiaoliang. Our newer PSFP designs uses the TCAM instead of the MAC table which maps a lot better to the “tc flower” filter command.
On Thu, Sep 09, 2021 at 01:33:57PM +0200, Joergen Andreasen wrote: > > > Yes, Using redirect action can give PSFP filter a forward port to > > > add > > > MAC table entry. But it also has the issue that when using "bridge > > > fdb > > > del" to delete the MAC entry will cause the tc-filter rule not > > > working. > > > > We need to define the expected behavior. > > > > As far as the 802.1Q-2018 spec is concerned, there is no logical > > dependency between the FDB lookup and the PSFP streams. But there > > seems > > to be no explicit text that forbids it either, though. > > > > If you install a tc-redirect rule and offload it as a bridge FDB > > entry, > > it needs to behave like a tc-redirect rule and not a bridge FDB > > entry. > > So it only needs to match on the intended source port. I don't > > believe > > that is possible. If it is, let's do that. > > > > To me, putting PSFP inside the bridge driver is completely outside of > > the question. There is no evidence that it belongs there, and there > > are > > switch implementations from other vendors where the FDB lookup > > process > > is completely independent from the Qci stream identification process. > > Anyway, this strategy of combining the two could only work for the > > NULL > > stream identifiers in the first place (MAC DA + VLAN ID), not for the > > others (IP Stream identification etc etc). > > > > So what remains, if nothing else is possible, is to require the user > > to > > manage the bridge FDB entries, and make sure that the kernel side is > > sane, and does not remain with broken data structures. That is going > > to > > be a PITA both for the user and for the kernel side, because we are > > going to make the tc-flower filters effectively depend upon the > > bridge > > state. > > > > Let's wait for some feedback from Microchip engineers, how they > > envisioned this to be integrated with operating systems. > > We at Microchip agrees that it is a difficult task to map the PSFP > implementation in Felix to the “tc flower” filter command, but please > remember that Ocelot and its derivatives were designed long before > the 802.1Qci standard was ratified and also before anyone has > considered how to control it in Linux. > > We think that the best approach is to require the user to manage > bridge FDB entries manually as suggested by Xiaoliang. > > Our newer PSFP designs uses the TCAM instead of the MAC table > which maps a lot better to the “tc flower” filter command. Well, that's even more unfortunate, because as explained by Ido here: https://lore.kernel.org/netdev/YSHzLKpixhCrrgJ0@shredder/ the return code from SWITCHDEV_FDB_{ADD,DEL}_TO_DEVICE event handlers is not propagated to br_switchdev_fdb_notify. So in effect, the device driver cannot stop the bridge from removing an FDB entry which would lead it to having a broken tc filter. Now, the ocelot switchdev driver uses the bridge bypass .ndo_fdb_add and .ndo_fdb_del, while DSA actually listens for switchdev events on the atomic call chain. So any solution needs to work with switchdev, not just with the bridge bypass ops.
diff --git a/drivers/net/dsa/ocelot/felix_vsc9959.c b/drivers/net/dsa/ocelot/felix_vsc9959.c index f966a253d1c7..3dbc4e991748 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,449 @@ 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; +}; + +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; + 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_STREAMDATA); + reg &= (ANA_TABLES_STREAMDATA_SFID_VALID | ANA_TABLES_STREAMDATA_SSID_VALID); + entry.type = (reg ? ENTRYTYPE_LOCKED : ENTRYTYPE_NORMAL); + ether_addr_copy(entry.mac, stream->dmac); + entry.vid = stream->vid; + + reg = ocelot_read(ocelot, ANA_TABLES_MACACCESS); + dst_idx = (reg & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3; + + 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, extack); + if (ret) { + kfree(stream_entry); + return ret; + } + + list_add_tail(&stream_entry->list, stream_list); + + return 0; +} + +static bool 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 true; + + return false; +} + +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 struct felix_stream_filter * +vsc9959_psfp_sfi_table_get(struct list_head *sfi_list, u32 index) +{ + struct felix_stream_filter *tmp; + + list_for_each_entry(tmp, sfi_list, list) + if (tmp->index == index) + return tmp; + + return NULL; +} + +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 = {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. */ + ret = vsc9959_stream_table_lookup(&psfp->stream_list, &stream); + if (ret) { + 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 | 455 ++++++++++++++++++++++++- include/soc/mscc/ocelot.h | 8 + include/soc/mscc/ocelot_ana.h | 10 + 3 files changed, 463 insertions(+), 10 deletions(-)