arch/s390/kernel/time.c

   1 /*
   2  *    Time of day based timer functions.
   3  *
   4  *  S390 version
   5  *    Copyright IBM Corp. 1999, 2008
   6  *    Author(s): Hartmut Penner (hp@de.ibm.com),
   7  *               Martin Schwidefsky (schwidefsky@de.ibm.com),
   8  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   9  *
  10  *  Derived from "arch/i386/kernel/time.c"
  11  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  12  */
  13
  14 #define KMSG_COMPONENT "time"
  15 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  16
  17 #include <linux/kernel_stat.h>
  18 #include <linux/errno.h>
  19 #include <linux/export.h>
  20 #include <linux/sched.h>
  21 #include <linux/kernel.h>
  22 #include <linux/param.h>
  23 #include <linux/string.h>
  24 #include <linux/mm.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/cpu.h>
  27 #include <linux/stop_machine.h>
  28 #include <linux/time.h>
  29 #include <linux/device.h>
  30 #include <linux/delay.h>
  31 #include <linux/init.h>
  32 #include <linux/smp.h>
  33 #include <linux/types.h>
  34 #include <linux/profile.h>
  35 #include <linux/timex.h>
  36 #include <linux/notifier.h>
  37 #include <linux/timekeeper_internal.h>
  38 #include <linux/clockchips.h>
  39 #include <linux/gfp.h>
  40 #include <linux/kprobes.h>
  41 #include <linux/uaccess.h>
  42 #include <asm/facility.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/vtimer.h>
  49 #include <asm/stp.h>
  50 #include <asm/cio.h>
  51 #include "entry.h"
  52
  53 u64 sched_clock_base_cc = -1;   /* Force to data section. */
  54 EXPORT_SYMBOL_GPL(sched_clock_base_cc);
  55
  56 static DEFINE_PER_CPU(struct clock_event_device, comparators);
  57
  58 ATOMIC_NOTIFIER_HEAD(s390_epoch_delta_notifier);
  59 EXPORT_SYMBOL(s390_epoch_delta_notifier);
  60
  61 unsigned char ptff_function_mask[16];
  62
  63 static unsigned long long lpar_offset;
  64 static unsigned long long initial_leap_seconds;
  65 static unsigned long long tod_steering_end;
  66 static long long tod_steering_delta;
  67
  68 /*
  69  * Get time offsets with PTFF
  70  */
  71 void __init time_early_init(void)
  72 {
  73         struct ptff_qto qto;
  74         struct ptff_qui qui;
  75
  76         /* Initialize TOD steering parameters */
  77         tod_steering_end = sched_clock_base_cc;
  78         vdso_data->ts_end = tod_steering_end;
  79
  80         if (!test_facility(28))
  81                 return;
  82
  83         ptff(&ptff_function_mask, sizeof(ptff_function_mask), PTFF_QAF);
  84
  85         /* get LPAR offset */
  86         if (ptff_query(PTFF_QTO) && ptff(&qto, sizeof(qto), PTFF_QTO) == 0)
  87                 lpar_offset = qto.tod_epoch_difference;
  88
  89         /* get initial leap seconds */
  90         if (ptff_query(PTFF_QUI) && ptff(&qui, sizeof(qui), PTFF_QUI) == 0)
  91                 initial_leap_seconds = (unsigned long long)
  92                         ((long) qui.old_leap * 4096000000L);
  93 }
  94
  95 /*
  96  * Scheduler clock - returns current time in nanosec units.
  97  */
  98 unsigned long long notrace sched_clock(void)
  99 {
 100         return tod_to_ns(get_tod_clock_monotonic());
 101 }
 102 NOKPROBE_SYMBOL(sched_clock);
 103
 104 /*
 105  * Monotonic_clock - returns # of nanoseconds passed since time_init()
 106  */
 107 unsigned long long monotonic_clock(void)
 108 {
 109         return sched_clock();
 110 }
 111 EXPORT_SYMBOL(monotonic_clock);
 112
 113 static void tod_to_timeval(__u64 todval, struct timespec64 *xt)
 114 {
 115         unsigned long long sec;
 116
 117         sec = todval >> 12;
 118         do_div(sec, 1000000);
 119         xt->tv_sec = sec;
 120         todval -= (sec * 1000000) << 12;
 121         xt->tv_nsec = ((todval * 1000) >> 12);
 122 }
 123
 124 void clock_comparator_work(void)
 125 {
 126         struct clock_event_device *cd;
 127
 128         S390_lowcore.clock_comparator = -1ULL;
 129         cd = this_cpu_ptr(&comparators);
 130         cd->event_handler(cd);
 131 }
 132
 133 static int s390_next_event(unsigned long delta,
 134                            struct clock_event_device *evt)
 135 {
 136         S390_lowcore.clock_comparator = get_tod_clock() + delta;
 137         set_clock_comparator(S390_lowcore.clock_comparator);
 138         return 0;
 139 }
 140
 141 /*
 142  * Set up lowcore and control register of the current cpu to
 143  * enable TOD clock and clock comparator interrupts.
 144  */
 145 void init_cpu_timer(void)
 146 {
 147         struct clock_event_device *cd;
 148         int cpu;
 149
 150         S390_lowcore.clock_comparator = -1ULL;
 151         set_clock_comparator(S390_lowcore.clock_comparator);
 152
 153         cpu = smp_processor_id();
 154         cd = &per_cpu(comparators, cpu);
 155         cd->name                = "comparator";
 156         cd->features            = CLOCK_EVT_FEAT_ONESHOT;
 157         cd->mult                = 16777;
 158         cd->shift               = 12;
 159         cd->min_delta_ns        = 1;
 160         cd->max_delta_ns        = LONG_MAX;
 161         cd->rating              = 400;
 162         cd->cpumask             = cpumask_of(cpu);
 163         cd->set_next_event      = s390_next_event;
 164
 165         clockevents_register_device(cd);
 166
 167         /* Enable clock comparator timer interrupt. */
 168         __ctl_set_bit(0,11);
 169
 170         /* Always allow the timing alert external interrupt. */
 171         __ctl_set_bit(0, 4);
 172 }
 173
 174 static void clock_comparator_interrupt(struct ext_code ext_code,
 175                                        unsigned int param32,
 176                                        unsigned long param64)
 177 {
 178         inc_irq_stat(IRQEXT_CLK);
 179         if (S390_lowcore.clock_comparator == -1ULL)
 180                 set_clock_comparator(S390_lowcore.clock_comparator);
 181 }
 182
 183 static void stp_timing_alert(struct stp_irq_parm *);
 184
 185 static void timing_alert_interrupt(struct ext_code ext_code,
 186                                    unsigned int param32, unsigned long param64)
 187 {
 188         inc_irq_stat(IRQEXT_TLA);
 189         if (param32 & 0x00038000)
 190                 stp_timing_alert((struct stp_irq_parm *) &param32);
 191 }
 192
 193 static void stp_reset(void);
 194
 195 void read_persistent_clock64(struct timespec64 *ts)
 196 {
 197         __u64 clock;
 198
 199         clock = get_tod_clock() - initial_leap_seconds;
 200         tod_to_timeval(clock - TOD_UNIX_EPOCH, ts);
 201 }
 202
 203 void read_boot_clock64(struct timespec64 *ts)
 204 {
 205         __u64 clock;
 206
 207         clock = sched_clock_base_cc - initial_leap_seconds;
 208         tod_to_timeval(clock - TOD_UNIX_EPOCH, ts);
 209 }
 210
 211 static u64 read_tod_clock(struct clocksource *cs)
 212 {
 213         unsigned long long now, adj;
 214
 215         preempt_disable(); /* protect from changes to steering parameters */
 216         now = get_tod_clock();
 217         adj = tod_steering_end - now;
 218         if (unlikely((s64) adj >= 0))
 219                 /*
 220                  * manually steer by 1 cycle every 2^16 cycles. This
 221                  * corresponds to shifting the tod delta by 15. 1s is
 222                  * therefore steered in ~9h. The adjust will decrease
 223                  * over time, until it finally reaches 0.
 224                  */
 225                 now += (tod_steering_delta < 0) ? (adj >> 15) : -(adj >> 15);
 226         preempt_enable();
 227         return now;
 228 }
 229
 230 static struct clocksource clocksource_tod = {
 231         .name           = "tod",
 232         .rating         = 400,
 233         .read           = read_tod_clock,
 234         .mask           = -1ULL,
 235         .mult           = 1000,
 236         .shift          = 12,
 237         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 238 };
 239
 240 struct clocksource * __init clocksource_default_clock(void)
 241 {
 242         return &clocksource_tod;
 243 }
 244
 245 void update_vsyscall(struct timekeeper *tk)
 246 {
 247         u64 nsecps;
 248
 249         if (tk->tkr_mono.clock != &clocksource_tod)
 250                 return;
 251
 252         /* Make userspace gettimeofday spin until we're done. */
 253         ++vdso_data->tb_update_count;
 254         smp_wmb();
 255         vdso_data->xtime_tod_stamp = tk->tkr_mono.cycle_last;
 256         vdso_data->xtime_clock_sec = tk->xtime_sec;
 257         vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec;
 258         vdso_data->wtom_clock_sec =
 259                 tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
 260         vdso_data->wtom_clock_nsec = tk->tkr_mono.xtime_nsec +
 261                 + ((u64) tk->wall_to_monotonic.tv_nsec << tk->tkr_mono.shift);
 262         nsecps = (u64) NSEC_PER_SEC << tk->tkr_mono.shift;
 263         while (vdso_data->wtom_clock_nsec >= nsecps) {
 264                 vdso_data->wtom_clock_nsec -= nsecps;
 265                 vdso_data->wtom_clock_sec++;
 266         }
 267
 268         vdso_data->xtime_coarse_sec = tk->xtime_sec;
 269         vdso_data->xtime_coarse_nsec =
 270                 (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);
 271         vdso_data->wtom_coarse_sec =
 272                 vdso_data->xtime_coarse_sec + tk->wall_to_monotonic.tv_sec;
 273         vdso_data->wtom_coarse_nsec =
 274                 vdso_data->xtime_coarse_nsec + tk->wall_to_monotonic.tv_nsec;
 275         while (vdso_data->wtom_coarse_nsec >= NSEC_PER_SEC) {
 276                 vdso_data->wtom_coarse_nsec -= NSEC_PER_SEC;
 277                 vdso_data->wtom_coarse_sec++;
 278         }
 279
 280         vdso_data->tk_mult = tk->tkr_mono.mult;
 281         vdso_data->tk_shift = tk->tkr_mono.shift;
 282         smp_wmb();
 283         ++vdso_data->tb_update_count;
 284 }
 285
 286 extern struct timezone sys_tz;
 287
 288 void update_vsyscall_tz(void)
 289 {
 290         vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
 291         vdso_data->tz_dsttime = sys_tz.tz_dsttime;
 292 }
 293
 294 /*
 295  * Initialize the TOD clock and the CPU timer of
 296  * the boot cpu.
 297  */
 298 void __init time_init(void)
 299 {
 300         /* Reset time synchronization interfaces. */
 301         stp_reset();
 302
 303         /* request the clock comparator external interrupt */
 304         if (register_external_irq(EXT_IRQ_CLK_COMP, clock_comparator_interrupt))
 305                 panic("Couldn't request external interrupt 0x1004");
 306
 307         /* request the timing alert external interrupt */
 308         if (register_external_irq(EXT_IRQ_TIMING_ALERT, timing_alert_interrupt))
 309                 panic("Couldn't request external interrupt 0x1406");
 310
 311         if (__clocksource_register(&clocksource_tod) != 0)
 312                 panic("Could not register TOD clock source");
 313
 314         /* Enable TOD clock interrupts on the boot cpu. */
 315         init_cpu_timer();
 316
 317         /* Enable cpu timer interrupts on the boot cpu. */
 318         vtime_init();
 319 }
 320
 321 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
 322 static DEFINE_MUTEX(clock_sync_mutex);
 323 static unsigned long clock_sync_flags;
 324
 325 #define CLOCK_SYNC_HAS_STP      0
 326 #define CLOCK_SYNC_STP          1
 327
 328 /*
 329  * The get_clock function for the physical clock. It will get the current
 330  * TOD clock, subtract the LPAR offset and write the result to *clock.
 331  * The function returns 0 if the clock is in sync with the external time
 332  * source. If the clock mode is local it will return -EOPNOTSUPP and
 333  * -EAGAIN if the clock is not in sync with the external reference.
 334  */
 335 int get_phys_clock(unsigned long long *clock)
 336 {
 337         atomic_t *sw_ptr;
 338         unsigned int sw0, sw1;
 339
 340         sw_ptr = &get_cpu_var(clock_sync_word);
 341         sw0 = atomic_read(sw_ptr);
 342         *clock = get_tod_clock() - lpar_offset;
 343         sw1 = atomic_read(sw_ptr);
 344         put_cpu_var(clock_sync_word);
 345         if (sw0 == sw1 && (sw0 & 0x80000000U))
 346                 /* Success: time is in sync. */
 347                 return 0;
 348         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 349                 return -EOPNOTSUPP;
 350         if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
 351                 return -EACCES;
 352         return -EAGAIN;
 353 }
 354 EXPORT_SYMBOL(get_phys_clock);
 355
 356 /*
 357  * Make get_phys_clock() return -EAGAIN.
 358  */
 359 static void disable_sync_clock(void *dummy)
 360 {
 361         atomic_t *sw_ptr = this_cpu_ptr(&clock_sync_word);
 362         /*
 363          * Clear the in-sync bit 2^31. All get_phys_clock calls will
 364          * fail until the sync bit is turned back on. In addition
 365          * increase the "sequence" counter to avoid the race of an
 366          * stp event and the complete recovery against get_phys_clock.
 367          */
 368         atomic_andnot(0x80000000, sw_ptr);
 369         atomic_inc(sw_ptr);
 370 }
 371
 372 /*
 373  * Make get_phys_clock() return 0 again.
 374  * Needs to be called from a context disabled for preemption.
 375  */
 376 static void enable_sync_clock(void)
 377 {
 378         atomic_t *sw_ptr = this_cpu_ptr(&clock_sync_word);
 379         atomic_or(0x80000000, sw_ptr);
 380 }
 381
 382 /*
 383  * Function to check if the clock is in sync.
 384  */
 385 static inline int check_sync_clock(void)
 386 {
 387         atomic_t *sw_ptr;
 388         int rc;
 389
 390         sw_ptr = &get_cpu_var(clock_sync_word);
 391         rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
 392         put_cpu_var(clock_sync_word);
 393         return rc;
 394 }
 395
 396 /*
 397  * Apply clock delta to the global data structures.
 398  * This is called once on the CPU that performed the clock sync.
 399  */
 400 static void clock_sync_global(unsigned long long delta)
 401 {
 402         unsigned long now, adj;
 403         struct ptff_qto qto;
 404
 405         /* Fixup the monotonic sched clock. */
 406         sched_clock_base_cc += delta;
 407         /* Adjust TOD steering parameters. */
 408         vdso_data->tb_update_count++;
 409         now = get_tod_clock();
 410         adj = tod_steering_end - now;
 411         if (unlikely((s64) adj >= 0))
 412                 /* Calculate how much of the old adjustment is left. */
 413                 tod_steering_delta = (tod_steering_delta < 0) ?
 414                         -(adj >> 15) : (adj >> 15);
 415         tod_steering_delta += delta;
 416         if ((abs(tod_steering_delta) >> 48) != 0)
 417                 panic("TOD clock sync offset %lli is too large to drift\n",
 418                       tod_steering_delta);
 419         tod_steering_end = now + (abs(tod_steering_delta) << 15);
 420         vdso_data->ts_dir = (tod_steering_delta < 0) ? 0 : 1;
 421         vdso_data->ts_end = tod_steering_end;
 422         vdso_data->tb_update_count++;
 423         /* Update LPAR offset. */
 424         if (ptff_query(PTFF_QTO) && ptff(&qto, sizeof(qto), PTFF_QTO) == 0)
 425                 lpar_offset = qto.tod_epoch_difference;
 426         /* Call the TOD clock change notifier. */
 427         atomic_notifier_call_chain(&s390_epoch_delta_notifier, 0, &delta);
 428 }
 429
 430 /*
 431  * Apply clock delta to the per-CPU data structures of this CPU.
 432  * This is called for each online CPU after the call to clock_sync_global.
 433  */
 434 static void clock_sync_local(unsigned long long delta)
 435 {
 436         /* Add the delta to the clock comparator. */
 437         if (S390_lowcore.clock_comparator != -1ULL) {
 438                 S390_lowcore.clock_comparator += delta;
 439                 set_clock_comparator(S390_lowcore.clock_comparator);
 440         }
 441         /* Adjust the last_update_clock time-stamp. */
 442         S390_lowcore.last_update_clock += delta;
 443 }
 444
 445 /* Single threaded workqueue used for stp sync events */
 446 static struct workqueue_struct *time_sync_wq;
 447
 448 static void __init time_init_wq(void)
 449 {
 450         if (time_sync_wq)
 451                 return;
 452         time_sync_wq = create_singlethread_workqueue("timesync");
 453 }
 454
 455 struct clock_sync_data {
 456         atomic_t cpus;
 457         int in_sync;
 458         unsigned long long clock_delta;
 459 };
 460
 461 /*
 462  * Server Time Protocol (STP) code.
 463  */
 464 static bool stp_online;
 465 static struct stp_sstpi stp_info;
 466 static void *stp_page;
 467
 468 static void stp_work_fn(struct work_struct *work);
 469 static DEFINE_MUTEX(stp_work_mutex);
 470 static DECLARE_WORK(stp_work, stp_work_fn);
 471 static struct timer_list stp_timer;
 472
 473 static int __init early_parse_stp(char *p)
 474 {
 475         return kstrtobool(p, &stp_online);
 476 }
 477 early_param("stp", early_parse_stp);
 478
 479 /*
 480  * Reset STP attachment.
 481  */
 482 static void __init stp_reset(void)
 483 {
 484         int rc;
 485
 486         stp_page = (void *) get_zeroed_page(GFP_ATOMIC);
 487         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000, NULL);
 488         if (rc == 0)
 489                 set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
 490         else if (stp_online) {
 491                 pr_warn("The real or virtual hardware system does not provide an STP interface\n");
 492                 free_page((unsigned long) stp_page);
 493                 stp_page = NULL;
 494                 stp_online = false;
 495         }
 496 }
 497
 498 static void stp_timeout(unsigned long dummy)
 499 {
 500         queue_work(time_sync_wq, &stp_work);
 501 }
 502
 503 static int __init stp_init(void)
 504 {
 505         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 506                 return 0;
 507         setup_timer(&stp_timer, stp_timeout, 0UL);
 508         time_init_wq();
 509         if (!stp_online)
 510                 return 0;
 511         queue_work(time_sync_wq, &stp_work);
 512         return 0;
 513 }
 514
 515 arch_initcall(stp_init);
 516
 517 /*
 518  * STP timing alert. There are three causes:
 519  * 1) timing status change
 520  * 2) link availability change
 521  * 3) time control parameter change
 522  * In all three cases we are only interested in the clock source state.
 523  * If a STP clock source is now available use it.
 524  */
 525 static void stp_timing_alert(struct stp_irq_parm *intparm)
 526 {
 527         if (intparm->tsc || intparm->lac || intparm->tcpc)
 528                 queue_work(time_sync_wq, &stp_work);
 529 }
 530
 531 /*
 532  * STP sync check machine check. This is called when the timing state
 533  * changes from the synchronized state to the unsynchronized state.
 534  * After a STP sync check the clock is not in sync. The machine check
 535  * is broadcasted to all cpus at the same time.
 536  */
 537 int stp_sync_check(void)
 538 {
 539         disable_sync_clock(NULL);
 540         return 1;
 541 }
 542
 543 /*
 544  * STP island condition machine check. This is called when an attached
 545  * server  attempts to communicate over an STP link and the servers
 546  * have matching CTN ids and have a valid stratum-1 configuration
 547  * but the configurations do not match.
 548  */
 549 int stp_island_check(void)
 550 {
 551         disable_sync_clock(NULL);
 552         return 1;
 553 }
 554
 555 void stp_queue_work(void)
 556 {
 557         queue_work(time_sync_wq, &stp_work);
 558 }
 559
 560 static int stp_sync_clock(void *data)
 561 {
 562         struct clock_sync_data *sync = data;
 563         unsigned long long clock_delta;
 564         static int first;
 565         int rc;
 566
 567         enable_sync_clock();
 568         if (xchg(&first, 1) == 0) {
 569                 /* Wait until all other cpus entered the sync function. */
 570                 while (atomic_read(&sync->cpus) != 0)
 571                         cpu_relax();
 572                 rc = 0;
 573                 if (stp_info.todoff[0] || stp_info.todoff[1] ||
 574                     stp_info.todoff[2] || stp_info.todoff[3] ||
 575                     stp_info.tmd != 2) {
 576                         rc = chsc_sstpc(stp_page, STP_OP_SYNC, 0,
 577                                         &clock_delta);
 578                         if (rc == 0) {
 579                                 sync->clock_delta = clock_delta;
 580                                 clock_sync_global(clock_delta);
 581                                 rc = chsc_sstpi(stp_page, &stp_info,
 582                                                 sizeof(struct stp_sstpi));
 583                                 if (rc == 0 && stp_info.tmd != 2)
 584                                         rc = -EAGAIN;
 585                         }
 586                 }
 587                 sync->in_sync = rc ? -EAGAIN : 1;
 588                 xchg(&first, 0);
 589         } else {
 590                 /* Slave */
 591                 atomic_dec(&sync->cpus);
 592                 /* Wait for in_sync to be set. */
 593                 while (READ_ONCE(sync->in_sync) == 0)
 594                         __udelay(1);
 595         }
 596         if (sync->in_sync != 1)
 597                 /* Didn't work. Clear per-cpu in sync bit again. */
 598                 disable_sync_clock(NULL);
 599         /* Apply clock delta to per-CPU fields of this CPU. */
 600         clock_sync_local(sync->clock_delta);
 601
 602         return 0;
 603 }
 604
 605 /*
 606  * STP work. Check for the STP state and take over the clock
 607  * synchronization if the STP clock source is usable.
 608  */
 609 static void stp_work_fn(struct work_struct *work)
 610 {
 611         struct clock_sync_data stp_sync;
 612         int rc;
 613
 614         /* prevent multiple execution. */
 615         mutex_lock(&stp_work_mutex);
 616
 617         if (!stp_online) {
 618                 chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000, NULL);
 619                 del_timer_sync(&stp_timer);
 620                 goto out_unlock;
 621         }
 622
 623         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0, NULL);
 624         if (rc)
 625                 goto out_unlock;
 626
 627         rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
 628         if (rc || stp_info.c == 0)
 629                 goto out_unlock;
 630
 631         /* Skip synchronization if the clock is already in sync. */
 632         if (check_sync_clock())
 633                 goto out_unlock;
 634
 635         memset(&stp_sync, 0, sizeof(stp_sync));
 636         get_online_cpus();
 637         atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
 638         stop_machine(stp_sync_clock, &stp_sync, cpu_online_mask);
 639         put_online_cpus();
 640
 641         if (!check_sync_clock())
 642                 /*
 643                  * There is a usable clock but the synchonization failed.
 644                  * Retry after a second.
 645                  */
 646                 mod_timer(&stp_timer, jiffies + HZ);
 647
 648 out_unlock:
 649         mutex_unlock(&stp_work_mutex);
 650 }
 651
 652 /*
 653  * STP subsys sysfs interface functions
 654  */
 655 static struct bus_type stp_subsys = {
 656         .name           = "stp",
 657         .dev_name       = "stp",
 658 };
 659
 660 static ssize_t stp_ctn_id_show(struct device *dev,
 661                                 struct device_attribute *attr,
 662                                 char *buf)
 663 {
 664         if (!stp_online)
 665                 return -ENODATA;
 666         return sprintf(buf, "%016llx\n",
 667                        *(unsigned long long *) stp_info.ctnid);
 668 }
 669
 670 static DEVICE_ATTR(ctn_id, 0400, stp_ctn_id_show, NULL);
 671
 672 static ssize_t stp_ctn_type_show(struct device *dev,
 673                                 struct device_attribute *attr,
 674                                 char *buf)
 675 {
 676         if (!stp_online)
 677                 return -ENODATA;
 678         return sprintf(buf, "%i\n", stp_info.ctn);
 679 }
 680
 681 static DEVICE_ATTR(ctn_type, 0400, stp_ctn_type_show, NULL);
 682
 683 static ssize_t stp_dst_offset_show(struct device *dev,
 684                                    struct device_attribute *attr,
 685                                    char *buf)
 686 {
 687         if (!stp_online || !(stp_info.vbits & 0x2000))
 688                 return -ENODATA;
 689         return sprintf(buf, "%i\n", (int)(s16) stp_info.dsto);
 690 }
 691
 692 static DEVICE_ATTR(dst_offset, 0400, stp_dst_offset_show, NULL);
 693
 694 static ssize_t stp_leap_seconds_show(struct device *dev,
 695                                         struct device_attribute *attr,
 696                                         char *buf)
 697 {
 698         if (!stp_online || !(stp_info.vbits & 0x8000))
 699                 return -ENODATA;
 700         return sprintf(buf, "%i\n", (int)(s16) stp_info.leaps);
 701 }
 702
 703 static DEVICE_ATTR(leap_seconds, 0400, stp_leap_seconds_show, NULL);
 704
 705 static ssize_t stp_stratum_show(struct device *dev,
 706                                 struct device_attribute *attr,
 707                                 char *buf)
 708 {
 709         if (!stp_online)
 710                 return -ENODATA;
 711         return sprintf(buf, "%i\n", (int)(s16) stp_info.stratum);
 712 }
 713
 714 static DEVICE_ATTR(stratum, 0400, stp_stratum_show, NULL);
 715
 716 static ssize_t stp_time_offset_show(struct device *dev,
 717                                 struct device_attribute *attr,
 718                                 char *buf)
 719 {
 720         if (!stp_online || !(stp_info.vbits & 0x0800))
 721                 return -ENODATA;
 722         return sprintf(buf, "%i\n", (int) stp_info.tto);
 723 }
 724
 725 static DEVICE_ATTR(time_offset, 0400, stp_time_offset_show, NULL);
 726
 727 static ssize_t stp_time_zone_offset_show(struct device *dev,
 728                                 struct device_attribute *attr,
 729                                 char *buf)
 730 {
 731         if (!stp_online || !(stp_info.vbits & 0x4000))
 732                 return -ENODATA;
 733         return sprintf(buf, "%i\n", (int)(s16) stp_info.tzo);
 734 }
 735
 736 static DEVICE_ATTR(time_zone_offset, 0400,
 737                          stp_time_zone_offset_show, NULL);
 738
 739 static ssize_t stp_timing_mode_show(struct device *dev,
 740                                 struct device_attribute *attr,
 741                                 char *buf)
 742 {
 743         if (!stp_online)
 744                 return -ENODATA;
 745         return sprintf(buf, "%i\n", stp_info.tmd);
 746 }
 747
 748 static DEVICE_ATTR(timing_mode, 0400, stp_timing_mode_show, NULL);
 749
 750 static ssize_t stp_timing_state_show(struct device *dev,
 751                                 struct device_attribute *attr,
 752                                 char *buf)
 753 {
 754         if (!stp_online)
 755                 return -ENODATA;
 756         return sprintf(buf, "%i\n", stp_info.tst);
 757 }
 758
 759 static DEVICE_ATTR(timing_state, 0400, stp_timing_state_show, NULL);
 760
 761 static ssize_t stp_online_show(struct device *dev,
 762                                 struct device_attribute *attr,
 763                                 char *buf)
 764 {
 765         return sprintf(buf, "%i\n", stp_online);
 766 }
 767
 768 static ssize_t stp_online_store(struct device *dev,
 769                                 struct device_attribute *attr,
 770                                 const char *buf, size_t count)
 771 {
 772         unsigned int value;
 773
 774         value = simple_strtoul(buf, NULL, 0);
 775         if (value != 0 && value != 1)
 776                 return -EINVAL;
 777         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 778                 return -EOPNOTSUPP;
 779         mutex_lock(&clock_sync_mutex);
 780         stp_online = value;
 781         if (stp_online)
 782                 set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
 783         else
 784                 clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
 785         queue_work(time_sync_wq, &stp_work);
 786         mutex_unlock(&clock_sync_mutex);
 787         return count;
 788 }
 789
 790 /*
 791  * Can't use DEVICE_ATTR because the attribute should be named
 792  * stp/online but dev_attr_online already exists in this file ..
 793  */
 794 static struct device_attribute dev_attr_stp_online = {
 795         .attr = { .name = "online", .mode = 0600 },
 796         .show   = stp_online_show,
 797         .store  = stp_online_store,
 798 };
 799
 800 static struct device_attribute *stp_attributes[] = {
 801         &dev_attr_ctn_id,
 802         &dev_attr_ctn_type,
 803         &dev_attr_dst_offset,
 804         &dev_attr_leap_seconds,
 805         &dev_attr_stp_online,
 806         &dev_attr_stratum,
 807         &dev_attr_time_offset,
 808         &dev_attr_time_zone_offset,
 809         &dev_attr_timing_mode,
 810         &dev_attr_timing_state,
 811         NULL
 812 };
 813
 814 static int __init stp_init_sysfs(void)
 815 {
 816         struct device_attribute **attr;
 817         int rc;
 818
 819         rc = subsys_system_register(&stp_subsys, NULL);
 820         if (rc)
 821                 goto out;
 822         for (attr = stp_attributes; *attr; attr++) {
 823                 rc = device_create_file(stp_subsys.dev_root, *attr);
 824                 if (rc)
 825                         goto out_unreg;
 826         }
 827         return 0;
 828 out_unreg:
 829         for (; attr >= stp_attributes; attr--)
 830                 device_remove_file(stp_subsys.dev_root, *attr);
 831         bus_unregister(&stp_subsys);
 832 out:
 833         return rc;
 834 }
 835
 836 device_initcall(stp_init_sysfs);