1 // SPDX-License-Identifier: GPL-2.0
2 /* NXP C45 PHY driver
3  * Copyright (C) 2021 NXP
4  * Author: Radu Pirea <radu-nicolae.pirea@oss.nxp.com>
5  */
6 
7 #include <linux/delay.h>
8 #include <linux/ethtool.h>
9 #include <linux/ethtool_netlink.h>
10 #include <linux/kernel.h>
11 #include <linux/mii.h>
12 #include <linux/module.h>
13 #include <linux/phy.h>
14 #include <linux/processor.h>
15 #include <linux/property.h>
16 #include <linux/ptp_classify.h>
17 #include <linux/ptp_clock_kernel.h>
18 #include <linux/net_tstamp.h>
19 
20 #define PHY_ID_TJA_1103			0x001BB010
21 
22 #define PMAPMD_B100T1_PMAPMD_CTL	0x0834
23 #define B100T1_PMAPMD_CONFIG_EN		BIT(15)
24 #define B100T1_PMAPMD_MASTER		BIT(14)
25 #define MASTER_MODE			(B100T1_PMAPMD_CONFIG_EN | \
26 					 B100T1_PMAPMD_MASTER)
27 #define SLAVE_MODE			(B100T1_PMAPMD_CONFIG_EN)
28 
29 #define VEND1_DEVICE_CONTROL		0x0040
30 #define DEVICE_CONTROL_RESET		BIT(15)
31 #define DEVICE_CONTROL_CONFIG_GLOBAL_EN	BIT(14)
32 #define DEVICE_CONTROL_CONFIG_ALL_EN	BIT(13)
33 
34 #define VEND1_PHY_IRQ_ACK		0x80A0
35 #define VEND1_PHY_IRQ_EN		0x80A1
36 #define VEND1_PHY_IRQ_STATUS		0x80A2
37 #define PHY_IRQ_LINK_EVENT		BIT(1)
38 
39 #define VEND1_PHY_CONTROL		0x8100
40 #define PHY_CONFIG_EN			BIT(14)
41 #define PHY_START_OP			BIT(0)
42 
43 #define VEND1_PHY_CONFIG		0x8108
44 #define PHY_CONFIG_AUTO			BIT(0)
45 
46 #define VEND1_SIGNAL_QUALITY		0x8320
47 #define SQI_VALID			BIT(14)
48 #define SQI_MASK			GENMASK(2, 0)
49 #define MAX_SQI				SQI_MASK
50 
51 #define VEND1_CABLE_TEST		0x8330
52 #define CABLE_TEST_ENABLE		BIT(15)
53 #define CABLE_TEST_START		BIT(14)
54 #define CABLE_TEST_VALID		BIT(13)
55 #define CABLE_TEST_OK			0x00
56 #define CABLE_TEST_SHORTED		0x01
57 #define CABLE_TEST_OPEN			0x02
58 #define CABLE_TEST_UNKNOWN		0x07
59 
60 #define VEND1_PORT_CONTROL		0x8040
61 #define PORT_CONTROL_EN			BIT(14)
62 
63 #define VEND1_PORT_ABILITIES		0x8046
64 #define PTP_ABILITY			BIT(3)
65 
66 #define VEND1_PORT_INFRA_CONTROL	0xAC00
67 #define PORT_INFRA_CONTROL_EN		BIT(14)
68 
69 #define VEND1_RXID			0xAFCC
70 #define VEND1_TXID			0xAFCD
71 #define ID_ENABLE			BIT(15)
72 
73 #define VEND1_ABILITIES			0xAFC4
74 #define RGMII_ID_ABILITY		BIT(15)
75 #define RGMII_ABILITY			BIT(14)
76 #define RMII_ABILITY			BIT(10)
77 #define REVMII_ABILITY			BIT(9)
78 #define MII_ABILITY			BIT(8)
79 #define SGMII_ABILITY			BIT(0)
80 
81 #define VEND1_MII_BASIC_CONFIG		0xAFC6
82 #define MII_BASIC_CONFIG_REV		BIT(4)
83 #define MII_BASIC_CONFIG_SGMII		0x9
84 #define MII_BASIC_CONFIG_RGMII		0x7
85 #define MII_BASIC_CONFIG_RMII		0x5
86 #define MII_BASIC_CONFIG_MII		0x4
87 
88 #define VEND1_SYMBOL_ERROR_COUNTER	0x8350
89 #define VEND1_LINK_DROP_COUNTER		0x8352
90 #define VEND1_LINK_LOSSES_AND_FAILURES	0x8353
91 #define VEND1_R_GOOD_FRAME_CNT		0xA950
92 #define VEND1_R_BAD_FRAME_CNT		0xA952
93 #define VEND1_R_RXER_FRAME_CNT		0xA954
94 #define VEND1_RX_PREAMBLE_COUNT		0xAFCE
95 #define VEND1_TX_PREAMBLE_COUNT		0xAFCF
96 #define VEND1_RX_IPG_LENGTH		0xAFD0
97 #define VEND1_TX_IPG_LENGTH		0xAFD1
98 #define COUNTER_EN			BIT(15)
99 
100 #define VEND1_PTP_CONFIG		0x1102
101 #define EXT_TRG_EDGE			BIT(1)
102 #define PPS_OUT_POL			BIT(2)
103 #define PPS_OUT_EN			BIT(3)
104 
105 #define VEND1_LTC_LOAD_CTRL		0x1105
106 #define READ_LTC			BIT(2)
107 #define LOAD_LTC			BIT(0)
108 
109 #define VEND1_LTC_WR_NSEC_0		0x1106
110 #define VEND1_LTC_WR_NSEC_1		0x1107
111 #define VEND1_LTC_WR_SEC_0		0x1108
112 #define VEND1_LTC_WR_SEC_1		0x1109
113 
114 #define VEND1_LTC_RD_NSEC_0		0x110A
115 #define VEND1_LTC_RD_NSEC_1		0x110B
116 #define VEND1_LTC_RD_SEC_0		0x110C
117 #define VEND1_LTC_RD_SEC_1		0x110D
118 
119 #define VEND1_RATE_ADJ_SUBNS_0		0x110F
120 #define VEND1_RATE_ADJ_SUBNS_1		0x1110
121 #define CLK_RATE_ADJ_LD			BIT(15)
122 #define CLK_RATE_ADJ_DIR		BIT(14)
123 
124 #define VEND1_HW_LTC_LOCK_CTRL		0x1115
125 #define HW_LTC_LOCK_EN			BIT(0)
126 
127 #define VEND1_PTP_IRQ_EN		0x1131
128 #define VEND1_PTP_IRQ_STATUS		0x1132
129 #define PTP_IRQ_EGR_TS			BIT(0)
130 
131 #define VEND1_RX_TS_INSRT_CTRL		0x114D
132 #define RX_TS_INSRT_MODE2		0x02
133 
134 #define VEND1_EGR_RING_DATA_0		0x114E
135 #define VEND1_EGR_RING_DATA_1_SEQ_ID	0x114F
136 #define VEND1_EGR_RING_DATA_2_NSEC_15_0	0x1150
137 #define VEND1_EGR_RING_DATA_3		0x1151
138 #define VEND1_EGR_RING_CTRL		0x1154
139 
140 #define VEND1_EXT_TRG_TS_DATA_0		0x1121
141 #define VEND1_EXT_TRG_TS_DATA_1		0x1122
142 #define VEND1_EXT_TRG_TS_DATA_2		0x1123
143 #define VEND1_EXT_TRG_TS_DATA_3		0x1124
144 #define VEND1_EXT_TRG_TS_DATA_4		0x1125
145 #define VEND1_EXT_TRG_TS_CTRL		0x1126
146 
147 #define RING_DATA_0_DOMAIN_NUMBER	GENMASK(7, 0)
148 #define RING_DATA_0_MSG_TYPE		GENMASK(11, 8)
149 #define RING_DATA_0_SEC_4_2		GENMASK(14, 2)
150 #define RING_DATA_0_TS_VALID		BIT(15)
151 
152 #define RING_DATA_3_NSEC_29_16		GENMASK(13, 0)
153 #define RING_DATA_3_SEC_1_0		GENMASK(15, 14)
154 #define RING_DATA_5_SEC_16_5		GENMASK(15, 4)
155 #define RING_DONE			BIT(0)
156 
157 #define TS_SEC_MASK			GENMASK(1, 0)
158 
159 #define VEND1_PORT_FUNC_ENABLES		0x8048
160 #define PTP_ENABLE			BIT(3)
161 
162 #define VEND1_PORT_PTP_CONTROL		0x9000
163 #define PORT_PTP_CONTROL_BYPASS		BIT(11)
164 
165 #define VEND1_PTP_CLK_PERIOD		0x1104
166 #define PTP_CLK_PERIOD_100BT1		15ULL
167 
168 #define VEND1_EVENT_MSG_FILT		0x1148
169 #define EVENT_MSG_FILT_ALL		0x0F
170 #define EVENT_MSG_FILT_NONE		0x00
171 
172 #define VEND1_TX_PIPE_DLY_NS		0x1149
173 #define VEND1_TX_PIPEDLY_SUBNS		0x114A
174 #define VEND1_RX_PIPE_DLY_NS		0x114B
175 #define VEND1_RX_PIPEDLY_SUBNS		0x114C
176 
177 #define VEND1_GPIO_FUNC_CONFIG_BASE	0x2C40
178 #define GPIO_FUNC_EN			BIT(15)
179 #define GPIO_FUNC_PTP			BIT(6)
180 #define GPIO_SIGNAL_PTP_TRIGGER		0x01
181 #define GPIO_SIGNAL_PPS_OUT		0x12
182 #define GPIO_DISABLE			0
183 #define GPIO_PPS_OUT_CFG		(GPIO_FUNC_EN | GPIO_FUNC_PTP | \
184 	GPIO_SIGNAL_PPS_OUT)
185 #define GPIO_EXTTS_OUT_CFG		(GPIO_FUNC_EN | GPIO_FUNC_PTP | \
186 	GPIO_SIGNAL_PTP_TRIGGER)
187 
188 #define RGMII_PERIOD_PS			8000U
189 #define PS_PER_DEGREE			div_u64(RGMII_PERIOD_PS, 360)
190 #define MIN_ID_PS			1644U
191 #define MAX_ID_PS			2260U
192 #define DEFAULT_ID_PS			2000U
193 
194 #define PPM_TO_SUBNS_INC(ppb)	div_u64(GENMASK_ULL(31, 0) * (ppb) * \
195 					PTP_CLK_PERIOD_100BT1, NSEC_PER_SEC)
196 
197 #define NXP_C45_SKB_CB(skb)	((struct nxp_c45_skb_cb *)(skb)->cb)
198 
199 struct nxp_c45_skb_cb {
200 	struct ptp_header *header;
201 	unsigned int type;
202 };
203 
204 struct nxp_c45_hwts {
205 	u32	nsec;
206 	u32	sec;
207 	u8	domain_number;
208 	u16	sequence_id;
209 	u8	msg_type;
210 };
211 
212 struct nxp_c45_phy {
213 	struct phy_device *phydev;
214 	struct mii_timestamper mii_ts;
215 	struct ptp_clock *ptp_clock;
216 	struct ptp_clock_info caps;
217 	struct sk_buff_head tx_queue;
218 	struct sk_buff_head rx_queue;
219 	/* used to access the PTP registers atomic */
220 	struct mutex ptp_lock;
221 	int hwts_tx;
222 	int hwts_rx;
223 	u32 tx_delay;
224 	u32 rx_delay;
225 	struct timespec64 extts_ts;
226 	int extts_index;
227 	bool extts;
228 };
229 
230 struct nxp_c45_phy_stats {
231 	const char	*name;
232 	u8		mmd;
233 	u16		reg;
234 	u8		off;
235 	u16		mask;
236 };
237 
238 static bool nxp_c45_poll_txts(struct phy_device *phydev)
239 {
240 	return phydev->irq <= 0;
241 }
242 
243 static int _nxp_c45_ptp_gettimex64(struct ptp_clock_info *ptp,
244 				   struct timespec64 *ts,
245 				   struct ptp_system_timestamp *sts)
246 {
247 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
248 
249 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_LOAD_CTRL,
250 		      READ_LTC);
251 	ts->tv_nsec = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
252 				   VEND1_LTC_RD_NSEC_0);
253 	ts->tv_nsec |= phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
254 				    VEND1_LTC_RD_NSEC_1) << 16;
255 	ts->tv_sec = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
256 				  VEND1_LTC_RD_SEC_0);
257 	ts->tv_sec |= phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
258 				   VEND1_LTC_RD_SEC_1) << 16;
259 
260 	return 0;
261 }
262 
263 static int nxp_c45_ptp_gettimex64(struct ptp_clock_info *ptp,
264 				  struct timespec64 *ts,
265 				  struct ptp_system_timestamp *sts)
266 {
267 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
268 
269 	mutex_lock(&priv->ptp_lock);
270 	_nxp_c45_ptp_gettimex64(ptp, ts, sts);
271 	mutex_unlock(&priv->ptp_lock);
272 
273 	return 0;
274 }
275 
276 static int _nxp_c45_ptp_settime64(struct ptp_clock_info *ptp,
277 				  const struct timespec64 *ts)
278 {
279 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
280 
281 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_WR_NSEC_0,
282 		      ts->tv_nsec);
283 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_WR_NSEC_1,
284 		      ts->tv_nsec >> 16);
285 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_WR_SEC_0,
286 		      ts->tv_sec);
287 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_WR_SEC_1,
288 		      ts->tv_sec >> 16);
289 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_LTC_LOAD_CTRL,
290 		      LOAD_LTC);
291 
292 	return 0;
293 }
294 
295 static int nxp_c45_ptp_settime64(struct ptp_clock_info *ptp,
296 				 const struct timespec64 *ts)
297 {
298 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
299 
300 	mutex_lock(&priv->ptp_lock);
301 	_nxp_c45_ptp_settime64(ptp, ts);
302 	mutex_unlock(&priv->ptp_lock);
303 
304 	return 0;
305 }
306 
307 static int nxp_c45_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
308 {
309 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
310 	s32 ppb = scaled_ppm_to_ppb(scaled_ppm);
311 	u64 subns_inc_val;
312 	bool inc;
313 
314 	mutex_lock(&priv->ptp_lock);
315 	inc = ppb >= 0;
316 	ppb = abs(ppb);
317 
318 	subns_inc_val = PPM_TO_SUBNS_INC(ppb);
319 
320 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_RATE_ADJ_SUBNS_0,
321 		      subns_inc_val);
322 	subns_inc_val >>= 16;
323 	subns_inc_val |= CLK_RATE_ADJ_LD;
324 	if (inc)
325 		subns_inc_val |= CLK_RATE_ADJ_DIR;
326 
327 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_RATE_ADJ_SUBNS_1,
328 		      subns_inc_val);
329 	mutex_unlock(&priv->ptp_lock);
330 
331 	return 0;
332 }
333 
334 static int nxp_c45_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
335 {
336 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
337 	struct timespec64 now, then;
338 
339 	mutex_lock(&priv->ptp_lock);
340 	then = ns_to_timespec64(delta);
341 	_nxp_c45_ptp_gettimex64(ptp, &now, NULL);
342 	now = timespec64_add(now, then);
343 	_nxp_c45_ptp_settime64(ptp, &now);
344 	mutex_unlock(&priv->ptp_lock);
345 
346 	return 0;
347 }
348 
349 static void nxp_c45_reconstruct_ts(struct timespec64 *ts,
350 				   struct nxp_c45_hwts *hwts)
351 {
352 	ts->tv_nsec = hwts->nsec;
353 	if ((ts->tv_sec & TS_SEC_MASK) < (hwts->sec & TS_SEC_MASK))
354 		ts->tv_sec -= TS_SEC_MASK + 1;
355 	ts->tv_sec &= ~TS_SEC_MASK;
356 	ts->tv_sec |= hwts->sec & TS_SEC_MASK;
357 }
358 
359 static bool nxp_c45_match_ts(struct ptp_header *header,
360 			     struct nxp_c45_hwts *hwts,
361 			     unsigned int type)
362 {
363 	return ntohs(header->sequence_id) == hwts->sequence_id &&
364 	       ptp_get_msgtype(header, type) == hwts->msg_type &&
365 	       header->domain_number  == hwts->domain_number;
366 }
367 
368 static void nxp_c45_get_extts(struct nxp_c45_phy *priv,
369 			      struct timespec64 *extts)
370 {
371 	extts->tv_nsec = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
372 				      VEND1_EXT_TRG_TS_DATA_0);
373 	extts->tv_nsec |= phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
374 				       VEND1_EXT_TRG_TS_DATA_1) << 16;
375 	extts->tv_sec = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
376 				     VEND1_EXT_TRG_TS_DATA_2);
377 	extts->tv_sec |= phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
378 				      VEND1_EXT_TRG_TS_DATA_3) << 16;
379 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_EXT_TRG_TS_CTRL,
380 		      RING_DONE);
381 }
382 
383 static bool nxp_c45_get_hwtxts(struct nxp_c45_phy *priv,
384 			       struct nxp_c45_hwts *hwts)
385 {
386 	bool valid;
387 	u16 reg;
388 
389 	mutex_lock(&priv->ptp_lock);
390 	phy_write_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_EGR_RING_CTRL,
391 		      RING_DONE);
392 	reg = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_EGR_RING_DATA_0);
393 	valid = !!(reg & RING_DATA_0_TS_VALID);
394 	if (!valid)
395 		goto nxp_c45_get_hwtxts_out;
396 
397 	hwts->domain_number = reg;
398 	hwts->msg_type = (reg & RING_DATA_0_MSG_TYPE) >> 8;
399 	hwts->sec = (reg & RING_DATA_0_SEC_4_2) >> 10;
400 	hwts->sequence_id = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
401 					 VEND1_EGR_RING_DATA_1_SEQ_ID);
402 	hwts->nsec = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1,
403 				  VEND1_EGR_RING_DATA_2_NSEC_15_0);
404 	reg = phy_read_mmd(priv->phydev, MDIO_MMD_VEND1, VEND1_EGR_RING_DATA_3);
405 	hwts->nsec |= (reg & RING_DATA_3_NSEC_29_16) << 16;
406 	hwts->sec |= (reg & RING_DATA_3_SEC_1_0) >> 14;
407 
408 nxp_c45_get_hwtxts_out:
409 	mutex_unlock(&priv->ptp_lock);
410 	return valid;
411 }
412 
413 static void nxp_c45_process_txts(struct nxp_c45_phy *priv,
414 				 struct nxp_c45_hwts *txts)
415 {
416 	struct sk_buff *skb, *tmp, *skb_match = NULL;
417 	struct skb_shared_hwtstamps shhwtstamps;
418 	struct timespec64 ts;
419 	unsigned long flags;
420 	bool ts_match;
421 	s64 ts_ns;
422 
423 	spin_lock_irqsave(&priv->tx_queue.lock, flags);
424 	skb_queue_walk_safe(&priv->tx_queue, skb, tmp) {
425 		ts_match = nxp_c45_match_ts(NXP_C45_SKB_CB(skb)->header, txts,
426 					    NXP_C45_SKB_CB(skb)->type);
427 		if (!ts_match)
428 			continue;
429 		skb_match = skb;
430 		__skb_unlink(skb, &priv->tx_queue);
431 		break;
432 	}
433 	spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
434 
435 	if (skb_match) {
436 		nxp_c45_ptp_gettimex64(&priv->caps, &ts, NULL);
437 		nxp_c45_reconstruct_ts(&ts, txts);
438 		memset(&shhwtstamps, 0, sizeof(shhwtstamps));
439 		ts_ns = timespec64_to_ns(&ts);
440 		shhwtstamps.hwtstamp = ns_to_ktime(ts_ns);
441 		skb_complete_tx_timestamp(skb_match, &shhwtstamps);
442 	} else {
443 		phydev_warn(priv->phydev,
444 			    "the tx timestamp doesn't match with any skb\n");
445 	}
446 }
447 
448 static long nxp_c45_do_aux_work(struct ptp_clock_info *ptp)
449 {
450 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
451 	bool poll_txts = nxp_c45_poll_txts(priv->phydev);
452 	struct skb_shared_hwtstamps *shhwtstamps_rx;
453 	struct ptp_clock_event event;
454 	struct nxp_c45_hwts hwts;
455 	bool reschedule = false;
456 	struct timespec64 ts;
457 	struct sk_buff *skb;
458 	bool txts_valid;
459 	u32 ts_raw;
460 
461 	while (!skb_queue_empty_lockless(&priv->tx_queue) && poll_txts) {
462 		txts_valid = nxp_c45_get_hwtxts(priv, &hwts);
463 		if (unlikely(!txts_valid)) {
464 			/* Still more skbs in the queue */
465 			reschedule = true;
466 			break;
467 		}
468 
469 		nxp_c45_process_txts(priv, &hwts);
470 	}
471 
472 	while ((skb = skb_dequeue(&priv->rx_queue)) != NULL) {
473 		nxp_c45_ptp_gettimex64(&priv->caps, &ts, NULL);
474 		ts_raw = __be32_to_cpu(NXP_C45_SKB_CB(skb)->header->reserved2);
475 		hwts.sec = ts_raw >> 30;
476 		hwts.nsec = ts_raw & GENMASK(29, 0);
477 		nxp_c45_reconstruct_ts(&ts, &hwts);
478 		shhwtstamps_rx = skb_hwtstamps(skb);
479 		shhwtstamps_rx->hwtstamp = ns_to_ktime(timespec64_to_ns(&ts));
480 		NXP_C45_SKB_CB(skb)->header->reserved2 = 0;
481 		netif_rx(skb);
482 	}
483 
484 	if (priv->extts) {
485 		nxp_c45_get_extts(priv, &ts);
486 		if (timespec64_compare(&ts, &priv->extts_ts) != 0) {
487 			priv->extts_ts = ts;
488 			event.index = priv->extts_index;
489 			event.type = PTP_CLOCK_EXTTS;
490 			event.timestamp = ns_to_ktime(timespec64_to_ns(&ts));
491 			ptp_clock_event(priv->ptp_clock, &event);
492 		}
493 		reschedule = true;
494 	}
495 
496 	return reschedule ? 1 : -1;
497 }
498 
499 static void nxp_c45_gpio_config(struct nxp_c45_phy *priv,
500 				int pin, u16 pin_cfg)
501 {
502 	struct phy_device *phydev = priv->phydev;
503 
504 	phy_write_mmd(phydev, MDIO_MMD_VEND1,
505 		      VEND1_GPIO_FUNC_CONFIG_BASE + pin, pin_cfg);
506 }
507 
508 static int nxp_c45_perout_enable(struct nxp_c45_phy *priv,
509 				 struct ptp_perout_request *perout, int on)
510 {
511 	struct phy_device *phydev = priv->phydev;
512 	int pin;
513 
514 	if (perout->flags & ~PTP_PEROUT_PHASE)
515 		return -EOPNOTSUPP;
516 
517 	pin = ptp_find_pin(priv->ptp_clock, PTP_PF_PEROUT, perout->index);
518 	if (pin < 0)
519 		return pin;
520 
521 	if (!on) {
522 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PTP_CONFIG,
523 				   PPS_OUT_EN);
524 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PTP_CONFIG,
525 				   PPS_OUT_POL);
526 
527 		nxp_c45_gpio_config(priv, pin, GPIO_DISABLE);
528 
529 		return 0;
530 	}
531 
532 	/* The PPS signal is fixed to 1 second and is always generated when the
533 	 * seconds counter is incremented. The start time is not configurable.
534 	 * If the clock is adjusted, the PPS signal is automatically readjusted.
535 	 */
536 	if (perout->period.sec != 1 || perout->period.nsec != 0) {
537 		phydev_warn(phydev, "The period can be set only to 1 second.");
538 		return -EINVAL;
539 	}
540 
541 	if (!(perout->flags & PTP_PEROUT_PHASE)) {
542 		if (perout->start.sec != 0 || perout->start.nsec != 0) {
543 			phydev_warn(phydev, "The start time is not configurable. Should be set to 0 seconds and 0 nanoseconds.");
544 			return -EINVAL;
545 		}
546 	} else {
547 		if (perout->phase.nsec != 0 &&
548 		    perout->phase.nsec != (NSEC_PER_SEC >> 1)) {
549 			phydev_warn(phydev, "The phase can be set only to 0 or 500000000 nanoseconds.");
550 			return -EINVAL;
551 		}
552 
553 		if (perout->phase.nsec == 0)
554 			phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1,
555 					   VEND1_PTP_CONFIG, PPS_OUT_POL);
556 		else
557 			phy_set_bits_mmd(phydev, MDIO_MMD_VEND1,
558 					 VEND1_PTP_CONFIG, PPS_OUT_POL);
559 	}
560 
561 	nxp_c45_gpio_config(priv, pin, GPIO_PPS_OUT_CFG);
562 
563 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PTP_CONFIG, PPS_OUT_EN);
564 
565 	return 0;
566 }
567 
568 static int nxp_c45_extts_enable(struct nxp_c45_phy *priv,
569 				struct ptp_extts_request *extts, int on)
570 {
571 	int pin;
572 
573 	if (extts->flags & ~(PTP_ENABLE_FEATURE |
574 			      PTP_RISING_EDGE |
575 			      PTP_FALLING_EDGE |
576 			      PTP_STRICT_FLAGS))
577 		return -EOPNOTSUPP;
578 
579 	/* Sampling on both edges is not supported */
580 	if ((extts->flags & PTP_RISING_EDGE) &&
581 	    (extts->flags & PTP_FALLING_EDGE))
582 		return -EOPNOTSUPP;
583 
584 	pin = ptp_find_pin(priv->ptp_clock, PTP_PF_EXTTS, extts->index);
585 	if (pin < 0)
586 		return pin;
587 
588 	if (!on) {
589 		nxp_c45_gpio_config(priv, pin, GPIO_DISABLE);
590 		priv->extts = false;
591 
592 		return 0;
593 	}
594 
595 	if (extts->flags & PTP_RISING_EDGE)
596 		phy_clear_bits_mmd(priv->phydev, MDIO_MMD_VEND1,
597 				   VEND1_PTP_CONFIG, EXT_TRG_EDGE);
598 
599 	if (extts->flags & PTP_FALLING_EDGE)
600 		phy_set_bits_mmd(priv->phydev, MDIO_MMD_VEND1,
601 				 VEND1_PTP_CONFIG, EXT_TRG_EDGE);
602 
603 	nxp_c45_gpio_config(priv, pin, GPIO_EXTTS_OUT_CFG);
604 	priv->extts = true;
605 	priv->extts_index = extts->index;
606 	ptp_schedule_worker(priv->ptp_clock, 0);
607 
608 	return 0;
609 }
610 
611 static int nxp_c45_ptp_enable(struct ptp_clock_info *ptp,
612 			      struct ptp_clock_request *req, int on)
613 {
614 	struct nxp_c45_phy *priv = container_of(ptp, struct nxp_c45_phy, caps);
615 
616 	switch (req->type) {
617 	case PTP_CLK_REQ_EXTTS:
618 		return nxp_c45_extts_enable(priv, &req->extts, on);
619 	case PTP_CLK_REQ_PEROUT:
620 		return nxp_c45_perout_enable(priv, &req->perout, on);
621 	default:
622 		return -EOPNOTSUPP;
623 	}
624 }
625 
626 static struct ptp_pin_desc nxp_c45_ptp_pins[] = {
627 	{ "nxp_c45_gpio0", 0, PTP_PF_NONE},
628 	{ "nxp_c45_gpio1", 1, PTP_PF_NONE},
629 	{ "nxp_c45_gpio2", 2, PTP_PF_NONE},
630 	{ "nxp_c45_gpio3", 3, PTP_PF_NONE},
631 	{ "nxp_c45_gpio4", 4, PTP_PF_NONE},
632 	{ "nxp_c45_gpio5", 5, PTP_PF_NONE},
633 	{ "nxp_c45_gpio6", 6, PTP_PF_NONE},
634 	{ "nxp_c45_gpio7", 7, PTP_PF_NONE},
635 	{ "nxp_c45_gpio8", 8, PTP_PF_NONE},
636 	{ "nxp_c45_gpio9", 9, PTP_PF_NONE},
637 	{ "nxp_c45_gpio10", 10, PTP_PF_NONE},
638 	{ "nxp_c45_gpio11", 11, PTP_PF_NONE},
639 };
640 
641 static int nxp_c45_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
642 				  enum ptp_pin_function func, unsigned int chan)
643 {
644 	if (pin >= ARRAY_SIZE(nxp_c45_ptp_pins))
645 		return -EINVAL;
646 
647 	switch (func) {
648 	case PTP_PF_NONE:
649 	case PTP_PF_PEROUT:
650 	case PTP_PF_EXTTS:
651 		break;
652 	default:
653 		return -EOPNOTSUPP;
654 	}
655 
656 	return 0;
657 }
658 
659 static int nxp_c45_init_ptp_clock(struct nxp_c45_phy *priv)
660 {
661 	priv->caps = (struct ptp_clock_info) {
662 		.owner		= THIS_MODULE,
663 		.name		= "NXP C45 PHC",
664 		.max_adj	= 16666666,
665 		.adjfine	= nxp_c45_ptp_adjfine,
666 		.adjtime	= nxp_c45_ptp_adjtime,
667 		.gettimex64	= nxp_c45_ptp_gettimex64,
668 		.settime64	= nxp_c45_ptp_settime64,
669 		.enable		= nxp_c45_ptp_enable,
670 		.verify		= nxp_c45_ptp_verify_pin,
671 		.do_aux_work	= nxp_c45_do_aux_work,
672 		.pin_config	= nxp_c45_ptp_pins,
673 		.n_pins		= ARRAY_SIZE(nxp_c45_ptp_pins),
674 		.n_ext_ts	= 1,
675 		.n_per_out	= 1,
676 	};
677 
678 	priv->ptp_clock = ptp_clock_register(&priv->caps,
679 					     &priv->phydev->mdio.dev);
680 
681 	if (IS_ERR(priv->ptp_clock))
682 		return PTR_ERR(priv->ptp_clock);
683 
684 	if (!priv->ptp_clock)
685 		return -ENOMEM;
686 
687 	return 0;
688 }
689 
690 static void nxp_c45_txtstamp(struct mii_timestamper *mii_ts,
691 			     struct sk_buff *skb, int type)
692 {
693 	struct nxp_c45_phy *priv = container_of(mii_ts, struct nxp_c45_phy,
694 						mii_ts);
695 
696 	switch (priv->hwts_tx) {
697 	case HWTSTAMP_TX_ON:
698 		NXP_C45_SKB_CB(skb)->type = type;
699 		NXP_C45_SKB_CB(skb)->header = ptp_parse_header(skb, type);
700 		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
701 		skb_queue_tail(&priv->tx_queue, skb);
702 		if (nxp_c45_poll_txts(priv->phydev))
703 			ptp_schedule_worker(priv->ptp_clock, 0);
704 		break;
705 	case HWTSTAMP_TX_OFF:
706 	default:
707 		kfree_skb(skb);
708 		break;
709 	}
710 }
711 
712 static bool nxp_c45_rxtstamp(struct mii_timestamper *mii_ts,
713 			     struct sk_buff *skb, int type)
714 {
715 	struct nxp_c45_phy *priv = container_of(mii_ts, struct nxp_c45_phy,
716 						mii_ts);
717 	struct ptp_header *header = ptp_parse_header(skb, type);
718 
719 	if (!header)
720 		return false;
721 
722 	if (!priv->hwts_rx)
723 		return false;
724 
725 	NXP_C45_SKB_CB(skb)->header = header;
726 	skb_queue_tail(&priv->rx_queue, skb);
727 	ptp_schedule_worker(priv->ptp_clock, 0);
728 
729 	return true;
730 }
731 
732 static int nxp_c45_hwtstamp(struct mii_timestamper *mii_ts,
733 			    struct ifreq *ifreq)
734 {
735 	struct nxp_c45_phy *priv = container_of(mii_ts, struct nxp_c45_phy,
736 						mii_ts);
737 	struct phy_device *phydev = priv->phydev;
738 	struct hwtstamp_config cfg;
739 
740 	if (copy_from_user(&cfg, ifreq->ifr_data, sizeof(cfg)))
741 		return -EFAULT;
742 
743 	if (cfg.tx_type < 0 || cfg.tx_type > HWTSTAMP_TX_ON)
744 		return -ERANGE;
745 
746 	priv->hwts_tx = cfg.tx_type;
747 
748 	switch (cfg.rx_filter) {
749 	case HWTSTAMP_FILTER_NONE:
750 		priv->hwts_rx = 0;
751 		break;
752 	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
753 	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
754 	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
755 		priv->hwts_rx = 1;
756 		cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_EVENT;
757 		break;
758 	default:
759 		return -ERANGE;
760 	}
761 
762 	if (priv->hwts_rx || priv->hwts_tx) {
763 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_EVENT_MSG_FILT,
764 			      EVENT_MSG_FILT_ALL);
765 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1,
766 				   VEND1_PORT_PTP_CONTROL,
767 				   PORT_PTP_CONTROL_BYPASS);
768 	} else {
769 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_EVENT_MSG_FILT,
770 			      EVENT_MSG_FILT_NONE);
771 		phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PORT_PTP_CONTROL,
772 				 PORT_PTP_CONTROL_BYPASS);
773 	}
774 
775 	if (nxp_c45_poll_txts(priv->phydev))
776 		goto nxp_c45_no_ptp_irq;
777 
778 	if (priv->hwts_tx)
779 		phy_set_bits_mmd(phydev, MDIO_MMD_VEND1,
780 				 VEND1_PTP_IRQ_EN, PTP_IRQ_EGR_TS);
781 	else
782 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1,
783 				   VEND1_PTP_IRQ_EN, PTP_IRQ_EGR_TS);
784 
785 nxp_c45_no_ptp_irq:
786 	return copy_to_user(ifreq->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
787 }
788 
789 static int nxp_c45_ts_info(struct mii_timestamper *mii_ts,
790 			   struct ethtool_ts_info *ts_info)
791 {
792 	struct nxp_c45_phy *priv = container_of(mii_ts, struct nxp_c45_phy,
793 						mii_ts);
794 
795 	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
796 			SOF_TIMESTAMPING_RX_HARDWARE |
797 			SOF_TIMESTAMPING_RAW_HARDWARE;
798 	ts_info->phc_index = ptp_clock_index(priv->ptp_clock);
799 	ts_info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON);
800 	ts_info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
801 			(1 << HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
802 			(1 << HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
803 			(1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT);
804 
805 	return 0;
806 }
807 
808 static const struct nxp_c45_phy_stats nxp_c45_hw_stats[] = {
809 	{ "phy_symbol_error_cnt", MDIO_MMD_VEND1,
810 		VEND1_SYMBOL_ERROR_COUNTER, 0, GENMASK(15, 0) },
811 	{ "phy_link_status_drop_cnt", MDIO_MMD_VEND1,
812 		VEND1_LINK_DROP_COUNTER, 8, GENMASK(13, 8) },
813 	{ "phy_link_availability_drop_cnt", MDIO_MMD_VEND1,
814 		VEND1_LINK_DROP_COUNTER, 0, GENMASK(5, 0) },
815 	{ "phy_link_loss_cnt", MDIO_MMD_VEND1,
816 		VEND1_LINK_LOSSES_AND_FAILURES, 10, GENMASK(15, 10) },
817 	{ "phy_link_failure_cnt", MDIO_MMD_VEND1,
818 		VEND1_LINK_LOSSES_AND_FAILURES, 0, GENMASK(9, 0) },
819 	{ "r_good_frame_cnt", MDIO_MMD_VEND1,
820 		VEND1_R_GOOD_FRAME_CNT, 0, GENMASK(15, 0) },
821 	{ "r_bad_frame_cnt", MDIO_MMD_VEND1,
822 		VEND1_R_BAD_FRAME_CNT, 0, GENMASK(15, 0) },
823 	{ "r_rxer_frame_cnt", MDIO_MMD_VEND1,
824 		VEND1_R_RXER_FRAME_CNT, 0, GENMASK(15, 0) },
825 	{ "rx_preamble_count", MDIO_MMD_VEND1,
826 		VEND1_RX_PREAMBLE_COUNT, 0, GENMASK(5, 0) },
827 	{ "tx_preamble_count", MDIO_MMD_VEND1,
828 		VEND1_TX_PREAMBLE_COUNT, 0, GENMASK(5, 0) },
829 	{ "rx_ipg_length", MDIO_MMD_VEND1,
830 		VEND1_RX_IPG_LENGTH, 0, GENMASK(8, 0) },
831 	{ "tx_ipg_length", MDIO_MMD_VEND1,
832 		VEND1_TX_IPG_LENGTH, 0, GENMASK(8, 0) },
833 };
834 
835 static int nxp_c45_get_sset_count(struct phy_device *phydev)
836 {
837 	return ARRAY_SIZE(nxp_c45_hw_stats);
838 }
839 
840 static void nxp_c45_get_strings(struct phy_device *phydev, u8 *data)
841 {
842 	size_t i;
843 
844 	for (i = 0; i < ARRAY_SIZE(nxp_c45_hw_stats); i++) {
845 		strncpy(data + i * ETH_GSTRING_LEN,
846 			nxp_c45_hw_stats[i].name, ETH_GSTRING_LEN);
847 	}
848 }
849 
850 static void nxp_c45_get_stats(struct phy_device *phydev,
851 			      struct ethtool_stats *stats, u64 *data)
852 {
853 	size_t i;
854 	int ret;
855 
856 	for (i = 0; i < ARRAY_SIZE(nxp_c45_hw_stats); i++) {
857 		ret = phy_read_mmd(phydev, nxp_c45_hw_stats[i].mmd,
858 				   nxp_c45_hw_stats[i].reg);
859 		if (ret < 0) {
860 			data[i] = U64_MAX;
861 		} else {
862 			data[i] = ret & nxp_c45_hw_stats[i].mask;
863 			data[i] >>= nxp_c45_hw_stats[i].off;
864 		}
865 	}
866 }
867 
868 static int nxp_c45_config_enable(struct phy_device *phydev)
869 {
870 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_DEVICE_CONTROL,
871 		      DEVICE_CONTROL_CONFIG_GLOBAL_EN |
872 		      DEVICE_CONTROL_CONFIG_ALL_EN);
873 	usleep_range(400, 450);
874 
875 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_PORT_CONTROL,
876 		      PORT_CONTROL_EN);
877 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_PHY_CONTROL,
878 		      PHY_CONFIG_EN);
879 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_PORT_INFRA_CONTROL,
880 		      PORT_INFRA_CONTROL_EN);
881 
882 	return 0;
883 }
884 
885 static int nxp_c45_start_op(struct phy_device *phydev)
886 {
887 	return phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PHY_CONTROL,
888 				PHY_START_OP);
889 }
890 
891 static int nxp_c45_config_intr(struct phy_device *phydev)
892 {
893 	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
894 		return phy_set_bits_mmd(phydev, MDIO_MMD_VEND1,
895 					VEND1_PHY_IRQ_EN, PHY_IRQ_LINK_EVENT);
896 	else
897 		return phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1,
898 					  VEND1_PHY_IRQ_EN, PHY_IRQ_LINK_EVENT);
899 }
900 
901 static irqreturn_t nxp_c45_handle_interrupt(struct phy_device *phydev)
902 {
903 	struct nxp_c45_phy *priv = phydev->priv;
904 	irqreturn_t ret = IRQ_NONE;
905 	struct nxp_c45_hwts hwts;
906 	int irq;
907 
908 	irq = phy_read_mmd(phydev, MDIO_MMD_VEND1, VEND1_PHY_IRQ_STATUS);
909 	if (irq & PHY_IRQ_LINK_EVENT) {
910 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_PHY_IRQ_ACK,
911 			      PHY_IRQ_LINK_EVENT);
912 		phy_trigger_machine(phydev);
913 		ret = IRQ_HANDLED;
914 	}
915 
916 	/* There is no need for ACK.
917 	 * The irq signal will be asserted until the EGR TS FIFO will be
918 	 * emptied.
919 	 */
920 	irq = phy_read_mmd(phydev, MDIO_MMD_VEND1, VEND1_PTP_IRQ_STATUS);
921 	if (irq & PTP_IRQ_EGR_TS) {
922 		while (nxp_c45_get_hwtxts(priv, &hwts))
923 			nxp_c45_process_txts(priv, &hwts);
924 
925 		ret = IRQ_HANDLED;
926 	}
927 
928 	return ret;
929 }
930 
931 static int nxp_c45_soft_reset(struct phy_device *phydev)
932 {
933 	int ret;
934 
935 	ret = phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_DEVICE_CONTROL,
936 			    DEVICE_CONTROL_RESET);
937 	if (ret)
938 		return ret;
939 
940 	return phy_read_mmd_poll_timeout(phydev, MDIO_MMD_VEND1,
941 					 VEND1_DEVICE_CONTROL, ret,
942 					 !(ret & DEVICE_CONTROL_RESET), 20000,
943 					 240000, false);
944 }
945 
946 static int nxp_c45_cable_test_start(struct phy_device *phydev)
947 {
948 	return phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_CABLE_TEST,
949 			     CABLE_TEST_ENABLE | CABLE_TEST_START);
950 }
951 
952 static int nxp_c45_cable_test_get_status(struct phy_device *phydev,
953 					 bool *finished)
954 {
955 	int ret;
956 	u8 cable_test_result;
957 
958 	ret = phy_read_mmd(phydev, MDIO_MMD_VEND1, VEND1_CABLE_TEST);
959 	if (!(ret & CABLE_TEST_VALID)) {
960 		*finished = false;
961 		return 0;
962 	}
963 
964 	*finished = true;
965 	cable_test_result = ret & GENMASK(2, 0);
966 
967 	switch (cable_test_result) {
968 	case CABLE_TEST_OK:
969 		ethnl_cable_test_result(phydev, ETHTOOL_A_CABLE_PAIR_A,
970 					ETHTOOL_A_CABLE_RESULT_CODE_OK);
971 		break;
972 	case CABLE_TEST_SHORTED:
973 		ethnl_cable_test_result(phydev, ETHTOOL_A_CABLE_PAIR_A,
974 					ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT);
975 		break;
976 	case CABLE_TEST_OPEN:
977 		ethnl_cable_test_result(phydev, ETHTOOL_A_CABLE_PAIR_A,
978 					ETHTOOL_A_CABLE_RESULT_CODE_OPEN);
979 		break;
980 	default:
981 		ethnl_cable_test_result(phydev, ETHTOOL_A_CABLE_PAIR_A,
982 					ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC);
983 	}
984 
985 	phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_CABLE_TEST,
986 			   CABLE_TEST_ENABLE);
987 
988 	return nxp_c45_start_op(phydev);
989 }
990 
991 static int nxp_c45_setup_master_slave(struct phy_device *phydev)
992 {
993 	switch (phydev->master_slave_set) {
994 	case MASTER_SLAVE_CFG_MASTER_FORCE:
995 	case MASTER_SLAVE_CFG_MASTER_PREFERRED:
996 		phy_write_mmd(phydev, MDIO_MMD_PMAPMD, PMAPMD_B100T1_PMAPMD_CTL,
997 			      MASTER_MODE);
998 		break;
999 	case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
1000 	case MASTER_SLAVE_CFG_SLAVE_FORCE:
1001 		phy_write_mmd(phydev, MDIO_MMD_PMAPMD, PMAPMD_B100T1_PMAPMD_CTL,
1002 			      SLAVE_MODE);
1003 		break;
1004 	case MASTER_SLAVE_CFG_UNKNOWN:
1005 	case MASTER_SLAVE_CFG_UNSUPPORTED:
1006 		return 0;
1007 	default:
1008 		phydev_warn(phydev, "Unsupported Master/Slave mode\n");
1009 		return -EOPNOTSUPP;
1010 	}
1011 
1012 	return 0;
1013 }
1014 
1015 static int nxp_c45_read_master_slave(struct phy_device *phydev)
1016 {
1017 	int reg;
1018 
1019 	phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
1020 	phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
1021 
1022 	reg = phy_read_mmd(phydev, MDIO_MMD_PMAPMD, PMAPMD_B100T1_PMAPMD_CTL);
1023 	if (reg < 0)
1024 		return reg;
1025 
1026 	if (reg & B100T1_PMAPMD_MASTER) {
1027 		phydev->master_slave_get = MASTER_SLAVE_CFG_MASTER_FORCE;
1028 		phydev->master_slave_state = MASTER_SLAVE_STATE_MASTER;
1029 	} else {
1030 		phydev->master_slave_get = MASTER_SLAVE_CFG_SLAVE_FORCE;
1031 		phydev->master_slave_state = MASTER_SLAVE_STATE_SLAVE;
1032 	}
1033 
1034 	return 0;
1035 }
1036 
1037 static int nxp_c45_config_aneg(struct phy_device *phydev)
1038 {
1039 	return nxp_c45_setup_master_slave(phydev);
1040 }
1041 
1042 static int nxp_c45_read_status(struct phy_device *phydev)
1043 {
1044 	int ret;
1045 
1046 	ret = genphy_c45_read_status(phydev);
1047 	if (ret)
1048 		return ret;
1049 
1050 	ret = nxp_c45_read_master_slave(phydev);
1051 	if (ret)
1052 		return ret;
1053 
1054 	return 0;
1055 }
1056 
1057 static int nxp_c45_get_sqi(struct phy_device *phydev)
1058 {
1059 	int reg;
1060 
1061 	reg = phy_read_mmd(phydev, MDIO_MMD_VEND1, VEND1_SIGNAL_QUALITY);
1062 	if (!(reg & SQI_VALID))
1063 		return -EINVAL;
1064 
1065 	reg &= SQI_MASK;
1066 
1067 	return reg;
1068 }
1069 
1070 static int nxp_c45_get_sqi_max(struct phy_device *phydev)
1071 {
1072 	return MAX_SQI;
1073 }
1074 
1075 static int nxp_c45_check_delay(struct phy_device *phydev, u32 delay)
1076 {
1077 	if (delay < MIN_ID_PS) {
1078 		phydev_err(phydev, "delay value smaller than %u\n", MIN_ID_PS);
1079 		return -EINVAL;
1080 	}
1081 
1082 	if (delay > MAX_ID_PS) {
1083 		phydev_err(phydev, "delay value higher than %u\n", MAX_ID_PS);
1084 		return -EINVAL;
1085 	}
1086 
1087 	return 0;
1088 }
1089 
1090 static u64 nxp_c45_get_phase_shift(u64 phase_offset_raw)
1091 {
1092 	/* The delay in degree phase is 73.8 + phase_offset_raw * 0.9.
1093 	 * To avoid floating point operations we'll multiply by 10
1094 	 * and get 1 decimal point precision.
1095 	 */
1096 	phase_offset_raw *= 10;
1097 	phase_offset_raw -= 738;
1098 	return div_u64(phase_offset_raw, 9);
1099 }
1100 
1101 static void nxp_c45_disable_delays(struct phy_device *phydev)
1102 {
1103 	phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_TXID, ID_ENABLE);
1104 	phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_RXID, ID_ENABLE);
1105 }
1106 
1107 static void nxp_c45_set_delays(struct phy_device *phydev)
1108 {
1109 	struct nxp_c45_phy *priv = phydev->priv;
1110 	u64 tx_delay = priv->tx_delay;
1111 	u64 rx_delay = priv->rx_delay;
1112 	u64 degree;
1113 
1114 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
1115 	    phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) {
1116 		degree = div_u64(tx_delay, PS_PER_DEGREE);
1117 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_TXID,
1118 			      ID_ENABLE | nxp_c45_get_phase_shift(degree));
1119 	} else {
1120 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_TXID,
1121 				   ID_ENABLE);
1122 	}
1123 
1124 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
1125 	    phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) {
1126 		degree = div_u64(rx_delay, PS_PER_DEGREE);
1127 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_RXID,
1128 			      ID_ENABLE | nxp_c45_get_phase_shift(degree));
1129 	} else {
1130 		phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_RXID,
1131 				   ID_ENABLE);
1132 	}
1133 }
1134 
1135 static int nxp_c45_get_delays(struct phy_device *phydev)
1136 {
1137 	struct nxp_c45_phy *priv = phydev->priv;
1138 	int ret;
1139 
1140 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
1141 	    phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) {
1142 		ret = device_property_read_u32(&phydev->mdio.dev,
1143 					       "tx-internal-delay-ps",
1144 					       &priv->tx_delay);
1145 		if (ret)
1146 			priv->tx_delay = DEFAULT_ID_PS;
1147 
1148 		ret = nxp_c45_check_delay(phydev, priv->tx_delay);
1149 		if (ret) {
1150 			phydev_err(phydev,
1151 				   "tx-internal-delay-ps invalid value\n");
1152 			return ret;
1153 		}
1154 	}
1155 
1156 	if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
1157 	    phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) {
1158 		ret = device_property_read_u32(&phydev->mdio.dev,
1159 					       "rx-internal-delay-ps",
1160 					       &priv->rx_delay);
1161 		if (ret)
1162 			priv->rx_delay = DEFAULT_ID_PS;
1163 
1164 		ret = nxp_c45_check_delay(phydev, priv->rx_delay);
1165 		if (ret) {
1166 			phydev_err(phydev,
1167 				   "rx-internal-delay-ps invalid value\n");
1168 			return ret;
1169 		}
1170 	}
1171 
1172 	return 0;
1173 }
1174 
1175 static int nxp_c45_set_phy_mode(struct phy_device *phydev)
1176 {
1177 	int ret;
1178 
1179 	ret = phy_read_mmd(phydev, MDIO_MMD_VEND1, VEND1_ABILITIES);
1180 	phydev_dbg(phydev, "Clause 45 managed PHY abilities 0x%x\n", ret);
1181 
1182 	switch (phydev->interface) {
1183 	case PHY_INTERFACE_MODE_RGMII:
1184 		if (!(ret & RGMII_ABILITY)) {
1185 			phydev_err(phydev, "rgmii mode not supported\n");
1186 			return -EINVAL;
1187 		}
1188 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1189 			      MII_BASIC_CONFIG_RGMII);
1190 		nxp_c45_disable_delays(phydev);
1191 		break;
1192 	case PHY_INTERFACE_MODE_RGMII_ID:
1193 	case PHY_INTERFACE_MODE_RGMII_TXID:
1194 	case PHY_INTERFACE_MODE_RGMII_RXID:
1195 		if (!(ret & RGMII_ID_ABILITY)) {
1196 			phydev_err(phydev, "rgmii-id, rgmii-txid, rgmii-rxid modes are not supported\n");
1197 			return -EINVAL;
1198 		}
1199 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1200 			      MII_BASIC_CONFIG_RGMII);
1201 		ret = nxp_c45_get_delays(phydev);
1202 		if (ret)
1203 			return ret;
1204 
1205 		nxp_c45_set_delays(phydev);
1206 		break;
1207 	case PHY_INTERFACE_MODE_MII:
1208 		if (!(ret & MII_ABILITY)) {
1209 			phydev_err(phydev, "mii mode not supported\n");
1210 			return -EINVAL;
1211 		}
1212 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1213 			      MII_BASIC_CONFIG_MII);
1214 		break;
1215 	case PHY_INTERFACE_MODE_REVMII:
1216 		if (!(ret & REVMII_ABILITY)) {
1217 			phydev_err(phydev, "rev-mii mode not supported\n");
1218 			return -EINVAL;
1219 		}
1220 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1221 			      MII_BASIC_CONFIG_MII | MII_BASIC_CONFIG_REV);
1222 		break;
1223 	case PHY_INTERFACE_MODE_RMII:
1224 		if (!(ret & RMII_ABILITY)) {
1225 			phydev_err(phydev, "rmii mode not supported\n");
1226 			return -EINVAL;
1227 		}
1228 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1229 			      MII_BASIC_CONFIG_RMII);
1230 		break;
1231 	case PHY_INTERFACE_MODE_SGMII:
1232 		if (!(ret & SGMII_ABILITY)) {
1233 			phydev_err(phydev, "sgmii mode not supported\n");
1234 			return -EINVAL;
1235 		}
1236 		phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_MII_BASIC_CONFIG,
1237 			      MII_BASIC_CONFIG_SGMII);
1238 		break;
1239 	case PHY_INTERFACE_MODE_INTERNAL:
1240 		break;
1241 	default:
1242 		return -EINVAL;
1243 	}
1244 
1245 	return 0;
1246 }
1247 
1248 static int nxp_c45_config_init(struct phy_device *phydev)
1249 {
1250 	int ret;
1251 
1252 	ret = nxp_c45_config_enable(phydev);
1253 	if (ret) {
1254 		phydev_err(phydev, "Failed to enable config\n");
1255 		return ret;
1256 	}
1257 
1258 	/* Bug workaround for SJA1110 rev B: enable write access
1259 	 * to MDIO_MMD_PMAPMD
1260 	 */
1261 	phy_write_mmd(phydev, MDIO_MMD_VEND1, 0x01F8, 1);
1262 	phy_write_mmd(phydev, MDIO_MMD_VEND1, 0x01F9, 2);
1263 
1264 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PHY_CONFIG,
1265 			 PHY_CONFIG_AUTO);
1266 
1267 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_LINK_DROP_COUNTER,
1268 			 COUNTER_EN);
1269 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_RX_PREAMBLE_COUNT,
1270 			 COUNTER_EN);
1271 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_TX_PREAMBLE_COUNT,
1272 			 COUNTER_EN);
1273 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_RX_IPG_LENGTH,
1274 			 COUNTER_EN);
1275 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_TX_IPG_LENGTH,
1276 			 COUNTER_EN);
1277 
1278 	ret = nxp_c45_set_phy_mode(phydev);
1279 	if (ret)
1280 		return ret;
1281 
1282 	phydev->autoneg = AUTONEG_DISABLE;
1283 
1284 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_PTP_CLK_PERIOD,
1285 		      PTP_CLK_PERIOD_100BT1);
1286 	phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_HW_LTC_LOCK_CTRL,
1287 			   HW_LTC_LOCK_EN);
1288 	phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_RX_TS_INSRT_CTRL,
1289 		      RX_TS_INSRT_MODE2);
1290 	phy_set_bits_mmd(phydev, MDIO_MMD_VEND1, VEND1_PORT_FUNC_ENABLES,
1291 			 PTP_ENABLE);
1292 
1293 	return nxp_c45_start_op(phydev);
1294 }
1295 
1296 static int nxp_c45_probe(struct phy_device *phydev)
1297 {
1298 	struct nxp_c45_phy *priv;
1299 	int ptp_ability;
1300 	int ret = 0;
1301 
1302 	priv = devm_kzalloc(&phydev->mdio.dev, sizeof(*priv), GFP_KERNEL);
1303 	if (!priv)
1304 		return -ENOMEM;
1305 
1306 	skb_queue_head_init(&priv->tx_queue);
1307 	skb_queue_head_init(&priv->rx_queue);
1308 
1309 	priv->phydev = phydev;
1310 
1311 	phydev->priv = priv;
1312 
1313 	mutex_init(&priv->ptp_lock);
1314 
1315 	ptp_ability = phy_read_mmd(phydev, MDIO_MMD_VEND1,
1316 				   VEND1_PORT_ABILITIES);
1317 	ptp_ability = !!(ptp_ability & PTP_ABILITY);
1318 	if (!ptp_ability) {
1319 		phydev_dbg(phydev, "the phy does not support PTP");
1320 		goto no_ptp_support;
1321 	}
1322 
1323 	if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) &&
1324 	    IS_ENABLED(CONFIG_NETWORK_PHY_TIMESTAMPING)) {
1325 		priv->mii_ts.rxtstamp = nxp_c45_rxtstamp;
1326 		priv->mii_ts.txtstamp = nxp_c45_txtstamp;
1327 		priv->mii_ts.hwtstamp = nxp_c45_hwtstamp;
1328 		priv->mii_ts.ts_info = nxp_c45_ts_info;
1329 		phydev->mii_ts = &priv->mii_ts;
1330 		ret = nxp_c45_init_ptp_clock(priv);
1331 	} else {
1332 		phydev_dbg(phydev, "PTP support not enabled even if the phy supports it");
1333 	}
1334 
1335 no_ptp_support:
1336 
1337 	return ret;
1338 }
1339 
1340 static void nxp_c45_remove(struct phy_device *phydev)
1341 {
1342 	struct nxp_c45_phy *priv = phydev->priv;
1343 
1344 	if (priv->ptp_clock)
1345 		ptp_clock_unregister(priv->ptp_clock);
1346 
1347 	skb_queue_purge(&priv->tx_queue);
1348 	skb_queue_purge(&priv->rx_queue);
1349 }
1350 
1351 static struct phy_driver nxp_c45_driver[] = {
1352 	{
1353 		PHY_ID_MATCH_MODEL(PHY_ID_TJA_1103),
1354 		.name			= "NXP C45 TJA1103",
1355 		.features		= PHY_BASIC_T1_FEATURES,
1356 		.probe			= nxp_c45_probe,
1357 		.soft_reset		= nxp_c45_soft_reset,
1358 		.config_aneg		= nxp_c45_config_aneg,
1359 		.config_init		= nxp_c45_config_init,
1360 		.config_intr		= nxp_c45_config_intr,
1361 		.handle_interrupt	= nxp_c45_handle_interrupt,
1362 		.read_status		= nxp_c45_read_status,
1363 		.suspend		= genphy_c45_pma_suspend,
1364 		.resume			= genphy_c45_pma_resume,
1365 		.get_sset_count		= nxp_c45_get_sset_count,
1366 		.get_strings		= nxp_c45_get_strings,
1367 		.get_stats		= nxp_c45_get_stats,
1368 		.cable_test_start	= nxp_c45_cable_test_start,
1369 		.cable_test_get_status	= nxp_c45_cable_test_get_status,
1370 		.set_loopback		= genphy_c45_loopback,
1371 		.get_sqi		= nxp_c45_get_sqi,
1372 		.get_sqi_max		= nxp_c45_get_sqi_max,
1373 		.remove			= nxp_c45_remove,
1374 	},
1375 };
1376 
1377 module_phy_driver(nxp_c45_driver);
1378 
1379 static struct mdio_device_id __maybe_unused nxp_c45_tbl[] = {
1380 	{ PHY_ID_MATCH_MODEL(PHY_ID_TJA_1103) },
1381 	{ /*sentinel*/ },
1382 };
1383 
1384 MODULE_DEVICE_TABLE(mdio, nxp_c45_tbl);
1385 
1386 MODULE_AUTHOR("Radu Pirea <radu-nicolae.pirea@oss.nxp.com>");
1387 MODULE_DESCRIPTION("NXP C45 PHY driver");
1388 MODULE_LICENSE("GPL v2");
1389