aboutsummaryrefslogtreecommitdiffstats
path: root/arch/powerpc/kernel
diff options
context:
space:
mode:
Diffstat (limited to 'arch/powerpc/kernel')
-rw-r--r--arch/powerpc/kernel/crash.c4
-rw-r--r--arch/powerpc/kernel/head_32.S1
-rw-r--r--arch/powerpc/kernel/head_64.S111
-rw-r--r--arch/powerpc/kernel/lparcfg.c6
-rw-r--r--arch/powerpc/kernel/machine_kexec_64.c10
-rw-r--r--arch/powerpc/kernel/ppc_ksyms.c16
-rw-r--r--arch/powerpc/kernel/process.c32
-rw-r--r--arch/powerpc/kernel/prom_init.c38
-rw-r--r--arch/powerpc/kernel/setup_64.c4
-rw-r--r--arch/powerpc/kernel/sys_ppc32.c4
-rw-r--r--arch/powerpc/kernel/time.c282
11 files changed, 150 insertions, 358 deletions
diff --git a/arch/powerpc/kernel/crash.c b/arch/powerpc/kernel/crash.c
index 8c21d378f5d2..778f22fd85d2 100644
--- a/arch/powerpc/kernel/crash.c
+++ b/arch/powerpc/kernel/crash.c
@@ -134,8 +134,10 @@ static void crash_kexec_prepare_cpus(void)
134 * the crash CPU will send an IPI and wait for other CPUs to 134 * the crash CPU will send an IPI and wait for other CPUs to
135 * respond. If not, proceed the kexec boot even though we failed to 135 * respond. If not, proceed the kexec boot even though we failed to
136 * capture other CPU states. 136 * capture other CPU states.
137 * Delay of at least 10 seconds.
137 */ 138 */
138 msecs = 1000000; 139 printk(KERN_ALERT "Sending IPI to other cpus...\n");
140 msecs = 10000;
139 while ((atomic_read(&waiting_for_crash_ipi) > 0) && (--msecs > 0)) { 141 while ((atomic_read(&waiting_for_crash_ipi) > 0) && (--msecs > 0)) {
140 barrier(); 142 barrier();
141 mdelay(1); 143 mdelay(1);
diff --git a/arch/powerpc/kernel/head_32.S b/arch/powerpc/kernel/head_32.S
index 03b25f9359f8..a0579e859b21 100644
--- a/arch/powerpc/kernel/head_32.S
+++ b/arch/powerpc/kernel/head_32.S
@@ -714,6 +714,7 @@ AltiVecUnavailable:
714#ifdef CONFIG_ALTIVEC 714#ifdef CONFIG_ALTIVEC
715 bne load_up_altivec /* if from user, just load it up */ 715 bne load_up_altivec /* if from user, just load it up */
716#endif /* CONFIG_ALTIVEC */ 716#endif /* CONFIG_ALTIVEC */
717 addi r3,r1,STACK_FRAME_OVERHEAD
717 EXC_XFER_EE_LITE(0xf20, altivec_unavailable_exception) 718 EXC_XFER_EE_LITE(0xf20, altivec_unavailable_exception)
718 719
719PerformanceMonitor: 720PerformanceMonitor:
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index 7ebb73665e9d..2b21ec499285 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -137,7 +137,7 @@ _GLOBAL(__secondary_hold)
137 ori r24,r24,MSR_RI 137 ori r24,r24,MSR_RI
138 mtmsrd r24 /* RI on */ 138 mtmsrd r24 /* RI on */
139 139
140 /* Grab our linux cpu number */ 140 /* Grab our physical cpu number */
141 mr r24,r3 141 mr r24,r3
142 142
143 /* Tell the master cpu we're here */ 143 /* Tell the master cpu we're here */
@@ -151,12 +151,7 @@ _GLOBAL(__secondary_hold)
151 cmpdi 0,r4,1 151 cmpdi 0,r4,1
152 bne 100b 152 bne 100b
153 153
154#ifdef CONFIG_HMT 154#if defined(CONFIG_SMP) || defined(CONFIG_KEXEC)
155 SET_REG_IMMEDIATE(r4, .hmt_init)
156 mtctr r4
157 bctr
158#else
159#ifdef CONFIG_SMP
160 LOAD_REG_IMMEDIATE(r4, .pSeries_secondary_smp_init) 155 LOAD_REG_IMMEDIATE(r4, .pSeries_secondary_smp_init)
161 mtctr r4 156 mtctr r4
162 mr r3,r24 157 mr r3,r24
@@ -164,7 +159,6 @@ _GLOBAL(__secondary_hold)
164#else 159#else
165 BUG_OPCODE 160 BUG_OPCODE
166#endif 161#endif
167#endif
168 162
169/* This value is used to mark exception frames on the stack. */ 163/* This value is used to mark exception frames on the stack. */
170 .section ".toc","aw" 164 .section ".toc","aw"
@@ -319,7 +313,6 @@ exception_marker:
319label##_pSeries: \ 313label##_pSeries: \
320 HMT_MEDIUM; \ 314 HMT_MEDIUM; \
321 mtspr SPRN_SPRG1,r13; /* save r13 */ \ 315 mtspr SPRN_SPRG1,r13; /* save r13 */ \
322 RUNLATCH_ON(r13); \
323 EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common) 316 EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, label##_common)
324 317
325#define STD_EXCEPTION_ISERIES(n, label, area) \ 318#define STD_EXCEPTION_ISERIES(n, label, area) \
@@ -327,7 +320,6 @@ label##_pSeries: \
327label##_iSeries: \ 320label##_iSeries: \
328 HMT_MEDIUM; \ 321 HMT_MEDIUM; \
329 mtspr SPRN_SPRG1,r13; /* save r13 */ \ 322 mtspr SPRN_SPRG1,r13; /* save r13 */ \
330 RUNLATCH_ON(r13); \
331 EXCEPTION_PROLOG_ISERIES_1(area); \ 323 EXCEPTION_PROLOG_ISERIES_1(area); \
332 EXCEPTION_PROLOG_ISERIES_2; \ 324 EXCEPTION_PROLOG_ISERIES_2; \
333 b label##_common 325 b label##_common
@@ -337,7 +329,6 @@ label##_iSeries: \
337label##_iSeries: \ 329label##_iSeries: \
338 HMT_MEDIUM; \ 330 HMT_MEDIUM; \
339 mtspr SPRN_SPRG1,r13; /* save r13 */ \ 331 mtspr SPRN_SPRG1,r13; /* save r13 */ \
340 RUNLATCH_ON(r13); \
341 EXCEPTION_PROLOG_ISERIES_1(PACA_EXGEN); \ 332 EXCEPTION_PROLOG_ISERIES_1(PACA_EXGEN); \
342 lbz r10,PACAPROCENABLED(r13); \ 333 lbz r10,PACAPROCENABLED(r13); \
343 cmpwi 0,r10,0; \ 334 cmpwi 0,r10,0; \
@@ -390,6 +381,7 @@ label##_common: \
390label##_common: \ 381label##_common: \
391 EXCEPTION_PROLOG_COMMON(trap, PACA_EXGEN); \ 382 EXCEPTION_PROLOG_COMMON(trap, PACA_EXGEN); \
392 DISABLE_INTS; \ 383 DISABLE_INTS; \
384 bl .ppc64_runlatch_on; \
393 addi r3,r1,STACK_FRAME_OVERHEAD; \ 385 addi r3,r1,STACK_FRAME_OVERHEAD; \
394 bl hdlr; \ 386 bl hdlr; \
395 b .ret_from_except_lite 387 b .ret_from_except_lite
@@ -407,7 +399,6 @@ __start_interrupts:
407_machine_check_pSeries: 399_machine_check_pSeries:
408 HMT_MEDIUM 400 HMT_MEDIUM
409 mtspr SPRN_SPRG1,r13 /* save r13 */ 401 mtspr SPRN_SPRG1,r13 /* save r13 */
410 RUNLATCH_ON(r13)
411 EXCEPTION_PROLOG_PSERIES(PACA_EXMC, machine_check_common) 402 EXCEPTION_PROLOG_PSERIES(PACA_EXMC, machine_check_common)
412 403
413 . = 0x300 404 . = 0x300
@@ -434,7 +425,6 @@ END_FTR_SECTION_IFCLR(CPU_FTR_SLB)
434data_access_slb_pSeries: 425data_access_slb_pSeries:
435 HMT_MEDIUM 426 HMT_MEDIUM
436 mtspr SPRN_SPRG1,r13 427 mtspr SPRN_SPRG1,r13
437 RUNLATCH_ON(r13)
438 mfspr r13,SPRN_SPRG3 /* get paca address into r13 */ 428 mfspr r13,SPRN_SPRG3 /* get paca address into r13 */
439 std r3,PACA_EXSLB+EX_R3(r13) 429 std r3,PACA_EXSLB+EX_R3(r13)
440 mfspr r3,SPRN_DAR 430 mfspr r3,SPRN_DAR
@@ -460,7 +450,6 @@ data_access_slb_pSeries:
460instruction_access_slb_pSeries: 450instruction_access_slb_pSeries:
461 HMT_MEDIUM 451 HMT_MEDIUM
462 mtspr SPRN_SPRG1,r13 452 mtspr SPRN_SPRG1,r13
463 RUNLATCH_ON(r13)
464 mfspr r13,SPRN_SPRG3 /* get paca address into r13 */ 453 mfspr r13,SPRN_SPRG3 /* get paca address into r13 */
465 std r3,PACA_EXSLB+EX_R3(r13) 454 std r3,PACA_EXSLB+EX_R3(r13)
466 mfspr r3,SPRN_SRR0 /* SRR0 is faulting address */ 455 mfspr r3,SPRN_SRR0 /* SRR0 is faulting address */
@@ -491,7 +480,6 @@ instruction_access_slb_pSeries:
491 .globl system_call_pSeries 480 .globl system_call_pSeries
492system_call_pSeries: 481system_call_pSeries:
493 HMT_MEDIUM 482 HMT_MEDIUM
494 RUNLATCH_ON(r9)
495 mr r9,r13 483 mr r9,r13
496 mfmsr r10 484 mfmsr r10
497 mfspr r13,SPRN_SPRG3 485 mfspr r13,SPRN_SPRG3
@@ -575,7 +563,6 @@ slb_miss_user_pseries:
575system_reset_fwnmi: 563system_reset_fwnmi:
576 HMT_MEDIUM 564 HMT_MEDIUM
577 mtspr SPRN_SPRG1,r13 /* save r13 */ 565 mtspr SPRN_SPRG1,r13 /* save r13 */
578 RUNLATCH_ON(r13)
579 EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, system_reset_common) 566 EXCEPTION_PROLOG_PSERIES(PACA_EXGEN, system_reset_common)
580 567
581 .globl machine_check_fwnmi 568 .globl machine_check_fwnmi
@@ -583,7 +570,6 @@ system_reset_fwnmi:
583machine_check_fwnmi: 570machine_check_fwnmi:
584 HMT_MEDIUM 571 HMT_MEDIUM
585 mtspr SPRN_SPRG1,r13 /* save r13 */ 572 mtspr SPRN_SPRG1,r13 /* save r13 */
586 RUNLATCH_ON(r13)
587 EXCEPTION_PROLOG_PSERIES(PACA_EXMC, machine_check_common) 573 EXCEPTION_PROLOG_PSERIES(PACA_EXMC, machine_check_common)
588 574
589#ifdef CONFIG_PPC_ISERIES 575#ifdef CONFIG_PPC_ISERIES
@@ -894,7 +880,6 @@ unrecov_fer:
894 .align 7 880 .align 7
895 .globl data_access_common 881 .globl data_access_common
896data_access_common: 882data_access_common:
897 RUNLATCH_ON(r10) /* It wont fit in the 0x300 handler */
898 mfspr r10,SPRN_DAR 883 mfspr r10,SPRN_DAR
899 std r10,PACA_EXGEN+EX_DAR(r13) 884 std r10,PACA_EXGEN+EX_DAR(r13)
900 mfspr r10,SPRN_DSISR 885 mfspr r10,SPRN_DSISR
@@ -1042,6 +1027,7 @@ hardware_interrupt_common:
1042 EXCEPTION_PROLOG_COMMON(0x500, PACA_EXGEN) 1027 EXCEPTION_PROLOG_COMMON(0x500, PACA_EXGEN)
1043hardware_interrupt_entry: 1028hardware_interrupt_entry:
1044 DISABLE_INTS 1029 DISABLE_INTS
1030 bl .ppc64_runlatch_on
1045 addi r3,r1,STACK_FRAME_OVERHEAD 1031 addi r3,r1,STACK_FRAME_OVERHEAD
1046 bl .do_IRQ 1032 bl .do_IRQ
1047 b .ret_from_except_lite 1033 b .ret_from_except_lite
@@ -1816,22 +1802,6 @@ _STATIC(start_here_multiplatform)
1816 ori r6,r6,MSR_RI 1802 ori r6,r6,MSR_RI
1817 mtmsrd r6 /* RI on */ 1803 mtmsrd r6 /* RI on */
1818 1804
1819#ifdef CONFIG_HMT
1820 /* Start up the second thread on cpu 0 */
1821 mfspr r3,SPRN_PVR
1822 srwi r3,r3,16
1823 cmpwi r3,0x34 /* Pulsar */
1824 beq 90f
1825 cmpwi r3,0x36 /* Icestar */
1826 beq 90f
1827 cmpwi r3,0x37 /* SStar */
1828 beq 90f
1829 b 91f /* HMT not supported */
183090: li r3,0
1831 bl .hmt_start_secondary
183291:
1833#endif
1834
1835 /* The following gets the stack and TOC set up with the regs */ 1805 /* The following gets the stack and TOC set up with the regs */
1836 /* pointing to the real addr of the kernel stack. This is */ 1806 /* pointing to the real addr of the kernel stack. This is */
1837 /* all done to support the C function call below which sets */ 1807 /* all done to support the C function call below which sets */
@@ -1945,77 +1915,8 @@ _STATIC(start_here_common)
1945 1915
1946 bl .start_kernel 1916 bl .start_kernel
1947 1917
1948_GLOBAL(hmt_init) 1918 /* Not reached */
1949#ifdef CONFIG_HMT 1919 BUG_OPCODE
1950 LOAD_REG_IMMEDIATE(r5, hmt_thread_data)
1951 mfspr r7,SPRN_PVR
1952 srwi r7,r7,16
1953 cmpwi r7,0x34 /* Pulsar */
1954 beq 90f
1955 cmpwi r7,0x36 /* Icestar */
1956 beq 91f
1957 cmpwi r7,0x37 /* SStar */
1958 beq 91f
1959 b 101f
196090: mfspr r6,SPRN_PIR
1961 andi. r6,r6,0x1f
1962 b 92f
196391: mfspr r6,SPRN_PIR
1964 andi. r6,r6,0x3ff
196592: sldi r4,r24,3
1966 stwx r6,r5,r4
1967 bl .hmt_start_secondary
1968 b 101f
1969
1970__hmt_secondary_hold:
1971 LOAD_REG_IMMEDIATE(r5, hmt_thread_data)
1972 clrldi r5,r5,4
1973 li r7,0
1974 mfspr r6,SPRN_PIR
1975 mfspr r8,SPRN_PVR
1976 srwi r8,r8,16
1977 cmpwi r8,0x34
1978 bne 93f
1979 andi. r6,r6,0x1f
1980 b 103f
198193: andi. r6,r6,0x3f
1982
1983103: lwzx r8,r5,r7
1984 cmpw r8,r6
1985 beq 104f
1986 addi r7,r7,8
1987 b 103b
1988
1989104: addi r7,r7,4
1990 lwzx r9,r5,r7
1991 mr r24,r9
1992101:
1993#endif
1994 mr r3,r24
1995 b .pSeries_secondary_smp_init
1996
1997#ifdef CONFIG_HMT
1998_GLOBAL(hmt_start_secondary)
1999 LOAD_REG_IMMEDIATE(r4,__hmt_secondary_hold)
2000 clrldi r4,r4,4
2001 mtspr SPRN_NIADORM, r4
2002 mfspr r4, SPRN_MSRDORM
2003 li r5, -65
2004 and r4, r4, r5
2005 mtspr SPRN_MSRDORM, r4
2006 lis r4,0xffef
2007 ori r4,r4,0x7403
2008 mtspr SPRN_TSC, r4
2009 li r4,0x1f4
2010 mtspr SPRN_TST, r4
2011 mfspr r4, SPRN_HID0
2012 ori r4, r4, 0x1
2013 mtspr SPRN_HID0, r4
2014 mfspr r4, SPRN_CTRLF
2015 oris r4, r4, 0x40
2016 mtspr SPRN_CTRLT, r4
2017 blr
2018#endif
2019 1920
2020/* 1921/*
2021 * We put a few things here that have to be page-aligned. 1922 * We put a few things here that have to be page-aligned.
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 1ae96a8ed7e2..e789fef4eb8a 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -341,7 +341,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
341 const char *system_id = ""; 341 const char *system_id = "";
342 unsigned int *lp_index_ptr, lp_index = 0; 342 unsigned int *lp_index_ptr, lp_index = 0;
343 struct device_node *rtas_node; 343 struct device_node *rtas_node;
344 int *lrdrp; 344 int *lrdrp = NULL;
345 345
346 rootdn = find_path_device("/"); 346 rootdn = find_path_device("/");
347 if (rootdn) { 347 if (rootdn) {
@@ -362,7 +362,9 @@ static int lparcfg_data(struct seq_file *m, void *v)
362 seq_printf(m, "partition_id=%d\n", (int)lp_index); 362 seq_printf(m, "partition_id=%d\n", (int)lp_index);
363 363
364 rtas_node = find_path_device("/rtas"); 364 rtas_node = find_path_device("/rtas");
365 lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity", NULL); 365 if (rtas_node)
366 lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity",
367 NULL);
366 368
367 if (lrdrp == NULL) { 369 if (lrdrp == NULL) {
368 partition_potential_processors = vdso_data->processorCount; 370 partition_potential_processors = vdso_data->processorCount;
diff --git a/arch/powerpc/kernel/machine_kexec_64.c b/arch/powerpc/kernel/machine_kexec_64.c
index d6431440c54f..ee166c586642 100644
--- a/arch/powerpc/kernel/machine_kexec_64.c
+++ b/arch/powerpc/kernel/machine_kexec_64.c
@@ -26,8 +26,6 @@
26#include <asm/prom.h> 26#include <asm/prom.h>
27#include <asm/smp.h> 27#include <asm/smp.h>
28 28
29#define HASH_GROUP_SIZE 0x80 /* size of each hash group, asm/mmu.h */
30
31int default_machine_kexec_prepare(struct kimage *image) 29int default_machine_kexec_prepare(struct kimage *image)
32{ 30{
33 int i; 31 int i;
@@ -61,7 +59,7 @@ int default_machine_kexec_prepare(struct kimage *image)
61 */ 59 */
62 if (htab_address) { 60 if (htab_address) {
63 low = __pa(htab_address); 61 low = __pa(htab_address);
64 high = low + (htab_hash_mask + 1) * HASH_GROUP_SIZE; 62 high = low + htab_size_bytes;
65 63
66 for (i = 0; i < image->nr_segments; i++) { 64 for (i = 0; i < image->nr_segments; i++) {
67 begin = image->segment[i].mem; 65 begin = image->segment[i].mem;
@@ -294,7 +292,7 @@ void default_machine_kexec(struct kimage *image)
294} 292}
295 293
296/* Values we need to export to the second kernel via the device tree. */ 294/* Values we need to export to the second kernel via the device tree. */
297static unsigned long htab_base, htab_size, kernel_end; 295static unsigned long htab_base, kernel_end;
298 296
299static struct property htab_base_prop = { 297static struct property htab_base_prop = {
300 .name = "linux,htab-base", 298 .name = "linux,htab-base",
@@ -305,7 +303,7 @@ static struct property htab_base_prop = {
305static struct property htab_size_prop = { 303static struct property htab_size_prop = {
306 .name = "linux,htab-size", 304 .name = "linux,htab-size",
307 .length = sizeof(unsigned long), 305 .length = sizeof(unsigned long),
308 .value = (unsigned char *)&htab_size, 306 .value = (unsigned char *)&htab_size_bytes,
309}; 307};
310 308
311static struct property kernel_end_prop = { 309static struct property kernel_end_prop = {
@@ -331,8 +329,6 @@ static void __init export_htab_values(void)
331 329
332 htab_base = __pa(htab_address); 330 htab_base = __pa(htab_address);
333 prom_add_property(node, &htab_base_prop); 331 prom_add_property(node, &htab_base_prop);
334
335 htab_size = 1UL << ppc64_pft_size;
336 prom_add_property(node, &htab_size_prop); 332 prom_add_property(node, &htab_size_prop);
337 333
338 out: 334 out:
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index b212d3e64b8d..af32922db65b 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -78,15 +78,8 @@ EXPORT_SYMBOL(sys_sigreturn);
78EXPORT_SYMBOL(strcpy); 78EXPORT_SYMBOL(strcpy);
79EXPORT_SYMBOL(strncpy); 79EXPORT_SYMBOL(strncpy);
80EXPORT_SYMBOL(strcat); 80EXPORT_SYMBOL(strcat);
81EXPORT_SYMBOL(strncat);
82EXPORT_SYMBOL(strchr);
83EXPORT_SYMBOL(strrchr);
84EXPORT_SYMBOL(strpbrk);
85EXPORT_SYMBOL(strstr);
86EXPORT_SYMBOL(strlen); 81EXPORT_SYMBOL(strlen);
87EXPORT_SYMBOL(strnlen);
88EXPORT_SYMBOL(strcmp); 82EXPORT_SYMBOL(strcmp);
89EXPORT_SYMBOL(strncmp);
90EXPORT_SYMBOL(strcasecmp); 83EXPORT_SYMBOL(strcasecmp);
91 84
92EXPORT_SYMBOL(csum_partial); 85EXPORT_SYMBOL(csum_partial);
@@ -184,9 +177,6 @@ EXPORT_SYMBOL(adb_try_handler_change);
184EXPORT_SYMBOL(cuda_request); 177EXPORT_SYMBOL(cuda_request);
185EXPORT_SYMBOL(cuda_poll); 178EXPORT_SYMBOL(cuda_poll);
186#endif /* CONFIG_ADB_CUDA */ 179#endif /* CONFIG_ADB_CUDA */
187#ifdef CONFIG_PPC_PMAC
188EXPORT_SYMBOL(sys_ctrler);
189#endif
190#ifdef CONFIG_VT 180#ifdef CONFIG_VT
191EXPORT_SYMBOL(kd_mksound); 181EXPORT_SYMBOL(kd_mksound);
192#endif 182#endif
@@ -204,7 +194,6 @@ EXPORT_SYMBOL(__lshrdi3);
204EXPORT_SYMBOL(memcpy); 194EXPORT_SYMBOL(memcpy);
205EXPORT_SYMBOL(memset); 195EXPORT_SYMBOL(memset);
206EXPORT_SYMBOL(memmove); 196EXPORT_SYMBOL(memmove);
207EXPORT_SYMBOL(memscan);
208EXPORT_SYMBOL(memcmp); 197EXPORT_SYMBOL(memcmp);
209EXPORT_SYMBOL(memchr); 198EXPORT_SYMBOL(memchr);
210 199
@@ -213,7 +202,6 @@ EXPORT_SYMBOL(screen_info);
213#endif 202#endif
214 203
215#ifdef CONFIG_PPC32 204#ifdef CONFIG_PPC32
216EXPORT_SYMBOL(__delay);
217EXPORT_SYMBOL(timer_interrupt); 205EXPORT_SYMBOL(timer_interrupt);
218EXPORT_SYMBOL(irq_desc); 206EXPORT_SYMBOL(irq_desc);
219EXPORT_SYMBOL(tb_ticks_per_jiffy); 207EXPORT_SYMBOL(tb_ticks_per_jiffy);
@@ -221,10 +209,6 @@ EXPORT_SYMBOL(console_drivers);
221EXPORT_SYMBOL(cacheable_memcpy); 209EXPORT_SYMBOL(cacheable_memcpy);
222#endif 210#endif
223 211
224EXPORT_SYMBOL(__up);
225EXPORT_SYMBOL(__down);
226EXPORT_SYMBOL(__down_interruptible);
227
228#ifdef CONFIG_8xx 212#ifdef CONFIG_8xx
229EXPORT_SYMBOL(cpm_install_handler); 213EXPORT_SYMBOL(cpm_install_handler);
230EXPORT_SYMBOL(cpm_free_handler); 214EXPORT_SYMBOL(cpm_free_handler);
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 1201880cab40..dd774c3c9302 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -886,3 +886,35 @@ void dump_stack(void)
886 show_stack(current, NULL); 886 show_stack(current, NULL);
887} 887}
888EXPORT_SYMBOL(dump_stack); 888EXPORT_SYMBOL(dump_stack);
889
890#ifdef CONFIG_PPC64
891void ppc64_runlatch_on(void)
892{
893 unsigned long ctrl;
894
895 if (cpu_has_feature(CPU_FTR_CTRL) && !test_thread_flag(TIF_RUNLATCH)) {
896 HMT_medium();
897
898 ctrl = mfspr(SPRN_CTRLF);
899 ctrl |= CTRL_RUNLATCH;
900 mtspr(SPRN_CTRLT, ctrl);
901
902 set_thread_flag(TIF_RUNLATCH);
903 }
904}
905
906void ppc64_runlatch_off(void)
907{
908 unsigned long ctrl;
909
910 if (cpu_has_feature(CPU_FTR_CTRL) && test_thread_flag(TIF_RUNLATCH)) {
911 HMT_medium();
912
913 clear_thread_flag(TIF_RUNLATCH);
914
915 ctrl = mfspr(SPRN_CTRLF);
916 ctrl &= ~CTRL_RUNLATCH;
917 mtspr(SPRN_CTRLT, ctrl);
918 }
919}
920#endif
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index ec7153f4d47c..d34fe537400e 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -205,14 +205,6 @@ static cell_t __initdata regbuf[1024];
205 205
206#define MAX_CPU_THREADS 2 206#define MAX_CPU_THREADS 2
207 207
208/* TO GO */
209#ifdef CONFIG_HMT
210struct {
211 unsigned int pir;
212 unsigned int threadid;
213} hmt_thread_data[NR_CPUS];
214#endif /* CONFIG_HMT */
215
216/* 208/*
217 * Error results ... some OF calls will return "-1" on error, some 209 * Error results ... some OF calls will return "-1" on error, some
218 * will return 0, some will return either. To simplify, here are 210 * will return 0, some will return either. To simplify, here are
@@ -1319,10 +1311,6 @@ static void __init prom_hold_cpus(void)
1319 */ 1311 */
1320 *spinloop = 0; 1312 *spinloop = 0;
1321 1313
1322#ifdef CONFIG_HMT
1323 for (i = 0; i < NR_CPUS; i++)
1324 RELOC(hmt_thread_data)[i].pir = 0xdeadbeef;
1325#endif
1326 /* look for cpus */ 1314 /* look for cpus */
1327 for (node = 0; prom_next_node(&node); ) { 1315 for (node = 0; prom_next_node(&node); ) {
1328 type[0] = 0; 1316 type[0] = 0;
@@ -1389,32 +1377,6 @@ static void __init prom_hold_cpus(void)
1389 /* Reserve cpu #s for secondary threads. They start later. */ 1377 /* Reserve cpu #s for secondary threads. They start later. */
1390 cpuid += cpu_threads; 1378 cpuid += cpu_threads;
1391 } 1379 }
1392#ifdef CONFIG_HMT
1393 /* Only enable HMT on processors that provide support. */
1394 if (__is_processor(PV_PULSAR) ||
1395 __is_processor(PV_ICESTAR) ||
1396 __is_processor(PV_SSTAR)) {
1397 prom_printf(" starting secondary threads\n");
1398
1399 for (i = 0; i < NR_CPUS; i += 2) {
1400 if (!cpu_online(i))
1401 continue;
1402
1403 if (i == 0) {
1404 unsigned long pir = mfspr(SPRN_PIR);
1405 if (__is_processor(PV_PULSAR)) {
1406 RELOC(hmt_thread_data)[i].pir =
1407 pir & 0x1f;
1408 } else {
1409 RELOC(hmt_thread_data)[i].pir =
1410 pir & 0x3ff;
1411 }
1412 }
1413 }
1414 } else {
1415 prom_printf("Processor is not HMT capable\n");
1416 }
1417#endif
1418 1380
1419 if (cpuid > NR_CPUS) 1381 if (cpuid > NR_CPUS)
1420 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS) 1382 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index a717dff695ef..f96c49b03ba0 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -311,8 +311,6 @@ void smp_release_cpus(void)
311 311
312 DBG(" <- smp_release_cpus()\n"); 312 DBG(" <- smp_release_cpus()\n");
313} 313}
314#else
315#define smp_release_cpus()
316#endif /* CONFIG_SMP || CONFIG_KEXEC */ 314#endif /* CONFIG_SMP || CONFIG_KEXEC */
317 315
318/* 316/*
@@ -473,10 +471,12 @@ void __init setup_system(void)
473 check_smt_enabled(); 471 check_smt_enabled();
474 smp_setup_cpu_maps(); 472 smp_setup_cpu_maps();
475 473
474#ifdef CONFIG_SMP
476 /* Release secondary cpus out of their spinloops at 0x60 now that 475 /* Release secondary cpus out of their spinloops at 0x60 now that
477 * we can map physical -> logical CPU ids 476 * we can map physical -> logical CPU ids
478 */ 477 */
479 smp_release_cpus(); 478 smp_release_cpus();
479#endif
480 480
481 printk("Starting Linux PPC64 %s\n", system_utsname.version); 481 printk("Starting Linux PPC64 %s\n", system_utsname.version);
482 482
diff --git a/arch/powerpc/kernel/sys_ppc32.c b/arch/powerpc/kernel/sys_ppc32.c
index 475249dc2350..cd75ab2908fa 100644
--- a/arch/powerpc/kernel/sys_ppc32.c
+++ b/arch/powerpc/kernel/sys_ppc32.c
@@ -176,7 +176,6 @@ struct timex32 {
176}; 176};
177 177
178extern int do_adjtimex(struct timex *); 178extern int do_adjtimex(struct timex *);
179extern void ppc_adjtimex(void);
180 179
181asmlinkage long compat_sys_adjtimex(struct timex32 __user *utp) 180asmlinkage long compat_sys_adjtimex(struct timex32 __user *utp)
182{ 181{
@@ -209,9 +208,6 @@ asmlinkage long compat_sys_adjtimex(struct timex32 __user *utp)
209 208
210 ret = do_adjtimex(&txc); 209 ret = do_adjtimex(&txc);
211 210
212 /* adjust the conversion of TB to time of day to track adjtimex */
213 ppc_adjtimex();
214
215 if(put_user(txc.modes, &utp->modes) || 211 if(put_user(txc.modes, &utp->modes) ||
216 __put_user(txc.offset, &utp->offset) || 212 __put_user(txc.offset, &utp->offset) ||
217 __put_user(txc.freq, &utp->freq) || 213 __put_user(txc.freq, &utp->freq) ||
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 1886045a2fd8..2a7ddc579379 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -50,6 +50,7 @@
50#include <linux/security.h> 50#include <linux/security.h>
51#include <linux/percpu.h> 51#include <linux/percpu.h>
52#include <linux/rtc.h> 52#include <linux/rtc.h>
53#include <linux/jiffies.h>
53 54
54#include <asm/io.h> 55#include <asm/io.h>
55#include <asm/processor.h> 56#include <asm/processor.h>
@@ -99,7 +100,15 @@ EXPORT_SYMBOL(tb_ticks_per_usec);
99unsigned long tb_ticks_per_sec; 100unsigned long tb_ticks_per_sec;
100u64 tb_to_xs; 101u64 tb_to_xs;
101unsigned tb_to_us; 102unsigned tb_to_us;
102unsigned long processor_freq; 103
104#define TICKLEN_SCALE (SHIFT_SCALE - 10)
105u64 last_tick_len; /* units are ns / 2^TICKLEN_SCALE */
106u64 ticklen_to_xs; /* 0.64 fraction */
107
108/* If last_tick_len corresponds to about 1/HZ seconds, then
109 last_tick_len << TICKLEN_SHIFT will be about 2^63. */
110#define TICKLEN_SHIFT (63 - 30 - TICKLEN_SCALE + SHIFT_HZ)
111
103DEFINE_SPINLOCK(rtc_lock); 112DEFINE_SPINLOCK(rtc_lock);
104EXPORT_SYMBOL_GPL(rtc_lock); 113EXPORT_SYMBOL_GPL(rtc_lock);
105 114
@@ -113,10 +122,6 @@ extern unsigned long wall_jiffies;
113extern struct timezone sys_tz; 122extern struct timezone sys_tz;
114static long timezone_offset; 123static long timezone_offset;
115 124
116void ppc_adjtimex(void);
117
118static unsigned adjusting_time = 0;
119
120unsigned long ppc_proc_freq; 125unsigned long ppc_proc_freq;
121unsigned long ppc_tb_freq; 126unsigned long ppc_tb_freq;
122 127
@@ -178,8 +183,7 @@ static __inline__ void timer_check_rtc(void)
178 */ 183 */
179 if (ppc_md.set_rtc_time && ntp_synced() && 184 if (ppc_md.set_rtc_time && ntp_synced() &&
180 xtime.tv_sec - last_rtc_update >= 659 && 185 xtime.tv_sec - last_rtc_update >= 659 &&
181 abs((xtime.tv_nsec/1000) - (1000000-1000000/HZ)) < 500000/HZ && 186 abs((xtime.tv_nsec/1000) - (1000000-1000000/HZ)) < 500000/HZ) {
182 jiffies - wall_jiffies == 1) {
183 struct rtc_time tm; 187 struct rtc_time tm;
184 to_tm(xtime.tv_sec + 1 + timezone_offset, &tm); 188 to_tm(xtime.tv_sec + 1 + timezone_offset, &tm);
185 tm.tm_year -= 1900; 189 tm.tm_year -= 1900;
@@ -226,15 +230,14 @@ void do_gettimeofday(struct timeval *tv)
226 if (__USE_RTC()) { 230 if (__USE_RTC()) {
227 /* do this the old way */ 231 /* do this the old way */
228 unsigned long flags, seq; 232 unsigned long flags, seq;
229 unsigned int sec, nsec, usec, lost; 233 unsigned int sec, nsec, usec;
230 234
231 do { 235 do {
232 seq = read_seqbegin_irqsave(&xtime_lock, flags); 236 seq = read_seqbegin_irqsave(&xtime_lock, flags);
233 sec = xtime.tv_sec; 237 sec = xtime.tv_sec;
234 nsec = xtime.tv_nsec + tb_ticks_since(tb_last_stamp); 238 nsec = xtime.tv_nsec + tb_ticks_since(tb_last_stamp);
235 lost = jiffies - wall_jiffies;
236 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); 239 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
237 usec = nsec / 1000 + lost * (1000000 / HZ); 240 usec = nsec / 1000;
238 while (usec >= 1000000) { 241 while (usec >= 1000000) {
239 usec -= 1000000; 242 usec -= 1000000;
240 ++sec; 243 ++sec;
@@ -248,23 +251,6 @@ void do_gettimeofday(struct timeval *tv)
248 251
249EXPORT_SYMBOL(do_gettimeofday); 252EXPORT_SYMBOL(do_gettimeofday);
250 253
251/* Synchronize xtime with do_gettimeofday */
252
253static inline void timer_sync_xtime(unsigned long cur_tb)
254{
255#ifdef CONFIG_PPC64
256 /* why do we do this? */
257 struct timeval my_tv;
258
259 __do_gettimeofday(&my_tv, cur_tb);
260
261 if (xtime.tv_sec <= my_tv.tv_sec) {
262 xtime.tv_sec = my_tv.tv_sec;
263 xtime.tv_nsec = my_tv.tv_usec * 1000;
264 }
265#endif
266}
267
268/* 254/*
269 * There are two copies of tb_to_xs and stamp_xsec so that no 255 * There are two copies of tb_to_xs and stamp_xsec so that no
270 * lock is needed to access and use these values in 256 * lock is needed to access and use these values in
@@ -323,15 +309,30 @@ static __inline__ void timer_recalc_offset(u64 cur_tb)
323{ 309{
324 unsigned long offset; 310 unsigned long offset;
325 u64 new_stamp_xsec; 311 u64 new_stamp_xsec;
312 u64 tlen, t2x;
326 313
327 if (__USE_RTC()) 314 if (__USE_RTC())
328 return; 315 return;
316 tlen = current_tick_length();
329 offset = cur_tb - do_gtod.varp->tb_orig_stamp; 317 offset = cur_tb - do_gtod.varp->tb_orig_stamp;
330 if ((offset & 0x80000000u) == 0) 318 if (tlen == last_tick_len && offset < 0x80000000u) {
331 return; 319 /* check that we're still in sync; if not, resync */
332 new_stamp_xsec = do_gtod.varp->stamp_xsec 320 struct timeval tv;
333 + mulhdu(offset, do_gtod.varp->tb_to_xs); 321 __do_gettimeofday(&tv, cur_tb);
334 update_gtod(cur_tb, new_stamp_xsec, do_gtod.varp->tb_to_xs); 322 if (tv.tv_sec <= xtime.tv_sec &&
323 (tv.tv_sec < xtime.tv_sec ||
324 tv.tv_usec * 1000 <= xtime.tv_nsec))
325 return;
326 }
327 if (tlen != last_tick_len) {
328 t2x = mulhdu(tlen << TICKLEN_SHIFT, ticklen_to_xs);
329 last_tick_len = tlen;
330 } else
331 t2x = do_gtod.varp->tb_to_xs;
332 new_stamp_xsec = (u64) xtime.tv_nsec * XSEC_PER_SEC;
333 do_div(new_stamp_xsec, 1000000000);
334 new_stamp_xsec += (u64) xtime.tv_sec * XSEC_PER_SEC;
335 update_gtod(cur_tb, new_stamp_xsec, t2x);
335} 336}
336 337
337#ifdef CONFIG_SMP 338#ifdef CONFIG_SMP
@@ -462,13 +463,10 @@ void timer_interrupt(struct pt_regs * regs)
462 write_seqlock(&xtime_lock); 463 write_seqlock(&xtime_lock);
463 tb_last_jiffy += tb_ticks_per_jiffy; 464 tb_last_jiffy += tb_ticks_per_jiffy;
464 tb_last_stamp = per_cpu(last_jiffy, cpu); 465 tb_last_stamp = per_cpu(last_jiffy, cpu);
465 timer_recalc_offset(tb_last_jiffy);
466 do_timer(regs); 466 do_timer(regs);
467 timer_sync_xtime(tb_last_jiffy); 467 timer_recalc_offset(tb_last_jiffy);
468 timer_check_rtc(); 468 timer_check_rtc();
469 write_sequnlock(&xtime_lock); 469 write_sequnlock(&xtime_lock);
470 if (adjusting_time && (time_adjust == 0))
471 ppc_adjtimex();
472 } 470 }
473 471
474 next_dec = tb_ticks_per_jiffy - ticks; 472 next_dec = tb_ticks_per_jiffy - ticks;
@@ -492,16 +490,18 @@ void timer_interrupt(struct pt_regs * regs)
492 490
493void wakeup_decrementer(void) 491void wakeup_decrementer(void)
494{ 492{
495 int i; 493 unsigned long ticks;
496 494
497 set_dec(tb_ticks_per_jiffy);
498 /* 495 /*
499 * We don't expect this to be called on a machine with a 601, 496 * The timebase gets saved on sleep and restored on wakeup,
500 * so using get_tbl is fine. 497 * so all we need to do is to reset the decrementer.
501 */ 498 */
502 tb_last_stamp = tb_last_jiffy = get_tb(); 499 ticks = tb_ticks_since(__get_cpu_var(last_jiffy));
503 for_each_cpu(i) 500 if (ticks < tb_ticks_per_jiffy)
504 per_cpu(last_jiffy, i) = tb_last_stamp; 501 ticks = tb_ticks_per_jiffy - ticks;
502 else
503 ticks = 1;
504 set_dec(ticks);
505} 505}
506 506
507#ifdef CONFIG_SMP 507#ifdef CONFIG_SMP
@@ -541,8 +541,8 @@ int do_settimeofday(struct timespec *tv)
541 time_t wtm_sec, new_sec = tv->tv_sec; 541 time_t wtm_sec, new_sec = tv->tv_sec;
542 long wtm_nsec, new_nsec = tv->tv_nsec; 542 long wtm_nsec, new_nsec = tv->tv_nsec;
543 unsigned long flags; 543 unsigned long flags;
544 long int tb_delta; 544 u64 new_xsec;
545 u64 new_xsec, tb_delta_xs; 545 unsigned long tb_delta;
546 546
547 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) 547 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
548 return -EINVAL; 548 return -EINVAL;
@@ -563,9 +563,19 @@ int do_settimeofday(struct timespec *tv)
563 first_settimeofday = 0; 563 first_settimeofday = 0;
564 } 564 }
565#endif 565#endif
566
567 /*
568 * Subtract off the number of nanoseconds since the
569 * beginning of the last tick.
570 * Note that since we don't increment jiffies_64 anywhere other
571 * than in do_timer (since we don't have a lost tick problem),
572 * wall_jiffies will always be the same as jiffies,
573 * and therefore the (jiffies - wall_jiffies) computation
574 * has been removed.
575 */
566 tb_delta = tb_ticks_since(tb_last_stamp); 576 tb_delta = tb_ticks_since(tb_last_stamp);
567 tb_delta += (jiffies - wall_jiffies) * tb_ticks_per_jiffy; 577 tb_delta = mulhdu(tb_delta, do_gtod.varp->tb_to_xs); /* in xsec */
568 tb_delta_xs = mulhdu(tb_delta, do_gtod.varp->tb_to_xs); 578 new_nsec -= SCALE_XSEC(tb_delta, 1000000000);
569 579
570 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - new_sec); 580 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - new_sec);
571 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - new_nsec); 581 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - new_nsec);
@@ -580,12 +590,12 @@ int do_settimeofday(struct timespec *tv)
580 590
581 ntp_clear(); 591 ntp_clear();
582 592
583 new_xsec = 0; 593 new_xsec = xtime.tv_nsec;
584 if (new_nsec != 0) { 594 if (new_xsec != 0) {
585 new_xsec = (u64)new_nsec * XSEC_PER_SEC; 595 new_xsec *= XSEC_PER_SEC;
586 do_div(new_xsec, NSEC_PER_SEC); 596 do_div(new_xsec, NSEC_PER_SEC);
587 } 597 }
588 new_xsec += (u64)new_sec * XSEC_PER_SEC - tb_delta_xs; 598 new_xsec += (u64)xtime.tv_sec * XSEC_PER_SEC;
589 update_gtod(tb_last_jiffy, new_xsec, do_gtod.varp->tb_to_xs); 599 update_gtod(tb_last_jiffy, new_xsec, do_gtod.varp->tb_to_xs);
590 600
591 vdso_data->tz_minuteswest = sys_tz.tz_minuteswest; 601 vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
@@ -671,7 +681,7 @@ void __init time_init(void)
671 unsigned long flags; 681 unsigned long flags;
672 unsigned long tm = 0; 682 unsigned long tm = 0;
673 struct div_result res; 683 struct div_result res;
674 u64 scale; 684 u64 scale, x;
675 unsigned shift; 685 unsigned shift;
676 686
677 if (ppc_md.time_init != NULL) 687 if (ppc_md.time_init != NULL)
@@ -693,11 +703,36 @@ void __init time_init(void)
693 } 703 }
694 704
695 tb_ticks_per_jiffy = ppc_tb_freq / HZ; 705 tb_ticks_per_jiffy = ppc_tb_freq / HZ;
696 tb_ticks_per_sec = tb_ticks_per_jiffy * HZ; 706 tb_ticks_per_sec = ppc_tb_freq;
697 tb_ticks_per_usec = ppc_tb_freq / 1000000; 707 tb_ticks_per_usec = ppc_tb_freq / 1000000;
698 tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000); 708 tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
699 div128_by_32(1024*1024, 0, tb_ticks_per_sec, &res); 709
700 tb_to_xs = res.result_low; 710 /*
711 * Calculate the length of each tick in ns. It will not be
712 * exactly 1e9/HZ unless ppc_tb_freq is divisible by HZ.
713 * We compute 1e9 * tb_ticks_per_jiffy / ppc_tb_freq,
714 * rounded up.
715 */
716 x = (u64) NSEC_PER_SEC * tb_ticks_per_jiffy + ppc_tb_freq - 1;
717 do_div(x, ppc_tb_freq);
718 tick_nsec = x;
719 last_tick_len = x << TICKLEN_SCALE;
720
721 /*
722 * Compute ticklen_to_xs, which is a factor which gets multiplied
723 * by (last_tick_len << TICKLEN_SHIFT) to get a tb_to_xs value.
724 * It is computed as:
725 * ticklen_to_xs = 2^N / (tb_ticks_per_jiffy * 1e9)
726 * where N = 64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT
727 * so as to give the result as a 0.64 fixed-point fraction.
728 */
729 div128_by_32(1ULL << (64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT), 0,
730 tb_ticks_per_jiffy, &res);
731 div128_by_32(res.result_high, res.result_low, NSEC_PER_SEC, &res);
732 ticklen_to_xs = res.result_low;
733
734 /* Compute tb_to_xs from tick_nsec */
735 tb_to_xs = mulhdu(last_tick_len << TICKLEN_SHIFT, ticklen_to_xs);
701 736
702 /* 737 /*
703 * Compute scale factor for sched_clock. 738 * Compute scale factor for sched_clock.
@@ -724,6 +759,14 @@ void __init time_init(void)
724 tm = get_boot_time(); 759 tm = get_boot_time();
725 760
726 write_seqlock_irqsave(&xtime_lock, flags); 761 write_seqlock_irqsave(&xtime_lock, flags);
762
763 /* If platform provided a timezone (pmac), we correct the time */
764 if (timezone_offset) {
765 sys_tz.tz_minuteswest = -timezone_offset / 60;
766 sys_tz.tz_dsttime = 0;
767 tm -= timezone_offset;
768 }
769
727 xtime.tv_sec = tm; 770 xtime.tv_sec = tm;
728 xtime.tv_nsec = 0; 771 xtime.tv_nsec = 0;
729 do_gtod.varp = &do_gtod.vars[0]; 772 do_gtod.varp = &do_gtod.vars[0];
@@ -738,18 +781,11 @@ void __init time_init(void)
738 vdso_data->tb_orig_stamp = tb_last_jiffy; 781 vdso_data->tb_orig_stamp = tb_last_jiffy;
739 vdso_data->tb_update_count = 0; 782 vdso_data->tb_update_count = 0;
740 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec; 783 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
741 vdso_data->stamp_xsec = xtime.tv_sec * XSEC_PER_SEC; 784 vdso_data->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC;
742 vdso_data->tb_to_xs = tb_to_xs; 785 vdso_data->tb_to_xs = tb_to_xs;
743 786
744 time_freq = 0; 787 time_freq = 0;
745 788
746 /* If platform provided a timezone (pmac), we correct the time */
747 if (timezone_offset) {
748 sys_tz.tz_minuteswest = -timezone_offset / 60;
749 sys_tz.tz_dsttime = 0;
750 xtime.tv_sec -= timezone_offset;
751 }
752
753 last_rtc_update = xtime.tv_sec; 789 last_rtc_update = xtime.tv_sec;
754 set_normalized_timespec(&wall_to_monotonic, 790 set_normalized_timespec(&wall_to_monotonic,
755 -xtime.tv_sec, -xtime.tv_nsec); 791 -xtime.tv_sec, -xtime.tv_nsec);
@@ -759,126 +795,6 @@ void __init time_init(void)
759 set_dec(tb_ticks_per_jiffy); 795 set_dec(tb_ticks_per_jiffy);
760} 796}
761 797
762/*
763 * After adjtimex is called, adjust the conversion of tb ticks
764 * to microseconds to keep do_gettimeofday synchronized
765 * with ntpd.
766 *
767 * Use the time_adjust, time_freq and time_offset computed by adjtimex to
768 * adjust the frequency.
769 */
770
771/* #define DEBUG_PPC_ADJTIMEX 1 */
772
773void ppc_adjtimex(void)
774{
775#ifdef CONFIG_PPC64
776 unsigned long den, new_tb_ticks_per_sec, tb_ticks, old_xsec,
777 new_tb_to_xs, new_xsec, new_stamp_xsec;
778 unsigned long tb_ticks_per_sec_delta;
779 long delta_freq, ltemp;
780 struct div_result divres;
781 unsigned long flags;
782 long singleshot_ppm = 0;
783
784 /*
785 * Compute parts per million frequency adjustment to
786 * accomplish the time adjustment implied by time_offset to be
787 * applied over the elapsed time indicated by time_constant.
788 * Use SHIFT_USEC to get it into the same units as
789 * time_freq.
790 */
791 if ( time_offset < 0 ) {
792 ltemp = -time_offset;
793 ltemp <<= SHIFT_USEC - SHIFT_UPDATE;
794 ltemp >>= SHIFT_KG + time_constant;
795 ltemp = -ltemp;
796 } else {
797 ltemp = time_offset;
798 ltemp <<= SHIFT_USEC - SHIFT_UPDATE;
799 ltemp >>= SHIFT_KG + time_constant;
800 }
801
802 /* If there is a single shot time adjustment in progress */
803 if ( time_adjust ) {
804#ifdef DEBUG_PPC_ADJTIMEX
805 printk("ppc_adjtimex: ");
806 if ( adjusting_time == 0 )
807 printk("starting ");
808 printk("single shot time_adjust = %ld\n", time_adjust);
809#endif
810
811 adjusting_time = 1;
812
813 /*
814 * Compute parts per million frequency adjustment
815 * to match time_adjust
816 */
817 singleshot_ppm = tickadj * HZ;
818 /*
819 * The adjustment should be tickadj*HZ to match the code in
820 * linux/kernel/timer.c, but experiments show that this is too
821 * large. 3/4 of tickadj*HZ seems about right
822 */
823 singleshot_ppm -= singleshot_ppm / 4;
824 /* Use SHIFT_USEC to get it into the same units as time_freq */
825 singleshot_ppm <<= SHIFT_USEC;
826 if ( time_adjust < 0 )
827 singleshot_ppm = -singleshot_ppm;
828 }
829 else {
830#ifdef DEBUG_PPC_ADJTIMEX
831 if ( adjusting_time )
832 printk("ppc_adjtimex: ending single shot time_adjust\n");
833#endif
834 adjusting_time = 0;
835 }
836
837 /* Add up all of the frequency adjustments */
838 delta_freq = time_freq + ltemp + singleshot_ppm;
839
840 /*
841 * Compute a new value for tb_ticks_per_sec based on
842 * the frequency adjustment
843 */
844 den = 1000000 * (1 << (SHIFT_USEC - 8));
845 if ( delta_freq < 0 ) {
846 tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( (-delta_freq) >> (SHIFT_USEC - 8))) / den;
847 new_tb_ticks_per_sec = tb_ticks_per_sec + tb_ticks_per_sec_delta;
848 }
849 else {
850 tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( delta_freq >> (SHIFT_USEC - 8))) / den;
851 new_tb_ticks_per_sec = tb_ticks_per_sec - tb_ticks_per_sec_delta;
852 }
853
854#ifdef DEBUG_PPC_ADJTIMEX
855 printk("ppc_adjtimex: ltemp = %ld, time_freq = %ld, singleshot_ppm = %ld\n", ltemp, time_freq, singleshot_ppm);
856 printk("ppc_adjtimex: tb_ticks_per_sec - base = %ld new = %ld\n", tb_ticks_per_sec, new_tb_ticks_per_sec);
857#endif
858
859 /*
860 * Compute a new value of tb_to_xs (used to convert tb to
861 * microseconds) and a new value of stamp_xsec which is the
862 * time (in 1/2^20 second units) corresponding to
863 * tb_orig_stamp. This new value of stamp_xsec compensates
864 * for the change in frequency (implied by the new tb_to_xs)
865 * which guarantees that the current time remains the same.
866 */
867 write_seqlock_irqsave( &xtime_lock, flags );
868 tb_ticks = get_tb() - do_gtod.varp->tb_orig_stamp;
869 div128_by_32(1024*1024, 0, new_tb_ticks_per_sec, &divres);
870 new_tb_to_xs = divres.result_low;
871 new_xsec = mulhdu(tb_ticks, new_tb_to_xs);
872
873 old_xsec = mulhdu(tb_ticks, do_gtod.varp->tb_to_xs);
874 new_stamp_xsec = do_gtod.varp->stamp_xsec + old_xsec - new_xsec;
875
876 update_gtod(do_gtod.varp->tb_orig_stamp, new_stamp_xsec, new_tb_to_xs);
877
878 write_sequnlock_irqrestore( &xtime_lock, flags );
879#endif /* CONFIG_PPC64 */
880}
881
882 798
883#define FEBRUARY 2 799#define FEBRUARY 2
884#define STARTOFTIME 1970 800#define STARTOFTIME 1970
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-26 16:17:42 -0500