?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / net / ethernet / microchip / lan743x_ptp.c
blobccdf9123f26f304b8c70e2bd4ac0e1010e09e72f
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
18 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter);
19 static void lan743x_ptp_enable(struct lan743x_adapter *adapter);
20 static void lan743x_ptp_disable(struct lan743x_adapter *adapter);
21 static void lan743x_ptp_reset(struct lan743x_adapter *adapter);
22 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
23 u32 seconds, u32 nano_seconds,
24 u32 sub_nano_seconds);
25
26 int 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
44 static 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
63 static 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
82 static 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;
137 done:
138 ptp->pending_tx_timestamps -= c;
139 spin_unlock_bh(&ptp->tx_ts_lock);
140 }
141
142 static 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
160 static 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
176 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
177 u32 *seconds, u32 *nano_seconds,
178 u32 *sub_nano_seconds);
179 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
180 s64 time_step_ns);
181
182 static 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
227 static 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
262 static 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
295 static 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
329 static 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
341 static 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
358 static 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
394 static 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
422 static 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 if (!on) {
433 lan743x_ptp_perout_off(adapter);
434 return 0;
435 }
436
437 if (ptp->perout_event_ch >= 0 ||
438 ptp->perout_gpio_bit >= 0) {
439 /* already on, turn off first */
440 lan743x_ptp_perout_off(adapter);
441 }
442
443 ptp->perout_event_ch = lan743x_ptp_reserve_event_ch(adapter);
444 if (ptp->perout_event_ch < 0) {
445 netif_warn(adapter, drv, adapter->netdev,
446 "Failed to reserve event channel for PEROUT\n");
447 goto failed;
448 }
449
450 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) {
451 case ID_REV_ID_LAN7430_:
452 perout_bit = 2;/* GPIO 2 is preferred on EVB LAN7430 */
453 break;
454 case ID_REV_ID_LAN7431_:
455 perout_bit = 4;/* GPIO 4 is preferred on EVB LAN7431 */
456 break;
457 }
458
459 ptp->perout_gpio_bit = lan743x_gpio_rsrv_ptp_out(adapter,
460 perout_bit,
461 ptp->perout_event_ch);
462
463 if (ptp->perout_gpio_bit < 0) {
464 netif_warn(adapter, drv, adapter->netdev,
465 "Failed to reserve gpio %d for PEROUT\n",
466 perout_bit);
467 goto failed;
468 }
469
470 start_sec = perout->start.sec;
471 start_sec += perout->start.nsec / 1000000000;
472 start_nsec = perout->start.nsec % 1000000000;
473
474 period_sec = perout->period.sec;
475 period_sec += perout->period.nsec / 1000000000;
476 period_nsec = perout->period.nsec % 1000000000;
477
478 if (period_sec == 0) {
479 if (period_nsec >= 400000000) {
480 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
481 } else if (period_nsec >= 20000000) {
482 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
483 } else if (period_nsec >= 2000000) {
484 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
485 } else if (period_nsec >= 200000) {
486 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
487 } else if (period_nsec >= 20000) {
488 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
489 } else if (period_nsec >= 200) {
490 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
491 } else {
492 netif_warn(adapter, drv, adapter->netdev,
493 "perout period too small, minimum is 200nS\n");
494 goto failed;
495 }
496 } else {
497 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
498 }
499
500 /* turn off by setting target far in future */
501 lan743x_csr_write(adapter,
502 PTP_CLOCK_TARGET_SEC_X(ptp->perout_event_ch),
503 0xFFFF0000);
504 lan743x_csr_write(adapter,
505 PTP_CLOCK_TARGET_NS_X(ptp->perout_event_ch), 0);
506
507 /* Configure to pulse every period */
508 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
509 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_
510 (ptp->perout_event_ch));
511 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_
512 (ptp->perout_event_ch, pulse_width);
513 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_
514 (ptp->perout_event_ch);
515 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
516
517 /* set the reload to one toggle cycle */
518 lan743x_csr_write(adapter,
519 PTP_CLOCK_TARGET_RELOAD_SEC_X(ptp->perout_event_ch),
520 period_sec);
521 lan743x_csr_write(adapter,
522 PTP_CLOCK_TARGET_RELOAD_NS_X(ptp->perout_event_ch),
523 period_nsec);
524
525 /* set the start time */
526 lan743x_csr_write(adapter,
527 PTP_CLOCK_TARGET_SEC_X(ptp->perout_event_ch),
528 start_sec);
529 lan743x_csr_write(adapter,
530 PTP_CLOCK_TARGET_NS_X(ptp->perout_event_ch),
531 start_nsec);
532
533 return 0;
534
535 failed:
536 lan743x_ptp_perout_off(adapter);
537 return -ENODEV;
538 }
539
540 static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci,
541 struct ptp_clock_request *request, int on)
542 {
543 struct lan743x_ptp *ptp =
544 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
545 struct lan743x_adapter *adapter =
546 container_of(ptp, struct lan743x_adapter, ptp);
547
548 if (request) {
549 switch (request->type) {
550 case PTP_CLK_REQ_EXTTS:
551 return -EINVAL;
552 case PTP_CLK_REQ_PEROUT:
553 if (request->perout.index == 0)
554 return lan743x_ptp_perout(adapter, on,
555 &request->perout);
556 return -EINVAL;
557 case PTP_CLK_REQ_PPS:
558 return -EINVAL;
559 default:
560 netif_err(adapter, drv, adapter->netdev,
561 "request->type == %d, Unknown\n",
562 request->type);
563 break;
564 }
565 } else {
566 netif_err(adapter, drv, adapter->netdev, "request == NULL\n");
567 }
568 return 0;
569 }
570
571 static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci)
572 {
573 struct lan743x_ptp *ptp =
574 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
575 struct lan743x_adapter *adapter =
576 container_of(ptp, struct lan743x_adapter, ptp);
577 u32 cap_info, cause, header, nsec, seconds;
578 bool new_timestamp_available = false;
579 int count = 0;
580
581 while ((count < 100) &&
582 (lan743x_csr_read(adapter, PTP_INT_STS) & PTP_INT_BIT_TX_TS_)) {
583 count++;
584 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO);
585
586 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) {
587 seconds = lan743x_csr_read(adapter,
588 PTP_TX_EGRESS_SEC);
589 nsec = lan743x_csr_read(adapter, PTP_TX_EGRESS_NS);
590 cause = (nsec &
591 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_);
592 header = lan743x_csr_read(adapter,
593 PTP_TX_MSG_HEADER);
594
595 if (cause == PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) {
596 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_;
597 lan743x_ptp_tx_ts_enqueue_ts(adapter,
598 seconds, nsec,
599 header);
600 new_timestamp_available = true;
601 } else if (cause ==
602 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) {
603 netif_err(adapter, drv, adapter->netdev,
604 "Auto capture cause not supported\n");
605 } else {
606 netif_warn(adapter, drv, adapter->netdev,
607 "unknown tx timestamp capture cause\n");
608 }
609 } else {
610 netif_warn(adapter, drv, adapter->netdev,
611 "TX TS INT but no TX TS CNT\n");
612 }
613 lan743x_csr_write(adapter, PTP_INT_STS, PTP_INT_BIT_TX_TS_);
614 }
615
616 if (new_timestamp_available)
617 lan743x_ptp_tx_ts_complete(adapter);
618
619 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
620
621 return -1;
622 }
623
624 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
625 u32 *seconds, u32 *nano_seconds,
626 u32 *sub_nano_seconds)
627 {
628 struct lan743x_ptp *ptp = &adapter->ptp;
629
630 mutex_lock(&ptp->command_lock);
631
632 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_);
633 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_);
634
635 if (seconds)
636 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC);
637
638 if (nano_seconds)
639 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS);
640
641 if (sub_nano_seconds)
642 (*sub_nano_seconds) =
643 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS);
644
645 mutex_unlock(&ptp->command_lock);
646 }
647
648 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
649 s64 time_step_ns)
650 {
651 struct lan743x_ptp *ptp = &adapter->ptp;
652 u32 nano_seconds_step = 0;
653 u64 abs_time_step_ns = 0;
654 u32 unsigned_seconds = 0;
655 u32 nano_seconds = 0;
656 u32 remainder = 0;
657 s32 seconds = 0;
658
659 if (time_step_ns > 15000000000LL) {
660 /* convert to clock set */
661 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
662 &nano_seconds, NULL);
663 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL,
664 &remainder);
665 nano_seconds += remainder;
666 if (nano_seconds >= 1000000000) {
667 unsigned_seconds++;
668 nano_seconds -= 1000000000;
669 }
670 lan743x_ptp_clock_set(adapter, unsigned_seconds,
671 nano_seconds, 0);
672 return;
673 } else if (time_step_ns < -15000000000LL) {
674 /* convert to clock set */
675 time_step_ns = -time_step_ns;
676
677 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
678 &nano_seconds, NULL);
679 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL,
680 &remainder);
681 nano_seconds_step = remainder;
682 if (nano_seconds < nano_seconds_step) {
683 unsigned_seconds--;
684 nano_seconds += 1000000000;
685 }
686 nano_seconds -= nano_seconds_step;
687 lan743x_ptp_clock_set(adapter, unsigned_seconds,
688 nano_seconds, 0);
689 return;
690 }
691
692 /* do clock step */
693 if (time_step_ns >= 0) {
694 abs_time_step_ns = (u64)(time_step_ns);
695 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000,
696 &remainder);
697 nano_seconds = (u32)remainder;
698 } else {
699 abs_time_step_ns = (u64)(-time_step_ns);
700 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000,
701 &remainder));
702 nano_seconds = (u32)remainder;
703 if (nano_seconds > 0) {
704 /* subtracting nano seconds is not allowed
705 * convert to subtracting from seconds,
706 * and adding to nanoseconds
707 */
708 seconds--;
709 nano_seconds = (1000000000 - nano_seconds);
710 }
711 }
712
713 if (nano_seconds > 0) {
714 /* add 8 ns to cover the likely normal increment */
715 nano_seconds += 8;
716 }
717
718 if (nano_seconds >= 1000000000) {
719 /* carry into seconds */
720 seconds++;
721 nano_seconds -= 1000000000;
722 }
723
724 while (seconds) {
725 mutex_lock(&ptp->command_lock);
726 if (seconds > 0) {
727 u32 adjustment_value = (u32)seconds;
728
729 if (adjustment_value > 0xF)
730 adjustment_value = 0xF;
731 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
732 PTP_CLOCK_STEP_ADJ_DIR_ |
733 adjustment_value);
734 seconds -= ((s32)adjustment_value);
735 } else {
736 u32 adjustment_value = (u32)(-seconds);
737
738 if (adjustment_value > 0xF)
739 adjustment_value = 0xF;
740 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
741 adjustment_value);
742 seconds += ((s32)adjustment_value);
743 }
744 lan743x_csr_write(adapter, PTP_CMD_CTL,
745 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
746 lan743x_ptp_wait_till_cmd_done(adapter,
747 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
748 mutex_unlock(&ptp->command_lock);
749 }
750 if (nano_seconds) {
751 mutex_lock(&ptp->command_lock);
752 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
753 PTP_CLOCK_STEP_ADJ_DIR_ |
754 (nano_seconds &
755 PTP_CLOCK_STEP_ADJ_VALUE_MASK_));
756 lan743x_csr_write(adapter, PTP_CMD_CTL,
757 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
758 lan743x_ptp_wait_till_cmd_done(adapter,
759 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
760 mutex_unlock(&ptp->command_lock);
761 }
762 }
763
764 void lan743x_ptp_isr(void *context)
765 {
766 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context;
767 struct lan743x_ptp *ptp = NULL;
768 int enable_flag = 1;
769 u32 ptp_int_sts = 0;
770
771 ptp = &adapter->ptp;
772
773 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
774
775 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
776 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET);
777
778 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) {
779 ptp_schedule_worker(ptp->ptp_clock, 0);
780 enable_flag = 0;/* tasklet will re-enable later */
781 }
782 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) {
783 netif_err(adapter, drv, adapter->netdev,
784 "PTP TX Software Timestamp Error\n");
785 /* clear int status bit */
786 lan743x_csr_write(adapter, PTP_INT_STS,
787 PTP_INT_BIT_TX_SWTS_ERR_);
788 }
789 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) {
790 /* clear int status bit */
791 lan743x_csr_write(adapter, PTP_INT_STS,
792 PTP_INT_BIT_TIMER_B_);
793 }
794 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) {
795 /* clear int status bit */
796 lan743x_csr_write(adapter, PTP_INT_STS,
797 PTP_INT_BIT_TIMER_A_);
798 }
799
800 if (enable_flag) {
801 /* re-enable isr */
802 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
803 }
804 }
805
806 static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter,
807 struct sk_buff *skb, bool ignore_sync)
808 {
809 struct lan743x_ptp *ptp = &adapter->ptp;
810
811 spin_lock_bh(&ptp->tx_ts_lock);
812 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
813 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb;
814 if (ignore_sync)
815 ptp->tx_ts_ignore_sync_queue |=
816 BIT(ptp->tx_ts_skb_queue_size);
817 ptp->tx_ts_skb_queue_size++;
818 } else {
819 /* this should never happen, so long as the tx channel
820 * calls and honors the result from
821 * lan743x_ptp_request_tx_timestamp
822 */
823 netif_err(adapter, drv, adapter->netdev,
824 "tx ts skb queue overflow\n");
825 dev_kfree_skb(skb);
826 }
827 spin_unlock_bh(&ptp->tx_ts_lock);
828 }
829
830 static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter)
831 {
832 struct timespec64 ts;
833
834 ktime_get_clocktai_ts64(&ts);
835
836 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0);
837 }
838
839 void lan743x_ptp_update_latency(struct lan743x_adapter *adapter,
840 u32 link_speed)
841 {
842 switch (link_speed) {
843 case 10:
844 lan743x_csr_write(adapter, PTP_LATENCY,
845 PTP_LATENCY_TX_SET_(0) |
846 PTP_LATENCY_RX_SET_(0));
847 break;
848 case 100:
849 lan743x_csr_write(adapter, PTP_LATENCY,
850 PTP_LATENCY_TX_SET_(181) |
851 PTP_LATENCY_RX_SET_(594));
852 break;
853 case 1000:
854 lan743x_csr_write(adapter, PTP_LATENCY,
855 PTP_LATENCY_TX_SET_(30) |
856 PTP_LATENCY_RX_SET_(525));
857 break;
858 }
859 }
860
861 int lan743x_ptp_init(struct lan743x_adapter *adapter)
862 {
863 struct lan743x_ptp *ptp = &adapter->ptp;
864
865 mutex_init(&ptp->command_lock);
866 spin_lock_init(&ptp->tx_ts_lock);
867 ptp->used_event_ch = 0;
868 ptp->perout_event_ch = -1;
869 ptp->perout_gpio_bit = -1;
870 return 0;
871 }
872
873 int lan743x_ptp_open(struct lan743x_adapter *adapter)
874 {
875 struct lan743x_ptp *ptp = &adapter->ptp;
876 int ret = -ENODEV;
877 u32 temp;
878
879 lan743x_ptp_reset(adapter);
880 lan743x_ptp_sync_to_system_clock(adapter);
881 temp = lan743x_csr_read(adapter, PTP_TX_MOD2);
882 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_;
883 lan743x_csr_write(adapter, PTP_TX_MOD2, temp);
884 lan743x_ptp_enable(adapter);
885 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
886 lan743x_csr_write(adapter, PTP_INT_EN_SET,
887 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_);
888 ptp->flags |= PTP_FLAG_ISR_ENABLED;
889
890 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK))
891 return 0;
892
893 snprintf(ptp->pin_config[0].name, 32, "lan743x_ptp_pin_0");
894 ptp->pin_config[0].index = 0;
895 ptp->pin_config[0].func = PTP_PF_PEROUT;
896 ptp->pin_config[0].chan = 0;
897
898 ptp->ptp_clock_info.owner = THIS_MODULE;
899 snprintf(ptp->ptp_clock_info.name, 16, "%pm",
900 adapter->netdev->dev_addr);
901 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB;
902 ptp->ptp_clock_info.n_alarm = 0;
903 ptp->ptp_clock_info.n_ext_ts = 0;
904 ptp->ptp_clock_info.n_per_out = 1;
905 ptp->ptp_clock_info.n_pins = 0;
906 ptp->ptp_clock_info.pps = 0;
907 ptp->ptp_clock_info.pin_config = NULL;
908 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine;
909 ptp->ptp_clock_info.adjfreq = lan743x_ptpci_adjfreq;
910 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime;
911 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64;
912 ptp->ptp_clock_info.getcrosststamp = NULL;
913 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64;
914 ptp->ptp_clock_info.enable = lan743x_ptpci_enable;
915 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work;
916 ptp->ptp_clock_info.verify = NULL;
917
918 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info,
919 &adapter->pdev->dev);
920
921 if (IS_ERR(ptp->ptp_clock)) {
922 netif_err(adapter, ifup, adapter->netdev,
923 "ptp_clock_register failed\n");
924 goto done;
925 }
926 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED;
927 netif_info(adapter, ifup, adapter->netdev,
928 "successfully registered ptp clock\n");
929
930 return 0;
931 done:
932 lan743x_ptp_close(adapter);
933 return ret;
934 }
935
936 void lan743x_ptp_close(struct lan743x_adapter *adapter)
937 {
938 struct lan743x_ptp *ptp = &adapter->ptp;
939 int index;
940
941 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) &&
942 ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED) {
943 ptp_clock_unregister(ptp->ptp_clock);
944 ptp->ptp_clock = NULL;
945 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED;
946 netif_info(adapter, drv, adapter->netdev,
947 "ptp clock unregister\n");
948 }
949
950 if (ptp->flags & PTP_FLAG_ISR_ENABLED) {
951 lan743x_csr_write(adapter, PTP_INT_EN_CLR,
952 PTP_INT_BIT_TX_SWTS_ERR_ |
953 PTP_INT_BIT_TX_TS_);
954 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
955 ptp->flags &= ~PTP_FLAG_ISR_ENABLED;
956 }
957
958 /* clean up pending timestamp requests */
959 lan743x_ptp_tx_ts_complete(adapter);
960 spin_lock_bh(&ptp->tx_ts_lock);
961 for (index = 0;
962 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS;
963 index++) {
964 struct sk_buff *skb = ptp->tx_ts_skb_queue[index];
965
966 if (skb)
967 dev_kfree_skb(skb);
968 ptp->tx_ts_skb_queue[index] = NULL;
969 ptp->tx_ts_seconds_queue[index] = 0;
970 ptp->tx_ts_nseconds_queue[index] = 0;
971 }
972 ptp->tx_ts_skb_queue_size = 0;
973 ptp->tx_ts_queue_size = 0;
974 ptp->pending_tx_timestamps = 0;
975 spin_unlock_bh(&ptp->tx_ts_lock);
976
977 lan743x_ptp_disable(adapter);
978 }
979
980 void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter,
981 bool ts_insert_enable)
982 {
983 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD);
984
985 if (ts_insert_enable)
986 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
987 else
988 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
989
990 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod);
991 }
992
993 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter)
994 {
995 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_)
996 return true;
997 return false;
998 }
999
1000 static void lan743x_ptp_enable(struct lan743x_adapter *adapter)
1001 {
1002 struct lan743x_ptp *ptp = &adapter->ptp;
1003
1004 mutex_lock(&ptp->command_lock);
1005
1006 if (lan743x_ptp_is_enabled(adapter)) {
1007 netif_warn(adapter, drv, adapter->netdev,
1008 "PTP already enabled\n");
1009 goto done;
1010 }
1011 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_);
1012 done:
1013 mutex_unlock(&ptp->command_lock);
1014 }
1015
1016 static void lan743x_ptp_disable(struct lan743x_adapter *adapter)
1017 {
1018 struct lan743x_ptp *ptp = &adapter->ptp;
1019
1020 mutex_lock(&ptp->command_lock);
1021 if (!lan743x_ptp_is_enabled(adapter)) {
1022 netif_warn(adapter, drv, adapter->netdev,
1023 "PTP already disabled\n");
1024 goto done;
1025 }
1026 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_);
1027 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_);
1028 done:
1029 mutex_unlock(&ptp->command_lock);
1030 }
1031
1032 static void lan743x_ptp_reset(struct lan743x_adapter *adapter)
1033 {
1034 struct lan743x_ptp *ptp = &adapter->ptp;
1035
1036 mutex_lock(&ptp->command_lock);
1037
1038 if (lan743x_ptp_is_enabled(adapter)) {
1039 netif_err(adapter, drv, adapter->netdev,
1040 "Attempting reset while enabled\n");
1041 goto done;
1042 }
1043
1044 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_);
1045 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_);
1046 done:
1047 mutex_unlock(&ptp->command_lock);
1048 }
1049
1050 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
1051 u32 seconds, u32 nano_seconds,
1052 u32 sub_nano_seconds)
1053 {
1054 struct lan743x_ptp *ptp = &adapter->ptp;
1055
1056 mutex_lock(&ptp->command_lock);
1057
1058 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds);
1059 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds);
1060 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds);
1061
1062 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1063 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1064 mutex_unlock(&ptp->command_lock);
1065 }
1066
1067 bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter)
1068 {
1069 struct lan743x_ptp *ptp = &adapter->ptp;
1070 bool result = false;
1071
1072 spin_lock_bh(&ptp->tx_ts_lock);
1073 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
1074 /* request granted */
1075 ptp->pending_tx_timestamps++;
1076 result = true;
1077 }
1078 spin_unlock_bh(&ptp->tx_ts_lock);
1079 return result;
1080 }
1081
1082 void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter)
1083 {
1084 struct lan743x_ptp *ptp = &adapter->ptp;
1085
1086 spin_lock_bh(&ptp->tx_ts_lock);
1087 if (ptp->pending_tx_timestamps > 0)
1088 ptp->pending_tx_timestamps--;
1089 else
1090 netif_err(adapter, drv, adapter->netdev,
1091 "unrequest failed, pending_tx_timestamps==0\n");
1092 spin_unlock_bh(&ptp->tx_ts_lock);
1093 }
1094
1095 void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter,
1096 struct sk_buff *skb, bool ignore_sync)
1097 {
1098 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync);
1099
1100 lan743x_ptp_tx_ts_complete(adapter);
1101 }
1102
1103 int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1104 {
1105 struct lan743x_adapter *adapter = netdev_priv(netdev);
1106 struct hwtstamp_config config;
1107 int ret = 0;
1108 int index;
1109
1110 if (!ifr) {
1111 netif_err(adapter, drv, adapter->netdev,
1112 "SIOCSHWTSTAMP, ifr == NULL\n");
1113 return -EINVAL;
1114 }
1115
1116 if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
1117 return -EFAULT;
1118
1119 if (config.flags) {
1120 netif_warn(adapter, drv, adapter->netdev,
1121 "ignoring hwtstamp_config.flags == 0x%08X, expected 0\n",
1122 config.flags);
1123 }
1124
1125 switch (config.tx_type) {
1126 case HWTSTAMP_TX_OFF:
1127 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1128 index++)
1129 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1130 false, false);
1131 lan743x_ptp_set_sync_ts_insert(adapter, false);
1132 break;
1133 case HWTSTAMP_TX_ON:
1134 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1135 index++)
1136 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1137 true, false);
1138 lan743x_ptp_set_sync_ts_insert(adapter, false);
1139 break;
1140 case HWTSTAMP_TX_ONESTEP_SYNC:
1141 for (index = 0; index < LAN743X_MAX_TX_CHANNELS;
1142 index++)
1143 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1144 true, true);
1145
1146 lan743x_ptp_set_sync_ts_insert(adapter, true);
1147 break;
1148 default:
1149 netif_warn(adapter, drv, adapter->netdev,
1150 " tx_type = %d, UNKNOWN\n", config.tx_type);
1151 ret = -EINVAL;
1152 break;
1153 }
1154
1155 if (!ret)
1156 return copy_to_user(ifr->ifr_data, &config,
1157 sizeof(config)) ? -EFAULT : 0;
1158 return ret;
1159 }
Linux with added FPC-III support