[S390] irq: merge irq.c and s390_ext.c
[linux-2.6.git] / arch / s390 / kernel / time.c
1 /*
2  *  arch/s390/kernel/time.c
3  *    Time of day based timer functions.
4  *
5  *  S390 version
6  *    Copyright IBM Corp. 1999, 2008
7  *    Author(s): Hartmut Penner (hp@de.ibm.com),
8  *               Martin Schwidefsky (schwidefsky@de.ibm.com),
9  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
10  *
11  *  Derived from "arch/i386/kernel/time.c"
12  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
13  */
14
15 #define KMSG_COMPONENT "time"
16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
17
18 #include <linux/kernel_stat.h>
19 #include <linux/errno.h>
20 #include <linux/module.h>
21 #include <linux/sched.h>
22 #include <linux/kernel.h>
23 #include <linux/param.h>
24 #include <linux/string.h>
25 #include <linux/mm.h>
26 #include <linux/interrupt.h>
27 #include <linux/cpu.h>
28 #include <linux/stop_machine.h>
29 #include <linux/time.h>
30 #include <linux/sysdev.h>
31 #include <linux/delay.h>
32 #include <linux/init.h>
33 #include <linux/smp.h>
34 #include <linux/types.h>
35 #include <linux/profile.h>
36 #include <linux/timex.h>
37 #include <linux/notifier.h>
38 #include <linux/clocksource.h>
39 #include <linux/clockchips.h>
40 #include <linux/gfp.h>
41 #include <linux/kprobes.h>
42 #include <asm/uaccess.h>
43 #include <asm/delay.h>
44 #include <asm/div64.h>
45 #include <asm/vdso.h>
46 #include <asm/irq.h>
47 #include <asm/irq_regs.h>
48 #include <asm/timer.h>
49 #include <asm/etr.h>
50 #include <asm/cio.h>
51
52 /* change this if you have some constant time drift */
53 #define USECS_PER_JIFFY     ((unsigned long) 1000000/HZ)
54 #define CLK_TICKS_PER_JIFFY ((unsigned long) USECS_PER_JIFFY << 12)
55
56 u64 sched_clock_base_cc = -1;   /* Force to data section. */
57 EXPORT_SYMBOL_GPL(sched_clock_base_cc);
58
59 static DEFINE_PER_CPU(struct clock_event_device, comparators);
60
61 /*
62  * Scheduler clock - returns current time in nanosec units.
63  */
64 unsigned long long notrace __kprobes sched_clock(void)
65 {
66         return (get_clock_monotonic() * 125) >> 9;
67 }
68
69 /*
70  * Monotonic_clock - returns # of nanoseconds passed since time_init()
71  */
72 unsigned long long monotonic_clock(void)
73 {
74         return sched_clock();
75 }
76 EXPORT_SYMBOL(monotonic_clock);
77
78 void tod_to_timeval(__u64 todval, struct timespec *xt)
79 {
80         unsigned long long sec;
81
82         sec = todval >> 12;
83         do_div(sec, 1000000);
84         xt->tv_sec = sec;
85         todval -= (sec * 1000000) << 12;
86         xt->tv_nsec = ((todval * 1000) >> 12);
87 }
88 EXPORT_SYMBOL(tod_to_timeval);
89
90 void clock_comparator_work(void)
91 {
92         struct clock_event_device *cd;
93
94         S390_lowcore.clock_comparator = -1ULL;
95         set_clock_comparator(S390_lowcore.clock_comparator);
96         cd = &__get_cpu_var(comparators);
97         cd->event_handler(cd);
98 }
99
100 /*
101  * Fixup the clock comparator.
102  */
103 static void fixup_clock_comparator(unsigned long long delta)
104 {
105         /* If nobody is waiting there's nothing to fix. */
106         if (S390_lowcore.clock_comparator == -1ULL)
107                 return;
108         S390_lowcore.clock_comparator += delta;
109         set_clock_comparator(S390_lowcore.clock_comparator);
110 }
111
112 static int s390_next_event(unsigned long delta,
113                            struct clock_event_device *evt)
114 {
115         S390_lowcore.clock_comparator = get_clock() + delta;
116         set_clock_comparator(S390_lowcore.clock_comparator);
117         return 0;
118 }
119
120 static void s390_set_mode(enum clock_event_mode mode,
121                           struct clock_event_device *evt)
122 {
123 }
124
125 /*
126  * Set up lowcore and control register of the current cpu to
127  * enable TOD clock and clock comparator interrupts.
128  */
129 void init_cpu_timer(void)
130 {
131         struct clock_event_device *cd;
132         int cpu;
133
134         S390_lowcore.clock_comparator = -1ULL;
135         set_clock_comparator(S390_lowcore.clock_comparator);
136
137         cpu = smp_processor_id();
138         cd = &per_cpu(comparators, cpu);
139         cd->name                = "comparator";
140         cd->features            = CLOCK_EVT_FEAT_ONESHOT;
141         cd->mult                = 16777;
142         cd->shift               = 12;
143         cd->min_delta_ns        = 1;
144         cd->max_delta_ns        = LONG_MAX;
145         cd->rating              = 400;
146         cd->cpumask             = cpumask_of(cpu);
147         cd->set_next_event      = s390_next_event;
148         cd->set_mode            = s390_set_mode;
149
150         clockevents_register_device(cd);
151
152         /* Enable clock comparator timer interrupt. */
153         __ctl_set_bit(0,11);
154
155         /* Always allow the timing alert external interrupt. */
156         __ctl_set_bit(0, 4);
157 }
158
159 static void clock_comparator_interrupt(unsigned int ext_int_code,
160                                        unsigned int param32,
161                                        unsigned long param64)
162 {
163         kstat_cpu(smp_processor_id()).irqs[EXTINT_CLK]++;
164         if (S390_lowcore.clock_comparator == -1ULL)
165                 set_clock_comparator(S390_lowcore.clock_comparator);
166 }
167
168 static void etr_timing_alert(struct etr_irq_parm *);
169 static void stp_timing_alert(struct stp_irq_parm *);
170
171 static void timing_alert_interrupt(unsigned int ext_int_code,
172                                    unsigned int param32, unsigned long param64)
173 {
174         kstat_cpu(smp_processor_id()).irqs[EXTINT_TLA]++;
175         if (param32 & 0x00c40000)
176                 etr_timing_alert((struct etr_irq_parm *) &param32);
177         if (param32 & 0x00038000)
178                 stp_timing_alert((struct stp_irq_parm *) &param32);
179 }
180
181 static void etr_reset(void);
182 static void stp_reset(void);
183
184 void read_persistent_clock(struct timespec *ts)
185 {
186         tod_to_timeval(get_clock() - TOD_UNIX_EPOCH, ts);
187 }
188
189 void read_boot_clock(struct timespec *ts)
190 {
191         tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, ts);
192 }
193
194 static cycle_t read_tod_clock(struct clocksource *cs)
195 {
196         return get_clock();
197 }
198
199 static struct clocksource clocksource_tod = {
200         .name           = "tod",
201         .rating         = 400,
202         .read           = read_tod_clock,
203         .mask           = -1ULL,
204         .mult           = 1000,
205         .shift          = 12,
206         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
207 };
208
209 struct clocksource * __init clocksource_default_clock(void)
210 {
211         return &clocksource_tod;
212 }
213
214 void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
215                         struct clocksource *clock, u32 mult)
216 {
217         if (clock != &clocksource_tod)
218                 return;
219
220         /* Make userspace gettimeofday spin until we're done. */
221         ++vdso_data->tb_update_count;
222         smp_wmb();
223         vdso_data->xtime_tod_stamp = clock->cycle_last;
224         vdso_data->xtime_clock_sec = wall_time->tv_sec;
225         vdso_data->xtime_clock_nsec = wall_time->tv_nsec;
226         vdso_data->wtom_clock_sec = wtm->tv_sec;
227         vdso_data->wtom_clock_nsec = wtm->tv_nsec;
228         vdso_data->ntp_mult = mult;
229         smp_wmb();
230         ++vdso_data->tb_update_count;
231 }
232
233 extern struct timezone sys_tz;
234
235 void update_vsyscall_tz(void)
236 {
237         /* Make userspace gettimeofday spin until we're done. */
238         ++vdso_data->tb_update_count;
239         smp_wmb();
240         vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
241         vdso_data->tz_dsttime = sys_tz.tz_dsttime;
242         smp_wmb();
243         ++vdso_data->tb_update_count;
244 }
245
246 /*
247  * Initialize the TOD clock and the CPU timer of
248  * the boot cpu.
249  */
250 void __init time_init(void)
251 {
252         /* Reset time synchronization interfaces. */
253         etr_reset();
254         stp_reset();
255
256         /* request the clock comparator external interrupt */
257         if (register_external_interrupt(0x1004, clock_comparator_interrupt))
258                 panic("Couldn't request external interrupt 0x1004");
259
260         /* request the timing alert external interrupt */
261         if (register_external_interrupt(0x1406, timing_alert_interrupt))
262                 panic("Couldn't request external interrupt 0x1406");
263
264         if (clocksource_register(&clocksource_tod) != 0)
265                 panic("Could not register TOD clock source");
266
267         /* Enable TOD clock interrupts on the boot cpu. */
268         init_cpu_timer();
269
270         /* Enable cpu timer interrupts on the boot cpu. */
271         vtime_init();
272 }
273
274 /*
275  * The time is "clock". old is what we think the time is.
276  * Adjust the value by a multiple of jiffies and add the delta to ntp.
277  * "delay" is an approximation how long the synchronization took. If
278  * the time correction is positive, then "delay" is subtracted from
279  * the time difference and only the remaining part is passed to ntp.
280  */
281 static unsigned long long adjust_time(unsigned long long old,
282                                       unsigned long long clock,
283                                       unsigned long long delay)
284 {
285         unsigned long long delta, ticks;
286         struct timex adjust;
287
288         if (clock > old) {
289                 /* It is later than we thought. */
290                 delta = ticks = clock - old;
291                 delta = ticks = (delta < delay) ? 0 : delta - delay;
292                 delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
293                 adjust.offset = ticks * (1000000 / HZ);
294         } else {
295                 /* It is earlier than we thought. */
296                 delta = ticks = old - clock;
297                 delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
298                 delta = -delta;
299                 adjust.offset = -ticks * (1000000 / HZ);
300         }
301         sched_clock_base_cc += delta;
302         if (adjust.offset != 0) {
303                 pr_notice("The ETR interface has adjusted the clock "
304                           "by %li microseconds\n", adjust.offset);
305                 adjust.modes = ADJ_OFFSET_SINGLESHOT;
306                 do_adjtimex(&adjust);
307         }
308         return delta;
309 }
310
311 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
312 static DEFINE_MUTEX(clock_sync_mutex);
313 static unsigned long clock_sync_flags;
314
315 #define CLOCK_SYNC_HAS_ETR      0
316 #define CLOCK_SYNC_HAS_STP      1
317 #define CLOCK_SYNC_ETR          2
318 #define CLOCK_SYNC_STP          3
319
320 /*
321  * The synchronous get_clock function. It will write the current clock
322  * value to the clock pointer and return 0 if the clock is in sync with
323  * the external time source. If the clock mode is local it will return
324  * -ENOSYS and -EAGAIN if the clock is not in sync with the external
325  * reference.
326  */
327 int get_sync_clock(unsigned long long *clock)
328 {
329         atomic_t *sw_ptr;
330         unsigned int sw0, sw1;
331
332         sw_ptr = &get_cpu_var(clock_sync_word);
333         sw0 = atomic_read(sw_ptr);
334         *clock = get_clock();
335         sw1 = atomic_read(sw_ptr);
336         put_cpu_var(clock_sync_word);
337         if (sw0 == sw1 && (sw0 & 0x80000000U))
338                 /* Success: time is in sync. */
339                 return 0;
340         if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags) &&
341             !test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
342                 return -ENOSYS;
343         if (!test_bit(CLOCK_SYNC_ETR, &clock_sync_flags) &&
344             !test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
345                 return -EACCES;
346         return -EAGAIN;
347 }
348 EXPORT_SYMBOL(get_sync_clock);
349
350 /*
351  * Make get_sync_clock return -EAGAIN.
352  */
353 static void disable_sync_clock(void *dummy)
354 {
355         atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
356         /*
357          * Clear the in-sync bit 2^31. All get_sync_clock calls will
358          * fail until the sync bit is turned back on. In addition
359          * increase the "sequence" counter to avoid the race of an
360          * etr event and the complete recovery against get_sync_clock.
361          */
362         atomic_clear_mask(0x80000000, sw_ptr);
363         atomic_inc(sw_ptr);
364 }
365
366 /*
367  * Make get_sync_clock return 0 again.
368  * Needs to be called from a context disabled for preemption.
369  */
370 static void enable_sync_clock(void)
371 {
372         atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
373         atomic_set_mask(0x80000000, sw_ptr);
374 }
375
376 /*
377  * Function to check if the clock is in sync.
378  */
379 static inline int check_sync_clock(void)
380 {
381         atomic_t *sw_ptr;
382         int rc;
383
384         sw_ptr = &get_cpu_var(clock_sync_word);
385         rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
386         put_cpu_var(clock_sync_word);
387         return rc;
388 }
389
390 /* Single threaded workqueue used for etr and stp sync events */
391 static struct workqueue_struct *time_sync_wq;
392
393 static void __init time_init_wq(void)
394 {
395         if (time_sync_wq)
396                 return;
397         time_sync_wq = create_singlethread_workqueue("timesync");
398 }
399
400 /*
401  * External Time Reference (ETR) code.
402  */
403 static int etr_port0_online;
404 static int etr_port1_online;
405 static int etr_steai_available;
406
407 static int __init early_parse_etr(char *p)
408 {
409         if (strncmp(p, "off", 3) == 0)
410                 etr_port0_online = etr_port1_online = 0;
411         else if (strncmp(p, "port0", 5) == 0)
412                 etr_port0_online = 1;
413         else if (strncmp(p, "port1", 5) == 0)
414                 etr_port1_online = 1;
415         else if (strncmp(p, "on", 2) == 0)
416                 etr_port0_online = etr_port1_online = 1;
417         return 0;
418 }
419 early_param("etr", early_parse_etr);
420
421 enum etr_event {
422         ETR_EVENT_PORT0_CHANGE,
423         ETR_EVENT_PORT1_CHANGE,
424         ETR_EVENT_PORT_ALERT,
425         ETR_EVENT_SYNC_CHECK,
426         ETR_EVENT_SWITCH_LOCAL,
427         ETR_EVENT_UPDATE,
428 };
429
430 /*
431  * Valid bit combinations of the eacr register are (x = don't care):
432  * e0 e1 dp p0 p1 ea es sl
433  *  0  0  x  0  0  0  0  0  initial, disabled state
434  *  0  0  x  0  1  1  0  0  port 1 online
435  *  0  0  x  1  0  1  0  0  port 0 online
436  *  0  0  x  1  1  1  0  0  both ports online
437  *  0  1  x  0  1  1  0  0  port 1 online and usable, ETR or PPS mode
438  *  0  1  x  0  1  1  0  1  port 1 online, usable and ETR mode
439  *  0  1  x  0  1  1  1  0  port 1 online, usable, PPS mode, in-sync
440  *  0  1  x  0  1  1  1  1  port 1 online, usable, ETR mode, in-sync
441  *  0  1  x  1  1  1  0  0  both ports online, port 1 usable
442  *  0  1  x  1  1  1  1  0  both ports online, port 1 usable, PPS mode, in-sync
443  *  0  1  x  1  1  1  1  1  both ports online, port 1 usable, ETR mode, in-sync
444  *  1  0  x  1  0  1  0  0  port 0 online and usable, ETR or PPS mode
445  *  1  0  x  1  0  1  0  1  port 0 online, usable and ETR mode
446  *  1  0  x  1  0  1  1  0  port 0 online, usable, PPS mode, in-sync
447  *  1  0  x  1  0  1  1  1  port 0 online, usable, ETR mode, in-sync
448  *  1  0  x  1  1  1  0  0  both ports online, port 0 usable
449  *  1  0  x  1  1  1  1  0  both ports online, port 0 usable, PPS mode, in-sync
450  *  1  0  x  1  1  1  1  1  both ports online, port 0 usable, ETR mode, in-sync
451  *  1  1  x  1  1  1  1  0  both ports online & usable, ETR, in-sync
452  *  1  1  x  1  1  1  1  1  both ports online & usable, ETR, in-sync
453  */
454 static struct etr_eacr etr_eacr;
455 static u64 etr_tolec;                   /* time of last eacr update */
456 static struct etr_aib etr_port0;
457 static int etr_port0_uptodate;
458 static struct etr_aib etr_port1;
459 static int etr_port1_uptodate;
460 static unsigned long etr_events;
461 static struct timer_list etr_timer;
462
463 static void etr_timeout(unsigned long dummy);
464 static void etr_work_fn(struct work_struct *work);
465 static DEFINE_MUTEX(etr_work_mutex);
466 static DECLARE_WORK(etr_work, etr_work_fn);
467
468 /*
469  * Reset ETR attachment.
470  */
471 static void etr_reset(void)
472 {
473         etr_eacr =  (struct etr_eacr) {
474                 .e0 = 0, .e1 = 0, ._pad0 = 4, .dp = 0,
475                 .p0 = 0, .p1 = 0, ._pad1 = 0, .ea = 0,
476                 .es = 0, .sl = 0 };
477         if (etr_setr(&etr_eacr) == 0) {
478                 etr_tolec = get_clock();
479                 set_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags);
480                 if (etr_port0_online && etr_port1_online)
481                         set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
482         } else if (etr_port0_online || etr_port1_online) {
483                 pr_warning("The real or virtual hardware system does "
484                            "not provide an ETR interface\n");
485                 etr_port0_online = etr_port1_online = 0;
486         }
487 }
488
489 static int __init etr_init(void)
490 {
491         struct etr_aib aib;
492
493         if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
494                 return 0;
495         time_init_wq();
496         /* Check if this machine has the steai instruction. */
497         if (etr_steai(&aib, ETR_STEAI_STEPPING_PORT) == 0)
498                 etr_steai_available = 1;
499         setup_timer(&etr_timer, etr_timeout, 0UL);
500         if (etr_port0_online) {
501                 set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
502                 queue_work(time_sync_wq, &etr_work);
503         }
504         if (etr_port1_online) {
505                 set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
506                 queue_work(time_sync_wq, &etr_work);
507         }
508         return 0;
509 }
510
511 arch_initcall(etr_init);
512
513 /*
514  * Two sorts of ETR machine checks. The architecture reads:
515  * "When a machine-check niterruption occurs and if a switch-to-local or
516  *  ETR-sync-check interrupt request is pending but disabled, this pending
517  *  disabled interruption request is indicated and is cleared".
518  * Which means that we can get etr_switch_to_local events from the machine
519  * check handler although the interruption condition is disabled. Lovely..
520  */
521
522 /*
523  * Switch to local machine check. This is called when the last usable
524  * ETR port goes inactive. After switch to local the clock is not in sync.
525  */
526 void etr_switch_to_local(void)
527 {
528         if (!etr_eacr.sl)
529                 return;
530         disable_sync_clock(NULL);
531         if (!test_and_set_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events)) {
532                 etr_eacr.es = etr_eacr.sl = 0;
533                 etr_setr(&etr_eacr);
534                 queue_work(time_sync_wq, &etr_work);
535         }
536 }
537
538 /*
539  * ETR sync check machine check. This is called when the ETR OTE and the
540  * local clock OTE are farther apart than the ETR sync check tolerance.
541  * After a ETR sync check the clock is not in sync. The machine check
542  * is broadcasted to all cpus at the same time.
543  */
544 void etr_sync_check(void)
545 {
546         if (!etr_eacr.es)
547                 return;
548         disable_sync_clock(NULL);
549         if (!test_and_set_bit(ETR_EVENT_SYNC_CHECK, &etr_events)) {
550                 etr_eacr.es = 0;
551                 etr_setr(&etr_eacr);
552                 queue_work(time_sync_wq, &etr_work);
553         }
554 }
555
556 /*
557  * ETR timing alert. There are two causes:
558  * 1) port state change, check the usability of the port
559  * 2) port alert, one of the ETR-data-validity bits (v1-v2 bits of the
560  *    sldr-status word) or ETR-data word 1 (edf1) or ETR-data word 3 (edf3)
561  *    or ETR-data word 4 (edf4) has changed.
562  */
563 static void etr_timing_alert(struct etr_irq_parm *intparm)
564 {
565         if (intparm->pc0)
566                 /* ETR port 0 state change. */
567                 set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
568         if (intparm->pc1)
569                 /* ETR port 1 state change. */
570                 set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
571         if (intparm->eai)
572                 /*
573                  * ETR port alert on either port 0, 1 or both.
574                  * Both ports are not up-to-date now.
575                  */
576                 set_bit(ETR_EVENT_PORT_ALERT, &etr_events);
577         queue_work(time_sync_wq, &etr_work);
578 }
579
580 static void etr_timeout(unsigned long dummy)
581 {
582         set_bit(ETR_EVENT_UPDATE, &etr_events);
583         queue_work(time_sync_wq, &etr_work);
584 }
585
586 /*
587  * Check if the etr mode is pss.
588  */
589 static inline int etr_mode_is_pps(struct etr_eacr eacr)
590 {
591         return eacr.es && !eacr.sl;
592 }
593
594 /*
595  * Check if the etr mode is etr.
596  */
597 static inline int etr_mode_is_etr(struct etr_eacr eacr)
598 {
599         return eacr.es && eacr.sl;
600 }
601
602 /*
603  * Check if the port can be used for TOD synchronization.
604  * For PPS mode the port has to receive OTEs. For ETR mode
605  * the port has to receive OTEs, the ETR stepping bit has to
606  * be zero and the validity bits for data frame 1, 2, and 3
607  * have to be 1.
608  */
609 static int etr_port_valid(struct etr_aib *aib, int port)
610 {
611         unsigned int psc;
612
613         /* Check that this port is receiving OTEs. */
614         if (aib->tsp == 0)
615                 return 0;
616
617         psc = port ? aib->esw.psc1 : aib->esw.psc0;
618         if (psc == etr_lpsc_pps_mode)
619                 return 1;
620         if (psc == etr_lpsc_operational_step)
621                 return !aib->esw.y && aib->slsw.v1 &&
622                         aib->slsw.v2 && aib->slsw.v3;
623         return 0;
624 }
625
626 /*
627  * Check if two ports are on the same network.
628  */
629 static int etr_compare_network(struct etr_aib *aib1, struct etr_aib *aib2)
630 {
631         // FIXME: any other fields we have to compare?
632         return aib1->edf1.net_id == aib2->edf1.net_id;
633 }
634
635 /*
636  * Wrapper for etr_stei that converts physical port states
637  * to logical port states to be consistent with the output
638  * of stetr (see etr_psc vs. etr_lpsc).
639  */
640 static void etr_steai_cv(struct etr_aib *aib, unsigned int func)
641 {
642         BUG_ON(etr_steai(aib, func) != 0);
643         /* Convert port state to logical port state. */
644         if (aib->esw.psc0 == 1)
645                 aib->esw.psc0 = 2;
646         else if (aib->esw.psc0 == 0 && aib->esw.p == 0)
647                 aib->esw.psc0 = 1;
648         if (aib->esw.psc1 == 1)
649                 aib->esw.psc1 = 2;
650         else if (aib->esw.psc1 == 0 && aib->esw.p == 1)
651                 aib->esw.psc1 = 1;
652 }
653
654 /*
655  * Check if the aib a2 is still connected to the same attachment as
656  * aib a1, the etv values differ by one and a2 is valid.
657  */
658 static int etr_aib_follows(struct etr_aib *a1, struct etr_aib *a2, int p)
659 {
660         int state_a1, state_a2;
661
662         /* Paranoia check: e0/e1 should better be the same. */
663         if (a1->esw.eacr.e0 != a2->esw.eacr.e0 ||
664             a1->esw.eacr.e1 != a2->esw.eacr.e1)
665                 return 0;
666
667         /* Still connected to the same etr ? */
668         state_a1 = p ? a1->esw.psc1 : a1->esw.psc0;
669         state_a2 = p ? a2->esw.psc1 : a2->esw.psc0;
670         if (state_a1 == etr_lpsc_operational_step) {
671                 if (state_a2 != etr_lpsc_operational_step ||
672                     a1->edf1.net_id != a2->edf1.net_id ||
673                     a1->edf1.etr_id != a2->edf1.etr_id ||
674                     a1->edf1.etr_pn != a2->edf1.etr_pn)
675                         return 0;
676         } else if (state_a2 != etr_lpsc_pps_mode)
677                 return 0;
678
679         /* The ETV value of a2 needs to be ETV of a1 + 1. */
680         if (a1->edf2.etv + 1 != a2->edf2.etv)
681                 return 0;
682
683         if (!etr_port_valid(a2, p))
684                 return 0;
685
686         return 1;
687 }
688
689 struct clock_sync_data {
690         atomic_t cpus;
691         int in_sync;
692         unsigned long long fixup_cc;
693         int etr_port;
694         struct etr_aib *etr_aib;
695 };
696
697 static void clock_sync_cpu(struct clock_sync_data *sync)
698 {
699         atomic_dec(&sync->cpus);
700         enable_sync_clock();
701         /*
702          * This looks like a busy wait loop but it isn't. etr_sync_cpus
703          * is called on all other cpus while the TOD clocks is stopped.
704          * __udelay will stop the cpu on an enabled wait psw until the
705          * TOD is running again.
706          */
707         while (sync->in_sync == 0) {
708                 __udelay(1);
709                 /*
710                  * A different cpu changes *in_sync. Therefore use
711                  * barrier() to force memory access.
712                  */
713                 barrier();
714         }
715         if (sync->in_sync != 1)
716                 /* Didn't work. Clear per-cpu in sync bit again. */
717                 disable_sync_clock(NULL);
718         /*
719          * This round of TOD syncing is done. Set the clock comparator
720          * to the next tick and let the processor continue.
721          */
722         fixup_clock_comparator(sync->fixup_cc);
723 }
724
725 /*
726  * Sync the TOD clock using the port referred to by aibp. This port
727  * has to be enabled and the other port has to be disabled. The
728  * last eacr update has to be more than 1.6 seconds in the past.
729  */
730 static int etr_sync_clock(void *data)
731 {
732         static int first;
733         unsigned long long clock, old_clock, delay, delta;
734         struct clock_sync_data *etr_sync;
735         struct etr_aib *sync_port, *aib;
736         int port;
737         int rc;
738
739         etr_sync = data;
740
741         if (xchg(&first, 1) == 1) {
742                 /* Slave */
743                 clock_sync_cpu(etr_sync);
744                 return 0;
745         }
746
747         /* Wait until all other cpus entered the sync function. */
748         while (atomic_read(&etr_sync->cpus) != 0)
749                 cpu_relax();
750
751         port = etr_sync->etr_port;
752         aib = etr_sync->etr_aib;
753         sync_port = (port == 0) ? &etr_port0 : &etr_port1;
754         enable_sync_clock();
755
756         /* Set clock to next OTE. */
757         __ctl_set_bit(14, 21);
758         __ctl_set_bit(0, 29);
759         clock = ((unsigned long long) (aib->edf2.etv + 1)) << 32;
760         old_clock = get_clock();
761         if (set_clock(clock) == 0) {
762                 __udelay(1);    /* Wait for the clock to start. */
763                 __ctl_clear_bit(0, 29);
764                 __ctl_clear_bit(14, 21);
765                 etr_stetr(aib);
766                 /* Adjust Linux timing variables. */
767                 delay = (unsigned long long)
768                         (aib->edf2.etv - sync_port->edf2.etv) << 32;
769                 delta = adjust_time(old_clock, clock, delay);
770                 etr_sync->fixup_cc = delta;
771                 fixup_clock_comparator(delta);
772                 /* Verify that the clock is properly set. */
773                 if (!etr_aib_follows(sync_port, aib, port)) {
774                         /* Didn't work. */
775                         disable_sync_clock(NULL);
776                         etr_sync->in_sync = -EAGAIN;
777                         rc = -EAGAIN;
778                 } else {
779                         etr_sync->in_sync = 1;
780                         rc = 0;
781                 }
782         } else {
783                 /* Could not set the clock ?!? */
784                 __ctl_clear_bit(0, 29);
785                 __ctl_clear_bit(14, 21);
786                 disable_sync_clock(NULL);
787                 etr_sync->in_sync = -EAGAIN;
788                 rc = -EAGAIN;
789         }
790         xchg(&first, 0);
791         return rc;
792 }
793
794 static int etr_sync_clock_stop(struct etr_aib *aib, int port)
795 {
796         struct clock_sync_data etr_sync;
797         struct etr_aib *sync_port;
798         int follows;
799         int rc;
800
801         /* Check if the current aib is adjacent to the sync port aib. */
802         sync_port = (port == 0) ? &etr_port0 : &etr_port1;
803         follows = etr_aib_follows(sync_port, aib, port);
804         memcpy(sync_port, aib, sizeof(*aib));
805         if (!follows)
806                 return -EAGAIN;
807         memset(&etr_sync, 0, sizeof(etr_sync));
808         etr_sync.etr_aib = aib;
809         etr_sync.etr_port = port;
810         get_online_cpus();
811         atomic_set(&etr_sync.cpus, num_online_cpus() - 1);
812         rc = stop_machine(etr_sync_clock, &etr_sync, cpu_online_mask);
813         put_online_cpus();
814         return rc;
815 }
816
817 /*
818  * Handle the immediate effects of the different events.
819  * The port change event is used for online/offline changes.
820  */
821 static struct etr_eacr etr_handle_events(struct etr_eacr eacr)
822 {
823         if (test_and_clear_bit(ETR_EVENT_SYNC_CHECK, &etr_events))
824                 eacr.es = 0;
825         if (test_and_clear_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events))
826                 eacr.es = eacr.sl = 0;
827         if (test_and_clear_bit(ETR_EVENT_PORT_ALERT, &etr_events))
828                 etr_port0_uptodate = etr_port1_uptodate = 0;
829
830         if (test_and_clear_bit(ETR_EVENT_PORT0_CHANGE, &etr_events)) {
831                 if (eacr.e0)
832                         /*
833                          * Port change of an enabled port. We have to
834                          * assume that this can have caused an stepping
835                          * port switch.
836                          */
837                         etr_tolec = get_clock();
838                 eacr.p0 = etr_port0_online;
839                 if (!eacr.p0)
840                         eacr.e0 = 0;
841                 etr_port0_uptodate = 0;
842         }
843         if (test_and_clear_bit(ETR_EVENT_PORT1_CHANGE, &etr_events)) {
844                 if (eacr.e1)
845                         /*
846                          * Port change of an enabled port. We have to
847                          * assume that this can have caused an stepping
848                          * port switch.
849                          */
850                         etr_tolec = get_clock();
851                 eacr.p1 = etr_port1_online;
852                 if (!eacr.p1)
853                         eacr.e1 = 0;
854                 etr_port1_uptodate = 0;
855         }
856         clear_bit(ETR_EVENT_UPDATE, &etr_events);
857         return eacr;
858 }
859
860 /*
861  * Set up a timer that expires after the etr_tolec + 1.6 seconds if
862  * one of the ports needs an update.
863  */
864 static void etr_set_tolec_timeout(unsigned long long now)
865 {
866         unsigned long micros;
867
868         if ((!etr_eacr.p0 || etr_port0_uptodate) &&
869             (!etr_eacr.p1 || etr_port1_uptodate))
870                 return;
871         micros = (now > etr_tolec) ? ((now - etr_tolec) >> 12) : 0;
872         micros = (micros > 1600000) ? 0 : 1600000 - micros;
873         mod_timer(&etr_timer, jiffies + (micros * HZ) / 1000000 + 1);
874 }
875
876 /*
877  * Set up a time that expires after 1/2 second.
878  */
879 static void etr_set_sync_timeout(void)
880 {
881         mod_timer(&etr_timer, jiffies + HZ/2);
882 }
883
884 /*
885  * Update the aib information for one or both ports.
886  */
887 static struct etr_eacr etr_handle_update(struct etr_aib *aib,
888                                          struct etr_eacr eacr)
889 {
890         /* With both ports disabled the aib information is useless. */
891         if (!eacr.e0 && !eacr.e1)
892                 return eacr;
893
894         /* Update port0 or port1 with aib stored in etr_work_fn. */
895         if (aib->esw.q == 0) {
896                 /* Information for port 0 stored. */
897                 if (eacr.p0 && !etr_port0_uptodate) {
898                         etr_port0 = *aib;
899                         if (etr_port0_online)
900                                 etr_port0_uptodate = 1;
901                 }
902         } else {
903                 /* Information for port 1 stored. */
904                 if (eacr.p1 && !etr_port1_uptodate) {
905                         etr_port1 = *aib;
906                         if (etr_port0_online)
907                                 etr_port1_uptodate = 1;
908                 }
909         }
910
911         /*
912          * Do not try to get the alternate port aib if the clock
913          * is not in sync yet.
914          */
915         if (!eacr.es || !check_sync_clock())
916                 return eacr;
917
918         /*
919          * If steai is available we can get the information about
920          * the other port immediately. If only stetr is available the
921          * data-port bit toggle has to be used.
922          */
923         if (etr_steai_available) {
924                 if (eacr.p0 && !etr_port0_uptodate) {
925                         etr_steai_cv(&etr_port0, ETR_STEAI_PORT_0);
926                         etr_port0_uptodate = 1;
927                 }
928                 if (eacr.p1 && !etr_port1_uptodate) {
929                         etr_steai_cv(&etr_port1, ETR_STEAI_PORT_1);
930                         etr_port1_uptodate = 1;
931                 }
932         } else {
933                 /*
934                  * One port was updated above, if the other
935                  * port is not uptodate toggle dp bit.
936                  */
937                 if ((eacr.p0 && !etr_port0_uptodate) ||
938                     (eacr.p1 && !etr_port1_uptodate))
939                         eacr.dp ^= 1;
940                 else
941                         eacr.dp = 0;
942         }
943         return eacr;
944 }
945
946 /*
947  * Write new etr control register if it differs from the current one.
948  * Return 1 if etr_tolec has been updated as well.
949  */
950 static void etr_update_eacr(struct etr_eacr eacr)
951 {
952         int dp_changed;
953
954         if (memcmp(&etr_eacr, &eacr, sizeof(eacr)) == 0)
955                 /* No change, return. */
956                 return;
957         /*
958          * The disable of an active port of the change of the data port
959          * bit can/will cause a change in the data port.
960          */
961         dp_changed = etr_eacr.e0 > eacr.e0 || etr_eacr.e1 > eacr.e1 ||
962                 (etr_eacr.dp ^ eacr.dp) != 0;
963         etr_eacr = eacr;
964         etr_setr(&etr_eacr);
965         if (dp_changed)
966                 etr_tolec = get_clock();
967 }
968
969 /*
970  * ETR work. In this function you'll find the main logic. In
971  * particular this is the only function that calls etr_update_eacr(),
972  * it "controls" the etr control register.
973  */
974 static void etr_work_fn(struct work_struct *work)
975 {
976         unsigned long long now;
977         struct etr_eacr eacr;
978         struct etr_aib aib;
979         int sync_port;
980
981         /* prevent multiple execution. */
982         mutex_lock(&etr_work_mutex);
983
984         /* Create working copy of etr_eacr. */
985         eacr = etr_eacr;
986
987         /* Check for the different events and their immediate effects. */
988         eacr = etr_handle_events(eacr);
989
990         /* Check if ETR is supposed to be active. */
991         eacr.ea = eacr.p0 || eacr.p1;
992         if (!eacr.ea) {
993                 /* Both ports offline. Reset everything. */
994                 eacr.dp = eacr.es = eacr.sl = 0;
995                 on_each_cpu(disable_sync_clock, NULL, 1);
996                 del_timer_sync(&etr_timer);
997                 etr_update_eacr(eacr);
998                 goto out_unlock;
999         }
1000
1001         /* Store aib to get the current ETR status word. */
1002         BUG_ON(etr_stetr(&aib) != 0);
1003         etr_port0.esw = etr_port1.esw = aib.esw;        /* Copy status word. */
1004         now = get_clock();
1005
1006         /*
1007          * Update the port information if the last stepping port change
1008          * or data port change is older than 1.6 seconds.
1009          */
1010         if (now >= etr_tolec + (1600000 << 12))
1011                 eacr = etr_handle_update(&aib, eacr);
1012
1013         /*
1014          * Select ports to enable. The preferred synchronization mode is PPS.
1015          * If a port can be enabled depends on a number of things:
1016          * 1) The port needs to be online and uptodate. A port is not
1017          *    disabled just because it is not uptodate, but it is only
1018          *    enabled if it is uptodate.
1019          * 2) The port needs to have the same mode (pps / etr).
1020          * 3) The port needs to be usable -> etr_port_valid() == 1
1021          * 4) To enable the second port the clock needs to be in sync.
1022          * 5) If both ports are useable and are ETR ports, the network id
1023          *    has to be the same.
1024          * The eacr.sl bit is used to indicate etr mode vs. pps mode.
1025          */
1026         if (eacr.p0 && aib.esw.psc0 == etr_lpsc_pps_mode) {
1027                 eacr.sl = 0;
1028                 eacr.e0 = 1;
1029                 if (!etr_mode_is_pps(etr_eacr))
1030                         eacr.es = 0;
1031                 if (!eacr.es || !eacr.p1 || aib.esw.psc1 != etr_lpsc_pps_mode)
1032                         eacr.e1 = 0;
1033                 // FIXME: uptodate checks ?
1034                 else if (etr_port0_uptodate && etr_port1_uptodate)
1035                         eacr.e1 = 1;
1036                 sync_port = (etr_port0_uptodate &&
1037                              etr_port_valid(&etr_port0, 0)) ? 0 : -1;
1038         } else if (eacr.p1 && aib.esw.psc1 == etr_lpsc_pps_mode) {
1039                 eacr.sl = 0;
1040                 eacr.e0 = 0;
1041                 eacr.e1 = 1;
1042                 if (!etr_mode_is_pps(etr_eacr))
1043                         eacr.es = 0;
1044                 sync_port = (etr_port1_uptodate &&
1045                              etr_port_valid(&etr_port1, 1)) ? 1 : -1;
1046         } else if (eacr.p0 && aib.esw.psc0 == etr_lpsc_operational_step) {
1047                 eacr.sl = 1;
1048                 eacr.e0 = 1;
1049                 if (!etr_mode_is_etr(etr_eacr))
1050                         eacr.es = 0;
1051                 if (!eacr.es || !eacr.p1 ||
1052                     aib.esw.psc1 != etr_lpsc_operational_alt)
1053                         eacr.e1 = 0;
1054                 else if (etr_port0_uptodate && etr_port1_uptodate &&
1055                          etr_compare_network(&etr_port0, &etr_port1))
1056                         eacr.e1 = 1;
1057                 sync_port = (etr_port0_uptodate &&
1058                              etr_port_valid(&etr_port0, 0)) ? 0 : -1;
1059         } else if (eacr.p1 && aib.esw.psc1 == etr_lpsc_operational_step) {
1060                 eacr.sl = 1;
1061                 eacr.e0 = 0;
1062                 eacr.e1 = 1;
1063                 if (!etr_mode_is_etr(etr_eacr))
1064                         eacr.es = 0;
1065                 sync_port = (etr_port1_uptodate &&
1066                              etr_port_valid(&etr_port1, 1)) ? 1 : -1;
1067         } else {
1068                 /* Both ports not usable. */
1069                 eacr.es = eacr.sl = 0;
1070                 sync_port = -1;
1071         }
1072
1073         /*
1074          * If the clock is in sync just update the eacr and return.
1075          * If there is no valid sync port wait for a port update.
1076          */
1077         if ((eacr.es && check_sync_clock()) || sync_port < 0) {
1078                 etr_update_eacr(eacr);
1079                 etr_set_tolec_timeout(now);
1080                 goto out_unlock;
1081         }
1082
1083         /*
1084          * Prepare control register for clock syncing
1085          * (reset data port bit, set sync check control.
1086          */
1087         eacr.dp = 0;
1088         eacr.es = 1;
1089
1090         /*
1091          * Update eacr and try to synchronize the clock. If the update
1092          * of eacr caused a stepping port switch (or if we have to
1093          * assume that a stepping port switch has occurred) or the
1094          * clock syncing failed, reset the sync check control bit
1095          * and set up a timer to try again after 0.5 seconds
1096          */
1097         etr_update_eacr(eacr);
1098         if (now < etr_tolec + (1600000 << 12) ||
1099             etr_sync_clock_stop(&aib, sync_port) != 0) {
1100                 /* Sync failed. Try again in 1/2 second. */
1101                 eacr.es = 0;
1102                 etr_update_eacr(eacr);
1103                 etr_set_sync_timeout();
1104         } else
1105                 etr_set_tolec_timeout(now);
1106 out_unlock:
1107         mutex_unlock(&etr_work_mutex);
1108 }
1109
1110 /*
1111  * Sysfs interface functions
1112  */
1113 static struct sysdev_class etr_sysclass = {
1114         .name   = "etr",
1115 };
1116
1117 static struct sys_device etr_port0_dev = {
1118         .id     = 0,
1119         .cls    = &etr_sysclass,
1120 };
1121
1122 static struct sys_device etr_port1_dev = {
1123         .id     = 1,
1124         .cls    = &etr_sysclass,
1125 };
1126
1127 /*
1128  * ETR class attributes
1129  */
1130 static ssize_t etr_stepping_port_show(struct sysdev_class *class,
1131                                         struct sysdev_class_attribute *attr,
1132                                         char *buf)
1133 {
1134         return sprintf(buf, "%i\n", etr_port0.esw.p);
1135 }
1136
1137 static SYSDEV_CLASS_ATTR(stepping_port, 0400, etr_stepping_port_show, NULL);
1138
1139 static ssize_t etr_stepping_mode_show(struct sysdev_class *class,
1140                                         struct sysdev_class_attribute *attr,
1141                                         char *buf)
1142 {
1143         char *mode_str;
1144
1145         if (etr_mode_is_pps(etr_eacr))
1146                 mode_str = "pps";
1147         else if (etr_mode_is_etr(etr_eacr))
1148                 mode_str = "etr";
1149         else
1150                 mode_str = "local";
1151         return sprintf(buf, "%s\n", mode_str);
1152 }
1153
1154 static SYSDEV_CLASS_ATTR(stepping_mode, 0400, etr_stepping_mode_show, NULL);
1155
1156 /*
1157  * ETR port attributes
1158  */
1159 static inline struct etr_aib *etr_aib_from_dev(struct sys_device *dev)
1160 {
1161         if (dev == &etr_port0_dev)
1162                 return etr_port0_online ? &etr_port0 : NULL;
1163         else
1164                 return etr_port1_online ? &etr_port1 : NULL;
1165 }
1166
1167 static ssize_t etr_online_show(struct sys_device *dev,
1168                                 struct sysdev_attribute *attr,
1169                                 char *buf)
1170 {
1171         unsigned int online;
1172
1173         online = (dev == &etr_port0_dev) ? etr_port0_online : etr_port1_online;
1174         return sprintf(buf, "%i\n", online);
1175 }
1176
1177 static ssize_t etr_online_store(struct sys_device *dev,
1178                                 struct sysdev_attribute *attr,
1179                                 const char *buf, size_t count)
1180 {
1181         unsigned int value;
1182
1183         value = simple_strtoul(buf, NULL, 0);
1184         if (value != 0 && value != 1)
1185                 return -EINVAL;
1186         if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
1187                 return -EOPNOTSUPP;
1188         mutex_lock(&clock_sync_mutex);
1189         if (dev == &etr_port0_dev) {
1190                 if (etr_port0_online == value)
1191                         goto out;       /* Nothing to do. */
1192                 etr_port0_online = value;
1193                 if (etr_port0_online && etr_port1_online)
1194                         set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
1195                 else
1196                         clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
1197                 set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
1198                 queue_work(time_sync_wq, &etr_work);
1199         } else {
1200                 if (etr_port1_online == value)
1201                         goto out;       /* Nothing to do. */
1202                 etr_port1_online = value;
1203                 if (etr_port0_online && etr_port1_online)
1204                         set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
1205                 else
1206                         clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
1207                 set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
1208                 queue_work(time_sync_wq, &etr_work);
1209         }
1210 out:
1211         mutex_unlock(&clock_sync_mutex);
1212         return count;
1213 }
1214
1215 static SYSDEV_ATTR(online, 0600, etr_online_show, etr_online_store);
1216
1217 static ssize_t etr_stepping_control_show(struct sys_device *dev,
1218                                         struct sysdev_attribute *attr,
1219                                         char *buf)
1220 {
1221         return sprintf(buf, "%i\n", (dev == &etr_port0_dev) ?
1222                        etr_eacr.e0 : etr_eacr.e1);
1223 }
1224
1225 static SYSDEV_ATTR(stepping_control, 0400, etr_stepping_control_show, NULL);
1226
1227 static ssize_t etr_mode_code_show(struct sys_device *dev,
1228                                 struct sysdev_attribute *attr, char *buf)
1229 {
1230         if (!etr_port0_online && !etr_port1_online)
1231                 /* Status word is not uptodate if both ports are offline. */
1232                 return -ENODATA;
1233         return sprintf(buf, "%i\n", (dev == &etr_port0_dev) ?
1234                        etr_port0.esw.psc0 : etr_port0.esw.psc1);
1235 }
1236
1237 static SYSDEV_ATTR(state_code, 0400, etr_mode_code_show, NULL);
1238
1239 static ssize_t etr_untuned_show(struct sys_device *dev,
1240                                 struct sysdev_attribute *attr, char *buf)
1241 {
1242         struct etr_aib *aib = etr_aib_from_dev(dev);
1243
1244         if (!aib || !aib->slsw.v1)
1245                 return -ENODATA;
1246         return sprintf(buf, "%i\n", aib->edf1.u);
1247 }
1248
1249 static SYSDEV_ATTR(untuned, 0400, etr_untuned_show, NULL);
1250
1251 static ssize_t etr_network_id_show(struct sys_device *dev,
1252                                 struct sysdev_attribute *attr, char *buf)
1253 {
1254         struct etr_aib *aib = etr_aib_from_dev(dev);
1255
1256         if (!aib || !aib->slsw.v1)
1257                 return -ENODATA;
1258         return sprintf(buf, "%i\n", aib->edf1.net_id);
1259 }
1260
1261 static SYSDEV_ATTR(network, 0400, etr_network_id_show, NULL);
1262
1263 static ssize_t etr_id_show(struct sys_device *dev,
1264                         struct sysdev_attribute *attr, char *buf)
1265 {
1266         struct etr_aib *aib = etr_aib_from_dev(dev);
1267
1268         if (!aib || !aib->slsw.v1)
1269                 return -ENODATA;
1270         return sprintf(buf, "%i\n", aib->edf1.etr_id);
1271 }
1272
1273 static SYSDEV_ATTR(id, 0400, etr_id_show, NULL);
1274
1275 static ssize_t etr_port_number_show(struct sys_device *dev,
1276                         struct sysdev_attribute *attr, char *buf)
1277 {
1278         struct etr_aib *aib = etr_aib_from_dev(dev);
1279
1280         if (!aib || !aib->slsw.v1)
1281                 return -ENODATA;
1282         return sprintf(buf, "%i\n", aib->edf1.etr_pn);
1283 }
1284
1285 static SYSDEV_ATTR(port, 0400, etr_port_number_show, NULL);
1286
1287 static ssize_t etr_coupled_show(struct sys_device *dev,
1288                         struct sysdev_attribute *attr, char *buf)
1289 {
1290         struct etr_aib *aib = etr_aib_from_dev(dev);
1291
1292         if (!aib || !aib->slsw.v3)
1293                 return -ENODATA;
1294         return sprintf(buf, "%i\n", aib->edf3.c);
1295 }
1296
1297 static SYSDEV_ATTR(coupled, 0400, etr_coupled_show, NULL);
1298
1299 static ssize_t etr_local_time_show(struct sys_device *dev,
1300                         struct sysdev_attribute *attr, char *buf)
1301 {
1302         struct etr_aib *aib = etr_aib_from_dev(dev);
1303
1304         if (!aib || !aib->slsw.v3)
1305                 return -ENODATA;
1306         return sprintf(buf, "%i\n", aib->edf3.blto);
1307 }
1308
1309 static SYSDEV_ATTR(local_time, 0400, etr_local_time_show, NULL);
1310
1311 static ssize_t etr_utc_offset_show(struct sys_device *dev,
1312                         struct sysdev_attribute *attr, char *buf)
1313 {
1314         struct etr_aib *aib = etr_aib_from_dev(dev);
1315
1316         if (!aib || !aib->slsw.v3)
1317                 return -ENODATA;
1318         return sprintf(buf, "%i\n", aib->edf3.buo);
1319 }
1320
1321 static SYSDEV_ATTR(utc_offset, 0400, etr_utc_offset_show, NULL);
1322
1323 static struct sysdev_attribute *etr_port_attributes[] = {
1324         &attr_online,
1325         &attr_stepping_control,
1326         &attr_state_code,
1327         &attr_untuned,
1328         &attr_network,
1329         &attr_id,
1330         &attr_port,
1331         &attr_coupled,
1332         &attr_local_time,
1333         &attr_utc_offset,
1334         NULL
1335 };
1336
1337 static int __init etr_register_port(struct sys_device *dev)
1338 {
1339         struct sysdev_attribute **attr;
1340         int rc;
1341
1342         rc = sysdev_register(dev);
1343         if (rc)
1344                 goto out;
1345         for (attr = etr_port_attributes; *attr; attr++) {
1346                 rc = sysdev_create_file(dev, *attr);
1347                 if (rc)
1348                         goto out_unreg;
1349         }
1350         return 0;
1351 out_unreg:
1352         for (; attr >= etr_port_attributes; attr--)
1353                 sysdev_remove_file(dev, *attr);
1354         sysdev_unregister(dev);
1355 out:
1356         return rc;
1357 }
1358
1359 static void __init etr_unregister_port(struct sys_device *dev)
1360 {
1361         struct sysdev_attribute **attr;
1362
1363         for (attr = etr_port_attributes; *attr; attr++)
1364                 sysdev_remove_file(dev, *attr);
1365         sysdev_unregister(dev);
1366 }
1367
1368 static int __init etr_init_sysfs(void)
1369 {
1370         int rc;
1371
1372         rc = sysdev_class_register(&etr_sysclass);
1373         if (rc)
1374                 goto out;
1375         rc = sysdev_class_create_file(&etr_sysclass, &attr_stepping_port);
1376         if (rc)
1377                 goto out_unreg_class;
1378         rc = sysdev_class_create_file(&etr_sysclass, &attr_stepping_mode);
1379         if (rc)
1380                 goto out_remove_stepping_port;
1381         rc = etr_register_port(&etr_port0_dev);
1382         if (rc)
1383                 goto out_remove_stepping_mode;
1384         rc = etr_register_port(&etr_port1_dev);
1385         if (rc)
1386                 goto out_remove_port0;
1387         return 0;
1388
1389 out_remove_port0:
1390         etr_unregister_port(&etr_port0_dev);
1391 out_remove_stepping_mode:
1392         sysdev_class_remove_file(&etr_sysclass, &attr_stepping_mode);
1393 out_remove_stepping_port:
1394         sysdev_class_remove_file(&etr_sysclass, &attr_stepping_port);
1395 out_unreg_class:
1396         sysdev_class_unregister(&etr_sysclass);
1397 out:
1398         return rc;
1399 }
1400
1401 device_initcall(etr_init_sysfs);
1402
1403 /*
1404  * Server Time Protocol (STP) code.
1405  */
1406 static int stp_online;
1407 static struct stp_sstpi stp_info;
1408 static void *stp_page;
1409
1410 static void stp_work_fn(struct work_struct *work);
1411 static DEFINE_MUTEX(stp_work_mutex);
1412 static DECLARE_WORK(stp_work, stp_work_fn);
1413 static struct timer_list stp_timer;
1414
1415 static int __init early_parse_stp(char *p)
1416 {
1417         if (strncmp(p, "off", 3) == 0)
1418                 stp_online = 0;
1419         else if (strncmp(p, "on", 2) == 0)
1420                 stp_online = 1;
1421         return 0;
1422 }
1423 early_param("stp", early_parse_stp);
1424
1425 /*
1426  * Reset STP attachment.
1427  */
1428 static void __init stp_reset(void)
1429 {
1430         int rc;
1431
1432         stp_page = (void *) get_zeroed_page(GFP_ATOMIC);
1433         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
1434         if (rc == 0)
1435                 set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
1436         else if (stp_online) {
1437                 pr_warning("The real or virtual hardware system does "
1438                            "not provide an STP interface\n");
1439                 free_page((unsigned long) stp_page);
1440                 stp_page = NULL;
1441                 stp_online = 0;
1442         }
1443 }
1444
1445 static void stp_timeout(unsigned long dummy)
1446 {
1447         queue_work(time_sync_wq, &stp_work);
1448 }
1449
1450 static int __init stp_init(void)
1451 {
1452         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
1453                 return 0;
1454         setup_timer(&stp_timer, stp_timeout, 0UL);
1455         time_init_wq();
1456         if (!stp_online)
1457                 return 0;
1458         queue_work(time_sync_wq, &stp_work);
1459         return 0;
1460 }
1461
1462 arch_initcall(stp_init);
1463
1464 /*
1465  * STP timing alert. There are three causes:
1466  * 1) timing status change
1467  * 2) link availability change
1468  * 3) time control parameter change
1469  * In all three cases we are only interested in the clock source state.
1470  * If a STP clock source is now available use it.
1471  */
1472 static void stp_timing_alert(struct stp_irq_parm *intparm)
1473 {
1474         if (intparm->tsc || intparm->lac || intparm->tcpc)
1475                 queue_work(time_sync_wq, &stp_work);
1476 }
1477
1478 /*
1479  * STP sync check machine check. This is called when the timing state
1480  * changes from the synchronized state to the unsynchronized state.
1481  * After a STP sync check the clock is not in sync. The machine check
1482  * is broadcasted to all cpus at the same time.
1483  */
1484 void stp_sync_check(void)
1485 {
1486         disable_sync_clock(NULL);
1487         queue_work(time_sync_wq, &stp_work);
1488 }
1489
1490 /*
1491  * STP island condition machine check. This is called when an attached
1492  * server  attempts to communicate over an STP link and the servers
1493  * have matching CTN ids and have a valid stratum-1 configuration
1494  * but the configurations do not match.
1495  */
1496 void stp_island_check(void)
1497 {
1498         disable_sync_clock(NULL);
1499         queue_work(time_sync_wq, &stp_work);
1500 }
1501
1502
1503 static int stp_sync_clock(void *data)
1504 {
1505         static int first;
1506         unsigned long long old_clock, delta;
1507         struct clock_sync_data *stp_sync;
1508         int rc;
1509
1510         stp_sync = data;
1511
1512         if (xchg(&first, 1) == 1) {
1513                 /* Slave */
1514                 clock_sync_cpu(stp_sync);
1515                 return 0;
1516         }
1517
1518         /* Wait until all other cpus entered the sync function. */
1519         while (atomic_read(&stp_sync->cpus) != 0)
1520                 cpu_relax();
1521
1522         enable_sync_clock();
1523
1524         rc = 0;
1525         if (stp_info.todoff[0] || stp_info.todoff[1] ||
1526             stp_info.todoff[2] || stp_info.todoff[3] ||
1527             stp_info.tmd != 2) {
1528                 old_clock = get_clock();
1529                 rc = chsc_sstpc(stp_page, STP_OP_SYNC, 0);
1530                 if (rc == 0) {
1531                         delta = adjust_time(old_clock, get_clock(), 0);
1532                         fixup_clock_comparator(delta);
1533                         rc = chsc_sstpi(stp_page, &stp_info,
1534                                         sizeof(struct stp_sstpi));
1535                         if (rc == 0 && stp_info.tmd != 2)
1536                                 rc = -EAGAIN;
1537                 }
1538         }
1539         if (rc) {
1540                 disable_sync_clock(NULL);
1541                 stp_sync->in_sync = -EAGAIN;
1542         } else
1543                 stp_sync->in_sync = 1;
1544         xchg(&first, 0);
1545         return 0;
1546 }
1547
1548 /*
1549  * STP work. Check for the STP state and take over the clock
1550  * synchronization if the STP clock source is usable.
1551  */
1552 static void stp_work_fn(struct work_struct *work)
1553 {
1554         struct clock_sync_data stp_sync;
1555         int rc;
1556
1557         /* prevent multiple execution. */
1558         mutex_lock(&stp_work_mutex);
1559
1560         if (!stp_online) {
1561                 chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
1562                 del_timer_sync(&stp_timer);
1563                 goto out_unlock;
1564         }
1565
1566         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0);
1567         if (rc)
1568                 goto out_unlock;
1569
1570         rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
1571         if (rc || stp_info.c == 0)
1572                 goto out_unlock;
1573
1574         /* Skip synchronization if the clock is already in sync. */
1575         if (check_sync_clock())
1576                 goto out_unlock;
1577
1578         memset(&stp_sync, 0, sizeof(stp_sync));
1579         get_online_cpus();
1580         atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
1581         stop_machine(stp_sync_clock, &stp_sync, cpu_online_mask);
1582         put_online_cpus();
1583
1584         if (!check_sync_clock())
1585                 /*
1586                  * There is a usable clock but the synchonization failed.
1587                  * Retry after a second.
1588                  */
1589                 mod_timer(&stp_timer, jiffies + HZ);
1590
1591 out_unlock:
1592         mutex_unlock(&stp_work_mutex);
1593 }
1594
1595 /*
1596  * STP class sysfs interface functions
1597  */
1598 static struct sysdev_class stp_sysclass = {
1599         .name   = "stp",
1600 };
1601
1602 static ssize_t stp_ctn_id_show(struct sysdev_class *class,
1603                                 struct sysdev_class_attribute *attr,
1604                                 char *buf)
1605 {
1606         if (!stp_online)
1607                 return -ENODATA;
1608         return sprintf(buf, "%016llx\n",
1609                        *(unsigned long long *) stp_info.ctnid);
1610 }
1611
1612 static SYSDEV_CLASS_ATTR(ctn_id, 0400, stp_ctn_id_show, NULL);
1613
1614 static ssize_t stp_ctn_type_show(struct sysdev_class *class,
1615                                 struct sysdev_class_attribute *attr,
1616                                 char *buf)
1617 {
1618         if (!stp_online)
1619                 return -ENODATA;
1620         return sprintf(buf, "%i\n", stp_info.ctn);
1621 }
1622
1623 static SYSDEV_CLASS_ATTR(ctn_type, 0400, stp_ctn_type_show, NULL);
1624
1625 static ssize_t stp_dst_offset_show(struct sysdev_class *class,
1626                                    struct sysdev_class_attribute *attr,
1627                                    char *buf)
1628 {
1629         if (!stp_online || !(stp_info.vbits & 0x2000))
1630                 return -ENODATA;
1631         return sprintf(buf, "%i\n", (int)(s16) stp_info.dsto);
1632 }
1633
1634 static SYSDEV_CLASS_ATTR(dst_offset, 0400, stp_dst_offset_show, NULL);
1635
1636 static ssize_t stp_leap_seconds_show(struct sysdev_class *class,
1637                                         struct sysdev_class_attribute *attr,
1638                                         char *buf)
1639 {
1640         if (!stp_online || !(stp_info.vbits & 0x8000))
1641                 return -ENODATA;
1642         return sprintf(buf, "%i\n", (int)(s16) stp_info.leaps);
1643 }
1644
1645 static SYSDEV_CLASS_ATTR(leap_seconds, 0400, stp_leap_seconds_show, NULL);
1646
1647 static ssize_t stp_stratum_show(struct sysdev_class *class,
1648                                 struct sysdev_class_attribute *attr,
1649                                 char *buf)
1650 {
1651         if (!stp_online)
1652                 return -ENODATA;
1653         return sprintf(buf, "%i\n", (int)(s16) stp_info.stratum);
1654 }
1655
1656 static SYSDEV_CLASS_ATTR(stratum, 0400, stp_stratum_show, NULL);
1657
1658 static ssize_t stp_time_offset_show(struct sysdev_class *class,
1659                                 struct sysdev_class_attribute *attr,
1660                                 char *buf)
1661 {
1662         if (!stp_online || !(stp_info.vbits & 0x0800))
1663                 return -ENODATA;
1664         return sprintf(buf, "%i\n", (int) stp_info.tto);
1665 }
1666
1667 static SYSDEV_CLASS_ATTR(time_offset, 0400, stp_time_offset_show, NULL);
1668
1669 static ssize_t stp_time_zone_offset_show(struct sysdev_class *class,
1670                                 struct sysdev_class_attribute *attr,
1671                                 char *buf)
1672 {
1673         if (!stp_online || !(stp_info.vbits & 0x4000))
1674                 return -ENODATA;
1675         return sprintf(buf, "%i\n", (int)(s16) stp_info.tzo);
1676 }
1677
1678 static SYSDEV_CLASS_ATTR(time_zone_offset, 0400,
1679                          stp_time_zone_offset_show, NULL);
1680
1681 static ssize_t stp_timing_mode_show(struct sysdev_class *class,
1682                                 struct sysdev_class_attribute *attr,
1683                                 char *buf)
1684 {
1685         if (!stp_online)
1686                 return -ENODATA;
1687         return sprintf(buf, "%i\n", stp_info.tmd);
1688 }
1689
1690 static SYSDEV_CLASS_ATTR(timing_mode, 0400, stp_timing_mode_show, NULL);
1691
1692 static ssize_t stp_timing_state_show(struct sysdev_class *class,
1693                                 struct sysdev_class_attribute *attr,
1694                                 char *buf)
1695 {
1696         if (!stp_online)
1697                 return -ENODATA;
1698         return sprintf(buf, "%i\n", stp_info.tst);
1699 }
1700
1701 static SYSDEV_CLASS_ATTR(timing_state, 0400, stp_timing_state_show, NULL);
1702
1703 static ssize_t stp_online_show(struct sysdev_class *class,
1704                                 struct sysdev_class_attribute *attr,
1705                                 char *buf)
1706 {
1707         return sprintf(buf, "%i\n", stp_online);
1708 }
1709
1710 static ssize_t stp_online_store(struct sysdev_class *class,
1711                                 struct sysdev_class_attribute *attr,
1712                                 const char *buf, size_t count)
1713 {
1714         unsigned int value;
1715
1716         value = simple_strtoul(buf, NULL, 0);
1717         if (value != 0 && value != 1)
1718                 return -EINVAL;
1719         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
1720                 return -EOPNOTSUPP;
1721         mutex_lock(&clock_sync_mutex);
1722         stp_online = value;
1723         if (stp_online)
1724                 set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
1725         else
1726                 clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
1727         queue_work(time_sync_wq, &stp_work);
1728         mutex_unlock(&clock_sync_mutex);
1729         return count;
1730 }
1731
1732 /*
1733  * Can't use SYSDEV_CLASS_ATTR because the attribute should be named
1734  * stp/online but attr_online already exists in this file ..
1735  */
1736 static struct sysdev_class_attribute attr_stp_online = {
1737         .attr = { .name = "online", .mode = 0600 },
1738         .show   = stp_online_show,
1739         .store  = stp_online_store,
1740 };
1741
1742 static struct sysdev_class_attribute *stp_attributes[] = {
1743         &attr_ctn_id,
1744         &attr_ctn_type,
1745         &attr_dst_offset,
1746         &attr_leap_seconds,
1747         &attr_stp_online,
1748         &attr_stratum,
1749         &attr_time_offset,
1750         &attr_time_zone_offset,
1751         &attr_timing_mode,
1752         &attr_timing_state,
1753         NULL
1754 };
1755
1756 static int __init stp_init_sysfs(void)
1757 {
1758         struct sysdev_class_attribute **attr;
1759         int rc;
1760
1761         rc = sysdev_class_register(&stp_sysclass);
1762         if (rc)
1763                 goto out;
1764         for (attr = stp_attributes; *attr; attr++) {
1765                 rc = sysdev_class_create_file(&stp_sysclass, *attr);
1766                 if (rc)
1767                         goto out_unreg;
1768         }
1769         return 0;
1770 out_unreg:
1771         for (; attr >= stp_attributes; attr--)
1772                 sysdev_class_remove_file(&stp_sysclass, *attr);
1773         sysdev_class_unregister(&stp_sysclass);
1774 out:
1775         return rc;
1776 }
1777
1778 device_initcall(stp_init_sysfs);