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

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

Linux/Unix编程

开发平台：

Unix_Linux

time.c：源码内容
  1. /* $Id: time.c,v 1.30 2001/09/01 14:34:31 mrbrown Exp $
  2.  *
  3.  *  linux/arch/sh/kernel/time.c
  4.  *
  5.  *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
  6.  *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
  7.  *
  8.  *  Some code taken from i386 version.
  9.  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  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/time.h>
  21. #include <linux/delay.h>
  22. #include <linux/init.h>
  23. #include <linux/smp.h>
  25. #include <asm/processor.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/io.h>
  28. #include <asm/irq.h>
  29. #include <asm/delay.h>
  30. #include <asm/machvec.h>
  31. #include <asm/rtc.h>
  33. #include <linux/timex.h>
  34. #include <linux/irq.h>
  36. #define TMU_TOCR_INIT 0x00
  37. #define TMU0_TCR_INIT 0x0020
  38. #define TMU_TSTR_INIT 1
  40. #define TMU0_TCR_CALIB 0x0000
  42. #if defined(__sh3__)
  43. #define TMU_TOCR 0xfffffe90 /* Byte access */
  44. #define TMU_TSTR 0xfffffe92 /* Byte access */
  46. #define TMU0_TCOR 0xfffffe94 /* Long access */
  47. #define TMU0_TCNT 0xfffffe98 /* Long access */
  48. #define TMU0_TCR 0xfffffe9c /* Word access */
  50. #define FRQCR 0xffffff80
  51. #elif defined(__SH4__)
  52. #define TMU_TOCR 0xffd80000 /* Byte access */
  53. #define TMU_TSTR 0xffd80004 /* Byte access */
  55. #define TMU0_TCOR 0xffd80008 /* Long access */
  56. #define TMU0_TCNT 0xffd8000c /* Long access */
  57. #define TMU0_TCR 0xffd80010 /* Word access */
  59. #define FRQCR 0xffc00000
  61. /* Core Processor Version Register */
  62. #define CCN_PVR 0xff000030
  63. #define CCN_PVR_CHIP_SHIFT 24
  64. #define CCN_PVR_CHIP_MASK  0xff
  65. #define CCN_PVR_CHIP_ST40STB1 0x4
  67. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  68. #define CLOCKGEN_MEMCLKCR 0xbb040038
  69. #define MEMCLKCR_RATIO_MASK 0x7
  70. #endif /* CONFIG_CPU_SUBTYPE_ST40STB1 */
  71. #endif /* __sh3__ or __SH4__ */
  73. extern rwlock_t xtime_lock;
  74. extern unsigned long wall_jiffies;
  75. #define TICK_SIZE tick
  77. static unsigned long do_gettimeoffset(void)
  78. {
  79. int count;
  81. static int count_p = 0x7fffffff;    /* for the first call after boot */
  82. static unsigned long jiffies_p = 0;
  84. /*
  85.  * cache volatile jiffies temporarily; we have IRQs turned off. 
  86.  */
  87. unsigned long jiffies_t;
  89. /* timer count may underflow right here */
  90. count = ctrl_inl(TMU0_TCNT); /* read the latched count */
  92.   jiffies_t = jiffies;
  94. /*
  95.  * avoiding timer inconsistencies (they are rare, but they happen)...
  96.  * there is one kind of problem that must be avoided here:
  97.  *  1. the timer counter underflows
  98.  */
  100. if( jiffies_t == jiffies_p ) {
  101. if( count > count_p ) {
  102. /* the nutcase */
  104. if(ctrl_inw(TMU0_TCR) & 0x100) { /* Check UNF bit */
  105. /*
  106.  * We cannot detect lost timer interrupts ... 
  107.  * well, that's why we call them lost, don't we? :)
  108.  * [hmm, on the Pentium and Alpha we can ... sort of]
  109.  */
  110. count -= LATCH;
  111. } else {
  112. printk("do_slow_gettimeoffset(): hardware timer problem?n");
  113. }
  114. }
  115. } else
  116. jiffies_p = jiffies_t;
  118. count_p = count;
  120. count = ((LATCH-1) - count) * TICK_SIZE;
  121. count = (count + LATCH/2) / LATCH;
  123. return count;
  124. }
  126. void do_gettimeofday(struct timeval *tv)
  127. {
  128. unsigned long flags;
  129. unsigned long usec, sec;
  131. read_lock_irqsave(&xtime_lock, flags);
  132. usec = do_gettimeoffset();
  133. {
  134. unsigned long lost = jiffies - wall_jiffies;
  135. if (lost)
  136. usec += lost * (1000000 / HZ);
  137. }
  138. sec = xtime.tv_sec;
  139. usec += xtime.tv_usec;
  140. read_unlock_irqrestore(&xtime_lock, flags);
  142. while (usec >= 1000000) {
  143. usec -= 1000000;
  144. sec++;
  145. }
  147. tv->tv_sec = sec;
  148. tv->tv_usec = usec;
  149. }
  151. void do_settimeofday(struct timeval *tv)
  152. {
  153. write_lock_irq(&xtime_lock);
  154. /*
  155.  * This is revolting. We need to set "xtime" correctly. However, the
  156.  * value in this location is the value at the most recent update of
  157.  * wall time.  Discover what correction gettimeofday() would have
  158.  * made, and then undo it!
  159.  */
  160. tv->tv_usec -= do_gettimeoffset();
  161. tv->tv_usec -= (jiffies - wall_jiffies) * (1000000 / HZ);
  163. while (tv->tv_usec < 0) {
  164. tv->tv_usec += 1000000;
  165. tv->tv_sec--;
  166. }
  168. xtime = *tv;
  169. time_adjust = 0; /* stop active adjtime() */
  170. time_status |= STA_UNSYNC;
  171. time_maxerror = NTP_PHASE_LIMIT;
  172. time_esterror = NTP_PHASE_LIMIT;
  173. write_unlock_irq(&xtime_lock);
  174. }
  176. /* last time the RTC clock got updated */
  177. static long last_rtc_update;
  179. /*
  180.  * timer_interrupt() needs to keep up the real-time clock,
  181.  * as well as call the "do_timer()" routine every clocktick
  182.  */
  183. static inline void do_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  184. {
  185. do_timer(regs);
  187. if (!user_mode(regs))
  188. sh_do_profile(regs->pc);
  190. #ifdef CONFIG_HEARTBEAT
  191. if (sh_mv.mv_heartbeat != NULL) 
  192. sh_mv.mv_heartbeat();
  193. #endif
  195. /*
  196.  * If we have an externally synchronized Linux clock, then update
  197.  * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
  198.  * called as close as possible to 500 ms before the new second starts.
  199.  */
  200. if ((time_status & STA_UNSYNC) == 0 &&
  201.     xtime.tv_sec > last_rtc_update + 660 &&
  202.     xtime.tv_usec >= 500000 - ((unsigned) tick) / 2 &&
  203.     xtime.tv_usec <= 500000 + ((unsigned) tick) / 2) {
  204. if (sh_mv.mv_rtc_settimeofday(&xtime) == 0)
  205. last_rtc_update = xtime.tv_sec;
  206. else
  207. last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
  208. }
  209. }
  211. /*
  212.  * This is the same as the above, except we _also_ save the current
  213.  * Time Stamp Counter value at the time of the timer interrupt, so that
  214.  * we later on can estimate the time of day more exactly.
  215.  */
  216. static void timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  217. {
  218. unsigned long timer_status;
  220. /* Clear UNF bit */
  221. timer_status = ctrl_inw(TMU0_TCR);
  222. timer_status &= ~0x100;
  223. ctrl_outw(timer_status, TMU0_TCR);
  225. /*
  226.  * Here we are in the timer irq handler. We just have irqs locally
  227.  * disabled but we don't know if the timer_bh is running on the other
  228.  * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
  229.  * the irq version of write_lock because as just said we have irq
  230.  * locally disabled. -arca
  231.  */
  232. write_lock(&xtime_lock);
  233. do_timer_interrupt(irq, NULL, regs);
  234. write_unlock(&xtime_lock);
  235. }
  237. static unsigned int __init get_timer_frequency(void)
  238. {
  239. u32 freq;
  240. struct timeval tv1, tv2;
  241. unsigned long diff_usec;
  242. unsigned long factor;
  244. /* Setup the timer:  We don't want to generate interrupts, just
  245.  * have it count down at its natural rate.
  246.  */
  247. ctrl_outb(0, TMU_TSTR);
  248. ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
  249. ctrl_outw(TMU0_TCR_CALIB, TMU0_TCR);
  250. ctrl_outl(0xffffffff, TMU0_TCOR);
  251. ctrl_outl(0xffffffff, TMU0_TCNT);
  253. rtc_gettimeofday(&tv2);
  255. do {
  256. rtc_gettimeofday(&tv1);
  257. } while (tv1.tv_usec == tv2.tv_usec && tv1.tv_sec == tv2.tv_sec);
  259. /* actually start the timer */
  260. ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
  262. do {
  263. rtc_gettimeofday(&tv2);
  264. } while (tv1.tv_usec == tv2.tv_usec && tv1.tv_sec == tv2.tv_sec);
  266. freq = 0xffffffff - ctrl_inl(TMU0_TCNT);
  267. if (tv2.tv_usec < tv1.tv_usec) {
  268. tv2.tv_usec += 1000000;
  269. tv2.tv_sec--;
  270. }
  272. diff_usec = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
  274. /* this should work well if the RTC has a precision of n Hz, where
  275.  * n is an integer.  I don't think we have to worry about the other
  276.  * cases. */
  277. factor = (1000000 + diff_usec/2) / diff_usec;
  279. if (factor * diff_usec > 1100000 ||
  280.     factor * diff_usec <  900000)
  281. panic("weird RTC (diff_usec %ld)", diff_usec);
  283. return freq * factor;
  284. }
  286. static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, 0, "timer", NULL, NULL};
  288. void __init time_init(void)
  289. {
  290. unsigned int cpu_clock, master_clock, bus_clock, module_clock;
  291. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  292. unsigned int memory_clock;
  293. #endif
  294. unsigned int timer_freq;
  295. unsigned short frqcr, ifc, pfc, bfc;
  296. unsigned long interval;
  297. #if defined(__sh3__)
  298. static int ifc_table[] = { 1, 2, 4, 1, 3, 1, 1, 1 };
  299. static int pfc_table[] = { 1, 2, 4, 1, 3, 6, 1, 1 };
  300. static int stc_table[] = { 1, 2, 4, 8, 3, 6, 1, 1 };
  301. #elif defined(__SH4__)
  302. static int ifc_table[] = { 1, 2, 3, 4, 6, 8, 1, 1 };
  303. #define bfc_table ifc_table /* Same */
  304. static int pfc_table[] = { 2, 3, 4, 6, 8, 2, 2, 2 };
  306. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  307. struct frqcr_data {
  308. unsigned short frqcr;
  309. struct {
  310. unsigned char multiplier;
  311. unsigned char divisor;
  312. } factor[3];
  313. };
  315. static struct frqcr_data st40_frqcr_table[] = {
  316. { 0x000, {{1,1}, {1,1}, {1,2}}},
  317. { 0x002, {{1,1}, {1,1}, {1,4}}},
  318. { 0x004, {{1,1}, {1,1}, {1,8}}},
  319. { 0x008, {{1,1}, {1,2}, {1,2}}},
  320. { 0x00A, {{1,1}, {1,2}, {1,4}}},
  321. { 0x00C, {{1,1}, {1,2}, {1,8}}},
  322. { 0x011, {{1,1}, {2,3}, {1,6}}},
  323. { 0x013, {{1,1}, {2,3}, {1,3}}},
  324. { 0x01A, {{1,1}, {1,2}, {1,4}}},
  325. { 0x01C, {{1,1}, {1,2}, {1,8}}},
  326. { 0x023, {{1,1}, {2,3}, {1,3}}},
  327. { 0x02C, {{1,1}, {1,2}, {1,8}}},
  328. { 0x048, {{1,2}, {1,2}, {1,4}}},
  329. { 0x04A, {{1,2}, {1,2}, {1,6}}},
  330. { 0x04C, {{1,2}, {1,2}, {1,8}}},
  331. { 0x05A, {{1,2}, {1,3}, {1,6}}},
  332. { 0x05C, {{1,2}, {1,3}, {1,6}}},
  333. { 0x063, {{1,2}, {1,4}, {1,4}}},
  334. { 0x06C, {{1,2}, {1,4}, {1,8}}},
  335. { 0x091, {{1,3}, {1,3}, {1,6}}},
  336. { 0x093, {{1,3}, {1,3}, {1,6}}},
  337. { 0x0A3, {{1,3}, {1,6}, {1,6}}},
  338. { 0x0DA, {{1,4}, {1,4}, {1,8}}},
  339. { 0x0DC, {{1,4}, {1,4}, {1,8}}},
  340. { 0x0EC, {{1,4}, {1,8}, {1,8}}},
  341. { 0x123, {{1,4}, {1,4}, {1,8}}},
  342. { 0x16C, {{1,4}, {1,8}, {1,8}}},
  343. };
  345. struct memclk_data {
  346. unsigned char multiplier;
  347. unsigned char divisor;
  348. };
  349. static struct memclk_data st40_memclk_table[8] = {
  350. {1,1}, // 000
  351. {1,2}, // 001
  352. {1,3}, // 010
  353. {2,3}, // 011
  354. {1,4}, // 100
  355. {1,6}, // 101
  356. {1,8}, // 110
  357. {1,8} // 111
  358. };
  359. #endif
  360. #endif
  362. rtc_gettimeofday(&xtime);
  364. setup_irq(TIMER_IRQ, &irq0);
  366. timer_freq = get_timer_frequency();
  368. module_clock = timer_freq * 4;
  370. #if defined(__sh3__)
  371. {
  372. unsigned short tmp;
  374. frqcr = ctrl_inw(FRQCR);
  375. tmp  = (frqcr & 0x8000) >> 13;
  376. tmp |= (frqcr & 0x0030) >>  4;
  377. bfc = stc_table[tmp];
  378. tmp  = (frqcr & 0x4000) >> 12;
  379. tmp |= (frqcr & 0x000c) >> 2;
  380. ifc  = ifc_table[tmp];
  381. tmp  = (frqcr & 0x2000) >> 11;
  382. tmp |= frqcr & 0x0003;
  383. pfc = pfc_table[tmp];
  384. }
  385. #elif defined(__SH4__)
  386. {
  387. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  388. unsigned long pvr;
  390. /* This should probably be moved into the SH3 probing code, and then use the processor
  391.  * structure to determine which CPU we are running on.
  392.  */
  393. pvr = ctrl_inl(CCN_PVR);
  394. printk("PVR %08xn", pvr);
  396. if (((pvr >>CCN_PVR_CHIP_SHIFT) & CCN_PVR_CHIP_MASK) == CCN_PVR_CHIP_ST40STB1) {
  397. /* Unfortunatly the STB1 FRQCR values are different from the 7750 ones */
  398. struct frqcr_data *d;
  399. int a;
  400. unsigned long memclkcr;
  401. struct memclk_data *e;
  403. for (a=0; a<ARRAY_SIZE(st40_frqcr_table); a++) {
  404. d = &st40_frqcr_table[a];
  405. if (d->frqcr == (frqcr & 0x1ff))
  406. break;
  407. }
  408. if (a == ARRAY_SIZE(st40_frqcr_table)) {
  409. d = st40_frqcr_table;
  410. printk("ERROR: Unrecognised FRQCR value, using default multipliersn");
  411. }
  413. memclkcr = ctrl_inl(CLOCKGEN_MEMCLKCR);
  414. e = &st40_memclk_table[memclkcr & MEMCLKCR_RATIO_MASK];
  416. printk("Clock multipliers: CPU: %d/%d Bus: %d/%d Mem: %d/%d Periph: %d/%dn",
  417.        d->factor[0].multiplier, d->factor[0].divisor,
  418.        d->factor[1].multiplier, d->factor[1].divisor,
  419.        e->multiplier,           e->divisor,
  420.        d->factor[2].multiplier, d->factor[2].divisor);
  422. master_clock = module_clock * d->factor[2].divisor    / d->factor[2].multiplier;
  423. bus_clock    = master_clock * d->factor[1].multiplier / d->factor[1].divisor;
  424. memory_clock = master_clock * e->multiplier           / e->divisor;
  425. cpu_clock    = master_clock * d->factor[0].multiplier / d->factor[0].divisor;
  426. goto skip_calc;
  427. } else
  428. #endif
  429. {
  430. frqcr = ctrl_inw(FRQCR);
  432. ifc  = ifc_table[(frqcr>> 6) & 0x0007];
  433. bfc  = bfc_table[(frqcr>> 3) & 0x0007];
  434. pfc = pfc_table[frqcr & 0x0007];
  435. }
  436. }
  437. #endif
  438. master_clock = module_clock * pfc;
  439. bus_clock = master_clock / bfc;
  440. cpu_clock = master_clock / ifc;
  441. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  442.  skip_calc:
  443. #endif
  444. printk("CPU clock: %d.%02dMHzn",
  445.        (cpu_clock / 1000000), (cpu_clock % 1000000)/10000);
  446. printk("Bus clock: %d.%02dMHzn",
  447.        (bus_clock/1000000), (bus_clock % 1000000)/10000);
  448. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  449. printk("Memory clock: %d.%02dMHzn",
  450.        (memory_clock/1000000), (memory_clock % 1000000)/10000);
  451. #endif
  452. printk("Module clock: %d.%02dMHzn",
  453.        (module_clock/1000000), (module_clock % 1000000)/10000);
  454. interval = (module_clock/4 + HZ/2) / HZ;
  456. printk("Interval = %ldn", interval);
  458. current_cpu_data.cpu_clock    = cpu_clock;
  459. current_cpu_data.master_clock = master_clock;
  460. current_cpu_data.bus_clock    = bus_clock;
  461. #ifdef CONFIG_CPU_SUBTYPE_ST40STB1
  462. current_cpu_data.memory_clock = memory_clock;
  463. #endif
  464. current_cpu_data.module_clock = module_clock;
  466. /* Start TMU0 */
  467. ctrl_outb(0, TMU_TSTR);
  468. ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
  469. ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
  470. ctrl_outl(interval, TMU0_TCOR);
  471. ctrl_outl(interval, TMU0_TCNT);
  472. ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
  473. }