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