1 // SPDX-License-Identifier: GPL-2.0+
2 
3 #include <linux/module.h>
4 #include <linux/if_bridge.h>
5 #include <linux/if_vlan.h>
6 #include <linux/iopoll.h>
7 #include <linux/ip.h>
8 #include <linux/of_platform.h>
9 #include <linux/of_net.h>
10 #include <linux/packing.h>
11 #include <linux/phy/phy.h>
12 #include <linux/reset.h>
13 #include <net/addrconf.h>
14 
15 #include "lan966x_main.h"
16 
17 #define XTR_EOF_0			0x00000080U
18 #define XTR_EOF_1			0x01000080U
19 #define XTR_EOF_2			0x02000080U
20 #define XTR_EOF_3			0x03000080U
21 #define XTR_PRUNED			0x04000080U
22 #define XTR_ABORT			0x05000080U
23 #define XTR_ESCAPE			0x06000080U
24 #define XTR_NOT_READY			0x07000080U
25 #define XTR_VALID_BYTES(x)		(4 - (((x) >> 24) & 3))
26 
27 #define IO_RANGES 2
28 
29 static const struct of_device_id lan966x_match[] = {
30 	{ .compatible = "microchip,lan966x-switch" },
31 	{ }
32 };
33 MODULE_DEVICE_TABLE(of, lan966x_match);
34 
35 struct lan966x_main_io_resource {
36 	enum lan966x_target id;
37 	phys_addr_t offset;
38 	int range;
39 };
40 
41 static const struct lan966x_main_io_resource lan966x_main_iomap[] =  {
42 	{ TARGET_CPU,                   0xc0000, 0 }, /* 0xe00c0000 */
43 	{ TARGET_FDMA,                  0xc0400, 0 }, /* 0xe00c0400 */
44 	{ TARGET_ORG,                         0, 1 }, /* 0xe2000000 */
45 	{ TARGET_GCB,                    0x4000, 1 }, /* 0xe2004000 */
46 	{ TARGET_QS,                     0x8000, 1 }, /* 0xe2008000 */
47 	{ TARGET_PTP,                    0xc000, 1 }, /* 0xe200c000 */
48 	{ TARGET_CHIP_TOP,              0x10000, 1 }, /* 0xe2010000 */
49 	{ TARGET_REW,                   0x14000, 1 }, /* 0xe2014000 */
50 	{ TARGET_VCAP,                  0x18000, 1 }, /* 0xe2018000 */
51 	{ TARGET_VCAP + 1,              0x20000, 1 }, /* 0xe2020000 */
52 	{ TARGET_VCAP + 2,              0x24000, 1 }, /* 0xe2024000 */
53 	{ TARGET_SYS,                   0x28000, 1 }, /* 0xe2028000 */
54 	{ TARGET_DEV,                   0x34000, 1 }, /* 0xe2034000 */
55 	{ TARGET_DEV +  1,              0x38000, 1 }, /* 0xe2038000 */
56 	{ TARGET_DEV +  2,              0x3c000, 1 }, /* 0xe203c000 */
57 	{ TARGET_DEV +  3,              0x40000, 1 }, /* 0xe2040000 */
58 	{ TARGET_DEV +  4,              0x44000, 1 }, /* 0xe2044000 */
59 	{ TARGET_DEV +  5,              0x48000, 1 }, /* 0xe2048000 */
60 	{ TARGET_DEV +  6,              0x4c000, 1 }, /* 0xe204c000 */
61 	{ TARGET_DEV +  7,              0x50000, 1 }, /* 0xe2050000 */
62 	{ TARGET_QSYS,                 0x100000, 1 }, /* 0xe2100000 */
63 	{ TARGET_AFI,                  0x120000, 1 }, /* 0xe2120000 */
64 	{ TARGET_ANA,                  0x140000, 1 }, /* 0xe2140000 */
65 };
66 
67 static int lan966x_create_targets(struct platform_device *pdev,
68 				  struct lan966x *lan966x)
69 {
70 	struct resource *iores[IO_RANGES];
71 	void __iomem *begin[IO_RANGES];
72 	int idx;
73 
74 	/* Initially map the entire range and after that update each target to
75 	 * point inside the region at the correct offset. It is possible that
76 	 * other devices access the same region so don't add any checks about
77 	 * this.
78 	 */
79 	for (idx = 0; idx < IO_RANGES; idx++) {
80 		iores[idx] = platform_get_resource(pdev, IORESOURCE_MEM,
81 						   idx);
82 		if (!iores[idx]) {
83 			dev_err(&pdev->dev, "Invalid resource\n");
84 			return -EINVAL;
85 		}
86 
87 		begin[idx] = devm_ioremap(&pdev->dev,
88 					  iores[idx]->start,
89 					  resource_size(iores[idx]));
90 		if (!begin[idx]) {
91 			dev_err(&pdev->dev, "Unable to get registers: %s\n",
92 				iores[idx]->name);
93 			return -ENOMEM;
94 		}
95 	}
96 
97 	for (idx = 0; idx < ARRAY_SIZE(lan966x_main_iomap); idx++) {
98 		const struct lan966x_main_io_resource *iomap =
99 			&lan966x_main_iomap[idx];
100 
101 		lan966x->regs[iomap->id] = begin[iomap->range] + iomap->offset;
102 	}
103 
104 	return 0;
105 }
106 
107 static bool lan966x_port_unique_address(struct net_device *dev)
108 {
109 	struct lan966x_port *port = netdev_priv(dev);
110 	struct lan966x *lan966x = port->lan966x;
111 	int p;
112 
113 	for (p = 0; p < lan966x->num_phys_ports; ++p) {
114 		port = lan966x->ports[p];
115 		if (!port || port->dev == dev)
116 			continue;
117 
118 		if (ether_addr_equal(dev->dev_addr, port->dev->dev_addr))
119 			return false;
120 	}
121 
122 	return true;
123 }
124 
125 static int lan966x_port_set_mac_address(struct net_device *dev, void *p)
126 {
127 	struct lan966x_port *port = netdev_priv(dev);
128 	struct lan966x *lan966x = port->lan966x;
129 	const struct sockaddr *addr = p;
130 	int ret;
131 
132 	if (ether_addr_equal(addr->sa_data, dev->dev_addr))
133 		return 0;
134 
135 	/* Learn the new net device MAC address in the mac table. */
136 	ret = lan966x_mac_cpu_learn(lan966x, addr->sa_data, HOST_PVID);
137 	if (ret)
138 		return ret;
139 
140 	/* If there is another port with the same address as the dev, then don't
141 	 * delete it from the MAC table
142 	 */
143 	if (!lan966x_port_unique_address(dev))
144 		goto out;
145 
146 	/* Then forget the previous one. */
147 	ret = lan966x_mac_cpu_forget(lan966x, dev->dev_addr, HOST_PVID);
148 	if (ret)
149 		return ret;
150 
151 out:
152 	eth_hw_addr_set(dev, addr->sa_data);
153 	return ret;
154 }
155 
156 static int lan966x_port_get_phys_port_name(struct net_device *dev,
157 					   char *buf, size_t len)
158 {
159 	struct lan966x_port *port = netdev_priv(dev);
160 	int ret;
161 
162 	ret = snprintf(buf, len, "p%d", port->chip_port);
163 	if (ret >= len)
164 		return -EINVAL;
165 
166 	return 0;
167 }
168 
169 static int lan966x_port_open(struct net_device *dev)
170 {
171 	struct lan966x_port *port = netdev_priv(dev);
172 	struct lan966x *lan966x = port->lan966x;
173 	int err;
174 
175 	/* Enable receiving frames on the port, and activate auto-learning of
176 	 * MAC addresses.
177 	 */
178 	lan_rmw(ANA_PORT_CFG_LEARNAUTO_SET(1) |
179 		ANA_PORT_CFG_RECV_ENA_SET(1) |
180 		ANA_PORT_CFG_PORTID_VAL_SET(port->chip_port),
181 		ANA_PORT_CFG_LEARNAUTO |
182 		ANA_PORT_CFG_RECV_ENA |
183 		ANA_PORT_CFG_PORTID_VAL,
184 		lan966x, ANA_PORT_CFG(port->chip_port));
185 
186 	err = phylink_fwnode_phy_connect(port->phylink, port->fwnode, 0);
187 	if (err) {
188 		netdev_err(dev, "Could not attach to PHY\n");
189 		return err;
190 	}
191 
192 	phylink_start(port->phylink);
193 
194 	return 0;
195 }
196 
197 static int lan966x_port_stop(struct net_device *dev)
198 {
199 	struct lan966x_port *port = netdev_priv(dev);
200 
201 	lan966x_port_config_down(port);
202 	phylink_stop(port->phylink);
203 	phylink_disconnect_phy(port->phylink);
204 
205 	return 0;
206 }
207 
208 static int lan966x_port_inj_status(struct lan966x *lan966x)
209 {
210 	return lan_rd(lan966x, QS_INJ_STATUS);
211 }
212 
213 static int lan966x_port_inj_ready(struct lan966x *lan966x, u8 grp)
214 {
215 	u32 val;
216 
217 	if (lan_rd(lan966x, QS_INJ_STATUS) & QS_INJ_STATUS_FIFO_RDY_SET(BIT(grp)))
218 		return 0;
219 
220 	return readx_poll_timeout_atomic(lan966x_port_inj_status, lan966x, val,
221 					 QS_INJ_STATUS_FIFO_RDY_GET(val) & BIT(grp),
222 					 READL_SLEEP_US, READL_TIMEOUT_US);
223 }
224 
225 static int lan966x_port_ifh_xmit(struct sk_buff *skb,
226 				 __be32 *ifh,
227 				 struct net_device *dev)
228 {
229 	struct lan966x_port *port = netdev_priv(dev);
230 	struct lan966x *lan966x = port->lan966x;
231 	u32 i, count, last;
232 	u8 grp = 0;
233 	u32 val;
234 	int err;
235 
236 	val = lan_rd(lan966x, QS_INJ_STATUS);
237 	if (!(QS_INJ_STATUS_FIFO_RDY_GET(val) & BIT(grp)) ||
238 	    (QS_INJ_STATUS_WMARK_REACHED_GET(val) & BIT(grp)))
239 		goto err;
240 
241 	/* Write start of frame */
242 	lan_wr(QS_INJ_CTRL_GAP_SIZE_SET(1) |
243 	       QS_INJ_CTRL_SOF_SET(1),
244 	       lan966x, QS_INJ_CTRL(grp));
245 
246 	/* Write IFH header */
247 	for (i = 0; i < IFH_LEN; ++i) {
248 		/* Wait until the fifo is ready */
249 		err = lan966x_port_inj_ready(lan966x, grp);
250 		if (err)
251 			goto err;
252 
253 		lan_wr((__force u32)ifh[i], lan966x, QS_INJ_WR(grp));
254 	}
255 
256 	/* Write frame */
257 	count = DIV_ROUND_UP(skb->len, 4);
258 	last = skb->len % 4;
259 	for (i = 0; i < count; ++i) {
260 		/* Wait until the fifo is ready */
261 		err = lan966x_port_inj_ready(lan966x, grp);
262 		if (err)
263 			goto err;
264 
265 		lan_wr(((u32 *)skb->data)[i], lan966x, QS_INJ_WR(grp));
266 	}
267 
268 	/* Add padding */
269 	while (i < (LAN966X_BUFFER_MIN_SZ / 4)) {
270 		/* Wait until the fifo is ready */
271 		err = lan966x_port_inj_ready(lan966x, grp);
272 		if (err)
273 			goto err;
274 
275 		lan_wr(0, lan966x, QS_INJ_WR(grp));
276 		++i;
277 	}
278 
279 	/* Inidcate EOF and valid bytes in the last word */
280 	lan_wr(QS_INJ_CTRL_GAP_SIZE_SET(1) |
281 	       QS_INJ_CTRL_VLD_BYTES_SET(skb->len < LAN966X_BUFFER_MIN_SZ ?
282 				     0 : last) |
283 	       QS_INJ_CTRL_EOF_SET(1),
284 	       lan966x, QS_INJ_CTRL(grp));
285 
286 	/* Add dummy CRC */
287 	lan_wr(0, lan966x, QS_INJ_WR(grp));
288 	skb_tx_timestamp(skb);
289 
290 	dev->stats.tx_packets++;
291 	dev->stats.tx_bytes += skb->len;
292 
293 	if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
294 	    LAN966X_SKB_CB(skb)->rew_op == IFH_REW_OP_TWO_STEP_PTP)
295 		return NETDEV_TX_OK;
296 
297 	dev_consume_skb_any(skb);
298 	return NETDEV_TX_OK;
299 
300 err:
301 	if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
302 	    LAN966X_SKB_CB(skb)->rew_op == IFH_REW_OP_TWO_STEP_PTP)
303 		lan966x_ptp_txtstamp_release(port, skb);
304 
305 	return NETDEV_TX_BUSY;
306 }
307 
308 void lan966x_ifh_set_bypass(void *ifh, u64 bypass)
309 {
310 	packing(ifh, &bypass, IFH_POS_BYPASS + IFH_WID_BYPASS - 1,
311 		IFH_POS_BYPASS, IFH_LEN * 4, PACK, 0);
312 }
313 
314 void lan966x_ifh_set_port(void *ifh, u64 bypass)
315 {
316 	packing(ifh, &bypass, IFH_POS_DSTS + IFH_WID_DSTS - 1,
317 		IFH_POS_DSTS, IFH_LEN * 4, PACK, 0);
318 }
319 
320 static void lan966x_ifh_set_qos_class(void *ifh, u64 bypass)
321 {
322 	packing(ifh, &bypass, IFH_POS_QOS_CLASS + IFH_WID_QOS_CLASS - 1,
323 		IFH_POS_QOS_CLASS, IFH_LEN * 4, PACK, 0);
324 }
325 
326 static void lan966x_ifh_set_ipv(void *ifh, u64 bypass)
327 {
328 	packing(ifh, &bypass, IFH_POS_IPV + IFH_WID_IPV - 1,
329 		IFH_POS_IPV, IFH_LEN * 4, PACK, 0);
330 }
331 
332 static void lan966x_ifh_set_vid(void *ifh, u64 vid)
333 {
334 	packing(ifh, &vid, IFH_POS_TCI + IFH_WID_TCI - 1,
335 		IFH_POS_TCI, IFH_LEN * 4, PACK, 0);
336 }
337 
338 static void lan966x_ifh_set_rew_op(void *ifh, u64 rew_op)
339 {
340 	packing(ifh, &rew_op, IFH_POS_REW_CMD + IFH_WID_REW_CMD - 1,
341 		IFH_POS_REW_CMD, IFH_LEN * 4, PACK, 0);
342 }
343 
344 static void lan966x_ifh_set_timestamp(void *ifh, u64 timestamp)
345 {
346 	packing(ifh, &timestamp, IFH_POS_TIMESTAMP + IFH_WID_TIMESTAMP - 1,
347 		IFH_POS_TIMESTAMP, IFH_LEN * 4, PACK, 0);
348 }
349 
350 static netdev_tx_t lan966x_port_xmit(struct sk_buff *skb,
351 				     struct net_device *dev)
352 {
353 	struct lan966x_port *port = netdev_priv(dev);
354 	struct lan966x *lan966x = port->lan966x;
355 	__be32 ifh[IFH_LEN];
356 	int err;
357 
358 	memset(ifh, 0x0, sizeof(__be32) * IFH_LEN);
359 
360 	lan966x_ifh_set_bypass(ifh, 1);
361 	lan966x_ifh_set_port(ifh, BIT_ULL(port->chip_port));
362 	lan966x_ifh_set_qos_class(ifh, skb->priority >= 7 ? 0x7 : skb->priority);
363 	lan966x_ifh_set_ipv(ifh, skb->priority >= 7 ? 0x7 : skb->priority);
364 	lan966x_ifh_set_vid(ifh, skb_vlan_tag_get(skb));
365 
366 	if (port->lan966x->ptp && skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) {
367 		err = lan966x_ptp_txtstamp_request(port, skb);
368 		if (err)
369 			return err;
370 
371 		lan966x_ifh_set_rew_op(ifh, LAN966X_SKB_CB(skb)->rew_op);
372 		lan966x_ifh_set_timestamp(ifh, LAN966X_SKB_CB(skb)->ts_id);
373 	}
374 
375 	spin_lock(&lan966x->tx_lock);
376 	if (port->lan966x->fdma)
377 		err = lan966x_fdma_xmit(skb, ifh, dev);
378 	else
379 		err = lan966x_port_ifh_xmit(skb, ifh, dev);
380 	spin_unlock(&lan966x->tx_lock);
381 
382 	return err;
383 }
384 
385 static int lan966x_port_change_mtu(struct net_device *dev, int new_mtu)
386 {
387 	struct lan966x_port *port = netdev_priv(dev);
388 	struct lan966x *lan966x = port->lan966x;
389 	int old_mtu = dev->mtu;
390 	int err;
391 
392 	lan_wr(DEV_MAC_MAXLEN_CFG_MAX_LEN_SET(LAN966X_HW_MTU(new_mtu)),
393 	       lan966x, DEV_MAC_MAXLEN_CFG(port->chip_port));
394 	dev->mtu = new_mtu;
395 
396 	if (!lan966x->fdma)
397 		return 0;
398 
399 	err = lan966x_fdma_change_mtu(lan966x);
400 	if (err) {
401 		lan_wr(DEV_MAC_MAXLEN_CFG_MAX_LEN_SET(LAN966X_HW_MTU(old_mtu)),
402 		       lan966x, DEV_MAC_MAXLEN_CFG(port->chip_port));
403 		dev->mtu = old_mtu;
404 	}
405 
406 	return err;
407 }
408 
409 static int lan966x_mc_unsync(struct net_device *dev, const unsigned char *addr)
410 {
411 	struct lan966x_port *port = netdev_priv(dev);
412 	struct lan966x *lan966x = port->lan966x;
413 
414 	return lan966x_mac_forget(lan966x, addr, HOST_PVID, ENTRYTYPE_LOCKED);
415 }
416 
417 static int lan966x_mc_sync(struct net_device *dev, const unsigned char *addr)
418 {
419 	struct lan966x_port *port = netdev_priv(dev);
420 	struct lan966x *lan966x = port->lan966x;
421 
422 	return lan966x_mac_cpu_learn(lan966x, addr, HOST_PVID);
423 }
424 
425 static void lan966x_port_set_rx_mode(struct net_device *dev)
426 {
427 	__dev_mc_sync(dev, lan966x_mc_sync, lan966x_mc_unsync);
428 }
429 
430 static int lan966x_port_get_parent_id(struct net_device *dev,
431 				      struct netdev_phys_item_id *ppid)
432 {
433 	struct lan966x_port *port = netdev_priv(dev);
434 	struct lan966x *lan966x = port->lan966x;
435 
436 	ppid->id_len = sizeof(lan966x->base_mac);
437 	memcpy(&ppid->id, &lan966x->base_mac, ppid->id_len);
438 
439 	return 0;
440 }
441 
442 static int lan966x_port_ioctl(struct net_device *dev, struct ifreq *ifr,
443 			      int cmd)
444 {
445 	struct lan966x_port *port = netdev_priv(dev);
446 	int err;
447 
448 	if (cmd == SIOCSHWTSTAMP) {
449 		err = lan966x_ptp_setup_traps(port, ifr);
450 		if (err)
451 			return err;
452 	}
453 
454 	if (!phy_has_hwtstamp(dev->phydev) && port->lan966x->ptp) {
455 		switch (cmd) {
456 		case SIOCSHWTSTAMP:
457 			err = lan966x_ptp_hwtstamp_set(port, ifr);
458 			if (err)
459 				lan966x_ptp_del_traps(port);
460 
461 			return err;
462 		case SIOCGHWTSTAMP:
463 			return lan966x_ptp_hwtstamp_get(port, ifr);
464 		}
465 	}
466 
467 	if (!dev->phydev)
468 		return -ENODEV;
469 
470 	err = phy_mii_ioctl(dev->phydev, ifr, cmd);
471 	if (err && cmd == SIOCSHWTSTAMP)
472 		lan966x_ptp_del_traps(port);
473 
474 	return err;
475 }
476 
477 static const struct net_device_ops lan966x_port_netdev_ops = {
478 	.ndo_open			= lan966x_port_open,
479 	.ndo_stop			= lan966x_port_stop,
480 	.ndo_start_xmit			= lan966x_port_xmit,
481 	.ndo_change_mtu			= lan966x_port_change_mtu,
482 	.ndo_set_rx_mode		= lan966x_port_set_rx_mode,
483 	.ndo_get_phys_port_name		= lan966x_port_get_phys_port_name,
484 	.ndo_get_stats64		= lan966x_stats_get,
485 	.ndo_set_mac_address		= lan966x_port_set_mac_address,
486 	.ndo_get_port_parent_id		= lan966x_port_get_parent_id,
487 	.ndo_eth_ioctl			= lan966x_port_ioctl,
488 	.ndo_setup_tc			= lan966x_tc_setup,
489 	.ndo_bpf			= lan966x_xdp,
490 	.ndo_xdp_xmit			= lan966x_xdp_xmit,
491 };
492 
493 bool lan966x_netdevice_check(const struct net_device *dev)
494 {
495 	return dev->netdev_ops == &lan966x_port_netdev_ops;
496 }
497 
498 bool lan966x_hw_offload(struct lan966x *lan966x, u32 port, struct sk_buff *skb)
499 {
500 	u32 val;
501 
502 	/* The IGMP and MLD frames are not forward by the HW if
503 	 * multicast snooping is enabled, therefor don't mark as
504 	 * offload to allow the SW to forward the frames accordingly.
505 	 */
506 	val = lan_rd(lan966x, ANA_CPU_FWD_CFG(port));
507 	if (!(val & (ANA_CPU_FWD_CFG_IGMP_REDIR_ENA |
508 		     ANA_CPU_FWD_CFG_MLD_REDIR_ENA)))
509 		return true;
510 
511 	if (eth_type_vlan(skb->protocol)) {
512 		skb = skb_vlan_untag(skb);
513 		if (unlikely(!skb))
514 			return false;
515 	}
516 
517 	if (skb->protocol == htons(ETH_P_IP) &&
518 	    ip_hdr(skb)->protocol == IPPROTO_IGMP)
519 		return false;
520 
521 	if (IS_ENABLED(CONFIG_IPV6) &&
522 	    skb->protocol == htons(ETH_P_IPV6) &&
523 	    ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) &&
524 	    !ipv6_mc_check_mld(skb))
525 		return false;
526 
527 	return true;
528 }
529 
530 static int lan966x_port_xtr_status(struct lan966x *lan966x, u8 grp)
531 {
532 	return lan_rd(lan966x, QS_XTR_RD(grp));
533 }
534 
535 static int lan966x_port_xtr_ready(struct lan966x *lan966x, u8 grp)
536 {
537 	u32 val;
538 
539 	return read_poll_timeout(lan966x_port_xtr_status, val,
540 				 val != XTR_NOT_READY,
541 				 READL_SLEEP_US, READL_TIMEOUT_US, false,
542 				 lan966x, grp);
543 }
544 
545 static int lan966x_rx_frame_word(struct lan966x *lan966x, u8 grp, u32 *rval)
546 {
547 	u32 bytes_valid;
548 	u32 val;
549 	int err;
550 
551 	val = lan_rd(lan966x, QS_XTR_RD(grp));
552 	if (val == XTR_NOT_READY) {
553 		err = lan966x_port_xtr_ready(lan966x, grp);
554 		if (err)
555 			return -EIO;
556 	}
557 
558 	switch (val) {
559 	case XTR_ABORT:
560 		return -EIO;
561 	case XTR_EOF_0:
562 	case XTR_EOF_1:
563 	case XTR_EOF_2:
564 	case XTR_EOF_3:
565 	case XTR_PRUNED:
566 		bytes_valid = XTR_VALID_BYTES(val);
567 		val = lan_rd(lan966x, QS_XTR_RD(grp));
568 		if (val == XTR_ESCAPE)
569 			*rval = lan_rd(lan966x, QS_XTR_RD(grp));
570 		else
571 			*rval = val;
572 
573 		return bytes_valid;
574 	case XTR_ESCAPE:
575 		*rval = lan_rd(lan966x, QS_XTR_RD(grp));
576 
577 		return 4;
578 	default:
579 		*rval = val;
580 
581 		return 4;
582 	}
583 }
584 
585 void lan966x_ifh_get_src_port(void *ifh, u64 *src_port)
586 {
587 	packing(ifh, src_port, IFH_POS_SRCPORT + IFH_WID_SRCPORT - 1,
588 		IFH_POS_SRCPORT, IFH_LEN * 4, UNPACK, 0);
589 }
590 
591 static void lan966x_ifh_get_len(void *ifh, u64 *len)
592 {
593 	packing(ifh, len, IFH_POS_LEN + IFH_WID_LEN - 1,
594 		IFH_POS_LEN, IFH_LEN * 4, UNPACK, 0);
595 }
596 
597 void lan966x_ifh_get_timestamp(void *ifh, u64 *timestamp)
598 {
599 	packing(ifh, timestamp, IFH_POS_TIMESTAMP + IFH_WID_TIMESTAMP - 1,
600 		IFH_POS_TIMESTAMP, IFH_LEN * 4, UNPACK, 0);
601 }
602 
603 static irqreturn_t lan966x_xtr_irq_handler(int irq, void *args)
604 {
605 	struct lan966x *lan966x = args;
606 	int i, grp = 0, err = 0;
607 
608 	if (!(lan_rd(lan966x, QS_XTR_DATA_PRESENT) & BIT(grp)))
609 		return IRQ_NONE;
610 
611 	do {
612 		u64 src_port, len, timestamp;
613 		struct net_device *dev;
614 		struct sk_buff *skb;
615 		int sz = 0, buf_len;
616 		u32 ifh[IFH_LEN];
617 		u32 *buf;
618 		u32 val;
619 
620 		for (i = 0; i < IFH_LEN; i++) {
621 			err = lan966x_rx_frame_word(lan966x, grp, &ifh[i]);
622 			if (err != 4)
623 				goto recover;
624 		}
625 
626 		err = 0;
627 
628 		lan966x_ifh_get_src_port(ifh, &src_port);
629 		lan966x_ifh_get_len(ifh, &len);
630 		lan966x_ifh_get_timestamp(ifh, &timestamp);
631 
632 		WARN_ON(src_port >= lan966x->num_phys_ports);
633 
634 		dev = lan966x->ports[src_port]->dev;
635 		skb = netdev_alloc_skb(dev, len);
636 		if (unlikely(!skb)) {
637 			netdev_err(dev, "Unable to allocate sk_buff\n");
638 			err = -ENOMEM;
639 			break;
640 		}
641 		buf_len = len - ETH_FCS_LEN;
642 		buf = (u32 *)skb_put(skb, buf_len);
643 
644 		len = 0;
645 		do {
646 			sz = lan966x_rx_frame_word(lan966x, grp, &val);
647 			if (sz < 0) {
648 				kfree_skb(skb);
649 				goto recover;
650 			}
651 
652 			*buf++ = val;
653 			len += sz;
654 		} while (len < buf_len);
655 
656 		/* Read the FCS */
657 		sz = lan966x_rx_frame_word(lan966x, grp, &val);
658 		if (sz < 0) {
659 			kfree_skb(skb);
660 			goto recover;
661 		}
662 
663 		/* Update the statistics if part of the FCS was read before */
664 		len -= ETH_FCS_LEN - sz;
665 
666 		if (unlikely(dev->features & NETIF_F_RXFCS)) {
667 			buf = (u32 *)skb_put(skb, ETH_FCS_LEN);
668 			*buf = val;
669 		}
670 
671 		lan966x_ptp_rxtstamp(lan966x, skb, timestamp);
672 		skb->protocol = eth_type_trans(skb, dev);
673 
674 		if (lan966x->bridge_mask & BIT(src_port)) {
675 			skb->offload_fwd_mark = 1;
676 
677 			skb_reset_network_header(skb);
678 			if (!lan966x_hw_offload(lan966x, src_port, skb))
679 				skb->offload_fwd_mark = 0;
680 		}
681 
682 		if (!skb_defer_rx_timestamp(skb))
683 			netif_rx(skb);
684 
685 		dev->stats.rx_bytes += len;
686 		dev->stats.rx_packets++;
687 
688 recover:
689 		if (sz < 0 || err)
690 			lan_rd(lan966x, QS_XTR_RD(grp));
691 
692 	} while (lan_rd(lan966x, QS_XTR_DATA_PRESENT) & BIT(grp));
693 
694 	return IRQ_HANDLED;
695 }
696 
697 static irqreturn_t lan966x_ana_irq_handler(int irq, void *args)
698 {
699 	struct lan966x *lan966x = args;
700 
701 	return lan966x_mac_irq_handler(lan966x);
702 }
703 
704 static void lan966x_cleanup_ports(struct lan966x *lan966x)
705 {
706 	struct lan966x_port *port;
707 	int p;
708 
709 	for (p = 0; p < lan966x->num_phys_ports; p++) {
710 		port = lan966x->ports[p];
711 		if (!port)
712 			continue;
713 
714 		if (port->dev)
715 			unregister_netdev(port->dev);
716 
717 		lan966x_xdp_port_deinit(port);
718 		if (lan966x->fdma && lan966x->fdma_ndev == port->dev)
719 			lan966x_fdma_netdev_deinit(lan966x, port->dev);
720 
721 		if (port->phylink) {
722 			rtnl_lock();
723 			lan966x_port_stop(port->dev);
724 			rtnl_unlock();
725 			phylink_destroy(port->phylink);
726 			port->phylink = NULL;
727 		}
728 
729 		if (port->fwnode)
730 			fwnode_handle_put(port->fwnode);
731 	}
732 
733 	disable_irq(lan966x->xtr_irq);
734 	lan966x->xtr_irq = -ENXIO;
735 
736 	if (lan966x->ana_irq > 0) {
737 		disable_irq(lan966x->ana_irq);
738 		lan966x->ana_irq = -ENXIO;
739 	}
740 
741 	if (lan966x->fdma)
742 		devm_free_irq(lan966x->dev, lan966x->fdma_irq, lan966x);
743 
744 	if (lan966x->ptp_irq > 0)
745 		devm_free_irq(lan966x->dev, lan966x->ptp_irq, lan966x);
746 
747 	if (lan966x->ptp_ext_irq > 0)
748 		devm_free_irq(lan966x->dev, lan966x->ptp_ext_irq, lan966x);
749 }
750 
751 static int lan966x_probe_port(struct lan966x *lan966x, u32 p,
752 			      phy_interface_t phy_mode,
753 			      struct fwnode_handle *portnp)
754 {
755 	struct lan966x_port *port;
756 	struct phylink *phylink;
757 	struct net_device *dev;
758 	int err;
759 
760 	if (p >= lan966x->num_phys_ports)
761 		return -EINVAL;
762 
763 	dev = devm_alloc_etherdev_mqs(lan966x->dev,
764 				      sizeof(struct lan966x_port),
765 				      NUM_PRIO_QUEUES, 1);
766 	if (!dev)
767 		return -ENOMEM;
768 
769 	SET_NETDEV_DEV(dev, lan966x->dev);
770 	port = netdev_priv(dev);
771 	port->dev = dev;
772 	port->lan966x = lan966x;
773 	port->chip_port = p;
774 	lan966x->ports[p] = port;
775 
776 	dev->max_mtu = ETH_MAX_MTU;
777 
778 	dev->netdev_ops = &lan966x_port_netdev_ops;
779 	dev->ethtool_ops = &lan966x_ethtool_ops;
780 	dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
781 			 NETIF_F_HW_VLAN_STAG_TX |
782 			 NETIF_F_HW_TC;
783 	dev->hw_features |= NETIF_F_HW_TC;
784 	dev->needed_headroom = IFH_LEN_BYTES;
785 
786 	eth_hw_addr_gen(dev, lan966x->base_mac, p + 1);
787 
788 	lan966x_mac_learn(lan966x, PGID_CPU, dev->dev_addr, HOST_PVID,
789 			  ENTRYTYPE_LOCKED);
790 
791 	port->phylink_config.dev = &port->dev->dev;
792 	port->phylink_config.type = PHYLINK_NETDEV;
793 	port->phylink_pcs.poll = true;
794 	port->phylink_pcs.ops = &lan966x_phylink_pcs_ops;
795 
796 	port->phylink_config.mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
797 		MAC_10 | MAC_100 | MAC_1000FD | MAC_2500FD;
798 
799 	phy_interface_set_rgmii(port->phylink_config.supported_interfaces);
800 	__set_bit(PHY_INTERFACE_MODE_MII,
801 		  port->phylink_config.supported_interfaces);
802 	__set_bit(PHY_INTERFACE_MODE_GMII,
803 		  port->phylink_config.supported_interfaces);
804 	__set_bit(PHY_INTERFACE_MODE_SGMII,
805 		  port->phylink_config.supported_interfaces);
806 	__set_bit(PHY_INTERFACE_MODE_QSGMII,
807 		  port->phylink_config.supported_interfaces);
808 	__set_bit(PHY_INTERFACE_MODE_QUSGMII,
809 		  port->phylink_config.supported_interfaces);
810 	__set_bit(PHY_INTERFACE_MODE_1000BASEX,
811 		  port->phylink_config.supported_interfaces);
812 	__set_bit(PHY_INTERFACE_MODE_2500BASEX,
813 		  port->phylink_config.supported_interfaces);
814 
815 	phylink = phylink_create(&port->phylink_config,
816 				 portnp,
817 				 phy_mode,
818 				 &lan966x_phylink_mac_ops);
819 	if (IS_ERR(phylink)) {
820 		port->dev = NULL;
821 		return PTR_ERR(phylink);
822 	}
823 
824 	port->phylink = phylink;
825 
826 	err = register_netdev(dev);
827 	if (err) {
828 		dev_err(lan966x->dev, "register_netdev failed\n");
829 		return err;
830 	}
831 
832 	lan966x_vlan_port_set_vlan_aware(port, 0);
833 	lan966x_vlan_port_set_vid(port, HOST_PVID, false, false);
834 	lan966x_vlan_port_apply(port);
835 
836 	return 0;
837 }
838 
839 static void lan966x_init(struct lan966x *lan966x)
840 {
841 	u32 p, i;
842 
843 	/* MAC table initialization */
844 	lan966x_mac_init(lan966x);
845 
846 	lan966x_vlan_init(lan966x);
847 
848 	/* Flush queues */
849 	lan_wr(lan_rd(lan966x, QS_XTR_FLUSH) |
850 	       GENMASK(1, 0),
851 	       lan966x, QS_XTR_FLUSH);
852 
853 	/* Allow to drain */
854 	mdelay(1);
855 
856 	/* All Queues normal */
857 	lan_wr(lan_rd(lan966x, QS_XTR_FLUSH) &
858 	       ~(GENMASK(1, 0)),
859 	       lan966x, QS_XTR_FLUSH);
860 
861 	/* Set MAC age time to default value, the entry is aged after
862 	 * 2 * AGE_PERIOD
863 	 */
864 	lan_wr(ANA_AUTOAGE_AGE_PERIOD_SET(BR_DEFAULT_AGEING_TIME / 2 / HZ),
865 	       lan966x, ANA_AUTOAGE);
866 
867 	/* Disable learning for frames discarded by VLAN ingress filtering */
868 	lan_rmw(ANA_ADVLEARN_VLAN_CHK_SET(1),
869 		ANA_ADVLEARN_VLAN_CHK,
870 		lan966x, ANA_ADVLEARN);
871 
872 	/* Setup frame ageing - "2 sec" - The unit is 6.5 us on lan966x */
873 	lan_wr(SYS_FRM_AGING_AGE_TX_ENA_SET(1) |
874 	       (20000000 / 65),
875 	       lan966x,  SYS_FRM_AGING);
876 
877 	/* Map the 8 CPU extraction queues to CPU port */
878 	lan_wr(0, lan966x, QSYS_CPU_GROUP_MAP);
879 
880 	/* Do byte-swap and expect status after last data word
881 	 * Extraction: Mode: manual extraction) | Byte_swap
882 	 */
883 	lan_wr(QS_XTR_GRP_CFG_MODE_SET(lan966x->fdma ? 2 : 1) |
884 	       QS_XTR_GRP_CFG_BYTE_SWAP_SET(1),
885 	       lan966x, QS_XTR_GRP_CFG(0));
886 
887 	/* Injection: Mode: manual injection | Byte_swap */
888 	lan_wr(QS_INJ_GRP_CFG_MODE_SET(lan966x->fdma ? 2 : 1) |
889 	       QS_INJ_GRP_CFG_BYTE_SWAP_SET(1),
890 	       lan966x, QS_INJ_GRP_CFG(0));
891 
892 	lan_rmw(QS_INJ_CTRL_GAP_SIZE_SET(0),
893 		QS_INJ_CTRL_GAP_SIZE,
894 		lan966x, QS_INJ_CTRL(0));
895 
896 	/* Enable IFH insertion/parsing on CPU ports */
897 	lan_wr(SYS_PORT_MODE_INCL_INJ_HDR_SET(1) |
898 	       SYS_PORT_MODE_INCL_XTR_HDR_SET(1),
899 	       lan966x, SYS_PORT_MODE(CPU_PORT));
900 
901 	/* Setup flooding PGIDs */
902 	lan_wr(ANA_FLOODING_IPMC_FLD_MC4_DATA_SET(PGID_MCIPV4) |
903 	       ANA_FLOODING_IPMC_FLD_MC4_CTRL_SET(PGID_MC) |
904 	       ANA_FLOODING_IPMC_FLD_MC6_DATA_SET(PGID_MCIPV6) |
905 	       ANA_FLOODING_IPMC_FLD_MC6_CTRL_SET(PGID_MC),
906 	       lan966x, ANA_FLOODING_IPMC);
907 
908 	/* There are 8 priorities */
909 	for (i = 0; i < 8; ++i)
910 		lan_rmw(ANA_FLOODING_FLD_MULTICAST_SET(PGID_MC) |
911 			ANA_FLOODING_FLD_UNICAST_SET(PGID_UC) |
912 			ANA_FLOODING_FLD_BROADCAST_SET(PGID_BC),
913 			ANA_FLOODING_FLD_MULTICAST |
914 			ANA_FLOODING_FLD_UNICAST |
915 			ANA_FLOODING_FLD_BROADCAST,
916 			lan966x, ANA_FLOODING(i));
917 
918 	for (i = 0; i < PGID_ENTRIES; ++i)
919 		/* Set all the entries to obey VLAN_VLAN */
920 		lan_rmw(ANA_PGID_CFG_OBEY_VLAN_SET(1),
921 			ANA_PGID_CFG_OBEY_VLAN,
922 			lan966x, ANA_PGID_CFG(i));
923 
924 	for (p = 0; p < lan966x->num_phys_ports; p++) {
925 		/* Disable bridging by default */
926 		lan_rmw(ANA_PGID_PGID_SET(0x0),
927 			ANA_PGID_PGID,
928 			lan966x, ANA_PGID(p + PGID_SRC));
929 
930 		/* Do not forward BPDU frames to the front ports and copy them
931 		 * to CPU
932 		 */
933 		lan_wr(0xffff, lan966x, ANA_CPU_FWD_BPDU_CFG(p));
934 	}
935 
936 	/* Set source buffer size for each priority and each port to 1500 bytes */
937 	for (i = 0; i <= QSYS_Q_RSRV; ++i) {
938 		lan_wr(1500 / 64, lan966x, QSYS_RES_CFG(i));
939 		lan_wr(1500 / 64, lan966x, QSYS_RES_CFG(512 + i));
940 	}
941 
942 	/* Enable switching to/from cpu port */
943 	lan_wr(QSYS_SW_PORT_MODE_PORT_ENA_SET(1) |
944 	       QSYS_SW_PORT_MODE_SCH_NEXT_CFG_SET(1) |
945 	       QSYS_SW_PORT_MODE_INGRESS_DROP_MODE_SET(1),
946 	       lan966x,  QSYS_SW_PORT_MODE(CPU_PORT));
947 
948 	/* Configure and enable the CPU port */
949 	lan_rmw(ANA_PGID_PGID_SET(0),
950 		ANA_PGID_PGID,
951 		lan966x, ANA_PGID(CPU_PORT));
952 	lan_rmw(ANA_PGID_PGID_SET(BIT(CPU_PORT)),
953 		ANA_PGID_PGID,
954 		lan966x, ANA_PGID(PGID_CPU));
955 
956 	/* Multicast to all other ports */
957 	lan_rmw(GENMASK(lan966x->num_phys_ports - 1, 0),
958 		ANA_PGID_PGID,
959 		lan966x, ANA_PGID(PGID_MC));
960 
961 	/* This will be controlled by mrouter ports */
962 	lan_rmw(GENMASK(lan966x->num_phys_ports - 1, 0),
963 		ANA_PGID_PGID,
964 		lan966x, ANA_PGID(PGID_MCIPV4));
965 
966 	lan_rmw(GENMASK(lan966x->num_phys_ports - 1, 0),
967 		ANA_PGID_PGID,
968 		lan966x, ANA_PGID(PGID_MCIPV6));
969 
970 	/* Unicast to all other ports */
971 	lan_rmw(GENMASK(lan966x->num_phys_ports - 1, 0),
972 		ANA_PGID_PGID,
973 		lan966x, ANA_PGID(PGID_UC));
974 
975 	/* Broadcast to the CPU port and to other ports */
976 	lan_rmw(ANA_PGID_PGID_SET(BIT(CPU_PORT) | GENMASK(lan966x->num_phys_ports - 1, 0)),
977 		ANA_PGID_PGID,
978 		lan966x, ANA_PGID(PGID_BC));
979 
980 	lan_wr(REW_PORT_CFG_NO_REWRITE_SET(1),
981 	       lan966x, REW_PORT_CFG(CPU_PORT));
982 
983 	lan_rmw(ANA_ANAINTR_INTR_ENA_SET(1),
984 		ANA_ANAINTR_INTR_ENA,
985 		lan966x, ANA_ANAINTR);
986 
987 	spin_lock_init(&lan966x->tx_lock);
988 
989 	lan966x_taprio_init(lan966x);
990 }
991 
992 static int lan966x_ram_init(struct lan966x *lan966x)
993 {
994 	return lan_rd(lan966x, SYS_RAM_INIT);
995 }
996 
997 static int lan966x_reset_switch(struct lan966x *lan966x)
998 {
999 	struct reset_control *switch_reset;
1000 	int val = 0;
1001 	int ret;
1002 
1003 	switch_reset = devm_reset_control_get_optional_shared(lan966x->dev,
1004 							      "switch");
1005 	if (IS_ERR(switch_reset))
1006 		return dev_err_probe(lan966x->dev, PTR_ERR(switch_reset),
1007 				     "Could not obtain switch reset");
1008 
1009 	reset_control_reset(switch_reset);
1010 
1011 	lan_wr(SYS_RESET_CFG_CORE_ENA_SET(0), lan966x, SYS_RESET_CFG);
1012 	lan_wr(SYS_RAM_INIT_RAM_INIT_SET(1), lan966x, SYS_RAM_INIT);
1013 	ret = readx_poll_timeout(lan966x_ram_init, lan966x,
1014 				 val, (val & BIT(1)) == 0, READL_SLEEP_US,
1015 				 READL_TIMEOUT_US);
1016 	if (ret)
1017 		return ret;
1018 
1019 	lan_wr(SYS_RESET_CFG_CORE_ENA_SET(1), lan966x, SYS_RESET_CFG);
1020 
1021 	return 0;
1022 }
1023 
1024 static int lan966x_probe(struct platform_device *pdev)
1025 {
1026 	struct fwnode_handle *ports, *portnp;
1027 	struct lan966x *lan966x;
1028 	u8 mac_addr[ETH_ALEN];
1029 	int err;
1030 
1031 	lan966x = devm_kzalloc(&pdev->dev, sizeof(*lan966x), GFP_KERNEL);
1032 	if (!lan966x)
1033 		return -ENOMEM;
1034 
1035 	platform_set_drvdata(pdev, lan966x);
1036 	lan966x->dev = &pdev->dev;
1037 
1038 	if (!device_get_mac_address(&pdev->dev, mac_addr)) {
1039 		ether_addr_copy(lan966x->base_mac, mac_addr);
1040 	} else {
1041 		pr_info("MAC addr was not set, use random MAC\n");
1042 		eth_random_addr(lan966x->base_mac);
1043 		lan966x->base_mac[5] &= 0xf0;
1044 	}
1045 
1046 	ports = device_get_named_child_node(&pdev->dev, "ethernet-ports");
1047 	if (!ports)
1048 		return dev_err_probe(&pdev->dev, -ENODEV,
1049 				     "no ethernet-ports child found\n");
1050 
1051 	err = lan966x_create_targets(pdev, lan966x);
1052 	if (err)
1053 		return dev_err_probe(&pdev->dev, err,
1054 				     "Failed to create targets");
1055 
1056 	err = lan966x_reset_switch(lan966x);
1057 	if (err)
1058 		return dev_err_probe(&pdev->dev, err, "Reset failed");
1059 
1060 	lan966x->num_phys_ports = NUM_PHYS_PORTS;
1061 	lan966x->ports = devm_kcalloc(&pdev->dev, lan966x->num_phys_ports,
1062 				      sizeof(struct lan966x_port *),
1063 				      GFP_KERNEL);
1064 	if (!lan966x->ports)
1065 		return -ENOMEM;
1066 
1067 	/* There QS system has 32KB of memory */
1068 	lan966x->shared_queue_sz = LAN966X_BUFFER_MEMORY;
1069 
1070 	/* set irq */
1071 	lan966x->xtr_irq = platform_get_irq_byname(pdev, "xtr");
1072 	if (lan966x->xtr_irq <= 0)
1073 		return -EINVAL;
1074 
1075 	err = devm_request_threaded_irq(&pdev->dev, lan966x->xtr_irq, NULL,
1076 					lan966x_xtr_irq_handler, IRQF_ONESHOT,
1077 					"frame extraction", lan966x);
1078 	if (err) {
1079 		pr_err("Unable to use xtr irq");
1080 		return -ENODEV;
1081 	}
1082 
1083 	lan966x->ana_irq = platform_get_irq_byname(pdev, "ana");
1084 	if (lan966x->ana_irq > 0) {
1085 		err = devm_request_threaded_irq(&pdev->dev, lan966x->ana_irq, NULL,
1086 						lan966x_ana_irq_handler, IRQF_ONESHOT,
1087 						"ana irq", lan966x);
1088 		if (err)
1089 			return dev_err_probe(&pdev->dev, err, "Unable to use ana irq");
1090 	}
1091 
1092 	lan966x->ptp_irq = platform_get_irq_byname(pdev, "ptp");
1093 	if (lan966x->ptp_irq > 0) {
1094 		err = devm_request_threaded_irq(&pdev->dev, lan966x->ptp_irq, NULL,
1095 						lan966x_ptp_irq_handler, IRQF_ONESHOT,
1096 						"ptp irq", lan966x);
1097 		if (err)
1098 			return dev_err_probe(&pdev->dev, err, "Unable to use ptp irq");
1099 
1100 		lan966x->ptp = 1;
1101 	}
1102 
1103 	lan966x->fdma_irq = platform_get_irq_byname(pdev, "fdma");
1104 	if (lan966x->fdma_irq > 0) {
1105 		err = devm_request_irq(&pdev->dev, lan966x->fdma_irq,
1106 				       lan966x_fdma_irq_handler, 0,
1107 				       "fdma irq", lan966x);
1108 		if (err)
1109 			return dev_err_probe(&pdev->dev, err, "Unable to use fdma irq");
1110 
1111 		lan966x->fdma = true;
1112 	}
1113 
1114 	if (lan966x->ptp) {
1115 		lan966x->ptp_ext_irq = platform_get_irq_byname(pdev, "ptp-ext");
1116 		if (lan966x->ptp_ext_irq > 0) {
1117 			err = devm_request_threaded_irq(&pdev->dev,
1118 							lan966x->ptp_ext_irq, NULL,
1119 							lan966x_ptp_ext_irq_handler,
1120 							IRQF_ONESHOT,
1121 							"ptp-ext irq", lan966x);
1122 			if (err)
1123 				return dev_err_probe(&pdev->dev, err,
1124 						     "Unable to use ptp-ext irq");
1125 		}
1126 	}
1127 
1128 	/* init switch */
1129 	lan966x_init(lan966x);
1130 	lan966x_stats_init(lan966x);
1131 
1132 	/* go over the child nodes */
1133 	fwnode_for_each_available_child_node(ports, portnp) {
1134 		phy_interface_t phy_mode;
1135 		struct phy *serdes;
1136 		u32 p;
1137 
1138 		if (fwnode_property_read_u32(portnp, "reg", &p))
1139 			continue;
1140 
1141 		phy_mode = fwnode_get_phy_mode(portnp);
1142 		err = lan966x_probe_port(lan966x, p, phy_mode, portnp);
1143 		if (err)
1144 			goto cleanup_ports;
1145 
1146 		/* Read needed configuration */
1147 		lan966x->ports[p]->config.portmode = phy_mode;
1148 		lan966x->ports[p]->fwnode = fwnode_handle_get(portnp);
1149 
1150 		serdes = devm_of_phy_get(lan966x->dev, to_of_node(portnp), NULL);
1151 		if (PTR_ERR(serdes) == -ENODEV)
1152 			serdes = NULL;
1153 		if (IS_ERR(serdes)) {
1154 			err = PTR_ERR(serdes);
1155 			goto cleanup_ports;
1156 		}
1157 		lan966x->ports[p]->serdes = serdes;
1158 
1159 		lan966x_port_init(lan966x->ports[p]);
1160 		err = lan966x_xdp_port_init(lan966x->ports[p]);
1161 		if (err)
1162 			goto cleanup_ports;
1163 	}
1164 
1165 	lan966x_mdb_init(lan966x);
1166 	err = lan966x_fdb_init(lan966x);
1167 	if (err)
1168 		goto cleanup_ports;
1169 
1170 	err = lan966x_ptp_init(lan966x);
1171 	if (err)
1172 		goto cleanup_fdb;
1173 
1174 	err = lan966x_fdma_init(lan966x);
1175 	if (err)
1176 		goto cleanup_ptp;
1177 
1178 	err = lan966x_vcap_init(lan966x);
1179 	if (err)
1180 		goto cleanup_fdma;
1181 
1182 	return 0;
1183 
1184 cleanup_fdma:
1185 	lan966x_fdma_deinit(lan966x);
1186 
1187 cleanup_ptp:
1188 	lan966x_ptp_deinit(lan966x);
1189 
1190 cleanup_fdb:
1191 	lan966x_fdb_deinit(lan966x);
1192 
1193 cleanup_ports:
1194 	fwnode_handle_put(portnp);
1195 
1196 	lan966x_cleanup_ports(lan966x);
1197 
1198 	cancel_delayed_work_sync(&lan966x->stats_work);
1199 	destroy_workqueue(lan966x->stats_queue);
1200 	mutex_destroy(&lan966x->stats_lock);
1201 
1202 	return err;
1203 }
1204 
1205 static int lan966x_remove(struct platform_device *pdev)
1206 {
1207 	struct lan966x *lan966x = platform_get_drvdata(pdev);
1208 
1209 	lan966x_taprio_deinit(lan966x);
1210 	lan966x_vcap_deinit(lan966x);
1211 	lan966x_fdma_deinit(lan966x);
1212 	lan966x_cleanup_ports(lan966x);
1213 
1214 	cancel_delayed_work_sync(&lan966x->stats_work);
1215 	destroy_workqueue(lan966x->stats_queue);
1216 	mutex_destroy(&lan966x->stats_lock);
1217 
1218 	lan966x_mac_purge_entries(lan966x);
1219 	lan966x_mdb_deinit(lan966x);
1220 	lan966x_fdb_deinit(lan966x);
1221 	lan966x_ptp_deinit(lan966x);
1222 
1223 	return 0;
1224 }
1225 
1226 static struct platform_driver lan966x_driver = {
1227 	.probe = lan966x_probe,
1228 	.remove = lan966x_remove,
1229 	.driver = {
1230 		.name = "lan966x-switch",
1231 		.of_match_table = lan966x_match,
1232 	},
1233 };
1234 
1235 static int __init lan966x_switch_driver_init(void)
1236 {
1237 	int ret;
1238 
1239 	lan966x_register_notifier_blocks();
1240 
1241 	ret = platform_driver_register(&lan966x_driver);
1242 	if (ret)
1243 		goto err;
1244 
1245 	return 0;
1246 
1247 err:
1248 	lan966x_unregister_notifier_blocks();
1249 	return ret;
1250 }
1251 
1252 static void __exit lan966x_switch_driver_exit(void)
1253 {
1254 	platform_driver_unregister(&lan966x_driver);
1255 	lan966x_unregister_notifier_blocks();
1256 }
1257 
1258 module_init(lan966x_switch_driver_init);
1259 module_exit(lan966x_switch_driver_exit);
1260 
1261 MODULE_DESCRIPTION("Microchip LAN966X switch driver");
1262 MODULE_AUTHOR("Horatiu Vultur <horatiu.vultur@microchip.com>");
1263 MODULE_LICENSE("Dual MIT/GPL");
1264