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 "tag.h"
81
82 /* Protocols supported:
83 *
84 * 0x04 = RTL8365MB DSA protocol
85 */
86
87 #define RTL8_4_NAME "rtl8_4"
88 #define RTL8_4T_NAME "rtl8_4t"
89
90 #define RTL8_4_TAG_LEN 8
91
92 #define RTL8_4_PROTOCOL GENMASK(15, 8)
93 #define RTL8_4_PROTOCOL_RTL8365MB 0x04
94 #define RTL8_4_REASON GENMASK(7, 0)
95 #define RTL8_4_REASON_FORWARD 0
96 #define RTL8_4_REASON_TRAP 80
97
98 #define RTL8_4_LEARN_DIS BIT(5)
99
100 #define RTL8_4_TX GENMASK(3, 0)
101 #define RTL8_4_RX GENMASK(10, 0)
102
rtl8_4_write_tag(struct sk_buff * skb,struct net_device * dev,void * tag)103 static void rtl8_4_write_tag(struct sk_buff *skb, struct net_device *dev,
104 void *tag)
105 {
106 struct dsa_port *dp = dsa_slave_to_port(dev);
107 __be16 tag16[RTL8_4_TAG_LEN / 2];
108
109 /* Set Realtek EtherType */
110 tag16[0] = htons(ETH_P_REALTEK);
111
112 /* Set Protocol; zero REASON */
113 tag16[1] = htons(FIELD_PREP(RTL8_4_PROTOCOL, RTL8_4_PROTOCOL_RTL8365MB));
114
115 /* Zero FID_EN, FID, PRI_EN, PRI, KEEP; set LEARN_DIS */
116 tag16[2] = htons(FIELD_PREP(RTL8_4_LEARN_DIS, 1));
117
118 /* Zero ALLOW; set RX (CPU->switch) forwarding port mask */
119 tag16[3] = htons(FIELD_PREP(RTL8_4_RX, BIT(dp->index)));
120
121 memcpy(tag, tag16, RTL8_4_TAG_LEN);
122 }
123
rtl8_4_tag_xmit(struct sk_buff * skb,struct net_device * dev)124 static struct sk_buff *rtl8_4_tag_xmit(struct sk_buff *skb,
125 struct net_device *dev)
126 {
127 skb_push(skb, RTL8_4_TAG_LEN);
128
129 dsa_alloc_etype_header(skb, RTL8_4_TAG_LEN);
130
131 rtl8_4_write_tag(skb, dev, dsa_etype_header_pos_tx(skb));
132
133 return skb;
134 }
135
rtl8_4t_tag_xmit(struct sk_buff * skb,struct net_device * dev)136 static struct sk_buff *rtl8_4t_tag_xmit(struct sk_buff *skb,
137 struct net_device *dev)
138 {
139 /* Calculate the checksum here if not done yet as trailing tags will
140 * break either software or hardware based checksum
141 */
142 if (skb->ip_summed == CHECKSUM_PARTIAL && skb_checksum_help(skb))
143 return NULL;
144
145 rtl8_4_write_tag(skb, dev, skb_put(skb, RTL8_4_TAG_LEN));
146
147 return skb;
148 }
149
rtl8_4_read_tag(struct sk_buff * skb,struct net_device * dev,void * tag)150 static int rtl8_4_read_tag(struct sk_buff *skb, struct net_device *dev,
151 void *tag)
152 {
153 __be16 tag16[RTL8_4_TAG_LEN / 2];
154 u16 etype;
155 u8 reason;
156 u8 proto;
157 u8 port;
158
159 memcpy(tag16, tag, RTL8_4_TAG_LEN);
160
161 /* Parse Realtek EtherType */
162 etype = ntohs(tag16[0]);
163 if (unlikely(etype != ETH_P_REALTEK)) {
164 dev_warn_ratelimited(&dev->dev,
165 "non-realtek ethertype 0x%04x\n", etype);
166 return -EPROTO;
167 }
168
169 /* Parse Protocol */
170 proto = FIELD_GET(RTL8_4_PROTOCOL, ntohs(tag16[1]));
171 if (unlikely(proto != RTL8_4_PROTOCOL_RTL8365MB)) {
172 dev_warn_ratelimited(&dev->dev,
173 "unknown realtek protocol 0x%02x\n",
174 proto);
175 return -EPROTO;
176 }
177
178 /* Parse REASON */
179 reason = FIELD_GET(RTL8_4_REASON, ntohs(tag16[1]));
180
181 /* Parse TX (switch->CPU) */
182 port = FIELD_GET(RTL8_4_TX, ntohs(tag16[3]));
183 skb->dev = dsa_master_find_slave(dev, 0, port);
184 if (!skb->dev) {
185 dev_warn_ratelimited(&dev->dev,
186 "could not find slave for port %d\n",
187 port);
188 return -ENOENT;
189 }
190
191 if (reason != RTL8_4_REASON_TRAP)
192 dsa_default_offload_fwd_mark(skb);
193
194 return 0;
195 }
196
rtl8_4_tag_rcv(struct sk_buff * skb,struct net_device * dev)197 static struct sk_buff *rtl8_4_tag_rcv(struct sk_buff *skb,
198 struct net_device *dev)
199 {
200 if (unlikely(!pskb_may_pull(skb, RTL8_4_TAG_LEN)))
201 return NULL;
202
203 if (unlikely(rtl8_4_read_tag(skb, dev, dsa_etype_header_pos_rx(skb))))
204 return NULL;
205
206 /* Remove tag and recalculate checksum */
207 skb_pull_rcsum(skb, RTL8_4_TAG_LEN);
208
209 dsa_strip_etype_header(skb, RTL8_4_TAG_LEN);
210
211 return skb;
212 }
213
rtl8_4t_tag_rcv(struct sk_buff * skb,struct net_device * dev)214 static struct sk_buff *rtl8_4t_tag_rcv(struct sk_buff *skb,
215 struct net_device *dev)
216 {
217 if (skb_linearize(skb))
218 return NULL;
219
220 if (unlikely(rtl8_4_read_tag(skb, dev, skb_tail_pointer(skb) - RTL8_4_TAG_LEN)))
221 return NULL;
222
223 if (pskb_trim_rcsum(skb, skb->len - RTL8_4_TAG_LEN))
224 return NULL;
225
226 return skb;
227 }
228
229 /* Ethertype version */
230 static const struct dsa_device_ops rtl8_4_netdev_ops = {
231 .name = "rtl8_4",
232 .proto = DSA_TAG_PROTO_RTL8_4,
233 .xmit = rtl8_4_tag_xmit,
234 .rcv = rtl8_4_tag_rcv,
235 .needed_headroom = RTL8_4_TAG_LEN,
236 };
237
238 DSA_TAG_DRIVER(rtl8_4_netdev_ops);
239
240 MODULE_ALIAS_DSA_TAG_DRIVER(DSA_TAG_PROTO_RTL8_4, RTL8_4_NAME);
241
242 /* Tail version */
243 static const struct dsa_device_ops rtl8_4t_netdev_ops = {
244 .name = "rtl8_4t",
245 .proto = DSA_TAG_PROTO_RTL8_4T,
246 .xmit = rtl8_4t_tag_xmit,
247 .rcv = rtl8_4t_tag_rcv,
248 .needed_tailroom = RTL8_4_TAG_LEN,
249 };
250
251 DSA_TAG_DRIVER(rtl8_4t_netdev_ops);
252
253 MODULE_ALIAS_DSA_TAG_DRIVER(DSA_TAG_PROTO_RTL8_4T, RTL8_4T_NAME);
254
255 static struct dsa_tag_driver *dsa_tag_drivers[] = {
256 &DSA_TAG_DRIVER_NAME(rtl8_4_netdev_ops),
257 &DSA_TAG_DRIVER_NAME(rtl8_4t_netdev_ops),
258 };
259 module_dsa_tag_drivers(dsa_tag_drivers);
260
261 MODULE_LICENSE("GPL");
262
