Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[linux-2.6] / arch / x86_64 / kernel / time.c
1 /*
2  *  linux/arch/x86-64/kernel/time.c
3  *
4  *  "High Precision Event Timer" based timekeeping.
5  *
6  *  Copyright (c) 1991,1992,1995  Linus Torvalds
7  *  Copyright (c) 1994  Alan Modra
8  *  Copyright (c) 1995  Markus Kuhn
9  *  Copyright (c) 1996  Ingo Molnar
10  *  Copyright (c) 1998  Andrea Arcangeli
11  *  Copyright (c) 2002,2006  Vojtech Pavlik
12  *  Copyright (c) 2003  Andi Kleen
13  *  RTC support code taken from arch/i386/kernel/timers/time_hpet.c
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/interrupt.h>
19 #include <linux/init.h>
20 #include <linux/mc146818rtc.h>
21 #include <linux/time.h>
22 #include <linux/ioport.h>
23 #include <linux/module.h>
24 #include <linux/device.h>
25 #include <linux/sysdev.h>
26 #include <linux/bcd.h>
27 #include <linux/kallsyms.h>
28 #include <linux/acpi.h>
29 #ifdef CONFIG_ACPI
30 #include <acpi/achware.h>       /* for PM timer frequency */
31 #include <acpi/acpi_bus.h>
32 #endif
33 #include <asm/8253pit.h>
34 #include <asm/pgtable.h>
35 #include <asm/vsyscall.h>
36 #include <asm/timex.h>
37 #include <asm/proto.h>
38 #include <asm/hpet.h>
39 #include <asm/sections.h>
40 #include <linux/cpufreq.h>
41 #include <linux/hpet.h>
42 #ifdef CONFIG_X86_LOCAL_APIC
43 #include <asm/apic.h>
44 #endif
45
46 #ifdef CONFIG_CPU_FREQ
47 static void cpufreq_delayed_get(void);
48 #endif
49 extern void i8254_timer_resume(void);
50 extern int using_apic_timer;
51
52 static char *time_init_gtod(void);
53
54 DEFINE_SPINLOCK(rtc_lock);
55 EXPORT_SYMBOL(rtc_lock);
56 DEFINE_SPINLOCK(i8253_lock);
57
58 int nohpet __initdata = 0;
59 static int notsc __initdata = 0;
60
61 #define USEC_PER_TICK (USEC_PER_SEC / HZ)
62 #define NSEC_PER_TICK (NSEC_PER_SEC / HZ)
63 #define FSEC_PER_TICK (FSEC_PER_SEC / HZ)
64
65 #define NS_SCALE        10 /* 2^10, carefully chosen */
66 #define US_SCALE        32 /* 2^32, arbitralrily chosen */
67
68 unsigned int cpu_khz;                                   /* TSC clocks / usec, not used here */
69 EXPORT_SYMBOL(cpu_khz);
70 static unsigned long hpet_period;                       /* fsecs / HPET clock */
71 unsigned long hpet_tick;                                /* HPET clocks / interrupt */
72 int hpet_use_timer;                             /* Use counter of hpet for time keeping, otherwise PIT */
73 unsigned long vxtime_hz = PIT_TICK_RATE;
74 int report_lost_ticks;                          /* command line option */
75 unsigned long long monotonic_base;
76
77 struct vxtime_data __vxtime __section_vxtime;   /* for vsyscalls */
78
79 volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES;
80 unsigned long __wall_jiffies __section_wall_jiffies = INITIAL_JIFFIES;
81 struct timespec __xtime __section_xtime;
82 struct timezone __sys_tz __section_sys_tz;
83
84 /*
85  * do_gettimeoffset() returns microseconds since last timer interrupt was
86  * triggered by hardware. A memory read of HPET is slower than a register read
87  * of TSC, but much more reliable. It's also synchronized to the timer
88  * interrupt. Note that do_gettimeoffset() may return more than hpet_tick, if a
89  * timer interrupt has happened already, but vxtime.trigger wasn't updated yet.
90  * This is not a problem, because jiffies hasn't updated either. They are bound
91  * together by xtime_lock.
92  */
93
94 static inline unsigned int do_gettimeoffset_tsc(void)
95 {
96         unsigned long t;
97         unsigned long x;
98         t = get_cycles_sync();
99         if (t < vxtime.last_tsc) 
100                 t = vxtime.last_tsc; /* hack */
101         x = ((t - vxtime.last_tsc) * vxtime.tsc_quot) >> US_SCALE;
102         return x;
103 }
104
105 static inline unsigned int do_gettimeoffset_hpet(void)
106 {
107         /* cap counter read to one tick to avoid inconsistencies */
108         unsigned long counter = hpet_readl(HPET_COUNTER) - vxtime.last;
109         return (min(counter,hpet_tick) * vxtime.quot) >> US_SCALE;
110 }
111
112 unsigned int (*do_gettimeoffset)(void) = do_gettimeoffset_tsc;
113
114 /*
115  * This version of gettimeofday() has microsecond resolution and better than
116  * microsecond precision, as we're using at least a 10 MHz (usually 14.31818
117  * MHz) HPET timer.
118  */
119
120 void do_gettimeofday(struct timeval *tv)
121 {
122         unsigned long seq, t;
123         unsigned int sec, usec;
124
125         do {
126                 seq = read_seqbegin(&xtime_lock);
127
128                 sec = xtime.tv_sec;
129                 usec = xtime.tv_nsec / NSEC_PER_USEC;
130
131                 /* i386 does some correction here to keep the clock 
132                    monotonous even when ntpd is fixing drift.
133                    But they didn't work for me, there is a non monotonic
134                    clock anyways with ntp.
135                    I dropped all corrections now until a real solution can
136                    be found. Note when you fix it here you need to do the same
137                    in arch/x86_64/kernel/vsyscall.c and export all needed
138                    variables in vmlinux.lds. -AK */ 
139
140                 t = (jiffies - wall_jiffies) * USEC_PER_TICK +
141                         do_gettimeoffset();
142                 usec += t;
143
144         } while (read_seqretry(&xtime_lock, seq));
145
146         tv->tv_sec = sec + usec / USEC_PER_SEC;
147         tv->tv_usec = usec % USEC_PER_SEC;
148 }
149
150 EXPORT_SYMBOL(do_gettimeofday);
151
152 /*
153  * settimeofday() first undoes the correction that gettimeofday would do
154  * on the time, and then saves it. This is ugly, but has been like this for
155  * ages already.
156  */
157
158 int do_settimeofday(struct timespec *tv)
159 {
160         time_t wtm_sec, sec = tv->tv_sec;
161         long wtm_nsec, nsec = tv->tv_nsec;
162
163         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
164                 return -EINVAL;
165
166         write_seqlock_irq(&xtime_lock);
167
168         nsec -= do_gettimeoffset() * NSEC_PER_USEC +
169                 (jiffies - wall_jiffies) * NSEC_PER_TICK;
170
171         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
172         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
173
174         set_normalized_timespec(&xtime, sec, nsec);
175         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
176
177         ntp_clear();
178
179         write_sequnlock_irq(&xtime_lock);
180         clock_was_set();
181         return 0;
182 }
183
184 EXPORT_SYMBOL(do_settimeofday);
185
186 unsigned long profile_pc(struct pt_regs *regs)
187 {
188         unsigned long pc = instruction_pointer(regs);
189
190         /* Assume the lock function has either no stack frame or only a single 
191            word.  This checks if the address on the stack looks like a kernel 
192            text address.
193            There is a small window for false hits, but in that case the tick
194            is just accounted to the spinlock function.
195            Better would be to write these functions in assembler again
196            and check exactly. */
197         if (!user_mode(regs) && in_lock_functions(pc)) {
198                 char *v = *(char **)regs->rsp;
199                 if ((v >= _stext && v <= _etext) ||
200                         (v >= _sinittext && v <= _einittext) ||
201                         (v >= (char *)MODULES_VADDR  && v <= (char *)MODULES_END))
202                         return (unsigned long)v;
203                 return ((unsigned long *)regs->rsp)[1];
204         }
205         return pc;
206 }
207 EXPORT_SYMBOL(profile_pc);
208
209 /*
210  * In order to set the CMOS clock precisely, set_rtc_mmss has to be called 500
211  * ms after the second nowtime has started, because when nowtime is written
212  * into the registers of the CMOS clock, it will jump to the next second
213  * precisely 500 ms later. Check the Motorola MC146818A or Dallas DS12887 data
214  * sheet for details.
215  */
216
217 static void set_rtc_mmss(unsigned long nowtime)
218 {
219         int real_seconds, real_minutes, cmos_minutes;
220         unsigned char control, freq_select;
221
222 /*
223  * IRQs are disabled when we're called from the timer interrupt,
224  * no need for spin_lock_irqsave()
225  */
226
227         spin_lock(&rtc_lock);
228
229 /*
230  * Tell the clock it's being set and stop it.
231  */
232
233         control = CMOS_READ(RTC_CONTROL);
234         CMOS_WRITE(control | RTC_SET, RTC_CONTROL);
235
236         freq_select = CMOS_READ(RTC_FREQ_SELECT);
237         CMOS_WRITE(freq_select | RTC_DIV_RESET2, RTC_FREQ_SELECT);
238
239         cmos_minutes = CMOS_READ(RTC_MINUTES);
240                 BCD_TO_BIN(cmos_minutes);
241
242 /*
243  * since we're only adjusting minutes and seconds, don't interfere with hour
244  * overflow. This avoids messing with unknown time zones but requires your RTC
245  * not to be off by more than 15 minutes. Since we're calling it only when
246  * our clock is externally synchronized using NTP, this shouldn't be a problem.
247  */
248
249         real_seconds = nowtime % 60;
250         real_minutes = nowtime / 60;
251         if (((abs(real_minutes - cmos_minutes) + 15) / 30) & 1)
252                 real_minutes += 30;             /* correct for half hour time zone */
253         real_minutes %= 60;
254
255         if (abs(real_minutes - cmos_minutes) >= 30) {
256                 printk(KERN_WARNING "time.c: can't update CMOS clock "
257                        "from %d to %d\n", cmos_minutes, real_minutes);
258         } else {
259                 BIN_TO_BCD(real_seconds);
260                 BIN_TO_BCD(real_minutes);
261                 CMOS_WRITE(real_seconds, RTC_SECONDS);
262                 CMOS_WRITE(real_minutes, RTC_MINUTES);
263         }
264
265 /*
266  * The following flags have to be released exactly in this order, otherwise the
267  * DS12887 (popular MC146818A clone with integrated battery and quartz) will
268  * not reset the oscillator and will not update precisely 500 ms later. You
269  * won't find this mentioned in the Dallas Semiconductor data sheets, but who
270  * believes data sheets anyway ... -- Markus Kuhn
271  */
272
273         CMOS_WRITE(control, RTC_CONTROL);
274         CMOS_WRITE(freq_select, RTC_FREQ_SELECT);
275
276         spin_unlock(&rtc_lock);
277 }
278
279
280 /* monotonic_clock(): returns # of nanoseconds passed since time_init()
281  *              Note: This function is required to return accurate
282  *              time even in the absence of multiple timer ticks.
283  */
284 unsigned long long monotonic_clock(void)
285 {
286         unsigned long seq;
287         u32 last_offset, this_offset, offset;
288         unsigned long long base;
289
290         if (vxtime.mode == VXTIME_HPET) {
291                 do {
292                         seq = read_seqbegin(&xtime_lock);
293
294                         last_offset = vxtime.last;
295                         base = monotonic_base;
296                         this_offset = hpet_readl(HPET_COUNTER);
297                 } while (read_seqretry(&xtime_lock, seq));
298                 offset = (this_offset - last_offset);
299                 offset *= NSEC_PER_TICK / hpet_tick;
300         } else {
301                 do {
302                         seq = read_seqbegin(&xtime_lock);
303
304                         last_offset = vxtime.last_tsc;
305                         base = monotonic_base;
306                 } while (read_seqretry(&xtime_lock, seq));
307                 this_offset = get_cycles_sync();
308                 /* FIXME: 1000 or 1000000? */
309                 offset = (this_offset - last_offset)*1000 / cpu_khz;
310         }
311         return base + offset;
312 }
313 EXPORT_SYMBOL(monotonic_clock);
314
315 static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
316 {
317         static long lost_count;
318         static int warned;
319         if (report_lost_ticks) {
320                 printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost);
321                 print_symbol("rip %s)\n", regs->rip);
322         }
323
324         if (lost_count == 1000 && !warned) {
325                 printk(KERN_WARNING "warning: many lost ticks.\n"
326                        KERN_WARNING "Your time source seems to be instable or "
327                                 "some driver is hogging interupts\n");
328                 print_symbol("rip %s\n", regs->rip);
329                 if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) {
330                         printk(KERN_WARNING "Falling back to HPET\n");
331                         if (hpet_use_timer)
332                                 vxtime.last = hpet_readl(HPET_T0_CMP) - 
333                                                         hpet_tick;
334                         else
335                                 vxtime.last = hpet_readl(HPET_COUNTER);
336                         vxtime.mode = VXTIME_HPET;
337                         do_gettimeoffset = do_gettimeoffset_hpet;
338                 }
339                 /* else should fall back to PIT, but code missing. */
340                 warned = 1;
341         } else
342                 lost_count++;
343
344 #ifdef CONFIG_CPU_FREQ
345         /* In some cases the CPU can change frequency without us noticing
346            Give cpufreq a change to catch up. */
347         if ((lost_count+1) % 25 == 0)
348                 cpufreq_delayed_get();
349 #endif
350 }
351
352 void main_timer_handler(struct pt_regs *regs)
353 {
354         static unsigned long rtc_update = 0;
355         unsigned long tsc;
356         int delay = 0, offset = 0, lost = 0;
357
358 /*
359  * Here we are in the timer irq handler. We have irqs locally disabled (so we
360  * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
361  * on the other CPU, so we need a lock. We also need to lock the vsyscall
362  * variables, because both do_timer() and us change them -arca+vojtech
363  */
364
365         write_seqlock(&xtime_lock);
366
367         if (vxtime.hpet_address)
368                 offset = hpet_readl(HPET_COUNTER);
369
370         if (hpet_use_timer) {
371                 /* if we're using the hpet timer functionality,
372                  * we can more accurately know the counter value
373                  * when the timer interrupt occured.
374                  */
375                 offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
376                 delay = hpet_readl(HPET_COUNTER) - offset;
377         } else if (!pmtmr_ioport) {
378                 spin_lock(&i8253_lock);
379                 outb_p(0x00, 0x43);
380                 delay = inb_p(0x40);
381                 delay |= inb(0x40) << 8;
382                 spin_unlock(&i8253_lock);
383                 delay = LATCH - 1 - delay;
384         }
385
386         tsc = get_cycles_sync();
387
388         if (vxtime.mode == VXTIME_HPET) {
389                 if (offset - vxtime.last > hpet_tick) {
390                         lost = (offset - vxtime.last) / hpet_tick - 1;
391                 }
392
393                 monotonic_base += 
394                         (offset - vxtime.last) * NSEC_PER_TICK / hpet_tick;
395
396                 vxtime.last = offset;
397 #ifdef CONFIG_X86_PM_TIMER
398         } else if (vxtime.mode == VXTIME_PMTMR) {
399                 lost = pmtimer_mark_offset();
400 #endif
401         } else {
402                 offset = (((tsc - vxtime.last_tsc) *
403                            vxtime.tsc_quot) >> US_SCALE) - USEC_PER_TICK;
404
405                 if (offset < 0)
406                         offset = 0;
407
408                 if (offset > USEC_PER_TICK) {
409                         lost = offset / USEC_PER_TICK;
410                         offset %= USEC_PER_TICK;
411                 }
412
413                 /* FIXME: 1000 or 1000000? */
414                 monotonic_base += (tsc - vxtime.last_tsc) * 1000000 / cpu_khz;
415
416                 vxtime.last_tsc = tsc - vxtime.quot * delay / vxtime.tsc_quot;
417
418                 if ((((tsc - vxtime.last_tsc) *
419                       vxtime.tsc_quot) >> US_SCALE) < offset)
420                         vxtime.last_tsc = tsc -
421                                 (((long) offset << US_SCALE) / vxtime.tsc_quot) - 1;
422         }
423
424         if (lost > 0) {
425                 handle_lost_ticks(lost, regs);
426                 jiffies += lost;
427         }
428
429 /*
430  * Do the timer stuff.
431  */
432
433         do_timer(regs);
434 #ifndef CONFIG_SMP
435         update_process_times(user_mode(regs));
436 #endif
437
438 /*
439  * In the SMP case we use the local APIC timer interrupt to do the profiling,
440  * except when we simulate SMP mode on a uniprocessor system, in that case we
441  * have to call the local interrupt handler.
442  */
443
444 #ifndef CONFIG_X86_LOCAL_APIC
445         profile_tick(CPU_PROFILING, regs);
446 #else
447         if (!using_apic_timer)
448                 smp_local_timer_interrupt(regs);
449 #endif
450
451 /*
452  * If we have an externally synchronized Linux clock, then update CMOS clock
453  * accordingly every ~11 minutes. set_rtc_mmss() will be called in the jiffy
454  * closest to exactly 500 ms before the next second. If the update fails, we
455  * don't care, as it'll be updated on the next turn, and the problem (time way
456  * off) isn't likely to go away much sooner anyway.
457  */
458
459         if (ntp_synced() && xtime.tv_sec > rtc_update &&
460                 abs(xtime.tv_nsec - 500000000) <= tick_nsec / 2) {
461                 set_rtc_mmss(xtime.tv_sec);
462                 rtc_update = xtime.tv_sec + 660;
463         }
464  
465         write_sequnlock(&xtime_lock);
466 }
467
468 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
469 {
470         if (apic_runs_main_timer > 1)
471                 return IRQ_HANDLED;
472         main_timer_handler(regs);
473 #ifdef CONFIG_X86_LOCAL_APIC
474         if (using_apic_timer)
475                 smp_send_timer_broadcast_ipi();
476 #endif
477         return IRQ_HANDLED;
478 }
479
480 static unsigned int cyc2ns_scale __read_mostly;
481
482 static inline void set_cyc2ns_scale(unsigned long cpu_khz)
483 {
484         cyc2ns_scale = (NSEC_PER_MSEC << NS_SCALE) / cpu_khz;
485 }
486
487 static inline unsigned long long cycles_2_ns(unsigned long long cyc)
488 {
489         return (cyc * cyc2ns_scale) >> NS_SCALE;
490 }
491
492 unsigned long long sched_clock(void)
493 {
494         unsigned long a = 0;
495
496 #if 0
497         /* Don't do a HPET read here. Using TSC always is much faster
498            and HPET may not be mapped yet when the scheduler first runs.
499            Disadvantage is a small drift between CPUs in some configurations,
500            but that should be tolerable. */
501         if (__vxtime.mode == VXTIME_HPET)
502                 return (hpet_readl(HPET_COUNTER) * vxtime.quot) >> US_SCALE;
503 #endif
504
505         /* Could do CPU core sync here. Opteron can execute rdtsc speculatively,
506            which means it is not completely exact and may not be monotonous between
507            CPUs. But the errors should be too small to matter for scheduling
508            purposes. */
509
510         rdtscll(a);
511         return cycles_2_ns(a);
512 }
513
514 static unsigned long get_cmos_time(void)
515 {
516         unsigned int year, mon, day, hour, min, sec;
517         unsigned long flags;
518         unsigned extyear = 0;
519
520         spin_lock_irqsave(&rtc_lock, flags);
521
522         do {
523                 sec = CMOS_READ(RTC_SECONDS);
524                 min = CMOS_READ(RTC_MINUTES);
525                 hour = CMOS_READ(RTC_HOURS);
526                 day = CMOS_READ(RTC_DAY_OF_MONTH);
527                 mon = CMOS_READ(RTC_MONTH);
528                 year = CMOS_READ(RTC_YEAR);
529 #ifdef CONFIG_ACPI
530                 if (acpi_fadt.revision >= FADT2_REVISION_ID &&
531                                         acpi_fadt.century)
532                         extyear = CMOS_READ(acpi_fadt.century);
533 #endif
534         } while (sec != CMOS_READ(RTC_SECONDS));
535
536         spin_unlock_irqrestore(&rtc_lock, flags);
537
538         /*
539          * We know that x86-64 always uses BCD format, no need to check the
540          * config register.
541          */
542
543         BCD_TO_BIN(sec);
544         BCD_TO_BIN(min);
545         BCD_TO_BIN(hour);
546         BCD_TO_BIN(day);
547         BCD_TO_BIN(mon);
548         BCD_TO_BIN(year);
549
550         if (extyear) {
551                 BCD_TO_BIN(extyear);
552                 year += extyear;
553                 printk(KERN_INFO "Extended CMOS year: %d\n", extyear);
554         } else { 
555                 /*
556                  * x86-64 systems only exists since 2002.
557                  * This will work up to Dec 31, 2100
558                  */
559                 year += 2000;
560         }
561
562         return mktime(year, mon, day, hour, min, sec);
563 }
564
565 #ifdef CONFIG_CPU_FREQ
566
567 /* Frequency scaling support. Adjust the TSC based timer when the cpu frequency
568    changes.
569    
570    RED-PEN: On SMP we assume all CPUs run with the same frequency.  It's
571    not that important because current Opteron setups do not support
572    scaling on SMP anyroads.
573
574    Should fix up last_tsc too. Currently gettimeofday in the
575    first tick after the change will be slightly wrong. */
576
577 #include <linux/workqueue.h>
578
579 static unsigned int cpufreq_delayed_issched = 0;
580 static unsigned int cpufreq_init = 0;
581 static struct work_struct cpufreq_delayed_get_work;
582
583 static void handle_cpufreq_delayed_get(void *v)
584 {
585         unsigned int cpu;
586         for_each_online_cpu(cpu) {
587                 cpufreq_get(cpu);
588         }
589         cpufreq_delayed_issched = 0;
590 }
591
592 /* if we notice lost ticks, schedule a call to cpufreq_get() as it tries
593  * to verify the CPU frequency the timing core thinks the CPU is running
594  * at is still correct.
595  */
596 static void cpufreq_delayed_get(void)
597 {
598         static int warned;
599         if (cpufreq_init && !cpufreq_delayed_issched) {
600                 cpufreq_delayed_issched = 1;
601                 if (!warned) {
602                         warned = 1;
603                         printk(KERN_DEBUG 
604         "Losing some ticks... checking if CPU frequency changed.\n");
605                 }
606                 schedule_work(&cpufreq_delayed_get_work);
607         }
608 }
609
610 static unsigned int  ref_freq = 0;
611 static unsigned long loops_per_jiffy_ref = 0;
612
613 static unsigned long cpu_khz_ref = 0;
614
615 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
616                                  void *data)
617 {
618         struct cpufreq_freqs *freq = data;
619         unsigned long *lpj, dummy;
620
621         if (cpu_has(&cpu_data[freq->cpu], X86_FEATURE_CONSTANT_TSC))
622                 return 0;
623
624         lpj = &dummy;
625         if (!(freq->flags & CPUFREQ_CONST_LOOPS))
626 #ifdef CONFIG_SMP
627                 lpj = &cpu_data[freq->cpu].loops_per_jiffy;
628 #else
629                 lpj = &boot_cpu_data.loops_per_jiffy;
630 #endif
631
632         if (!ref_freq) {
633                 ref_freq = freq->old;
634                 loops_per_jiffy_ref = *lpj;
635                 cpu_khz_ref = cpu_khz;
636         }
637         if ((val == CPUFREQ_PRECHANGE  && freq->old < freq->new) ||
638             (val == CPUFREQ_POSTCHANGE && freq->old > freq->new) ||
639             (val == CPUFREQ_RESUMECHANGE)) {
640                 *lpj =
641                 cpufreq_scale(loops_per_jiffy_ref, ref_freq, freq->new);
642
643                 cpu_khz = cpufreq_scale(cpu_khz_ref, ref_freq, freq->new);
644                 if (!(freq->flags & CPUFREQ_CONST_LOOPS))
645                         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
646         }
647         
648         set_cyc2ns_scale(cpu_khz_ref);
649
650         return 0;
651 }
652  
653 static struct notifier_block time_cpufreq_notifier_block = {
654          .notifier_call  = time_cpufreq_notifier
655 };
656
657 static int __init cpufreq_tsc(void)
658 {
659         INIT_WORK(&cpufreq_delayed_get_work, handle_cpufreq_delayed_get, NULL);
660         if (!cpufreq_register_notifier(&time_cpufreq_notifier_block,
661                                        CPUFREQ_TRANSITION_NOTIFIER))
662                 cpufreq_init = 1;
663         return 0;
664 }
665
666 core_initcall(cpufreq_tsc);
667
668 #endif
669
670 /*
671  * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
672  * it to the HPET timer of known frequency.
673  */
674
675 #define TICK_COUNT 100000000
676
677 static unsigned int __init hpet_calibrate_tsc(void)
678 {
679         int tsc_start, hpet_start;
680         int tsc_now, hpet_now;
681         unsigned long flags;
682
683         local_irq_save(flags);
684         local_irq_disable();
685
686         hpet_start = hpet_readl(HPET_COUNTER);
687         rdtscl(tsc_start);
688
689         do {
690                 local_irq_disable();
691                 hpet_now = hpet_readl(HPET_COUNTER);
692                 tsc_now = get_cycles_sync();
693                 local_irq_restore(flags);
694         } while ((tsc_now - tsc_start) < TICK_COUNT &&
695                  (hpet_now - hpet_start) < TICK_COUNT);
696
697         return (tsc_now - tsc_start) * 1000000000L
698                 / ((hpet_now - hpet_start) * hpet_period / 1000);
699 }
700
701
702 /*
703  * pit_calibrate_tsc() uses the speaker output (channel 2) of
704  * the PIT. This is better than using the timer interrupt output,
705  * because we can read the value of the speaker with just one inb(),
706  * where we need three i/o operations for the interrupt channel.
707  * We count how many ticks the TSC does in 50 ms.
708  */
709
710 static unsigned int __init pit_calibrate_tsc(void)
711 {
712         unsigned long start, end;
713         unsigned long flags;
714
715         spin_lock_irqsave(&i8253_lock, flags);
716
717         outb((inb(0x61) & ~0x02) | 0x01, 0x61);
718
719         outb(0xb0, 0x43);
720         outb((PIT_TICK_RATE / (1000 / 50)) & 0xff, 0x42);
721         outb((PIT_TICK_RATE / (1000 / 50)) >> 8, 0x42);
722         start = get_cycles_sync();
723         while ((inb(0x61) & 0x20) == 0);
724         end = get_cycles_sync();
725
726         spin_unlock_irqrestore(&i8253_lock, flags);
727         
728         return (end - start) / 50;
729 }
730
731 #ifdef  CONFIG_HPET
732 static __init int late_hpet_init(void)
733 {
734         struct hpet_data        hd;
735         unsigned int            ntimer;
736
737         if (!vxtime.hpet_address)
738                 return 0;
739
740         memset(&hd, 0, sizeof (hd));
741
742         ntimer = hpet_readl(HPET_ID);
743         ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
744         ntimer++;
745
746         /*
747          * Register with driver.
748          * Timer0 and Timer1 is used by platform.
749          */
750         hd.hd_phys_address = vxtime.hpet_address;
751         hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
752         hd.hd_nirqs = ntimer;
753         hd.hd_flags = HPET_DATA_PLATFORM;
754         hpet_reserve_timer(&hd, 0);
755 #ifdef  CONFIG_HPET_EMULATE_RTC
756         hpet_reserve_timer(&hd, 1);
757 #endif
758         hd.hd_irq[0] = HPET_LEGACY_8254;
759         hd.hd_irq[1] = HPET_LEGACY_RTC;
760         if (ntimer > 2) {
761                 struct hpet             *hpet;
762                 struct hpet_timer       *timer;
763                 int                     i;
764
765                 hpet = (struct hpet *) fix_to_virt(FIX_HPET_BASE);
766                 timer = &hpet->hpet_timers[2];
767                 for (i = 2; i < ntimer; timer++, i++)
768                         hd.hd_irq[i] = (timer->hpet_config &
769                                         Tn_INT_ROUTE_CNF_MASK) >>
770                                 Tn_INT_ROUTE_CNF_SHIFT;
771
772         }
773
774         hpet_alloc(&hd);
775         return 0;
776 }
777 fs_initcall(late_hpet_init);
778 #endif
779
780 static int hpet_timer_stop_set_go(unsigned long tick)
781 {
782         unsigned int cfg;
783
784 /*
785  * Stop the timers and reset the main counter.
786  */
787
788         cfg = hpet_readl(HPET_CFG);
789         cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
790         hpet_writel(cfg, HPET_CFG);
791         hpet_writel(0, HPET_COUNTER);
792         hpet_writel(0, HPET_COUNTER + 4);
793
794 /*
795  * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
796  * and period also hpet_tick.
797  */
798         if (hpet_use_timer) {
799                 hpet_writel(HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
800                     HPET_TN_32BIT, HPET_T0_CFG);
801                 hpet_writel(hpet_tick, HPET_T0_CMP); /* next interrupt */
802                 hpet_writel(hpet_tick, HPET_T0_CMP); /* period */
803                 cfg |= HPET_CFG_LEGACY;
804         }
805 /*
806  * Go!
807  */
808
809         cfg |= HPET_CFG_ENABLE;
810         hpet_writel(cfg, HPET_CFG);
811
812         return 0;
813 }
814
815 static int hpet_init(void)
816 {
817         unsigned int id;
818
819         if (!vxtime.hpet_address)
820                 return -1;
821         set_fixmap_nocache(FIX_HPET_BASE, vxtime.hpet_address);
822         __set_fixmap(VSYSCALL_HPET, vxtime.hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
823
824 /*
825  * Read the period, compute tick and quotient.
826  */
827
828         id = hpet_readl(HPET_ID);
829
830         if (!(id & HPET_ID_VENDOR) || !(id & HPET_ID_NUMBER))
831                 return -1;
832
833         hpet_period = hpet_readl(HPET_PERIOD);
834         if (hpet_period < 100000 || hpet_period > 100000000)
835                 return -1;
836
837         hpet_tick = (FSEC_PER_TICK + hpet_period / 2) / hpet_period;
838
839         hpet_use_timer = (id & HPET_ID_LEGSUP);
840
841         return hpet_timer_stop_set_go(hpet_tick);
842 }
843
844 static int hpet_reenable(void)
845 {
846         return hpet_timer_stop_set_go(hpet_tick);
847 }
848
849 #define PIT_MODE 0x43
850 #define PIT_CH0  0x40
851
852 static void __init __pit_init(int val, u8 mode)
853 {
854         unsigned long flags;
855
856         spin_lock_irqsave(&i8253_lock, flags);
857         outb_p(mode, PIT_MODE);
858         outb_p(val & 0xff, PIT_CH0);    /* LSB */
859         outb_p(val >> 8, PIT_CH0);      /* MSB */
860         spin_unlock_irqrestore(&i8253_lock, flags);
861 }
862
863 void __init pit_init(void)
864 {
865         __pit_init(LATCH, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
866 }
867
868 void __init pit_stop_interrupt(void)
869 {
870         __pit_init(0, 0x30); /* mode 0 */
871 }
872
873 void __init stop_timer_interrupt(void)
874 {
875         char *name;
876         if (vxtime.hpet_address) {
877                 name = "HPET";
878                 hpet_timer_stop_set_go(0);
879         } else {
880                 name = "PIT";
881                 pit_stop_interrupt();
882         }
883         printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
884 }
885
886 int __init time_setup(char *str)
887 {
888         report_lost_ticks = 1;
889         return 1;
890 }
891
892 static struct irqaction irq0 = {
893         timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL
894 };
895
896 void __init time_init(void)
897 {
898         char *timename;
899         char *gtod;
900
901         if (nohpet)
902                 vxtime.hpet_address = 0;
903
904         xtime.tv_sec = get_cmos_time();
905         xtime.tv_nsec = 0;
906
907         set_normalized_timespec(&wall_to_monotonic,
908                                 -xtime.tv_sec, -xtime.tv_nsec);
909
910         if (!hpet_init())
911                 vxtime_hz = (FSEC_PER_SEC + hpet_period / 2) / hpet_period;
912         else
913                 vxtime.hpet_address = 0;
914
915         if (hpet_use_timer) {
916                 /* set tick_nsec to use the proper rate for HPET */
917                 tick_nsec = TICK_NSEC_HPET;
918                 cpu_khz = hpet_calibrate_tsc();
919                 timename = "HPET";
920 #ifdef CONFIG_X86_PM_TIMER
921         } else if (pmtmr_ioport && !vxtime.hpet_address) {
922                 vxtime_hz = PM_TIMER_FREQUENCY;
923                 timename = "PM";
924                 pit_init();
925                 cpu_khz = pit_calibrate_tsc();
926 #endif
927         } else {
928                 pit_init();
929                 cpu_khz = pit_calibrate_tsc();
930                 timename = "PIT";
931         }
932
933         vxtime.mode = VXTIME_TSC;
934         gtod = time_init_gtod();
935
936         printk(KERN_INFO "time.c: Using %ld.%06ld MHz WALL %s GTOD %s timer.\n",
937                vxtime_hz / 1000000, vxtime_hz % 1000000, timename, gtod);
938         printk(KERN_INFO "time.c: Detected %d.%03d MHz processor.\n",
939                 cpu_khz / 1000, cpu_khz % 1000);
940         vxtime.quot = (USEC_PER_SEC << US_SCALE) / vxtime_hz;
941         vxtime.tsc_quot = (USEC_PER_MSEC << US_SCALE) / cpu_khz;
942         vxtime.last_tsc = get_cycles_sync();
943         setup_irq(0, &irq0);
944
945         set_cyc2ns_scale(cpu_khz);
946 }
947
948 /*
949  * Make an educated guess if the TSC is trustworthy and synchronized
950  * over all CPUs.
951  */
952 __cpuinit int unsynchronized_tsc(void)
953 {
954 #ifdef CONFIG_SMP
955         if (apic_is_clustered_box())
956                 return 1;
957 #endif
958         /* Most intel systems have synchronized TSCs except for
959            multi node systems */
960         if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) {
961 #ifdef CONFIG_ACPI
962                 /* But TSC doesn't tick in C3 so don't use it there */
963                 if (acpi_fadt.length > 0 && acpi_fadt.plvl3_lat < 100)
964                         return 1;
965 #endif
966                 return 0;
967         }
968
969         /* Assume multi socket systems are not synchronized */
970         return num_present_cpus() > 1;
971 }
972
973 /*
974  * Decide what mode gettimeofday should use.
975  */
976 __init static char *time_init_gtod(void)
977 {
978         char *timetype;
979
980         if (unsynchronized_tsc())
981                 notsc = 1;
982         if (vxtime.hpet_address && notsc) {
983                 timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
984                 if (hpet_use_timer)
985                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
986                 else
987                         vxtime.last = hpet_readl(HPET_COUNTER);
988                 vxtime.mode = VXTIME_HPET;
989                 do_gettimeoffset = do_gettimeoffset_hpet;
990 #ifdef CONFIG_X86_PM_TIMER
991         /* Using PM for gettimeofday is quite slow, but we have no other
992            choice because the TSC is too unreliable on some systems. */
993         } else if (pmtmr_ioport && !vxtime.hpet_address && notsc) {
994                 timetype = "PM";
995                 do_gettimeoffset = do_gettimeoffset_pm;
996                 vxtime.mode = VXTIME_PMTMR;
997                 sysctl_vsyscall = 0;
998                 printk(KERN_INFO "Disabling vsyscall due to use of PM timer\n");
999 #endif
1000         } else {
1001                 timetype = hpet_use_timer ? "HPET/TSC" : "PIT/TSC";
1002                 vxtime.mode = VXTIME_TSC;
1003         }
1004         return timetype;
1005 }
1006
1007 __setup("report_lost_ticks", time_setup);
1008
1009 static long clock_cmos_diff;
1010 static unsigned long sleep_start;
1011
1012 /*
1013  * sysfs support for the timer.
1014  */
1015
1016 static int timer_suspend(struct sys_device *dev, pm_message_t state)
1017 {
1018         /*
1019          * Estimate time zone so that set_time can update the clock
1020          */
1021         long cmos_time =  get_cmos_time();
1022
1023         clock_cmos_diff = -cmos_time;
1024         clock_cmos_diff += get_seconds();
1025         sleep_start = cmos_time;
1026         return 0;
1027 }
1028
1029 static int timer_resume(struct sys_device *dev)
1030 {
1031         unsigned long flags;
1032         unsigned long sec;
1033         unsigned long ctime = get_cmos_time();
1034         unsigned long sleep_length = (ctime - sleep_start) * HZ;
1035
1036         if (vxtime.hpet_address)
1037                 hpet_reenable();
1038         else
1039                 i8254_timer_resume();
1040
1041         sec = ctime + clock_cmos_diff;
1042         write_seqlock_irqsave(&xtime_lock,flags);
1043         xtime.tv_sec = sec;
1044         xtime.tv_nsec = 0;
1045         if (vxtime.mode == VXTIME_HPET) {
1046                 if (hpet_use_timer)
1047                         vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
1048                 else
1049                         vxtime.last = hpet_readl(HPET_COUNTER);
1050 #ifdef CONFIG_X86_PM_TIMER
1051         } else if (vxtime.mode == VXTIME_PMTMR) {
1052                 pmtimer_resume();
1053 #endif
1054         } else
1055                 vxtime.last_tsc = get_cycles_sync();
1056         write_sequnlock_irqrestore(&xtime_lock,flags);
1057         jiffies += sleep_length;
1058         wall_jiffies += sleep_length;
1059         monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
1060         touch_softlockup_watchdog();
1061         return 0;
1062 }
1063
1064 static struct sysdev_class timer_sysclass = {
1065         .resume = timer_resume,
1066         .suspend = timer_suspend,
1067         set_kset_name("timer"),
1068 };
1069
1070 /* XXX this driverfs stuff should probably go elsewhere later -john */
1071 static struct sys_device device_timer = {
1072         .id     = 0,
1073         .cls    = &timer_sysclass,
1074 };
1075
1076 static int time_init_device(void)
1077 {
1078         int error = sysdev_class_register(&timer_sysclass);
1079         if (!error)
1080                 error = sysdev_register(&device_timer);
1081         return error;
1082 }
1083
1084 device_initcall(time_init_device);
1085
1086 #ifdef CONFIG_HPET_EMULATE_RTC
1087 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
1088  * is enabled, we support RTC interrupt functionality in software.
1089  * RTC has 3 kinds of interrupts:
1090  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
1091  *    is updated
1092  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
1093  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
1094  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
1095  * (1) and (2) above are implemented using polling at a frequency of
1096  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
1097  * overhead. (DEFAULT_RTC_INT_FREQ)
1098  * For (3), we use interrupts at 64Hz or user specified periodic
1099  * frequency, whichever is higher.
1100  */
1101 #include <linux/rtc.h>
1102
1103 #define DEFAULT_RTC_INT_FREQ    64
1104 #define RTC_NUM_INTS            1
1105
1106 static unsigned long UIE_on;
1107 static unsigned long prev_update_sec;
1108
1109 static unsigned long AIE_on;
1110 static struct rtc_time alarm_time;
1111
1112 static unsigned long PIE_on;
1113 static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
1114 static unsigned long PIE_count;
1115
1116 static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
1117 static unsigned int hpet_t1_cmp; /* cached comparator register */
1118
1119 int is_hpet_enabled(void)
1120 {
1121         return vxtime.hpet_address != 0;
1122 }
1123
1124 /*
1125  * Timer 1 for RTC, we do not use periodic interrupt feature,
1126  * even if HPET supports periodic interrupts on Timer 1.
1127  * The reason being, to set up a periodic interrupt in HPET, we need to
1128  * stop the main counter. And if we do that everytime someone diables/enables
1129  * RTC, we will have adverse effect on main kernel timer running on Timer 0.
1130  * So, for the time being, simulate the periodic interrupt in software.
1131  *
1132  * hpet_rtc_timer_init() is called for the first time and during subsequent
1133  * interuppts reinit happens through hpet_rtc_timer_reinit().
1134  */
1135 int hpet_rtc_timer_init(void)
1136 {
1137         unsigned int cfg, cnt;
1138         unsigned long flags;
1139
1140         if (!is_hpet_enabled())
1141                 return 0;
1142         /*
1143          * Set the counter 1 and enable the interrupts.
1144          */
1145         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1146                 hpet_rtc_int_freq = PIE_freq;
1147         else
1148                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1149
1150         local_irq_save(flags);
1151         cnt = hpet_readl(HPET_COUNTER);
1152         cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
1153         hpet_writel(cnt, HPET_T1_CMP);
1154         hpet_t1_cmp = cnt;
1155         local_irq_restore(flags);
1156
1157         cfg = hpet_readl(HPET_T1_CFG);
1158         cfg &= ~HPET_TN_PERIODIC;
1159         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
1160         hpet_writel(cfg, HPET_T1_CFG);
1161
1162         return 1;
1163 }
1164
1165 static void hpet_rtc_timer_reinit(void)
1166 {
1167         unsigned int cfg, cnt;
1168
1169         if (unlikely(!(PIE_on | AIE_on | UIE_on))) {
1170                 cfg = hpet_readl(HPET_T1_CFG);
1171                 cfg &= ~HPET_TN_ENABLE;
1172                 hpet_writel(cfg, HPET_T1_CFG);
1173                 return;
1174         }
1175
1176         if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
1177                 hpet_rtc_int_freq = PIE_freq;
1178         else
1179                 hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
1180
1181         /* It is more accurate to use the comparator value than current count.*/
1182         cnt = hpet_t1_cmp;
1183         cnt += hpet_tick*HZ/hpet_rtc_int_freq;
1184         hpet_writel(cnt, HPET_T1_CMP);
1185         hpet_t1_cmp = cnt;
1186 }
1187
1188 /*
1189  * The functions below are called from rtc driver.
1190  * Return 0 if HPET is not being used.
1191  * Otherwise do the necessary changes and return 1.
1192  */
1193 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
1194 {
1195         if (!is_hpet_enabled())
1196                 return 0;
1197
1198         if (bit_mask & RTC_UIE)
1199                 UIE_on = 0;
1200         if (bit_mask & RTC_PIE)
1201                 PIE_on = 0;
1202         if (bit_mask & RTC_AIE)
1203                 AIE_on = 0;
1204
1205         return 1;
1206 }
1207
1208 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
1209 {
1210         int timer_init_reqd = 0;
1211
1212         if (!is_hpet_enabled())
1213                 return 0;
1214
1215         if (!(PIE_on | AIE_on | UIE_on))
1216                 timer_init_reqd = 1;
1217
1218         if (bit_mask & RTC_UIE) {
1219                 UIE_on = 1;
1220         }
1221         if (bit_mask & RTC_PIE) {
1222                 PIE_on = 1;
1223                 PIE_count = 0;
1224         }
1225         if (bit_mask & RTC_AIE) {
1226                 AIE_on = 1;
1227         }
1228
1229         if (timer_init_reqd)
1230                 hpet_rtc_timer_init();
1231
1232         return 1;
1233 }
1234
1235 int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
1236 {
1237         if (!is_hpet_enabled())
1238                 return 0;
1239
1240         alarm_time.tm_hour = hrs;
1241         alarm_time.tm_min = min;
1242         alarm_time.tm_sec = sec;
1243
1244         return 1;
1245 }
1246
1247 int hpet_set_periodic_freq(unsigned long freq)
1248 {
1249         if (!is_hpet_enabled())
1250                 return 0;
1251
1252         PIE_freq = freq;
1253         PIE_count = 0;
1254
1255         return 1;
1256 }
1257
1258 int hpet_rtc_dropped_irq(void)
1259 {
1260         if (!is_hpet_enabled())
1261                 return 0;
1262
1263         return 1;
1264 }
1265
1266 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1267 {
1268         struct rtc_time curr_time;
1269         unsigned long rtc_int_flag = 0;
1270         int call_rtc_interrupt = 0;
1271
1272         hpet_rtc_timer_reinit();
1273
1274         if (UIE_on | AIE_on) {
1275                 rtc_get_rtc_time(&curr_time);
1276         }
1277         if (UIE_on) {
1278                 if (curr_time.tm_sec != prev_update_sec) {
1279                         /* Set update int info, call real rtc int routine */
1280                         call_rtc_interrupt = 1;
1281                         rtc_int_flag = RTC_UF;
1282                         prev_update_sec = curr_time.tm_sec;
1283                 }
1284         }
1285         if (PIE_on) {
1286                 PIE_count++;
1287                 if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
1288                         /* Set periodic int info, call real rtc int routine */
1289                         call_rtc_interrupt = 1;
1290                         rtc_int_flag |= RTC_PF;
1291                         PIE_count = 0;
1292                 }
1293         }
1294         if (AIE_on) {
1295                 if ((curr_time.tm_sec == alarm_time.tm_sec) &&
1296                     (curr_time.tm_min == alarm_time.tm_min) &&
1297                     (curr_time.tm_hour == alarm_time.tm_hour)) {
1298                         /* Set alarm int info, call real rtc int routine */
1299                         call_rtc_interrupt = 1;
1300                         rtc_int_flag |= RTC_AF;
1301                 }
1302         }
1303         if (call_rtc_interrupt) {
1304                 rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
1305                 rtc_interrupt(rtc_int_flag, dev_id, regs);
1306         }
1307         return IRQ_HANDLED;
1308 }
1309 #endif
1310
1311 static int __init nohpet_setup(char *s) 
1312
1313         nohpet = 1;
1314         return 1;
1315
1316
1317 __setup("nohpet", nohpet_setup);
1318
1319 int __init notsc_setup(char *s)
1320 {
1321         notsc = 1;
1322         return 1;
1323 }
1324
1325 __setup("notsc", notsc_setup);