开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
time.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：20k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

time.c：源码内容
  1. /* $Id: time.c,v 1.41.2.2 2002/03/03 04:08:10 davem Exp $
  2.  * time.c: UltraSparc timer and TOD clock support.
  3.  *
  4.  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  5.  * Copyright (C) 1998 Eddie C. Dost   (ecd@skynet.be)
  6.  *
  7.  * Based largely on code which is:
  8.  *
  9.  * Copyright (C) 1996 Thomas K. Dyas (tdyas@eden.rutgers.edu)
  10.  */
  12. #include <linux/config.h>
  13. #include <linux/errno.h>
  14. #include <linux/sched.h>
  15. #include <linux/kernel.h>
  16. #include <linux/param.h>
  17. #include <linux/string.h>
  18. #include <linux/mm.h>
  19. #include <linux/interrupt.h>
  20. #include <linux/timex.h>
  21. #include <linux/init.h>
  22. #include <linux/ioport.h>
  23. #include <linux/mc146818rtc.h>
  24. #include <linux/delay.h>
  26. #include <asm/oplib.h>
  27. #include <asm/mostek.h>
  28. #include <asm/timer.h>
  29. #include <asm/irq.h>
  30. #include <asm/io.h>
  31. #include <asm/sbus.h>
  32. #include <asm/fhc.h>
  33. #include <asm/pbm.h>
  34. #include <asm/ebus.h>
  35. #include <asm/isa.h>
  36. #include <asm/starfire.h>
  38. extern rwlock_t xtime_lock;
  40. spinlock_t mostek_lock = SPIN_LOCK_UNLOCKED;
  41. spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
  42. unsigned long mstk48t02_regs = 0UL;
  43. #ifdef CONFIG_PCI
  44. unsigned long ds1287_regs = 0UL;
  45. #endif
  47. static unsigned long mstk48t08_regs = 0UL;
  48. static unsigned long mstk48t59_regs = 0UL;
  50. static int set_rtc_mmss(unsigned long);
  52. /* timer_interrupt() needs to keep up the real-time clock,
  53.  * as well as call the "do_timer()" routine every clocktick
  54.  *
  55.  * NOTE: On SUN5 systems the ticker interrupt comes in using 2
  56.  *       interrupts, one at level14 and one with softint bit 0.
  57.  */
  58. unsigned long timer_tick_offset;
  59. unsigned long timer_tick_compare;
  60. unsigned long timer_ticks_per_usec_quotient;
  62. static __inline__ void timer_check_rtc(void)
  63. {
  64. /* last time the cmos clock got updated */
  65. static long last_rtc_update;
  67. /* Determine when to update the Mostek clock. */
  68. if ((time_status & STA_UNSYNC) == 0 &&
  69.     xtime.tv_sec > last_rtc_update + 660 &&
  70.     xtime.tv_usec >= 500000 - ((unsigned) tick) / 2 &&
  71.     xtime.tv_usec <= 500000 + ((unsigned) tick) / 2) {
  72. if (set_rtc_mmss(xtime.tv_sec) == 0)
  73. last_rtc_update = xtime.tv_sec;
  74. else
  75. last_rtc_update = xtime.tv_sec - 600;
  76. /* do it again in 60 s */
  77. }
  78. }
  80. void sparc64_do_profile(unsigned long pc, unsigned long o7)
  81. {
  82. if (prof_buffer && current->pid) {
  83. extern int _stext;
  84. extern int rwlock_impl_begin, rwlock_impl_end;
  85. extern int atomic_impl_begin, atomic_impl_end;
  86. extern int __memcpy_begin, __memcpy_end;
  87. extern int __bzero_begin, __bzero_end;
  88. extern int __bitops_begin, __bitops_end;
  90. if ((pc >= (unsigned long) &atomic_impl_begin &&
  91.      pc < (unsigned long) &atomic_impl_end) ||
  92.     (pc >= (unsigned long) &rwlock_impl_begin &&
  93.      pc < (unsigned long) &rwlock_impl_end) ||
  94.     (pc >= (unsigned long) &__memcpy_begin &&
  95.      pc < (unsigned long) &__memcpy_end) ||
  96.     (pc >= (unsigned long) &__bzero_begin &&
  97.      pc < (unsigned long) &__bzero_end) ||
  98.     (pc >= (unsigned long) &__bitops_begin &&
  99.      pc < (unsigned long) &__bitops_end))
  100. pc = o7;
  102. pc -= (unsigned long) &_stext;
  103. pc >>= prof_shift;
  105. if(pc >= prof_len)
  106. pc = prof_len - 1;
  107. atomic_inc((atomic_t *)&prof_buffer[pc]);
  108. }
  109. }
  111. static void timer_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  112. {
  113. unsigned long ticks, pstate;
  115. write_lock(&xtime_lock);
  117. do {
  118. #ifndef CONFIG_SMP
  119. if ((regs->tstate & TSTATE_PRIV) != 0)
  120. sparc64_do_profile(regs->tpc, regs->u_regs[UREG_RETPC]);
  121. #endif
  122. do_timer(regs);
  124. /* Guarentee that the following sequences execute
  125.  * uninterrupted.
  126.  */
  127. __asm__ __volatile__("rdpr %%pstate, %0nt"
  128.      "wrpr %0, %1, %%pstate"
  129.      : "=r" (pstate)
  130.      : "i" (PSTATE_IE));
  132. /* Workaround for Spitfire Errata (#54 I think??), I discovered
  133.  * this via Sun BugID 4008234, mentioned in Solaris-2.5.1 patch
  134.  * number 103640.
  135.  *
  136.  * On Blackbird writes to %tick_cmpr can fail, the
  137.  * workaround seems to be to execute the wr instruction
  138.  * at the start of an I-cache line, and perform a dummy
  139.  * read back from %tick_cmpr right after writing to it. -DaveM
  140.  *
  141.  * Just to be anal we add a workaround for Spitfire
  142.  * Errata 50 by preventing pipeline bypasses on the
  143.  * final read of the %tick register into a compare
  144.  * instruction.  The Errata 50 description states
  145.  * that %tick is not prone to this bug, but I am not
  146.  * taking any chances.
  147.  */
  148. if (!SPARC64_USE_STICK) {
  149. __asm__ __volatile__(
  150. " rd %%tick_cmpr, %0n"
  151. " ba,pt %%xcc, 1fn"
  152. "  add %0, %2, %0n"
  153. " .align 64n"
  154. "1:  wr %0, 0, %%tick_cmprn"
  155. " rd %%tick_cmpr, %%g0n"
  156. " rd %%tick, %1n"
  157. " mov %1, %1"
  158. : "=&r" (timer_tick_compare), "=r" (ticks)
  159. : "r" (timer_tick_offset));
  160. } else {
  161. __asm__ __volatile__(
  162. " rd %%asr25, %0n"
  163. " add %0, %2, %0n"
  164. " wr %0, 0, %%asr25n"
  165. " rd %%asr24, %1"
  166. : "=&r" (timer_tick_compare), "=r" (ticks)
  167. : "r" (timer_tick_offset));
  168. }
  170. /* Restore PSTATE_IE. */
  171. __asm__ __volatile__("wrpr %0, 0x0, %%pstate"
  172.      : /* no outputs */
  173.      : "r" (pstate));
  174. } while (ticks >= timer_tick_compare);
  176. timer_check_rtc();
  178. write_unlock(&xtime_lock);
  179. }
  181. #ifdef CONFIG_SMP
  182. void timer_tick_interrupt(struct pt_regs *regs)
  183. {
  184. write_lock(&xtime_lock);
  186. do_timer(regs);
  188. /*
  189.  * Only keep timer_tick_offset uptodate, but don't set TICK_CMPR.
  190.  */
  191. if (!SPARC64_USE_STICK) {
  192. __asm__ __volatile__(
  193. " rd %%tick_cmpr, %0n"
  194. " add %0, %1, %0"
  195. : "=&r" (timer_tick_compare)
  196. : "r" (timer_tick_offset));
  197. } else {
  198. __asm__ __volatile__(
  199. " rd %%asr25, %0n"
  200. " add %0, %1, %0"
  201. : "=&r" (timer_tick_compare)
  202. : "r" (timer_tick_offset));
  203. }
  205. timer_check_rtc();
  207. write_unlock(&xtime_lock);
  208. }
  209. #endif
  211. /* Kick start a stopped clock (procedure from the Sun NVRAM/hostid FAQ). */
  212. static void __init kick_start_clock(void)
  213. {
  214. unsigned long regs = mstk48t02_regs;
  215. u8 sec, tmp;
  216. int i, count;
  218. prom_printf("CLOCK: Clock was stopped. Kick start ");
  220. spin_lock_irq(&mostek_lock);
  222. /* Turn on the kick start bit to start the oscillator. */
  223. tmp = mostek_read(regs + MOSTEK_CREG);
  224. tmp |= MSTK_CREG_WRITE;
  225. mostek_write(regs + MOSTEK_CREG, tmp);
  226. tmp = mostek_read(regs + MOSTEK_SEC);
  227. tmp &= ~MSTK_STOP;
  228. mostek_write(regs + MOSTEK_SEC, tmp);
  229. tmp = mostek_read(regs + MOSTEK_HOUR);
  230. tmp |= MSTK_KICK_START;
  231. mostek_write(regs + MOSTEK_HOUR, tmp);
  232. tmp = mostek_read(regs + MOSTEK_CREG);
  233. tmp &= ~MSTK_CREG_WRITE;
  234. mostek_write(regs + MOSTEK_CREG, tmp);
  236. spin_unlock_irq(&mostek_lock);
  238. /* Delay to allow the clock oscillator to start. */
  239. sec = MSTK_REG_SEC(regs);
  240. for (i = 0; i < 3; i++) {
  241. while (sec == MSTK_REG_SEC(regs))
  242. for (count = 0; count < 100000; count++)
  243. /* nothing */ ;
  244. prom_printf(".");
  245. sec = MSTK_REG_SEC(regs);
  246. }
  247. prom_printf("n");
  249. spin_lock_irq(&mostek_lock);
  251. /* Turn off kick start and set a "valid" time and date. */
  252. tmp = mostek_read(regs + MOSTEK_CREG);
  253. tmp |= MSTK_CREG_WRITE;
  254. mostek_write(regs + MOSTEK_CREG, tmp);
  255. tmp = mostek_read(regs + MOSTEK_HOUR);
  256. tmp &= ~MSTK_KICK_START;
  257. mostek_write(regs + MOSTEK_HOUR, tmp);
  258. MSTK_SET_REG_SEC(regs,0);
  259. MSTK_SET_REG_MIN(regs,0);
  260. MSTK_SET_REG_HOUR(regs,0);
  261. MSTK_SET_REG_DOW(regs,5);
  262. MSTK_SET_REG_DOM(regs,1);
  263. MSTK_SET_REG_MONTH(regs,8);
  264. MSTK_SET_REG_YEAR(regs,1996 - MSTK_YEAR_ZERO);
  265. tmp = mostek_read(regs + MOSTEK_CREG);
  266. tmp &= ~MSTK_CREG_WRITE;
  267. mostek_write(regs + MOSTEK_CREG, tmp);
  269. spin_unlock_irq(&mostek_lock);
  271. /* Ensure the kick start bit is off. If it isn't, turn it off. */
  272. while (mostek_read(regs + MOSTEK_HOUR) & MSTK_KICK_START) {
  273. prom_printf("CLOCK: Kick start still on!n");
  275. spin_lock_irq(&mostek_lock);
  277. tmp = mostek_read(regs + MOSTEK_CREG);
  278. tmp |= MSTK_CREG_WRITE;
  279. mostek_write(regs + MOSTEK_CREG, tmp);
  281. tmp = mostek_read(regs + MOSTEK_HOUR);
  282. tmp &= ~MSTK_KICK_START;
  283. mostek_write(regs + MOSTEK_HOUR, tmp);
  285. tmp = mostek_read(regs + MOSTEK_CREG);
  286. tmp &= ~MSTK_CREG_WRITE;
  287. mostek_write(regs + MOSTEK_CREG, tmp);
  289. spin_unlock_irq(&mostek_lock);
  290. }
  292. prom_printf("CLOCK: Kick start procedure successful.n");
  293. }
  295. /* Return nonzero if the clock chip battery is low. */
  296. static int __init has_low_battery(void)
  297. {
  298. unsigned long regs = mstk48t02_regs;
  299. u8 data1, data2;
  301. spin_lock_irq(&mostek_lock);
  303. data1 = mostek_read(regs + MOSTEK_EEPROM); /* Read some data. */
  304. mostek_write(regs + MOSTEK_EEPROM, ~data1); /* Write back the complement. */
  305. data2 = mostek_read(regs + MOSTEK_EEPROM); /* Read back the complement. */
  306. mostek_write(regs + MOSTEK_EEPROM, data1); /* Restore original value. */
  308. spin_unlock_irq(&mostek_lock);
  310. return (data1 == data2); /* Was the write blocked? */
  311. }
  313. #ifndef BCD_TO_BIN
  314. #define BCD_TO_BIN(val) (((val)&15) + ((val)>>4)*10)
  315. #endif
  317. #ifndef BIN_TO_BCD
  318. #define BIN_TO_BCD(val) ((((val)/10)<<4) + (val)%10)
  319. #endif
  321. /* Probe for the real time clock chip. */
  322. static void __init set_system_time(void)
  323. {
  324. unsigned int year, mon, day, hour, min, sec;
  325. unsigned long mregs = mstk48t02_regs;
  326. #ifdef CONFIG_PCI
  327. unsigned long dregs = ds1287_regs;
  328. #else
  329. unsigned long dregs = 0UL;
  330. #endif
  331. u8 tmp;
  333. if (!mregs && !dregs) {
  334. prom_printf("Something wrong, clock regs not mapped yet.n");
  335. prom_halt();
  336. }
  338. if (mregs) {
  339. spin_lock_irq(&mostek_lock);
  341. /* Traditional Mostek chip. */
  342. tmp = mostek_read(mregs + MOSTEK_CREG);
  343. tmp |= MSTK_CREG_READ;
  344. mostek_write(mregs + MOSTEK_CREG, tmp);
  346. sec = MSTK_REG_SEC(mregs);
  347. min = MSTK_REG_MIN(mregs);
  348. hour = MSTK_REG_HOUR(mregs);
  349. day = MSTK_REG_DOM(mregs);
  350. mon = MSTK_REG_MONTH(mregs);
  351. year = MSTK_CVT_YEAR( MSTK_REG_YEAR(mregs) );
  352. } else {
  353. int i;
  355. /* Dallas 12887 RTC chip. */
  357. /* Stolen from arch/i386/kernel/time.c, see there for
  358.  * credits and descriptive comments.
  359.  */
  360. for (i = 0; i < 1000000; i++) {
  361. if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
  362. break;
  363. udelay(10);
  364. }
  365. for (i = 0; i < 1000000; i++) {
  366. if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
  367. break;
  368. udelay(10);
  369. }
  370. do {
  371. sec  = CMOS_READ(RTC_SECONDS);
  372. min  = CMOS_READ(RTC_MINUTES);
  373. hour = CMOS_READ(RTC_HOURS);
  374. day  = CMOS_READ(RTC_DAY_OF_MONTH);
  375. mon  = CMOS_READ(RTC_MONTH);
  376. year = CMOS_READ(RTC_YEAR);
  377. } while (sec != CMOS_READ(RTC_SECONDS));
  378. if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
  379. BCD_TO_BIN(sec);
  380. BCD_TO_BIN(min);
  381. BCD_TO_BIN(hour);
  382. BCD_TO_BIN(day);
  383. BCD_TO_BIN(mon);
  384. BCD_TO_BIN(year);
  385. }
  386. if ((year += 1900) < 1970)
  387. year += 100;
  388. }
  390. xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  391. xtime.tv_usec = 0;
  393. if (mregs) {
  394. tmp = mostek_read(mregs + MOSTEK_CREG);
  395. tmp &= ~MSTK_CREG_READ;
  396. mostek_write(mregs + MOSTEK_CREG, tmp);
  398. spin_unlock_irq(&mostek_lock);
  399. }
  400. }
  402. void __init clock_probe(void)
  403. {
  404. struct linux_prom_registers clk_reg[2];
  405. char model[128];
  406. int node, busnd = -1, err;
  407. unsigned long flags;
  408. struct linux_central *cbus;
  409. #ifdef CONFIG_PCI
  410. struct linux_ebus *ebus = NULL;
  411. struct isa_bridge *isa_br = NULL;
  412. #endif
  413. static int invoked;
  415. if (invoked)
  416. return;
  417. invoked = 1;
  420. if (this_is_starfire) {
  421. /* davem suggests we keep this within the 4M locked kernel image */
  422. static char obp_gettod[256];
  423. static u32 unix_tod;
  425. sprintf(obp_gettod, "h# %08x unix-gettod",
  426. (unsigned int) (long) &unix_tod);
  427. prom_feval(obp_gettod);
  428. xtime.tv_sec = unix_tod;
  429. xtime.tv_usec = 0;
  430. return;
  431. }
  433. __save_and_cli(flags);
  435. cbus = central_bus;
  436. if (cbus != NULL)
  437. busnd = central_bus->child->prom_node;
  439. /* Check FHC Central then EBUSs then ISA bridges then SBUSs.
  440.  * That way we handle the presence of multiple properly.
  441.  *
  442.  * As a special case, machines with Central must provide the
  443.  * timer chip there.
  444.  */
  445. #ifdef CONFIG_PCI
  446. if (ebus_chain != NULL) {
  447. ebus = ebus_chain;
  448. if (busnd == -1)
  449. busnd = ebus->prom_node;
  450. }
  451. if (isa_chain != NULL) {
  452. isa_br = isa_chain;
  453. if (busnd == -1)
  454. busnd = isa_br->prom_node;
  455. }
  456. #endif
  457. if (sbus_root != NULL && busnd == -1)
  458. busnd = sbus_root->prom_node;
  460. if (busnd == -1) {
  461. prom_printf("clock_probe: problem, cannot find bus to search.n");
  462. prom_halt();
  463. }
  465. node = prom_getchild(busnd);
  467. while (1) {
  468. if (!node)
  469. model[0] = 0;
  470. else
  471. prom_getstring(node, "model", model, sizeof(model));
  472. if (strcmp(model, "mk48t02") &&
  473.     strcmp(model, "mk48t08") &&
  474.     strcmp(model, "mk48t59") &&
  475.     strcmp(model, "m5819") &&
  476.     strcmp(model, "ds1287")) {
  477. if (cbus != NULL) {
  478. prom_printf("clock_probe: Central bus lacks timer chip.n");
  479. prom_halt();
  480. }
  482.     if (node != 0)
  483. node = prom_getsibling(node);
  484. #ifdef CONFIG_PCI
  485. while ((node == 0) && ebus != NULL) {
  486. ebus = ebus->next;
  487. if (ebus != NULL) {
  488. busnd = ebus->prom_node;
  489. node = prom_getchild(busnd);
  490. }
  491. }
  492. while ((node == 0) && isa_br != NULL) {
  493. isa_br = isa_br->next;
  494. if (isa_br != NULL) {
  495. busnd = isa_br->prom_node;
  496. node = prom_getchild(busnd);
  497. }
  498. }
  499. #endif
  500. if (node == 0) {
  501. prom_printf("clock_probe: Cannot find timer chipn");
  502. prom_halt();
  503. }
  504. continue;
  505. }
  507. err = prom_getproperty(node, "reg", (char *)clk_reg,
  508.        sizeof(clk_reg));
  509. if(err == -1) {
  510. prom_printf("clock_probe: Cannot get Mostek reg propertyn");
  511. prom_halt();
  512. }
  514. if (cbus != NULL) {
  515. apply_fhc_ranges(central_bus->child, clk_reg, 1);
  516. apply_central_ranges(central_bus, clk_reg, 1);
  517. }
  518. #ifdef CONFIG_PCI
  519. else if (ebus != NULL) {
  520. struct linux_ebus_device *edev;
  522. for_each_ebusdev(edev, ebus)
  523. if (edev->prom_node == node)
  524. break;
  525. if (edev == NULL) {
  526. if (isa_chain != NULL)
  527. goto try_isa_clock;
  528. prom_printf("%s: Mostek not probed by EBUSn",
  529.     __FUNCTION__);
  530. prom_halt();
  531. }
  533. if (!strcmp(model, "ds1287") ||
  534.     !strcmp(model, "m5819")) {
  535. ds1287_regs = edev->resource[0].start;
  536. } else {
  537. mstk48t59_regs = edev->resource[0].start;
  538. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  539. }
  540. break;
  541. }
  542. else if (isa_br != NULL) {
  543. struct isa_device *isadev;
  545. try_isa_clock:
  546. for_each_isadev(isadev, isa_br)
  547. if (isadev->prom_node == node)
  548. break;
  549. if (isadev == NULL) {
  550. prom_printf("%s: Mostek not probed by ISAn");
  551. prom_halt();
  552. }
  553. if (!strcmp(model, "ds1287") ||
  554.     !strcmp(model, "m5819")) {
  555. ds1287_regs = isadev->resource.start;
  556. } else {
  557. mstk48t59_regs = isadev->resource.start;
  558. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  559. }
  560. break;
  561. }
  562. #endif
  563. else {
  564. if (sbus_root->num_sbus_ranges) {
  565. int nranges = sbus_root->num_sbus_ranges;
  566. int rngc;
  568. for (rngc = 0; rngc < nranges; rngc++)
  569. if (clk_reg[0].which_io ==
  570.     sbus_root->sbus_ranges[rngc].ot_child_space)
  571. break;
  572. if (rngc == nranges) {
  573. prom_printf("clock_probe: Cannot find ranges for "
  574.     "clock regs.n");
  575. prom_halt();
  576. }
  577. clk_reg[0].which_io =
  578. sbus_root->sbus_ranges[rngc].ot_parent_space;
  579. clk_reg[0].phys_addr +=
  580. sbus_root->sbus_ranges[rngc].ot_parent_base;
  581. }
  582. }
  584. if(model[5] == '0' && model[6] == '2') {
  585. mstk48t02_regs = (((u64)clk_reg[0].phys_addr) |
  586.   (((u64)clk_reg[0].which_io)<<32UL));
  587. } else if(model[5] == '0' && model[6] == '8') {
  588. mstk48t08_regs = (((u64)clk_reg[0].phys_addr) |
  589.   (((u64)clk_reg[0].which_io)<<32UL));
  590. mstk48t02_regs = mstk48t08_regs + MOSTEK_48T08_48T02;
  591. } else {
  592. mstk48t59_regs = (((u64)clk_reg[0].phys_addr) |
  593.   (((u64)clk_reg[0].which_io)<<32UL));
  594. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  595. }
  596. break;
  597. }
  599. if (mstk48t02_regs != 0UL) {
  600. /* Report a low battery voltage condition. */
  601. if (has_low_battery())
  602. prom_printf("NVRAM: Low battery voltage!n");
  604. /* Kick start the clock if it is completely stopped. */
  605. if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
  606. kick_start_clock();
  607. }
  609. set_system_time();
  611. __restore_flags(flags);
  612. }
  614. extern void init_timers(void (*func)(int, void *, struct pt_regs *),
  615. unsigned long *);
  617. void __init time_init(void)
  618. {
  619. /* clock_probe() is now done at end of [se]bus_init on sparc64
  620.  * so that sbus, fhc and ebus bus information is probed and
  621.  * available.
  622.  */
  623. unsigned long clock;
  625. init_timers(timer_interrupt, &clock);
  626. timer_ticks_per_usec_quotient = ((1UL<<32) / (clock / 1000020));
  627. }
  629. static __inline__ unsigned long do_gettimeoffset(void)
  630. {
  631. unsigned long ticks;
  633. if (!SPARC64_USE_STICK) {
  634. __asm__ __volatile__(
  635. " rd %%tick, %%g1n"
  636. " add %1, %%g1, %0n"
  637. " sub %0, %2, %0n"
  638. : "=r" (ticks)
  639. : "r" (timer_tick_offset), "r" (timer_tick_compare)
  640. : "g1", "g2");
  641. } else {
  642. __asm__ __volatile__("rd %%asr24, %%g1nt"
  643.      "add %1, %%g1, %0nt"
  644.      "sub %0, %2, %0nt"
  645.      : "=&r" (ticks)
  646.      : "r" (timer_tick_offset), "r" (timer_tick_compare)
  647.      : "g1");
  648. }
  650. return (ticks * timer_ticks_per_usec_quotient) >> 32UL;
  651. }
  653. void do_settimeofday(struct timeval *tv)
  654. {
  655. if (this_is_starfire)
  656. return;
  658. write_lock_irq(&xtime_lock);
  660. tv->tv_usec -= do_gettimeoffset();
  661. if(tv->tv_usec < 0) {
  662. tv->tv_usec += 1000000;
  663. tv->tv_sec--;
  664. }
  666. xtime = *tv;
  667. time_adjust = 0; /* stop active adjtime() */
  668. time_status |= STA_UNSYNC;
  669. time_maxerror = NTP_PHASE_LIMIT;
  670. time_esterror = NTP_PHASE_LIMIT;
  672. write_unlock_irq(&xtime_lock);
  673. }
  675. static int set_rtc_mmss(unsigned long nowtime)
  676. {
  677. int real_seconds, real_minutes, chip_minutes;
  678. unsigned long mregs = mstk48t02_regs;
  679. #ifdef CONFIG_PCI
  680. unsigned long dregs = ds1287_regs;
  681. #else
  682. unsigned long dregs = 0UL;
  683. #endif
  684. unsigned long flags;
  685. u8 tmp;
  687. /* 
  688.  * Not having a register set can lead to trouble.
  689.  * Also starfire doesn't have a tod clock.
  690.  */
  691. if (!mregs && !dregs) 
  692. return -1;
  694. if (mregs) {
  695. spin_lock_irqsave(&mostek_lock, flags);
  697. /* Read the current RTC minutes. */
  698. tmp = mostek_read(mregs + MOSTEK_CREG);
  699. tmp |= MSTK_CREG_READ;
  700. mostek_write(mregs + MOSTEK_CREG, tmp);
  702. chip_minutes = MSTK_REG_MIN(mregs);
  704. tmp = mostek_read(mregs + MOSTEK_CREG);
  705. tmp &= ~MSTK_CREG_READ;
  706. mostek_write(mregs + MOSTEK_CREG, tmp);
  708. /*
  709.  * since we're only adjusting minutes and seconds,
  710.  * don't interfere with hour overflow. This avoids
  711.  * messing with unknown time zones but requires your
  712.  * RTC not to be off by more than 15 minutes
  713.  */
  714. real_seconds = nowtime % 60;
  715. real_minutes = nowtime / 60;
  716. if (((abs(real_minutes - chip_minutes) + 15)/30) & 1)
  717. real_minutes += 30; /* correct for half hour time zone */
  718. real_minutes %= 60;
  720. if (abs(real_minutes - chip_minutes) < 30) {
  721. tmp = mostek_read(mregs + MOSTEK_CREG);
  722. tmp |= MSTK_CREG_WRITE;
  723. mostek_write(mregs + MOSTEK_CREG, tmp);
  725. MSTK_SET_REG_SEC(mregs,real_seconds);
  726. MSTK_SET_REG_MIN(mregs,real_minutes);
  728. tmp = mostek_read(mregs + MOSTEK_CREG);
  729. tmp &= ~MSTK_CREG_WRITE;
  730. mostek_write(mregs + MOSTEK_CREG, tmp);
  732. spin_unlock_irqrestore(&mostek_lock, flags);
  734. return 0;
  735. } else {
  736. spin_unlock_irqrestore(&mostek_lock, flags);
  738. return -1;
  739. }
  740. } else {
  741. int retval = 0;
  742. unsigned char save_control, save_freq_select;
  744. /* Stolen from arch/i386/kernel/time.c, see there for
  745.  * credits and descriptive comments.
  746.  */
  747. spin_lock_irqsave(&rtc_lock, flags);
  748. save_control = CMOS_READ(RTC_CONTROL); /* tell the clock it's being set */
  749. CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
  751. save_freq_select = CMOS_READ(RTC_FREQ_SELECT); /* stop and reset prescaler */
  752. CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
  754. chip_minutes = CMOS_READ(RTC_MINUTES);
  755. if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  756. BCD_TO_BIN(chip_minutes);
  757. real_seconds = nowtime % 60;
  758. real_minutes = nowtime / 60;
  759. if (((abs(real_minutes - chip_minutes) + 15)/30) & 1)
  760. real_minutes += 30;
  761. real_minutes %= 60;
  763. if (abs(real_minutes - chip_minutes) < 30) {
  764. if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
  765. BIN_TO_BCD(real_seconds);
  766. BIN_TO_BCD(real_minutes);
  767. }
  768. CMOS_WRITE(real_seconds,RTC_SECONDS);
  769. CMOS_WRITE(real_minutes,RTC_MINUTES);
  770. } else {
  771. printk(KERN_WARNING
  772.        "set_rtc_mmss: can't update from %d to %dn",
  773.        chip_minutes, real_minutes);
  774. retval = -1;
  775. }
  777. CMOS_WRITE(save_control, RTC_CONTROL);
  778. CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
  779. spin_unlock_irqrestore(&rtc_lock, flags);
  781. return retval;
  782. }
  783. }