?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mtd: nand: brcmnand: Check flash #WP pin status before nand erase/program
[linux/fpc-iii.git] / drivers / staging / greybus / timesync.c
blob2e68af7dea6d51ad8c3ae5657e0af9debaf4a285
1 /*
2 * TimeSync API driver.
3 *
4 * Copyright 2016 Google Inc.
5 * Copyright 2016 Linaro Ltd.
6 *
7 * Released under the GPLv2 only.
8 */
9 #include <linux/debugfs.h>
10 #include <linux/hrtimer.h>
11 #include "greybus.h"
12 #include "timesync.h"
13 #include "greybus_trace.h"
14
15 /*
16 * Minimum inter-strobe value of one millisecond is chosen because it
17 * just-about fits the common definition of a jiffy.
18 *
19 * Maximum value OTOH is constrained by the number of bits the SVC can fit
20 * into a 16 bit up-counter. The SVC configures the timer in microseconds
21 * so the maximum allowable value is 65535 microseconds. We clip that value
22 * to 10000 microseconds for the sake of using nice round base 10 numbers
23 * and since right-now there's no imaginable use-case requiring anything
24 * other than a one millisecond inter-strobe time, let alone something
25 * higher than ten milliseconds.
26 */
27 #define GB_TIMESYNC_STROBE_DELAY_US 1000
28 #define GB_TIMESYNC_DEFAULT_OFFSET_US 1000
29
30 /* Work queue timers long, short and SVC strobe timeout */
31 #define GB_TIMESYNC_DELAYED_WORK_LONG msecs_to_jiffies(10)
32 #define GB_TIMESYNC_DELAYED_WORK_SHORT msecs_to_jiffies(1)
33 #define GB_TIMESYNC_MAX_WAIT_SVC msecs_to_jiffies(5000)
34 #define GB_TIMESYNC_KTIME_UPDATE msecs_to_jiffies(1000)
35 #define GB_TIMESYNC_MAX_KTIME_CONVERSION 15
36
37 /* Maximum number of times we'll retry a failed synchronous sync */
38 #define GB_TIMESYNC_MAX_RETRIES 5
39
40 /* Reported nanoseconds/femtoseconds per clock */
41 static u64 gb_timesync_ns_per_clock;
42 static u64 gb_timesync_fs_per_clock;
43
44 /* Maximum difference we will accept converting FrameTime to ktime */
45 static u32 gb_timesync_max_ktime_diff;
46
47 /* Reported clock rate */
48 static unsigned long gb_timesync_clock_rate;
49
50 /* Workqueue */
51 static void gb_timesync_worker(struct work_struct *work);
52
53 /* List of SVCs with one FrameTime per SVC */
54 static LIST_HEAD(gb_timesync_svc_list);
55
56 /* Synchronize parallel contexts accessing a valid timesync_svc pointer */
57 static DEFINE_MUTEX(gb_timesync_svc_list_mutex);
58
59 /* Structure to convert from FrameTime to timespec/ktime */
60 struct gb_timesync_frame_time_data {
61 u64 frame_time;
62 struct timespec ts;
63 };
64
65 struct gb_timesync_svc {
66 struct list_head list;
67 struct list_head interface_list;
68 struct gb_svc *svc;
69 struct gb_timesync_host_device *timesync_hd;
70
71 spinlock_t spinlock; /* Per SVC spinlock to sync with ISR */
72 struct mutex mutex; /* Per SVC mutex for regular synchronization */
73
74 struct dentry *frame_time_dentry;
75 struct dentry *frame_ktime_dentry;
76 struct workqueue_struct *work_queue;
77 wait_queue_head_t wait_queue;
78 struct delayed_work delayed_work;
79 struct timer_list ktime_timer;
80
81 /* The current local FrameTime */
82 u64 frame_time_offset;
83 struct gb_timesync_frame_time_data strobe_data[GB_TIMESYNC_MAX_STROBES];
84 struct gb_timesync_frame_time_data ktime_data;
85
86 /* The SVC FrameTime and relative AP FrameTime @ last TIMESYNC_PING */
87 u64 svc_ping_frame_time;
88 u64 ap_ping_frame_time;
89
90 /* Transitory settings */
91 u32 strobe_mask;
92 bool offset_down;
93 bool print_ping;
94 bool capture_ping;
95 int strobe;
96
97 /* Current state */
98 int state;
99 };
100
101 struct gb_timesync_host_device {
102 struct list_head list;
103 struct gb_host_device *hd;
104 u64 ping_frame_time;
105 };
106
107 struct gb_timesync_interface {
108 struct list_head list;
109 struct gb_interface *interface;
110 u64 ping_frame_time;
111 };
112
113 enum gb_timesync_state {
114 GB_TIMESYNC_STATE_INVALID = 0,
115 GB_TIMESYNC_STATE_INACTIVE = 1,
116 GB_TIMESYNC_STATE_INIT = 2,
117 GB_TIMESYNC_STATE_WAIT_SVC = 3,
118 GB_TIMESYNC_STATE_AUTHORITATIVE = 4,
119 GB_TIMESYNC_STATE_PING = 5,
120 GB_TIMESYNC_STATE_ACTIVE = 6,
121 };
122
123 static void gb_timesync_ktime_timer_fn(unsigned long data);
124
125 static u64 gb_timesync_adjust_count(struct gb_timesync_svc *timesync_svc,
126 u64 counts)
127 {
128 if (timesync_svc->offset_down)
129 return counts - timesync_svc->frame_time_offset;
130 else
131 return counts + timesync_svc->frame_time_offset;
132 }
133
134 /*
135 * This function provides the authoritative FrameTime to a calling function. It
136 * is designed to be lockless and should remain that way the caller is assumed
137 * to be state-aware.
138 */
139 static u64 __gb_timesync_get_frame_time(struct gb_timesync_svc *timesync_svc)
140 {
141 u64 clocks = gb_timesync_platform_get_counter();
142
143 return gb_timesync_adjust_count(timesync_svc, clocks);
144 }
145
146 static void gb_timesync_schedule_svc_timeout(struct gb_timesync_svc
147 *timesync_svc)
148 {
149 queue_delayed_work(timesync_svc->work_queue,
150 &timesync_svc->delayed_work,
151 GB_TIMESYNC_MAX_WAIT_SVC);
152 }
153
154 static void gb_timesync_set_state(struct gb_timesync_svc *timesync_svc,
155 int state)
156 {
157 switch (state) {
158 case GB_TIMESYNC_STATE_INVALID:
159 timesync_svc->state = state;
160 wake_up(&timesync_svc->wait_queue);
161 break;
162 case GB_TIMESYNC_STATE_INACTIVE:
163 timesync_svc->state = state;
164 wake_up(&timesync_svc->wait_queue);
165 break;
166 case GB_TIMESYNC_STATE_INIT:
167 if (timesync_svc->state != GB_TIMESYNC_STATE_INVALID) {
168 timesync_svc->strobe = 0;
169 timesync_svc->frame_time_offset = 0;
170 timesync_svc->state = state;
171 cancel_delayed_work(&timesync_svc->delayed_work);
172 queue_delayed_work(timesync_svc->work_queue,
173 &timesync_svc->delayed_work,
174 GB_TIMESYNC_DELAYED_WORK_LONG);
175 }
176 break;
177 case GB_TIMESYNC_STATE_WAIT_SVC:
178 if (timesync_svc->state == GB_TIMESYNC_STATE_INIT)
179 timesync_svc->state = state;
180 break;
181 case GB_TIMESYNC_STATE_AUTHORITATIVE:
182 if (timesync_svc->state == GB_TIMESYNC_STATE_WAIT_SVC) {
183 timesync_svc->state = state;
184 cancel_delayed_work(&timesync_svc->delayed_work);
185 queue_delayed_work(timesync_svc->work_queue,
186 &timesync_svc->delayed_work, 0);
187 }
188 break;
189 case GB_TIMESYNC_STATE_PING:
190 if (timesync_svc->state == GB_TIMESYNC_STATE_ACTIVE) {
191 timesync_svc->state = state;
192 queue_delayed_work(timesync_svc->work_queue,
193 &timesync_svc->delayed_work,
194 GB_TIMESYNC_DELAYED_WORK_SHORT);
195 }
196 break;
197 case GB_TIMESYNC_STATE_ACTIVE:
198 if (timesync_svc->state == GB_TIMESYNC_STATE_AUTHORITATIVE ||
199 timesync_svc->state == GB_TIMESYNC_STATE_PING) {
200 timesync_svc->state = state;
201 wake_up(&timesync_svc->wait_queue);
202 }
203 break;
204 }
205
206 if (WARN_ON(timesync_svc->state != state)) {
207 pr_err("Invalid state transition %d=>%d\n",
208 timesync_svc->state, state);
209 }
210 }
211
212 static void gb_timesync_set_state_atomic(struct gb_timesync_svc *timesync_svc,
213 int state)
214 {
215 unsigned long flags;
216
217 spin_lock_irqsave(&timesync_svc->spinlock, flags);
218 gb_timesync_set_state(timesync_svc, state);
219 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
220 }
221
222 static u64 gb_timesync_diff(u64 x, u64 y)
223 {
224 if (x > y)
225 return x - y;
226 else
227 return y - x;
228 }
229
230 static void gb_timesync_adjust_to_svc(struct gb_timesync_svc *svc,
231 u64 svc_frame_time, u64 ap_frame_time)
232 {
233 if (svc_frame_time > ap_frame_time) {
234 svc->frame_time_offset = svc_frame_time - ap_frame_time;
235 svc->offset_down = false;
236 } else {
237 svc->frame_time_offset = ap_frame_time - svc_frame_time;
238 svc->offset_down = true;
239 }
240 }
241
242 /*
243 * Associate a FrameTime with a ktime timestamp represented as struct timespec
244 * Requires the calling context to hold timesync_svc->mutex
245 */
246 static void gb_timesync_store_ktime(struct gb_timesync_svc *timesync_svc,
247 struct timespec ts, u64 frame_time)
248 {
249 timesync_svc->ktime_data.ts = ts;
250 timesync_svc->ktime_data.frame_time = frame_time;
251 }
252
253 /*
254 * Find the two pulses that best-match our expected inter-strobe gap and
255 * then calculate the difference between the SVC time at the second pulse
256 * to the local time at the second pulse.
257 */
258 static void gb_timesync_collate_frame_time(struct gb_timesync_svc *timesync_svc,
259 u64 *frame_time)
260 {
261 int i = 0;
262 u64 delta, ap_frame_time;
263 u64 strobe_delay_ns = GB_TIMESYNC_STROBE_DELAY_US * NSEC_PER_USEC;
264 u64 least = 0;
265
266 for (i = 1; i < GB_TIMESYNC_MAX_STROBES; i++) {
267 delta = timesync_svc->strobe_data[i].frame_time -
268 timesync_svc->strobe_data[i - 1].frame_time;
269 delta *= gb_timesync_ns_per_clock;
270 delta = gb_timesync_diff(delta, strobe_delay_ns);
271
272 if (!least || delta < least) {
273 least = delta;
274 gb_timesync_adjust_to_svc(timesync_svc, frame_time[i],
275 timesync_svc->strobe_data[i].frame_time);
276
277 ap_frame_time = timesync_svc->strobe_data[i].frame_time;
278 ap_frame_time = gb_timesync_adjust_count(timesync_svc,
279 ap_frame_time);
280 gb_timesync_store_ktime(timesync_svc,
281 timesync_svc->strobe_data[i].ts,
282 ap_frame_time);
283
284 pr_debug("adjust %s local %llu svc %llu delta %llu\n",
285 timesync_svc->offset_down ? "down" : "up",
286 timesync_svc->strobe_data[i].frame_time,
287 frame_time[i], delta);
288 }
289 }
290 }
291
292 static void gb_timesync_teardown(struct gb_timesync_svc *timesync_svc)
293 {
294 struct gb_timesync_interface *timesync_interface;
295 struct gb_svc *svc = timesync_svc->svc;
296 struct gb_interface *interface;
297 struct gb_host_device *hd;
298 int ret;
299
300 list_for_each_entry(timesync_interface,
301 &timesync_svc->interface_list, list) {
302 interface = timesync_interface->interface;
303 ret = gb_interface_timesync_disable(interface);
304 if (ret) {
305 dev_err(&interface->dev,
306 "interface timesync_disable %d\n", ret);
307 }
308 }
309
310 hd = timesync_svc->timesync_hd->hd;
311 ret = hd->driver->timesync_disable(hd);
312 if (ret < 0) {
313 dev_err(&hd->dev, "host timesync_disable %d\n",
314 ret);
315 }
316
317 gb_svc_timesync_wake_pins_release(svc);
318 gb_svc_timesync_disable(svc);
319 gb_timesync_platform_unlock_bus();
320
321 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_INACTIVE);
322 }
323
324 static void gb_timesync_platform_lock_bus_fail(struct gb_timesync_svc
325 *timesync_svc, int ret)
326 {
327 if (ret == -EAGAIN) {
328 gb_timesync_set_state(timesync_svc, timesync_svc->state);
329 } else {
330 pr_err("Failed to lock timesync bus %d\n", ret);
331 gb_timesync_set_state(timesync_svc, GB_TIMESYNC_STATE_INACTIVE);
332 }
333 }
334
335 static void gb_timesync_enable(struct gb_timesync_svc *timesync_svc)
336 {
337 struct gb_svc *svc = timesync_svc->svc;
338 struct gb_host_device *hd;
339 struct gb_timesync_interface *timesync_interface;
340 struct gb_interface *interface;
341 u64 init_frame_time;
342 unsigned long clock_rate = gb_timesync_clock_rate;
343 int ret;
344
345 /*
346 * Get access to the wake pins in the AP and SVC
347 * Release these pins either in gb_timesync_teardown() or in
348 * gb_timesync_authoritative()
349 */
350 ret = gb_timesync_platform_lock_bus(timesync_svc);
351 if (ret < 0) {
352 gb_timesync_platform_lock_bus_fail(timesync_svc, ret);
353 return;
354 }
355 ret = gb_svc_timesync_wake_pins_acquire(svc, timesync_svc->strobe_mask);
356 if (ret) {
357 dev_err(&svc->dev,
358 "gb_svc_timesync_wake_pins_acquire %d\n", ret);
359 gb_timesync_teardown(timesync_svc);
360 return;
361 }
362
363 /* Choose an initial time in the future */
364 init_frame_time = __gb_timesync_get_frame_time(timesync_svc) + 100000UL;
365
366 /* Send enable command to all relevant participants */
367 list_for_each_entry(timesync_interface, &timesync_svc->interface_list,
368 list) {
369 interface = timesync_interface->interface;
370 ret = gb_interface_timesync_enable(interface,
371 GB_TIMESYNC_MAX_STROBES,
372 init_frame_time,
373 GB_TIMESYNC_STROBE_DELAY_US,
374 clock_rate);
375 if (ret) {
376 dev_err(&interface->dev,
377 "interface timesync_enable %d\n", ret);
378 }
379 }
380
381 hd = timesync_svc->timesync_hd->hd;
382 ret = hd->driver->timesync_enable(hd, GB_TIMESYNC_MAX_STROBES,
383 init_frame_time,
384 GB_TIMESYNC_STROBE_DELAY_US,
385 clock_rate);
386 if (ret < 0) {
387 dev_err(&hd->dev, "host timesync_enable %d\n",
388 ret);
389 }
390
391 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_WAIT_SVC);
392 ret = gb_svc_timesync_enable(svc, GB_TIMESYNC_MAX_STROBES,
393 init_frame_time,
394 GB_TIMESYNC_STROBE_DELAY_US,
395 clock_rate);
396 if (ret) {
397 dev_err(&svc->dev,
398 "gb_svc_timesync_enable %d\n", ret);
399 gb_timesync_teardown(timesync_svc);
400 return;
401 }
402
403 /* Schedule a timeout waiting for SVC to complete strobing */
404 gb_timesync_schedule_svc_timeout(timesync_svc);
405 }
406
407 static void gb_timesync_authoritative(struct gb_timesync_svc *timesync_svc)
408 {
409 struct gb_svc *svc = timesync_svc->svc;
410 struct gb_host_device *hd;
411 struct gb_timesync_interface *timesync_interface;
412 struct gb_interface *interface;
413 u64 svc_frame_time[GB_TIMESYNC_MAX_STROBES];
414 int ret;
415
416 /* Get authoritative time from SVC and adjust local clock */
417 ret = gb_svc_timesync_authoritative(svc, svc_frame_time);
418 if (ret) {
419 dev_err(&svc->dev,
420 "gb_svc_timesync_authoritative %d\n", ret);
421 gb_timesync_teardown(timesync_svc);
422 return;
423 }
424 gb_timesync_collate_frame_time(timesync_svc, svc_frame_time);
425
426 /* Transmit authoritative time to downstream slaves */
427 hd = timesync_svc->timesync_hd->hd;
428 ret = hd->driver->timesync_authoritative(hd, svc_frame_time);
429 if (ret < 0)
430 dev_err(&hd->dev, "host timesync_authoritative %d\n", ret);
431
432 list_for_each_entry(timesync_interface,
433 &timesync_svc->interface_list, list) {
434 interface = timesync_interface->interface;
435 ret = gb_interface_timesync_authoritative(
436 interface,
437 svc_frame_time);
438 if (ret) {
439 dev_err(&interface->dev,
440 "interface timesync_authoritative %d\n", ret);
441 }
442 }
443
444 /* Release wake pins */
445 gb_svc_timesync_wake_pins_release(svc);
446 gb_timesync_platform_unlock_bus();
447
448 /* Transition to state ACTIVE */
449 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_ACTIVE);
450
451 /* Schedule a ping to verify the synchronized system time */
452 timesync_svc->print_ping = true;
453 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_PING);
454 }
455
456 static int __gb_timesync_get_status(struct gb_timesync_svc *timesync_svc)
457 {
458 int ret = -EINVAL;
459
460 switch (timesync_svc->state) {
461 case GB_TIMESYNC_STATE_INVALID:
462 case GB_TIMESYNC_STATE_INACTIVE:
463 ret = -ENODEV;
464 break;
465 case GB_TIMESYNC_STATE_INIT:
466 case GB_TIMESYNC_STATE_WAIT_SVC:
467 case GB_TIMESYNC_STATE_AUTHORITATIVE:
468 ret = -EAGAIN;
469 break;
470 case GB_TIMESYNC_STATE_PING:
471 case GB_TIMESYNC_STATE_ACTIVE:
472 ret = 0;
473 break;
474 }
475 return ret;
476 }
477
478 /*
479 * This routine takes a FrameTime and derives the difference with-respect
480 * to a reference FrameTime/ktime pair. It then returns the calculated
481 * ktime based on the difference between the supplied FrameTime and
482 * the reference FrameTime.
483 *
484 * The time difference is calculated to six decimal places. Taking 19.2MHz
485 * as an example this means we have 52.083333~ nanoseconds per clock or
486 * 52083333~ femtoseconds per clock.
487 *
488 * Naively taking the count difference and converting to
489 * seconds/nanoseconds would quickly see the 0.0833 component produce
490 * noticeable errors. For example a time difference of one second would
491 * loose 19200000 * 0.08333x nanoseconds or 1.59 seconds.
492 *
493 * In contrast calculating in femtoseconds the same example of 19200000 *
494 * 0.000000083333x nanoseconds per count of error is just 1.59 nanoseconds!
495 *
496 * Continuing the example of 19.2 MHz we cap the maximum error difference
497 * at a worst-case 0.3 microseconds over a potential calculation window of
498 * abount 15 seconds, meaning you can convert a FrameTime that is <= 15
499 * seconds older/younger than the reference time with a maximum error of
500 * 0.2385 useconds. Note 19.2MHz is an example frequency not a requirement.
501 */
502 static int gb_timesync_to_timespec(struct gb_timesync_svc *timesync_svc,
503 u64 frame_time, struct timespec *ts)
504 {
505 unsigned long flags;
506 u64 delta_fs, counts, sec, nsec;
507 bool add;
508 int ret = 0;
509
510 memset(ts, 0x00, sizeof(*ts));
511 mutex_lock(&timesync_svc->mutex);
512 spin_lock_irqsave(&timesync_svc->spinlock, flags);
513
514 ret = __gb_timesync_get_status(timesync_svc);
515 if (ret)
516 goto done;
517
518 /* Support calculating ktime upwards or downwards from the reference */
519 if (frame_time < timesync_svc->ktime_data.frame_time) {
520 add = false;
521 counts = timesync_svc->ktime_data.frame_time - frame_time;
522 } else {
523 add = true;
524 counts = frame_time - timesync_svc->ktime_data.frame_time;
525 }
526
527 /* Enforce the .23 of a usecond boundary @ 19.2MHz */
528 if (counts > gb_timesync_max_ktime_diff) {
529 ret = -EINVAL;
530 goto done;
531 }
532
533 /* Determine the time difference in femtoseconds */
534 delta_fs = counts * gb_timesync_fs_per_clock;
535
536 /* Convert to seconds */
537 sec = delta_fs;
538 do_div(sec, NSEC_PER_SEC);
539 do_div(sec, 1000000UL);
540
541 /* Get the nanosecond remainder */
542 nsec = do_div(delta_fs, sec);
543 do_div(nsec, 1000000UL);
544
545 if (add) {
546 /* Add the calculated offset - overflow nanoseconds upwards */
547 ts->tv_sec = timesync_svc->ktime_data.ts.tv_sec + sec;
548 ts->tv_nsec = timesync_svc->ktime_data.ts.tv_nsec + nsec;
549 if (ts->tv_nsec >= NSEC_PER_SEC) {
550 ts->tv_sec++;
551 ts->tv_nsec -= NSEC_PER_SEC;
552 }
553 } else {
554 /* Subtract the difference over/underflow as necessary */
555 if (nsec > timesync_svc->ktime_data.ts.tv_nsec) {
556 sec++;
557 nsec = nsec + timesync_svc->ktime_data.ts.tv_nsec;
558 nsec = do_div(nsec, NSEC_PER_SEC);
559 } else {
560 nsec = timesync_svc->ktime_data.ts.tv_nsec - nsec;
561 }
562 /* Cannot return a negative second value */
563 if (sec > timesync_svc->ktime_data.ts.tv_sec) {
564 ret = -EINVAL;
565 goto done;
566 }
567 ts->tv_sec = timesync_svc->ktime_data.ts.tv_sec - sec;
568 ts->tv_nsec = nsec;
569 }
570 done:
571 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
572 mutex_unlock(&timesync_svc->mutex);
573 return ret;
574 }
575
576 static size_t gb_timesync_log_frame_time(struct gb_timesync_svc *timesync_svc,
577 char *buf, size_t buflen)
578 {
579 struct gb_svc *svc = timesync_svc->svc;
580 struct gb_host_device *hd;
581 struct gb_timesync_interface *timesync_interface;
582 struct gb_interface *interface;
583 unsigned int len;
584 size_t off;
585
586 /* AP/SVC */
587 off = snprintf(buf, buflen, "%s frametime: ap=%llu %s=%llu ",
588 greybus_bus_type.name,
589 timesync_svc->ap_ping_frame_time, dev_name(&svc->dev),
590 timesync_svc->svc_ping_frame_time);
591 len = buflen - off;
592
593 /* APB/GPB */
594 if (len < buflen) {
595 hd = timesync_svc->timesync_hd->hd;
596 off += snprintf(&buf[off], len, "%s=%llu ", dev_name(&hd->dev),
597 timesync_svc->timesync_hd->ping_frame_time);
598 len = buflen - off;
599 }
600
601 list_for_each_entry(timesync_interface,
602 &timesync_svc->interface_list, list) {
603 if (len < buflen) {
604 interface = timesync_interface->interface;
605 off += snprintf(&buf[off], len, "%s=%llu ",
606 dev_name(&interface->dev),
607 timesync_interface->ping_frame_time);
608 len = buflen - off;
609 }
610 }
611 if (len < buflen)
612 off += snprintf(&buf[off], len, "\n");
613 return off;
614 }
615
616 static size_t gb_timesync_log_frame_ktime(struct gb_timesync_svc *timesync_svc,
617 char *buf, size_t buflen)
618 {
619 struct gb_svc *svc = timesync_svc->svc;
620 struct gb_host_device *hd;
621 struct gb_timesync_interface *timesync_interface;
622 struct gb_interface *interface;
623 struct timespec ts;
624 unsigned int len;
625 size_t off;
626
627 /* AP */
628 gb_timesync_to_timespec(timesync_svc, timesync_svc->ap_ping_frame_time,
629 &ts);
630 off = snprintf(buf, buflen, "%s frametime: ap=%lu.%lu ",
631 greybus_bus_type.name, ts.tv_sec, ts.tv_nsec);
632 len = buflen - off;
633 if (len >= buflen)
634 goto done;
635
636 /* SVC */
637 gb_timesync_to_timespec(timesync_svc, timesync_svc->svc_ping_frame_time,
638 &ts);
639 off += snprintf(&buf[off], len, "%s=%lu.%lu ", dev_name(&svc->dev),
640 ts.tv_sec, ts.tv_nsec);
641 len = buflen - off;
642 if (len >= buflen)
643 goto done;
644
645 /* APB/GPB */
646 hd = timesync_svc->timesync_hd->hd;
647 gb_timesync_to_timespec(timesync_svc,
648 timesync_svc->timesync_hd->ping_frame_time,
649 &ts);
650 off += snprintf(&buf[off], len, "%s=%lu.%lu ",
651 dev_name(&hd->dev),
652 ts.tv_sec, ts.tv_nsec);
653 len = buflen - off;
654 if (len >= buflen)
655 goto done;
656
657 list_for_each_entry(timesync_interface,
658 &timesync_svc->interface_list, list) {
659 interface = timesync_interface->interface;
660 gb_timesync_to_timespec(timesync_svc,
661 timesync_interface->ping_frame_time,
662 &ts);
663 off += snprintf(&buf[off], len, "%s=%lu.%lu ",
664 dev_name(&interface->dev),
665 ts.tv_sec, ts.tv_nsec);
666 len = buflen - off;
667 if (len >= buflen)
668 goto done;
669 }
670 off += snprintf(&buf[off], len, "\n");
671 done:
672 return off;
673 }
674
675 /*
676 * Send an SVC initiated wake 'ping' to each TimeSync participant.
677 * Get the FrameTime from each participant associated with the wake
678 * ping.
679 */
680 static void gb_timesync_ping(struct gb_timesync_svc *timesync_svc)
681 {
682 struct gb_svc *svc = timesync_svc->svc;
683 struct gb_host_device *hd;
684 struct gb_timesync_interface *timesync_interface;
685 struct gb_control *control;
686 u64 *ping_frame_time;
687 int ret;
688
689 /* Get access to the wake pins in the AP and SVC */
690 ret = gb_timesync_platform_lock_bus(timesync_svc);
691 if (ret < 0) {
692 gb_timesync_platform_lock_bus_fail(timesync_svc, ret);
693 return;
694 }
695 ret = gb_svc_timesync_wake_pins_acquire(svc, timesync_svc->strobe_mask);
696 if (ret) {
697 dev_err(&svc->dev,
698 "gb_svc_timesync_wake_pins_acquire %d\n", ret);
699 gb_timesync_teardown(timesync_svc);
700 return;
701 }
702
703 /* Have SVC generate a timesync ping */
704 timesync_svc->capture_ping = true;
705 timesync_svc->svc_ping_frame_time = 0;
706 ret = gb_svc_timesync_ping(svc, &timesync_svc->svc_ping_frame_time);
707 timesync_svc->capture_ping = false;
708 if (ret) {
709 dev_err(&svc->dev,
710 "gb_svc_timesync_ping %d\n", ret);
711 gb_timesync_teardown(timesync_svc);
712 return;
713 }
714
715 /* Get the ping FrameTime from each APB/GPB */
716 hd = timesync_svc->timesync_hd->hd;
717 timesync_svc->timesync_hd->ping_frame_time = 0;
718 ret = hd->driver->timesync_get_last_event(hd,
719 &timesync_svc->timesync_hd->ping_frame_time);
720 if (ret)
721 dev_err(&hd->dev, "host timesync_get_last_event %d\n", ret);
722
723 list_for_each_entry(timesync_interface,
724 &timesync_svc->interface_list, list) {
725 control = timesync_interface->interface->control;
726 timesync_interface->ping_frame_time = 0;
727 ping_frame_time = &timesync_interface->ping_frame_time;
728 ret = gb_control_timesync_get_last_event(control,
729 ping_frame_time);
730 if (ret) {
731 dev_err(&timesync_interface->interface->dev,
732 "gb_control_timesync_get_last_event %d\n", ret);
733 }
734 }
735
736 /* Ping success - move to timesync active */
737 gb_svc_timesync_wake_pins_release(svc);
738 gb_timesync_platform_unlock_bus();
739 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_ACTIVE);
740 }
741
742 static void gb_timesync_log_ping_time(struct gb_timesync_svc *timesync_svc)
743 {
744 char *buf;
745
746 if (!timesync_svc->print_ping)
747 return;
748
749 buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
750 if (buf) {
751 gb_timesync_log_frame_time(timesync_svc, buf, PAGE_SIZE);
752 dev_dbg(&timesync_svc->svc->dev, "%s", buf);
753 kfree(buf);
754 }
755 }
756
757 /*
758 * Perform the actual work of scheduled TimeSync logic.
759 */
760 static void gb_timesync_worker(struct work_struct *work)
761 {
762 struct delayed_work *delayed_work = to_delayed_work(work);
763 struct gb_timesync_svc *timesync_svc =
764 container_of(delayed_work, struct gb_timesync_svc, delayed_work);
765
766 mutex_lock(&timesync_svc->mutex);
767
768 switch (timesync_svc->state) {
769 case GB_TIMESYNC_STATE_INIT:
770 gb_timesync_enable(timesync_svc);
771 break;
772
773 case GB_TIMESYNC_STATE_WAIT_SVC:
774 dev_err(&timesync_svc->svc->dev,
775 "timeout SVC strobe completion %d/%d\n",
776 timesync_svc->strobe, GB_TIMESYNC_MAX_STROBES);
777 gb_timesync_teardown(timesync_svc);
778 break;
779
780 case GB_TIMESYNC_STATE_AUTHORITATIVE:
781 gb_timesync_authoritative(timesync_svc);
782 break;
783
784 case GB_TIMESYNC_STATE_PING:
785 gb_timesync_ping(timesync_svc);
786 gb_timesync_log_ping_time(timesync_svc);
787 break;
788
789 default:
790 pr_err("Invalid state %d for delayed work\n",
791 timesync_svc->state);
792 break;
793 }
794
795 mutex_unlock(&timesync_svc->mutex);
796 }
797
798 /*
799 * Schedule a new TimeSync INIT or PING operation serialized w/r to
800 * gb_timesync_worker().
801 */
802 static int gb_timesync_schedule(struct gb_timesync_svc *timesync_svc, int state)
803 {
804 int ret = 0;
805
806 if (state != GB_TIMESYNC_STATE_INIT && state != GB_TIMESYNC_STATE_PING)
807 return -EINVAL;
808
809 mutex_lock(&timesync_svc->mutex);
810 if (timesync_svc->state != GB_TIMESYNC_STATE_INVALID) {
811 gb_timesync_set_state_atomic(timesync_svc, state);
812 } else {
813 ret = -ENODEV;
814 }
815 mutex_unlock(&timesync_svc->mutex);
816 return ret;
817 }
818
819 static int __gb_timesync_schedule_synchronous(
820 struct gb_timesync_svc *timesync_svc, int state)
821 {
822 unsigned long flags;
823 int ret;
824
825 ret = gb_timesync_schedule(timesync_svc, state);
826 if (ret)
827 return ret;
828
829 ret = wait_event_interruptible(timesync_svc->wait_queue,
830 (timesync_svc->state == GB_TIMESYNC_STATE_ACTIVE ||
831 timesync_svc->state == GB_TIMESYNC_STATE_INACTIVE ||
832 timesync_svc->state == GB_TIMESYNC_STATE_INVALID));
833 if (ret)
834 return ret;
835
836 mutex_lock(&timesync_svc->mutex);
837 spin_lock_irqsave(&timesync_svc->spinlock, flags);
838
839 ret = __gb_timesync_get_status(timesync_svc);
840
841 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
842 mutex_unlock(&timesync_svc->mutex);
843
844 return ret;
845 }
846
847 static struct gb_timesync_svc *gb_timesync_find_timesync_svc(
848 struct gb_host_device *hd)
849 {
850 struct gb_timesync_svc *timesync_svc;
851
852 list_for_each_entry(timesync_svc, &gb_timesync_svc_list, list) {
853 if (timesync_svc->svc == hd->svc)
854 return timesync_svc;
855 }
856 return NULL;
857 }
858
859 static struct gb_timesync_interface *gb_timesync_find_timesync_interface(
860 struct gb_timesync_svc *timesync_svc,
861 struct gb_interface *interface)
862 {
863 struct gb_timesync_interface *timesync_interface;
864
865 list_for_each_entry(timesync_interface, &timesync_svc->interface_list, list) {
866 if (timesync_interface->interface == interface)
867 return timesync_interface;
868 }
869 return NULL;
870 }
871
872 int gb_timesync_schedule_synchronous(struct gb_interface *interface)
873 {
874 int ret;
875 struct gb_timesync_svc *timesync_svc;
876 int retries;
877
878 if (!(interface->features & GREYBUS_INTERFACE_FEATURE_TIMESYNC))
879 return 0;
880
881 mutex_lock(&gb_timesync_svc_list_mutex);
882 for (retries = 0; retries < GB_TIMESYNC_MAX_RETRIES; retries++) {
883 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
884 if (!timesync_svc) {
885 ret = -ENODEV;
886 goto done;
887 }
888
889 ret = __gb_timesync_schedule_synchronous(timesync_svc,
890 GB_TIMESYNC_STATE_INIT);
891 if (!ret)
892 break;
893 }
894 if (ret && retries == GB_TIMESYNC_MAX_RETRIES)
895 ret = -ETIMEDOUT;
896 done:
897 mutex_unlock(&gb_timesync_svc_list_mutex);
898 return ret;
899 }
900 EXPORT_SYMBOL_GPL(gb_timesync_schedule_synchronous);
901
902 void gb_timesync_schedule_asynchronous(struct gb_interface *interface)
903 {
904 struct gb_timesync_svc *timesync_svc;
905
906 if (!(interface->features & GREYBUS_INTERFACE_FEATURE_TIMESYNC))
907 return;
908
909 mutex_lock(&gb_timesync_svc_list_mutex);
910 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
911 if (!timesync_svc)
912 goto done;
913
914 gb_timesync_schedule(timesync_svc, GB_TIMESYNC_STATE_INIT);
915 done:
916 mutex_unlock(&gb_timesync_svc_list_mutex);
917 return;
918 }
919 EXPORT_SYMBOL_GPL(gb_timesync_schedule_asynchronous);
920
921 static ssize_t gb_timesync_ping_read(struct file *file, char __user *ubuf,
922 size_t len, loff_t *offset, bool ktime)
923 {
924 struct gb_timesync_svc *timesync_svc = file->f_inode->i_private;
925 char *buf;
926 ssize_t ret = 0;
927
928 mutex_lock(&gb_timesync_svc_list_mutex);
929 mutex_lock(&timesync_svc->mutex);
930 if (list_empty(&timesync_svc->interface_list))
931 ret = -ENODEV;
932 timesync_svc->print_ping = false;
933 mutex_unlock(&timesync_svc->mutex);
934 if (ret)
935 goto done;
936
937 ret = __gb_timesync_schedule_synchronous(timesync_svc,
938 GB_TIMESYNC_STATE_PING);
939 if (ret)
940 goto done;
941
942 buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
943 if (!buf) {
944 ret = -ENOMEM;
945 goto done;
946 }
947
948 if (ktime)
949 ret = gb_timesync_log_frame_ktime(timesync_svc, buf, PAGE_SIZE);
950 else
951 ret = gb_timesync_log_frame_time(timesync_svc, buf, PAGE_SIZE);
952 if (ret > 0)
953 ret = simple_read_from_buffer(ubuf, len, offset, buf, ret);
954 kfree(buf);
955 done:
956 mutex_unlock(&gb_timesync_svc_list_mutex);
957 return ret;
958 }
959
960 static ssize_t gb_timesync_ping_read_frame_time(struct file *file,
961 char __user *buf,
962 size_t len, loff_t *offset)
963 {
964 return gb_timesync_ping_read(file, buf, len, offset, false);
965 }
966
967 static ssize_t gb_timesync_ping_read_frame_ktime(struct file *file,
968 char __user *buf,
969 size_t len, loff_t *offset)
970 {
971 return gb_timesync_ping_read(file, buf, len, offset, true);
972 }
973
974 static const struct file_operations gb_timesync_debugfs_frame_time_ops = {
975 .read = gb_timesync_ping_read_frame_time,
976 };
977
978 static const struct file_operations gb_timesync_debugfs_frame_ktime_ops = {
979 .read = gb_timesync_ping_read_frame_ktime,
980 };
981
982 static int gb_timesync_hd_add(struct gb_timesync_svc *timesync_svc,
983 struct gb_host_device *hd)
984 {
985 struct gb_timesync_host_device *timesync_hd;
986
987 timesync_hd = kzalloc(sizeof(*timesync_hd), GFP_KERNEL);
988 if (!timesync_hd)
989 return -ENOMEM;
990
991 WARN_ON(timesync_svc->timesync_hd);
992 timesync_hd->hd = hd;
993 timesync_svc->timesync_hd = timesync_hd;
994
995 return 0;
996 }
997
998 static void gb_timesync_hd_remove(struct gb_timesync_svc *timesync_svc,
999 struct gb_host_device *hd)
1000 {
1001 if (timesync_svc->timesync_hd->hd == hd) {
1002 kfree(timesync_svc->timesync_hd);
1003 timesync_svc->timesync_hd = NULL;
1004 return;
1005 }
1006 WARN_ON(1);
1007 }
1008
1009 int gb_timesync_svc_add(struct gb_svc *svc)
1010 {
1011 struct gb_timesync_svc *timesync_svc;
1012 int ret;
1013
1014 timesync_svc = kzalloc(sizeof(*timesync_svc), GFP_KERNEL);
1015 if (!timesync_svc)
1016 return -ENOMEM;
1017
1018 timesync_svc->work_queue =
1019 create_singlethread_workqueue("gb-timesync-work_queue");
1020
1021 if (!timesync_svc->work_queue) {
1022 kfree(timesync_svc);
1023 return -ENOMEM;
1024 }
1025
1026 mutex_lock(&gb_timesync_svc_list_mutex);
1027 INIT_LIST_HEAD(&timesync_svc->interface_list);
1028 INIT_DELAYED_WORK(&timesync_svc->delayed_work, gb_timesync_worker);
1029 mutex_init(&timesync_svc->mutex);
1030 spin_lock_init(&timesync_svc->spinlock);
1031 init_waitqueue_head(&timesync_svc->wait_queue);
1032
1033 timesync_svc->svc = svc;
1034 timesync_svc->frame_time_offset = 0;
1035 timesync_svc->capture_ping = false;
1036 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_INACTIVE);
1037
1038 timesync_svc->frame_time_dentry =
1039 debugfs_create_file("frame-time", S_IRUGO, svc->debugfs_dentry,
1040 timesync_svc,
1041 &gb_timesync_debugfs_frame_time_ops);
1042 timesync_svc->frame_ktime_dentry =
1043 debugfs_create_file("frame-ktime", S_IRUGO, svc->debugfs_dentry,
1044 timesync_svc,
1045 &gb_timesync_debugfs_frame_ktime_ops);
1046
1047 list_add(&timesync_svc->list, &gb_timesync_svc_list);
1048 ret = gb_timesync_hd_add(timesync_svc, svc->hd);
1049 if (ret) {
1050 list_del(&timesync_svc->list);
1051 debugfs_remove(timesync_svc->frame_ktime_dentry);
1052 debugfs_remove(timesync_svc->frame_time_dentry);
1053 destroy_workqueue(timesync_svc->work_queue);
1054 kfree(timesync_svc);
1055 goto done;
1056 }
1057
1058 init_timer(&timesync_svc->ktime_timer);
1059 timesync_svc->ktime_timer.function = gb_timesync_ktime_timer_fn;
1060 timesync_svc->ktime_timer.expires = jiffies + GB_TIMESYNC_KTIME_UPDATE;
1061 timesync_svc->ktime_timer.data = (unsigned long)timesync_svc;
1062 add_timer(&timesync_svc->ktime_timer);
1063 done:
1064 mutex_unlock(&gb_timesync_svc_list_mutex);
1065 return ret;
1066 }
1067 EXPORT_SYMBOL_GPL(gb_timesync_svc_add);
1068
1069 void gb_timesync_svc_remove(struct gb_svc *svc)
1070 {
1071 struct gb_timesync_svc *timesync_svc;
1072 struct gb_timesync_interface *timesync_interface;
1073 struct gb_timesync_interface *next;
1074
1075 mutex_lock(&gb_timesync_svc_list_mutex);
1076 timesync_svc = gb_timesync_find_timesync_svc(svc->hd);
1077 if (!timesync_svc)
1078 goto done;
1079
1080 cancel_delayed_work_sync(&timesync_svc->delayed_work);
1081
1082 mutex_lock(&timesync_svc->mutex);
1083
1084 gb_timesync_set_state_atomic(timesync_svc, GB_TIMESYNC_STATE_INVALID);
1085 del_timer_sync(&timesync_svc->ktime_timer);
1086 gb_timesync_teardown(timesync_svc);
1087
1088 gb_timesync_hd_remove(timesync_svc, svc->hd);
1089 list_for_each_entry_safe(timesync_interface, next,
1090 &timesync_svc->interface_list, list) {
1091 list_del(&timesync_interface->list);
1092 kfree(timesync_interface);
1093 }
1094 debugfs_remove(timesync_svc->frame_ktime_dentry);
1095 debugfs_remove(timesync_svc->frame_time_dentry);
1096 destroy_workqueue(timesync_svc->work_queue);
1097 list_del(&timesync_svc->list);
1098
1099 mutex_unlock(&timesync_svc->mutex);
1100
1101 kfree(timesync_svc);
1102 done:
1103 mutex_unlock(&gb_timesync_svc_list_mutex);
1104 }
1105 EXPORT_SYMBOL_GPL(gb_timesync_svc_remove);
1106
1107 /*
1108 * Add a Greybus Interface to the set of TimeSync Interfaces.
1109 */
1110 int gb_timesync_interface_add(struct gb_interface *interface)
1111 {
1112 struct gb_timesync_svc *timesync_svc;
1113 struct gb_timesync_interface *timesync_interface;
1114 int ret = 0;
1115
1116 if (!(interface->features & GREYBUS_INTERFACE_FEATURE_TIMESYNC))
1117 return 0;
1118
1119 mutex_lock(&gb_timesync_svc_list_mutex);
1120 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
1121 if (!timesync_svc) {
1122 ret = -ENODEV;
1123 goto done;
1124 }
1125
1126 timesync_interface = kzalloc(sizeof(*timesync_interface), GFP_KERNEL);
1127 if (!timesync_interface) {
1128 ret = -ENOMEM;
1129 goto done;
1130 }
1131
1132 mutex_lock(&timesync_svc->mutex);
1133 timesync_interface->interface = interface;
1134 list_add(&timesync_interface->list, &timesync_svc->interface_list);
1135 timesync_svc->strobe_mask |= 1 << interface->interface_id;
1136 mutex_unlock(&timesync_svc->mutex);
1137
1138 done:
1139 mutex_unlock(&gb_timesync_svc_list_mutex);
1140 return ret;
1141 }
1142 EXPORT_SYMBOL_GPL(gb_timesync_interface_add);
1143
1144 /*
1145 * Remove a Greybus Interface from the set of TimeSync Interfaces.
1146 */
1147 void gb_timesync_interface_remove(struct gb_interface *interface)
1148 {
1149 struct gb_timesync_svc *timesync_svc;
1150 struct gb_timesync_interface *timesync_interface;
1151
1152 if (!(interface->features & GREYBUS_INTERFACE_FEATURE_TIMESYNC))
1153 return;
1154
1155 mutex_lock(&gb_timesync_svc_list_mutex);
1156 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
1157 if (!timesync_svc)
1158 goto done;
1159
1160 timesync_interface = gb_timesync_find_timesync_interface(timesync_svc,
1161 interface);
1162 if (!timesync_interface)
1163 goto done;
1164
1165 mutex_lock(&timesync_svc->mutex);
1166 timesync_svc->strobe_mask &= ~(1 << interface->interface_id);
1167 list_del(&timesync_interface->list);
1168 kfree(timesync_interface);
1169 mutex_unlock(&timesync_svc->mutex);
1170 done:
1171 mutex_unlock(&gb_timesync_svc_list_mutex);
1172 }
1173 EXPORT_SYMBOL_GPL(gb_timesync_interface_remove);
1174
1175 /*
1176 * Give the authoritative FrameTime to the calling function. Returns zero if we
1177 * are not in GB_TIMESYNC_STATE_ACTIVE.
1178 */
1179 static u64 gb_timesync_get_frame_time(struct gb_timesync_svc *timesync_svc)
1180 {
1181 unsigned long flags;
1182 u64 ret;
1183
1184 spin_lock_irqsave(&timesync_svc->spinlock, flags);
1185 if (timesync_svc->state == GB_TIMESYNC_STATE_ACTIVE)
1186 ret = __gb_timesync_get_frame_time(timesync_svc);
1187 else
1188 ret = 0;
1189 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
1190 return ret;
1191 }
1192
1193 u64 gb_timesync_get_frame_time_by_interface(struct gb_interface *interface)
1194 {
1195 struct gb_timesync_svc *timesync_svc;
1196 u64 ret = 0;
1197
1198 mutex_lock(&gb_timesync_svc_list_mutex);
1199 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
1200 if (!timesync_svc)
1201 goto done;
1202
1203 ret = gb_timesync_get_frame_time(timesync_svc);
1204 done:
1205 mutex_unlock(&gb_timesync_svc_list_mutex);
1206 return ret;
1207 }
1208 EXPORT_SYMBOL_GPL(gb_timesync_get_frame_time_by_interface);
1209
1210 u64 gb_timesync_get_frame_time_by_svc(struct gb_svc *svc)
1211 {
1212 struct gb_timesync_svc *timesync_svc;
1213 u64 ret = 0;
1214
1215 mutex_lock(&gb_timesync_svc_list_mutex);
1216 timesync_svc = gb_timesync_find_timesync_svc(svc->hd);
1217 if (!timesync_svc)
1218 goto done;
1219
1220 ret = gb_timesync_get_frame_time(timesync_svc);
1221 done:
1222 mutex_unlock(&gb_timesync_svc_list_mutex);
1223 return ret;
1224 }
1225 EXPORT_SYMBOL_GPL(gb_timesync_get_frame_time_by_svc);
1226
1227 /* Incrementally updates the conversion base from FrameTime to ktime */
1228 static void gb_timesync_ktime_timer_fn(unsigned long data)
1229 {
1230 struct gb_timesync_svc *timesync_svc =
1231 (struct gb_timesync_svc *)data;
1232 unsigned long flags;
1233 u64 frame_time;
1234 struct timespec ts;
1235
1236 spin_lock_irqsave(&timesync_svc->spinlock, flags);
1237
1238 if (timesync_svc->state != GB_TIMESYNC_STATE_ACTIVE)
1239 goto done;
1240
1241 ktime_get_ts(&ts);
1242 frame_time = __gb_timesync_get_frame_time(timesync_svc);
1243 gb_timesync_store_ktime(timesync_svc, ts, frame_time);
1244
1245 done:
1246 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
1247 mod_timer(&timesync_svc->ktime_timer,
1248 jiffies + GB_TIMESYNC_KTIME_UPDATE);
1249 }
1250
1251 int gb_timesync_to_timespec_by_svc(struct gb_svc *svc, u64 frame_time,
1252 struct timespec *ts)
1253 {
1254 struct gb_timesync_svc *timesync_svc;
1255 int ret = 0;
1256
1257 mutex_lock(&gb_timesync_svc_list_mutex);
1258 timesync_svc = gb_timesync_find_timesync_svc(svc->hd);
1259 if (!timesync_svc) {
1260 ret = -ENODEV;
1261 goto done;
1262 }
1263 ret = gb_timesync_to_timespec(timesync_svc, frame_time, ts);
1264 done:
1265 mutex_unlock(&gb_timesync_svc_list_mutex);
1266 return ret;
1267 }
1268 EXPORT_SYMBOL_GPL(gb_timesync_to_timespec_by_svc);
1269
1270 int gb_timesync_to_timespec_by_interface(struct gb_interface *interface,
1271 u64 frame_time, struct timespec *ts)
1272 {
1273 struct gb_timesync_svc *timesync_svc;
1274 int ret = 0;
1275
1276 mutex_lock(&gb_timesync_svc_list_mutex);
1277 timesync_svc = gb_timesync_find_timesync_svc(interface->hd);
1278 if (!timesync_svc) {
1279 ret = -ENODEV;
1280 goto done;
1281 }
1282
1283 ret = gb_timesync_to_timespec(timesync_svc, frame_time, ts);
1284 done:
1285 mutex_unlock(&gb_timesync_svc_list_mutex);
1286 return ret;
1287 }
1288 EXPORT_SYMBOL_GPL(gb_timesync_to_timespec_by_interface);
1289
1290 void gb_timesync_irq(struct gb_timesync_svc *timesync_svc)
1291 {
1292 unsigned long flags;
1293 u64 strobe_time;
1294 bool strobe_is_ping = true;
1295 struct timespec ts;
1296
1297 ktime_get_ts(&ts);
1298 strobe_time = __gb_timesync_get_frame_time(timesync_svc);
1299
1300 spin_lock_irqsave(&timesync_svc->spinlock, flags);
1301
1302 if (timesync_svc->state == GB_TIMESYNC_STATE_PING) {
1303 if (!timesync_svc->capture_ping)
1304 goto done_nolog;
1305 timesync_svc->ap_ping_frame_time = strobe_time;
1306 goto done_log;
1307 } else if (timesync_svc->state != GB_TIMESYNC_STATE_WAIT_SVC) {
1308 goto done_nolog;
1309 }
1310
1311 timesync_svc->strobe_data[timesync_svc->strobe].frame_time = strobe_time;
1312 timesync_svc->strobe_data[timesync_svc->strobe].ts = ts;
1313
1314 if (++timesync_svc->strobe == GB_TIMESYNC_MAX_STROBES) {
1315 gb_timesync_set_state(timesync_svc,
1316 GB_TIMESYNC_STATE_AUTHORITATIVE);
1317 }
1318 strobe_is_ping = false;
1319 done_log:
1320 trace_gb_timesync_irq(strobe_is_ping, timesync_svc->strobe,
1321 GB_TIMESYNC_MAX_STROBES, strobe_time);
1322 done_nolog:
1323 spin_unlock_irqrestore(&timesync_svc->spinlock, flags);
1324 }
1325 EXPORT_SYMBOL(gb_timesync_irq);
1326
1327 int __init gb_timesync_init(void)
1328 {
1329 int ret = 0;
1330
1331 ret = gb_timesync_platform_init();
1332 if (ret) {
1333 pr_err("timesync platform init fail!\n");
1334 return ret;
1335 }
1336
1337 gb_timesync_clock_rate = gb_timesync_platform_get_clock_rate();
1338
1339 /* Calculate nanoseconds and femtoseconds per clock */
1340 gb_timesync_fs_per_clock = FSEC_PER_SEC;
1341 do_div(gb_timesync_fs_per_clock, gb_timesync_clock_rate);
1342 gb_timesync_ns_per_clock = NSEC_PER_SEC;
1343 do_div(gb_timesync_ns_per_clock, gb_timesync_clock_rate);
1344
1345 /* Calculate the maximum number of clocks we will convert to ktime */
1346 gb_timesync_max_ktime_diff =
1347 GB_TIMESYNC_MAX_KTIME_CONVERSION * gb_timesync_clock_rate;
1348
1349 pr_info("Time-Sync @ %lu Hz max ktime conversion +/- %d seconds\n",
1350 gb_timesync_clock_rate, GB_TIMESYNC_MAX_KTIME_CONVERSION);
1351 return 0;
1352 }
1353
1354 void gb_timesync_exit(void)
1355 {
1356 gb_timesync_platform_exit();
1357 }
Linux with added FPC-III support