PageRenderTime 45ms CodeModel.GetById 15ms app.highlight 24ms RepoModel.GetById 1ms app.codeStats 1ms

/arch/mips/kernel/time.c

https://bitbucket.org/evzijst/gittest
C | 755 lines | 407 code | 135 blank | 213 comment | 58 complexity | cd6b28dcf0457ec7b8dd704b659f9334 MD5 | raw file
  1/*
  2 * Copyright 2001 MontaVista Software Inc.
  3 * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  4 * Copyright (c) 2003, 2004  Maciej W. Rozycki
  5 *
  6 * Common time service routines for MIPS machines. See
  7 * Documentation/mips/time.README.
  8 *
  9 * This program is free software; you can redistribute  it and/or modify it
 10 * under  the terms of  the GNU General  Public License as published by the
 11 * Free Software Foundation;  either version 2 of the  License, or (at your
 12 * option) any later version.
 13 */
 14#include <linux/types.h>
 15#include <linux/kernel.h>
 16#include <linux/init.h>
 17#include <linux/sched.h>
 18#include <linux/param.h>
 19#include <linux/time.h>
 20#include <linux/timex.h>
 21#include <linux/smp.h>
 22#include <linux/kernel_stat.h>
 23#include <linux/spinlock.h>
 24#include <linux/interrupt.h>
 25#include <linux/module.h>
 26
 27#include <asm/bootinfo.h>
 28#include <asm/compiler.h>
 29#include <asm/cpu.h>
 30#include <asm/cpu-features.h>
 31#include <asm/div64.h>
 32#include <asm/sections.h>
 33#include <asm/time.h>
 34
 35/*
 36 * The integer part of the number of usecs per jiffy is taken from tick,
 37 * but the fractional part is not recorded, so we calculate it using the
 38 * initial value of HZ.  This aids systems where tick isn't really an
 39 * integer (e.g. for HZ = 128).
 40 */
 41#define USECS_PER_JIFFY		TICK_SIZE
 42#define USECS_PER_JIFFY_FRAC	((unsigned long)(u32)((1000000ULL << 32) / HZ))
 43
 44#define TICK_SIZE	(tick_nsec / 1000)
 45
 46u64 jiffies_64 = INITIAL_JIFFIES;
 47
 48EXPORT_SYMBOL(jiffies_64);
 49
 50/*
 51 * forward reference
 52 */
 53extern volatile unsigned long wall_jiffies;
 54
 55DEFINE_SPINLOCK(rtc_lock);
 56
 57/*
 58 * By default we provide the null RTC ops
 59 */
 60static unsigned long null_rtc_get_time(void)
 61{
 62	return mktime(2000, 1, 1, 0, 0, 0);
 63}
 64
 65static int null_rtc_set_time(unsigned long sec)
 66{
 67	return 0;
 68}
 69
 70unsigned long (*rtc_get_time)(void) = null_rtc_get_time;
 71int (*rtc_set_time)(unsigned long) = null_rtc_set_time;
 72int (*rtc_set_mmss)(unsigned long);
 73
 74
 75/* usecs per counter cycle, shifted to left by 32 bits */
 76static unsigned int sll32_usecs_per_cycle;
 77
 78/* how many counter cycles in a jiffy */
 79static unsigned long cycles_per_jiffy;
 80
 81/* Cycle counter value at the previous timer interrupt.. */
 82static unsigned int timerhi, timerlo;
 83
 84/* expirelo is the count value for next CPU timer interrupt */
 85static unsigned int expirelo;
 86
 87
 88/*
 89 * Null timer ack for systems not needing one (e.g. i8254).
 90 */
 91static void null_timer_ack(void) { /* nothing */ }
 92
 93/*
 94 * Null high precision timer functions for systems lacking one.
 95 */
 96static unsigned int null_hpt_read(void)
 97{
 98	return 0;
 99}
100
101static void null_hpt_init(unsigned int count) { /* nothing */ }
102
103
104/*
105 * Timer ack for an R4k-compatible timer of a known frequency.
106 */
107static void c0_timer_ack(void)
108{
109	unsigned int count;
110
111	/* Ack this timer interrupt and set the next one.  */
112	expirelo += cycles_per_jiffy;
113	write_c0_compare(expirelo);
114
115	/* Check to see if we have missed any timer interrupts.  */
116	count = read_c0_count();
117	if ((count - expirelo) < 0x7fffffff) {
118		/* missed_timer_count++; */
119		expirelo = count + cycles_per_jiffy;
120		write_c0_compare(expirelo);
121	}
122}
123
124/*
125 * High precision timer functions for a R4k-compatible timer.
126 */
127static unsigned int c0_hpt_read(void)
128{
129	return read_c0_count();
130}
131
132/* For use solely as a high precision timer.  */
133static void c0_hpt_init(unsigned int count)
134{
135	write_c0_count(read_c0_count() - count);
136}
137
138/* For use both as a high precision timer and an interrupt source.  */
139static void c0_hpt_timer_init(unsigned int count)
140{
141	count = read_c0_count() - count;
142	expirelo = (count / cycles_per_jiffy + 1) * cycles_per_jiffy;
143	write_c0_count(expirelo - cycles_per_jiffy);
144	write_c0_compare(expirelo);
145	write_c0_count(count);
146}
147
148int (*mips_timer_state)(void);
149void (*mips_timer_ack)(void);
150unsigned int (*mips_hpt_read)(void);
151void (*mips_hpt_init)(unsigned int);
152
153
154/*
155 * This version of gettimeofday has microsecond resolution and better than
156 * microsecond precision on fast machines with cycle counter.
157 */
158void do_gettimeofday(struct timeval *tv)
159{
160	unsigned long seq;
161	unsigned long lost;
162	unsigned long usec, sec;
163	unsigned long max_ntp_tick = tick_usec - tickadj;
164
165	do {
166		seq = read_seqbegin(&xtime_lock);
167
168		usec = do_gettimeoffset();
169
170		lost = jiffies - wall_jiffies;
171
172		/*
173		 * If time_adjust is negative then NTP is slowing the clock
174		 * so make sure not to go into next possible interval.
175		 * Better to lose some accuracy than have time go backwards..
176		 */
177		if (unlikely(time_adjust < 0)) {
178			usec = min(usec, max_ntp_tick);
179
180			if (lost)
181				usec += lost * max_ntp_tick;
182		} else if (unlikely(lost))
183			usec += lost * tick_usec;
184
185		sec = xtime.tv_sec;
186		usec += (xtime.tv_nsec / 1000);
187
188	} while (read_seqretry(&xtime_lock, seq));
189
190	while (usec >= 1000000) {
191		usec -= 1000000;
192		sec++;
193	}
194
195	tv->tv_sec = sec;
196	tv->tv_usec = usec;
197}
198
199EXPORT_SYMBOL(do_gettimeofday);
200
201int do_settimeofday(struct timespec *tv)
202{
203	time_t wtm_sec, sec = tv->tv_sec;
204	long wtm_nsec, nsec = tv->tv_nsec;
205
206	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
207		return -EINVAL;
208
209	write_seqlock_irq(&xtime_lock);
210
211	/*
212	 * This is revolting.  We need to set "xtime" correctly.  However,
213	 * the value in this location is the value at the most recent update
214	 * of wall time.  Discover what correction gettimeofday() would have
215	 * made, and then undo it!
216	 */
217	nsec -= do_gettimeoffset() * NSEC_PER_USEC;
218	nsec -= (jiffies - wall_jiffies) * tick_nsec;
219
220	wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
221	wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
222
223	set_normalized_timespec(&xtime, sec, nsec);
224	set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
225
226	time_adjust = 0;			/* stop active adjtime() */
227	time_status |= STA_UNSYNC;
228	time_maxerror = NTP_PHASE_LIMIT;
229	time_esterror = NTP_PHASE_LIMIT;
230
231	write_sequnlock_irq(&xtime_lock);
232	clock_was_set();
233	return 0;
234}
235
236EXPORT_SYMBOL(do_settimeofday);
237
238/*
239 * Gettimeoffset routines.  These routines returns the time duration
240 * since last timer interrupt in usecs.
241 *
242 * If the exact CPU counter frequency is known, use fixed_rate_gettimeoffset.
243 * Otherwise use calibrate_gettimeoffset()
244 *
245 * If the CPU does not have the counter register, you can either supply
246 * your own gettimeoffset() routine, or use null_gettimeoffset(), which
247 * gives the same resolution as HZ.
248 */
249
250static unsigned long null_gettimeoffset(void)
251{
252	return 0;
253}
254
255
256/* The function pointer to one of the gettimeoffset funcs.  */
257unsigned long (*do_gettimeoffset)(void) = null_gettimeoffset;
258
259
260static unsigned long fixed_rate_gettimeoffset(void)
261{
262	u32 count;
263	unsigned long res;
264
265	/* Get last timer tick in absolute kernel time */
266	count = mips_hpt_read();
267
268	/* .. relative to previous jiffy (32 bits is enough) */
269	count -= timerlo;
270
271	__asm__("multu	%1,%2"
272		: "=h" (res)
273		: "r" (count), "r" (sll32_usecs_per_cycle)
274		: "lo", GCC_REG_ACCUM);
275
276	/*
277	 * Due to possible jiffies inconsistencies, we need to check
278	 * the result so that we'll get a timer that is monotonic.
279	 */
280	if (res >= USECS_PER_JIFFY)
281		res = USECS_PER_JIFFY - 1;
282
283	return res;
284}
285
286
287/*
288 * Cached "1/(clocks per usec) * 2^32" value.
289 * It has to be recalculated once each jiffy.
290 */
291static unsigned long cached_quotient;
292
293/* Last jiffy when calibrate_divXX_gettimeoffset() was called. */
294static unsigned long last_jiffies;
295
296/*
297 * This is moved from dec/time.c:do_ioasic_gettimeoffset() by Maciej.
298 */
299static unsigned long calibrate_div32_gettimeoffset(void)
300{
301	u32 count;
302	unsigned long res, tmp;
303	unsigned long quotient;
304
305	tmp = jiffies;
306
307	quotient = cached_quotient;
308
309	if (last_jiffies != tmp) {
310		last_jiffies = tmp;
311		if (last_jiffies != 0) {
312			unsigned long r0;
313			do_div64_32(r0, timerhi, timerlo, tmp);
314			do_div64_32(quotient, USECS_PER_JIFFY,
315				    USECS_PER_JIFFY_FRAC, r0);
316			cached_quotient = quotient;
317		}
318	}
319
320	/* Get last timer tick in absolute kernel time */
321	count = mips_hpt_read();
322
323	/* .. relative to previous jiffy (32 bits is enough) */
324	count -= timerlo;
325
326	__asm__("multu  %1,%2"
327		: "=h" (res)
328		: "r" (count), "r" (quotient)
329		: "lo", GCC_REG_ACCUM);
330
331	/*
332	 * Due to possible jiffies inconsistencies, we need to check
333	 * the result so that we'll get a timer that is monotonic.
334	 */
335	if (res >= USECS_PER_JIFFY)
336		res = USECS_PER_JIFFY - 1;
337
338	return res;
339}
340
341static unsigned long calibrate_div64_gettimeoffset(void)
342{
343	u32 count;
344	unsigned long res, tmp;
345	unsigned long quotient;
346
347	tmp = jiffies;
348
349	quotient = cached_quotient;
350
351	if (last_jiffies != tmp) {
352		last_jiffies = tmp;
353		if (last_jiffies) {
354			unsigned long r0;
355			__asm__(".set	push\n\t"
356				".set	mips3\n\t"
357				"lwu	%0,%3\n\t"
358				"dsll32	%1,%2,0\n\t"
359				"or	%1,%1,%0\n\t"
360				"ddivu	$0,%1,%4\n\t"
361				"mflo	%1\n\t"
362				"dsll32	%0,%5,0\n\t"
363				"or	%0,%0,%6\n\t"
364				"ddivu	$0,%0,%1\n\t"
365				"mflo	%0\n\t"
366				".set	pop"
367				: "=&r" (quotient), "=&r" (r0)
368				: "r" (timerhi), "m" (timerlo),
369				  "r" (tmp), "r" (USECS_PER_JIFFY),
370				  "r" (USECS_PER_JIFFY_FRAC)
371				: "hi", "lo", GCC_REG_ACCUM);
372			cached_quotient = quotient;
373		}
374	}
375
376	/* Get last timer tick in absolute kernel time */
377	count = mips_hpt_read();
378
379	/* .. relative to previous jiffy (32 bits is enough) */
380	count -= timerlo;
381
382	__asm__("multu	%1,%2"
383		: "=h" (res)
384		: "r" (count), "r" (quotient)
385		: "lo", GCC_REG_ACCUM);
386
387	/*
388	 * Due to possible jiffies inconsistencies, we need to check
389	 * the result so that we'll get a timer that is monotonic.
390	 */
391	if (res >= USECS_PER_JIFFY)
392		res = USECS_PER_JIFFY - 1;
393
394	return res;
395}
396
397
398/* last time when xtime and rtc are sync'ed up */
399static long last_rtc_update;
400
401/*
402 * local_timer_interrupt() does profiling and process accounting
403 * on a per-CPU basis.
404 *
405 * In UP mode, it is invoked from the (global) timer_interrupt.
406 *
407 * In SMP mode, it might invoked by per-CPU timer interrupt, or
408 * a broadcasted inter-processor interrupt which itself is triggered
409 * by the global timer interrupt.
410 */
411void local_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
412{
413	if (current->pid)
414		profile_tick(CPU_PROFILING, regs);
415	update_process_times(user_mode(regs));
416}
417
418/*
419 * High-level timer interrupt service routines.  This function
420 * is set as irqaction->handler and is invoked through do_IRQ.
421 */
422irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
423{
424	unsigned long j;
425	unsigned int count;
426
427	count = mips_hpt_read();
428	mips_timer_ack();
429
430	/* Update timerhi/timerlo for intra-jiffy calibration. */
431	timerhi += count < timerlo;			/* Wrap around */
432	timerlo = count;
433
434	/*
435	 * call the generic timer interrupt handling
436	 */
437	do_timer(regs);
438
439	/*
440	 * If we have an externally synchronized Linux clock, then update
441	 * CMOS clock accordingly every ~11 minutes. rtc_set_time() has to be
442	 * called as close as possible to 500 ms before the new second starts.
443	 */
444	write_seqlock(&xtime_lock);
445	if ((time_status & STA_UNSYNC) == 0 &&
446	    xtime.tv_sec > last_rtc_update + 660 &&
447	    (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
448	    (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
449		if (rtc_set_mmss(xtime.tv_sec) == 0) {
450			last_rtc_update = xtime.tv_sec;
451		} else {
452			/* do it again in 60 s */
453			last_rtc_update = xtime.tv_sec - 600;
454		}
455	}
456	write_sequnlock(&xtime_lock);
457
458	/*
459	 * If jiffies has overflown in this timer_interrupt, we must
460	 * update the timer[hi]/[lo] to make fast gettimeoffset funcs
461	 * quotient calc still valid. -arca
462	 *
463	 * The first timer interrupt comes late as interrupts are
464	 * enabled long after timers are initialized.  Therefore the
465	 * high precision timer is fast, leading to wrong gettimeoffset()
466	 * calculations.  We deal with it by setting it based on the
467	 * number of its ticks between the second and the third interrupt.
468	 * That is still somewhat imprecise, but it's a good estimate.
469	 * --macro
470	 */
471	j = jiffies;
472	if (j < 4) {
473		static unsigned int prev_count;
474		static int hpt_initialized;
475
476		switch (j) {
477		case 0:
478			timerhi = timerlo = 0;
479			mips_hpt_init(count);
480			break;
481		case 2:
482			prev_count = count;
483			break;
484		case 3:
485			if (!hpt_initialized) {
486				unsigned int c3 = 3 * (count - prev_count);
487
488				timerhi = 0;
489				timerlo = c3;
490				mips_hpt_init(count - c3);
491				hpt_initialized = 1;
492			}
493			break;
494		default:
495			break;
496		}
497	}
498
499	/*
500	 * In UP mode, we call local_timer_interrupt() to do profiling
501	 * and process accouting.
502	 *
503	 * In SMP mode, local_timer_interrupt() is invoked by appropriate
504	 * low-level local timer interrupt handler.
505	 */
506	local_timer_interrupt(irq, dev_id, regs);
507
508	return IRQ_HANDLED;
509}
510
511asmlinkage void ll_timer_interrupt(int irq, struct pt_regs *regs)
512{
513	irq_enter();
514	kstat_this_cpu.irqs[irq]++;
515
516	/* we keep interrupt disabled all the time */
517	timer_interrupt(irq, NULL, regs);
518
519	irq_exit();
520}
521
522asmlinkage void ll_local_timer_interrupt(int irq, struct pt_regs *regs)
523{
524	irq_enter();
525	if (smp_processor_id() != 0)
526		kstat_this_cpu.irqs[irq]++;
527
528	/* we keep interrupt disabled all the time */
529	local_timer_interrupt(irq, NULL, regs);
530
531	irq_exit();
532}
533
534/*
535 * time_init() - it does the following things.
536 *
537 * 1) board_time_init() -
538 * 	a) (optional) set up RTC routines,
539 *      b) (optional) calibrate and set the mips_hpt_frequency
540 *	    (only needed if you intended to use fixed_rate_gettimeoffset
541 *	     or use cpu counter as timer interrupt source)
542 * 2) setup xtime based on rtc_get_time().
543 * 3) choose a appropriate gettimeoffset routine.
544 * 4) calculate a couple of cached variables for later usage
545 * 5) board_timer_setup() -
546 *	a) (optional) over-write any choices made above by time_init().
547 *	b) machine specific code should setup the timer irqaction.
548 *	c) enable the timer interrupt
549 */
550
551void (*board_time_init)(void);
552void (*board_timer_setup)(struct irqaction *irq);
553
554unsigned int mips_hpt_frequency;
555
556static struct irqaction timer_irqaction = {
557	.handler = timer_interrupt,
558	.flags = SA_INTERRUPT,
559	.name = "timer",
560};
561
562static unsigned int __init calibrate_hpt(void)
563{
564	u64 frequency;
565	u32 hpt_start, hpt_end, hpt_count, hz;
566
567	const int loops = HZ / 10;
568	int log_2_loops = 0;
569	int i;
570
571	/*
572	 * We want to calibrate for 0.1s, but to avoid a 64-bit
573	 * division we round the number of loops up to the nearest
574	 * power of 2.
575	 */
576	while (loops > 1 << log_2_loops)
577		log_2_loops++;
578	i = 1 << log_2_loops;
579
580	/*
581	 * Wait for a rising edge of the timer interrupt.
582	 */
583	while (mips_timer_state());
584	while (!mips_timer_state());
585
586	/*
587	 * Now see how many high precision timer ticks happen
588	 * during the calculated number of periods between timer
589	 * interrupts.
590	 */
591	hpt_start = mips_hpt_read();
592	do {
593		while (mips_timer_state());
594		while (!mips_timer_state());
595	} while (--i);
596	hpt_end = mips_hpt_read();
597
598	hpt_count = hpt_end - hpt_start;
599	hz = HZ;
600	frequency = (u64)hpt_count * (u64)hz;
601
602	return frequency >> log_2_loops;
603}
604
605void __init time_init(void)
606{
607	if (board_time_init)
608		board_time_init();
609
610	if (!rtc_set_mmss)
611		rtc_set_mmss = rtc_set_time;
612
613	xtime.tv_sec = rtc_get_time();
614	xtime.tv_nsec = 0;
615
616	set_normalized_timespec(&wall_to_monotonic,
617	                        -xtime.tv_sec, -xtime.tv_nsec);
618
619	/* Choose appropriate high precision timer routines.  */
620	if (!cpu_has_counter && !mips_hpt_read) {
621		/* No high precision timer -- sorry.  */
622		mips_hpt_read = null_hpt_read;
623		mips_hpt_init = null_hpt_init;
624	} else if (!mips_hpt_frequency && !mips_timer_state) {
625		/* A high precision timer of unknown frequency.  */
626		if (!mips_hpt_read) {
627			/* No external high precision timer -- use R4k.  */
628			mips_hpt_read = c0_hpt_read;
629			mips_hpt_init = c0_hpt_init;
630		}
631
632		if ((current_cpu_data.isa_level == MIPS_CPU_ISA_M32) ||
633			 (current_cpu_data.isa_level == MIPS_CPU_ISA_I) ||
634			 (current_cpu_data.isa_level == MIPS_CPU_ISA_II))
635			/*
636			 * We need to calibrate the counter but we don't have
637			 * 64-bit division.
638			 */
639			do_gettimeoffset = calibrate_div32_gettimeoffset;
640		else
641			/*
642			 * We need to calibrate the counter but we *do* have
643			 * 64-bit division.
644			 */
645			do_gettimeoffset = calibrate_div64_gettimeoffset;
646	} else {
647		/* We know counter frequency.  Or we can get it.  */
648		if (!mips_hpt_read) {
649			/* No external high precision timer -- use R4k.  */
650			mips_hpt_read = c0_hpt_read;
651
652			if (mips_timer_state)
653				mips_hpt_init = c0_hpt_init;
654			else {
655				/* No external timer interrupt -- use R4k.  */
656				mips_hpt_init = c0_hpt_timer_init;
657				mips_timer_ack = c0_timer_ack;
658			}
659		}
660		if (!mips_hpt_frequency)
661			mips_hpt_frequency = calibrate_hpt();
662
663		do_gettimeoffset = fixed_rate_gettimeoffset;
664
665		/* Calculate cache parameters.  */
666		cycles_per_jiffy = (mips_hpt_frequency + HZ / 2) / HZ;
667
668		/* sll32_usecs_per_cycle = 10^6 * 2^32 / mips_counter_freq  */
669		do_div64_32(sll32_usecs_per_cycle,
670			    1000000, mips_hpt_frequency / 2,
671			    mips_hpt_frequency);
672
673		/* Report the high precision timer rate for a reference.  */
674		printk("Using %u.%03u MHz high precision timer.\n",
675		       ((mips_hpt_frequency + 500) / 1000) / 1000,
676		       ((mips_hpt_frequency + 500) / 1000) % 1000);
677	}
678
679	if (!mips_timer_ack)
680		/* No timer interrupt ack (e.g. i8254).  */
681		mips_timer_ack = null_timer_ack;
682
683	/* This sets up the high precision timer for the first interrupt.  */
684	mips_hpt_init(mips_hpt_read());
685
686	/*
687	 * Call board specific timer interrupt setup.
688	 *
689	 * this pointer must be setup in machine setup routine.
690	 *
691	 * Even if a machine chooses to use a low-level timer interrupt,
692	 * it still needs to setup the timer_irqaction.
693	 * In that case, it might be better to set timer_irqaction.handler
694	 * to be NULL function so that we are sure the high-level code
695	 * is not invoked accidentally.
696	 */
697	board_timer_setup(&timer_irqaction);
698}
699
700#define FEBRUARY		2
701#define STARTOFTIME		1970
702#define SECDAY			86400L
703#define SECYR			(SECDAY * 365)
704#define leapyear(y)		((!((y) % 4) && ((y) % 100)) || !((y) % 400))
705#define days_in_year(y)		(leapyear(y) ? 366 : 365)
706#define days_in_month(m)	(month_days[(m) - 1])
707
708static int month_days[12] = {
709	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
710};
711
712void to_tm(unsigned long tim, struct rtc_time *tm)
713{
714	long hms, day, gday;
715	int i;
716
717	gday = day = tim / SECDAY;
718	hms = tim % SECDAY;
719
720	/* Hours, minutes, seconds are easy */
721	tm->tm_hour = hms / 3600;
722	tm->tm_min = (hms % 3600) / 60;
723	tm->tm_sec = (hms % 3600) % 60;
724
725	/* Number of years in days */
726	for (i = STARTOFTIME; day >= days_in_year(i); i++)
727		day -= days_in_year(i);
728	tm->tm_year = i;
729
730	/* Number of months in days left */
731	if (leapyear(tm->tm_year))
732		days_in_month(FEBRUARY) = 29;
733	for (i = 1; day >= days_in_month(i); i++)
734		day -= days_in_month(i);
735	days_in_month(FEBRUARY) = 28;
736	tm->tm_mon = i - 1;		/* tm_mon starts from 0 to 11 */
737
738	/* Days are what is left over (+1) from all that. */
739	tm->tm_mday = day + 1;
740
741	/*
742	 * Determine the day of week
743	 */
744	tm->tm_wday = (gday + 4) % 7;	/* 1970/1/1 was Thursday */
745}
746
747EXPORT_SYMBOL(rtc_lock);
748EXPORT_SYMBOL(to_tm);
749EXPORT_SYMBOL(rtc_set_time);
750EXPORT_SYMBOL(rtc_get_time);
751
752unsigned long long sched_clock(void)
753{
754	return (unsigned long long)jiffies*(1000000000/HZ);
755}