1 // SPDX-License-Identifier: GPL-2.0+
2 /* Microchip Sparx5 Switch driver
3  *
4  * Copyright (c) 2021 Microchip Technology Inc. and its subsidiaries.
5  */
6 
7 #include "sparx5_main_regs.h"
8 #include "sparx5_main.h"
9 #include "sparx5_port.h"
10 
11 /* The IFH bit position of the first VSTAX bit. This is because the
12  * VSTAX bit positions in Data sheet is starting from zero.
13  */
14 #define VSTAX 73
15 
16 #define ifh_encode_bitfield(ifh, value, pos, _width)			\
17 	({								\
18 		u32 width = (_width);					\
19 									\
20 		/* Max width is 5 bytes - 40 bits. In worst case this will
21 		 * spread over 6 bytes - 48 bits
22 		 */							\
23 		compiletime_assert(width <= 40,				\
24 				   "Unsupported width, must be <= 40");	\
25 		__ifh_encode_bitfield((ifh), (value), (pos), width);	\
26 	})
27 
28 static void __ifh_encode_bitfield(void *ifh, u64 value, u32 pos, u32 width)
29 {
30 	u8 *ifh_hdr = ifh;
31 	/* Calculate the Start IFH byte position of this IFH bit position */
32 	u32 byte = (35 - (pos / 8));
33 	/* Calculate the Start bit position in the Start IFH byte */
34 	u32 bit  = (pos % 8);
35 	u64 encode = GENMASK_ULL(bit + width - 1, bit) & (value << bit);
36 
37 	/* The b0-b7 goes into the start IFH byte */
38 	if (encode & 0xFF)
39 		ifh_hdr[byte] |= (u8)((encode & 0xFF));
40 	/* The b8-b15 goes into the next IFH byte */
41 	if (encode & 0xFF00)
42 		ifh_hdr[byte - 1] |= (u8)((encode & 0xFF00) >> 8);
43 	/* The b16-b23 goes into the next IFH byte */
44 	if (encode & 0xFF0000)
45 		ifh_hdr[byte - 2] |= (u8)((encode & 0xFF0000) >> 16);
46 	/* The b24-b31 goes into the next IFH byte */
47 	if (encode & 0xFF000000)
48 		ifh_hdr[byte - 3] |= (u8)((encode & 0xFF000000) >> 24);
49 	/* The b32-b39 goes into the next IFH byte */
50 	if (encode & 0xFF00000000)
51 		ifh_hdr[byte - 4] |= (u8)((encode & 0xFF00000000) >> 32);
52 	/* The b40-b47 goes into the next IFH byte */
53 	if (encode & 0xFF0000000000)
54 		ifh_hdr[byte - 5] |= (u8)((encode & 0xFF0000000000) >> 40);
55 }
56 
57 static void sparx5_set_port_ifh(void *ifh_hdr, u16 portno)
58 {
59 	/* VSTAX.RSV = 1. MSBit must be 1 */
60 	ifh_encode_bitfield(ifh_hdr, 1, VSTAX + 79,  1);
61 	/* VSTAX.INGR_DROP_MODE = Enable. Don't make head-of-line blocking */
62 	ifh_encode_bitfield(ifh_hdr, 1, VSTAX + 55,  1);
63 	/* MISC.CPU_MASK/DPORT = Destination port */
64 	ifh_encode_bitfield(ifh_hdr, portno,   29, 8);
65 	/* MISC.PIPELINE_PT */
66 	ifh_encode_bitfield(ifh_hdr, 16,       37, 5);
67 	/* MISC.PIPELINE_ACT */
68 	ifh_encode_bitfield(ifh_hdr, 1,        42, 3);
69 	/* FWD.SRC_PORT = CPU */
70 	ifh_encode_bitfield(ifh_hdr, SPX5_PORT_CPU, 46, 7);
71 	/* FWD.SFLOW_ID (disable SFlow sampling) */
72 	ifh_encode_bitfield(ifh_hdr, 124,      57, 7);
73 	/* FWD.UPDATE_FCS = Enable. Enforce update of FCS. */
74 	ifh_encode_bitfield(ifh_hdr, 1,        67, 1);
75 }
76 
77 static int sparx5_port_open(struct net_device *ndev)
78 {
79 	struct sparx5_port *port = netdev_priv(ndev);
80 	int err = 0;
81 
82 	sparx5_port_enable(port, true);
83 	err = phylink_of_phy_connect(port->phylink, port->of_node, 0);
84 	if (err) {
85 		netdev_err(ndev, "Could not attach to PHY\n");
86 		return err;
87 	}
88 
89 	phylink_start(port->phylink);
90 
91 	if (!ndev->phydev) {
92 		/* power up serdes */
93 		port->conf.power_down = false;
94 		if (port->conf.serdes_reset)
95 			err = sparx5_serdes_set(port->sparx5, port, &port->conf);
96 		else
97 			err = phy_power_on(port->serdes);
98 		if (err)
99 			netdev_err(ndev, "%s failed\n", __func__);
100 	}
101 
102 	return err;
103 }
104 
105 static int sparx5_port_stop(struct net_device *ndev)
106 {
107 	struct sparx5_port *port = netdev_priv(ndev);
108 	int err = 0;
109 
110 	sparx5_port_enable(port, false);
111 	phylink_stop(port->phylink);
112 	phylink_disconnect_phy(port->phylink);
113 
114 	if (!ndev->phydev) {
115 		/* power down serdes */
116 		port->conf.power_down = true;
117 		if (port->conf.serdes_reset)
118 			err = sparx5_serdes_set(port->sparx5, port, &port->conf);
119 		else
120 			err = phy_power_off(port->serdes);
121 		if (err)
122 			netdev_err(ndev, "%s failed\n", __func__);
123 	}
124 	return 0;
125 }
126 
127 static void sparx5_set_rx_mode(struct net_device *dev)
128 {
129 	struct sparx5_port *port = netdev_priv(dev);
130 	struct sparx5 *sparx5 = port->sparx5;
131 
132 	if (!test_bit(port->portno, sparx5->bridge_mask))
133 		__dev_mc_sync(dev, sparx5_mc_sync, sparx5_mc_unsync);
134 }
135 
136 static int sparx5_port_get_phys_port_name(struct net_device *dev,
137 					  char *buf, size_t len)
138 {
139 	struct sparx5_port *port = netdev_priv(dev);
140 	int ret;
141 
142 	ret = snprintf(buf, len, "p%d", port->portno);
143 	if (ret >= len)
144 		return -EINVAL;
145 
146 	return 0;
147 }
148 
149 static int sparx5_set_mac_address(struct net_device *dev, void *p)
150 {
151 	struct sparx5_port *port = netdev_priv(dev);
152 	struct sparx5 *sparx5 = port->sparx5;
153 	const struct sockaddr *addr = p;
154 
155 	if (!is_valid_ether_addr(addr->sa_data))
156 		return -EADDRNOTAVAIL;
157 
158 	/* Remove current */
159 	sparx5_mact_forget(sparx5, dev->dev_addr,  port->pvid);
160 
161 	/* Add new */
162 	sparx5_mact_learn(sparx5, PGID_CPU, addr->sa_data, port->pvid);
163 
164 	/* Record the address */
165 	ether_addr_copy(dev->dev_addr, addr->sa_data);
166 
167 	return 0;
168 }
169 
170 static int sparx5_get_port_parent_id(struct net_device *dev,
171 				     struct netdev_phys_item_id *ppid)
172 {
173 	struct sparx5_port *sparx5_port = netdev_priv(dev);
174 	struct sparx5 *sparx5 = sparx5_port->sparx5;
175 
176 	ppid->id_len = sizeof(sparx5->base_mac);
177 	memcpy(&ppid->id, &sparx5->base_mac, ppid->id_len);
178 
179 	return 0;
180 }
181 
182 static const struct net_device_ops sparx5_port_netdev_ops = {
183 	.ndo_open               = sparx5_port_open,
184 	.ndo_stop               = sparx5_port_stop,
185 	.ndo_start_xmit         = sparx5_port_xmit_impl,
186 	.ndo_set_rx_mode        = sparx5_set_rx_mode,
187 	.ndo_get_phys_port_name = sparx5_port_get_phys_port_name,
188 	.ndo_set_mac_address    = sparx5_set_mac_address,
189 	.ndo_validate_addr      = eth_validate_addr,
190 	.ndo_get_stats64        = sparx5_get_stats64,
191 	.ndo_get_port_parent_id = sparx5_get_port_parent_id,
192 };
193 
194 bool sparx5_netdevice_check(const struct net_device *dev)
195 {
196 	return dev && (dev->netdev_ops == &sparx5_port_netdev_ops);
197 }
198 
199 struct net_device *sparx5_create_netdev(struct sparx5 *sparx5, u32 portno)
200 {
201 	struct sparx5_port *spx5_port;
202 	struct net_device *ndev;
203 	u64 val;
204 
205 	ndev = devm_alloc_etherdev(sparx5->dev, sizeof(struct sparx5_port));
206 	if (!ndev)
207 		return ERR_PTR(-ENOMEM);
208 
209 	SET_NETDEV_DEV(ndev, sparx5->dev);
210 	spx5_port = netdev_priv(ndev);
211 	spx5_port->ndev = ndev;
212 	spx5_port->sparx5 = sparx5;
213 	spx5_port->portno = portno;
214 	sparx5_set_port_ifh(spx5_port->ifh, portno);
215 
216 	ndev->netdev_ops = &sparx5_port_netdev_ops;
217 	ndev->ethtool_ops = &sparx5_ethtool_ops;
218 
219 	val = ether_addr_to_u64(sparx5->base_mac) + portno + 1;
220 	u64_to_ether_addr(val, ndev->dev_addr);
221 
222 	return ndev;
223 }
224 
225 int sparx5_register_netdevs(struct sparx5 *sparx5)
226 {
227 	int portno;
228 	int err;
229 
230 	for (portno = 0; portno < SPX5_PORTS; portno++)
231 		if (sparx5->ports[portno]) {
232 			err = register_netdev(sparx5->ports[portno]->ndev);
233 			if (err) {
234 				dev_err(sparx5->dev,
235 					"port: %02u: netdev registration failed\n",
236 					portno);
237 				return err;
238 			}
239 			sparx5_port_inj_timer_setup(sparx5->ports[portno]);
240 		}
241 	return 0;
242 }
243 
244 void sparx5_destroy_netdevs(struct sparx5 *sparx5)
245 {
246 	struct sparx5_port *port;
247 	int portno;
248 
249 	for (portno = 0; portno < SPX5_PORTS; portno++) {
250 		port = sparx5->ports[portno];
251 		if (port && port->phylink) {
252 			/* Disconnect the phy */
253 			rtnl_lock();
254 			sparx5_port_stop(port->ndev);
255 			phylink_disconnect_phy(port->phylink);
256 			rtnl_unlock();
257 			phylink_destroy(port->phylink);
258 			port->phylink = NULL;
259 		}
260 	}
261 }
262 
263 void sparx5_unregister_netdevs(struct sparx5 *sparx5)
264 {
265 	int portno;
266 
267 	for (portno = 0; portno < SPX5_PORTS; portno++)
268 		if (sparx5->ports[portno])
269 			unregister_netdev(sparx5->ports[portno]->ndev);
270 }
271 
272