arch/sparc/kernel/time.c

   1 /* $Id: time.c,v 1.60 2002/01/23 14:33:55 davem Exp $
   2  * linux/arch/sparc/kernel/time.c
   3  *
   4  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   5  * Copyright (C) 1996 Thomas K. Dyas (tdyas@eden.rutgers.edu)
   6  *
   7  * Chris Davis (cdavis@cois.on.ca) 03/27/1998
   8  * Added support for the intersil on the sun4/4200
   9  *
  10  * Gleb Raiko (rajko@mech.math.msu.su) 08/18/1998
  11  * Support for MicroSPARC-IIep, PCI CPU.
  12  *
  13  * This file handles the Sparc specific time handling details.
  14  *
  15  * 1997-09-10   Updated NTP code according to technical memorandum Jan '96
  16  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
  17  */
  18 #include <linux/config.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/time.h>
  28 #include <linux/timex.h>
  29 #include <linux/init.h>
  30 #include <linux/pci.h>
  31 #include <linux/ioport.h>
  32 #include <linux/profile.h>
  33
  34 #include <asm/oplib.h>
  35 #include <asm/timer.h>
  36 #include <asm/mostek.h>
  37 #include <asm/system.h>
  38 #include <asm/irq.h>
  39 #include <asm/io.h>
  40 #include <asm/idprom.h>
  41 #include <asm/machines.h>
  42 #include <asm/sun4paddr.h>
  43 #include <asm/page.h>
  44 #include <asm/pcic.h>
  45
  46 extern unsigned long wall_jiffies;
  47
  48 DEFINE_SPINLOCK(rtc_lock);
  49 enum sparc_clock_type sp_clock_typ;
  50 DEFINE_SPINLOCK(mostek_lock);
  51 void __iomem *mstk48t02_regs = NULL;
  52 static struct mostek48t08 __iomem *mstk48t08_regs = NULL;
  53 static int set_rtc_mmss(unsigned long);
  54 static int sbus_do_settimeofday(struct timespec *tv);
  55
  56 #ifdef CONFIG_SUN4
  57 struct intersil *intersil_clock;
  58 #define intersil_cmd(intersil_reg, intsil_cmd) intersil_reg->int_cmd_reg = \
  59         (intsil_cmd)
  60
  61 #define intersil_intr(intersil_reg, intsil_cmd) intersil_reg->int_intr_reg = \
  62         (intsil_cmd)
  63
  64 #define intersil_start(intersil_reg) intersil_cmd(intersil_reg, \
  65         ( INTERSIL_START | INTERSIL_32K | INTERSIL_NORMAL | INTERSIL_24H |\
  66           INTERSIL_INTR_ENABLE))
  67
  68 #define intersil_stop(intersil_reg) intersil_cmd(intersil_reg, \
  69         ( INTERSIL_STOP | INTERSIL_32K | INTERSIL_NORMAL | INTERSIL_24H |\
  70           INTERSIL_INTR_ENABLE))
  71
  72 #define intersil_read_intr(intersil_reg, towhere) towhere = \
  73         intersil_reg->int_intr_reg
  74
  75 #endif
  76
  77 unsigned long profile_pc(struct pt_regs *regs)
  78 {
  79         extern char __copy_user_begin[], __copy_user_end[];
  80         extern char __atomic_begin[], __atomic_end[];
  81         extern char __bzero_begin[], __bzero_end[];
  82         extern char __bitops_begin[], __bitops_end[];
  83
  84         unsigned long pc = regs->pc;
  85
  86         if (in_lock_functions(pc) ||
  87             (pc >= (unsigned long) __copy_user_begin &&
  88              pc < (unsigned long) __copy_user_end) ||
  89             (pc >= (unsigned long) __atomic_begin &&
  90              pc < (unsigned long) __atomic_end) ||
  91             (pc >= (unsigned long) __bzero_begin &&
  92              pc < (unsigned long) __bzero_end) ||
  93             (pc >= (unsigned long) __bitops_begin &&
  94              pc < (unsigned long) __bitops_end))
  95                 pc = regs->u_regs[UREG_RETPC];
  96         return pc;
  97 }
  98
  99 __volatile__ unsigned int *master_l10_counter;
 100 __volatile__ unsigned int *master_l10_limit;
 101
 102 /*
 103  * timer_interrupt() needs to keep up the real-time clock,
 104  * as well as call the "do_timer()" routine every clocktick
 105  */
 106
 107 #define TICK_SIZE (tick_nsec / 1000)
 108
 109 irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs * regs)
 110 {
 111         /* last time the cmos clock got updated */
 112         static long last_rtc_update;
 113
 114 #ifndef CONFIG_SMP
 115         profile_tick(CPU_PROFILING, regs);
 116 #endif
 117
 118         /* Protect counter clear so that do_gettimeoffset works */
 119         write_seqlock(&xtime_lock);
 120 #ifdef CONFIG_SUN4
 121         if((idprom->id_machtype == (SM_SUN4 | SM_4_260)) ||
 122            (idprom->id_machtype == (SM_SUN4 | SM_4_110))) {
 123                 int temp;
 124                 intersil_read_intr(intersil_clock, temp);
 125                 /* re-enable the irq */
 126                 enable_pil_irq(10);
 127         }
 128 #endif
 129         clear_clock_irq();
 130
 131         do_timer(regs);
 132 #ifndef CONFIG_SMP
 133         update_process_times(user_mode(regs));
 134 #endif
 135
 136
 137         /* Determine when to update the Mostek clock. */
 138         if (ntp_synced() &&
 139             xtime.tv_sec > last_rtc_update + 660 &&
 140             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
 141             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
 142           if (set_rtc_mmss(xtime.tv_sec) == 0)
 143             last_rtc_update = xtime.tv_sec;
 144           else
 145             last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
 146         }
 147         write_sequnlock(&xtime_lock);
 148
 149         return IRQ_HANDLED;
 150 }
 151
 152 /* Kick start a stopped clock (procedure from the Sun NVRAM/hostid FAQ). */
 153 static void __init kick_start_clock(void)
 154 {
 155         struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
 156         unsigned char sec;
 157         int i, count;
 158
 159         prom_printf("CLOCK: Clock was stopped. Kick start ");
 160
 161         spin_lock_irq(&mostek_lock);
 162
 163         /* Turn on the kick start bit to start the oscillator. */
 164         regs->creg |= MSTK_CREG_WRITE;
 165         regs->sec &= ~MSTK_STOP;
 166         regs->hour |= MSTK_KICK_START;
 167         regs->creg &= ~MSTK_CREG_WRITE;
 168
 169         spin_unlock_irq(&mostek_lock);
 170
 171         /* Delay to allow the clock oscillator to start. */
 172         sec = MSTK_REG_SEC(regs);
 173         for (i = 0; i < 3; i++) {
 174                 while (sec == MSTK_REG_SEC(regs))
 175                         for (count = 0; count < 100000; count++)
 176                                 /* nothing */ ;
 177                 prom_printf(".");
 178                 sec = regs->sec;
 179         }
 180         prom_printf("\n");
 181
 182         spin_lock_irq(&mostek_lock);
 183
 184         /* Turn off kick start and set a "valid" time and date. */
 185         regs->creg |= MSTK_CREG_WRITE;
 186         regs->hour &= ~MSTK_KICK_START;
 187         MSTK_SET_REG_SEC(regs,0);
 188         MSTK_SET_REG_MIN(regs,0);
 189         MSTK_SET_REG_HOUR(regs,0);
 190         MSTK_SET_REG_DOW(regs,5);
 191         MSTK_SET_REG_DOM(regs,1);
 192         MSTK_SET_REG_MONTH(regs,8);
 193         MSTK_SET_REG_YEAR(regs,1996 - MSTK_YEAR_ZERO);
 194         regs->creg &= ~MSTK_CREG_WRITE;
 195
 196         spin_unlock_irq(&mostek_lock);
 197
 198         /* Ensure the kick start bit is off. If it isn't, turn it off. */
 199         while (regs->hour & MSTK_KICK_START) {
 200                 prom_printf("CLOCK: Kick start still on!\n");
 201
 202                 spin_lock_irq(&mostek_lock);
 203                 regs->creg |= MSTK_CREG_WRITE;
 204                 regs->hour &= ~MSTK_KICK_START;
 205                 regs->creg &= ~MSTK_CREG_WRITE;
 206                 spin_unlock_irq(&mostek_lock);
 207         }
 208
 209         prom_printf("CLOCK: Kick start procedure successful.\n");
 210 }
 211
 212 /* Return nonzero if the clock chip battery is low. */
 213 static __inline__ int has_low_battery(void)
 214 {
 215         struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
 216         unsigned char data1, data2;
 217
 218         spin_lock_irq(&mostek_lock);
 219         data1 = regs->eeprom[0];        /* Read some data. */
 220         regs->eeprom[0] = ~data1;       /* Write back the complement. */
 221         data2 = regs->eeprom[0];        /* Read back the complement. */
 222         regs->eeprom[0] = data1;        /* Restore the original value. */
 223         spin_unlock_irq(&mostek_lock);
 224
 225         return (data1 == data2);        /* Was the write blocked? */
 226 }
 227
 228 /* Probe for the real time clock chip on Sun4 */
 229 static __inline__ void sun4_clock_probe(void)
 230 {
 231 #ifdef CONFIG_SUN4
 232         int temp;
 233         struct resource r;
 234
 235         memset(&r, 0, sizeof(r));
 236         if( idprom->id_machtype == (SM_SUN4 | SM_4_330) ) {
 237                 sp_clock_typ = MSTK48T02;
 238                 r.start = sun4_clock_physaddr;
 239                 mstk48t02_regs = sbus_ioremap(&r, 0,
 240                                        sizeof(struct mostek48t02), NULL);
 241                 mstk48t08_regs = NULL;  /* To catch weirdness */
 242                 intersil_clock = NULL;  /* just in case */
 243
 244                 /* Kick start the clock if it is completely stopped. */
 245                 if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
 246                         kick_start_clock();
 247         } else if( idprom->id_machtype == (SM_SUN4 | SM_4_260)) {
 248                 /* intersil setup code */
 249                 printk("Clock: INTERSIL at %8x ",sun4_clock_physaddr);
 250                 sp_clock_typ = INTERSIL;
 251                 r.start = sun4_clock_physaddr;
 252                 intersil_clock = (struct intersil *)
 253                     sbus_ioremap(&r, 0, sizeof(*intersil_clock), "intersil");
 254                 mstk48t02_regs = 0;  /* just be sure */
 255                 mstk48t08_regs = NULL;  /* ditto */
 256                 /* initialise the clock */
 257
 258                 intersil_intr(intersil_clock,INTERSIL_INT_100HZ);
 259
 260                 intersil_start(intersil_clock);
 261
 262                 intersil_read_intr(intersil_clock, temp);
 263                 while (!(temp & 0x80))
 264                         intersil_read_intr(intersil_clock, temp);
 265
 266                 intersil_read_intr(intersil_clock, temp);
 267                 while (!(temp & 0x80))
 268                         intersil_read_intr(intersil_clock, temp);
 269
 270                 intersil_stop(intersil_clock);
 271
 272         }
 273 #endif
 274 }
 275
 276 /* Probe for the mostek real time clock chip. */
 277 static __inline__ void clock_probe(void)
 278 {
 279         struct linux_prom_registers clk_reg[2];
 280         char model[128];
 281         register int node, cpuunit, bootbus;
 282         struct resource r;
 283
 284         cpuunit = bootbus = 0;
 285         memset(&r, 0, sizeof(r));
 286
 287         /* Determine the correct starting PROM node for the probe. */
 288         node = prom_getchild(prom_root_node);
 289         switch (sparc_cpu_model) {
 290         case sun4c:
 291                 break;
 292         case sun4m:
 293                 node = prom_getchild(prom_searchsiblings(node, "obio"));
 294                 break;
 295         case sun4d:
 296                 node = prom_getchild(bootbus = prom_searchsiblings(prom_getchild(cpuunit = prom_searchsiblings(node, "cpu-unit")), "bootbus"));
 297                 break;
 298         default:
 299                 prom_printf("CLOCK: Unsupported architecture!\n");
 300                 prom_halt();
 301         }
 302
 303         /* Find the PROM node describing the real time clock. */
 304         sp_clock_typ = MSTK_INVALID;
 305         node = prom_searchsiblings(node,"eeprom");
 306         if (!node) {
 307                 prom_printf("CLOCK: No clock found!\n");
 308                 prom_halt();
 309         }
 310
 311         /* Get the model name and setup everything up. */
 312         model[0] = '\0';
 313         prom_getstring(node, "model", model, sizeof(model));
 314         if (strcmp(model, "mk48t02") == 0) {
 315                 sp_clock_typ = MSTK48T02;
 316                 if (prom_getproperty(node, "reg", (char *) clk_reg, sizeof(clk_reg)) == -1) {
 317                         prom_printf("clock_probe: FAILED!\n");
 318                         prom_halt();
 319                 }
 320                 if (sparc_cpu_model == sun4d)
 321                         prom_apply_generic_ranges (bootbus, cpuunit, clk_reg, 1);
 322                 else
 323                         prom_apply_obio_ranges(clk_reg, 1);
 324                 /* Map the clock register io area read-only */
 325                 r.flags = clk_reg[0].which_io;
 326                 r.start = clk_reg[0].phys_addr;
 327                 mstk48t02_regs = sbus_ioremap(&r, 0,
 328                     sizeof(struct mostek48t02), "mk48t02");
 329                 mstk48t08_regs = NULL;  /* To catch weirdness */
 330         } else if (strcmp(model, "mk48t08") == 0) {
 331                 sp_clock_typ = MSTK48T08;
 332                 if(prom_getproperty(node, "reg", (char *) clk_reg,
 333                                     sizeof(clk_reg)) == -1) {
 334                         prom_printf("clock_probe: FAILED!\n");
 335                         prom_halt();
 336                 }
 337                 if (sparc_cpu_model == sun4d)
 338                         prom_apply_generic_ranges (bootbus, cpuunit, clk_reg, 1);
 339                 else
 340                         prom_apply_obio_ranges(clk_reg, 1);
 341                 /* Map the clock register io area read-only */
 342                 /* XXX r/o attribute is somewhere in r.flags */
 343                 r.flags = clk_reg[0].which_io;
 344                 r.start = clk_reg[0].phys_addr;
 345                 mstk48t08_regs = sbus_ioremap(&r, 0,
 346                     sizeof(struct mostek48t08), "mk48t08");
 347
 348                 mstk48t02_regs = &mstk48t08_regs->regs;
 349         } else {
 350                 prom_printf("CLOCK: Unknown model name '%s'\n",model);
 351                 prom_halt();
 352         }
 353
 354         /* Report a low battery voltage condition. */
 355         if (has_low_battery())
 356                 printk(KERN_CRIT "NVRAM: Low battery voltage!\n");
 357
 358         /* Kick start the clock if it is completely stopped. */
 359         if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
 360                 kick_start_clock();
 361 }
 362
 363 void __init sbus_time_init(void)
 364 {
 365         unsigned int year, mon, day, hour, min, sec;
 366         struct mostek48t02 *mregs;
 367
 368 #ifdef CONFIG_SUN4
 369         int temp;
 370         struct intersil *iregs;
 371 #endif
 372
 373         BTFIXUPSET_CALL(bus_do_settimeofday, sbus_do_settimeofday, BTFIXUPCALL_NORM);
 374         btfixup();
 375
 376         if (ARCH_SUN4)
 377                 sun4_clock_probe();
 378         else
 379                 clock_probe();
 380
 381         sparc_init_timers(timer_interrupt);
 382
 383 #ifdef CONFIG_SUN4
 384         if(idprom->id_machtype == (SM_SUN4 | SM_4_330)) {
 385 #endif
 386         mregs = (struct mostek48t02 *)mstk48t02_regs;
 387         if(!mregs) {
 388                 prom_printf("Something wrong, clock regs not mapped yet.\n");
 389                 prom_halt();
 390         }
 391         spin_lock_irq(&mostek_lock);
 392         mregs->creg |= MSTK_CREG_READ;
 393         sec = MSTK_REG_SEC(mregs);
 394         min = MSTK_REG_MIN(mregs);
 395         hour = MSTK_REG_HOUR(mregs);
 396         day = MSTK_REG_DOM(mregs);
 397         mon = MSTK_REG_MONTH(mregs);
 398         year = MSTK_CVT_YEAR( MSTK_REG_YEAR(mregs) );
 399         xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
 400         xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
 401         set_normalized_timespec(&wall_to_monotonic,
 402                                 -xtime.tv_sec, -xtime.tv_nsec);
 403         mregs->creg &= ~MSTK_CREG_READ;
 404         spin_unlock_irq(&mostek_lock);
 405 #ifdef CONFIG_SUN4
 406         } else if(idprom->id_machtype == (SM_SUN4 | SM_4_260) ) {
 407                 /* initialise the intersil on sun4 */
 408
 409                 iregs=intersil_clock;
 410                 if(!iregs) {
 411                         prom_printf("Something wrong, clock regs not mapped yet.\n");
 412                         prom_halt();
 413                 }
 414
 415                 intersil_intr(intersil_clock,INTERSIL_INT_100HZ);
 416                 disable_pil_irq(10);
 417                 intersil_stop(iregs);
 418                 intersil_read_intr(intersil_clock, temp);
 419
 420                 temp = iregs->clk.int_csec;
 421
 422                 sec = iregs->clk.int_sec;
 423                 min = iregs->clk.int_min;
 424                 hour = iregs->clk.int_hour;
 425                 day = iregs->clk.int_day;
 426                 mon = iregs->clk.int_month;
 427                 year = MSTK_CVT_YEAR(iregs->clk.int_year);
 428
 429                 enable_pil_irq(10);
 430                 intersil_start(iregs);
 431
 432                 xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
 433                 xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
 434                 set_normalized_timespec(&wall_to_monotonic,
 435                                        -xtime.tv_sec, -xtime.tv_nsec);
 436                 printk("%u/%u/%u %u:%u:%u\n",day,mon,year,hour,min,sec);
 437         }
 438 #endif
 439
 440         /* Now that OBP ticker has been silenced, it is safe to enable IRQ. */
 441         local_irq_enable();
 442 }
 443
 444 void __init time_init(void)
 445 {
 446 #ifdef CONFIG_PCI
 447         extern void pci_time_init(void);
 448         if (pcic_present()) {
 449                 pci_time_init();
 450                 return;
 451         }
 452 #endif
 453         sbus_time_init();
 454 }
 455
 456 static inline unsigned long do_gettimeoffset(void)
 457 {
 458         return (*master_l10_counter >> 10) & 0x1fffff;
 459 }
 460
 461 /*
 462  * Returns nanoseconds
 463  * XXX This is a suboptimal implementation.
 464  */
 465 unsigned long long sched_clock(void)
 466 {
 467         return (unsigned long long)jiffies * (1000000000 / HZ);
 468 }
 469
 470 /* Ok, my cute asm atomicity trick doesn't work anymore.
 471  * There are just too many variables that need to be protected
 472  * now (both members of xtime, wall_jiffies, et al.)
 473  */
 474 void do_gettimeofday(struct timeval *tv)
 475 {
 476         unsigned long flags;
 477         unsigned long seq;
 478         unsigned long usec, sec;
 479         unsigned long max_ntp_tick = tick_usec - tickadj;
 480
 481         do {
 482                 unsigned long lost;
 483
 484                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 485                 usec = do_gettimeoffset();
 486                 lost = jiffies - wall_jiffies;
 487
 488                 /*
 489                  * If time_adjust is negative then NTP is slowing the clock
 490                  * so make sure not to go into next possible interval.
 491                  * Better to lose some accuracy than have time go backwards..
 492                  */
 493                 if (unlikely(time_adjust < 0)) {
 494                         usec = min(usec, max_ntp_tick);
 495
 496                         if (lost)
 497                                 usec += lost * max_ntp_tick;
 498                 }
 499                 else if (unlikely(lost))
 500                         usec += lost * tick_usec;
 501
 502                 sec = xtime.tv_sec;
 503                 usec += (xtime.tv_nsec / 1000);
 504         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 505
 506         while (usec >= 1000000) {
 507                 usec -= 1000000;
 508                 sec++;
 509         }
 510
 511         tv->tv_sec = sec;
 512         tv->tv_usec = usec;
 513 }
 514
 515 EXPORT_SYMBOL(do_gettimeofday);
 516
 517 int do_settimeofday(struct timespec *tv)
 518 {
 519         int ret;
 520
 521         write_seqlock_irq(&xtime_lock);
 522         ret = bus_do_settimeofday(tv);
 523         write_sequnlock_irq(&xtime_lock);
 524         clock_was_set();
 525         return ret;
 526 }
 527
 528 EXPORT_SYMBOL(do_settimeofday);
 529
 530 static int sbus_do_settimeofday(struct timespec *tv)
 531 {
 532         time_t wtm_sec, sec = tv->tv_sec;
 533         long wtm_nsec, nsec = tv->tv_nsec;
 534
 535         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 536                 return -EINVAL;
 537
 538         /*
 539          * This is revolting. We need to set "xtime" correctly. However, the
 540          * value in this location is the value at the most recent update of
 541          * wall time.  Discover what correction gettimeofday() would have
 542          * made, and then undo it!
 543          */
 544         nsec -= 1000 * (do_gettimeoffset() +
 545                         (jiffies - wall_jiffies) * (USEC_PER_SEC / HZ));
 546
 547         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 548         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 549
 550         set_normalized_timespec(&xtime, sec, nsec);
 551         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 552
 553         ntp_clear();
 554         return 0;
 555 }
 556
 557 /*
 558  * BUG: This routine does not handle hour overflow properly; it just
 559  *      sets the minutes. Usually you won't notice until after reboot!
 560  */
 561 static int set_rtc_mmss(unsigned long nowtime)
 562 {
 563         int real_seconds, real_minutes, mostek_minutes;
 564         struct mostek48t02 *regs = (struct mostek48t02 *)mstk48t02_regs;
 565         unsigned long flags;
 566 #ifdef CONFIG_SUN4
 567         struct intersil *iregs = intersil_clock;
 568         int temp;
 569 #endif
 570
 571         /* Not having a register set can lead to trouble. */
 572         if (!regs) {
 573 #ifdef CONFIG_SUN4
 574                 if(!iregs)
 575                 return -1;
 576                 else {
 577                         temp = iregs->clk.int_csec;
 578
 579                         mostek_minutes = iregs->clk.int_min;
 580
 581                         real_seconds = nowtime % 60;
 582                         real_minutes = nowtime / 60;
 583                         if (((abs(real_minutes - mostek_minutes) + 15)/30) & 1)
 584                                 real_minutes += 30;     /* correct for half hour time zone */
 585                         real_minutes %= 60;
 586
 587                         if (abs(real_minutes - mostek_minutes) < 30) {
 588                                 intersil_stop(iregs);
 589                                 iregs->clk.int_sec=real_seconds;
 590                                 iregs->clk.int_min=real_minutes;
 591                                 intersil_start(iregs);
 592                         } else {
 593                                 printk(KERN_WARNING
 594                                "set_rtc_mmss: can't update from %d to %d\n",
 595                                        mostek_minutes, real_minutes);
 596                                 return -1;
 597                         }
 598
 599                         return 0;
 600                 }
 601 #endif
 602         }
 603
 604         spin_lock_irqsave(&mostek_lock, flags);
 605         /* Read the current RTC minutes. */
 606         regs->creg |= MSTK_CREG_READ;
 607         mostek_minutes = MSTK_REG_MIN(regs);
 608         regs->creg &= ~MSTK_CREG_READ;
 609
 610         /*
 611          * since we're only adjusting minutes and seconds,
 612          * don't interfere with hour overflow. This avoids
 613          * messing with unknown time zones but requires your
 614          * RTC not to be off by more than 15 minutes
 615          */
 616         real_seconds = nowtime % 60;
 617         real_minutes = nowtime / 60;
 618         if (((abs(real_minutes - mostek_minutes) + 15)/30) & 1)
 619                 real_minutes += 30;     /* correct for half hour time zone */
 620         real_minutes %= 60;
 621
 622         if (abs(real_minutes - mostek_minutes) < 30) {
 623                 regs->creg |= MSTK_CREG_WRITE;
 624                 MSTK_SET_REG_SEC(regs,real_seconds);
 625                 MSTK_SET_REG_MIN(regs,real_minutes);
 626                 regs->creg &= ~MSTK_CREG_WRITE;
 627                 spin_unlock_irqrestore(&mostek_lock, flags);
 628                 return 0;
 629         } else {
 630                 spin_unlock_irqrestore(&mostek_lock, flags);
 631                 return -1;
 632         }
 633 }