Loading...
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
28static int lan743x_get_channel(u32 ch_map)
29{
30 int idx;
31
32 for (idx = 0; idx < 32; idx++) {
33 if (ch_map & (0x1 << idx))
34 return idx;
35 }
36
37 return -EINVAL;
38}
39
40int lan743x_gpio_init(struct lan743x_adapter *adapter)
41{
42 struct lan743x_gpio *gpio = &adapter->gpio;
43
44 spin_lock_init(&gpio->gpio_lock);
45
46 gpio->gpio_cfg0 = 0; /* set all direction to input, data = 0 */
47 gpio->gpio_cfg1 = 0x0FFF0000;/* disable all gpio, set to open drain */
48 gpio->gpio_cfg2 = 0;/* set all to 1588 low polarity level */
49 gpio->gpio_cfg3 = 0;/* disable all 1588 output */
50 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
51 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
52 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
53 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
54
55 return 0;
56}
57
58static void lan743x_ptp_wait_till_cmd_done(struct lan743x_adapter *adapter,
59 u32 bit_mask)
60{
61 int timeout = PTP_CMD_CTL_TIMEOUT_CNT;
62 u32 data = 0;
63
64 while (timeout &&
65 (data = (lan743x_csr_read(adapter, PTP_CMD_CTL) &
66 bit_mask))) {
67 usleep_range(1000, 20000);
68 timeout--;
69 }
70 if (data) {
71 netif_err(adapter, drv, adapter->netdev,
72 "timeout waiting for cmd to be done, cmd = 0x%08X\n",
73 bit_mask);
74 }
75}
76
77static void lan743x_ptp_tx_ts_enqueue_ts(struct lan743x_adapter *adapter,
78 u32 seconds, u32 nano_seconds,
79 u32 header)
80{
81 struct lan743x_ptp *ptp = &adapter->ptp;
82
83 spin_lock_bh(&ptp->tx_ts_lock);
84 if (ptp->tx_ts_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
85 ptp->tx_ts_seconds_queue[ptp->tx_ts_queue_size] = seconds;
86 ptp->tx_ts_nseconds_queue[ptp->tx_ts_queue_size] = nano_seconds;
87 ptp->tx_ts_header_queue[ptp->tx_ts_queue_size] = header;
88 ptp->tx_ts_queue_size++;
89 } else {
90 netif_err(adapter, drv, adapter->netdev,
91 "tx ts queue overflow\n");
92 }
93 spin_unlock_bh(&ptp->tx_ts_lock);
94}
95
96static void lan743x_ptp_tx_ts_complete(struct lan743x_adapter *adapter)
97{
98 struct lan743x_ptp *ptp = &adapter->ptp;
99 struct skb_shared_hwtstamps tstamps;
100 u32 header, nseconds, seconds;
101 bool ignore_sync = false;
102 struct sk_buff *skb;
103 int c, i;
104
105 spin_lock_bh(&ptp->tx_ts_lock);
106 c = ptp->tx_ts_skb_queue_size;
107
108 if (c > ptp->tx_ts_queue_size)
109 c = ptp->tx_ts_queue_size;
110 if (c <= 0)
111 goto done;
112
113 for (i = 0; i < c; i++) {
114 ignore_sync = ((ptp->tx_ts_ignore_sync_queue &
115 BIT(i)) != 0);
116 skb = ptp->tx_ts_skb_queue[i];
117 nseconds = ptp->tx_ts_nseconds_queue[i];
118 seconds = ptp->tx_ts_seconds_queue[i];
119 header = ptp->tx_ts_header_queue[i];
120
121 memset(&tstamps, 0, sizeof(tstamps));
122 tstamps.hwtstamp = ktime_set(seconds, nseconds);
123 if (!ignore_sync ||
124 ((header & PTP_TX_MSG_HEADER_MSG_TYPE_) !=
125 PTP_TX_MSG_HEADER_MSG_TYPE_SYNC_))
126 skb_tstamp_tx(skb, &tstamps);
127
128 dev_kfree_skb(skb);
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
136 /* shift queue */
137 ptp->tx_ts_ignore_sync_queue >>= c;
138 for (i = c; i < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; i++) {
139 ptp->tx_ts_skb_queue[i - c] = ptp->tx_ts_skb_queue[i];
140 ptp->tx_ts_seconds_queue[i - c] = ptp->tx_ts_seconds_queue[i];
141 ptp->tx_ts_nseconds_queue[i - c] = ptp->tx_ts_nseconds_queue[i];
142 ptp->tx_ts_header_queue[i - c] = ptp->tx_ts_header_queue[i];
143
144 ptp->tx_ts_skb_queue[i] = NULL;
145 ptp->tx_ts_seconds_queue[i] = 0;
146 ptp->tx_ts_nseconds_queue[i] = 0;
147 ptp->tx_ts_header_queue[i] = 0;
148 }
149 ptp->tx_ts_skb_queue_size -= c;
150 ptp->tx_ts_queue_size -= c;
151done:
152 ptp->pending_tx_timestamps -= c;
153 spin_unlock_bh(&ptp->tx_ts_lock);
154}
155
156static int lan743x_ptp_reserve_event_ch(struct lan743x_adapter *adapter,
157 int event_channel)
158{
159 struct lan743x_ptp *ptp = &adapter->ptp;
160 int result = -ENODEV;
161
162 mutex_lock(&ptp->command_lock);
163 if (!(test_bit(event_channel, &ptp->used_event_ch))) {
164 ptp->used_event_ch |= BIT(event_channel);
165 result = event_channel;
166 } else {
167 netif_warn(adapter, drv, adapter->netdev,
168 "attempted to reserved a used event_channel = %d\n",
169 event_channel);
170 }
171 mutex_unlock(&ptp->command_lock);
172 return result;
173}
174
175static void lan743x_ptp_release_event_ch(struct lan743x_adapter *adapter,
176 int event_channel)
177{
178 struct lan743x_ptp *ptp = &adapter->ptp;
179
180 mutex_lock(&ptp->command_lock);
181 if (test_bit(event_channel, &ptp->used_event_ch)) {
182 ptp->used_event_ch &= ~BIT(event_channel);
183 } else {
184 netif_warn(adapter, drv, adapter->netdev,
185 "attempted release on a not used event_channel = %d\n",
186 event_channel);
187 }
188 mutex_unlock(&ptp->command_lock);
189}
190
191static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
192 u32 *seconds, u32 *nano_seconds,
193 u32 *sub_nano_seconds);
194static void lan743x_ptp_io_clock_get(struct lan743x_adapter *adapter,
195 u32 *sec, u32 *nsec, u32 *sub_nsec);
196static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
197 s64 time_step_ns);
198
199static void lan743x_led_mux_enable(struct lan743x_adapter *adapter,
200 int pin, bool enable)
201{
202 struct lan743x_ptp *ptp = &adapter->ptp;
203
204 if (ptp->leds_multiplexed &&
205 ptp->led_enabled[pin]) {
206 u32 val = lan743x_csr_read(adapter, HW_CFG);
207
208 if (enable)
209 val |= LAN743X_LED_ENABLE(pin);
210 else
211 val &= ~LAN743X_LED_ENABLE(pin);
212
213 lan743x_csr_write(adapter, HW_CFG, val);
214 }
215}
216
217static void lan743x_led_mux_save(struct lan743x_adapter *adapter)
218{
219 struct lan743x_ptp *ptp = &adapter->ptp;
220 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_;
221
222 if (id_rev == ID_REV_ID_LAN7430_) {
223 int i;
224 u32 val = lan743x_csr_read(adapter, HW_CFG);
225
226 for (i = 0; i < LAN7430_N_LED; i++) {
227 bool led_enabled = (val & LAN743X_LED_ENABLE(i)) != 0;
228
229 ptp->led_enabled[i] = led_enabled;
230 }
231 ptp->leds_multiplexed = true;
232 } else {
233 ptp->leds_multiplexed = false;
234 }
235}
236
237static void lan743x_led_mux_restore(struct lan743x_adapter *adapter)
238{
239 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_;
240
241 if (id_rev == ID_REV_ID_LAN7430_) {
242 int i;
243
244 for (i = 0; i < LAN7430_N_LED; i++)
245 lan743x_led_mux_enable(adapter, i, true);
246 }
247}
248
249static int lan743x_gpio_rsrv_ptp_out(struct lan743x_adapter *adapter,
250 int pin, int event_channel)
251{
252 struct lan743x_gpio *gpio = &adapter->gpio;
253 unsigned long irq_flags = 0;
254 int bit_mask = BIT(pin);
255 int ret = -EBUSY;
256
257 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
258
259 if (!(gpio->used_bits & bit_mask)) {
260 gpio->used_bits |= bit_mask;
261 gpio->output_bits |= bit_mask;
262 gpio->ptp_bits |= bit_mask;
263
264 /* assign pin to GPIO function */
265 lan743x_led_mux_enable(adapter, pin, false);
266
267 /* set as output, and zero initial value */
268 gpio->gpio_cfg0 |= GPIO_CFG0_GPIO_DIR_BIT_(pin);
269 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin);
270 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
271
272 /* enable gpio, and set buffer type to push pull */
273 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOEN_BIT_(pin);
274 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOBUF_BIT_(pin);
275 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
276
277 /* set 1588 polarity to high */
278 gpio->gpio_cfg2 |= GPIO_CFG2_1588_POL_BIT_(pin);
279 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2);
280
281 if (event_channel == 0) {
282 /* use channel A */
283 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_CH_SEL_BIT_(pin);
284 } else {
285 /* use channel B */
286 gpio->gpio_cfg3 |= GPIO_CFG3_1588_CH_SEL_BIT_(pin);
287 }
288 gpio->gpio_cfg3 |= GPIO_CFG3_1588_OE_BIT_(pin);
289 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3);
290
291 ret = pin;
292 }
293 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
294 return ret;
295}
296
297static void lan743x_gpio_release(struct lan743x_adapter *adapter, int pin)
298{
299 struct lan743x_gpio *gpio = &adapter->gpio;
300 unsigned long irq_flags = 0;
301 int bit_mask = BIT(pin);
302
303 spin_lock_irqsave(&gpio->gpio_lock, irq_flags);
304 if (gpio->used_bits & bit_mask) {
305 gpio->used_bits &= ~bit_mask;
306 if (gpio->output_bits & bit_mask) {
307 gpio->output_bits &= ~bit_mask;
308
309 if (gpio->ptp_bits & bit_mask) {
310 gpio->ptp_bits &= ~bit_mask;
311 /* disable ptp output */
312 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_OE_BIT_(pin);
313 lan743x_csr_write(adapter, GPIO_CFG3,
314 gpio->gpio_cfg3);
315 }
316 /* release gpio output */
317
318 /* disable gpio */
319 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOEN_BIT_(pin);
320 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOBUF_BIT_(pin);
321 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1);
322
323 /* reset back to input */
324 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DIR_BIT_(pin);
325 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin);
326 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0);
327
328 /* assign pin to original function */
329 lan743x_led_mux_enable(adapter, pin, true);
330 }
331 }
332 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags);
333}
334
335static int lan743x_ptpci_adjfine(struct ptp_clock_info *ptpci, long scaled_ppm)
336{
337 struct lan743x_ptp *ptp =
338 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
339 struct lan743x_adapter *adapter =
340 container_of(ptp, struct lan743x_adapter, ptp);
341 u32 lan743x_rate_adj = 0;
342 u64 u64_delta;
343
344 if ((scaled_ppm < (-LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM)) ||
345 scaled_ppm > LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM) {
346 return -EINVAL;
347 }
348
349 /* diff_by_scaled_ppm returns true if the difference is negative */
350 if (diff_by_scaled_ppm(1ULL << 35, scaled_ppm, &u64_delta))
351 lan743x_rate_adj = (u32)u64_delta;
352 else
353 lan743x_rate_adj = (u32)u64_delta | PTP_CLOCK_RATE_ADJ_DIR_;
354
355 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ,
356 lan743x_rate_adj);
357
358 return 0;
359}
360
361static int lan743x_ptpci_adjtime(struct ptp_clock_info *ptpci, s64 delta)
362{
363 struct lan743x_ptp *ptp =
364 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
365 struct lan743x_adapter *adapter =
366 container_of(ptp, struct lan743x_adapter, ptp);
367
368 lan743x_ptp_clock_step(adapter, delta);
369
370 return 0;
371}
372
373static int lan743x_ptpci_gettime64(struct ptp_clock_info *ptpci,
374 struct timespec64 *ts)
375{
376 struct lan743x_ptp *ptp =
377 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
378 struct lan743x_adapter *adapter =
379 container_of(ptp, struct lan743x_adapter, ptp);
380 u32 nano_seconds = 0;
381 u32 seconds = 0;
382
383 if (adapter->is_pci11x1x)
384 lan743x_ptp_io_clock_get(adapter, &seconds, &nano_seconds,
385 NULL);
386 else
387 lan743x_ptp_clock_get(adapter, &seconds, &nano_seconds, NULL);
388 ts->tv_sec = seconds;
389 ts->tv_nsec = nano_seconds;
390
391 return 0;
392}
393
394static int lan743x_ptpci_settime64(struct ptp_clock_info *ptpci,
395 const struct timespec64 *ts)
396{
397 struct lan743x_ptp *ptp =
398 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
399 struct lan743x_adapter *adapter =
400 container_of(ptp, struct lan743x_adapter, ptp);
401 u32 nano_seconds = 0;
402 u32 seconds = 0;
403
404 if (ts->tv_sec > 0xFFFFFFFFLL) {
405 netif_warn(adapter, drv, adapter->netdev,
406 "ts->tv_sec out of range, %lld\n",
407 ts->tv_sec);
408 return -ERANGE;
409 }
410 if (ts->tv_nsec < 0) {
411 netif_warn(adapter, drv, adapter->netdev,
412 "ts->tv_nsec out of range, %ld\n",
413 ts->tv_nsec);
414 return -ERANGE;
415 }
416 seconds = ts->tv_sec;
417 nano_seconds = ts->tv_nsec;
418 lan743x_ptp_clock_set(adapter, seconds, nano_seconds, 0);
419
420 return 0;
421}
422
423static void lan743x_ptp_perout_off(struct lan743x_adapter *adapter,
424 unsigned int index)
425{
426 struct lan743x_ptp *ptp = &adapter->ptp;
427 u32 general_config = 0;
428 struct lan743x_ptp_perout *perout = &ptp->perout[index];
429
430 if (perout->gpio_pin >= 0) {
431 lan743x_gpio_release(adapter, perout->gpio_pin);
432 perout->gpio_pin = -1;
433 }
434
435 if (perout->event_ch >= 0) {
436 /* set target to far in the future, effectively disabling it */
437 lan743x_csr_write(adapter,
438 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
439 0xFFFF0000);
440 lan743x_csr_write(adapter,
441 PTP_CLOCK_TARGET_NS_X(perout->event_ch),
442 0);
443
444 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
445 general_config |= PTP_GENERAL_CONFIG_RELOAD_ADD_X_
446 (perout->event_ch);
447 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
448 lan743x_ptp_release_event_ch(adapter, perout->event_ch);
449 perout->event_ch = -1;
450 }
451}
452
453static int lan743x_ptp_perout(struct lan743x_adapter *adapter, int on,
454 struct ptp_perout_request *perout_request)
455{
456 struct lan743x_ptp *ptp = &adapter->ptp;
457 u32 period_sec = 0, period_nsec = 0;
458 u32 start_sec = 0, start_nsec = 0;
459 u32 general_config = 0;
460 int pulse_width = 0;
461 int perout_pin = 0;
462 unsigned int index = perout_request->index;
463 struct lan743x_ptp_perout *perout = &ptp->perout[index];
464 int ret = 0;
465
466 /* Reject requests with unsupported flags */
467 if (perout_request->flags & ~PTP_PEROUT_DUTY_CYCLE)
468 return -EOPNOTSUPP;
469
470 if (on) {
471 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT,
472 perout_request->index);
473 if (perout_pin < 0)
474 return -EBUSY;
475 } else {
476 lan743x_ptp_perout_off(adapter, index);
477 return 0;
478 }
479
480 if (perout->event_ch >= 0 ||
481 perout->gpio_pin >= 0) {
482 /* already on, turn off first */
483 lan743x_ptp_perout_off(adapter, index);
484 }
485
486 perout->event_ch = lan743x_ptp_reserve_event_ch(adapter, index);
487
488 if (perout->event_ch < 0) {
489 netif_warn(adapter, drv, adapter->netdev,
490 "Failed to reserve event channel %d for PEROUT\n",
491 index);
492 ret = -EBUSY;
493 goto failed;
494 }
495
496 perout->gpio_pin = lan743x_gpio_rsrv_ptp_out(adapter,
497 perout_pin,
498 perout->event_ch);
499
500 if (perout->gpio_pin < 0) {
501 netif_warn(adapter, drv, adapter->netdev,
502 "Failed to reserve gpio %d for PEROUT\n",
503 perout_pin);
504 ret = -EBUSY;
505 goto failed;
506 }
507
508 start_sec = perout_request->start.sec;
509 start_sec += perout_request->start.nsec / 1000000000;
510 start_nsec = perout_request->start.nsec % 1000000000;
511
512 period_sec = perout_request->period.sec;
513 period_sec += perout_request->period.nsec / 1000000000;
514 period_nsec = perout_request->period.nsec % 1000000000;
515
516 if (perout_request->flags & PTP_PEROUT_DUTY_CYCLE) {
517 struct timespec64 ts_on, ts_period;
518 s64 wf_high, period64, half;
519 s32 reminder;
520
521 ts_on.tv_sec = perout_request->on.sec;
522 ts_on.tv_nsec = perout_request->on.nsec;
523 wf_high = timespec64_to_ns(&ts_on);
524 ts_period.tv_sec = perout_request->period.sec;
525 ts_period.tv_nsec = perout_request->period.nsec;
526 period64 = timespec64_to_ns(&ts_period);
527
528 if (period64 < 200) {
529 netif_warn(adapter, drv, adapter->netdev,
530 "perout period too small, minimum is 200nS\n");
531 ret = -EOPNOTSUPP;
532 goto failed;
533 }
534 if (wf_high >= period64) {
535 netif_warn(adapter, drv, adapter->netdev,
536 "pulse width must be smaller than period\n");
537 ret = -EINVAL;
538 goto failed;
539 }
540
541 /* Check if we can do 50% toggle on an even value of period.
542 * If the period number is odd, then check if the requested
543 * pulse width is the same as one of pre-defined width values.
544 * Otherwise, return failure.
545 */
546 half = div_s64_rem(period64, 2, &reminder);
547 if (!reminder) {
548 if (half == wf_high) {
549 /* It's 50% match. Use the toggle option */
550 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_TOGGLE_;
551 /* In this case, divide period value by 2 */
552 ts_period = ns_to_timespec64(div_s64(period64, 2));
553 period_sec = ts_period.tv_sec;
554 period_nsec = ts_period.tv_nsec;
555
556 goto program;
557 }
558 }
559 /* if we can't do toggle, then the width option needs to be the exact match */
560 if (wf_high == 200000000) {
561 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
562 } else if (wf_high == 10000000) {
563 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
564 } else if (wf_high == 1000000) {
565 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
566 } else if (wf_high == 100000) {
567 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
568 } else if (wf_high == 10000) {
569 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
570 } else if (wf_high == 100) {
571 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
572 } else {
573 netif_warn(adapter, drv, adapter->netdev,
574 "duty cycle specified is not supported\n");
575 ret = -EOPNOTSUPP;
576 goto failed;
577 }
578 } else {
579 if (period_sec == 0) {
580 if (period_nsec >= 400000000) {
581 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
582 } else if (period_nsec >= 20000000) {
583 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
584 } else if (period_nsec >= 2000000) {
585 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
586 } else if (period_nsec >= 200000) {
587 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
588 } else if (period_nsec >= 20000) {
589 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
590 } else if (period_nsec >= 200) {
591 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
592 } else {
593 netif_warn(adapter, drv, adapter->netdev,
594 "perout period too small, minimum is 200nS\n");
595 ret = -EOPNOTSUPP;
596 goto failed;
597 }
598 } else {
599 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
600 }
601 }
602program:
603
604 /* turn off by setting target far in future */
605 lan743x_csr_write(adapter,
606 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
607 0xFFFF0000);
608 lan743x_csr_write(adapter,
609 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 0);
610
611 /* Configure to pulse every period */
612 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG);
613 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_
614 (perout->event_ch));
615 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_
616 (perout->event_ch, pulse_width);
617 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_
618 (perout->event_ch);
619 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config);
620
621 /* set the reload to one toggle cycle */
622 lan743x_csr_write(adapter,
623 PTP_CLOCK_TARGET_RELOAD_SEC_X(perout->event_ch),
624 period_sec);
625 lan743x_csr_write(adapter,
626 PTP_CLOCK_TARGET_RELOAD_NS_X(perout->event_ch),
627 period_nsec);
628
629 /* set the start time */
630 lan743x_csr_write(adapter,
631 PTP_CLOCK_TARGET_SEC_X(perout->event_ch),
632 start_sec);
633 lan743x_csr_write(adapter,
634 PTP_CLOCK_TARGET_NS_X(perout->event_ch),
635 start_nsec);
636
637 return 0;
638
639failed:
640 lan743x_ptp_perout_off(adapter, index);
641 return ret;
642}
643
644static void lan743x_ptp_io_perout_off(struct lan743x_adapter *adapter,
645 u32 index)
646{
647 struct lan743x_ptp *ptp = &adapter->ptp;
648 int perout_pin;
649 int event_ch;
650 u32 gen_cfg;
651 int val;
652
653 event_ch = ptp->ptp_io_perout[index];
654 if (event_ch >= 0) {
655 /* set target to far in the future, effectively disabling it */
656 lan743x_csr_write(adapter,
657 PTP_CLOCK_TARGET_SEC_X(event_ch),
658 0xFFFF0000);
659 lan743x_csr_write(adapter,
660 PTP_CLOCK_TARGET_NS_X(event_ch),
661 0);
662
663 gen_cfg = lan743x_csr_read(adapter, HS_PTP_GENERAL_CONFIG);
664 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_
665 (event_ch));
666 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_EVENT_POL_X_(event_ch));
667 gen_cfg |= HS_PTP_GENERAL_CONFIG_RELOAD_ADD_X_(event_ch);
668 lan743x_csr_write(adapter, HS_PTP_GENERAL_CONFIG, gen_cfg);
669 if (event_ch)
670 lan743x_csr_write(adapter, PTP_INT_STS,
671 PTP_INT_TIMER_INT_B_);
672 else
673 lan743x_csr_write(adapter, PTP_INT_STS,
674 PTP_INT_TIMER_INT_A_);
675 lan743x_ptp_release_event_ch(adapter, event_ch);
676 ptp->ptp_io_perout[index] = -1;
677 }
678
679 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, index);
680
681 /* Deselect Event output */
682 val = lan743x_csr_read(adapter, PTP_IO_EVENT_OUTPUT_CFG);
683
684 /* Disables the output of Local Time Target compare events */
685 val &= ~PTP_IO_EVENT_OUTPUT_CFG_EN_(perout_pin);
686 lan743x_csr_write(adapter, PTP_IO_EVENT_OUTPUT_CFG, val);
687
688 /* Configured as an opendrain driver*/
689 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG);
690 val &= ~PTP_IO_PIN_CFG_OBUF_TYPE_(perout_pin);
691 lan743x_csr_write(adapter, PTP_IO_PIN_CFG, val);
692 /* Dummy read to make sure write operation success */
693 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG);
694}
695
696static int lan743x_ptp_io_perout(struct lan743x_adapter *adapter, int on,
697 struct ptp_perout_request *perout_request)
698{
699 struct lan743x_ptp *ptp = &adapter->ptp;
700 u32 period_sec, period_nsec;
701 u32 start_sec, start_nsec;
702 u32 pulse_sec, pulse_nsec;
703 int pulse_width;
704 int perout_pin;
705 int event_ch;
706 u32 gen_cfg;
707 u32 index;
708 int val;
709
710 index = perout_request->index;
711 event_ch = ptp->ptp_io_perout[index];
712
713 if (on) {
714 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, index);
715 if (perout_pin < 0)
716 return -EBUSY;
717 } else {
718 lan743x_ptp_io_perout_off(adapter, index);
719 return 0;
720 }
721
722 if (event_ch >= LAN743X_PTP_N_EVENT_CHAN) {
723 /* already on, turn off first */
724 lan743x_ptp_io_perout_off(adapter, index);
725 }
726
727 event_ch = lan743x_ptp_reserve_event_ch(adapter, index);
728 if (event_ch < 0) {
729 netif_warn(adapter, drv, adapter->netdev,
730 "Failed to reserve event channel %d for PEROUT\n",
731 index);
732 goto failed;
733 }
734 ptp->ptp_io_perout[index] = event_ch;
735
736 if (perout_request->flags & PTP_PEROUT_DUTY_CYCLE) {
737 pulse_sec = perout_request->on.sec;
738 pulse_sec += perout_request->on.nsec / 1000000000;
739 pulse_nsec = perout_request->on.nsec % 1000000000;
740 } else {
741 pulse_sec = perout_request->period.sec;
742 pulse_sec += perout_request->period.nsec / 1000000000;
743 pulse_nsec = perout_request->period.nsec % 1000000000;
744 }
745
746 if (pulse_sec == 0) {
747 if (pulse_nsec >= 400000000) {
748 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
749 } else if (pulse_nsec >= 200000000) {
750 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100MS_;
751 } else if (pulse_nsec >= 100000000) {
752 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_50MS_;
753 } else if (pulse_nsec >= 20000000) {
754 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_;
755 } else if (pulse_nsec >= 10000000) {
756 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_5MS_;
757 } else if (pulse_nsec >= 2000000) {
758 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_;
759 } else if (pulse_nsec >= 1000000) {
760 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_500US_;
761 } else if (pulse_nsec >= 200000) {
762 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_;
763 } else if (pulse_nsec >= 100000) {
764 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_50US_;
765 } else if (pulse_nsec >= 20000) {
766 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_;
767 } else if (pulse_nsec >= 10000) {
768 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_5US_;
769 } else if (pulse_nsec >= 2000) {
770 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_1US_;
771 } else if (pulse_nsec >= 1000) {
772 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_500NS_;
773 } else if (pulse_nsec >= 200) {
774 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_;
775 } else {
776 netif_warn(adapter, drv, adapter->netdev,
777 "perout period too small, min is 200nS\n");
778 goto failed;
779 }
780 } else {
781 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_;
782 }
783
784 /* turn off by setting target far in future */
785 lan743x_csr_write(adapter,
786 PTP_CLOCK_TARGET_SEC_X(event_ch),
787 0xFFFF0000);
788 lan743x_csr_write(adapter,
789 PTP_CLOCK_TARGET_NS_X(event_ch), 0);
790
791 /* Configure to pulse every period */
792 gen_cfg = lan743x_csr_read(adapter, HS_PTP_GENERAL_CONFIG);
793 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_(event_ch));
794 gen_cfg |= HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_
795 (event_ch, pulse_width);
796 gen_cfg |= HS_PTP_GENERAL_CONFIG_EVENT_POL_X_(event_ch);
797 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_RELOAD_ADD_X_(event_ch));
798 lan743x_csr_write(adapter, HS_PTP_GENERAL_CONFIG, gen_cfg);
799
800 /* set the reload to one toggle cycle */
801 period_sec = perout_request->period.sec;
802 period_sec += perout_request->period.nsec / 1000000000;
803 period_nsec = perout_request->period.nsec % 1000000000;
804 lan743x_csr_write(adapter,
805 PTP_CLOCK_TARGET_RELOAD_SEC_X(event_ch),
806 period_sec);
807 lan743x_csr_write(adapter,
808 PTP_CLOCK_TARGET_RELOAD_NS_X(event_ch),
809 period_nsec);
810
811 start_sec = perout_request->start.sec;
812 start_sec += perout_request->start.nsec / 1000000000;
813 start_nsec = perout_request->start.nsec % 1000000000;
814
815 /* set the start time */
816 lan743x_csr_write(adapter,
817 PTP_CLOCK_TARGET_SEC_X(event_ch),
818 start_sec);
819 lan743x_csr_write(adapter,
820 PTP_CLOCK_TARGET_NS_X(event_ch),
821 start_nsec);
822
823 /* Enable LTC Target Read */
824 val = lan743x_csr_read(adapter, PTP_CMD_CTL);
825 val |= PTP_CMD_CTL_PTP_LTC_TARGET_READ_;
826 lan743x_csr_write(adapter, PTP_CMD_CTL, val);
827
828 /* Configure as an push/pull driver */
829 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG);
830 val |= PTP_IO_PIN_CFG_OBUF_TYPE_(perout_pin);
831 lan743x_csr_write(adapter, PTP_IO_PIN_CFG, val);
832
833 /* Select Event output */
834 val = lan743x_csr_read(adapter, PTP_IO_EVENT_OUTPUT_CFG);
835 if (event_ch)
836 /* Channel B as the output */
837 val |= PTP_IO_EVENT_OUTPUT_CFG_SEL_(perout_pin);
838 else
839 /* Channel A as the output */
840 val &= ~PTP_IO_EVENT_OUTPUT_CFG_SEL_(perout_pin);
841
842 /* Enables the output of Local Time Target compare events */
843 val |= PTP_IO_EVENT_OUTPUT_CFG_EN_(perout_pin);
844 lan743x_csr_write(adapter, PTP_IO_EVENT_OUTPUT_CFG, val);
845
846 return 0;
847
848failed:
849 lan743x_ptp_io_perout_off(adapter, index);
850 return -ENODEV;
851}
852
853static void lan743x_ptp_io_extts_off(struct lan743x_adapter *adapter,
854 u32 index)
855{
856 struct lan743x_ptp *ptp = &adapter->ptp;
857 struct lan743x_extts *extts;
858 int val;
859
860 extts = &ptp->extts[index];
861 /* PTP Interrupt Enable Clear Register */
862 if (extts->flags & PTP_FALLING_EDGE)
863 val = PTP_INT_EN_FE_EN_CLR_(index);
864 else
865 val = PTP_INT_EN_RE_EN_CLR_(index);
866 lan743x_csr_write(adapter, PTP_INT_EN_CLR, val);
867
868 /* Disables PTP-IO edge lock */
869 val = lan743x_csr_read(adapter, PTP_IO_CAP_CONFIG);
870 if (extts->flags & PTP_FALLING_EDGE) {
871 val &= ~PTP_IO_CAP_CONFIG_LOCK_FE_(index);
872 val &= ~PTP_IO_CAP_CONFIG_FE_CAP_EN_(index);
873 } else {
874 val &= ~PTP_IO_CAP_CONFIG_LOCK_RE_(index);
875 val &= ~PTP_IO_CAP_CONFIG_RE_CAP_EN_(index);
876 }
877 lan743x_csr_write(adapter, PTP_IO_CAP_CONFIG, val);
878
879 /* PTP-IO De-select register */
880 val = lan743x_csr_read(adapter, PTP_IO_SEL);
881 val &= ~PTP_IO_SEL_MASK_;
882 lan743x_csr_write(adapter, PTP_IO_SEL, val);
883
884 /* Clear timestamp */
885 memset(&extts->ts, 0, sizeof(struct timespec64));
886 extts->flags = 0;
887}
888
889static int lan743x_ptp_io_event_cap_en(struct lan743x_adapter *adapter,
890 u32 flags, u32 channel)
891{
892 struct lan743x_ptp *ptp = &adapter->ptp;
893 int val;
894
895 if ((flags & PTP_EXTTS_EDGES) == PTP_EXTTS_EDGES)
896 return -EOPNOTSUPP;
897
898 mutex_lock(&ptp->command_lock);
899 /* PTP-IO Event Capture Enable */
900 val = lan743x_csr_read(adapter, PTP_IO_CAP_CONFIG);
901 if (flags & PTP_FALLING_EDGE) {
902 val &= ~PTP_IO_CAP_CONFIG_LOCK_RE_(channel);
903 val &= ~PTP_IO_CAP_CONFIG_RE_CAP_EN_(channel);
904 val |= PTP_IO_CAP_CONFIG_LOCK_FE_(channel);
905 val |= PTP_IO_CAP_CONFIG_FE_CAP_EN_(channel);
906 } else {
907 /* Rising eventing as Default */
908 val &= ~PTP_IO_CAP_CONFIG_LOCK_FE_(channel);
909 val &= ~PTP_IO_CAP_CONFIG_FE_CAP_EN_(channel);
910 val |= PTP_IO_CAP_CONFIG_LOCK_RE_(channel);
911 val |= PTP_IO_CAP_CONFIG_RE_CAP_EN_(channel);
912 }
913 lan743x_csr_write(adapter, PTP_IO_CAP_CONFIG, val);
914
915 /* PTP-IO Select */
916 val = lan743x_csr_read(adapter, PTP_IO_SEL);
917 val &= ~PTP_IO_SEL_MASK_;
918 val |= channel << PTP_IO_SEL_SHIFT_;
919 lan743x_csr_write(adapter, PTP_IO_SEL, val);
920
921 /* PTP Interrupt Enable Register */
922 if (flags & PTP_FALLING_EDGE)
923 val = PTP_INT_EN_FE_EN_SET_(channel);
924 else
925 val = PTP_INT_EN_RE_EN_SET_(channel);
926 lan743x_csr_write(adapter, PTP_INT_EN_SET, val);
927
928 mutex_unlock(&ptp->command_lock);
929
930 return 0;
931}
932
933static int lan743x_ptp_io_extts(struct lan743x_adapter *adapter, int on,
934 struct ptp_extts_request *extts_request)
935{
936 struct lan743x_ptp *ptp = &adapter->ptp;
937 u32 flags = extts_request->flags;
938 u32 index = extts_request->index;
939 struct lan743x_extts *extts;
940 int extts_pin;
941 int ret = 0;
942
943 extts = &ptp->extts[index];
944
945 if (on) {
946 extts_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_EXTTS, index);
947 if (extts_pin < 0)
948 return -EBUSY;
949
950 ret = lan743x_ptp_io_event_cap_en(adapter, flags, index);
951 if (!ret)
952 extts->flags = flags;
953 } else {
954 lan743x_ptp_io_extts_off(adapter, index);
955 }
956
957 return ret;
958}
959
960static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci,
961 struct ptp_clock_request *request, int on)
962{
963 struct lan743x_ptp *ptp =
964 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
965 struct lan743x_adapter *adapter =
966 container_of(ptp, struct lan743x_adapter, ptp);
967
968 if (request) {
969 switch (request->type) {
970 case PTP_CLK_REQ_EXTTS:
971 if (request->extts.index < ptpci->n_ext_ts)
972 return lan743x_ptp_io_extts(adapter, on,
973 &request->extts);
974 return -EINVAL;
975 case PTP_CLK_REQ_PEROUT:
976 if (request->perout.index < ptpci->n_per_out) {
977 if (adapter->is_pci11x1x)
978 return lan743x_ptp_io_perout(adapter, on,
979 &request->perout);
980 else
981 return lan743x_ptp_perout(adapter, on,
982 &request->perout);
983 }
984 return -EINVAL;
985 case PTP_CLK_REQ_PPS:
986 return -EINVAL;
987 default:
988 netif_err(adapter, drv, adapter->netdev,
989 "request->type == %d, Unknown\n",
990 request->type);
991 break;
992 }
993 } else {
994 netif_err(adapter, drv, adapter->netdev, "request == NULL\n");
995 }
996 return 0;
997}
998
999static int lan743x_ptpci_verify_pin_config(struct ptp_clock_info *ptp,
1000 unsigned int pin,
1001 enum ptp_pin_function func,
1002 unsigned int chan)
1003{
1004 struct lan743x_ptp *lan_ptp =
1005 container_of(ptp, struct lan743x_ptp, ptp_clock_info);
1006 struct lan743x_adapter *adapter =
1007 container_of(lan_ptp, struct lan743x_adapter, ptp);
1008 int result = 0;
1009
1010 /* Confirm the requested function is supported. Parameter
1011 * validation is done by the caller.
1012 */
1013 switch (func) {
1014 case PTP_PF_NONE:
1015 case PTP_PF_PEROUT:
1016 break;
1017 case PTP_PF_EXTTS:
1018 if (!adapter->is_pci11x1x)
1019 result = -1;
1020 break;
1021 case PTP_PF_PHYSYNC:
1022 default:
1023 result = -1;
1024 break;
1025 }
1026 return result;
1027}
1028
1029static void lan743x_ptp_io_event_clock_get(struct lan743x_adapter *adapter,
1030 bool fe, u8 channel,
1031 struct timespec64 *ts)
1032{
1033 struct lan743x_ptp *ptp = &adapter->ptp;
1034 struct lan743x_extts *extts;
1035 u32 sec, nsec;
1036
1037 mutex_lock(&ptp->command_lock);
1038 if (fe) {
1039 sec = lan743x_csr_read(adapter, PTP_IO_FE_LTC_SEC_CAP_X);
1040 nsec = lan743x_csr_read(adapter, PTP_IO_FE_LTC_NS_CAP_X);
1041 } else {
1042 sec = lan743x_csr_read(adapter, PTP_IO_RE_LTC_SEC_CAP_X);
1043 nsec = lan743x_csr_read(adapter, PTP_IO_RE_LTC_NS_CAP_X);
1044 }
1045
1046 mutex_unlock(&ptp->command_lock);
1047
1048 /* Update Local timestamp */
1049 extts = &ptp->extts[channel];
1050 extts->ts.tv_sec = sec;
1051 extts->ts.tv_nsec = nsec;
1052 ts->tv_sec = sec;
1053 ts->tv_nsec = nsec;
1054}
1055
1056static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci)
1057{
1058 struct lan743x_ptp *ptp =
1059 container_of(ptpci, struct lan743x_ptp, ptp_clock_info);
1060 struct lan743x_adapter *adapter =
1061 container_of(ptp, struct lan743x_adapter, ptp);
1062 u32 cap_info, cause, header, nsec, seconds;
1063 bool new_timestamp_available = false;
1064 struct ptp_clock_event ptp_event;
1065 struct timespec64 ts;
1066 int ptp_int_sts;
1067 int count = 0;
1068 int channel;
1069 s64 ns;
1070
1071 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
1072 while ((count < 100) && ptp_int_sts) {
1073 count++;
1074
1075 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) {
1076 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO);
1077
1078 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) {
1079 seconds = lan743x_csr_read(adapter,
1080 PTP_TX_EGRESS_SEC);
1081 nsec = lan743x_csr_read(adapter,
1082 PTP_TX_EGRESS_NS);
1083 cause = (nsec &
1084 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_);
1085 header = lan743x_csr_read(adapter,
1086 PTP_TX_MSG_HEADER);
1087
1088 if (cause ==
1089 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) {
1090 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_;
1091 lan743x_ptp_tx_ts_enqueue_ts(adapter,
1092 seconds,
1093 nsec,
1094 header);
1095 new_timestamp_available = true;
1096 } else if (cause ==
1097 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) {
1098 netif_err(adapter, drv, adapter->netdev,
1099 "Auto capture cause not supported\n");
1100 } else {
1101 netif_warn(adapter, drv, adapter->netdev,
1102 "unknown tx timestamp capture cause\n");
1103 }
1104 } else {
1105 netif_warn(adapter, drv, adapter->netdev,
1106 "TX TS INT but no TX TS CNT\n");
1107 }
1108 lan743x_csr_write(adapter, PTP_INT_STS,
1109 PTP_INT_BIT_TX_TS_);
1110 }
1111
1112 if (ptp_int_sts & PTP_INT_IO_FE_MASK_) {
1113 do {
1114 channel = lan743x_get_channel((ptp_int_sts &
1115 PTP_INT_IO_FE_MASK_) >>
1116 PTP_INT_IO_FE_SHIFT_);
1117 if (channel >= 0 &&
1118 channel < PCI11X1X_PTP_IO_MAX_CHANNELS) {
1119 lan743x_ptp_io_event_clock_get(adapter,
1120 true,
1121 channel,
1122 &ts);
1123 /* PTP Falling Event post */
1124 ns = timespec64_to_ns(&ts);
1125 ptp_event.timestamp = ns;
1126 ptp_event.index = channel;
1127 ptp_event.type = PTP_CLOCK_EXTTS;
1128 ptp_clock_event(ptp->ptp_clock,
1129 &ptp_event);
1130 lan743x_csr_write(adapter, PTP_INT_STS,
1131 PTP_INT_IO_FE_SET_
1132 (channel));
1133 ptp_int_sts &= ~(1 <<
1134 (PTP_INT_IO_FE_SHIFT_ +
1135 channel));
1136 } else {
1137 /* Clear falling event interrupts */
1138 lan743x_csr_write(adapter, PTP_INT_STS,
1139 PTP_INT_IO_FE_MASK_);
1140 ptp_int_sts &= ~PTP_INT_IO_FE_MASK_;
1141 }
1142 } while (ptp_int_sts & PTP_INT_IO_FE_MASK_);
1143 }
1144
1145 if (ptp_int_sts & PTP_INT_IO_RE_MASK_) {
1146 do {
1147 channel = lan743x_get_channel((ptp_int_sts &
1148 PTP_INT_IO_RE_MASK_) >>
1149 PTP_INT_IO_RE_SHIFT_);
1150 if (channel >= 0 &&
1151 channel < PCI11X1X_PTP_IO_MAX_CHANNELS) {
1152 lan743x_ptp_io_event_clock_get(adapter,
1153 false,
1154 channel,
1155 &ts);
1156 /* PTP Rising Event post */
1157 ns = timespec64_to_ns(&ts);
1158 ptp_event.timestamp = ns;
1159 ptp_event.index = channel;
1160 ptp_event.type = PTP_CLOCK_EXTTS;
1161 ptp_clock_event(ptp->ptp_clock,
1162 &ptp_event);
1163 lan743x_csr_write(adapter, PTP_INT_STS,
1164 PTP_INT_IO_RE_SET_
1165 (channel));
1166 ptp_int_sts &= ~(1 <<
1167 (PTP_INT_IO_RE_SHIFT_ +
1168 channel));
1169 } else {
1170 /* Clear Rising event interrupt */
1171 lan743x_csr_write(adapter, PTP_INT_STS,
1172 PTP_INT_IO_RE_MASK_);
1173 ptp_int_sts &= ~PTP_INT_IO_RE_MASK_;
1174 }
1175 } while (ptp_int_sts & PTP_INT_IO_RE_MASK_);
1176 }
1177
1178 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
1179 }
1180
1181 if (new_timestamp_available)
1182 lan743x_ptp_tx_ts_complete(adapter);
1183
1184 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
1185
1186 return -1;
1187}
1188
1189static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,
1190 u32 *seconds, u32 *nano_seconds,
1191 u32 *sub_nano_seconds)
1192{
1193 struct lan743x_ptp *ptp = &adapter->ptp;
1194
1195 mutex_lock(&ptp->command_lock);
1196
1197 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_);
1198 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_);
1199
1200 if (seconds)
1201 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC);
1202
1203 if (nano_seconds)
1204 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS);
1205
1206 if (sub_nano_seconds)
1207 (*sub_nano_seconds) =
1208 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS);
1209
1210 mutex_unlock(&ptp->command_lock);
1211}
1212
1213static void lan743x_ptp_io_clock_get(struct lan743x_adapter *adapter,
1214 u32 *sec, u32 *nsec, u32 *sub_nsec)
1215{
1216 struct lan743x_ptp *ptp = &adapter->ptp;
1217
1218 mutex_lock(&ptp->command_lock);
1219 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_);
1220 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_);
1221
1222 if (sec)
1223 (*sec) = lan743x_csr_read(adapter, PTP_LTC_RD_SEC_LO);
1224
1225 if (nsec)
1226 (*nsec) = lan743x_csr_read(adapter, PTP_LTC_RD_NS);
1227
1228 if (sub_nsec)
1229 (*sub_nsec) =
1230 lan743x_csr_read(adapter, PTP_LTC_RD_SUBNS);
1231
1232 mutex_unlock(&ptp->command_lock);
1233}
1234
1235static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,
1236 s64 time_step_ns)
1237{
1238 struct lan743x_ptp *ptp = &adapter->ptp;
1239 u32 nano_seconds_step = 0;
1240 u64 abs_time_step_ns = 0;
1241 u32 unsigned_seconds = 0;
1242 u32 nano_seconds = 0;
1243 u32 remainder = 0;
1244 s32 seconds = 0;
1245
1246 if (time_step_ns > 15000000000LL) {
1247 /* convert to clock set */
1248 if (adapter->is_pci11x1x)
1249 lan743x_ptp_io_clock_get(adapter, &unsigned_seconds,
1250 &nano_seconds, NULL);
1251 else
1252 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
1253 &nano_seconds, NULL);
1254 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL,
1255 &remainder);
1256 nano_seconds += remainder;
1257 if (nano_seconds >= 1000000000) {
1258 unsigned_seconds++;
1259 nano_seconds -= 1000000000;
1260 }
1261 lan743x_ptp_clock_set(adapter, unsigned_seconds,
1262 nano_seconds, 0);
1263 return;
1264 } else if (time_step_ns < -15000000000LL) {
1265 /* convert to clock set */
1266 time_step_ns = -time_step_ns;
1267
1268 if (adapter->is_pci11x1x) {
1269 lan743x_ptp_io_clock_get(adapter, &unsigned_seconds,
1270 &nano_seconds, NULL);
1271 } else {
1272 lan743x_ptp_clock_get(adapter, &unsigned_seconds,
1273 &nano_seconds, NULL);
1274 }
1275 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL,
1276 &remainder);
1277 nano_seconds_step = remainder;
1278 if (nano_seconds < nano_seconds_step) {
1279 unsigned_seconds--;
1280 nano_seconds += 1000000000;
1281 }
1282 nano_seconds -= nano_seconds_step;
1283 lan743x_ptp_clock_set(adapter, unsigned_seconds,
1284 nano_seconds, 0);
1285 return;
1286 }
1287
1288 /* do clock step */
1289 if (time_step_ns >= 0) {
1290 abs_time_step_ns = (u64)(time_step_ns);
1291 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000,
1292 &remainder);
1293 nano_seconds = (u32)remainder;
1294 } else {
1295 abs_time_step_ns = (u64)(-time_step_ns);
1296 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000,
1297 &remainder));
1298 nano_seconds = (u32)remainder;
1299 if (nano_seconds > 0) {
1300 /* subtracting nano seconds is not allowed
1301 * convert to subtracting from seconds,
1302 * and adding to nanoseconds
1303 */
1304 seconds--;
1305 nano_seconds = (1000000000 - nano_seconds);
1306 }
1307 }
1308
1309 if (nano_seconds > 0) {
1310 /* add 8 ns to cover the likely normal increment */
1311 nano_seconds += 8;
1312 }
1313
1314 if (nano_seconds >= 1000000000) {
1315 /* carry into seconds */
1316 seconds++;
1317 nano_seconds -= 1000000000;
1318 }
1319
1320 while (seconds) {
1321 mutex_lock(&ptp->command_lock);
1322 if (seconds > 0) {
1323 u32 adjustment_value = (u32)seconds;
1324
1325 if (adjustment_value > 0xF)
1326 adjustment_value = 0xF;
1327 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
1328 PTP_CLOCK_STEP_ADJ_DIR_ |
1329 adjustment_value);
1330 seconds -= ((s32)adjustment_value);
1331 } else {
1332 u32 adjustment_value = (u32)(-seconds);
1333
1334 if (adjustment_value > 0xF)
1335 adjustment_value = 0xF;
1336 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
1337 adjustment_value);
1338 seconds += ((s32)adjustment_value);
1339 }
1340 lan743x_csr_write(adapter, PTP_CMD_CTL,
1341 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
1342 lan743x_ptp_wait_till_cmd_done(adapter,
1343 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_);
1344 mutex_unlock(&ptp->command_lock);
1345 }
1346 if (nano_seconds) {
1347 mutex_lock(&ptp->command_lock);
1348 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ,
1349 PTP_CLOCK_STEP_ADJ_DIR_ |
1350 (nano_seconds &
1351 PTP_CLOCK_STEP_ADJ_VALUE_MASK_));
1352 lan743x_csr_write(adapter, PTP_CMD_CTL,
1353 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
1354 lan743x_ptp_wait_till_cmd_done(adapter,
1355 PTP_CMD_CTL_PTP_CLK_STP_NSEC_);
1356 mutex_unlock(&ptp->command_lock);
1357 }
1358}
1359
1360void lan743x_ptp_isr(void *context)
1361{
1362 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context;
1363 struct lan743x_ptp *ptp = NULL;
1364 int enable_flag = 1;
1365 u32 ptp_int_sts = 0;
1366
1367 ptp = &adapter->ptp;
1368
1369 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
1370
1371 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS);
1372 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET);
1373
1374 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) {
1375 ptp_schedule_worker(ptp->ptp_clock, 0);
1376 enable_flag = 0;/* tasklet will re-enable later */
1377 }
1378 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) {
1379 netif_err(adapter, drv, adapter->netdev,
1380 "PTP TX Software Timestamp Error\n");
1381 /* clear int status bit */
1382 lan743x_csr_write(adapter, PTP_INT_STS,
1383 PTP_INT_BIT_TX_SWTS_ERR_);
1384 }
1385 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) {
1386 /* clear int status bit */
1387 lan743x_csr_write(adapter, PTP_INT_STS,
1388 PTP_INT_BIT_TIMER_B_);
1389 }
1390 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) {
1391 /* clear int status bit */
1392 lan743x_csr_write(adapter, PTP_INT_STS,
1393 PTP_INT_BIT_TIMER_A_);
1394 }
1395
1396 if (enable_flag) {
1397 /* re-enable isr */
1398 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
1399 }
1400}
1401
1402static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter,
1403 struct sk_buff *skb, bool ignore_sync)
1404{
1405 struct lan743x_ptp *ptp = &adapter->ptp;
1406
1407 spin_lock_bh(&ptp->tx_ts_lock);
1408 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
1409 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb;
1410 if (ignore_sync)
1411 ptp->tx_ts_ignore_sync_queue |=
1412 BIT(ptp->tx_ts_skb_queue_size);
1413 ptp->tx_ts_skb_queue_size++;
1414 } else {
1415 /* this should never happen, so long as the tx channel
1416 * calls and honors the result from
1417 * lan743x_ptp_request_tx_timestamp
1418 */
1419 netif_err(adapter, drv, adapter->netdev,
1420 "tx ts skb queue overflow\n");
1421 dev_kfree_skb(skb);
1422 }
1423 spin_unlock_bh(&ptp->tx_ts_lock);
1424}
1425
1426static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter)
1427{
1428 struct timespec64 ts;
1429
1430 ktime_get_clocktai_ts64(&ts);
1431
1432 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0);
1433}
1434
1435void lan743x_ptp_update_latency(struct lan743x_adapter *adapter,
1436 u32 link_speed)
1437{
1438 switch (link_speed) {
1439 case 10:
1440 lan743x_csr_write(adapter, PTP_LATENCY,
1441 PTP_LATENCY_TX_SET_(0) |
1442 PTP_LATENCY_RX_SET_(0));
1443 break;
1444 case 100:
1445 lan743x_csr_write(adapter, PTP_LATENCY,
1446 PTP_LATENCY_TX_SET_(181) |
1447 PTP_LATENCY_RX_SET_(594));
1448 break;
1449 case 1000:
1450 lan743x_csr_write(adapter, PTP_LATENCY,
1451 PTP_LATENCY_TX_SET_(30) |
1452 PTP_LATENCY_RX_SET_(525));
1453 break;
1454 }
1455}
1456
1457int lan743x_ptp_init(struct lan743x_adapter *adapter)
1458{
1459 struct lan743x_ptp *ptp = &adapter->ptp;
1460 int i;
1461
1462 mutex_init(&ptp->command_lock);
1463 spin_lock_init(&ptp->tx_ts_lock);
1464 ptp->used_event_ch = 0;
1465
1466 for (i = 0; i < LAN743X_PTP_N_EVENT_CHAN; i++) {
1467 ptp->perout[i].event_ch = -1;
1468 ptp->perout[i].gpio_pin = -1;
1469 }
1470
1471 lan743x_led_mux_save(adapter);
1472
1473 return 0;
1474}
1475
1476int lan743x_ptp_open(struct lan743x_adapter *adapter)
1477{
1478 struct lan743x_ptp *ptp = &adapter->ptp;
1479 int ret = -ENODEV;
1480 u32 temp;
1481 int i;
1482 int n_pins;
1483
1484 lan743x_ptp_reset(adapter);
1485 lan743x_ptp_sync_to_system_clock(adapter);
1486 temp = lan743x_csr_read(adapter, PTP_TX_MOD2);
1487 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_;
1488 lan743x_csr_write(adapter, PTP_TX_MOD2, temp);
1489
1490 /* Default Timestamping */
1491 lan743x_rx_set_tstamp_mode(adapter, HWTSTAMP_FILTER_NONE);
1492
1493 lan743x_ptp_enable(adapter);
1494 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_);
1495 lan743x_csr_write(adapter, PTP_INT_EN_SET,
1496 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_);
1497 ptp->flags |= PTP_FLAG_ISR_ENABLED;
1498
1499 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK))
1500 return 0;
1501
1502 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) {
1503 case ID_REV_ID_LAN7430_:
1504 n_pins = LAN7430_N_GPIO;
1505 break;
1506 case ID_REV_ID_LAN7431_:
1507 case ID_REV_ID_A011_:
1508 case ID_REV_ID_A041_:
1509 n_pins = LAN7431_N_GPIO;
1510 break;
1511 default:
1512 netif_warn(adapter, drv, adapter->netdev,
1513 "Unknown LAN743x (%08x). Assuming no GPIO\n",
1514 adapter->csr.id_rev);
1515 n_pins = 0;
1516 break;
1517 }
1518
1519 if (n_pins > LAN743X_PTP_N_GPIO)
1520 n_pins = LAN743X_PTP_N_GPIO;
1521
1522 for (i = 0; i < n_pins; i++) {
1523 struct ptp_pin_desc *ptp_pin = &ptp->pin_config[i];
1524
1525 snprintf(ptp_pin->name,
1526 sizeof(ptp_pin->name), "lan743x_ptp_pin_%02d", i);
1527 ptp_pin->index = i;
1528 ptp_pin->func = PTP_PF_NONE;
1529 }
1530
1531 ptp->ptp_clock_info.owner = THIS_MODULE;
1532 snprintf(ptp->ptp_clock_info.name, 16, "%pm",
1533 adapter->netdev->dev_addr);
1534 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB;
1535 ptp->ptp_clock_info.n_alarm = 0;
1536 ptp->ptp_clock_info.n_ext_ts = LAN743X_PTP_N_EXTTS;
1537 ptp->ptp_clock_info.n_per_out = LAN743X_PTP_N_EVENT_CHAN;
1538 ptp->ptp_clock_info.n_pins = n_pins;
1539 ptp->ptp_clock_info.pps = LAN743X_PTP_N_PPS;
1540 ptp->ptp_clock_info.pin_config = ptp->pin_config;
1541 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine;
1542 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime;
1543 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64;
1544 ptp->ptp_clock_info.getcrosststamp = NULL;
1545 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64;
1546 ptp->ptp_clock_info.enable = lan743x_ptpci_enable;
1547 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work;
1548 ptp->ptp_clock_info.verify = lan743x_ptpci_verify_pin_config;
1549
1550 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info,
1551 &adapter->pdev->dev);
1552
1553 if (IS_ERR(ptp->ptp_clock)) {
1554 netif_err(adapter, ifup, adapter->netdev,
1555 "ptp_clock_register failed\n");
1556 goto done;
1557 }
1558 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED;
1559 netif_info(adapter, ifup, adapter->netdev,
1560 "successfully registered ptp clock\n");
1561
1562 return 0;
1563done:
1564 lan743x_ptp_close(adapter);
1565 return ret;
1566}
1567
1568void lan743x_ptp_close(struct lan743x_adapter *adapter)
1569{
1570 struct lan743x_ptp *ptp = &adapter->ptp;
1571 int index;
1572
1573 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) &&
1574 (ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED)) {
1575 ptp_clock_unregister(ptp->ptp_clock);
1576 ptp->ptp_clock = NULL;
1577 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED;
1578 netif_info(adapter, drv, adapter->netdev,
1579 "ptp clock unregister\n");
1580 }
1581
1582 if (ptp->flags & PTP_FLAG_ISR_ENABLED) {
1583 lan743x_csr_write(adapter, PTP_INT_EN_CLR,
1584 PTP_INT_BIT_TX_SWTS_ERR_ |
1585 PTP_INT_BIT_TX_TS_);
1586 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_);
1587 ptp->flags &= ~PTP_FLAG_ISR_ENABLED;
1588 }
1589
1590 /* clean up pending timestamp requests */
1591 lan743x_ptp_tx_ts_complete(adapter);
1592 spin_lock_bh(&ptp->tx_ts_lock);
1593 for (index = 0;
1594 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS;
1595 index++) {
1596 struct sk_buff *skb = ptp->tx_ts_skb_queue[index];
1597
1598 dev_kfree_skb(skb);
1599 ptp->tx_ts_skb_queue[index] = NULL;
1600 ptp->tx_ts_seconds_queue[index] = 0;
1601 ptp->tx_ts_nseconds_queue[index] = 0;
1602 }
1603 ptp->tx_ts_skb_queue_size = 0;
1604 ptp->tx_ts_queue_size = 0;
1605 ptp->pending_tx_timestamps = 0;
1606 spin_unlock_bh(&ptp->tx_ts_lock);
1607
1608 lan743x_led_mux_restore(adapter);
1609
1610 lan743x_ptp_disable(adapter);
1611}
1612
1613static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter,
1614 bool ts_insert_enable)
1615{
1616 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD);
1617
1618 if (ts_insert_enable)
1619 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
1620 else
1621 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_;
1622
1623 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod);
1624}
1625
1626static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter)
1627{
1628 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_)
1629 return true;
1630 return false;
1631}
1632
1633static void lan743x_ptp_enable(struct lan743x_adapter *adapter)
1634{
1635 struct lan743x_ptp *ptp = &adapter->ptp;
1636
1637 mutex_lock(&ptp->command_lock);
1638
1639 if (lan743x_ptp_is_enabled(adapter)) {
1640 netif_warn(adapter, drv, adapter->netdev,
1641 "PTP already enabled\n");
1642 goto done;
1643 }
1644 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_);
1645done:
1646 mutex_unlock(&ptp->command_lock);
1647}
1648
1649static void lan743x_ptp_disable(struct lan743x_adapter *adapter)
1650{
1651 struct lan743x_ptp *ptp = &adapter->ptp;
1652
1653 /* Disable Timestamping */
1654 lan743x_rx_set_tstamp_mode(adapter, HWTSTAMP_FILTER_NONE);
1655
1656 mutex_lock(&ptp->command_lock);
1657 if (!lan743x_ptp_is_enabled(adapter)) {
1658 netif_warn(adapter, drv, adapter->netdev,
1659 "PTP already disabled\n");
1660 goto done;
1661 }
1662 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_);
1663 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_);
1664done:
1665 mutex_unlock(&ptp->command_lock);
1666}
1667
1668static void lan743x_ptp_reset(struct lan743x_adapter *adapter)
1669{
1670 struct lan743x_ptp *ptp = &adapter->ptp;
1671
1672 mutex_lock(&ptp->command_lock);
1673
1674 if (lan743x_ptp_is_enabled(adapter)) {
1675 netif_err(adapter, drv, adapter->netdev,
1676 "Attempting reset while enabled\n");
1677 goto done;
1678 }
1679
1680 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_);
1681 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_);
1682done:
1683 mutex_unlock(&ptp->command_lock);
1684}
1685
1686static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,
1687 u32 seconds, u32 nano_seconds,
1688 u32 sub_nano_seconds)
1689{
1690 struct lan743x_ptp *ptp = &adapter->ptp;
1691
1692 mutex_lock(&ptp->command_lock);
1693
1694 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds);
1695 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds);
1696 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds);
1697
1698 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1699 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_);
1700 mutex_unlock(&ptp->command_lock);
1701}
1702
1703bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter)
1704{
1705 struct lan743x_ptp *ptp = &adapter->ptp;
1706 bool result = false;
1707
1708 spin_lock(&ptp->tx_ts_lock);
1709 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) {
1710 /* request granted */
1711 ptp->pending_tx_timestamps++;
1712 result = true;
1713 }
1714 spin_unlock(&ptp->tx_ts_lock);
1715 return result;
1716}
1717
1718void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter)
1719{
1720 struct lan743x_ptp *ptp = &adapter->ptp;
1721
1722 spin_lock_bh(&ptp->tx_ts_lock);
1723 if (ptp->pending_tx_timestamps > 0)
1724 ptp->pending_tx_timestamps--;
1725 else
1726 netif_err(adapter, drv, adapter->netdev,
1727 "unrequest failed, pending_tx_timestamps==0\n");
1728 spin_unlock_bh(&ptp->tx_ts_lock);
1729}
1730
1731void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter,
1732 struct sk_buff *skb, bool ignore_sync)
1733{
1734 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync);
1735
1736 lan743x_ptp_tx_ts_complete(adapter);
1737}
1738
1739int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1740{
1741 struct lan743x_adapter *adapter = netdev_priv(netdev);
1742 struct hwtstamp_config config;
1743 int ret = 0;
1744 int index;
1745
1746 if (!ifr) {
1747 netif_err(adapter, drv, adapter->netdev,
1748 "SIOCSHWTSTAMP, ifr == NULL\n");
1749 return -EINVAL;
1750 }
1751
1752 if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
1753 return -EFAULT;
1754
1755 switch (config.tx_type) {
1756 case HWTSTAMP_TX_OFF:
1757 for (index = 0; index < adapter->used_tx_channels;
1758 index++)
1759 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1760 false, false);
1761 lan743x_ptp_set_sync_ts_insert(adapter, false);
1762 break;
1763 case HWTSTAMP_TX_ON:
1764 for (index = 0; index < adapter->used_tx_channels;
1765 index++)
1766 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1767 true, false);
1768 lan743x_ptp_set_sync_ts_insert(adapter, false);
1769 break;
1770 case HWTSTAMP_TX_ONESTEP_SYNC:
1771 for (index = 0; index < adapter->used_tx_channels;
1772 index++)
1773 lan743x_tx_set_timestamping_mode(&adapter->tx[index],
1774 true, true);
1775
1776 lan743x_ptp_set_sync_ts_insert(adapter, true);
1777 break;
1778 case HWTSTAMP_TX_ONESTEP_P2P:
1779 ret = -ERANGE;
1780 break;
1781 default:
1782 netif_warn(adapter, drv, adapter->netdev,
1783 " tx_type = %d, UNKNOWN\n", config.tx_type);
1784 ret = -EINVAL;
1785 break;
1786 }
1787
1788 ret = lan743x_rx_set_tstamp_mode(adapter, config.rx_filter);
1789
1790 if (!ret)
1791 return copy_to_user(ifr->ifr_data, &config,
1792 sizeof(config)) ? -EFAULT : 0;
1793 return ret;
1794}
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}