Merge tag 'arm-late-6.0' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
[linux-2.6-microblaze.git] / net / dsa / tag_rtl8_4.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Handler for Realtek 8 byte switch tags
4  *
5  * Copyright (C) 2021 Alvin Šipraga <alsi@bang-olufsen.dk>
6  *
7  * NOTE: Currently only supports protocol "4" found in the RTL8365MB, hence
8  * named tag_rtl8_4.
9  *
10  * This tag has the following format:
11  *
12  *  0                                  7|8                                 15
13  *  |-----------------------------------+-----------------------------------|---
14  *  |                               (16-bit)                                | ^
15  *  |                       Realtek EtherType [0x8899]                      | |
16  *  |-----------------------------------+-----------------------------------| 8
17  *  |              (8-bit)              |              (8-bit)              |
18  *  |          Protocol [0x04]          |              REASON               | b
19  *  |-----------------------------------+-----------------------------------| y
20  *  |   (1)  | (1) | (2) |   (1)  | (3) | (1)  | (1) |    (1)    |   (5)    | t
21  *  | FID_EN |  X  | FID | PRI_EN | PRI | KEEP |  X  | LEARN_DIS |    X     | e
22  *  |-----------------------------------+-----------------------------------| s
23  *  |   (1)  |                       (15-bit)                               | |
24  *  |  ALLOW |                        TX/RX                                 | v
25  *  |-----------------------------------+-----------------------------------|---
26  *
27  * With the following field descriptions:
28  *
29  *    field      | description
30  *   ------------+-------------
31  *    Realtek    | 0x8899: indicates that this is a proprietary Realtek tag;
32  *     EtherType |         note that Realtek uses the same EtherType for
33  *               |         other incompatible tag formats (e.g. tag_rtl4_a.c)
34  *    Protocol   | 0x04: indicates that this tag conforms to this format
35  *    X          | reserved
36  *   ------------+-------------
37  *    REASON     | reason for forwarding packet to CPU
38  *               | 0: packet was forwarded or flooded to CPU
39  *               | 80: packet was trapped to CPU
40  *    FID_EN     | 1: packet has an FID
41  *               | 0: no FID
42  *    FID        | FID of packet (if FID_EN=1)
43  *    PRI_EN     | 1: force priority of packet
44  *               | 0: don't force priority
45  *    PRI        | priority of packet (if PRI_EN=1)
46  *    KEEP       | preserve packet VLAN tag format
47  *    LEARN_DIS  | don't learn the source MAC address of the packet
48  *    ALLOW      | 1: treat TX/RX field as an allowance port mask, meaning the
49  *               |    packet may only be forwarded to ports specified in the
50  *               |    mask
51  *               | 0: no allowance port mask, TX/RX field is the forwarding
52  *               |    port mask
53  *    TX/RX      | TX (switch->CPU): port number the packet was received on
54  *               | RX (CPU->switch): forwarding port mask (if ALLOW=0)
55  *               |                   allowance port mask (if ALLOW=1)
56  *
57  * The tag can be positioned before Ethertype, using tag "rtl8_4":
58  *
59  *  +--------+--------+------------+------+-----
60  *  | MAC DA | MAC SA | 8 byte tag | Type | ...
61  *  +--------+--------+------------+------+-----
62  *
63  * The tag can also appear between the end of the payload and before the CRC,
64  * using tag "rtl8_4t":
65  *
66  * +--------+--------+------+-----+---------+------------+-----+
67  * | MAC DA | MAC SA | TYPE | ... | payload | 8-byte tag | CRC |
68  * +--------+--------+------+-----+---------+------------+-----+
69  *
70  * The added bytes after the payload will break most checksums, either in
71  * software or hardware. To avoid this issue, if the checksum is still pending,
72  * this tagger checksums the packet in software before adding the tag.
73  *
74  */
75
76 #include <linux/bitfield.h>
77 #include <linux/bits.h>
78 #include <linux/etherdevice.h>
79
80 #include "dsa_priv.h"
81
82 /* Protocols supported:
83  *
84  * 0x04 = RTL8365MB DSA protocol
85  */
86
87 #define RTL8_4_TAG_LEN                  8
88
89 #define RTL8_4_PROTOCOL                 GENMASK(15, 8)
90 #define   RTL8_4_PROTOCOL_RTL8365MB     0x04
91 #define RTL8_4_REASON                   GENMASK(7, 0)
92 #define   RTL8_4_REASON_FORWARD         0
93 #define   RTL8_4_REASON_TRAP            80
94
95 #define RTL8_4_LEARN_DIS                BIT(5)
96
97 #define RTL8_4_TX                       GENMASK(3, 0)
98 #define RTL8_4_RX                       GENMASK(10, 0)
99
100 static void rtl8_4_write_tag(struct sk_buff *skb, struct net_device *dev,
101                              void *tag)
102 {
103         struct dsa_port *dp = dsa_slave_to_port(dev);
104         __be16 tag16[RTL8_4_TAG_LEN / 2];
105
106         /* Set Realtek EtherType */
107         tag16[0] = htons(ETH_P_REALTEK);
108
109         /* Set Protocol; zero REASON */
110         tag16[1] = htons(FIELD_PREP(RTL8_4_PROTOCOL, RTL8_4_PROTOCOL_RTL8365MB));
111
112         /* Zero FID_EN, FID, PRI_EN, PRI, KEEP; set LEARN_DIS */
113         tag16[2] = htons(FIELD_PREP(RTL8_4_LEARN_DIS, 1));
114
115         /* Zero ALLOW; set RX (CPU->switch) forwarding port mask */
116         tag16[3] = htons(FIELD_PREP(RTL8_4_RX, BIT(dp->index)));
117
118         memcpy(tag, tag16, RTL8_4_TAG_LEN);
119 }
120
121 static struct sk_buff *rtl8_4_tag_xmit(struct sk_buff *skb,
122                                        struct net_device *dev)
123 {
124         skb_push(skb, RTL8_4_TAG_LEN);
125
126         dsa_alloc_etype_header(skb, RTL8_4_TAG_LEN);
127
128         rtl8_4_write_tag(skb, dev, dsa_etype_header_pos_tx(skb));
129
130         return skb;
131 }
132
133 static struct sk_buff *rtl8_4t_tag_xmit(struct sk_buff *skb,
134                                         struct net_device *dev)
135 {
136         /* Calculate the checksum here if not done yet as trailing tags will
137          * break either software or hardware based checksum
138          */
139         if (skb->ip_summed == CHECKSUM_PARTIAL && skb_checksum_help(skb))
140                 return NULL;
141
142         rtl8_4_write_tag(skb, dev, skb_put(skb, RTL8_4_TAG_LEN));
143
144         return skb;
145 }
146
147 static int rtl8_4_read_tag(struct sk_buff *skb, struct net_device *dev,
148                            void *tag)
149 {
150         __be16 tag16[RTL8_4_TAG_LEN / 2];
151         u16 etype;
152         u8 reason;
153         u8 proto;
154         u8 port;
155
156         memcpy(tag16, tag, RTL8_4_TAG_LEN);
157
158         /* Parse Realtek EtherType */
159         etype = ntohs(tag16[0]);
160         if (unlikely(etype != ETH_P_REALTEK)) {
161                 dev_warn_ratelimited(&dev->dev,
162                                      "non-realtek ethertype 0x%04x\n", etype);
163                 return -EPROTO;
164         }
165
166         /* Parse Protocol */
167         proto = FIELD_GET(RTL8_4_PROTOCOL, ntohs(tag16[1]));
168         if (unlikely(proto != RTL8_4_PROTOCOL_RTL8365MB)) {
169                 dev_warn_ratelimited(&dev->dev,
170                                      "unknown realtek protocol 0x%02x\n",
171                                      proto);
172                 return -EPROTO;
173         }
174
175         /* Parse REASON */
176         reason = FIELD_GET(RTL8_4_REASON, ntohs(tag16[1]));
177
178         /* Parse TX (switch->CPU) */
179         port = FIELD_GET(RTL8_4_TX, ntohs(tag16[3]));
180         skb->dev = dsa_master_find_slave(dev, 0, port);
181         if (!skb->dev) {
182                 dev_warn_ratelimited(&dev->dev,
183                                      "could not find slave for port %d\n",
184                                      port);
185                 return -ENOENT;
186         }
187
188         if (reason != RTL8_4_REASON_TRAP)
189                 dsa_default_offload_fwd_mark(skb);
190
191         return 0;
192 }
193
194 static struct sk_buff *rtl8_4_tag_rcv(struct sk_buff *skb,
195                                       struct net_device *dev)
196 {
197         if (unlikely(!pskb_may_pull(skb, RTL8_4_TAG_LEN)))
198                 return NULL;
199
200         if (unlikely(rtl8_4_read_tag(skb, dev, dsa_etype_header_pos_rx(skb))))
201                 return NULL;
202
203         /* Remove tag and recalculate checksum */
204         skb_pull_rcsum(skb, RTL8_4_TAG_LEN);
205
206         dsa_strip_etype_header(skb, RTL8_4_TAG_LEN);
207
208         return skb;
209 }
210
211 static struct sk_buff *rtl8_4t_tag_rcv(struct sk_buff *skb,
212                                        struct net_device *dev)
213 {
214         if (skb_linearize(skb))
215                 return NULL;
216
217         if (unlikely(rtl8_4_read_tag(skb, dev, skb_tail_pointer(skb) - RTL8_4_TAG_LEN)))
218                 return NULL;
219
220         if (pskb_trim_rcsum(skb, skb->len - RTL8_4_TAG_LEN))
221                 return NULL;
222
223         return skb;
224 }
225
226 /* Ethertype version */
227 static const struct dsa_device_ops rtl8_4_netdev_ops = {
228         .name = "rtl8_4",
229         .proto = DSA_TAG_PROTO_RTL8_4,
230         .xmit = rtl8_4_tag_xmit,
231         .rcv = rtl8_4_tag_rcv,
232         .needed_headroom = RTL8_4_TAG_LEN,
233 };
234
235 DSA_TAG_DRIVER(rtl8_4_netdev_ops);
236
237 MODULE_ALIAS_DSA_TAG_DRIVER(DSA_TAG_PROTO_RTL8_4);
238
239 /* Tail version */
240 static const struct dsa_device_ops rtl8_4t_netdev_ops = {
241         .name = "rtl8_4t",
242         .proto = DSA_TAG_PROTO_RTL8_4T,
243         .xmit = rtl8_4t_tag_xmit,
244         .rcv = rtl8_4t_tag_rcv,
245         .needed_tailroom = RTL8_4_TAG_LEN,
246 };
247
248 DSA_TAG_DRIVER(rtl8_4t_netdev_ops);
249
250 MODULE_ALIAS_DSA_TAG_DRIVER(DSA_TAG_PROTO_RTL8_4T);
251
252 static struct dsa_tag_driver *dsa_tag_drivers[] = {
253         &DSA_TAG_DRIVER_NAME(rtl8_4_netdev_ops),
254         &DSA_TAG_DRIVER_NAME(rtl8_4t_netdev_ops),
255 };
256 module_dsa_tag_drivers(dsa_tag_drivers);
257
258 MODULE_LICENSE("GPL");