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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
time.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

time.c：源码内容
  1. /* $Id: time.c,v 1.41.2.1 2002/01/23 14:35:45 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=0;
  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. #ifdef CONFIG_PCI
  409. struct linux_ebus *ebus = NULL;
  410. struct isa_bridge *isa_br = NULL;
  411. #endif
  412. static int invoked = 0;
  414. if (invoked)
  415. return;
  416. invoked = 1;
  419. if (this_is_starfire) {
  420. /* davem suggests we keep this within the 4M locked kernel image */
  421. static char obp_gettod[256];
  422. static u32 unix_tod;
  424. sprintf(obp_gettod, "h# %08x unix-gettod",
  425. (unsigned int) (long) &unix_tod);
  426. prom_feval(obp_gettod);
  427. xtime.tv_sec = unix_tod;
  428. xtime.tv_usec = 0;
  429. return;
  430. }
  432. __save_and_cli(flags);
  434. if(central_bus != NULL) {
  435. busnd = central_bus->child->prom_node;
  436. }
  437. #ifdef CONFIG_PCI
  438. else if (ebus_chain != NULL) {
  439. ebus = ebus_chain;
  440. busnd = ebus->prom_node;
  441. } else if (isa_chain != NULL) {
  442. isa_br = isa_chain;
  443. busnd = isa_br->prom_node;
  444. }
  445. #endif
  446. else if (sbus_root != NULL) {
  447. busnd = sbus_root->prom_node;
  448. }
  450. if (busnd == -1) {
  451. prom_printf("clock_probe: problem, cannot find bus to search.n");
  452. prom_halt();
  453. }
  455. node = prom_getchild(busnd);
  457. while (1) {
  458. if (!node)
  459. model[0] = 0;
  460. else
  461. prom_getstring(node, "model", model, sizeof(model));
  462. if (strcmp(model, "mk48t02") &&
  463.     strcmp(model, "mk48t08") &&
  464.     strcmp(model, "mk48t59") &&
  465.     strcmp(model, "m5819") &&
  466.     strcmp(model, "ds1287")) {
  467.     if (node)
  468. node = prom_getsibling(node);
  469. #ifdef CONFIG_PCI
  470. while ((node == 0) && ebus != NULL) {
  471. ebus = ebus->next;
  472. if (ebus != NULL) {
  473. busnd = ebus->prom_node;
  474. node = prom_getchild(busnd);
  475. }
  476. }
  477. while ((node == 0) && isa_br != NULL) {
  478. isa_br = isa_br->next;
  479. if (isa_br != NULL) {
  480. busnd = isa_br->prom_node;
  481. node = prom_getchild(busnd);
  482. }
  483. }
  484. #endif
  485. if (node == 0) {
  486. prom_printf("clock_probe: Cannot find timer chipn");
  487. prom_halt();
  488. }
  489. continue;
  490. }
  492. err = prom_getproperty(node, "reg", (char *)clk_reg,
  493.        sizeof(clk_reg));
  494. if(err == -1) {
  495. prom_printf("clock_probe: Cannot get Mostek reg propertyn");
  496. prom_halt();
  497. }
  499. if(central_bus) {
  500. apply_fhc_ranges(central_bus->child, clk_reg, 1);
  501. apply_central_ranges(central_bus, clk_reg, 1);
  502. }
  503. #ifdef CONFIG_PCI
  504. else if (ebus_chain != NULL) {
  505. struct linux_ebus_device *edev;
  507. for_each_ebusdev(edev, ebus)
  508. if (edev->prom_node == node)
  509. break;
  510. if (edev == NULL) {
  511. if (isa_chain != NULL)
  512. goto try_isa_clock;
  513. prom_printf("%s: Mostek not probed by EBUSn",
  514.     __FUNCTION__);
  515. prom_halt();
  516. }
  518. if (!strcmp(model, "ds1287") ||
  519.     !strcmp(model, "m5819")) {
  520. ds1287_regs = edev->resource[0].start;
  521. } else {
  522. mstk48t59_regs = edev->resource[0].start;
  523. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  524. }
  525. break;
  526. } else if (isa_chain != NULL) {
  527. struct isa_device *isadev;
  529. try_isa_clock:
  530. for_each_isadev(isadev, isa_br)
  531. if (isadev->prom_node == node)
  532. break;
  533. if (isadev == NULL) {
  534. prom_printf("%s: Mostek not probed by ISAn");
  535. prom_halt();
  536. }
  537. if (!strcmp(model, "ds1287") ||
  538.     !strcmp(model, "m5819")) {
  539. ds1287_regs = isadev->resource.start;
  540. } else {
  541. mstk48t59_regs = isadev->resource.start;
  542. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  543. }
  544. break;
  545. }
  546. #endif
  547. else {
  548. if (sbus_root->num_sbus_ranges) {
  549. int nranges = sbus_root->num_sbus_ranges;
  550. int rngc;
  552. for (rngc = 0; rngc < nranges; rngc++)
  553. if (clk_reg[0].which_io ==
  554.     sbus_root->sbus_ranges[rngc].ot_child_space)
  555. break;
  556. if (rngc == nranges) {
  557. prom_printf("clock_probe: Cannot find ranges for "
  558.     "clock regs.n");
  559. prom_halt();
  560. }
  561. clk_reg[0].which_io =
  562. sbus_root->sbus_ranges[rngc].ot_parent_space;
  563. clk_reg[0].phys_addr +=
  564. sbus_root->sbus_ranges[rngc].ot_parent_base;
  565. }
  566. }
  568. if(model[5] == '0' && model[6] == '2') {
  569. mstk48t02_regs = (((u64)clk_reg[0].phys_addr) |
  570.   (((u64)clk_reg[0].which_io)<<32UL));
  571. } else if(model[5] == '0' && model[6] == '8') {
  572. mstk48t08_regs = (((u64)clk_reg[0].phys_addr) |
  573.   (((u64)clk_reg[0].which_io)<<32UL));
  574. mstk48t02_regs = mstk48t08_regs + MOSTEK_48T08_48T02;
  575. } else {
  576. mstk48t59_regs = (((u64)clk_reg[0].phys_addr) |
  577.   (((u64)clk_reg[0].which_io)<<32UL));
  578. mstk48t02_regs = mstk48t59_regs + MOSTEK_48T59_48T02;
  579. }
  580. break;
  581. }
  583. if (mstk48t02_regs != 0UL) {
  584. /* Report a low battery voltage condition. */
  585. if (has_low_battery())
  586. prom_printf("NVRAM: Low battery voltage!n");
  588. /* Kick start the clock if it is completely stopped. */
  589. if (mostek_read(mstk48t02_regs + MOSTEK_SEC) & MSTK_STOP)
  590. kick_start_clock();
  591. }
  593. set_system_time();
  595. __restore_flags(flags);
  596. }
  598. extern void init_timers(void (*func)(int, void *, struct pt_regs *),
  599. unsigned long *);
  601. void __init time_init(void)
  602. {
  603. /* clock_probe() is now done at end of [se]bus_init on sparc64
  604.  * so that sbus, fhc and ebus bus information is probed and
  605.  * available.
  606.  */
  607. unsigned long clock;
  609. init_timers(timer_interrupt, &clock);
  610. timer_ticks_per_usec_quotient = ((1UL<<32) / (clock / 1000020));
  611. }
  613. static __inline__ unsigned long do_gettimeoffset(void)
  614. {
  615. unsigned long ticks;
  617. if (!SPARC64_USE_STICK) {
  618. __asm__ __volatile__(
  619. " rd %%tick, %%g1n"
  620. " add %1, %%g1, %0n"
  621. " sub %0, %2, %0n"
  622. : "=r" (ticks)
  623. : "r" (timer_tick_offset), "r" (timer_tick_compare)
  624. : "g1", "g2");
  625. } else {
  626. __asm__ __volatile__("rd %%asr24, %%g1nt"
  627.      "add %1, %%g1, %0nt"
  628.      "sub %0, %2, %0nt"
  629.      : "=&r" (ticks)
  630.      : "r" (timer_tick_offset), "r" (timer_tick_compare)
  631.      : "g1");
  632. }
  634. return (ticks * timer_ticks_per_usec_quotient) >> 32UL;
  635. }
  637. void do_settimeofday(struct timeval *tv)
  638. {
  639. if (this_is_starfire)
  640. return;
  642. write_lock_irq(&xtime_lock);
  644. tv->tv_usec -= do_gettimeoffset();
  645. if(tv->tv_usec < 0) {
  646. tv->tv_usec += 1000000;
  647. tv->tv_sec--;
  648. }
  650. xtime = *tv;
  651. time_adjust = 0; /* stop active adjtime() */
  652. time_status |= STA_UNSYNC;
  653. time_maxerror = NTP_PHASE_LIMIT;
  654. time_esterror = NTP_PHASE_LIMIT;
  656. write_unlock_irq(&xtime_lock);
  657. }
  659. static int set_rtc_mmss(unsigned long nowtime)
  660. {
  661. int real_seconds, real_minutes, chip_minutes;
  662. unsigned long mregs = mstk48t02_regs;
  663. #ifdef CONFIG_PCI
  664. unsigned long dregs = ds1287_regs;
  665. #else
  666. unsigned long dregs = 0UL;
  667. #endif
  668. unsigned long flags;
  669. u8 tmp;
  671. /* 
  672.  * Not having a register set can lead to trouble.
  673.  * Also starfire doesnt have a tod clock.
  674.  */
  675. if (!mregs && !dregs) 
  676. return -1;
  678. if (mregs) {
  679. spin_lock_irqsave(&mostek_lock, flags);
  681. /* Read the current RTC minutes. */
  682. tmp = mostek_read(mregs + MOSTEK_CREG);
  683. tmp |= MSTK_CREG_READ;
  684. mostek_write(mregs + MOSTEK_CREG, tmp);
  686. chip_minutes = MSTK_REG_MIN(mregs);
  688. tmp = mostek_read(mregs + MOSTEK_CREG);
  689. tmp &= ~MSTK_CREG_READ;
  690. mostek_write(mregs + MOSTEK_CREG, tmp);
  692. /*
  693.  * since we're only adjusting minutes and seconds,
  694.  * don't interfere with hour overflow. This avoids
  695.  * messing with unknown time zones but requires your
  696.  * RTC not to be off by more than 15 minutes
  697.  */
  698. real_seconds = nowtime % 60;
  699. real_minutes = nowtime / 60;
  700. if (((abs(real_minutes - chip_minutes) + 15)/30) & 1)
  701. real_minutes += 30; /* correct for half hour time zone */
  702. real_minutes %= 60;
  704. if (abs(real_minutes - chip_minutes) < 30) {
  705. tmp = mostek_read(mregs + MOSTEK_CREG);
  706. tmp |= MSTK_CREG_WRITE;
  707. mostek_write(mregs + MOSTEK_CREG, tmp);
  709. MSTK_SET_REG_SEC(mregs,real_seconds);
  710. MSTK_SET_REG_MIN(mregs,real_minutes);
  712. tmp = mostek_read(mregs + MOSTEK_CREG);
  713. tmp &= ~MSTK_CREG_WRITE;
  714. mostek_write(mregs + MOSTEK_CREG, tmp);
  716. spin_unlock_irqrestore(&mostek_lock, flags);
  718. return 0;
  719. } else {
  720. spin_unlock_irqrestore(&mostek_lock, flags);
  722. return -1;
  723. }
  724. } else {
  725. int retval = 0;
  726. unsigned char save_control, save_freq_select;
  728. /* Stolen from arch/i386/kernel/time.c, see there for
  729.  * credits and descriptive comments.
  730.  */
  731. spin_lock_irqsave(&rtc_lock, flags);
  732. save_control = CMOS_READ(RTC_CONTROL); /* tell the clock it's being set */
  733. CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
  735. save_freq_select = CMOS_READ(RTC_FREQ_SELECT); /* stop and reset prescaler */
  736. CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
  738. chip_minutes = CMOS_READ(RTC_MINUTES);
  739. if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  740. BCD_TO_BIN(chip_minutes);
  741. real_seconds = nowtime % 60;
  742. real_minutes = nowtime / 60;
  743. if (((abs(real_minutes - chip_minutes) + 15)/30) & 1)
  744. real_minutes += 30;
  745. real_minutes %= 60;
  747. if (abs(real_minutes - chip_minutes) < 30) {
  748. if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
  749. BIN_TO_BCD(real_seconds);
  750. BIN_TO_BCD(real_minutes);
  751. }
  752. CMOS_WRITE(real_seconds,RTC_SECONDS);
  753. CMOS_WRITE(real_minutes,RTC_MINUTES);
  754. } else {
  755. printk(KERN_WARNING
  756.        "set_rtc_mmss: can't update from %d to %dn",
  757.        chip_minutes, real_minutes);
  758. retval = -1;
  759. }
  761. CMOS_WRITE(save_control, RTC_CONTROL);
  762. CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
  763. spin_unlock_irqrestore(&rtc_lock, flags);
  765. return retval;
  766. }
  767. }