Loading...
1/* SPDX-License-Identifier: GPL-2.0+ */
2/* Copyright (C) 2018 Microchip Technology Inc. */
3
4#include <linux/netdevice.h>
5#include "lan743x_main.h"
6
7#include <linux/ptp_clock_kernel.h>
8#include <linux/module.h>
9#include <linux/pci.h>
10#include <linux/net_tstamp.h>
11
12#include "lan743x_ptp.h"
13
14#define LAN743X_NUMBER_OF_GPIO (12)
15#define LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB (31249999)
16#define LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM (2047999934)
17
18static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter);
19static void lan743x_ptp_enable(struct lan743x_adapter *adapter);
20static void lan743x_ptp_disable(struct lan743x_adapter *adapter);
21static void lan743x_ptp_reset(struct lan743x_adapter *adapter);
22static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
23 u32 seconds, u32 nano_seconds,
24 u32 sub_nano_seconds);
25
26int lan743x_gpio_init(struct lan743x_adapter *adapter)
27{
28 struct lan743x_gpio *gpio = &adapter->gpio;
29
30 spin_lock_init(&gpio->gpio_lock);
31
32 gpio->gpio_cfg0 = 0; /* set all direction to input, data = 0 */
33 gpio->gpio_cfg1 = 0x0FFF0000;/* disable all gpio, set to open drain */
34 gpio->gpio_cfg2 = 0;/* set all to 1588 low polarity level */
35 gpio->gpio_cfg3 = 0;/* disable all 1588 output */
36 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
37 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
38 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
39 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
40
41 return 0;
42}
43
44static void lan743x_ptp_wait_till_cmd_done(struct lan743x_adapter *adapter,
45 u32 bit_mask)
46{
47 int timeout = 1000;
48 u32 data = 0;
49
50 while (timeout &&
51 (data = (lan743x_csr_read(adapter, PTP_CMD_CTL) &
52 bit_mask))) {
53 usleep_range(1000, 20000);
54 timeout--;
55 }
56 if (data) {
57 netif_err(adapter, drv, adapter->netdev,
58 "timeout waiting for cmd to be done, cmd = 0x%08X\n",
59 bit_mask);
60 }
61}
62
63static void lan743x_ptp_tx_ts_enqueue_ts(struct lan743x_adapter *adapter,
64 u32 seconds, u32 nano_seconds,
65 u32 header)
66{
67 struct lan743x_ptp *ptp = &adapter->ptp;
68
69 spin_lock_bh(&ptp->tx_ts_lock);
70 if (ptp->tx_ts_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
71 ptp->tx_ts_seconds_queue[ptp->tx_ts_queue_size] = seconds;
72 ptp->tx_ts_nseconds_queue[ptp->tx_ts_queue_size] = nano_seconds;
73 ptp->tx_ts_header_queue[ptp->tx_ts_queue_size] = header;
74 ptp->tx_ts_queue_size++;
75 } else {
76 netif_err(adapter, drv, adapter->netdev,
77 "tx ts queue overflow\n");
78 }
79 spin_unlock_bh(&ptp->tx_ts_lock);
80}
81
82static void lan743x_ptp_tx_ts_complete(struct lan743x_adapter *adapter)
83{
84 struct lan743x_ptp *ptp = &adapter->ptp;
85 struct skb_shared_hwtstamps tstamps;
86 u32 header, nseconds, seconds;
87 bool ignore_sync = false;
88 struct sk_buff *skb;
89 int c, i;
90
91 spin_lock_bh(&ptp->tx_ts_lock);
92 c = ptp->tx_ts_skb_queue_size;
93
94 if (c > ptp->tx_ts_queue_size)
95 c = ptp->tx_ts_queue_size;
96 if (c <= 0)
97 goto done;
98
99 for (i = 0; i < c; i++) {
100 ignore_sync = ((ptp->tx_ts_ignore_sync_queue &
101 BIT(i)) != 0);
102 skb = ptp->tx_ts_skb_queue[i];
103 nseconds = ptp->tx_ts_nseconds_queue[i];
104 seconds = ptp->tx_ts_seconds_queue[i];
105 header = ptp->tx_ts_header_queue[i];
106
107 memset(&tstamps, 0, sizeof(tstamps));
108 tstamps.hwtstamp = ktime_set(seconds, nseconds);
109 if (!ignore_sync ||
110 ((header & PTP_TX_MSG_HEADER_MSG_TYPE_) !=
111 PTP_TX_MSG_HEADER_MSG_TYPE_SYNC_))
112 skb_tstamp_tx(skb, &tstamps);
113
114 dev_kfree_skb(skb);
115
116 ptp->tx_ts_skb_queue[i] = NULL;
117 ptp->tx_ts_seconds_queue[i] = 0;
118 ptp->tx_ts_nseconds_queue[i] = 0;
119 ptp->tx_ts_header_queue[i] = 0;
120 }
121
122 /* shift queue */
123 ptp->tx_ts_ignore_sync_queue >>= c;
124 for (i = c; i < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; i++) {
125 ptp->tx_ts_skb_queue[i - c] = ptp->tx_ts_skb_queue[i];
126 ptp->tx_ts_seconds_queue[i - c] = ptp->tx_ts_seconds_queue[i];
127 ptp->tx_ts_nseconds_queue[i - c] = ptp->tx_ts_nseconds_queue[i];
128 ptp->tx_ts_header_queue[i - c] = ptp->tx_ts_header_queue[i];
129
130 ptp->tx_ts_skb_queue[i] = NULL;
131 ptp->tx_ts_seconds_queue[i] = 0;
132 ptp->tx_ts_nseconds_queue[i] = 0;
133 ptp->tx_ts_header_queue[i] = 0;
134 }
135 ptp->tx_ts_skb_queue_size -= c;
136 ptp->tx_ts_queue_size -= c;
137done:
138 ptp->pending_tx_timestamps -= c;
139 spin_unlock_bh(&ptp->tx_ts_lock);
140}
141
142static int lan743x_ptp_reserve_event_ch(struct lan743x_adapter *adapter)
143{
144 struct lan743x_ptp *ptp = &adapter->ptp;
145 int result = -ENODEV;
146 int index = 0;
147
148 mutex_lock(&ptp->command_lock);
149 for (index = 0; index < LAN743X_PTP_NUMBER_OF_EVENT_CHANNELS; index++) {
150 if (!(test_bit(index, &ptp->used_event_ch))) {
151 ptp->used_event_ch |= BIT(index);
152 result = index;
153 break;
154 }
155 }
156 mutex_unlock(&ptp->command_lock);
157 return result;
158}
159
160static void lan743x_ptp_release_event_ch(struct lan743x_adapter *adapter,
161 int event_channel)
162{
163 struct lan743x_ptp *ptp = &adapter->ptp;
164
165 mutex_lock(&ptp->command_lock);
166 if (test_bit(event_channel, &ptp->used_event_ch)) {
167 ptp->used_event_ch &= ~BIT(event_channel);
168 } else {
169 netif_warn(adapter, drv, adapter->netdev,
170 "attempted release on a not used event_channel = %d\n",
171 event_channel);
172 }
173 mutex_unlock(&ptp->command_lock);
174}
175
176static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
177 u32 *seconds, u32 *nano_seconds,
178 u32 *sub_nano_seconds);
179static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
180 s64 time_step_ns);
181
182static int lan743x_gpio_rsrv_ptp_out(struct lan743x_adapter *adapter,
183 int bit, int ptp_channel)
184{
185 struct lan743x_gpio *gpio = &adapter->gpio;
186 unsigned long irq_flags = 0;
187 int bit_mask = BIT(bit);
188 int ret = -EBUSY;
189
190 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
191
192 if (!(gpio->used_bits & bit_mask)) {
193 gpio->used_bits |= bit_mask;
194 gpio->output_bits |= bit_mask;
195 gpio->ptp_bits |= bit_mask;
196
197 /* set as output, and zero initial value */
198 gpio->gpio_cfg0 |= GPIO_CFG0_GPIO_DIR_BIT_(bit);
199 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(bit);
200 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
201
202 /* enable gpio, and set buffer type to push pull */
203 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOEN_BIT_(bit);
204 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOBUF_BIT_(bit);
205 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
206
207 /* set 1588 polarity to high */
208 gpio->gpio_cfg2 |= GPIO_CFG2_1588_POL_BIT_(bit);
209 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
210
211 if (!ptp_channel) {
212 /* use channel A */
213 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_CH_SEL_BIT_(bit);
214 } else {
215 /* use channel B */
216 gpio->gpio_cfg3 |= GPIO_CFG3_1588_CH_SEL_BIT_(bit);
217 }
218 gpio->gpio_cfg3 |= GPIO_CFG3_1588_OE_BIT_(bit);
219 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
220
221 ret = bit;
222 }
223 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
224 return ret;
225}
226
227static void lan743x_gpio_release(struct lan743x_adapter *adapter, int bit)
228{
229 struct lan743x_gpio *gpio = &adapter->gpio;
230 unsigned long irq_flags = 0;
231 int bit_mask = BIT(bit);
232
233 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
234 if (gpio->used_bits & bit_mask) {
235 gpio->used_bits &= ~bit_mask;
236 if (gpio->output_bits & bit_mask) {
237 gpio->output_bits &= ~bit_mask;
238
239 if (gpio->ptp_bits & bit_mask) {
240 gpio->ptp_bits &= ~bit_mask;
241 /* disable ptp output */
242 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_OE_BIT_(bit);
243 lan743x_csr_write(adapter, GPIO_CFG3,
244 gpio->gpio_cfg3);
245 }
246 /* release gpio output */
247
248 /* disable gpio */
249 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOEN_BIT_(bit);
250 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOBUF_BIT_(bit);
251 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
252
253 /* reset back to input */
254 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DIR_BIT_(bit);
255 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(bit);
256 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
257 }
258 }
259 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
260}
261
262static int lan743x_ptpci_adjfine(struct ptp_clock_info *ptpci, long scaled_ppm)
263{
264 struct lan743x_ptp *ptp =
265 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
266 struct lan743x_adapter *adapter =
267 container_of(ptp, struct lan743x_adapter, ptp);
268 u32 lan743x_rate_adj = 0;
269 bool positive = true;
270 u64 u64_delta = 0;
271
272 if ((scaled_ppm < (-LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM)) ||
273 scaled_ppm > LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM) {
274 return -EINVAL;
275 }
276 if (scaled_ppm > 0) {
277 u64_delta = (u64)scaled_ppm;
278 positive = true;
279 } else {
280 u64_delta = (u64)(-scaled_ppm);
281 positive = false;
282 }
283 u64_delta = (u64_delta << 19);
284 lan743x_rate_adj = div_u64(u64_delta, 1000000);
285
286 if (positive)
287 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_;
288
289 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ,
290 lan743x_rate_adj);
291
292 return 0;
293}
294
295static int lan743x_ptpci_adjfreq(struct ptp_clock_info *ptpci, s32 delta_ppb)
296{
297 struct lan743x_ptp *ptp =
298 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
299 struct lan743x_adapter *adapter =
300 container_of(ptp, struct lan743x_adapter, ptp);
301 u32 lan743x_rate_adj = 0;
302 bool positive = true;
303 u32 u32_delta = 0;
304 u64 u64_delta = 0;
305
306 if ((delta_ppb < (-LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB)) ||
307 delta_ppb > LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB) {
308 return -EINVAL;
309 }
310 if (delta_ppb > 0) {
311 u32_delta = (u32)delta_ppb;
312 positive = true;
313 } else {
314 u32_delta = (u32)(-delta_ppb);
315 positive = false;
316 }
317 u64_delta = (((u64)u32_delta) << 35);
318 lan743x_rate_adj = div_u64(u64_delta, 1000000000);
319
320 if (positive)
321 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_;
322
323 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ,
324 lan743x_rate_adj);
325
326 return 0;
327}
328
329static int lan743x_ptpci_adjtime(struct ptp_clock_info *ptpci, s64 delta)
330{
331 struct lan743x_ptp *ptp =
332 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
333 struct lan743x_adapter *adapter =
334 container_of(ptp, struct lan743x_adapter, ptp);
335
336 lan743x_ptp_clock_step(adapter, delta);
337
338 return 0;
339}
340
341static int lan743x_ptpci_gettime64(struct ptp_clock_info *ptpci,
342 struct timespec64 *ts)
343{
344 struct lan743x_ptp *ptp =
345 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
346 struct lan743x_adapter *adapter =
347 container_of(ptp, struct lan743x_adapter, ptp);
348 u32 nano_seconds = 0;
349 u32 seconds = 0;
350
351 lan743x_ptp_clock_get(adapter, &seconds, &nano_seconds, NULL);
352 ts->tv_sec = seconds;
353 ts->tv_nsec = nano_seconds;
354
355 return 0;
356}
357
358static int lan743x_ptpci_settime64(struct ptp_clock_info *ptpci,
359 const struct timespec64 *ts)
360{
361 struct lan743x_ptp *ptp =
362 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
363 struct lan743x_adapter *adapter =
364 container_of(ptp, struct lan743x_adapter, ptp);
365 u32 nano_seconds = 0;
366 u32 seconds = 0;
367
368 if (ts) {
369 if (ts->tv_sec > 0xFFFFFFFFLL ||
370 ts->tv_sec < 0) {
371 netif_warn(adapter, drv, adapter->netdev,
372 "ts->tv_sec out of range, %lld\n",
373 ts->tv_sec);
374 return -ERANGE;
375 }
376 if (ts->tv_nsec >= 1000000000L ||
377 ts->tv_nsec < 0) {
378 netif_warn(adapter, drv, adapter->netdev,
379 "ts->tv_nsec out of range, %ld\n",
380 ts->tv_nsec);
381 return -ERANGE;
382 }
383 seconds = ts->tv_sec;
384 nano_seconds = ts->tv_nsec;
385 lan743x_ptp_clock_set(adapter, seconds, nano_seconds, 0);
386 } else {
387 netif_warn(adapter, drv, adapter->netdev, "ts == NULL\n");
388 return -EINVAL;
389 }
390
391 return 0;
392}
393
394static void lan743x_ptp_perout_off(struct lan743x_adapter *adapter)
395{
396 struct lan743x_ptp *ptp = &adapter->ptp;
397 u32 general_config = 0;
398
399 if (ptp->perout_gpio_bit >= 0) {
400 lan743x_gpio_release(adapter, ptp->perout_gpio_bit);
401 ptp->perout_gpio_bit = -1;
402 }
403
404 if (ptp->perout_event_ch >= 0) {
405 /* set target to far in the future, effectively disabling it */
406 lan743x_csr_write(adapter,
407 PTP_CLOCK_TARGET_SEC_X(ptp->perout_event_ch),
408 0xFFFF0000);
409 lan743x_csr_write(adapter,
410 PTP_CLOCK_TARGET_NS_X(ptp->perout_event_ch),
411 0);
412
413 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
414 general_config |= PTP_GENERAL_CONFIG_RELOAD_ADD_X_
415 (ptp->perout_event_ch);
416 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
417 lan743x_ptp_release_event_ch(adapter, ptp->perout_event_ch);
418 ptp->perout_event_ch = -1;
419 }
420}
421
422static int lan743x_ptp_perout(struct lan743x_adapter *adapter, int on,
423 struct ptp_perout_request *perout)
424{
425 struct lan743x_ptp *ptp = &adapter->ptp;
426 u32 period_sec = 0, period_nsec = 0;
427 u32 start_sec = 0, start_nsec = 0;
428 u32 general_config = 0;
429 int pulse_width = 0;
430 int perout_bit = 0;
431
432 /* Reject requests with unsupported flags */
433 if (perout->flags)
434 return -EOPNOTSUPP;
435
436 if (!on) {
437 lan743x_ptp_perout_off(adapter);
438 return 0;
439 }
440
441 if (ptp->perout_event_ch >= 0 ||
442 ptp->perout_gpio_bit >= 0) {
443 /* already on, turn off first */
444 lan743x_ptp_perout_off(adapter);
445 }
446
447 ptp->perout_event_ch = lan743x_ptp_reserve_event_ch(adapter);
448 if (ptp->perout_event_ch < 0) {
449 netif_warn(adapter, drv, adapter->netdev,
450 "Failed to reserve event channel for PEROUT\n");
451 goto failed;
452 }
453
454 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) {
455 case ID_REV_ID_LAN7430_:
456 perout_bit = 2;/* GPIO 2 is preferred on EVB LAN7430 */
457 break;
458 case ID_REV_ID_LAN7431_:
459 perout_bit = 4;/* GPIO 4 is preferred on EVB LAN7431 */
460 break;
461 }
462
463 ptp->perout_gpio_bit = lan743x_gpio_rsrv_ptp_out(adapter,
464 perout_bit,
465 ptp->perout_event_ch);
466
467 if (ptp->perout_gpio_bit < 0) {
468 netif_warn(adapter, drv, adapter->netdev,
469 "Failed to reserve gpio %d for PEROUT\n",
470 perout_bit);
471 goto failed;
472 }
473
474 start_sec = perout->start.sec;
475 start_sec += perout->start.nsec / 1000000000;
476 start_nsec = perout->start.nsec % 1000000000;
477
478 period_sec = perout->period.sec;
479 period_sec += perout->period.nsec / 1000000000;
480 period_nsec = perout->period.nsec % 1000000000;
481
482 if (period_sec == 0) {
483 if (period_nsec >= 400000000) {
484 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
485 } else if (period_nsec >= 20000000) {
486 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
487 } else if (period_nsec >= 2000000) {
488 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
489 } else if (period_nsec >= 200000) {
490 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
491 } else if (period_nsec >= 20000) {
492 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
493 } else if (period_nsec >= 200) {
494 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
495 } else {
496 netif_warn(adapter, drv, adapter->netdev,
497 "perout period too small, minimum is 200nS\n");
498 goto failed;
499 }
500 } else {
501 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
502 }
503
504 /* turn off by setting target far in future */
505 lan743x_csr_write(adapter,
506 PTP_CLOCK_TARGET_SEC_X(ptp->perout_event_ch),
507 0xFFFF0000);
508 lan743x_csr_write(adapter,
509 PTP_CLOCK_TARGET_NS_X(ptp->perout_event_ch), 0);
510
511 /* Configure to pulse every period */
512 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
513 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_
514 (ptp->perout_event_ch));
515 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_
516 (ptp->perout_event_ch, pulse_width);
517 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_
518 (ptp->perout_event_ch);
519 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
520
521 /* set the reload to one toggle cycle */
522 lan743x_csr_write(adapter,
523 PTP_CLOCK_TARGET_RELOAD_SEC_X(ptp->perout_event_ch),
524 period_sec);
525 lan743x_csr_write(adapter,
526 PTP_CLOCK_TARGET_RELOAD_NS_X(ptp->perout_event_ch),
527 period_nsec);
528
529 /* set the start time */
530 lan743x_csr_write(adapter,
531 PTP_CLOCK_TARGET_SEC_X(ptp->perout_event_ch),
532 start_sec);
533 lan743x_csr_write(adapter,
534 PTP_CLOCK_TARGET_NS_X(ptp->perout_event_ch),
535 start_nsec);
536
537 return 0;
538
539failed:
540 lan743x_ptp_perout_off(adapter);
541 return -ENODEV;
542}
543
544static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci,
545 struct ptp_clock_request *request, int on)
546{
547 struct lan743x_ptp *ptp =
548 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
549 struct lan743x_adapter *adapter =
550 container_of(ptp, struct lan743x_adapter, ptp);
551
552 if (request) {
553 switch (request->type) {
554 case PTP_CLK_REQ_EXTTS:
555 return -EINVAL;
556 case PTP_CLK_REQ_PEROUT:
557 if (request->perout.index == 0)
558 return lan743x_ptp_perout(adapter, on,
559 &request->perout);
560 return -EINVAL;
561 case PTP_CLK_REQ_PPS:
562 return -EINVAL;
563 default:
564 netif_err(adapter, drv, adapter->netdev,
565 "request->type == %d, Unknown\n",
566 request->type);
567 break;
568 }
569 } else {
570 netif_err(adapter, drv, adapter->netdev, "request == NULL\n");
571 }
572 return 0;
573}
574
575static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci)
576{
577 struct lan743x_ptp *ptp =
578 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
579 struct lan743x_adapter *adapter =
580 container_of(ptp, struct lan743x_adapter, ptp);
581 u32 cap_info, cause, header, nsec, seconds;
582 bool new_timestamp_available = false;
583 int count = 0;
584
585 while ((count < 100) &&
586 (lan743x_csr_read(adapter, PTP_INT_STS) & PTP_INT_BIT_TX_TS_)) {
587 count++;
588 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO);
589
590 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) {
591 seconds = lan743x_csr_read(adapter,
592 PTP_TX_EGRESS_SEC);
593 nsec = lan743x_csr_read(adapter, PTP_TX_EGRESS_NS);
594 cause = (nsec &
595 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_);
596 header = lan743x_csr_read(adapter,
597 PTP_TX_MSG_HEADER);
598
599 if (cause == PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) {
600 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_;
601 lan743x_ptp_tx_ts_enqueue_ts(adapter,
602 seconds, nsec,
603 header);
604 new_timestamp_available = true;
605 } else if (cause ==
606 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) {
607 netif_err(adapter, drv, adapter->netdev,
608 "Auto capture cause not supported\n");
609 } else {
610 netif_warn(adapter, drv, adapter->netdev,
611 "unknown tx timestamp capture cause\n");
612 }
613 } else {
614 netif_warn(adapter, drv, adapter->netdev,
615 "TX TS INT but no TX TS CNT\n");
616 }
617 lan743x_csr_write(adapter, PTP_INT_STS, PTP_INT_BIT_TX_TS_);
618 }
619
620 if (new_timestamp_available)
621 lan743x_ptp_tx_ts_complete(adapter);
622
623 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
624
625 return -1;
626}
627
628static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
629 u32 *seconds, u32 *nano_seconds,
630 u32 *sub_nano_seconds)
631{
632 struct lan743x_ptp *ptp = &adapter->ptp;
633
634 mutex_lock(&ptp->command_lock);
635
636 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_);
637 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_);
638
639 if (seconds)
640 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC);
641
642 if (nano_seconds)
643 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS);
644
645 if (sub_nano_seconds)
646 (*sub_nano_seconds) =
647 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS);
648
649 mutex_unlock(&ptp->command_lock);
650}
651
652static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
653 s64 time_step_ns)
654{
655 struct lan743x_ptp *ptp = &adapter->ptp;
656 u32 nano_seconds_step = 0;
657 u64 abs_time_step_ns = 0;
658 u32 unsigned_seconds = 0;
659 u32 nano_seconds = 0;
660 u32 remainder = 0;
661 s32 seconds = 0;
662
663 if (time_step_ns > 15000000000LL) {
664 /* convert to clock set */
665 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
666 &nano_seconds, NULL);
667 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL,
668 &remainder);
669 nano_seconds += remainder;
670 if (nano_seconds >= 1000000000) {
671 unsigned_seconds++;
672 nano_seconds -= 1000000000;
673 }
674 lan743x_ptp_clock_set(adapter, unsigned_seconds,
675 nano_seconds, 0);
676 return;
677 } else if (time_step_ns < -15000000000LL) {
678 /* convert to clock set */
679 time_step_ns = -time_step_ns;
680
681 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
682 &nano_seconds, NULL);
683 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL,
684 &remainder);
685 nano_seconds_step = remainder;
686 if (nano_seconds < nano_seconds_step) {
687 unsigned_seconds--;
688 nano_seconds += 1000000000;
689 }
690 nano_seconds -= nano_seconds_step;
691 lan743x_ptp_clock_set(adapter, unsigned_seconds,
692 nano_seconds, 0);
693 return;
694 }
695
696 /* do clock step */
697 if (time_step_ns >= 0) {
698 abs_time_step_ns = (u64)(time_step_ns);
699 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000,
700 &remainder);
701 nano_seconds = (u32)remainder;
702 } else {
703 abs_time_step_ns = (u64)(-time_step_ns);
704 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000,
705 &remainder));
706 nano_seconds = (u32)remainder;
707 if (nano_seconds > 0) {
708 /* subtracting nano seconds is not allowed
709 * convert to subtracting from seconds,
710 * and adding to nanoseconds
711 */
712 seconds--;
713 nano_seconds = (1000000000 - nano_seconds);
714 }
715 }
716
717 if (nano_seconds > 0) {
718 /* add 8 ns to cover the likely normal increment */
719 nano_seconds += 8;
720 }
721
722 if (nano_seconds >= 1000000000) {
723 /* carry into seconds */
724 seconds++;
725 nano_seconds -= 1000000000;
726 }
727
728 while (seconds) {
729 mutex_lock(&ptp->command_lock);
730 if (seconds > 0) {
731 u32 adjustment_value = (u32)seconds;
732
733 if (adjustment_value > 0xF)
734 adjustment_value = 0xF;
735 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
736 PTP_CLOCK_STEP_ADJ_DIR_ |
737 adjustment_value);
738 seconds -= ((s32)adjustment_value);
739 } else {
740 u32 adjustment_value = (u32)(-seconds);
741
742 if (adjustment_value > 0xF)
743 adjustment_value = 0xF;
744 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
745 adjustment_value);
746 seconds += ((s32)adjustment_value);
747 }
748 lan743x_csr_write(adapter, PTP_CMD_CTL,
749 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
750 lan743x_ptp_wait_till_cmd_done(adapter,
751 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
752 mutex_unlock(&ptp->command_lock);
753 }
754 if (nano_seconds) {
755 mutex_lock(&ptp->command_lock);
756 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
757 PTP_CLOCK_STEP_ADJ_DIR_ |
758 (nano_seconds &
759 PTP_CLOCK_STEP_ADJ_VALUE_MASK_));
760 lan743x_csr_write(adapter, PTP_CMD_CTL,
761 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
762 lan743x_ptp_wait_till_cmd_done(adapter,
763 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
764 mutex_unlock(&ptp->command_lock);
765 }
766}
767
768void lan743x_ptp_isr(void *context)
769{
770 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context;
771 struct lan743x_ptp *ptp = NULL;
772 int enable_flag = 1;
773 u32 ptp_int_sts = 0;
774
775 ptp = &adapter->ptp;
776
777 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
778
779 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
780 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET);
781
782 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) {
783 ptp_schedule_worker(ptp->ptp_clock, 0);
784 enable_flag = 0;/* tasklet will re-enable later */
785 }
786 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) {
787 netif_err(adapter, drv, adapter->netdev,
788 "PTP TX Software Timestamp Error\n");
789 /* clear int status bit */
790 lan743x_csr_write(adapter, PTP_INT_STS,
791 PTP_INT_BIT_TX_SWTS_ERR_);
792 }
793 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) {
794 /* clear int status bit */
795 lan743x_csr_write(adapter, PTP_INT_STS,
796 PTP_INT_BIT_TIMER_B_);
797 }
798 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) {
799 /* clear int status bit */
800 lan743x_csr_write(adapter, PTP_INT_STS,
801 PTP_INT_BIT_TIMER_A_);
802 }
803
804 if (enable_flag) {
805 /* re-enable isr */
806 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
807 }
808}
809
810static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter,
811 struct sk_buff *skb, bool ignore_sync)
812{
813 struct lan743x_ptp *ptp = &adapter->ptp;
814
815 spin_lock_bh(&ptp->tx_ts_lock);
816 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
817 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb;
818 if (ignore_sync)
819 ptp->tx_ts_ignore_sync_queue |=
820 BIT(ptp->tx_ts_skb_queue_size);
821 ptp->tx_ts_skb_queue_size++;
822 } else {
823 /* this should never happen, so long as the tx channel
824 * calls and honors the result from
825 * lan743x_ptp_request_tx_timestamp
826 */
827 netif_err(adapter, drv, adapter->netdev,
828 "tx ts skb queue overflow\n");
829 dev_kfree_skb(skb);
830 }
831 spin_unlock_bh(&ptp->tx_ts_lock);
832}
833
834static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter)
835{
836 struct timespec64 ts;
837
838 ktime_get_clocktai_ts64(&ts);
839
840 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0);
841}
842
843void lan743x_ptp_update_latency(struct lan743x_adapter *adapter,
844 u32 link_speed)
845{
846 switch (link_speed) {
847 case 10:
848 lan743x_csr_write(adapter, PTP_LATENCY,
849 PTP_LATENCY_TX_SET_(0) |
850 PTP_LATENCY_RX_SET_(0));
851 break;
852 case 100:
853 lan743x_csr_write(adapter, PTP_LATENCY,
854 PTP_LATENCY_TX_SET_(181) |
855 PTP_LATENCY_RX_SET_(594));
856 break;
857 case 1000:
858 lan743x_csr_write(adapter, PTP_LATENCY,
859 PTP_LATENCY_TX_SET_(30) |
860 PTP_LATENCY_RX_SET_(525));
861 break;
862 }
863}
864
865int lan743x_ptp_init(struct lan743x_adapter *adapter)
866{
867 struct lan743x_ptp *ptp = &adapter->ptp;
868
869 mutex_init(&ptp->command_lock);
870 spin_lock_init(&ptp->tx_ts_lock);
871 ptp->used_event_ch = 0;
872 ptp->perout_event_ch = -1;
873 ptp->perout_gpio_bit = -1;
874 return 0;
875}
876
877int lan743x_ptp_open(struct lan743x_adapter *adapter)
878{
879 struct lan743x_ptp *ptp = &adapter->ptp;
880 int ret = -ENODEV;
881 u32 temp;
882
883 lan743x_ptp_reset(adapter);
884 lan743x_ptp_sync_to_system_clock(adapter);
885 temp = lan743x_csr_read(adapter, PTP_TX_MOD2);
886 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_;
887 lan743x_csr_write(adapter, PTP_TX_MOD2, temp);
888 lan743x_ptp_enable(adapter);
889 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
890 lan743x_csr_write(adapter, PTP_INT_EN_SET,
891 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_);
892 ptp->flags |= PTP_FLAG_ISR_ENABLED;
893
894 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK))
895 return 0;
896
897 snprintf(ptp->pin_config[0].name, 32, "lan743x_ptp_pin_0");
898 ptp->pin_config[0].index = 0;
899 ptp->pin_config[0].func = PTP_PF_PEROUT;
900 ptp->pin_config[0].chan = 0;
901
902 ptp->ptp_clock_info.owner = THIS_MODULE;
903 snprintf(ptp->ptp_clock_info.name, 16, "%pm",
904 adapter->netdev->dev_addr);
905 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB;
906 ptp->ptp_clock_info.n_alarm = 0;
907 ptp->ptp_clock_info.n_ext_ts = 0;
908 ptp->ptp_clock_info.n_per_out = 1;
909 ptp->ptp_clock_info.n_pins = 0;
910 ptp->ptp_clock_info.pps = 0;
911 ptp->ptp_clock_info.pin_config = NULL;
912 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine;
913 ptp->ptp_clock_info.adjfreq = lan743x_ptpci_adjfreq;
914 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime;
915 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64;
916 ptp->ptp_clock_info.getcrosststamp = NULL;
917 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64;
918 ptp->ptp_clock_info.enable = lan743x_ptpci_enable;
919 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work;
920 ptp->ptp_clock_info.verify = NULL;
921
922 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info,
923 &adapter->pdev->dev);
924
925 if (IS_ERR(ptp->ptp_clock)) {
926 netif_err(adapter, ifup, adapter->netdev,
927 "ptp_clock_register failed\n");
928 goto done;
929 }
930 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED;
931 netif_info(adapter, ifup, adapter->netdev,
932 "successfully registered ptp clock\n");
933
934 return 0;
935done:
936 lan743x_ptp_close(adapter);
937 return ret;
938}
939
940void lan743x_ptp_close(struct lan743x_adapter *adapter)
941{
942 struct lan743x_ptp *ptp = &adapter->ptp;
943 int index;
944
945 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) &&
946 ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED) {
947 ptp_clock_unregister(ptp->ptp_clock);
948 ptp->ptp_clock = NULL;
949 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED;
950 netif_info(adapter, drv, adapter->netdev,
951 "ptp clock unregister\n");
952 }
953
954 if (ptp->flags & PTP_FLAG_ISR_ENABLED) {
955 lan743x_csr_write(adapter, PTP_INT_EN_CLR,
956 PTP_INT_BIT_TX_SWTS_ERR_ |
957 PTP_INT_BIT_TX_TS_);
958 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
959 ptp->flags &= ~PTP_FLAG_ISR_ENABLED;
960 }
961
962 /* clean up pending timestamp requests */
963 lan743x_ptp_tx_ts_complete(adapter);
964 spin_lock_bh(&ptp->tx_ts_lock);
965 for (index = 0;
966 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS;
967 index++) {
968 struct sk_buff *skb = ptp->tx_ts_skb_queue[index];
969
970 dev_kfree_skb(skb);
971 ptp->tx_ts_skb_queue[index] = NULL;
972 ptp->tx_ts_seconds_queue[index] = 0;
973 ptp->tx_ts_nseconds_queue[index] = 0;
974 }
975 ptp->tx_ts_skb_queue_size = 0;
976 ptp->tx_ts_queue_size = 0;
977 ptp->pending_tx_timestamps = 0;
978 spin_unlock_bh(&ptp->tx_ts_lock);
979
980 lan743x_ptp_disable(adapter);
981}
982
983static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter,
984 bool ts_insert_enable)
985{
986 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD);
987
988 if (ts_insert_enable)
989 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
990 else
991 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
992
993 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod);
994}
995
996static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter)
997{
998 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_)
999 return true;
1000 return false;
1001}
1002
1003static void lan743x_ptp_enable(struct lan743x_adapter *adapter)
1004{
1005 struct lan743x_ptp *ptp = &adapter->ptp;
1006
1007 mutex_lock(&ptp->command_lock);
1008
1009 if (lan743x_ptp_is_enabled(adapter)) {
1010 netif_warn(adapter, drv, adapter->netdev,
1011 "PTP already enabled\n");
1012 goto done;
1013 }
1014 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_);
1015done:
1016 mutex_unlock(&ptp->command_lock);
1017}
1018
1019static void lan743x_ptp_disable(struct lan743x_adapter *adapter)
1020{
1021 struct lan743x_ptp *ptp = &adapter->ptp;
1022
1023 mutex_lock(&ptp->command_lock);
1024 if (!lan743x_ptp_is_enabled(adapter)) {
1025 netif_warn(adapter, drv, adapter->netdev,
1026 "PTP already disabled\n");
1027 goto done;
1028 }
1029 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_);
1030 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_);
1031done:
1032 mutex_unlock(&ptp->command_lock);
1033}
1034
1035static void lan743x_ptp_reset(struct lan743x_adapter *adapter)
1036{
1037 struct lan743x_ptp *ptp = &adapter->ptp;
1038
1039 mutex_lock(&ptp->command_lock);
1040
1041 if (lan743x_ptp_is_enabled(adapter)) {
1042 netif_err(adapter, drv, adapter->netdev,
1043 "Attempting reset while enabled\n");
1044 goto done;
1045 }
1046
1047 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_);
1048 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_);
1049done:
1050 mutex_unlock(&ptp->command_lock);
1051}
1052
1053static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
1054 u32 seconds, u32 nano_seconds,
1055 u32 sub_nano_seconds)
1056{
1057 struct lan743x_ptp *ptp = &adapter->ptp;
1058
1059 mutex_lock(&ptp->command_lock);
1060
1061 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds);
1062 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds);
1063 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds);
1064
1065 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1066 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1067 mutex_unlock(&ptp->command_lock);
1068}
1069
1070bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter)
1071{
1072 struct lan743x_ptp *ptp = &adapter->ptp;
1073 bool result = false;
1074
1075 spin_lock_bh(&ptp->tx_ts_lock);
1076 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
1077 /* request granted */
1078 ptp->pending_tx_timestamps++;
1079 result = true;
1080 }
1081 spin_unlock_bh(&ptp->tx_ts_lock);
1082 return result;
1083}
1084
1085void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter)
1086{
1087 struct lan743x_ptp *ptp = &adapter->ptp;
1088
1089 spin_lock_bh(&ptp->tx_ts_lock);
1090 if (ptp->pending_tx_timestamps > 0)
1091 ptp->pending_tx_timestamps--;
1092 else
1093 netif_err(adapter, drv, adapter->netdev,
1094 "unrequest failed, pending_tx_timestamps==0\n");
1095 spin_unlock_bh(&ptp->tx_ts_lock);
1096}
1097
1098void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter,
1099 struct sk_buff *skb, bool ignore_sync)
1100{
1101 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync);
1102
1103 lan743x_ptp_tx_ts_complete(adapter);
1104}
1105
1106int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1107{
1108 struct lan743x_adapter *adapter = netdev_priv(netdev);
1109 struct hwtstamp_config config;
1110 int ret = 0;
1111 int index;
1112
1113 if (!ifr) {
1114 netif_err(adapter, drv, adapter->netdev,
1115 "SIOCSHWTSTAMP, ifr == NULL\n");
1116 return -EINVAL;
1117 }
1118
1119 if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
1120 return -EFAULT;
1121
1122 if (config.flags) {
1123 netif_warn(adapter, drv, adapter->netdev,
1124 "ignoring hwtstamp_config.flags == 0x%08X, expected 0\n",
1125 config.flags);
1126 }
1127
1128 switch (config.tx_type) {
1129 case HWTSTAMP_TX_OFF:
1130 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1131 index++)
1132 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1133 false, false);
1134 lan743x_ptp_set_sync_ts_insert(adapter, false);
1135 break;
1136 case HWTSTAMP_TX_ON:
1137 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1138 index++)
1139 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1140 true, false);
1141 lan743x_ptp_set_sync_ts_insert(adapter, false);
1142 break;
1143 case HWTSTAMP_TX_ONESTEP_SYNC:
1144 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1145 index++)
1146 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1147 true, true);
1148
1149 lan743x_ptp_set_sync_ts_insert(adapter, true);
1150 break;
1151 default:
1152 netif_warn(adapter, drv, adapter->netdev,
1153 " tx_type = %d, UNKNOWN\n", config.tx_type);
1154 ret = -EINVAL;
1155 break;
1156 }
1157
1158 if (!ret)
1159 return copy_to_user(ifr->ifr_data, &config,
1160 sizeof(config)) ? -EFAULT : 0;
1161 return ret;
1162}
1/* SPDX-License-Identifier: GPL-2.0+ */
2/* Copyright (C) 2018 Microchip Technology Inc. */
3
4#include <linux/netdevice.h>
5
6#include <linux/ptp_clock_kernel.h>
7#include <linux/module.h>
8#include <linux/pci.h>
9#include <linux/net_tstamp.h>
10#include "lan743x_main.h"
11
12#include "lan743x_ptp.h"
13
14#define LAN743X_LED0_ENABLE 20 /* LED0 offset in HW_CFG */
15#define LAN743X_LED_ENABLE(pin) BIT(LAN743X_LED0_ENABLE + (pin))
16
17#define LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB (31249999)
18#define LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM (2047999934)
19
20static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter);
21static void lan743x_ptp_enable(struct lan743x_adapter *adapter);
22static void lan743x_ptp_disable(struct lan743x_adapter *adapter);
23static void lan743x_ptp_reset(struct lan743x_adapter *adapter);
24static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
25 u32 seconds, u32 nano_seconds,
26 u32 sub_nano_seconds);
27
28int lan743x_gpio_init(struct lan743x_adapter *adapter)
29{
30 struct lan743x_gpio *gpio = &adapter->gpio;
31
32 spin_lock_init(&gpio->gpio_lock);
33
34 gpio->gpio_cfg0 = 0; /* set all direction to input, data = 0 */
35 gpio->gpio_cfg1 = 0x0FFF0000;/* disable all gpio, set to open drain */
36 gpio->gpio_cfg2 = 0;/* set all to 1588 low polarity level */
37 gpio->gpio_cfg3 = 0;/* disable all 1588 output */
38 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
39 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
40 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
41 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
42
43 return 0;
44}
45
46static void lan743x_ptp_wait_till_cmd_done(struct lan743x_adapter *adapter,
47 u32 bit_mask)
48{
49 int timeout = 1000;
50 u32 data = 0;
51
52 while (timeout &&
53 (data = (lan743x_csr_read(adapter, PTP_CMD_CTL) &
54 bit_mask))) {
55 usleep_range(1000, 20000);
56 timeout--;
57 }
58 if (data) {
59 netif_err(adapter, drv, adapter->netdev,
60 "timeout waiting for cmd to be done, cmd = 0x%08X\n",
61 bit_mask);
62 }
63}
64
65static void lan743x_ptp_tx_ts_enqueue_ts(struct lan743x_adapter *adapter,
66 u32 seconds, u32 nano_seconds,
67 u32 header)
68{
69 struct lan743x_ptp *ptp = &adapter->ptp;
70
71 spin_lock_bh(&ptp->tx_ts_lock);
72 if (ptp->tx_ts_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
73 ptp->tx_ts_seconds_queue[ptp->tx_ts_queue_size] = seconds;
74 ptp->tx_ts_nseconds_queue[ptp->tx_ts_queue_size] = nano_seconds;
75 ptp->tx_ts_header_queue[ptp->tx_ts_queue_size] = header;
76 ptp->tx_ts_queue_size++;
77 } else {
78 netif_err(adapter, drv, adapter->netdev,
79 "tx ts queue overflow\n");
80 }
81 spin_unlock_bh(&ptp->tx_ts_lock);
82}
83
84static void lan743x_ptp_tx_ts_complete(struct lan743x_adapter *adapter)
85{
86 struct lan743x_ptp *ptp = &adapter->ptp;
87 struct skb_shared_hwtstamps tstamps;
88 u32 header, nseconds, seconds;
89 bool ignore_sync = false;
90 struct sk_buff *skb;
91 int c, i;
92
93 spin_lock_bh(&ptp->tx_ts_lock);
94 c = ptp->tx_ts_skb_queue_size;
95
96 if (c > ptp->tx_ts_queue_size)
97 c = ptp->tx_ts_queue_size;
98 if (c <= 0)
99 goto done;
100
101 for (i = 0; i < c; i++) {
102 ignore_sync = ((ptp->tx_ts_ignore_sync_queue &
103 BIT(i)) != 0);
104 skb = ptp->tx_ts_skb_queue[i];
105 nseconds = ptp->tx_ts_nseconds_queue[i];
106 seconds = ptp->tx_ts_seconds_queue[i];
107 header = ptp->tx_ts_header_queue[i];
108
109 memset(&tstamps, 0, sizeof(tstamps));
110 tstamps.hwtstamp = ktime_set(seconds, nseconds);
111 if (!ignore_sync ||
112 ((header & PTP_TX_MSG_HEADER_MSG_TYPE_) !=
113 PTP_TX_MSG_HEADER_MSG_TYPE_SYNC_))
114 skb_tstamp_tx(skb, &tstamps);
115
116 dev_kfree_skb(skb);
117
118 ptp->tx_ts_skb_queue[i] = NULL;
119 ptp->tx_ts_seconds_queue[i] = 0;
120 ptp->tx_ts_nseconds_queue[i] = 0;
121 ptp->tx_ts_header_queue[i] = 0;
122 }
123
124 /* shift queue */
125 ptp->tx_ts_ignore_sync_queue >>= c;
126 for (i = c; i < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; i++) {
127 ptp->tx_ts_skb_queue[i - c] = ptp->tx_ts_skb_queue[i];
128 ptp->tx_ts_seconds_queue[i - c] = ptp->tx_ts_seconds_queue[i];
129 ptp->tx_ts_nseconds_queue[i - c] = ptp->tx_ts_nseconds_queue[i];
130 ptp->tx_ts_header_queue[i - c] = ptp->tx_ts_header_queue[i];
131
132 ptp->tx_ts_skb_queue[i] = NULL;
133 ptp->tx_ts_seconds_queue[i] = 0;
134 ptp->tx_ts_nseconds_queue[i] = 0;
135 ptp->tx_ts_header_queue[i] = 0;
136 }
137 ptp->tx_ts_skb_queue_size -= c;
138 ptp->tx_ts_queue_size -= c;
139done:
140 ptp->pending_tx_timestamps -= c;
141 spin_unlock_bh(&ptp->tx_ts_lock);
142}
143
144static int lan743x_ptp_reserve_event_ch(struct lan743x_adapter *adapter,
145 int event_channel)
146{
147 struct lan743x_ptp *ptp = &adapter->ptp;
148 int result = -ENODEV;
149
150 mutex_lock(&ptp->command_lock);
151 if (!(test_bit(event_channel, &ptp->used_event_ch))) {
152 ptp->used_event_ch |= BIT(event_channel);
153 result = event_channel;
154 } else {
155 netif_warn(adapter, drv, adapter->netdev,
156 "attempted to reserved a used event_channel = %d\n",
157 event_channel);
158 }
159 mutex_unlock(&ptp->command_lock);
160 return result;
161}
162
163static void lan743x_ptp_release_event_ch(struct lan743x_adapter *adapter,
164 int event_channel)
165{
166 struct lan743x_ptp *ptp = &adapter->ptp;
167
168 mutex_lock(&ptp->command_lock);
169 if (test_bit(event_channel, &ptp->used_event_ch)) {
170 ptp->used_event_ch &= ~BIT(event_channel);
171 } else {
172 netif_warn(adapter, drv, adapter->netdev,
173 "attempted release on a not used event_channel = %d\n",
174 event_channel);
175 }
176 mutex_unlock(&ptp->command_lock);
177}
178
179static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
180 u32 *seconds, u32 *nano_seconds,
181 u32 *sub_nano_seconds);
182static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
183 s64 time_step_ns);
184
185static void lan743x_led_mux_enable(struct lan743x_adapter *adapter,
186 int pin, bool enable)
187{
188 struct lan743x_ptp *ptp = &adapter->ptp;
189
190 if (ptp->leds_multiplexed &&
191 ptp->led_enabled[pin]) {
192 u32 val = lan743x_csr_read(adapter, HW_CFG);
193
194 if (enable)
195 val |= LAN743X_LED_ENABLE(pin);
196 else
197 val &= ~LAN743X_LED_ENABLE(pin);
198
199 lan743x_csr_write(adapter, HW_CFG, val);
200 }
201}
202
203static void lan743x_led_mux_save(struct lan743x_adapter *adapter)
204{
205 struct lan743x_ptp *ptp = &adapter->ptp;
206 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_;
207
208 if (id_rev == ID_REV_ID_LAN7430_) {
209 int i;
210 u32 val = lan743x_csr_read(adapter, HW_CFG);
211
212 for (i = 0; i < LAN7430_N_LED; i++) {
213 bool led_enabled = (val & LAN743X_LED_ENABLE(i)) != 0;
214
215 ptp->led_enabled[i] = led_enabled;
216 }
217 ptp->leds_multiplexed = true;
218 } else {
219 ptp->leds_multiplexed = false;
220 }
221}
222
223static void lan743x_led_mux_restore(struct lan743x_adapter *adapter)
224{
225 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_;
226
227 if (id_rev == ID_REV_ID_LAN7430_) {
228 int i;
229
230 for (i = 0; i < LAN7430_N_LED; i++)
231 lan743x_led_mux_enable(adapter, i, true);
232 }
233}
234
235static int lan743x_gpio_rsrv_ptp_out(struct lan743x_adapter *adapter,
236 int pin, int event_channel)
237{
238 struct lan743x_gpio *gpio = &adapter->gpio;
239 unsigned long irq_flags = 0;
240 int bit_mask = BIT(pin);
241 int ret = -EBUSY;
242
243 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
244
245 if (!(gpio->used_bits & bit_mask)) {
246 gpio->used_bits |= bit_mask;
247 gpio->output_bits |= bit_mask;
248 gpio->ptp_bits |= bit_mask;
249
250 /* assign pin to GPIO function */
251 lan743x_led_mux_enable(adapter, pin, false);
252
253 /* set as output, and zero initial value */
254 gpio->gpio_cfg0 |= GPIO_CFG0_GPIO_DIR_BIT_(pin);
255 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin);
256 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
257
258 /* enable gpio, and set buffer type to push pull */
259 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOEN_BIT_(pin);
260 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOBUF_BIT_(pin);
261 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
262
263 /* set 1588 polarity to high */
264 gpio->gpio_cfg2 |= GPIO_CFG2_1588_POL_BIT_(pin);
265 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
266
267 if (event_channel == 0) {
268 /* use channel A */
269 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_CH_SEL_BIT_(pin);
270 } else {
271 /* use channel B */
272 gpio->gpio_cfg3 |= GPIO_CFG3_1588_CH_SEL_BIT_(pin);
273 }
274 gpio->gpio_cfg3 |= GPIO_CFG3_1588_OE_BIT_(pin);
275 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
276
277 ret = pin;
278 }
279 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
280 return ret;
281}
282
283static void lan743x_gpio_release(struct lan743x_adapter *adapter, int pin)
284{
285 struct lan743x_gpio *gpio = &adapter->gpio;
286 unsigned long irq_flags = 0;
287 int bit_mask = BIT(pin);
288
289 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
290 if (gpio->used_bits & bit_mask) {
291 gpio->used_bits &= ~bit_mask;
292 if (gpio->output_bits & bit_mask) {
293 gpio->output_bits &= ~bit_mask;
294
295 if (gpio->ptp_bits & bit_mask) {
296 gpio->ptp_bits &= ~bit_mask;
297 /* disable ptp output */
298 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_OE_BIT_(pin);
299 lan743x_csr_write(adapter, GPIO_CFG3,
300 gpio->gpio_cfg3);
301 }
302 /* release gpio output */
303
304 /* disable gpio */
305 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOEN_BIT_(pin);
306 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOBUF_BIT_(pin);
307 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
308
309 /* reset back to input */
310 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DIR_BIT_(pin);
311 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin);
312 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
313
314 /* assign pin to original function */
315 lan743x_led_mux_enable(adapter, pin, true);
316 }
317 }
318 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
319}
320
321static int lan743x_ptpci_adjfine(struct ptp_clock_info *ptpci, long scaled_ppm)
322{
323 struct lan743x_ptp *ptp =
324 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
325 struct lan743x_adapter *adapter =
326 container_of(ptp, struct lan743x_adapter, ptp);
327 u32 lan743x_rate_adj = 0;
328 bool positive = true;
329 u64 u64_delta = 0;
330
331 if ((scaled_ppm < (-LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM)) ||
332 scaled_ppm > LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM) {
333 return -EINVAL;
334 }
335 if (scaled_ppm > 0) {
336 u64_delta = (u64)scaled_ppm;
337 positive = true;
338 } else {
339 u64_delta = (u64)(-scaled_ppm);
340 positive = false;
341 }
342 u64_delta = (u64_delta << 19);
343 lan743x_rate_adj = div_u64(u64_delta, 1000000);
344
345 if (positive)
346 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_;
347
348 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ,
349 lan743x_rate_adj);
350
351 return 0;
352}
353
354static int lan743x_ptpci_adjfreq(struct ptp_clock_info *ptpci, s32 delta_ppb)
355{
356 struct lan743x_ptp *ptp =
357 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
358 struct lan743x_adapter *adapter =
359 container_of(ptp, struct lan743x_adapter, ptp);
360 u32 lan743x_rate_adj = 0;
361 bool positive = true;
362 u32 u32_delta = 0;
363 u64 u64_delta = 0;
364
365 if ((delta_ppb < (-LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB)) ||
366 delta_ppb > LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB) {
367 return -EINVAL;
368 }
369 if (delta_ppb > 0) {
370 u32_delta = (u32)delta_ppb;
371 positive = true;
372 } else {
373 u32_delta = (u32)(-delta_ppb);
374 positive = false;
375 }
376 u64_delta = (((u64)u32_delta) << 35);
377 lan743x_rate_adj = div_u64(u64_delta, 1000000000);
378
379 if (positive)
380 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_;
381
382 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ,
383 lan743x_rate_adj);
384
385 return 0;
386}
387
388static int lan743x_ptpci_adjtime(struct ptp_clock_info *ptpci, s64 delta)
389{
390 struct lan743x_ptp *ptp =
391 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
392 struct lan743x_adapter *adapter =
393 container_of(ptp, struct lan743x_adapter, ptp);
394
395 lan743x_ptp_clock_step(adapter, delta);
396
397 return 0;
398}
399
400static int lan743x_ptpci_gettime64(struct ptp_clock_info *ptpci,
401 struct timespec64 *ts)
402{
403 struct lan743x_ptp *ptp =
404 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
405 struct lan743x_adapter *adapter =
406 container_of(ptp, struct lan743x_adapter, ptp);
407 u32 nano_seconds = 0;
408 u32 seconds = 0;
409
410 lan743x_ptp_clock_get(adapter, &seconds, &nano_seconds, NULL);
411 ts->tv_sec = seconds;
412 ts->tv_nsec = nano_seconds;
413
414 return 0;
415}
416
417static int lan743x_ptpci_settime64(struct ptp_clock_info *ptpci,
418 const struct timespec64 *ts)
419{
420 struct lan743x_ptp *ptp =
421 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
422 struct lan743x_adapter *adapter =
423 container_of(ptp, struct lan743x_adapter, ptp);
424 u32 nano_seconds = 0;
425 u32 seconds = 0;
426
427 if (ts) {
428 if (ts->tv_sec > 0xFFFFFFFFLL ||
429 ts->tv_sec < 0) {
430 netif_warn(adapter, drv, adapter->netdev,
431 "ts->tv_sec out of range, %lld\n",
432 ts->tv_sec);
433 return -ERANGE;
434 }
435 if (ts->tv_nsec >= 1000000000L ||
436 ts->tv_nsec < 0) {
437 netif_warn(adapter, drv, adapter->netdev,
438 "ts->tv_nsec out of range, %ld\n",
439 ts->tv_nsec);
440 return -ERANGE;
441 }
442 seconds = ts->tv_sec;
443 nano_seconds = ts->tv_nsec;
444 lan743x_ptp_clock_set(adapter, seconds, nano_seconds, 0);
445 } else {
446 netif_warn(adapter, drv, adapter->netdev, "ts == NULL\n");
447 return -EINVAL;
448 }
449
450 return 0;
451}
452
453static void lan743x_ptp_perout_off(struct lan743x_adapter *adapter,
454 unsigned int index)
455{
456 struct lan743x_ptp *ptp = &adapter->ptp;
457 u32 general_config = 0;
458 struct lan743x_ptp_perout *perout = &ptp->perout[index];
459
460 if (perout->gpio_pin >= 0) {
461 lan743x_gpio_release(adapter, perout->gpio_pin);
462 perout->gpio_pin = -1;
463 }
464
465 if (perout->event_ch >= 0) {
466 /* set target to far in the future, effectively disabling it */
467 lan743x_csr_write(adapter,
468 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
469 0xFFFF0000);
470 lan743x_csr_write(adapter,
471 PTP_CLOCK_TARGET_NS_X(perout->event_ch),
472 0);
473
474 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
475 general_config |= PTP_GENERAL_CONFIG_RELOAD_ADD_X_
476 (perout->event_ch);
477 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
478 lan743x_ptp_release_event_ch(adapter, perout->event_ch);
479 perout->event_ch = -1;
480 }
481}
482
483static int lan743x_ptp_perout(struct lan743x_adapter *adapter, int on,
484 struct ptp_perout_request *perout_request)
485{
486 struct lan743x_ptp *ptp = &adapter->ptp;
487 u32 period_sec = 0, period_nsec = 0;
488 u32 start_sec = 0, start_nsec = 0;
489 u32 general_config = 0;
490 int pulse_width = 0;
491 int perout_pin = 0;
492 unsigned int index = perout_request->index;
493 struct lan743x_ptp_perout *perout = &ptp->perout[index];
494
495 /* Reject requests with unsupported flags */
496 if (perout_request->flags)
497 return -EOPNOTSUPP;
498
499 if (on) {
500 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT,
501 perout_request->index);
502 if (perout_pin < 0)
503 return -EBUSY;
504 } else {
505 lan743x_ptp_perout_off(adapter, index);
506 return 0;
507 }
508
509 if (perout->event_ch >= 0 ||
510 perout->gpio_pin >= 0) {
511 /* already on, turn off first */
512 lan743x_ptp_perout_off(adapter, index);
513 }
514
515 perout->event_ch = lan743x_ptp_reserve_event_ch(adapter, index);
516
517 if (perout->event_ch < 0) {
518 netif_warn(adapter, drv, adapter->netdev,
519 "Failed to reserve event channel %d for PEROUT\n",
520 index);
521 goto failed;
522 }
523
524 perout->gpio_pin = lan743x_gpio_rsrv_ptp_out(adapter,
525 perout_pin,
526 perout->event_ch);
527
528 if (perout->gpio_pin < 0) {
529 netif_warn(adapter, drv, adapter->netdev,
530 "Failed to reserve gpio %d for PEROUT\n",
531 perout_pin);
532 goto failed;
533 }
534
535 start_sec = perout_request->start.sec;
536 start_sec += perout_request->start.nsec / 1000000000;
537 start_nsec = perout_request->start.nsec % 1000000000;
538
539 period_sec = perout_request->period.sec;
540 period_sec += perout_request->period.nsec / 1000000000;
541 period_nsec = perout_request->period.nsec % 1000000000;
542
543 if (period_sec == 0) {
544 if (period_nsec >= 400000000) {
545 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
546 } else if (period_nsec >= 20000000) {
547 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
548 } else if (period_nsec >= 2000000) {
549 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
550 } else if (period_nsec >= 200000) {
551 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
552 } else if (period_nsec >= 20000) {
553 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
554 } else if (period_nsec >= 200) {
555 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
556 } else {
557 netif_warn(adapter, drv, adapter->netdev,
558 "perout period too small, minimum is 200nS\n");
559 goto failed;
560 }
561 } else {
562 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
563 }
564
565 /* turn off by setting target far in future */
566 lan743x_csr_write(adapter,
567 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
568 0xFFFF0000);
569 lan743x_csr_write(adapter,
570 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 0);
571
572 /* Configure to pulse every period */
573 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
574 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_
575 (perout->event_ch));
576 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_
577 (perout->event_ch, pulse_width);
578 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_
579 (perout->event_ch);
580 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
581
582 /* set the reload to one toggle cycle */
583 lan743x_csr_write(adapter,
584 PTP_CLOCK_TARGET_RELOAD_SEC_X(perout->event_ch),
585 period_sec);
586 lan743x_csr_write(adapter,
587 PTP_CLOCK_TARGET_RELOAD_NS_X(perout->event_ch),
588 period_nsec);
589
590 /* set the start time */
591 lan743x_csr_write(adapter,
592 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
593 start_sec);
594 lan743x_csr_write(adapter,
595 PTP_CLOCK_TARGET_NS_X(perout->event_ch),
596 start_nsec);
597
598 return 0;
599
600failed:
601 lan743x_ptp_perout_off(adapter, index);
602 return -ENODEV;
603}
604
605static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci,
606 struct ptp_clock_request *request, int on)
607{
608 struct lan743x_ptp *ptp =
609 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
610 struct lan743x_adapter *adapter =
611 container_of(ptp, struct lan743x_adapter, ptp);
612
613 if (request) {
614 switch (request->type) {
615 case PTP_CLK_REQ_EXTTS:
616 return -EINVAL;
617 case PTP_CLK_REQ_PEROUT:
618 if (request->perout.index < ptpci->n_per_out)
619 return lan743x_ptp_perout(adapter, on,
620 &request->perout);
621 return -EINVAL;
622 case PTP_CLK_REQ_PPS:
623 return -EINVAL;
624 default:
625 netif_err(adapter, drv, adapter->netdev,
626 "request->type == %d, Unknown\n",
627 request->type);
628 break;
629 }
630 } else {
631 netif_err(adapter, drv, adapter->netdev, "request == NULL\n");
632 }
633 return 0;
634}
635
636static int lan743x_ptpci_verify_pin_config(struct ptp_clock_info *ptp,
637 unsigned int pin,
638 enum ptp_pin_function func,
639 unsigned int chan)
640{
641 int result = 0;
642
643 /* Confirm the requested function is supported. Parameter
644 * validation is done by the caller.
645 */
646 switch (func) {
647 case PTP_PF_NONE:
648 case PTP_PF_PEROUT:
649 break;
650 case PTP_PF_EXTTS:
651 case PTP_PF_PHYSYNC:
652 default:
653 result = -1;
654 break;
655 }
656 return result;
657}
658
659static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci)
660{
661 struct lan743x_ptp *ptp =
662 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
663 struct lan743x_adapter *adapter =
664 container_of(ptp, struct lan743x_adapter, ptp);
665 u32 cap_info, cause, header, nsec, seconds;
666 bool new_timestamp_available = false;
667 int count = 0;
668
669 while ((count < 100) &&
670 (lan743x_csr_read(adapter, PTP_INT_STS) & PTP_INT_BIT_TX_TS_)) {
671 count++;
672 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO);
673
674 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) {
675 seconds = lan743x_csr_read(adapter,
676 PTP_TX_EGRESS_SEC);
677 nsec = lan743x_csr_read(adapter, PTP_TX_EGRESS_NS);
678 cause = (nsec &
679 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_);
680 header = lan743x_csr_read(adapter,
681 PTP_TX_MSG_HEADER);
682
683 if (cause == PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) {
684 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_;
685 lan743x_ptp_tx_ts_enqueue_ts(adapter,
686 seconds, nsec,
687 header);
688 new_timestamp_available = true;
689 } else if (cause ==
690 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) {
691 netif_err(adapter, drv, adapter->netdev,
692 "Auto capture cause not supported\n");
693 } else {
694 netif_warn(adapter, drv, adapter->netdev,
695 "unknown tx timestamp capture cause\n");
696 }
697 } else {
698 netif_warn(adapter, drv, adapter->netdev,
699 "TX TS INT but no TX TS CNT\n");
700 }
701 lan743x_csr_write(adapter, PTP_INT_STS, PTP_INT_BIT_TX_TS_);
702 }
703
704 if (new_timestamp_available)
705 lan743x_ptp_tx_ts_complete(adapter);
706
707 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
708
709 return -1;
710}
711
712static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
713 u32 *seconds, u32 *nano_seconds,
714 u32 *sub_nano_seconds)
715{
716 struct lan743x_ptp *ptp = &adapter->ptp;
717
718 mutex_lock(&ptp->command_lock);
719
720 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_);
721 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_);
722
723 if (seconds)
724 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC);
725
726 if (nano_seconds)
727 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS);
728
729 if (sub_nano_seconds)
730 (*sub_nano_seconds) =
731 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS);
732
733 mutex_unlock(&ptp->command_lock);
734}
735
736static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
737 s64 time_step_ns)
738{
739 struct lan743x_ptp *ptp = &adapter->ptp;
740 u32 nano_seconds_step = 0;
741 u64 abs_time_step_ns = 0;
742 u32 unsigned_seconds = 0;
743 u32 nano_seconds = 0;
744 u32 remainder = 0;
745 s32 seconds = 0;
746
747 if (time_step_ns > 15000000000LL) {
748 /* convert to clock set */
749 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
750 &nano_seconds, NULL);
751 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL,
752 &remainder);
753 nano_seconds += remainder;
754 if (nano_seconds >= 1000000000) {
755 unsigned_seconds++;
756 nano_seconds -= 1000000000;
757 }
758 lan743x_ptp_clock_set(adapter, unsigned_seconds,
759 nano_seconds, 0);
760 return;
761 } else if (time_step_ns < -15000000000LL) {
762 /* convert to clock set */
763 time_step_ns = -time_step_ns;
764
765 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
766 &nano_seconds, NULL);
767 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL,
768 &remainder);
769 nano_seconds_step = remainder;
770 if (nano_seconds < nano_seconds_step) {
771 unsigned_seconds--;
772 nano_seconds += 1000000000;
773 }
774 nano_seconds -= nano_seconds_step;
775 lan743x_ptp_clock_set(adapter, unsigned_seconds,
776 nano_seconds, 0);
777 return;
778 }
779
780 /* do clock step */
781 if (time_step_ns >= 0) {
782 abs_time_step_ns = (u64)(time_step_ns);
783 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000,
784 &remainder);
785 nano_seconds = (u32)remainder;
786 } else {
787 abs_time_step_ns = (u64)(-time_step_ns);
788 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000,
789 &remainder));
790 nano_seconds = (u32)remainder;
791 if (nano_seconds > 0) {
792 /* subtracting nano seconds is not allowed
793 * convert to subtracting from seconds,
794 * and adding to nanoseconds
795 */
796 seconds--;
797 nano_seconds = (1000000000 - nano_seconds);
798 }
799 }
800
801 if (nano_seconds > 0) {
802 /* add 8 ns to cover the likely normal increment */
803 nano_seconds += 8;
804 }
805
806 if (nano_seconds >= 1000000000) {
807 /* carry into seconds */
808 seconds++;
809 nano_seconds -= 1000000000;
810 }
811
812 while (seconds) {
813 mutex_lock(&ptp->command_lock);
814 if (seconds > 0) {
815 u32 adjustment_value = (u32)seconds;
816
817 if (adjustment_value > 0xF)
818 adjustment_value = 0xF;
819 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
820 PTP_CLOCK_STEP_ADJ_DIR_ |
821 adjustment_value);
822 seconds -= ((s32)adjustment_value);
823 } else {
824 u32 adjustment_value = (u32)(-seconds);
825
826 if (adjustment_value > 0xF)
827 adjustment_value = 0xF;
828 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
829 adjustment_value);
830 seconds += ((s32)adjustment_value);
831 }
832 lan743x_csr_write(adapter, PTP_CMD_CTL,
833 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
834 lan743x_ptp_wait_till_cmd_done(adapter,
835 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
836 mutex_unlock(&ptp->command_lock);
837 }
838 if (nano_seconds) {
839 mutex_lock(&ptp->command_lock);
840 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
841 PTP_CLOCK_STEP_ADJ_DIR_ |
842 (nano_seconds &
843 PTP_CLOCK_STEP_ADJ_VALUE_MASK_));
844 lan743x_csr_write(adapter, PTP_CMD_CTL,
845 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
846 lan743x_ptp_wait_till_cmd_done(adapter,
847 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
848 mutex_unlock(&ptp->command_lock);
849 }
850}
851
852void lan743x_ptp_isr(void *context)
853{
854 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context;
855 struct lan743x_ptp *ptp = NULL;
856 int enable_flag = 1;
857 u32 ptp_int_sts = 0;
858
859 ptp = &adapter->ptp;
860
861 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
862
863 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
864 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET);
865
866 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) {
867 ptp_schedule_worker(ptp->ptp_clock, 0);
868 enable_flag = 0;/* tasklet will re-enable later */
869 }
870 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) {
871 netif_err(adapter, drv, adapter->netdev,
872 "PTP TX Software Timestamp Error\n");
873 /* clear int status bit */
874 lan743x_csr_write(adapter, PTP_INT_STS,
875 PTP_INT_BIT_TX_SWTS_ERR_);
876 }
877 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) {
878 /* clear int status bit */
879 lan743x_csr_write(adapter, PTP_INT_STS,
880 PTP_INT_BIT_TIMER_B_);
881 }
882 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) {
883 /* clear int status bit */
884 lan743x_csr_write(adapter, PTP_INT_STS,
885 PTP_INT_BIT_TIMER_A_);
886 }
887
888 if (enable_flag) {
889 /* re-enable isr */
890 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
891 }
892}
893
894static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter,
895 struct sk_buff *skb, bool ignore_sync)
896{
897 struct lan743x_ptp *ptp = &adapter->ptp;
898
899 spin_lock_bh(&ptp->tx_ts_lock);
900 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
901 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb;
902 if (ignore_sync)
903 ptp->tx_ts_ignore_sync_queue |=
904 BIT(ptp->tx_ts_skb_queue_size);
905 ptp->tx_ts_skb_queue_size++;
906 } else {
907 /* this should never happen, so long as the tx channel
908 * calls and honors the result from
909 * lan743x_ptp_request_tx_timestamp
910 */
911 netif_err(adapter, drv, adapter->netdev,
912 "tx ts skb queue overflow\n");
913 dev_kfree_skb(skb);
914 }
915 spin_unlock_bh(&ptp->tx_ts_lock);
916}
917
918static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter)
919{
920 struct timespec64 ts;
921
922 ktime_get_clocktai_ts64(&ts);
923
924 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0);
925}
926
927void lan743x_ptp_update_latency(struct lan743x_adapter *adapter,
928 u32 link_speed)
929{
930 switch (link_speed) {
931 case 10:
932 lan743x_csr_write(adapter, PTP_LATENCY,
933 PTP_LATENCY_TX_SET_(0) |
934 PTP_LATENCY_RX_SET_(0));
935 break;
936 case 100:
937 lan743x_csr_write(adapter, PTP_LATENCY,
938 PTP_LATENCY_TX_SET_(181) |
939 PTP_LATENCY_RX_SET_(594));
940 break;
941 case 1000:
942 lan743x_csr_write(adapter, PTP_LATENCY,
943 PTP_LATENCY_TX_SET_(30) |
944 PTP_LATENCY_RX_SET_(525));
945 break;
946 }
947}
948
949int lan743x_ptp_init(struct lan743x_adapter *adapter)
950{
951 struct lan743x_ptp *ptp = &adapter->ptp;
952 int i;
953
954 mutex_init(&ptp->command_lock);
955 spin_lock_init(&ptp->tx_ts_lock);
956 ptp->used_event_ch = 0;
957
958 for (i = 0; i < LAN743X_PTP_N_EVENT_CHAN; i++) {
959 ptp->perout[i].event_ch = -1;
960 ptp->perout[i].gpio_pin = -1;
961 }
962
963 lan743x_led_mux_save(adapter);
964
965 return 0;
966}
967
968int lan743x_ptp_open(struct lan743x_adapter *adapter)
969{
970 struct lan743x_ptp *ptp = &adapter->ptp;
971 int ret = -ENODEV;
972 u32 temp;
973 int i;
974 int n_pins;
975
976 lan743x_ptp_reset(adapter);
977 lan743x_ptp_sync_to_system_clock(adapter);
978 temp = lan743x_csr_read(adapter, PTP_TX_MOD2);
979 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_;
980 lan743x_csr_write(adapter, PTP_TX_MOD2, temp);
981 lan743x_ptp_enable(adapter);
982 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
983 lan743x_csr_write(adapter, PTP_INT_EN_SET,
984 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_);
985 ptp->flags |= PTP_FLAG_ISR_ENABLED;
986
987 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK))
988 return 0;
989
990 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) {
991 case ID_REV_ID_LAN7430_:
992 n_pins = LAN7430_N_GPIO;
993 break;
994 case ID_REV_ID_LAN7431_:
995 n_pins = LAN7431_N_GPIO;
996 break;
997 default:
998 netif_warn(adapter, drv, adapter->netdev,
999 "Unknown LAN743x (%08x). Assuming no GPIO\n",
1000 adapter->csr.id_rev);
1001 n_pins = 0;
1002 break;
1003 }
1004
1005 if (n_pins > LAN743X_PTP_N_GPIO)
1006 n_pins = LAN743X_PTP_N_GPIO;
1007
1008 for (i = 0; i < n_pins; i++) {
1009 struct ptp_pin_desc *ptp_pin = &ptp->pin_config[i];
1010
1011 snprintf(ptp_pin->name,
1012 sizeof(ptp_pin->name), "lan743x_ptp_pin_%02d", i);
1013 ptp_pin->index = i;
1014 ptp_pin->func = PTP_PF_NONE;
1015 }
1016
1017 ptp->ptp_clock_info.owner = THIS_MODULE;
1018 snprintf(ptp->ptp_clock_info.name, 16, "%pm",
1019 adapter->netdev->dev_addr);
1020 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB;
1021 ptp->ptp_clock_info.n_alarm = 0;
1022 ptp->ptp_clock_info.n_ext_ts = 0;
1023 ptp->ptp_clock_info.n_per_out = LAN743X_PTP_N_EVENT_CHAN;
1024 ptp->ptp_clock_info.n_pins = n_pins;
1025 ptp->ptp_clock_info.pps = 0;
1026 ptp->ptp_clock_info.pin_config = ptp->pin_config;
1027 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine;
1028 ptp->ptp_clock_info.adjfreq = lan743x_ptpci_adjfreq;
1029 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime;
1030 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64;
1031 ptp->ptp_clock_info.getcrosststamp = NULL;
1032 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64;
1033 ptp->ptp_clock_info.enable = lan743x_ptpci_enable;
1034 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work;
1035 ptp->ptp_clock_info.verify = lan743x_ptpci_verify_pin_config;
1036
1037 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info,
1038 &adapter->pdev->dev);
1039
1040 if (IS_ERR(ptp->ptp_clock)) {
1041 netif_err(adapter, ifup, adapter->netdev,
1042 "ptp_clock_register failed\n");
1043 goto done;
1044 }
1045 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED;
1046 netif_info(adapter, ifup, adapter->netdev,
1047 "successfully registered ptp clock\n");
1048
1049 return 0;
1050done:
1051 lan743x_ptp_close(adapter);
1052 return ret;
1053}
1054
1055void lan743x_ptp_close(struct lan743x_adapter *adapter)
1056{
1057 struct lan743x_ptp *ptp = &adapter->ptp;
1058 int index;
1059
1060 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) &&
1061 (ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED)) {
1062 ptp_clock_unregister(ptp->ptp_clock);
1063 ptp->ptp_clock = NULL;
1064 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED;
1065 netif_info(adapter, drv, adapter->netdev,
1066 "ptp clock unregister\n");
1067 }
1068
1069 if (ptp->flags & PTP_FLAG_ISR_ENABLED) {
1070 lan743x_csr_write(adapter, PTP_INT_EN_CLR,
1071 PTP_INT_BIT_TX_SWTS_ERR_ |
1072 PTP_INT_BIT_TX_TS_);
1073 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
1074 ptp->flags &= ~PTP_FLAG_ISR_ENABLED;
1075 }
1076
1077 /* clean up pending timestamp requests */
1078 lan743x_ptp_tx_ts_complete(adapter);
1079 spin_lock_bh(&ptp->tx_ts_lock);
1080 for (index = 0;
1081 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS;
1082 index++) {
1083 struct sk_buff *skb = ptp->tx_ts_skb_queue[index];
1084
1085 dev_kfree_skb(skb);
1086 ptp->tx_ts_skb_queue[index] = NULL;
1087 ptp->tx_ts_seconds_queue[index] = 0;
1088 ptp->tx_ts_nseconds_queue[index] = 0;
1089 }
1090 ptp->tx_ts_skb_queue_size = 0;
1091 ptp->tx_ts_queue_size = 0;
1092 ptp->pending_tx_timestamps = 0;
1093 spin_unlock_bh(&ptp->tx_ts_lock);
1094
1095 lan743x_led_mux_restore(adapter);
1096
1097 lan743x_ptp_disable(adapter);
1098}
1099
1100static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter,
1101 bool ts_insert_enable)
1102{
1103 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD);
1104
1105 if (ts_insert_enable)
1106 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
1107 else
1108 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
1109
1110 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod);
1111}
1112
1113static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter)
1114{
1115 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_)
1116 return true;
1117 return false;
1118}
1119
1120static void lan743x_ptp_enable(struct lan743x_adapter *adapter)
1121{
1122 struct lan743x_ptp *ptp = &adapter->ptp;
1123
1124 mutex_lock(&ptp->command_lock);
1125
1126 if (lan743x_ptp_is_enabled(adapter)) {
1127 netif_warn(adapter, drv, adapter->netdev,
1128 "PTP already enabled\n");
1129 goto done;
1130 }
1131 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_);
1132done:
1133 mutex_unlock(&ptp->command_lock);
1134}
1135
1136static void lan743x_ptp_disable(struct lan743x_adapter *adapter)
1137{
1138 struct lan743x_ptp *ptp = &adapter->ptp;
1139
1140 mutex_lock(&ptp->command_lock);
1141 if (!lan743x_ptp_is_enabled(adapter)) {
1142 netif_warn(adapter, drv, adapter->netdev,
1143 "PTP already disabled\n");
1144 goto done;
1145 }
1146 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_);
1147 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_);
1148done:
1149 mutex_unlock(&ptp->command_lock);
1150}
1151
1152static void lan743x_ptp_reset(struct lan743x_adapter *adapter)
1153{
1154 struct lan743x_ptp *ptp = &adapter->ptp;
1155
1156 mutex_lock(&ptp->command_lock);
1157
1158 if (lan743x_ptp_is_enabled(adapter)) {
1159 netif_err(adapter, drv, adapter->netdev,
1160 "Attempting reset while enabled\n");
1161 goto done;
1162 }
1163
1164 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_);
1165 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_);
1166done:
1167 mutex_unlock(&ptp->command_lock);
1168}
1169
1170static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
1171 u32 seconds, u32 nano_seconds,
1172 u32 sub_nano_seconds)
1173{
1174 struct lan743x_ptp *ptp = &adapter->ptp;
1175
1176 mutex_lock(&ptp->command_lock);
1177
1178 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds);
1179 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds);
1180 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds);
1181
1182 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1183 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1184 mutex_unlock(&ptp->command_lock);
1185}
1186
1187bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter)
1188{
1189 struct lan743x_ptp *ptp = &adapter->ptp;
1190 bool result = false;
1191
1192 spin_lock_bh(&ptp->tx_ts_lock);
1193 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
1194 /* request granted */
1195 ptp->pending_tx_timestamps++;
1196 result = true;
1197 }
1198 spin_unlock_bh(&ptp->tx_ts_lock);
1199 return result;
1200}
1201
1202void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter)
1203{
1204 struct lan743x_ptp *ptp = &adapter->ptp;
1205
1206 spin_lock_bh(&ptp->tx_ts_lock);
1207 if (ptp->pending_tx_timestamps > 0)
1208 ptp->pending_tx_timestamps--;
1209 else
1210 netif_err(adapter, drv, adapter->netdev,
1211 "unrequest failed, pending_tx_timestamps==0\n");
1212 spin_unlock_bh(&ptp->tx_ts_lock);
1213}
1214
1215void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter,
1216 struct sk_buff *skb, bool ignore_sync)
1217{
1218 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync);
1219
1220 lan743x_ptp_tx_ts_complete(adapter);
1221}
1222
1223int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1224{
1225 struct lan743x_adapter *adapter = netdev_priv(netdev);
1226 struct hwtstamp_config config;
1227 int ret = 0;
1228 int index;
1229
1230 if (!ifr) {
1231 netif_err(adapter, drv, adapter->netdev,
1232 "SIOCSHWTSTAMP, ifr == NULL\n");
1233 return -EINVAL;
1234 }
1235
1236 if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
1237 return -EFAULT;
1238
1239 if (config.flags) {
1240 netif_warn(adapter, drv, adapter->netdev,
1241 "ignoring hwtstamp_config.flags == 0x%08X, expected 0\n",
1242 config.flags);
1243 }
1244
1245 switch (config.tx_type) {
1246 case HWTSTAMP_TX_OFF:
1247 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1248 index++)
1249 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1250 false, false);
1251 lan743x_ptp_set_sync_ts_insert(adapter, false);
1252 break;
1253 case HWTSTAMP_TX_ON:
1254 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1255 index++)
1256 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1257 true, false);
1258 lan743x_ptp_set_sync_ts_insert(adapter, false);
1259 break;
1260 case HWTSTAMP_TX_ONESTEP_SYNC:
1261 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1262 index++)
1263 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1264 true, true);
1265
1266 lan743x_ptp_set_sync_ts_insert(adapter, true);
1267 break;
1268 case HWTSTAMP_TX_ONESTEP_P2P:
1269 ret = -ERANGE;
1270 break;
1271 default:
1272 netif_warn(adapter, drv, adapter->netdev,
1273 " tx_type = %d, UNKNOWN\n", config.tx_type);
1274 ret = -EINVAL;
1275 break;
1276 }
1277
1278 if (!ret)
1279 return copy_to_user(ifr->ifr_data, &config,
1280 sizeof(config)) ? -EFAULT : 0;
1281 return ret;
1282}